ToolpathManager
Jump to navigation
Jump to search
The ToolpathManager object is used to handle all the toolpaths within the program. Like the MaterialBlock object there is one instance within the program which is accessed by any ToolpathManager object. For the initial release, the ToolpathManager is only used to create new toolpaths, load templates and recalculate all toolpaths, for future releases Vectric may offer more access to existing toolpaths depending on demand.
Constructor
ToolpathManager
Returns: a new object which refers to the single toolpath manager within the program.
For Example:
local toolpath_mgr = ToolpathManager()
Properties
.Count
Interaction: Read Only
Returns: (integer) the number of toolpaths
.IsEmpty
Interaction: Read Only
Returns: (bool) true if there are no toolpaths
.NumVisibleToolpaths
Interaction: Read Only
Returns: (integer) the number of visible toolpaths
Methods
:AddExternalToolpath( ExternalToolpath toolpath)
Adds the passed toolpath to the list of toolpaths in the job.
Returns: (bool) true if the toolpath was added OK, else false. See the documentation for ExternalToolpath for information on how to create the actual toolpath itself.
- toolpath (ExternalToolpath) toolpath created in a lua script which is added to job
===:CreateProfilingToolpath(String name,Tool tool,ProfileParameterData profile_data,RampingData ramping_data,LeadInOutData lead_data,ToolpathPosData pos_data,GeometrySelector geometry_selector,bool create_2d_preview,bool interactive)
Creates a profiling toolpath for the currently selected vectors.
Returns: the UUID for the toolpath created.
- name(string) Name for the toolpath to be created
- tool (Tool) Tool to use for the toolpath
- profile_data (ProfileParameterData) Settings for profiling depth, inside or outside etc
- ramping_data (RampingData) Settings for ramping lead_data (LeadInOutData) Settings for lead in or out pos_data (ToolpathPosData) Settings for home position, safe z etc
- geometry_selector (GeometrySelector) Can be used to automatically select vectors on layers etc
- create_2d_preview(bool) If true create preview vectors in 2d view interactive(bool) If true display warnings etc to user
Example Code: CreateLayerProfileToolpath
from Profile_Vectors_On_Layer.lua
--[[ ---------------- CreateLayerProfileToolpath ----------------
|
| Create an outside Profile toolpath within the program for vectors on the passed layer
| Parameters:
| job -- Job we are working with
| layer_name -- Name of layer we will profile vectors for
| name -- Name for toolpath
| start_depth -- Start depth for toolpath below surface of material
| cut_depth -- cut depth for profile toolpath
| tool_dia -- diameter of end mill to use
| tool_stepdown -- stepdown for tool
| tool_in_mm -- true if tool size and stepdown are in mm
|
| Return Values:
| true if toolpath created OK else false
|
]]
function CreateLayerProfileToolpath( job, layer_name, name , start_depth, cut_depth, tool_dia, tool_stepdown, tool_in_mm)
-- clear current selection
local selection = job.Selection
selection:Clear()
-- get layer
local layer = job.LayerManager:FindLayerWithName(layer_name)
if layer == nil then
DisplayMessageBox("No layer found with name = " .. "\"" .. layer_name .. "\"")
return false
end
-- select all closed vectors on the layer
if not SelectVectorsOnLayer(layer, selection, true, false, true) then
DisplayMessageBox("No closed vectors found on layer " .. "\"" .. layer_name .. "\"")
return false
end
-- Create tool we will use to machine vectors
local tool = Tool(
"Lua End Mill",
Tool.END_MILL -- BALL_NOSE, END_MILL, VBIT
)
tool.InMM = tool_in_mm
tool.ToolDia = tool_dia
tool.Stepdown = tool_stepdown
tool.Stepover = tool_dia * 0.25
tool.RateUnits = Tool.MM_SEC -- MM_SEC, MM_MIN, METRES_MIN, INCHES_SEC, INCHES_MIN, FEET_MIN
tool.FeedRate = 30
tool.PlungeRate = 10
tool.SpindleSpeed = 20000
tool.ToolNumber = 1
tool.VBitAngle = 90.0 -- used for vbit only
tool.ClearStepover = tool_dia * 0.5 -- used for vbit only
-- we will set home position and safe z relative to material block size
local mtl_block = MaterialBlock()
local mtl_box = mtl_block.MaterialBox
local mtl_box_blc = mtl_box.BLC
-- Create object used to set home position and safez gap above material surface
local pos_data = ToolpathPosData()
pos_data:SetHomePosition(mtl_box_blc.x, mtl_box_blc.y, mtl_box.TRC.z + (mtl_block.Thickness * 0.2) )
pos_data.SafeZGap = mtl_block.Thickness * 0.1
-- Create object used to pass profile options
local profile_data = ProfileParameterData()
-- start depth for toolpath
profile_data.StartDepth = start_depth
-- cut depth for toolpath this is depth below start depth
profile_data.CutDepth = cut_depth
-- direction of cut - ProfileParameterData.CLIMB_DIRECTION or ProfileParameterData.CONVENTIONAL_DIRECTION
profile_data.CutDirection = ProfileParameterData.CLIMB_DIRECTION
-- side we machine on - ProfileParameterData.PROFILE_OUTSIDE, ProfileParameterData.PROFILE_INSIDE or ProfileParameterData.PROFILE_ON
profile_data.ProfileSide = ProfileParameterData.PROFILE_OUTSIDE
-- Allowance to leave on when machining
profile_data.Allowance = 0.0
-- true to preserve start point positions, false to reorder start points to minimise toolpath length
profile_data.KeepStartPoints = false
-- true if want to create 'square' external corners on toolpath
profile_data.CreateSquareCorners = false
-- true to perform corner sharpening on internal corners (only with v-bits)
profile_data.CornerSharpen = false
-- true to use tabs (position of tabs must already have been defined on vectors)
profile_data.UseTabs = false
-- length for tabs if being used
profile_data.TabLength = 5.0
-- Thickness for tabs if being used
profile_data.TabThickness = 1.0
-- if true then create 3d tabs else 2d tabs
profile_data.Use3dTabs = true
-- if true in Aspire, project toolpath onto composite model
profile_data.ProjectToolpath = false
-- Create object used to control ramping
local ramping_data = RampingData()
-- if true we do ramping into toolpath
ramping_data.DoRamping = false
-- type of ramping to perform RampingData.RAMP_LINEAR , RampingData.RAMP_ZIG_ZAG or RampingData.RAMP_SPIRAL
ramping_data.RampType = RampingData.RAMP_ZIG_ZAG
-- how ramp is contrained - either by angle or distance RampingData.CONSTRAIN_DISTANCE or RampingData.CONSTRAIN_ANGLE
ramping_data.RampConstraint = RampingData.CONSTRAIN_ANGLE
-- if we are constraining ramp by distance, distance to ramp over
ramping_data.RampDistance = 100.0
-- if we are contraining ramp by angle , angle to ramp in at (in degrees)
ramping_data.RampAngle = 25.0
-- if we are contraining ramp by angle, max distance to travel before 'zig zaging' if zig zaging
ramping_data.RampMaxAngleDist = 15
-- if true we restrict our ramping to lead in section of toolpath
ramping_data.RampOnLeadIn = false
-- Create object used to control lead in/out
local lead_in_out_data = LeadInOutData()
-- if true we create lead ins on profiles (not for profile on)
lead_in_out_data.DoLeadIn = false
-- if true we create lead outs on profiles (not for profile on)
lead_in_out_data.DoLeadOut = false
-- type of leads to create LeadInOutData.LINEAR_LEAD or LeadInOutData.CIRCULAR_LEAD
lead_in_out_data.LeadType = LeadInOutData.CIRCULAR_LEAD
-- length of lead to create
lead_in_out_data.LeadLength = 10.0
-- Angle for linear leads
lead_in_out_data.LinearLeadAngle = 45
-- Radius for circular arc leads
lead_in_out_data.CirularLeadRadius = 5.0
-- distance to 'overcut' (travel past start point) when profiling
lead_in_out_data.OvercutDistance = 0.0
-- Create object which can used to automatically select geometry on layers etc
local geometry_selector = GeometrySelector()
-- if this is true we create 2d toolpaths previews in 2d view, if false we dont
local create_2d_previews = true
-- if this is true we will display errors and warning to the user
local display_warnings = true
-- Create our toolpath
local toolpath_manager = ToolpathManager()
local toolpath_id = toolpath_manager:CreateProfilingToolpath(
name,
tool,
profile_data,
ramping_data,
lead_in_out_data,
pos_data,
geometry_selector,
create_2d_previews,
display_warnings
)
if toolpath_id == nil then
DisplayMessageBox("Error creating toolpath")
return false
end
return true
end
CreatePocketingToolpath()
Usage: CreatePocketingToolpath(
- String name,
- Tool tool,
- Tool area_clear_tool,
- PocketParameterData pocket_data,
- ToolpathPosData pos_data,
- GeometrySelector geometry_selector,
- bool create_2d_preview,
- bool interactive
- )
Creates a pocketing toolpath for the currently selected vectors. Return the UUID for the toolpath created.
- name(string) Name for the toolpath to be created
- tool (Tool) Tool to use for the toolpath. Note: must not be nil
- area_clear_tool (Tool) Optional tool for area clearance can be nil
- pocket_data (PocketParameterData) Setting for pocketing depth, style etc
- pos_data(ToolpathPosData) Settings for home position, safe z etc
- geometry_selector (GeometrySelector) Can be used to automatically select vectors on layers etc
- create_2d_preview(bool) If true create preview vectors in 2d view
- interactive(bool) If true display warnings etc to user
Example Code: CreatePocketingToolpath
from Create_Pocketing_Toolpath.lua
-- VECTRIC LUA SCRIPT
require "strict"
--[[ -------------- CreatePocketingToolpath --------------------------------------------------
|
| Create a Pocketing toolpath within the program for the currently selected vectors
| Parameters:
| name, -- Name for toolpath
| start_depth -- Start depth for toolpath below surface of material
| cut_depth -- cut depth for pocket toolpath
| tool_dia -- diameter of end mill to use
| tool_stepdown -- stepdown for tool
| tool_stepover_percent -- percentage stepover for tool
| tool_in_mm -- true if tool size and stepdown are in mm
|
| Return Values:
| true if toolpath created OK else false
|
]]
function CreatePocketingToolpath( name , start_depth, cut_depth, tool_dia, tool_stepdown, tool_stepover_percent, tool_in_mm)
-- Create tool we will use to machine vectors
local tool = Tool(
"Lua End Mill",
Tool.END_MILL -- BALL_NOSE, END_MILL, VBIT
)
tool.InMM = tool_in_mm
tool.ToolDia = tool_dia
tool.Stepdown = tool_stepdown
tool.Stepover = tool_dia * (tool_stepover_percent / 100)
tool.RateUnits = Tool.MM_SEC -- MM_SEC, MM_MIN, METRES_MIN, INCHES_SEC, INCHES_MIN, FEET_MIN
tool.FeedRate = 30
tool.PlungeRate = 10
tool.SpindleSpeed = 20000
tool.ToolNumber = 1
tool.VBitAngle = 90.0 -- used for vbit only
tool.ClearStepover = tool_dia * (tool_stepover_percent / 100) -- used for vbit only
-- we will set home position and safe z relative to material block size
local mtl_block = MaterialBlock()
local mtl_box = mtl_block.MaterialBox
local mtl_box_blc = mtl_box.BLC
-- Create object used to set home position and safez gap above material surface
local pos_data = ToolpathPosData()
pos_data:SetHomePosition(mtl_box_blc.x, mtl_box_blc.y, mtl_box.TRC.z + (mtl_block.Thickness * 0.2) )
pos_data.SafeZGap = mtl_block.Thickness * 0.1
-- Create object used to pass pocketing options
local pocket_data = PocketParameterData()
-- start depth for toolpath
pocket_data.StartDepth = start_depth
-- cut depth for toolpath this is depth below start depth
pocket_data.CutDepth = cut_depth
-- direction of cut for offet clearance - ProfileParameterData.CLIMB_DIRECTION or ProfileParameterData.CONVENTIONAL_DIRECTION - NOTE: enum from ProfileParameterData
pocket_data.CutDirection = ProfileParameterData.CLIMB_DIRECTION
-- Allowance to leave on when machining
pocket_data.Allowance = 0.0
-- if true use raster clearance strategy , else use offset area clearance
pocket_data.DoRasterClearance = true
-- angle for raster if using raster clearance
pocket_data.RasterAngle = 0
-- type of profile pass to perform PocketParameterData.PROFILE_NONE , PocketParameterData.PROFILE_FIRST orPocketParameterData.PROFILE_LAST
pocket_data.ProfilePassType = PocketParameterData.PROFILE_LAST
-- if true we ramp into pockets (always zig-zag)
pocket_data.DoRamping = false
-- if ramping, distance to ramp over
pocket_data.RampDistance = 10.0
-- if true in Aspire, project toolpath onto composite model
pocket_data.ProjectToolpath = false
-- Create object which can used to automatically select geometry on layers etc
local geometry_selector = GeometrySelector()
-- if this is true we create 2d toolpaths previews in 2d view, if false we dont
local create_2d_previews = true
-- if this is true we will display errors and warning to the user
local display_warnings = true
-- if we are doing two tool pocketing define tool to use for area clearance
local area_clear_tool = nil
-- we just create a tool twice as large for testing here
area_clear_tool = Tool(
"Lua Clearance End Mill",
Tool.END_MILL -- BALL_NOSE, END_MILL, VBIT
)
area_clear_tool.InMM = tool_in_mm
area_clear_tool.ToolDia = tool_dia * 2
area_clear_tool.Stepdown = tool_stepdown * 2
area_clear_tool.Stepover = tool_dia * 2 *(tool_stepover_percent / 100)
area_clear_tool.RateUnits = Tool.MM_SEC -- MM_SEC, MM_MIN, METRES_MIN, INCHES_SEC, INCHES_MIN, FEET_MIN
area_clear_tool.FeedRate = 30
area_clear_tool.PlungeRate = 10
area_clear_tool.SpindleSpeed = 20000
area_clear_tool.ToolNumber = 1
area_clear_tool.VBitAngle = 90.0 -- used for vbit only
area_clear_tool.ClearStepover = tool_dia * 2 * (tool_stepover_percent / 100) -- used for vbit only
-- Create our toolpath
local toolpath_manager = ToolpathManager()
local toolpath_id = toolpath_manager:CreatePocketingToolpath(
name,
tool,
area_clear_tool,
pocket_data,
pos_data,
geometry_selector,
create_2d_previews,
display_warnings
)
if toolpath_id == nil then
DisplayMessageBox("Error creating toolpath")
return false
end
return true
end
--[[ ----------- main --------------------------------------------------
|
| Entry point for script
|
]]
function main()
-- Check we have a job loaded
local job = VectricJob()
if not job.Exists then
DisplayMessageBox("No job loaded")
return false;
end
local selection = job.Selection
if selection.IsEmpty then
MessageBox("Please select one or more closed vectors to pocket")
return false
end
local mtl_block = MaterialBlock()
local start_depth = 0.0
local cut_depth = mtl_block.Thickness * 0.25
local tool_dia = 12.0
local tool_stepdown = 2.5
local tool_stepover_percent = 50.0
local tool_in_mm = true
local success = CreatePocketingToolpath(
"Lua Pocketing Toolpath",
start_depth,
cut_depth,
tool_dia,
tool_stepdown,
tool_stepover_percent,
tool_in_mm
)
return success;
end
:CreateDrillingToolpath
Usage: :CreateDrillingToolpath(
- String name,
- Tool tool,
- DrillParameterData drilling_data,
- ToolpathPosData pos_data,
- GeometrySelectorgeometry_selector,
- bool create_2d_preview,
- bool interactive)
Creates a drilling toolpath for the currently selected vectors.
Returns: the UUID for the toolpath created.
- name(string) Name for the toolpath to be created
- tool(Tool) Tool to use for the toolpath
- drill_data DrillParameterData Setting for drilling depth, peck etc
- pos_data(ToolpathPosData) Settings for home position, safe z etc
- geometry_selector(GeometrySelector) Can be used to automatically select vectors on layers etc
- create_2d_preview(bool) If true create preview vectors in 2d view
- interactive(bool) If true display warnings etc to user
Example Code: CreateDrillingToolpath
from Create_Drilling_Toolpath.lua
-- VECTRIC LUA SCRIPT
require "strict"
function CreateDrillingToolpath( name , start_depth, cut_depth, retract_gap, tool_dia, tool_stepdown, tool_in_mm)
-- Create tool we will use to machine vectors
local tool = Tool(
"Lua Drill",
Tool.THROUGH_DRILL -- BALL_NOSE, END_MILL, VBIT, THROUGH_DRILL
)
tool.InMM = tool_in_mm
tool.ToolDia = tool_dia
tool.Stepdown = tool_stepdown
tool.Stepover = tool_dia * 0.25
tool.RateUnits = Tool.MM_SEC -- MM_SEC, MM_MIN, METRES_MIN, INCHES_SEC, INCHES_MIN, FEET_MIN
tool.FeedRate = 30
tool.PlungeRate = 10
tool.SpindleSpeed = 20000
tool.ToolNumber = 1
tool.VBitAngle = 90.0 -- used for vbit only
tool.ClearStepover = tool_dia * 0.5 -- used for vbit only
-- we will set home position and safe z relative to material block size
local mtl_block = MaterialBlock()
local mtl_box = mtl_block.MaterialBox
local mtl_box_blc = mtl_box.BLC
-- Create object used to set home position and safez gap above material surface
local pos_data = ToolpathPosData()
pos_data:SetHomePosition(mtl_box_blc.x, mtl_box_blc.y, mtl_box.TRC.z + (mtl_block.Thickness * 0.2) )
pos_data.SafeZGap = mtl_block.Thickness * 0.1
-- Create object used to pass drilling options
local drill_data = DrillParameterData()
-- start depth for toolpath
drill_data.StartDepth = start_depth
-- cut depth for toolpath this is depth below start depth
drill_data.CutDepth = cut_depth
-- if true perform peck drilling
drill_data.DoPeckDrill = retract_gap > 0.0
-- distance to retract above surface when peck drilling
drill_data.PeckRetractGap = retract_gap
-- if true in Aspire, project toolpath onto composite model
drill_data.ProjectToolpath = false
-- Create object which can used to automatically select geometry on layers etc
local geometry_selector = GeometrySelector()
-- if this is true we create 2d toolpaths previews in 2d view, if false we dont
local create_2d_previews = true
-- if this is true we will display errors and warning to the user
local display_warnings = true
-- Create our toolpath
local toolpath_manager = ToolpathManager()
local toolpath_id = toolpath_manager:CreateDrillingToolpath(
name,
tool,
drill_data,
pos_data,
geometry_selector,
create_2d_previews,
display_warnings
)
if toolpath_id == nil then
DisplayMessageBox("Error creating toolpath")
return false
end
return true
end
--[[ ----------------- main -----------------
|
| Entry point for script
|
]]
function main()
-- Check we have a job loaded
local job = VectricJob()
if not job.Exists then
DisplayMessageBox("No job loaded")
return false;
end
local selection = job.Selection
if selection.IsEmpty then
MessageBox("Please select one or more vectors to drill")
return false
end
local mtl_block = MaterialBlock()
local start_depth = 0.0
local cut_depth = mtl_block.Thickness
local tool_dia = 3.0
local retract_gap = 1.0
local tool_stepdown = 1.0
local tool_in_mm = true
local success = CreateDrillingToolpath(
"Lua Drilling Toolpath",
start_depth,
cut_depth,
retract_gap,
tool_dia,
tool_stepdown,
tool_in_mm
)
return success;
end
:CreateVCarvingToolpath()
Usage: :CreateVCarvingToolpath(
- String name,
- Tool tool,
- Tool area_clear_tool,
- VCarveParameterData vcarve_data,
- PocketParameterData pocket_data,
- ToolpathPosData pos_data,
- GeometrySelector geometry_selector,
- bool create_2d_preview,
- bool interactive)
Creates a vcarving toolpath for the currently selected vectors.
Returns: the UUID for the toolpath created.
- name(string) Name for the toolpath to be created
- tool (Tool) Tool to use for the toolpath Note: must not be nil
- area_clear_tool(Tool) Optional tool for area clearance can be nil
- vcarve_data(VCarveParameterData) Settings for vcarving
- pocket_data(PocketParameterData) Setting for pocketing depth, style etc
- pos_data(ToolpathPosData) Settings for home position, safe z etc
- geometry_selector(GeometrySelector) Can be used to automatically select vectors on layers etc
- create_2d_preview(bool) If true create preview vectors in 2d view
- interactive(bool) If true display warnings etc to user
Example Code: CreateVCarvingToolpath
from Create_VCarving_Toolpath.lua
-- VECTRIC LUA SCRIPT
require "strict"
--[[ ------------- CreateVCarvingToolpath --------------------------------------------------
|
| Create a VCarving toolpath within the program for the currently selected vectors
| Parameters:
| name, -- name for toolpath
| start_depth -- start depth for toolpath below surface of material
| flat_depth -- flat depth - if 0.0 assume not doing flat bottom
| vbit_angle -- angle of vbit to use
| vbit_dia -- diameter of VBit to use
| vbit_stepdown -- stepdown for tool
| tool_stepover_percent -- percentage stepover for tool
| tool_in_mm -- true if tool size and stepdown are in mm
|
| Return Values:
| true if toolpath created OK else false
|
]]
function CreateVCarvingToolpath( name , start_depth, flat_depth, vbit_angle, vbit_dia, vbit_stepdown, tool_stepover_percent, tool_in_mm)
-- Create tool we will use to machine vectors
local tool = Tool(
"Lua VBit",
Tool.VBIT -- BALL_NOSE, END_MILL, VBIT
)
tool.InMM = tool_in_mm
tool.ToolDia = vbit_dia
tool.Stepdown = vbit_stepdown
tool.Stepover = vbit_dia * (tool_stepover_percent / 100)
tool.RateUnits = Tool.MM_SEC -- MM_SEC, MM_MIN, METRES_MIN, INCHES_SEC, INCHES_MIN, FEET_MIN
tool.FeedRate = 30
tool.PlungeRate = 10
tool.SpindleSpeed = 20000
tool.ToolNumber = 1
tool.VBitAngle = 90.0 -- used for vbit only
tool.ClearStepover = vbit_dia * (tool_stepover_percent / 100) * 2 -- used for vbit only
-- we will set home position and safe z relative to material block size
local mtl_block = MaterialBlock()
local mtl_box = mtl_block.MaterialBox
local mtl_box_blc = mtl_box.BLC
-- Create object used to set home position and safez gap above material surface
local pos_data = ToolpathPosData()
pos_data:SetHomePosition(mtl_box_blc.x, mtl_box_blc.y, mtl_box.TRC.z + (mtl_block.Thickness * 0.2) )
pos_data.SafeZGap = mtl_block.Thickness * 0.1
-- Create object used to pass vcarving options
local vcarve_data = VCarveParameterData()
-- start depth for toolpath
vcarve_data.StartDepth = start_depth
-- flag indicating if we are creating a flat bottomed toolpath
vcarve_data.DoFlatBottom = flat_depth > 0.0
-- cut depth for toolpath this is depth below start depth
vcarve_data.FlatDepth = flat_depth
-- if true in Aspire, project toolpath onto composite model
vcarve_data.ProjectToolpath = false
-- set flag indicating we are using flat tool
vcarve_data.UseAreaClearTool = true
-- Create object used to pass pocketing options - used for area clearance only
local pocket_data = PocketParameterData()
-- start depth for toolpath
pocket_data.StartDepth = start_depth
-- cut depth for toolpath this is depth below start depth
pocket_data.CutDepth = flat_depth
-- direction of cut for offet clearance - ProfileParameterData.CLIMB_DIRECTION or ProfileParameterData.CONVENTIONAL_DIRECTION - NOTE: enum from ProfileParameterData
pocket_data.CutDirection = ProfileParameterData.CLIMB_DIRECTION
-- if true use raster clearance strategy , else use offset area clearance
pocket_data.DoRasterClearance = false
-- angle for raster if using raster clearance
pocket_data.RasterAngle = 0
-- type of profile pass to perform PocketParameterData.PROFILE_NONE , PocketParameterData.PROFILE_FIRST orPocketParameterData.PROFILE_LAST
pocket_data.ProfilePassType = PocketParameterData.PROFILE_LAST
-- Create object which can used to automatically select geometry on layers etc
local geometry_selector = GeometrySelector()
-- if this is true we create 2d toolpaths previews in 2d view, if false we dont
local create_2d_previews = true
-- if this is true we will display errors and warning to the user
local display_warnings = true
-- if we are doing two tool pocketing define tool to use for area clearance
local area_clear_tool = nil
-- we just create a 10mm end mill
area_clear_tool = Tool(
"Lua Clearance End Mill",
Tool.END_MILL -- BALL_NOSE, END_MILL, VBIT
)
area_clear_tool.InMM = true
area_clear_tool.ToolDia = 10
area_clear_tool.Stepdown = 3
area_clear_tool.Stepover = 3
area_clear_tool.RateUnits = Tool.MM_SEC -- MM_SEC, MM_MIN, METRES_MIN, INCHES_SEC, INCHES_MIN, FEET_MIN
area_clear_tool.FeedRate = 30
area_clear_tool.PlungeRate = 10
area_clear_tool.SpindleSpeed = 20000
area_clear_tool.ToolNumber = 2
-- Create our toolpath
local toolpath_manager = ToolpathManager()
local toolpath_id = toolpath_manager:CreateVCarvingToolpath(
name,
tool,
area_clear_tool,
vcarve_data,
pocket_data,
pos_data,
geometry_selector,
create_2d_previews,
display_warnings
)
if toolpath_id == nil then
DisplayMessageBox("Error creating toolpath")
return false
end
return true
end
--[[ ------------- main --------------------------------------------------
|
| Entry point for script
|
]]
function main()
-- Check we have a document loaded
local job = VectricJob()
if not job.Exists then
DisplayMessageBox("No job loaded")
return false;
end
local selection = job.Selection
if selection.IsEmpty then
MessageBox("Please select one or more vectors to VCarve")
return false
end
local mtl_block = MaterialBlock()
local start_depth = 0.0
local flat_depth = mtl_block.Thickness * 0.5
local vbit_angle = 90.0
local tool_dia = 32.0
local tool_stepdown = 2.5
local tool_stepover_percent = 2.0
local tool_in_mm = true
local success = CreateVCarvingToolpath(
"Lua VCarving Toolpath",
start_depth,
flat_depth,
vbit_angle,
tool_dia,
tool_stepdown,
tool_stepover_percent,
tool_in_mm
)
return success;
end
:CreatePrismCarvingToolpath(
Usage: :CreatePrismCarvingToolpath(
- String name,
- Tool tool,
- PrismCarveParameterData prism_data,
- ToolpathPosData pos_data,
- GeometrySelectorgeometry_selector,
- bool create_2d_preview,
- bool interactive)
Creates a prism carving toolpath for the currently selected vectors.
Returns: the UUID for the toolpath created.
- name(string) Name for the toolpath to be created
- tool (Tool) Tool to use for the toolpath
- prism_data (PrismParameterData) Settings for prism carving
- pos_data (ToolpathPosData) Settings for home position, safe z etc
- geometry_selector (GeometrySelector) Can be used to automatically select vectors on layers etc
- create_2d_preview(bool) If true create preview vectors in 2d view
- interactive(bool) If true display warnings etc to user
Example Code: CreatePrismToolpath
from Create_Prism_CarvingToolpath.lua
-- VECTRIC LUA SCRIPT require "strict"
-- [[ CreatePrismToolpath
|
| Create a prism toolpath within the program for the currently selected vectors
| Parameters:
| name, -- Name for toolpath
| start_depth -- Start depth for toolpath below surface of material
| cut_depth -- cut depth for drilling toolpath
| vbit_angle -- angle of vbit to use
| vbit_dia -- diameter of VBit to use
| vbit_stepdown -- stepdown for tool
| tool_stepover_percent -- percentage stepover for tool
| tool_in_mm -- true if tool size and stepdown are in mm
|
| returns (Values:
| true if toolpath created OK else false
|
]]
function CreatePrismToolpath( name , start_depth, cut_depth, vbit_angle,
vbit_dia, vbit_stepdown, tool_stepover_percent, tool_in_mm)
-- Create tool we will use to machine vectors
local tool = Tool(
"Lua VBit",
Tool.VBIT -- BALL_NOSE, END_MILL, VBIT
)
tool.InMM = tool_in_mm
===.tool.ToolDia = vbit_dia===
tool.Stepdown = vbit_stepdown
tool.Stepover = vbit_dia * (tool_stepover_percent or 100)
tool.RateUnits = Tool.MM_SEC -- MM_SEC, MM_MIN, METRES_MIN, -- INCHES_SEC, INCHES_MIN, FEET_MIN tool.FeedRate = 30
tool.PlungeRate = 10
tool.SpindleSpeed = 20000
tool.ToolNumber = 1
tool.VBitAngle = 90.0 -- used for vbit only
tool.ClearStepover = vbit_dia * (tool_stepover_percent or 100) * 2 -- used for vbit only
-- Create object used to set home position and safez gap above material surface
local pos_data = ToolpathPosData()
pos_data:SetHomePosition(0, 0, 5.0)
pos_data.SafeZGap = 5.0
-- Create object used to pass profile options
local prism_data = PrismCarveParameterData()
-- start depth for toolpath
prism_data.StartDepth = start_depth
-- cut depth for toolpath this is depth below start depth
prism_data.CutDepth = cut_depth
-- direction of cut for offet clearance (ProfileParameterData.CLIMB_DIRECTION or ProfileParameterData.CONVENTIONAL_DIRECTION )
::''NOTE: enum from ProfileParameterData''
prism_data.CutDirection = ProfileParameterData.CLIMB_DIRECTION
-- calculate the minimum cut depth to fully form the bevel on the current
-- selection with the current tool
local min_bevel_depth = prism_data:CalculateMinimumBevelDepth(tool, true)
if min_bevel_depth > cut_depth then
DisplayMessageBox(
"A prism will not be fully formed with a depth of " cut_depth "\r\n"
"A depth of " min_bevel_depth " is required to fully form the prism"
) end
-- Create object which can be used to automatically select geometry
local geometry_selector = GeometrySelector()
-- if this is true we create 2d toolpaths previews in 2d view, if false we dont
local create_2d_previews = true
-- if this is true we will display errors and warning to the user
local display_warnings = true
-- Create our toolpath
local toolpath_manager = ToolpathManager()
local toolpath_id = toolpath_manager:CreatePrismCarvingToolpath( name, tool, prism_data, pos_data, geometry_selector, create_2d_previews, display_warnings
)
if toolpath_id == nil then
DisplayMessageBox("Error creating toolpath")
return false
end
return true
end
-- [[ main
|
| Entry point for script
|
]]
function main()
-- Check we have a job loaded
job = VectricJob()
if not job.Exists then
DisplayMessageBox("No job loaded")
return false;
end
local selection = job.Selection
if selection.IsEmpty then
MessageBox("Please select one or more vectors to bevel carve")
return false
end
local start_depth = 0.0
local cut_depth = 20.0
local vbit_angle = 90.0
local tool_dia = 32.0
local tool_stepdown = 2.5
local tool_stepover_percent = 2.0
local tool_in_mm = true
local success = CreatePrismToolpath(
"Lua Prism Toolpath", start_depth, cut_depth, vbit_angle, tool_dia, tool_stepdown, tool_stepover_percent, tool_in_mm
)
return success;
end
:CreateFlutingToolpath()
Usage::CreateFlutingToolpath(
- String name,
- Tool tool,
- FlutingParameterDatafluting_data,
- ToolpathPosData pos_data,
- GeometrySelector geometry_selector,
- bool create_2d_preview,
- bool interactive
- )
Creates a fluting toolpath for the currently selected vectors.
Returns: the UUID for the toolpath created.
- name(string) Name for the toolpath to be created
- tool (Tool) Tool to use for the toolpath
- fluting_data (FlutingParameterData) Settings for fluting
- pos_data(ToolpathPosData)Settings for home position, safe z etc
- geometry_selector(GeometrySelector) Can be used to automatically select vectors on layers etc
- create_2d_preview(bool) If true create preview vectors in 2d view
- interactive(bool) If true display warnings etc to user
Example Code: CreateFlutingToolpath()
-- VECTRIC LUA SCRIPT
-- Copyright 2013 Vectric Ltd.
-- Gadgets are an entirely optional add-in to Vectric's core software products.
-- They are provided 'as-is', without any express or implied warranty, and you make use of them entirely at your own risk.
-- In no event will the author(s) or Vectric Ltd. be held liable for any damages arising from their use.
-- Permission is granted to anyone to use this software for any purpose,
-- including commercial applications, and to alter it and redistribute it freely,
-- subject to the following restrictions:
-- 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
-- 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
-- 3. This notice may not be removed or altered from any source distribution.
require "strict"
--[[ ----------------- CreateFlutingToolpath -----------------
|
| Create a drilling toolpath within the program for the currently selected vectors
| Parameters:
| name, -- Name for toolpath
| start_depth -- Start depth for toolpath below surface of material
| cut_depth -- cut depth for toolpath
| tool_dia -- diameter of tool to use
| tool_stepdown -- stepdown for tool
| tool_in_mm -- true if tool size and stepdown are in mm
|
| Return Values:
| true if toolpath created OK else false
|
]]
function CreateFlutingToolpath( name , start_depth, cut_depth, tool_dia, tool_stepdown, tool_in_mm)
-- Create tool we will use to machine vectors
local tool = Tool(
"Lua Ball Nose",
Tool.BALL_NOSE -- BALL_NOSE, END_MILL, VBIT, THROUGH_DRILL
)
tool.InMM = tool_in_mm
tool.ToolDia = tool_dia
tool.Stepdown = tool_stepdown
tool.Stepover = tool_dia * 0.25
tool.RateUnits = Tool.MM_SEC -- MM_SEC, MM_MIN, METRES_MIN, INCHES_SEC, INCHES_MIN, FEET_MIN
tool.FeedRate = 30
tool.PlungeRate = 10
tool.SpindleSpeed = 20000
tool.ToolNumber = 1
tool.VBitAngle = 90.0 -- used for vbit only
tool.ClearStepover = tool_dia * 0.5 -- used for vbit only
-- Create object used to set home position and safez gap above material surface
local pos_data = ToolpathPosData()
pos_data:SetHomePosition(0, 0, 5.0)
pos_data.SafeZGap = 5.0
-- Create object used to pass fluting options
local fluting_data = FlutingParameterData()
-- start depth for toolpath
fluting_data.StartDepth = start_depth
-- cut depth for toolpath this is depth below start depth
fluting_data.CutDepth = cut_depth
-- type of fluting FULL_LENGTH, RAMP_START or RAMP_START_END
fluting_data.FluteType = FlutingParameterData.RAMP_START_END
-- type of ramping RAMP_LINEAR, RAMP_SMOOTH
fluting_data.RampType = FlutingParameterData.RAMP_LINEAR
-- if true use ratio field for controling ramp length else absolute length value
fluting_data.UseRampRatio = false
-- length of ramp as ratio of flute length(range 0 - 1.0) (for start and end - ratio is of half length)
fluting_data.RampRatio = 0.2
-- length to ramp over - if UseRampRatio == false
fluting_data.RampLength = 15
-- if true in Aspire, project toolpath onto composite model
fluting_data.ProjectToolpath = false
-- Create object which can used to automatically select geometry on layers etc
local geometry_selector = GeometrySelector()
-- if this is true we create 2d toolpaths previews in 2d view, if false we dont
local create_2d_previews = true
-- if this is true we will display errors and warning to the user
local display_warnings = true
-- Create our toolpath
local toolpath_manager = ToolpathManager()
local toolpath_id = toolpath_manager:CreateFlutingToolpath(
name,
tool,
fluting_data,
pos_data,
geometry_selector,
create_2d_previews,
display_warnings
)
if toolpath_id == nil then
DisplayMessageBox("Error creating toolpath")
return false
end
return true
end
--[[ ----------------- main -----------------
|
| Entry point for script
|
]]
function main()
-- Check we have a job loaded
local job = VectricJob()
if not job.Exists then
DisplayMessageBox("No job loaded")
return false;
end
local selection = job.Selection
if selection.IsEmpty then
MessageBox("Please select one or more vectors to flute")
return false
end
local start_depth = 0.0
local cut_depth = 1.0
local tool_dia = 1.0
local tool_stepdown = 0.5
local tool_in_mm = false
local success = CreateFlutingToolpath(
"Lua Fluting Toolpath",
start_depth,
cut_depth,
tool_dia,
tool_stepdown,
tool_in_mm
)
return success;
end
:CreateRoughingToolpath()
Usage: :CreateRoughingToolpath(
- String name,
- Tool tool,
- RoughingParameterData roughing_ data,
- ToolpathPosData pos_data,
- GeometrySelector geometry_selector,
- bool interactive) Aspire Only
Creates a roughing toolpath.
Returns: the UUID for the toolpath created. NOTE: This method is only available in Aspire
- name(string) Name for the toolpath to be created
- tool (Tool) Tool to use for the toolpath
- roughing_data(RoughingParameterData) Settings for roughing, strategy etc
- pos_data(ToolpathPosData) Settings for home position, safe z etc
- geometry_selector(GeometrySelector)Can be used to automatically select vectors on layers etc
- interactive(bool) If true display warnings etc to user
Example Code: CreateRoughingToolpath
From 05_Roughing_Toolpath.lua
function CreateRoughingToolpath()
-- Toolpath name
local name = "Lua Roughing Toolpath"
-- Metric unit parameters
local tool_dia = 6.35 -- Quarter of an inch
local tool_stepdown = 5
local tool_stepover_percent = 40
-- Create tool we will use to machine vectors
local tool = Tool("Lua End Mill", Tool.END_MILL)
tool.InMM = true
tool.ToolDia = tool_dia
tool.Stepdown = tool_stepdown
tool.Stepover = tool_dia * (tool_stepover_percent or 100)
tool.RateUnits = Tool.MM_SEC -- MM_SEC, MM_MIN, METRES_MIN, INCHES_SEC, INCHES_MIN, FEET_MIN
tool.FeedRate = 30
tool.PlungeRate = 10
tool.SpindleSpeed = 20000
tool.ToolNumber = 1
tool.VBitAngle = 90.0 -- used for vbit only
tool.ClearStepover = tool_dia * (tool_stepover_percent or 100) -- used for vbit only
-- we will set home position and safe z relative to material block size
local mtl_block = MaterialBlock()
local mtl_box = mtl_block.MaterialBox local mtl_box_blc = mtl_box.BLC
-- Create object used to set home position and safez gap above material surface
local pos_data = ToolpathPosData()
pos_data:SetHomePosition(mtl_box_blc.x, mtl_box_blc.y, mtl_box.TRC.z + (mtl_block.Thickness
* 0.2))
pos_data.SafeZGap = mtl_block.Thickness * 0.1
-- Pocketing parameters local start_depth = 0
local cut_depth = mtl_box.ZLength
-- Create object used to pass roughing options
local roughing_data = RoughingParameterData() -- start depth for toolpath
roughing_data.StartDepth = start_depth
-- cut depth for toolpath this is depth below start depth
roughing_data.CutDepth = cut_depth
-- Machining allowance
roughing_data.MachiningAllowance = 0.0
-- Allowance to leave on when machining (this is different from machining allowance)
roughing_data.Allowance = 0.0
-- if true use z level roughing
roughing_data.DoZLevelRoughing = true -- z level clearance strategy
roughing_data.ZLevelStrategy = RoughingParameterData.RASTER_X
roughing_data.ZLevelProfile = RoughingParameterData.LAST
-- angle for raster if using raster clearance
roughing_data.RasterAngle = 0
-- if true we ramp into pockets (always zig zag)
roughing_data.DoRamping = false -- if ramping, distance to ramp over
roughing_data.RampDistance = 10.0
-- Create object which can used to automatically select geometry on layers etc
local geometry_selector = GeometrySelector()
-- if this is true we will display errors and warning to the user
local display_warnings = true
-- Create our toolpath
local toolpath_manager = ToolpathManager()
local toolpath_id = toolpath_manager:CreateRoughingToolpath(
name,
tool,
roughing_data,
pos_data,
geometry_selector,
display_warnings
)
if not toolpath_id then
DisplayMessageBox("Error creating toolpath") end
end
:CreateFinishingToolpath() Aspire Only
String name, Tool tool, PocketParameterData pocket_data, ToolpathPosData pos_data, GeometrySelector geometry_selector, bool create_2d_preview, bool interactive ) Creates a finishing toolpath for the currently selected vectors.
Returns: the UUID for the toolpath created. NOTE: This method is only available in Aspire
name(string) Name for the toolpath to be created tool (Tool) Tool to use for the toolpath pocket_data (PoketParameterData) Setting for pocketing depth, style etc pos_data(ToolpathPosData) Settings for home position, safe z etc geometry_selector(GeometrySelector) Can be used to automatically select vectors on layers etc create_2d_preview(bool) If true create preview vectors in 2d view interactive(bool) If true display warnings etc to user
Example Code: CreateFinishingToolpath
From 04_Finishing_Toolpath.lua
function CreateFinishingToolpath()
-- Toolpath name
local name = "Lua Finishing Toolpath"
-- Metric unit parameters
local tool_dia = 3.175 -- 8th of an inch
local tool_stepdown = 5
local tool_stepover_percent = 10
-- Create tool we will use to machine vectors
local tool = Tool("Lua Ball Nose", Tool.BALL_NOSE)
tool.InMM = true
tool.ToolDia = tool_dia
tool.Stepdown = tool_stepdown
tool.Stepover = tool_dia * (tool_stepover_percent or 100)
tool.RateUnits = Tool.MM_SEC -- MM_SEC, MM_MIN, METRES_MIN, INCHES_SEC, INCHES_MIN, FEET_MIN
tool.FeedRate = 30
tool.PlungeRate = 10
tool.SpindleSpeed = 20000
tool.ToolNumber = 1
tool.VBitAngle = 90.0 -- used for vbit only
tool.ClearStepover = tool_dia * (tool_stepover_percent or 100) -- used for vbit only
-- we will set home position and safe z relative to material block size
local mtl_block = MaterialBlock()
local mtl_box = mtl_block.MaterialBox
local mtl_box_blc = mtl_box.BLC
-- Create object used to set home position and safez gap above material surface
local pos_data = ToolpathPosData()
pos_data:SetHomePosition(mtl_box_blc.x, mtl_box_blc.y, mtl_box.TRC.z +
(mtl_block.Thickness * 0.2))
pos_data.SafeZGap = mtl_block.Thickness * 0.1
-- Pocketing parameters local start_depth = 0
local cut_depth = mtl_box.ZLength
-- Create object used to pass pocketing options
local pocket_data = PocketParameterData()
-- start depth for toolpath
pocket_data.StartDepth = start_depth
-- cut depth for toolpath this is depth below start depth
pocket_data.CutDepth = cut_depth
-- direction of cut for offet clearance(ProfileParameterData.CLIMB_DIRECTION or ProfileParameterData.CONVENTIONAL_DIRECTION)
NOTE: enum from ProfileParameterData
pocket_data.CutDirection = ProfileParameterData.CLIMB_DIRECTION
-- Allowance to leave on when machining
pocket_data.Allowance = 0.0
-- if true use raster clearance strategy , else use offset area clearance
pocket_data.DoRasterClearance = true -- angle for raster if using raster clearance
pocket_data.RasterAngle = 0
-- type of profile pass to perform PocketParameterData.PROFILE_NONE , PocketParameterData.PROFILE_FIRST orPocketParameterData.PROFILE_LAST
pocket_data.ProfilePassType = PocketParameterData.PROFILE_LAST
-- if true we ramp into pockets (always zig zag)
pocket_data.DoRamping = false -- if ramping, distance to ramp over
pocket_data.RampDistance = 10.0
-- if true in Aspire, project toolpath onto composite model
pocket_data.ProjectToolpath = false
-- Create object which can used to automatically select geometry on layers etc
local geometry_selector = GeometrySelector()
-- if this is true we create 2d toolpaths previews in 2d view, if false we dont
local create_2d_previews = true
-- if this is true we will display errors and warning to the user
local display_warnings = true
-- Create our toolpath
local toolpath_manager = ToolpathManager()
local toolpath_id = toolpath_manager:CreateFinishingToolpath(name, tool, pocket_data, pos_data, geometry_selector, create_2d_previews display_warnings )
if not toolpath_id then
DisplayMessageBox("Error creating toolpath")
end
end
:LoadToolpathTemplate(string template_path)
Load a toolpath template from passed file.
Returns: (bool) true if template loaded OK, else false template_path (string) Full path to template file to load
Example Code:
-- VECTRIC LUA SCRIPT
require "strict"
-- [[ -------------- main ---------------------
|
| Entry point for script
|
]]
function main()
-- Check we have a job loaded
local job = VectricJob()
if not job.Exists then
DisplayMessageBox("No job loaded")
return false
end
local template_path = "c:\\temp\\TestToolpathTemplate.ToolpathTemplate"
local toolpath_manager = ToolpathManager()
if not toolpath_manager:LoadToolpathTemplate(template_path) then
MessageBox("Failed to load template " template_path)
return false
end
MessageBox("Loaded template " template_path)
local calc_result = toolpath_manager:RecalculateAllToolpaths()
if calc_result == nil then
MessageBox("Recalculate all toolpaths failed")
else
MessageBox("Results from recalculate all\n" calc_result)
end
return true
end
:CopyToolpathWithId( UUID id, bool insert_at_end, bool rename)
Copy (duplicate) toolpath with passed id , returns copied toolpath and adds to toolpath list id (UUID) Id of toolpath to copy insert_at_end (bool) If true, new toolpath is inserted at end of list, else following original to copy rename (bool) If true, new toolpath is automatically renamed, else keeps same name
:DeleteAllToolpaths()
Deletes ALL toolpaths in job. (Revised: Feb 10, 2020)
Example Code:
local toolpath_mgr = ToolpathManager()
toolpath_mgr:DeleteAllToolpaths()
:DeleteToolpath( Toolpath toolpath)
Delete passed toolpath Note: make sure you do not refer to toolpath in script after this call! toolpath (Toolpath) Toolpath to delete
:DeleteToolpathWithId( UUID id)
Delete toolpath with passed id id(UUID)id of toolpath to delete
:Find( UUID id)
Returns: the POSITION in the list of the toolpath with hte passed id Note: nil if no toolpath with id found id(UUID)id of toolpath to find position for
:GetAt( pos)
Returns: the toolpath at the passed position
- pos (POSTION) current position in list
:GetGroupToolpathWithIndex( UUID id, integer index)
Returns: (the n
th toolpath of the passed group id. Toolpaths created together such as the two toolpaths from a flat bottom vcarve with two tools share a unique groupid property.
- id (UUID) Id of toolpath group
- index (integer)Index (inrange 0 to n to 1) of toolpath in group to return
:GetNext( pos)
Returns: Both the toolpath at the current position ANDa new value for position pointing to the next item in the list (or nil if at end of list)
- pos (POSTION) current position in list
- Example Code:
Note: GetNext(pos) is returning two values
local pos = uuid_list:GetHeadPosition()
local id
while pos ~= nil do
id, pos = uuid_list:GetNext(pos)
DO SOMETHING WITH ID
end
:GetNumberOfToolpathsInGroup( UUID id)
Returns: (the number of toolpaths which have the passed group id. Toolpaths created together such as the two toolpaths from a flat bottom vcarve with two tools share a unique groupid property. id (UUID) Id of toolpath group to count members for
:GetPrev( pos)
Returns: Both the toolpath at the current position ANDa new value for position, pointing to the previous item in the list (or nil if at start of list)
- pos (POSTION) current position in list
:GetSelectedToolpath()
Returns: the currently selected toolpath or nil if no toolpath currently selected
:GetHeadPosition()
Returns: (POSITION) a variable to allow access to the head of the list of toolpaths
:GetTailPosition()
Returns: (POSITION) a variable to allow access to the tail of the list of toolpaths
:RecalculateAllToolpaths()
Recalculate all toolpaths in the job.
Returns: a string containing a list of all the toolpaths recalculated if it succeeds, else nil.
WARNING: Recalculating all toolpaths will destroy the original toolpaths and create new ones with the same ID.
Do not try and reuse a toolpath variable after this call. See
Example Code:
local toolpath_mgr = ToolpathManager() DisplayMessageBox(toolpath_mgr:RecalculateAllToolpaths())
:RecalculateToolpath(Toolpath toolpath )
For information on how to retrieve a specific toolpath after it has been recalculated.
For Example:
local orig_id = luaUUID()
orig_id:SetId(toolpath.Id)
local recalced_toolpath = nil
if toolpath_manager:RecalculateToolpath(toolpath) then
local recalced_pos = toolpath_manager:Find(orig_id.RawId)
if recalced_pos == nil then
MessageBox("Failed to find toolpath after calculation")
return false
else
recalced_toolpath = toolpath_manager:GetAt(recalced_pos)
end -- if end
end -- if end
:RecalculateToolpath( Toolpath toolpath)
Recalculates passed toolpath.
Returns: (bool) true if toolpath recalculated ok toolpath (Toolpath) Toolpath to recalculate
WARNING: The passed toolpath is invalid after this call as a new toolpath with the same id is created internally. If you wish to continue accesing the toolpath after recalculating, save its id BEFORE calling:RecalculateToolpath() and then use:Find(id) to find the position of the recalculated toolpath and use:GetAt(position) to return the recalculated toolpath.
:SaveToolpathAsTemplate( Toolpath toolpath, string template_path)
Save a toolpath as a template to passed file.
Returns: (bool) true if template saved, else false. If passed toolpath is part of a group (Note: flat bottom vcarving) all toolpaths in group are saved to the template toolpath (Toolpath) Toolpath to save as a template template_path (string) Full path to template file to save
:SaveVisibleToolpathsAsTemplate( string template_path)
Save all visible toolpaths as a template to passed file.
Returns: (bool) true if template saved, else false. template_path (string) Full path to template file to save
:ToolpathModified( Toolpath toolpath)
This method must be called if parameters for a toolpath are modified from script.
For Example:
tool parameters are changed. If this method is not called the ui will not show the changes you have made. toolpath (Toolpath) Toolpath which has been modified
:ToolpathWithNameExists( string name)
Returns: (bool) true if there is one or more existing toolpaths with passed name
- name (string) Toolpath name to check for id (UUID) Id of toolpath to delete
:UndrawAllToolpath()
Undraw (set visibility to false) ALL toolpaths in job.
:SetAllToolpathsVisibility( bool visibility)
Set visibility for all toolpaths in job.
- visibility (bool) true to draw all toolpaths, false to stop drawing them
References
Please Note: The base material for the contents found in this WiKi was sourced from Vectric Lua Interface for Gadgets, version 10.0, published August 21, 2019. by Vectric Ltd. Most current document from Vertric can be downloaded at Vertric Developer Information