Tool House Page

The Tool House is a page of its own at /tool-house/:toolId?/:node*, reached from the menu bar's first page switch, Tool House.

The key model is MachiningToolHouse. The model UserService is the server-side Environments/UserService.cs, which Mech/ToolHouseDisplayController.cs reads EnablePhysics from.

Layout

Four columns, left to right, in three nested pixel-width splitters — the tool house and its tool list, the Control Tree of the tool picked in that list, the editor of the node picked in that tree, and the tool canvas. The list picks the tool the tree shows; the tree picks the node the editor shows. Creating a tool opens no window of its own: New Tool adds a default tool, the tree re-roots at it, and the user sets it up node by node.

That is the page's List view. Its Gallery view keeps the tool list and draws every tool of the house to scale in place of the other three columns, which stay mounted behind it; the switch between the two sits in the tool list's header.

Tool House Page
- Tool List Column (header: Tool House, with the List / Gallery switch — a tooltip on each)
  - 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 while no project is open; an open project always has a tool house, a blank one when its file carries none)
    - Ready / No-Project Badge
    - Tool-count caption with the pick hint — replaced, while no project is open, by an empty-state block (No tool house available.) whose hint says to open a project and names New Tool and the Object Management button's .MachiningToolHouse extension
  - Tool List (a spinner while the list loads)
    - 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; the row of the tool the tree shows is highlighted
- Control Tree Column (header: Control Tree)
  - Control Tree Panel — the picked tool's parts as the tree's roots; the tool itself has no row (Stick Tool Panel)
    - General — Tool ID, Note, auto Abstract Note, Duplicate and Delete
    - Cutter — the Cutter Branch
    - Holder — the Holder Branch
    - Clamping
    - Int. Holder — only while Show Physics Options is on
  - No-tool block in the tree's place while the house has no tool: No tool selected., with a hint naming New Tool
- Editor Column (header: the selection breadcrumb, led by the tool — Tool #1 / Cutter / Flute Profile)
  - Primary Slave Panel — the selected node's editor panel
- Tool Canvas Column
  - Viewer ToolBar
    - RenderingCanvas Tool Bar
    - Scene ▾ Dropdown (Display Options Menu) — three flat groups, no submenus; its tooltip reads Cutter / holder solids, anchor & mount overlays, holder rendering mode
      - Head Label: Cutter
        
        Show Cutter CheckBox
      - Head Label: Holder
        
        Show Holder CheckBox
        
        Show Geom Anchor CheckBox
        
        Show Spindle Mount CheckBox
        
        Show Cutter Mount CheckBox
      - Head Label: Holder Rendering Mode
        
        Show Solid / Show Edge / Hide Radio Buttons
    - Selected-Tool Badge
    - Rendering-Connection Badge
  - RenderingCanvas
    - The DispEngine.Displayee is MillingToolEditorDisplayee.
- Gallery (in place of the three columns above while the URL carries ?view=gallery)
  - Legend Bar — a List Button first while the tool list column is hidden; swatches for Flute; Neck, taper and shank; Holder — the dashed Holder nose (stick-out) line, the dash-dot Spindle gauge line, Height above the tip (mm), and the Zoom each CheckBox
  - one cell per tool, in tool order — a router link to that tool in the List view
    - the Tool ID badge and the note (or the italic abstract note), cut with an ellipsis; the cell of the tool the List view has open is outlined
    - the drawing: flute, neck / taper / shank and holder as filled half outlines mirrored about the tool axis, ruled every few millimetres up from the tip, with the holder nose and the spindle gauge line across it
    - the labels: diameter and corner radius (Ø, R), flute length, stick-out and tool length

The tree and the editor are the same ControlTreePanel.vue + PrimarySlavePanel.vue pair the Execution and Equipment pages render, driven by a Control-Tree host in its toolhouse scope. The tree holds one tool, never the whole house, and that is a constraint rather than a choice: the holder branches' index keys are per session ({sessionKey}-HolderGeom, {sessionKey}-HolderCylindroid, re-pointed on every read), so two tools' holder branches built at once would both address the tool built last. The tools are therefore rows of the list, not rows of the tree, and the tool's own node is a virtual container: its children (Cutter, Holder, Clamping and, while Show Physics Options is on, Int. Holder) are promoted to the tree's roots, behind a General root the host places first.

Each column has a quick button in the nav bar (Toggle the tool list column, Toggle the Control Tree column, Toggle the editor column, Toggle the tool canvas), whose state is the page's columnVisibility.toolhouse record — the left, tree, primary and main bits — in useViewPrefs.ts. The three left columns hold pixel widths and the canvas absorbs every resize: toolListColPx (300 px by default) belongs to this page alone, while treeColPx (240 px) and editorColPx (420 px) are the same preferences as the Equipment page's tree and editor columns, so the two pages line up; treeColPx is also the Execution page's left-dock width. A hidden column is pinned to 0 px rather than unmounted, so the list keeps its scroll position and the editor stays alive, and hiding the canvas while the editor column is shown hands the canvas's space to the editor. While the Gallery view is shown, the tree, editor and canvas buttons are disabled — their columns are behind the gallery — and keep their state for the List view; the tool list's button stays live.

The gallery's drawings are the server's: GET /api/ToolHouse/silhouettes answers one silhouette per tool, computed by the engine from the geometry the tool canvas meshes and placed by the tool's own assembly, so a drawing cannot disagree with the canvas. Each part is a half outline in the tool-tip frame — Z up the tool axis from the tip, R out from it — that the gallery mirrors about the axis; a part with a Z-R profile (an APT flute, a Cylindroid upper beam or holder, an Extended Cylinder standing on the flute's top section, either one wrapped in moves along the axis or held in a Solid) is that profile, and any other part, or a profile the assembly sets askew or beside the axis, is its mesh's radial envelope: the farthest the mesh reaches from the axis at each height a vertex of it is at — at up to 170 evenly spaced heights when it has more — a step drawn level at its height. The answer also carries the heights of the holder nose and the spindle gauge line and the numbers each cell is labelled with. The gallery draws the whole house at one scale (px per mm) fitted to its tallest and widest tool; Zoom each fits each cell to its own cutter from the tip to a quarter above the holder nose instead, the holder cut off at the cell's edges and no tool drawn smaller than at the shared scale, a device preference (toolGalleryZoomEach). The gallery fetches on opening, on returning to the page, and whenever the tool list is reloaded, which every edit on this page does; a newer request aborts the one before it, and the server stops reading the house for an aborted one.

The left column carries no editing of its own. Tool ID and Note are edited on the selected tool's General node, 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. From then on the canvas follows the tool being edited: every node panel under wwwroot-src/src/components/controlTree/toolhouse/ (all of them except ToolHouseRootPanel, which heads the tool list and has no tool), when it mounts, points it at its tool through select-tool. Only when the displayee shows another tool object does that endpoint re-point its MillingToolGetter, clear its cache and call the renderingCanvas.DispEngine.SetViewToHomeView(); for the tool already shown it answers changed: false and does nothing. Selecting node after node of one tool therefore keeps the camera where the user left it, and switching tools returns it to the home view. The match is by object rather than by number, so a tool house installed by Load, or a project reload, still re-points a tool that keeps its number. A Freeform holder's Geometry, Geom To Spindle and Geom To Cutter nodes, and the nodes below them, are the generic Control-Tree slot panels and send no select-tool at all.

The three anchor-and-mount 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 Scene dropdown offers no switch for it.

Duplication Button

The tool is duplicated with Duplicate(params object[]); the clone joins the house under a fresh ID, and the tree re-roots at it on the same node.

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.

The URL Is the Selection

The route is /tool-house/:toolId?/:node*: the tool number, then the selected node's Control-Tree id with its toolhouse/tool-<n> prefix removed. /tool-house/3/cutter/profile selects tool 3's Flute Profile node, so every node of every tool is a bookmark. The page never reads or writes ?tree=; a ?tree= link naming a Tool House id that reaches the Execution or Equipment page is redirected here with the whole id carried over. Short paths such as /tool-house/3/general and /tool-house/3/cutter are ordinary node paths on this route — general names the General root — so the page has no redirect stub.

Picking another tool in the list rewrites :toolId and keeps the node path, so the editor stays on the same node of the next tool. A node path the tool does not grow — a third flute on a two-flute cutter, Int. Holder while Show Physics Options is off — resolves to its deepest built ancestor, or to General when not even its first segment is a root, and the URL is rewritten to the node actually selected. The path last asked for is remembered, so the deeper node comes back on the next tool that grows it.

The URL is the authority. A bare /tool-house — what the menu bar's page switch links to — names no selection, so it keeps the tool already shown (the house's first tool on a fresh load) and opens the remembered node, seeded from the last selection the browser persisted. Any other URL is taken literally and wins over that memory; a :toolId the house does not hold falls back to the house's first tool. Selecting replaces the URL rather than pushing a history entry, and re-roots run one at a time, so two quick clicks in the list settle on the second tool.

Changes to the house go through the same URL. New Tool, Duplicate and a Tool ID rename name the resulting tool, and the host rewrites :toolId to it, keeping the node path. Delete and an Object-Management install rebuild the tree in place, on the URL's tool when the house still holds it and on the house's first tool otherwise. Show Physics Options is structural here as well: flipping it rebuilds the tree and clips a selection whose node was withdrawn.

The view is in the URL as well: ?view=gallery shows the Gallery, no view the List. The switch replaces the URL with or without it, and the host's own rewrites of the selection keep it, so a re-root while the gallery shows does not drop it. A list row's link and a gallery cell's link carry no view: either opens its tool in the List view, on the remembered node. A bare /tool-house — the menu bar's page switch — opens the view this page last showed in this browser (toolHouseView in the device preferences, following the view on screen however it got there, read by the route's beforeEnter); any URL naming a tool or a view is followed as it is. The page is kept alive, so it reads the view from the URL only while the URL is its own: while another page shows, the gallery stays mounted, and coming back finds it as it was, scrolled where it was. New Tool in the gallery stays in the gallery, the new tool's cell the current one.

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 list on the left feeds a tree of one tool, the selected node's editor sits beside it, and the tool canvas fills the right.

wwwroot-src/src/router/routes.ts — declares the route itself: path tool-house/:toolId(\d+)?/:node(.*)*, name tool-house; its beforeEnter adds ?view=gallery to a bare /tool-house when the Gallery was the view last picked.
wwwroot-src/src/components/AppMenuBar.vue — the page switches; the first, Tool House, targets the tool-house route and is lit on every URL that route answers to. It also renders this page's four column quick buttons, three of them disabled while the Gallery view is shown.
wwwroot-src/src/router/treeRoutes.ts — toolNodePathOf() and toolTreeId(), which split a Tool House tree id into the URL's two halves and join them back, and routeForTreeId, which turns any Tool House id into this route losslessly; migrateLegacyTreeId renames a …/contours/tray segment.
wwwroot-src/src/pages/ToolHousePage.vue — routed page: four columns in three nested pixel <q-splitter> panes — the tool list (ToolHouseRootPanel over one router-link row per tool), ControlTreePanel, PrimarySlavePanel under the selection breadcrumb, and ToolHouseSetupPanel. It creates the page's useControlTreeHost('toolhouse') host and provides it to the two tree panes. While the pace player is locked it shows the read-only banner — the server's own ToolEditRefusedWhileRunning message, with a Stop and a Reset button — and covers the editor column. The List / Gallery switch in the tool list's header reads and writes ?view=gallery; in the Gallery view ToolHouseGallery takes the place of the three columns, which stay mounted (v-show) while the canvas is paused (active).
wwwroot-src/src/components/toolhouse/ToolHouseGallery.vue — the Gallery view: fetches GET /api/ToolHouse/silhouettes (again on returning to the page and on every tool-list reload, a newer request aborting the one before it), draws the legend, the Zoom each box and one cell per tool as an inline SVG, each cell a router link to toolLocation(id); it keeps its grid's scroll offset across a visit to another page, offers List in its bar while the tool list column (which holds the switch) is hidden, and tells a tool with no cutter or holder yet from one that cannot be drawn.
wwwroot-src/src/components/toolhouse/toolSilhouette.ts — the gallery's placement maths: the parts' draw order and hues (hue only, one saturation and lightness for all three), each tool's window in millimetres, the one shared scale or a cell's own (Zoom each), the mirrored polygon of a half outline, the millimetre rules.
wwwroot-src/src/components/controlTree/useControlTreeHost.ts — the shared Control-Tree host in its toolhouse scope: buildToolHouseRoots roots the tree at the one tool the URL names, toolLocation builds a list row's link, adoptToolhouseSelection clamps the node path to the deepest built node and rewrites the URL, desiredNodePath remembers the node across tool switches, and the toolhouse branch of onNodeStructureChanged re-roots through the URL when a create, duplicate or rename names another tool and rebuilds in place otherwise. keepToolHouseView carries ?view= through the host's own rewrites, that re-root included.
wwwroot-src/src/components/controlTree/ControlTreePanel.vue — the tree column.
wwwroot-src/src/components/controlTree/PrimarySlavePanel.vue — the editor column: the selected node's panel from the ItemType registry.
wwwroot-src/src/composables/useViewPrefs.ts — columnVisibility.toolhouse and the three column widths toolListColPx / treeColPx / editorColPx; lastTreeIds seeds the remembered node; toolHouseView is the view a bare /tool-house opens in and toolGalleryZoomEach the Zoom each box.
wwwroot-src/src/composables/useToolHouse.ts — the module-singleton state every tool-house panel and the canvas share: the session key, the tool-house key, the tool list, the active tool and the rendering connection id. ensureToolSelected points the session and the canvas at a tool; editingLocked says the pace player is locked (the shared execution status reads Running or Paused), which disables New Tool and the Object Management menu and drives the page's banner.
wwwroot-src/src/components/toolhouse/ToolHouseSetupPanel.vue — the canvas column: one RenderingCanvas bound server-side to MillingToolEditorDisplayee, following the active tool, with the Scene dropdown (Show Cutter / Show Holder + the 3 anchor-and-mount 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: toolContainerNode(toolId), the virtual tool node the host builds and never draws, whose …/cutter, …/holder, …/clamping and physics-gated …/intelligent children become the tree's roots; toolGeneralNode(toolId), the General root placed first; and everything below them. ToolHouseRoot has no buildChildren, because the tools are list rows.
wwwroot-src/src/components/controlTree/toolhouse/ToolHouseRootPanel.vue — the head of the tool-list column: Object Management over the MachiningToolHouse + New Tool. The button's own entries are Load, Save As, Copy, Paste and XML Mode; 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 — the General root: 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 root: an Object Management menu over the whole cutter (.Cutter, Load opening on Resource/Cutter), the cutter type selector, and the MillingCutter identity fields (Integral Mode while Show Physics Options is on, then Shank Mass / Hone Radius / Relief Angle).
wwwroot-src/src/components/controlTree/toolhouse/CutterSectionPanel.vue — the cutter's section nodes, keyed off the node's role path (insert / material / profile / inner-beam / upper-beam / opt). Insert and Flute Profile are edited inline; the others dispatch to wwwroot-src/src/components/toolhouse/MaterialDiv.vue (which grows CoatingLayersDiv.vue), wwwroot-src/src/components/toolhouse/InnerBeamDiv.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 is its child node.
wwwroot-src/src/components/controlTree/toolhouse/FlutingPanel.vue — the concrete fluting node and its fluting-level fields; uniform fluting grows one Baseline Contour node, free fluting one node per flute.
wwwroot-src/src/components/controlTree/toolhouse/FluteContourPanel.vue — one flute contour node (baseline, or flute-<i> for a free fluting): hosts Flute Offset Angle, with Side Contour and Bottom Contour as child nodes. 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 root: 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 node (the Z-R profile, via wwwroot-src/src/components/geom/CylindroidEditor.vue) and both holders' Resolution nodes; resyncs the Cylindroid holder (UpdateByCylindroid()) after each geometry edit. A Freeform holder's Geometry / Geom To Spindle / Geom To Cutter nodes 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 root: ExposedCutterHeight = PreservedDistance + FluteHeight; changing either field updates the other on the server. Setup Angle (deg) is a third field on the same node, coupled to neither: it is how far the cutter is turned in the holder about the tool axis, committed on its own to PUT /{id}/setup-angle.
wwwroot-src/src/components/controlTree/toolhouse/ToolIntelligentPanel.vue — the Int. Holder root; a thin wrapper over wwwroot-src/src/components/toolhouse/IntelligentHolderDiv.vue (Observation Location: ObservationAnchorReference dropdown + relative Z; Holder Channels check boxes).
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 /silhouettes (the Gallery's drawings: every tool's outlines, nose and gauge-line heights and cell labels, a tool that cannot be read carrying its error), GET /GetHolder, GET/PUT /{id}/observation, PUT /{id}/note | exposed-height | preserved-distance | setup-angle, 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, POST /{id}/install?cutterKey= (puts the cutter a menu Load, Paste or XML apply left under the session's cutter entry on the tool, inline; 409 for anything but a cutter), PUT /{id}/shaper-profile | fluting | general | opt-limit | integral-mode | insert, FreeFluting child CRUD at /{id}/fluting/contours[/{index}], POST/PUT /{id}/inner-beam with POST /{id}/inner-beam/geom/create and POST /{id}/inner-beam/resync, POST /{id}/upper-beam with POST /{id}/upper-beam/create and POST /{id}/upper-beam/resync, and the material endpoints /{id}/flute-material/*, /{id}/shank-material/*, /{id}/coating-layers/*. While the pace player is locked — a run in progress or paused — every non-GET endpoint of this controller, of ToolHouseController and of the two holder controllers answers 409 ToolEditRefusedWhileRunning (Common/RefuseWhilePlayerLockedAttribute.cs, before the action runs, so a refused request changes nothing): the tool house is read-only during a run, because the run mounts its tool by reference and an edit would clear the cache the removal worker is reading. The reads that only index stay available — POST /Initialize and POST /SelectTool, POST /{id}/inner-beam and POST /{id}/upper-beam, the holder controllers' POST Get and FreeformHolder's POST IndexCurrentGeometry — and so do every GET and the whole of ToolHouseDisplayController. The generic object-store routes the editors use (/api/Cylindroid, /api/StlFile, /api/TransformationGeom, /api/GeomCombination, ...) are not gated: the page keeps the keyboard and the pointer off them while the player is locked (the editor column is inert), a script must not send them against a tool during a run.
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-mount / show-cutter-mount, holder-rendering-mode, cutter-shape-mode, clear-cache — with ?home=true also back to the home view, sent when a whole cutter was replaced). initialize attaches the MillingToolEditorDisplayee and snaps to the isometric view; select-tool re-points the MillingToolGetter, clears the displayee's cache 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/*: POST 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/*: POST 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. PUT /{id}/fluting accepts the type name or its short form in any letter case — UniformFluting / uniform and FreeFluting / free — and refuses any other spelling. A Control-Tree id whose cutter branch reads …/contours/tray… resolves to the …/contours/fluting… node.

The physics-only parts of a tool are shown only while the Preference menu's Show Physics Options is on: the Int. Holder root, the Cutter root's Integral Mode selector, and the cutter's Insert (insert-end cutters only), Material, Inner Beam and Optimization sections. Inner Beam sets the equivalent solid core inside the flute — a radius ratio, or a Z-R geometry spun about the tool axis. The Flute Profile section offers the five APT types (General / Ball / Column / Cone / Taper); CustomSpinningProfile is offered as an Inner Beam profile only.

One cutter type has no editor here: the FreeformRemover. A tool that carries one — from a loaded tool house or project — shows it in the Cutter root's type selector with a caption naming HiNcRcl; the option is disabled on every other tool, and moving such a tool to Milling Cutter or None asks first, because the model cannot be rebuilt here. GET /api/ToolHouse/{id} reports the kind as cutterType beside hasCutter, while its cutter DTO describes a MillingCutter only.

HiAPI Engine

HiMech/Milling/MillingTools/MillingToolSilhouette.cs — MillingTool.GetSilhouette()'s result: the flute, shank and holder outlines in the tool-tip frame with the holder nose and spindle gauge-line heights, each read from the shape the part's 3D mesh is built from and placed through the tool's assembly; a mesh, or a profile set askew or beside the axis, becomes its radial envelope (RadialEnvelope: the plane cut at each vertex height, read just below, at and just above it, so a step stays level and a bore inside draws nothing; up to 170 evenly spaced heights).
HiMech/Milling/MillingTools/MillingTool.cs — GetSilhouette(), beside SpindleMountToToolTipLength, the gauge length the silhouette's gauge line stands at.

Table of Contents