Overview

The Finder class is used to traverse AP-238 files and find data. The functions in the finder object return three kinds of results:

  1. A requested value. For example, the x, y and z coordinates of the next point in a tool path.
  2. The identity of an object as an integer. For example, the identity of the first tool path in a working step. Typically this identity will then be used as an argument for another function. Note that are per Section 2.122 this identity is only valid until the data is saved to a file.
  3. A null value returned as a 0 to show that something has not been found. For example, if a function requests the tool of a workingstep and no tool is defined then the result returned will be zero.

A typical Finder object program starts with the main_workplan and traverses the nested workplans, and workingsteps in that program extracting information and when necessary modifying the information using the other objects in the STEP-NC API such as Feature and Process.

In a traversal “dead ends” are indicated by returning null values until the system determines that the application must be lost. When this determination is made an error message is issued. For example, if a workingstep does not contain a tool, but the application goes ahead and asks for the diameter of the tool anyway, then an error is issued because the program should have been written to test for the tool first.

When it finds a value the Finder object returns the nominal value. If the value can have plus/minus values then the Query object should be used to get this additional information. The query object is similar to the Finder object but with additional functionality to get information about lower and upper limits.

Except for two caveats, the Finder object is meant to be able to find any data in an AP-238 file. The first caveat is for plus/minus values as per the description above. The second caveat is for geometric and dimensional tolerances and their associated geometry. This information is found using the Tolerance object.

Navigating an AP-238 Data Set

The Finder object uses a subset of the entities in AP-238 as sentinels for finding the data. These sentinels are organized by their functionality so in order to get a value you first need to know which sentinel leads to that value. For example, if you want a feed value then you need to know to find the technology or path object that defines the feed.

The sentinel objects for navigating the program structure are as follows:

Executable
An executable is an element of a STEP-NC program. It could be a workplan, an NC function, workingstep or a selective. Most Finder applications start with the Main workplan and then navigate through the program structure until the desired workingstep is found.
Workplan
A Workplan is a type of executable that contains a list of other executables. A special workplan is called the Main Workplan. The STEP-NC program starts at the main workplan and executes each executable in that workplan in turn. If the executable is another nested workplan then the current plan is put onto a stack while the nested one is executed and then the current plan continues.
Selective
A Selective is another type of executable that is similar in structure to a workplan. The difference is that at run time only one of the executable in a selective is to be executed. How the executatble is chosen is determined by the user at run time. For the Finder object navigating a Selective is similar to navigating a Workplan and there is functionality in the API that will treat both equally. Selective and Workplan are both examples of Program Structure executables. Other types of program structure are allowed in the AP-238 standard but not yet supported by the API.
NC Function
An NC function is a CNC function that does not require axis movements. There are relatively few of these functions in STEP-NC. The most common are the Display function, the GoHome function, the Optional Stop function and the Stop function.
Workingstep
A workingstep is the most important and rich type of executable. A workingstep describes an operation to machine a feature on the part. It can describe the operation explicitly as a set of machining parameters, or implicitly as a set of tool paths.

In a STEP-NC program the main workplan can be found using the GetMainWorkplan function. You can then navigate through the executables using two sets of functions. If you only care about Workplans you can use the GetWorkplanExecutableCount and GetWorkplanExecutableNext functions to visit each executable in the main workplan. If you want your code to be more generic then you can also use GetNestedExectuableCount and GetNestedExecutableNext functions.

The following code sample shows how to navigate the program structure.

Find->Open238("sample.238");

int wp_id = Find->GetMainWorkplan ();

printf ("Workplan name: %s\n", GetExecutableName (wp_id));

int size = Find->GetNestedExecutableCount (wp_id);
printf ("Workplan size is %d\n", size);

for (int I = 0; I < size; I++) {
    int exe_id = Find->GetNestedExecutableNext (wp_id, I);
    CString type = Find->GetExecutableType (exe_id);
    printf ("Item at %d is a %s\n", type);
}

Notice how the code ends with a call to GetExecutableType function to find out the type of each executable. This is one way to decode the structure in a workplan. The other way is to use the IsProgramStructure, IsWorkplan, IsNcFunction, IsWorkingstep and IsSelective functions to test for the type of of executable. For example,

if (Find->IsWorkingstep (exe_id))
    decode_workingstep (exe_id);

Where decode_workingstep is a user defined function to look at the properties in a workingstep that we will discuss in the next section.

Navigating a Workingstep

A workingstep is the key unit of functionality in a STEP-NC program. The following objects are attached to a workingstep.

Tool
Each workingstep has one cutting tool. If you want to use a second tool then you must create a second workingstep. The GetWorkingstepTool function returns the tool of a workingstep.
Path
Each workingstep has a list of tool paths. The properties of a tool path are are described in the next section. The GetWorkingstepPathCount and GetWorkingstepPathNext functions get the paths in a workingstep using an index.
Feature
Each workingstep has two types of features. A process feature describes the data volume that is being machined by this workingstep. The final features describe requirements of the final part. The GetWorkingstepProcessFeature function returns the process feature. The GetWorkingstepFinalFeatureCount and GetWorkingstepFinalFeatureNext functions return each final feature using an index.
Operation
A workingstep has an operation that describes the parameters of the machining process. A series of functions each with the prefix GetOperationMilling or GetOperationDrilling return the parameters of each operation.

The following code illustrates a possible implementation for the decode_workingstep function discussed in the last section.

void decode_workingstep (int exe_id) 
{
    int tl_id = Find->GetWorkingstepTool (exe_id);

    if (tl_id == 0)
	printf ("Error workingstep has no tool\n");

    else {

	CString t_num = Find->GetToolNumber (tl_id);
	Cstring t_id = Find->GetToolReferenceDataName (tl_id);

	printf ("Tool Number is %s\n", t_num);
	printf ("Manufacturer name is %s\n",t_id);
    }

    int p_id = Find->GetWorkingstepProcessFeature(exe_id);

    CString type = Find->GetFeatureType (p_id);
    printf ("Process feature type is %s\n", type);

    int c = Find->GetWorkingstepFinalFeatureCount (e_id);
    printf ("Number of final features is %d\n", count);

    for (int I = 0; I < c; I++) {
	type = Find->GetWorkingstepFinalFeatureNext (p_id, I);
	printf ("\tType is %s\n" , type);
    }

    decode_paths (e_id);
}

Most AP-238 data sets use a free form milling operation that does not have any parameters so the GetOperation functions are not illustrated in the above example. Most AP-238 data sets also do not make significant use of features. In these data sets the process feature is most often a toolpath feature (type = "TOOLPATH_FEATURE") and there are zero final features. The exceptions are a few data sets made from AP-224 data, and the few data sets made from Mastercam data.

A Toolpath feature is a feature that has no parameters, but it may have a set of faces describing its shape. These faces are important for cutter compensation algorithms and can be manipulated using functionality in the Tolerance object.

Navigating a Toolpath

The example in the previous section ended with a call to a user defined function called decode_paths. In this section we will talk about manipulating path objects.

First some code to visit each toolpath in a workingstep.

void decode_paths (int ws_id) 
{
    boolean isContact;    // paths can be cutter contact or cutter center
    int count = Find->GetWorkingstepPathCount (ws_id);

    for (int I = 0; I < count; I++) {
	int path_id = Find->GetWorkingstepPathNext (ws_id, I, isContact);
	decode_path (path_id);
    }
}

A path is made up of bounded curves. Each curve describes one aspect of the tool path. The two most important aspects are the tool geometry curve and the tool axis curve. Other curves describe the cutting depth, the linearization tolerance and other qualities. The API also includes functionality to access a cross_section area curve that describes the area of contact between the cutting tool and the workpiece and enable dynamic feed and speed computation for different machining conditions and cutting tools.

Each curve is found using its own function. The two functions that we will discuss in this section are GetPathCurve for the geometry curve and GetPathAxis for the axis curve. Each function has two flavors, for example GetPathCurveCount and GetPathCurveNext. The two flavors iterate over the segements in the corresponding curve. One of the rules of STEP-NC requires evey curve in the same path to have the same number of segments so GetPathCurveCount should return the same result as GetPathAxisCount and the similar count functions for the other types of curves.

The following code segement checks that the geometry and axis curves have the same number of segements and then decodes each of those curves. The axis curve is optional for a tool path so the axis curve is only decoded if count2 is greater than zero.

void decode_path (int path_id) 
{
    int count1 = Find->GetPathCurveCount (path_id);
    int count2 = Find->GetPathAxisCount (path_id);

    if (count2 != 0 && count1 != count2) {
	printf ("Error: Bad parameterization\n");
	return;
    }

    decode_geometry (count1, path_id);

    if (count2 != 0)
	decode_axis (count2, path_id);

    decode_process (path_id);
}

The next code segement visits each segement in a geometry curve and prints its type. The two types can be “polyline” or “trimmed_curve”. Today the trimmed curve is assumed to be an arc. In the near future b_spline curves will also be supported. If the curve is an arc then its parameters can be decoded using the GetPathArc function. If it is a polyline then the functions to decode that polyline will be illustrated in our next example.

void decode_geometry (int path_id, int count) 
{
    for (int I = 0; I < count; I++) {
        boolean isArc;
	int cve_id = Find->GetPathCurveNext (path_id, I, isArc);
	CString type = Find->GetPathCurveType (cve_id);

	printf ("Curve type is %s\n");
    }
}

The next function traverses the axis curve of a tool path. Each segement should be a polyline. If the polyline only contains two points then it probably corresponds to an arc in the geometry curve. If the geometry curve only contains polylines then there is no need to break the curves up into segments and instead both curves will be described using one long polyline containing all the points. Another STEP-NC rule requires each curve to contain the same number of points in each curve segment so if the geometry curve segment contains an arc then the corresponding axis curve segment must contain two polyline points.

void decode_axis (int path_id, int count) 
{
    for (int I = 0; I < count; I++) {
	int cve_id = Find->GetPathAxisNext (path_id, I);
	int count2 = Find->GetPathPolylinePointCount (cve_id);

	for (J = 0; J < count2; J++)
	    double ai, aj, ak;

	Find-GetPathPolylinePointNext (cve_id, J, ai, aj, ak);
	printf ("\t(%f, %f, %f)\n", ai, aj, ak);

    }
}

GetPathPolylinePointNext can also be applied to the curve segements in the geometry curve. In this case the values returned will be the x, y and z coordinates of the next point instead of the i, j and k components of the next axis position.

Navigating the Process Parameters

In addition to the path geometries a tool path has process parameters describing the feedrate, the spindle speed and coolant switches. The easiest way to access this information is using the GetPathProcess function as illustrated by the following code segement.

void decode_process (int path_id) 
{
    double f, s;
    int is_rap, co_on;

    Find->GetPathProcess (path_id, f, s, is_rap, co_on);

    if (is_rap) {
	printf ("This path is rapid\n");
    }

    printf ("Feed = %f, Speed = %f\n", f, s);
}

The feed and speed values will have units. If you want to know these units then GetPathTechnologyID function can be used to access the technology object that is attached to the tool path. The GetProcessFeedUnit and GetProcessSpeedUnit functions can then be used to find the units of these two values.

Finally, if you do not want to access values in their native units but instead need them to be delivered in the units required by your program then you can define these units using the APIUnitsFeed and APIUnitsSpeed functions. For example, if you require the feedrate to be in inches per minute then you can request this unit and the API will convert any values that are in other units.

Other Access Methods

The normal way to access data using the Finder object is to go to the main workplan and then navigate to the desired workingstep. However, other access paths are available for applications that do not want to find data via the workingsteps. In the Finder object these functions have the name “All” somewhere in their title.

For example, GetFeatureAllCount returns a count of all the features in the program (both process and final features) amd GetFeatureAllNext gives you access to each feature in turn. Similarly, GetTechnologyAllCount/Next gives you direct access to all the technology objects and GetToolAllCount/Next gives you direct accss to all of the cutting tools.

The following code segment visits all of the features and prints out their types. The Finder object contains a lot of methods to access the attributes of the different types of features after their types have been decoded.

CString type;
int count = Find->GetFeatureAllCount ();
printf ("Number of features is %d\n", count);

for (int I = 0; I < count; I++) {
    int f_id = Find->GetFeatureAllNext (I);
    type = Find->GetFeatureType (f_id);

    printf ("Type is %s\n", type);
}

Final Features and Process Features

A feature can have two roles in a STEP-NC machining program. A process feature describes the volume of material to be removed in an operation. A process feature is typically created by a CAM system. A process feature probably does not have any tolerances because its only role is to define the target volume of an operation.

A final feature describes a property of the part being manufactured. A final feature is defined in CAD or during process planning. A final feature is a target or goal set for the manufacturing processes so it usually has plus/minus tolerances for its dimensions.

Final features can be defined using the STEP AP-224 protocol and they can be used as the input to a CAM system. When a CAM programmer defines a workingstep he or she will want that step to contribute to the manufacture of one or more of the target features defined by the AP-224. Frequently there will be more than one target feature. For example, the operation may be removing a block of material from a face so that subsequent operations can drill several holes into that face so each hole will be one of the final features.

In other cases the final feature and process feature will be identical because the final feature will be made in one operation.

APIUnitsFeed()

void APIUnitsFeed(		
	System::String^ units
	);

void APIUnitsFeed(		
	 string units
	 );

The APIUnitsFeed() function function tells all of the other functions that return feed values the unit to be used for those values. If the value in the AP-238 file is not one of these then it is converted to the requested unit. For example, if the native value is “ipm” and the requested value is “ips” then the native value will be multiplied by 60.

Arguments

units
One of the strings given below
  • “as-is” No conversions
  • “mmps” millimeters per second
  • “mmpm” millimeters per minute
  • “cmps” centimeters per second
  • “mps” meters per second
  • “ips” inches per second
  • “ipm” inches per minute
  • “fps” feet per second
  • “fpm” feet per minute
  • “iprev” inches per revolution
  • “mmprev” millimeters per revolution

Related Functions

APIUnitsInch()

void APIUnitsInch();		 

The APIUnitsInch() function tells all of the other functions to return units as inch values. For example, if a value is 3 inches then the value returned will be "3", and if the value is 25.4 millimeters then it will be "1".

The APIUnitsInch function also sets the speed unit to revolutions per minute (rpm), the feed unit to inches per minute (ipm), the power unit to horse power (hp), and the torque unit to pound foot.

Related Functions

APIUnitsMM()

void APIUnitsMM();		 

The APIUnitsMM() function tells all of the other functions to return length units as millimeter values. For example, if a value is 3 inches then the value returned will be "76.2", and it the value is 3 millimeters then it will be "3".

The APIUnitsMM function also sets the speed unit to revolutions per minute (rpm), the feed unit to millimeters per minute (mmpm), the power unit to kilowatt (kw), and the torque unit to Newton meter.

Related Functions

APIUnitsNative()

void APIUnitsNative();		 

The APIUnitsNative() function tells all of the other functions to return units in their native unit system. For example, regardless of whether a value is 3 inches or 3 millimeters the value returned will always be "3". APIUnitsNative is the default. Use APTUnitsInch or APIUnitsMM make the Finder functions return length values in inch and millimeter units.

Related Functions

APIUnitsSpeed()


void APIUnitsSpeed(		
	 System::String^ units
	 );

void APIUnitsSpeed(		
	 string units
	 );

The APIUnitsSpeed() function tells all of the other functions that return speed values the unit to be used for those values. If the value in the AP-238 file is not one of these then it is converted to the requested unit.

Arguments

units
One of the strings given below
  • “as-is” No conversions
  • “rpm” revolutions per minute
  • “hetrz” revolutions per second

Related Functions

ContainsMilling() / ContainsTurning()

System::Boolean ContainsMilling(); 	
System::Boolean ContainsTurning();

The ContainsMilling() function returns true if the AP-238 file contains any milling technology or milling machine functions. The function is used to determine if the STEP-NC program can be sent to a milling machine.

The ContainsTurning() function returns true if the AP-238 file contains any turning technology or turning machine functions. The function is used to determine if the STEP-NC program can be sent to a turning machine.

Common Errors

GetCompoundFeatureCount

System::Int64 GetCompoundFeatureCount(	
	 System::Int64 compound_id
	 );

int GetCompoundFeatureCount(		
	 int compound_id;
	 );

GetCompoundFeatureNext

System::Int64 GetCompoundFeatureNext(	
	System::Int64 compound_id,
	System::Int64 index
	);

The GetCompoundFeatureCount() function returns the number of features in a compound feature and the GetCompoundFeatureNext() function returns the identity of the feature at a position index. A compound feature is a list of features that have been grouped together so that they can be machined by the same operation. The count returns zero if it is not compound.

A compound feature can have its own coordinate system. If set then this coordinate system changes the direction and orientation of the features in the compound. The z direction of the axis of the compound feature is returned by the GetFeatureAxisDirection function. The x direction of the axis of the feature is returned by the GetFeatureAxisRefDirection function. The origin of the axis is returned by the GetFeatureAxisOrigin function.

Arguments

compound_id
The identity of the compound feature.
index
The index of the requested member.

Related Functions

Common Errors

GetCylindricalFaceEdgePoints()

System::Boolean GetCylindricalFaceEdgePoints(	
	System::Int64 face_id,
	double radius,
	[System::Runtime::InteropServices::Out] double %x1,
	[System::Runtime::InteropServices::Out] double %y1,
	[System::Runtime::InteropServices::Out] double %z1,
	[System::Runtime::InteropServices::Out] double %x2,
	[System::Runtime::InteropServices::Out] double %y2,
	[System::Runtime::InteropServices::Out] double %z2,
	[System::Runtime::InteropServices::Out] double %x3,
	[System::Runtime::InteropServices::Out] double %y3,
	[System::Runtime::InteropServices::Out] double %z3,
	[System::Runtime::InteropServices::Out] double %x4,
	[System::Runtime::InteropServices::Out] double %y4,
	[System::Runtime::InteropServices::Out] double %z4
	);

The GetCylindricalFaceEdgePoints() function checks the topology of a cylinder and returns the coordinates of the four points on the edges.

GetDrillPoint()

void GetDrillPoint(			
	System::Int64 ws_id,
	System::Int64 index,
	[System::Runtime::InteropServices::Out] double %x,
	[System::Runtime::InteropServices::Out] double %y,
	[System::Runtime::InteropServices::Out] double %z
	);

The GetDrillPoint() function get the coordinates of the next point in a drill pattern.

GetDrillPointCount()

System::Int64 GetDrillPointCount(	
	System::Int64 ws_id
	);

The GetDrillPointCount() function get the number of points in drill pattern.

GetExecutableBaseTime()

double GetExecutableBaseTime(		
	System::Int64 exe_id
	);

double GetExecutableBaseTime(		
	int exe_id
	);

The GetExecutableBaseTime() function computes the time to execute the tool paths defined in an executable which can be a workplan or workingstep. The return value is the base time without feed-speed optimizations. The time is computed by calculating the distance of the tool paths and multiplying by the feed speed of those tool paths. The time for rapids, tool changes and any NC functions is assumed to be zero.

Arguments

exe_id
The identity of the executable.

Related Functions

Common Errors

GetExecutableContainer()

System::Int64 GetExecutableContainer(	
	 System::Int64 exe_id
	 );

The GetExecutableContainer() function finds the executable (workplan or selective) that contains the given executable

Arguments

exe_id
The identity of the container executable or 0 if none found.

Related Functions

Common Errors

GetExecutableDistance() and Unit

double GetExecutableDistance(		
	 System::Int64 exe_id
	 );
System::String^ GetExecutableDistanceUnit(
	 System::Int64 exe_id
	 );


double GetExecutableDistance(		
	int exe_id
	);
string GetExecutableDistanceUnit(
	 int exe_id
	 );

The GetExecutableDistance() function returns the total length of the non-rapid tool paths in the executable. For more information see GetExecutableBaseTime and GetExecutableOptimizedTime.

The GetExecutableDistanceUnit() function returns the string name for the unit used for the distance.

GetExecutableName()

System::String^ GetExecutableName(	
	 System::Int64 exe_id
	 );

string GetExecutableName(		
	 int exe_id
	 );

The GetExecutableName() function returns a descriptive string name for an executable. Refer to the AptStepMaker::SetName functon for more information on names.

GetExecutableOptimizedTime()

double GetExecutableOptimizedTime(	
	System::Int64 exe_id
	);

The GetExecutableOptimizedTime() function computes the time to execute the tool paths defined in an executable which can be a workplan or workingstep. It returns the estimated time using the optimized feeds and speeds or zero if there is no override curve in the data.

The time computed is the time after optimizations have been applied to the feeds compute by the CAM system. These optimizations ae computed from cross section area curves that can be stored in the STEP-NC data. The result of the optimizations is an override curve that is also stored in the STEP-NC data. The override curve describes how much to increase or decrease the CAM feed for each segment of each tool path.

Arguments

exe_id
The identity of the executable.

Related Functions

Common Errors

GetExecutableTechnologyCount/Next()

System::Int64 GetExecutableTechnologyCount(	
	System::Int64 exe_id
	);

System::Int64 GetExecutableTechnologyNext(
	System::Int64 exe_id,
	System::Int64 index
	);

The GetExecutableTechnologyCount() function returns a count of all technologies that are used by an executable. If the executable is a workplan then the list may be quite extensive.

The GetExecutableTechnologyNext() function iterates over the technologies and returns one at a position index.

Arguments

exe_id
The identity of the executable
index
The position of the required technology

Related Functions

Common Errors

GetExecutableTimeUnit()

System::String^ GetExecutableTimeUnit(	
	System::Int64 exe_id
	);

string GetExecutableTimeUnit(		
	int exe_id
	);

The GetExecutableTimeUnit() function returns a string describing the unit used for the time data. See GetExecutableBaseTime and GetExecutableOptimizedTime.

GetExecutableType()

System::String^ GetExecutableType(	
	System::Int64 exe_id
	);

string GetExecutableType(		
	int exe_id
	);

The GetExecutableType() function returns a string describing the type of the executable. An executable an part of the control flow of a STEP-NC process. The following type names may be returned if the executable is an NC function.

The following type names are returned if the executable is program structure.

However, if the executable is a “MACHINING_WORKINGSTEP” then one of the following type names will be returned to indicate the type of operation in that workingstep.

Finally, if the Machining workingstep contains a probing operation then the following string will be returned. The functions that manipulate probing workingsteps are in the Tolerance object.

Arguments

exe_id
The identity of the executable.

Related Functions

Common Errors

GetExecutableWorkpieceAsIs()

System::Int64 GetExecutableWorkpieceAsIs(	
	 System::Int64 exe_id
	 );

int GetExecutableWorkpieceAsIs(			
	 int exe_id
	 );

The GetExecutableWorkpieceAsIs() function returns the identity of the workpiece that defines the input to the operation or zero if no workpiece is found.

The workpiece may be defined locally or it may be “inherited”. If it is inherited then it is the model that in the opinion of the API is the best available estimate of the initial state. In most cases this estimate will simply be the workpiece that defines the ToBe of the previous operation. When there is a choice we recommend ToBe models are defined explicitly and AsIs models are defined implictly.

Arguments

exe_id
The identity of the executable.

Related Functions

Common Errors

GetExecutableWorkpieceAsIsLocal()

System::Int64 GetExecutableWorkpieceAsIsLocal(	
	 System::Int64 exe_id
	 );

int GetExecutableWorkpieceAsIsLocal(		
	 int exe_id
	 );

The GetExecutableWorkpieceAsIsLocal() function returns the identity of the workpiece that defines the input to the operation. The workpiece may be defined locally or it may be “inherited”. However, this function returns zero if the workpiece is inherited.

Arguments

exe_id
The identity of the executable.

Related Functions

Common Errors

GetExecutableWorkpieceRemoval()

System::Int64 GetExecutableWorkpieceRemoval(	
	 System::Int64 exe_id
	 );

int GetExecutableWorkpieceRemoval(		
	 int exe_id
	 );

The GetExecutableWorkpieceRemoval() function returns the identity of the workpiece that defines the volume removed by an operation or zero if one is not found. Curently only locally defined workpieces are returned. There is no definition or computation of inherited workpieces for removal volumes.

Arguments

exe_id
The identity of the executable.

Related Functions

Common Errors

GetExecutableWorkpieceRemovalLocal()

System::Int64 GetExecutableWorkpieceRemovalLocal(  
	System::Int64 exe_id
	);

int GetExecutableWorkpieceRemovalLocal(		
	int exe_id
	);

The GetExecutableWorkpieceRemovalLocal() function returns the identity of the workpiece that defines the volume removed by an operation. Storing removal volumes is more space efficient than storing ToBe or AsIs volumes but computing the ToBe and AsIs from the delta is time expensive.

Arguments

exe_id
The identity of the executable.

Related Functions

Common Errors

GetExecutableWorkpieceToBe()

System::Int64 GetExecutableWorkpieceToBe(	
	 System::Int64 exe_id
	 );

int GetExecutableWorkpieceToBe(			
	 int exe_id
	 );

The GetExecutableWorkpieceToBe() function returns the identity of the workpiece that defines the result of an operation, or zero if one is not found. The workpiece may be defined locally or it may be “inherited”. If it is inherited then it is the model that in the opinion of the API is the best available estimate of the final state. In many cases this will be the To-Be model defined for the workplan containing the executable. When there is a choice we recommend that ToBe models are defined explicitly and AsIs models are defined implicitly.

Arguments

exe_id
The identity of the executable.

Related Functions

Common Errors

GetExecutableWorkpieceToBeLocal()

System::Int64 GetExecutableWorkpieceToBeLocal(	
	 System::Int64 exe_id
	 );

int GetExecutableWorkpieceToBeLocal(		
	 int exe_id
	 );

The GetExecutableWorkpieceToBeLocal() function returns the identity of the workpiece that defines the output of an operation. The workpiece may be defined locally or it may be “inherited”. However, this function returns zero if the workpiece is inherited.

Arguments

exe_id
The identity of the executable.

Related Functions

Common Errors

GetFaceEdgeCount()

System::Int64 GetFaceEdgeCount(		
	System::Int64 face_id
	);

int GetFaceEdgeCount(			
	int face_id
	);

The GetFaceEdgeCount() function

GetFaceEdgeNextPoint()


void GetFaceEdgeNextPoint(		
	System::Int64 face_id,
	System::Int64 index,
	[System::Runtime::InteropServices::Out] double %x1,
	[System::Runtime::InteropServices::Out] double %y1,
	[System::Runtime::InteropServices::Out] double %z1,
	[System::Runtime::InteropServices::Out] double %x2,
	[System::Runtime::InteropServices::Out] double %y2,
	[System::Runtime::InteropServices::Out] double %z2
	);

GetFaceEdgeNextPoint(			
	int face_id,
	int index
	);

The GetFaceEdgeNextPoint() function

GetFeatureAllCount/Next()

System::Int64 GetFeatureAllCount();	

System::Int64 GetFeatureAllNext(
	System::Int64 index
	);

The GetFeatureAllCount() function returns a count of all the features in the currently open AP-238 file. Most applications get to the features via the workingsteps that contain those features. This is another access path that is independent of the workingsteps.

The GetFeatureAllNext() function iterates over the features and returns the one at a particular index.

Arguments

index
The index of the requested feature.

Related Functions

Common Errors

GetFeatureAxisDirection()

void GetFeatureAxisDirection(		
	System::Int64 ws_id,
	[System::Runtime::InteropServices::Out] double %i,
	[System::Runtime::InteropServices::Out] double %j,
	[System::Runtime::InteropServices::Out] double %k
	);

The GetFeatureAxisDirection() function returns the Z-axis of a feature. Except for transition features, every feature has an axis direction that defines the z direction for that feature. If the feature is vertical then this direction will be “0, 0, 1”, but if it is horizontal then it could be “1 0, 0” or “0, 1, 0”.

Arguments

feature_id
The index of the requested feature.
i, j, k
[out] Components of the feature z axis.

Related Functions

Common Errors

GetFeatureAxisOrigin()

void GetFeatureAxisOrigin(		
	System::Int64 feature_id,
	[System::Runtime::InteropServices::Out] double %x,
	[System::Runtime::InteropServices::Out] double %y,
	[System::Runtime::InteropServices::Out] double %z
	);

The GetFeatureAxisOrigin() function returns the location of the feature origin. Except for transition features, every feature has an axis reference direction that defines a local origin for the feature. For most features the value of this origin is (0, 0, 0) so unlike the other axis components it has no effect of the feature display.

Arguments

feature_id
The index of the requested feature.
x, y, z
[out] Coordinates of the axis origin.

Related Functions

Common Errors

GetFeatureAxisRefDirection()

void GetFeatureAxisRefDirection(		
	System::Int64 ws_id,
	[System::Runtime::InteropServices::Out] double %a,
	[System::Runtime::InteropServices::Out] double %b,
	[System::Runtime::InteropServices::Out] double %c
	);

The GetFeatureAxisRefDirection() function returns the X-axis of a feature. Except for transition features, every feature has an axis reference direction that defines the x direction for that feature. For features that are circular the reference direction does not matter, but for others it is critical because, for example, it is the only way to give a rectangular feature the correct orientation.

Arguments

feature_id
The index of the requested feature.
a, b, c
[out] Components of the feature x axis.

Related Functions

Common Errors

GetFeatureBossCircular()

System::Boolean GetFeatureBossCircular(		
	System::Int64 feature_id,
	System::Int64 index,
	[System::Runtime::InteropServices::Out] System::Int64 %profile_id,
	[System::Runtime::InteropServices::Out] double %height,
	[System::Runtime::InteropServices::Out] double %diameter,
	[System::Runtime::InteropServices::Out] double %x,
	[System::Runtime::InteropServices::Out] double %y,
	[System::Runtime::InteropServices::Out] double %z
	);

The GetFeatureBossCircular() function returns the parameters of a circular boss. Planar face, open and closed pocket manufacturing features can have one or more bosses. Each boss defines an island in the feature where material is not to be removed by the manufacturing operation. This function returns the parametric definition of a circular boss. The function returns zero if the requested boss is not circular.

Arguments

feature_id
The identity of the feature containing the boss.
index
The boss number
profile_id
[out] Identity of profile object or zero if this is not a circular boss
height
[out] Height of the boss
diameter
[out] Diameter of the boss
x, y, z
[out] Bottom of the boss.

Related Functions

Common Errors

GetFeatureBossCount()

System::Int64 GetFeatureBossCount(		
	System::Int64 ws_id
	);

The GetFeatureBossCount() function returns the number of bosses defined on a feature. Planar face, open and closed pocket manufacturing features can have one or more bosses. Each boss defines an island in the feature where material is not to be removed by the manufacturing operation. This function returns a count of the number of bosses on a feature. The function will return 0 for feature types that cannot contains bosses.

Arguments

feature_id
The identity of the feature containing the boss.

Related Functions

Common Errors

GetFeatureBossGeneral()

System::Boolean GetFeatureBossGeneral(		
	System::Int64 feature_id,
	System::Int64 index,
	[System::Runtime::InteropServices::Out] System::Int64 %profile_id,
	[System::Runtime::InteropServices::Out] double %height,
	[System::Runtime::InteropServices::Out] double %x,
	[System::Runtime::InteropServices::Out] double %y,
	[System::Runtime::InteropServices::Out] double %z
	);

The GetFeatureBossGeneral() function returns the parameters of a general boss. Planar face, open and closed pocket manufacturing features can have one or more bosses. Each boss defines an island in the feature where material is not to be removed by the manufacturing operation. This function returns the parametric definition of a general boss and the identity of the closed loop profile that defines the top of the boss

Arguments

feature_id
The identity of the feature containing the boss.
index
The boss number
profile_id
[out] The identity of the closed loop that defines the boss, or zero if this is not a general boss.
height
[out] Height of the boss
x, y, z
[out] Bottom of the boss.

Related Functions

Common Errors

GetFeatureBossRectangular()

System::Boolean GetFeatureBossRectangular(	
	System::Int64 feature_id,
	System::Int64 index,
	[System::Runtime::InteropServices::Out] System::Int64 %profile_id,
	[System::Runtime::InteropServices::Out] double %height,
	[System::Runtime::InteropServices::Out] double %length,
	[System::Runtime::InteropServices::Out] double %width,
	[System::Runtime::InteropServices::Out] double %x,
	[System::Runtime::InteropServices::Out] double %y,
	[System::Runtime::InteropServices::Out] double %z
	);

The GetFeatureBossRectangular() function returns the parameters of a circular boss. Planar face, open and closed pocket manufacturing features can have one or more bosses. Each boss defines an island in the feature where material is not to be removed by the manufacturing operation. The function returns zero if the requested boss is not rectangular.

The z direction of the axis of the boss is returned by the GetFeatureAxisDirection function. The x direction of the axis of the boss is returned by the GetFeatureAxisRefDirection function. The origin of the axis of the boss is returned by the function and can also be accessed using the GetFeatureAxisOrigin function.

Arguments

feature_id
The identity of the feature containing the boss.
index
The boss number
  • profile_id
    [out] Identity of profile object or zero if this is not a rectangular boss
  • height
    [out] Height of the boss
  • length
    [out] Length (x dimension) of the boss
  • width
    [out] Width (y dimension) of the boss
  • x, y, z
    [out] Bottom of the boss.
  • Related Functions

    Common Errors

    GetFeatureBossType()

    System::String^ GetFeatureBossType(		
    	System::Int64 feature_id,
    	System::Int64 index
    	);
    

    The GetFeatureBossType() function returns a string describing the type of a boss. The string will have the value “circular”, “rectangular” or “general”.

    Arguments

    feature_id
    The identity of the boss or the feature containing the boss.
    index
    The boss number (0 if feature_id is a boss).

    Related Functions

    Common Errors

    GetFeatureChamfer()

    System::Int64 GetFeatureChamfer(			
    	System::Int64 feature_id,
    	[System::Runtime::InteropServices::Out] double %x,
    	[System::Runtime::InteropServices::Out] double %y,
    	[System::Runtime::InteropServices::Out] double %z,
    	[System::Runtime::InteropServices::Out] double %i,
    	[System::Runtime::InteropServices::Out] double %j,
    	[System::Runtime::InteropServices::Out] double %k,
    	[System::Runtime::InteropServices::Out] double %a,
    	[System::Runtime::InteropServices::Out] double %b,
    	[System::Runtime::InteropServices::Out] double %c
    	);
    

    The GetFeatureChamfer() function returns the parametric definition of a chamfer feature. The return value is zero if the feature is not a chamfer or the chamfer face is not defined by a plane with a single loop otherwise returns the identity this plane.

    Like an edge round, a chamfer is a transition feature so it is different to the other features. A transition feature connects two other features so many of its parameters are defined by its intersection with those features. This function returns the definition of the plane that defines the chamfer.

    Arguments

    feature_id The identity of the feature.
    x, y, z
    [out] Origin of the plane that defines the chamfer.
    i, j, k
    [out] Components of the plane’s z-direction
    a, b, c
    [out] Components of the plane’s x-direction

    Related Functions

    Common Errors

    GetFeatureDepth()

    double GetFeatureDepth(				
    	System::Int64 ws_id
    	);
    

    The GetFeatureDepth() function returns the depth parameter of a manufacturing feature if one is present. In general process features always have a depth because they define the volume of material to be removed in an operation, but final features may not have a depth because they define a region on the final part. See Final Features and Process Features for a note on the differences between process and final features. Toolpath features never have a depth.

    Arguments

    feature_id
    The identity of the feature.

    Related Functions

    Common Errors

    GetFeatureEdgeRound()

    System::Int64 GetFeatureEdgeRound(		
    	System::Int64 feature_id,
    	[System::Runtime::InteropServices::Out] double %radius,
    	[System::Runtime::InteropServices::Out] double %x,
    	[System::Runtime::InteropServices::Out] double %y,
    	[System::Runtime::InteropServices::Out] double %z,
    	[System::Runtime::InteropServices::Out] double %i,
    	[System::Runtime::InteropServices::Out] double %j,
    	[System::Runtime::InteropServices::Out] double %k,
    	[System::Runtime::InteropServices::Out] double %a,
    	[System::Runtime::InteropServices::Out] double %b,
    	[System::Runtime::InteropServices::Out] double %c
    	);
    

    The GetFeatureEdgeRound() function returns the parametric definition of an edge round feature or zero if the feature is not an edge round or not defined by a cylinder with a single edge loop.

    Like a chamfer, an edge round is a transition feature so it is different to the other features. A transition feature connects two other features so many of its parameters are defined by its intersection with those features. An edge round connects two features using a circular fillet. This function returns the parameters that define the cylinder of the fillet.

    Arguments

    feature_id The identity of the feature.
    radius
    [out] Radius of the fillet cylinder
    x, y, z
    [out] Origin of the cylinder.
    i, j, k
    [out] Components of the cylinder’s z-direction
    a, b, c
    [out] Components of the cylinders’s x-direction

    Related Functions

    Common Errors

    GetFeatureFaceCount/Next()

    System::Int64 GetFeatureFaceCount(		
    	System::Int64 ws_id
    	);
    
    System::Int64 GetFeatureFaceNext(
    	System::Int64 wp_id,
    	System::Int64 index
    	);
    

    The GetFeatureFaceCount() function returns a count of the number of faces in the feature. Features can have explicit and implicit descriptions. The implicit description is given by a set of geometric faces on the part that contains the feature.

    The GetFeatureFaceNext() function iterates over the faces and returns the one at a particular index value.

    The simplest argument for each function is a feature_id. However, the function will also accept a workingstep_id and in this case the function will return a count of all the faces in all of the features belonging to the workingstep. This includes both the process feature and the final features.

    Finally if the function is given the id of a workplan then it will return a count of all the faces in all of the features of all of the workinsteps in that workplan. This includes workingsteps belonging to workplans nested within the given workplan.

    The Tolerance object contains a suite of functions that can be used to process the data defining a face.

    Arguments

    feature_id
    The identity a feature, workingstep or workplan.
    index
    The index of the requested face

    Common Errors

    GetFeatureHole()

    System::Boolean GetFeatureHole(			
    	System::Int64 feature_id,
    	[System::Runtime::InteropServices::Out] System::Int64 %hole_id,
    	[System::Runtime::InteropServices::Out] double %depth,
    	[System::Runtime::InteropServices::Out] double %diameter,
    	[System::Runtime::InteropServices::Out] double %x,
    	[System::Runtime::InteropServices::Out] double %y,
    	[System::Runtime::InteropServices::Out] double %z
    	);
    

    The GetFeatureHole() function returns the parametric definition of a round hole feature, or zero if the function is not a round hole. A round hole defines material that is to be removed using a drilling operation.

    Arguments

    feature_id
    The identity of the round hole feature.
    profile_id
    [out] The id of the profile that defines the hole diameter, or zero if the feature is not a hole.
    depth
    [out] Depth of the hole
    diameter
    [out] Diameter of the hole
    x, y, z
    [out] Origin of the bottom of the hole.

    Related Functions

    Common Errors

    GetFeatureHoleBottomConical()

    System::Boolean GetFeatureHoleBottomConical(	
    	System::Int64 feature_id,
    	[System::Runtime::InteropServices::Out] System::Int64 %bottom_id,
    	[System::Runtime::InteropServices::Out] double %tip_angle,
    	[System::Runtime::InteropServices::Out] double %tip_radius
    	);
    

    The GetFeatureHoleBottomConical() function returns the parametric definition of a conical hole bottom, or zero if the hole does not have a conical bottom.

    A conical hole bottom is defined by a tip angle and a radius. The tip angle defines the angle of the cone and the tip radius defines the termination point. If the radius is zero then the cone terminates at the tip

    Arguments

    feature_id
    The identity of the round hole feature.
    bottom_id
    [out] The id of the bottom or zero if this hole does not have this kind of bottom.
    tip_angle
    [out] ngle between the plane at the bottom of the hole and the cone.
    tip_radius
    [out] Radius at the termination of the cone (0 if termination is at the tip).

    Related Functions

    Common Errors

    GetFeatureHoleBottomFlat()

    System::Boolean GetFeatureHoleBottomFlat(	
    	System::Int64 feature_id,
    	[System::Runtime::InteropServices::Out] System::Int64 %bottom_id
    	);
    

    The GetFeatureHoleBottomFlat() function returns the parametric definition of a flat hole bottom, or zero if the hole does not have this type of bottom.A flat hole bottom has no parameters.

    Arguments

    feature_id
    The identity of the round hole feature.
    bottom_id
    [out] The id of the bottom or zero if this hole does not have this kind of bottom.

    Related Functions

    Common Errors

    GetFeatureHoleBottomFlatWithRadius()

    System::Boolean GetFeatureHoleBottomFlatWithRadius(	
    	System::Int64 feature_id,
    	[System::Runtime::InteropServices::Out] System::Int64 %bottom_id,
    	[System::Runtime::InteropServices::Out] double %corner_radius
    	);
    

    The GetFeatureHoleBottomFlatWithRadius() function returns the parametric definition of a hole bottom with a radius, or zero if the hole does not have this type of bottom. The radius describes a fillet between the flat hole bottom and the hole sides.

    Arguments

    feature_id
    The identity of the round hole feature.
    bottom_id
    [out] The id of the bottom or zero if this hole does not have this kind of bottom.
    radius
    [out] The radius of the fillet

    Related Functions

    Common Errors

    GetFeatureHoleBottomSpherical()

    System::Boolean GetFeatureHoleBottomSpherical(	
    	System::Int64 feature_id,
    	[System::Runtime::InteropServices::Out] System::Int64 %bottom_id,
    	[System::Runtime::InteropServices::Out] double %radius
    	);
    

    The GetFeatureHoleBottomSpherical() function returns the parametric definition of a hole bottom with a spherical bottom, or zero if the hole does not have this type of bottom. The radius that describes a sphere that intersects with the bottom of the hole.

    Arguments

    feature_id
    The identity of the round hole feature.
    bottom_id
    [out]The id of the bottom or zero if this hole does not have this kind of bottom.
    radius
    [out] The radius of the sphere

    Related Functions

    Common Errors

    GetFeatureHoleBottomThrough()

    System::Boolean GetFeatureHoleBottomThrough(	
    	System::Int64 feature_id,
    	[System::Runtime::InteropServices::Out] System::Int64 %bottom_id
    	);
    

    The GetFeatureHoleBottomThrough() function returns the parametric definition of a through hole bottom, or zero if the hole does not have this type of bottom. A through hole bottom has no parameters.

    Arguments

    feature_id
    The identity of the round hole feature.
    bottom_id
    [out] The id of the bottom or zero if this hole does not have this kind of bottom.

    Related Functions

    Common Errors

    GetFeatureHoleBottomType()

    System::String^ GetFeatureHoleBottomType(	
    	System::Int64 hole_id
    	);
    

    The GetFeatureHoleBottomType() function returns the type of a hole bottom as one of the following strings.

    Arguments

    feature_id
    The identity of the round hole feature.

    Related Functions

    Common Errors

    GetFeatureHoleCounterbore()

    System::Boolean GetFeatureHoleCounterbore(	
    	System::Int64 feature_id,
    	[System::Runtime::InteropServices::Out] System::Int64 %large_hole_id
    	[System::Runtime::InteropServices::Out] System::Int64 %small_hole_id,
    	);
    

    The GetFeatureHoleCounterbore() function returns the two holes in a counterbore feature, or zero if it is not this kind of feature. A counter bore hole is a compound feature defined using a large hole and a small hole.

    Arguments

    feature_id
    The identity of the counter bore hole feature.
    large_hole_id
    [out] The identity of the large hole or 0.
    small_hole_id
    [out] The identity of the small hole or 0.

    Related Functions

    Common Errors

    GetFeatureHoleCounterboreDimensions()

    System::Boolean GetFeatureHoleCounterboreDimensions(	
    	System::Int64 feature_id,
    	[System::Runtime::InteropServices::Out] double %large_hole_depth,
    	[System::Runtime::InteropServices::Out] double %large_hole_diameter,
    	[System::Runtime::InteropServices::Out] double %small_hole_depth,
    	[System::Runtime::InteropServices::Out] double %small_hole_diameter
    	);
    

    The GetFeatureHoleCounterboreDimensions() function returns the dimensions of the two holes in a counterbore feature, or zero if it is not this kind of feature. A counterbore hole is defined using a large hole and a small hole.

    Arguments

    feature_id
    The identity of the counter bore hole feature.
    large_hole_depth
    [out] The large hole depth.
    large_hole_diameter
    [out] The large hole diameter.
    small_hole_depth
    [out] The small hole depth.
    small_hole_diameter
    [out] The small hole diameter.

    Related Functions

    Common Errors

    GetFeatureHoleCountersunk()

    System::Boolean GetFeatureHoleCountersunk(	
    	System::Int64 feature_id,
    	[System::Runtime::InteropServices::Out] System::Int64 %constant_hole_id,
    	[System::Runtime::InteropServices::Out] System::Int64 %taper_hole_id
    	);
    

    The GetFeatureHoleCountersunk() function returns the two holes in a counter sunk feature, or zero if it is not this kind of feature. A counter sunk hole is a compound feature defined using a constant hole and a taper.

    Arguments

    feature_id
    The identity of the counter sunk hole feature.
    constant_hole_id
    [out] The identity of the constant hole or 0.
    taper_hole_id
    [out] The identity of the taper hole or 0.

    Related Functions

    Common Errors

    GetFeatureHoleCountersunkDimensions()

    System::Boolean GetFeatureHoleCountersunkDimensions(	
    	System::Int64 feature_id,
    	[System::Runtime::InteropServices::Out] double %constant_hole_depth,
    	[System::Runtime::InteropServices::Out] double %constant_hole_diameter,
    	[System::Runtime::InteropServices::Out] double %taper_angle
    	);
    

    The GetFeatureHoleCountersunkDimensions() function returns the dimensions of the constant hole and taper or zero if it is not this kind of feature.

    Arguments

    feature_id
    The identity of the countersunk hole feature.
    constant_hole_depth
    [out] The hole depth.
    constant_hole_diameter
    [out] The hole diameter.
    taper_agle
    [out] The taper angle.

    Related Functions

    Common Errors

    GetFeatureHoleCounterbore()

    System::Boolean GetFeatureHoleDoubleCounterbore(	
    	System::Int64 feature_id,
    	[System::Runtime::InteropServices::Out] System::Int64 %large_hole_id,
    	[System::Runtime::InteropServices::Out] System::Int64 %midle_hole_id,
    	[System::Runtime::InteropServices::Out] System::Int64 %small_hole_id
    
    	);
    

    The GetFeatureHoleDoubleCounterbore() function returns the three holes in a double counterbore feature, or zero if it is not this kind of feature. A double counterbore hole is a compound feature defined using a large hole, a middle hole and a small hole. It is a counterbore hole in which the smaller hole is itself a counterbore hole that defines the middle hole and the small hole.

    Arguments

    feature_id
    The identity of the counter bore hole feature.
    large_hole_id
    [out] The identity of the large hole or 0.
    middle_hole_id
    [out] The identity of the middle hole or 0.
    small_hole_id
    [out] The identity of the small hole or 0.

    Related Functions

    Common Errors

    GetFeatureHoleDoubleCounterboreDimensions()

    System::Boolean GetFeatureHoleDoubleCounterboreDimensions(	
    	System::Int64 feature_id,
    	[System::Runtime::InteropServices::Out] double %large_hole_depth,
    	[System::Runtime::InteropServices::Out] double %large_hole_diameter,
    	[System::Runtime::InteropServices::Out] double %middle_hole_depth,
    	[System::Runtime::InteropServices::Out] double %middle_hole_diameter,
    	[System::Runtime::InteropServices::Out] double %small_hole_depth,
    	[System::Runtime::InteropServices::Out] double %small_hole_diameter
    	);
    

    The GetFeatureHoleDoubleCounterboreDimensions() function returns the dimensions of the three holes in a double counterbore feature, or zero if it is not this kind of feature. A double counterbore hole is a compound feature defined using a large hole, a middle hole and a small hole. It is a counterbore hole in which the smaller hole is itself a counterbore hole that defines the middle hole and the small hole.

    Arguments

    feature_id
    The identity of the counter bore hole feature.
    large_hole_depth
    [out] The large hole depth.
    large_hole_diameter
    [out] The large hole diameter.
    middle_hole_depth
    [out] The middle hole depth.
    middle_hole_diameter
    [out] The middle hole diameter.
    small_hole_depth
    [out] The small hole depth.
    small_hole_diameter
    [out] The small hole diameter.

    Related Functions

    Common Errors

    GetFeatureHoleSpotface()

    System::Boolean GetFeatureHoleSpotface(	
    	System::Int64 feature_id,
    	[System::Runtime::InteropServices::Out] System::Int64 %large_hole_id
    	[System::Runtime::InteropServices::Out] System::Int64 %small_hole_id,
    	[System::Runtime::InteropServices::Out] System::Int64 % large_bot_id
    	);
    

    The GetFeatureHoleSpotface() function returns the two holes in a spotface feature, or zero if it is not this kind of feature. A spotface hole is a compound feature defined using a large hole and a small hole with a radiused bottom on the large hole.

    Arguments

    feature_id
    The identity of the counter bore hole feature.
    large_hole_id
    [out] The identity of the large hole or 0.
    small_hole_id
    [out] The identity of the small hole or 0.
    bot_hole_id
    [out] The identity of the hole bottom for the large hole or 0.

    Related Functions

    Common Errors

    GetFeatureHoleSpotfaceDimensions()

    System::Boolean GetFeatureHoleSpotfaceDimensions(	
    	System::Int64 feature_id,
    	[System::Runtime::InteropServices::Out] double %large_hole_radius,
    	[System::Runtime::InteropServices::Out] double %large_hole_depth,
    	[System::Runtime::InteropServices::Out] double %large_hole_diameter,
    	[System::Runtime::InteropServices::Out] double %small_hole_depth,
    	[System::Runtime::InteropServices::Out] double %small_hole_diameter
    	);
    

    The GetFeatureHoleSpotfaceDimensions() function returns the dimensions of the two holes in a spotface feature, or zero if it is not this kind of feature. A spotface hole is a counterbore hole with a radiused bottom on the large hole.

    Arguments

    feature_id
    The identity of the counter bore hole feature.
    large_hole_radius
    [out] The large hole bottom radius.
    large_hole_depth
    [out] The large hole depth.
    large_hole_diameter
    [out] The large hole diameter.
    small_hole_depth
    [out] The small hole depth.
    small_hole_diameter
    [out] The small hole diameter.

    Related Functions

    Common Errors

    GetFeatureHoleDoubleSpotface()

    System::Boolean GetFeatureHoleDoubleSpotface(	
    	System::Int64 feature_id,
    	[System::Runtime::InteropServices::Out] System::Int64 %large_hole_id,
    	[System::Runtime::InteropServices::Out] System::Int64 %midle_hole_id,
    	[System::Runtime::InteropServices::Out] System::Int64 %small_hole_id.
    	[System::Runtime::InteropServices::Out] System::Int64 %large_bot_id
    	[System::Runtime::InteropServices::Out] System::Int64 %middle_bot_id
    
    	);
    

    The GetFeatureHoleDoubleSpotface() function returns the three holes in a double spotface feature, or zero if it is not this kind of feature. A double spotface hole is a double counterbore hole with radiused bottoms on the large and middle holes.

    Arguments

    feature_id
    The identity of the counter bore hole feature.
    large_hole_id
    [out] The identity of the large hole or 0.
    middle_hole_id
    [out] The identity of the middle hole or 0.
    small_hole_id
    [out] The identity of the small hole or 0.
    large_bot_id
    [out] The identity of the large hole bottom or 0.
    middle_bot_id
    [out] The identity of the middle hole bottom or 0.

    Related Functions

    Common Errors

    GetFeatureHoleDoubleSpotfaceDimensions()

    System::Boolean GetFeatureHoleDoubleSpotfaceDimensions(	
    	System::Int64 feature_id,
    	[System::Runtime::InteropServices::Out] double %large_hole_radius,
    	[System::Runtime::InteropServices::Out] double %large_hole_depth,
    	[System::Runtime::InteropServices::Out] double %large_hole_diameter,
    	[System::Runtime::InteropServices::Out] double %middle_hole_radius,
    	[System::Runtime::InteropServices::Out] double %middle_hole_depth,
    	[System::Runtime::InteropServices::Out] double %middle_hole_diameter,
    	[System::Runtime::InteropServices::Out] double %small_hole_depth,
    	[System::Runtime::InteropServices::Out] double %small_hole_diameter
    	);
    

    The GetFeatureHoleDoubleSpotfaceDimensions() function returns the dimensions of the three holes in a double spotface feature, or zero if it is not this kind of feature. A double spotface hole is a counterbore hole with radiused bottoms on the large and middle holes.

    Arguments

    feature_id
    The identity of the counter bore hole feature.
    large_hole_radius
    [out] The bottom radius of the large hole.
    large_hole_depth
    [out] The large hole depth.
    large_hole_diameter
    [out] The large hole diameter.
    middle_hole_radius
    [out] The bottom radius of the middle hole.
    middle_hole_depth
    [out] The middle hole depth.
    middle_hole_diameter
    [out] The middle hole diameter.
    small_hole_depth
    [out] The small hole depth.
    small_hole_diameter
    [out] The small hole diameter.

    Related Functions

    Common Errors

    GetFeatureHoleTaperAngle()

    double GetFeatureHoleTaperAngle(			
    	System::Int64 hole_id
    	);
    

    The GetFeatureHoleTaperAngle() function returns the taper angle of a hole if one is present.

    Arguments

    feature_id
    The identity of the round hole feature.

    Related Functions

    Common Errors

    GetFeatureID()

    System::Int64 GetFeatureID(		
    	System::Int64 ws_id
    	);
    
    int GetFeatureID(			
    	int ws_id
    	);
    

    The GetFeatureID() function

    GetFeatureName()

    System::String^ GetFeatureName(		
    	System::Int64 ws_or_fe_id
    	);
    
    string GetFeatureName(			
    	int ws_or_fe_id
    	);
    

    The GetFeatureName() function returns a string describing the name or null. If the input is a workingstep then the name of the process feature is returned if one exists. Otherwise the name of the first final feature is returned. If no feature exists in the workingstep then the string “no features in workingstep” is returned. This is an error condition because every workingstep is required to be defined by at least one feature.

    Arguments

    feature_id
    The identity of a feature or workingstep.

    Related Functions

    Common Errors

    GetFeatureOutsideProfileClosedCircular()

    System::Boolean GetFeatureOutsideProfileClosedCircular(	
    	System::Int64 feature_id,
    	[System::Runtime::InteropServices::Out] System::Int64 %profile_id,
    	[System::Runtime::InteropServices::Out] double %depth,
    	[System::Runtime::InteropServices::Out] double %diameter,
    	[System::Runtime::InteropServices::Out] double %x,
    	[System::Runtime::InteropServices::Out] double %y,
    	[System::Runtime::InteropServices::Out] double %z
    	);
    
    object GetFeatureOutsideProfileClosedCircular(		
    	int feature_id
    	); 
    returns:
    {
    	rtn: boolean,
    	profile_id: int,
    	depth: double,
    	diameter: double,
    	x: double,
    	y: double,
    	z: double,
    }
    

    The GetFeatureOutsideProfileClosedCircular() function returns the parameters of a closed circular outside profile or false if it is not this type of feature. A circular outside profile defines material that is to be removed from the perimeter of a part. Other closed outside profile features include a rectangular outside profile and a general path outside profile. There are also open outside profile features. A circular outside profile is defined by a diameter and a depth.

    The direction of the axis of the cylinder is returned by the GetFeatureAxisDirection function.

    Arguments

    feature_id
    The identity of the outside profile feature.
    profile_id
    [out] 0 if this is not a circular outside profile otherwise the id of the profile that defines the cylinder.
    depth
    [out] Depth of the cylinder
    diameter
    [out] Diameter of the cylinder
    [out] x, y, z
    [out] Origin of the bottom of the cylinder.

    Related Functions

    Common Errors

    GetFeatureOutsideProfileClosedGeneral()

    System::Boolean GetFeatureOutsideProfileClosedGeneral(	
    	System::Int64 feature_id,
    	[System::Runtime::InteropServices::Out] System::Int64 %profile_id,
    	[System::Runtime::InteropServices::Out] double %depth,
    	[System::Runtime::InteropServices::Out] double %x,
    	[System::Runtime::InteropServices::Out] double %y,
    	[System::Runtime::InteropServices::Out] double %z
    	);
    

    The GetFeatureOutsideProfileClosedGeneral() function returns the parameters of a closed general outside profile or false if it is not this type of feature. A closed general outside profile defines material that is to be removed from the outside of a part. Other closed outside profile features include an outside rectangular profile and an outside circular profile. There are also open outside profile features. The closed general outside profile is defined by a closed profile which is a closed bounded curve and a depth.

    The z direction of the axis of the feature is returned by the GetFeatureAxisDirection function. The x direction of the axis of the feature is returned by the GetFeatureAxisRefDirection function. The origin of the axis is returned by the function and can also be accessed using the GetFeatureAxisOrigin function.

    Arguments

    feature_id
    The identity of the closed general outside profile feature.
    profile_id
    [out] 0 if this is not a closed general outside profile otherwise the id of the profile that defines the outside profile. For a closed general outside profile this id is used by the GetProfileSegment functions to find the geometry items that define the loop that defines the profile.
    depth
    [out] Depth of the profile
    x, y, z
    [out] Origin of the bottom of the profile.

    Related Functions

    Common Errors

    GetFeatureOutsideProfileClosedRectangular()

    System::Boolean GetFeatureOutsideProfileClosedRectangular(	
    	System::Int64 feature_id,
    	[System::Runtime::InteropServices::Out] System::Int64 %profile_id,
    	[System::Runtime::InteropServices::Out] double %depth,
    	[System::Runtime::InteropServices::Out] double %length,
    	[System::Runtime::InteropServices::Out] double %width,
    	[System::Runtime::InteropServices::Out] double %x,
    	[System::Runtime::InteropServices::Out] double %y,
    	[System::Runtime::InteropServices::Out] double %z
    	);
    

    The GetFeatureOutsideProfileClosedRectangular() function returns the parameters of a closed rectangular outside profile or false if it is not this type of feature. A rectangular outside profile defines material that is to be removed from the perimeter of a part. Other closed outside profile features include a circular outside profile and a general path outside profile. There are also open outside profile features. A rectangular outside profile is defined by a length, width and depth.

    The z direction of the axis of the feature is returned by the GetFeatureAxisDirection function. The x direction of the axis of the feature is returned by the GetFeatureAxisRefDirection function. The origin of the axis is returned by the function and can also be accessed using the GetFeatureAxisOrigin function.

    Arguments

    feature_id
    The identity of the outside profile feature.
    profile_id
    [out] 0 if this is not a rectagular outside profile otherwise the id of the profile that defines the rectangle.
    depth
    [out] Depth of the cylinder
    length
    [out] Length (x dimension) of the rectangle
    width
    [out] Width (y dimension) of the rectangle
    x, y, z
    [out] Origin of the bottom of the profile.

    Related Functions

    Common Errors

    GetFeatureOutsideProfileOpenCircular()

    System::Boolean GetFeatureOutsideProfileOpenCircular(	
    	System::Int64 feature_id,
    	[System::Runtime::InteropServices::Out] System::Int64 %profile_id,
    	[System::Runtime::InteropServices::Out] double %depth,
    	[System::Runtime::InteropServices::Out] double %radius,
    	[System::Runtime::InteropServices::Out] double %sweep_angle,
    	[System::Runtime::InteropServices::Out] double %x,
    	[System::Runtime::InteropServices::Out] double %y,
    	[System::Runtime::InteropServices::Out] double %z
    	);
    

    The GetFeatureOutsideProfileOpenCircular() function returns the parameters of an open circular outside profile or false if it is not this type of feature. An open circular outside profile defines material that is to be removed from the perimeter of a part. Other open outside profile features include a linear outside profile and a general path outside profile. There are also closed outside profile features. An open circular outside profile is defined by a sweep angle, a diameter and a depth. The sweep angle describes the material to be machined. The sweep is oriented using the axis placement of the feature.

    The z direction of the axis of the feature is returned by the GetFeatureAxisDirection function. The x direction of the axis of the feature is returned by the GetFeatureAxisRefDirection function. The origin of the axis is returned by the function and can also be accessed using the GetFeatureAxisOrigin function.

    Arguments

    feature_id
    The identity of the outside profile feature.
    profile_id
    [out] 0 if this is not a circular outside profile otherwise the id of the profile that defines the cylinder.
    depth
    [out] Depth of the cylinder
    radius
    [out] Radius of the cylinder
    sweep angle
    [out] Sweep angle of the cylinder
    x, y, z
    [out] Origin of the bottom of the cylinder.

    Related Functions

    Common Errors

    GetFeatureOutsideProfileOpenGeneral()

    System::Boolean GetFeatureOutsideProfileOpenGeneral(	
    	System::Int64 feature_id,
    	[System::Runtime::InteropServices::Out] System::Int64 %profile_id,
    	[System::Runtime::InteropServices::Out] double %depth,
    	[System::Runtime::InteropServices::Out] double %x,
    	[System::Runtime::InteropServices::Out] double %y,
    	[System::Runtime::InteropServices::Out] double %z
    	);
    

    The GetFeatureOutsideProfileOpenGeneral() function the parameters of an open general outside profile or false if it is not this type of feature. A open general outside profile defines material that is to be removed from the outside of a part. Other open outside profile features include an outside linear profile and an outside circular profile. There are also closed outside profile features. The open general outside profile is defined by a open profile which is a bounded curve and a depth.

    The z direction of the axis of the feature is returned by the GetFeatureAxisDirection function. The x direction of the axis of the feature is returned by the GetFeatureAxisRefDirection function. The origin of the axis is returned by the function and can also be accessed using the GetFeatureAxisOrigin function.

    Arguments

    feature_id
    The identity of the closed general outside profile feature.
    profile_id
    [out] 0 if this is not a closed general outside profile otherwise the id of the profile that defines the outside profile. For a general outside profile this id is used by the GetProfileSegment functions to find the geometry items that define the loop that defines the profile.
    depth
    [out] Depth of the profile
    x, y, z
    [out] Origin of the bottom of the profile.

    Related Functions

    Common Errors

    GetFeatureOutsideProfileOpenLinear()

    System::Boolean GetFeatureOutsideProfileOpenLinear(	
    	System::Int64 feature_id,
    	[System::Runtime::InteropServices::Out] System::Int64 %profile_id,
    	[System::Runtime::InteropServices::Out] double %depth,
    	[System::Runtime::InteropServices::Out] double %length,
    	[System::Runtime::InteropServices::Out] double %x,
    	[System::Runtime::InteropServices::Out] double %y,
    	[System::Runtime::InteropServices::Out] double %z
    	);
    

    The GetFeatureOutsideProfileOpenLinear() function the parameters of an open linear outside profile or false if it is not this type of feature. An open linear outside profile defines material that is to be removed from the perimeter of a part. Other open outside profile features include a circular outside profile and a general path outside profile. There are also closed outside profile features. A linear outside profile is defined by a length. The length is oriented using the axis placement of the feature.

    The z direction of the axis of the feature is returned by the GetFeatureAxisDirection function. The x direction of the axis of the feature is returned by the GetFeatureAxisRefDirection function. The origin of the axis is returned by the function and can also be accessed using the GetFeatureAxisOrigin function.

    Arguments

    feature_id
    The identity of the outside profile feature.
    [out] profile_id
    [out] 0 if this is not a rectagular outside profile otherwise the id of the profile that defines the rectangle.
    depth
    [out] Depth of the cylinder
    length
    [out] Length (x dimension) of the line to be machined.
    x, y, z
    [out] Origin of the bottom of the profile.

    Related Functions

    Common Errors

    GetFeaturePlacedType()

    System::String^ GetFeaturePlacedType(		
    	System::Int64 placed_id
    	);
    

    The GetFeaturePlacedType() function returns the underlying featre type of a placed feature. Two types of features are supported in the system: instanced features and template features. An instanced feature is a complete definition and a template feature is a template that can be placed at multiple locations. Template features save space when there are many instances of the same feature. Most functions in the DLL will process both instance features and templates features and go to the underlying template data for a placed feature automatically when necessary. The GetFeaturePlacedType() function gets the type of the underlying template feature.

    Arguments

    placed_id
    The identity of a placed feature.

    Related Functions

    Common Errors

    GetFeaturePlanarFace()

    System::Boolean GetFeaturePlanarFace(	
    	System::Int64 feature_id,
    	[System::Runtime::InteropServices::Out] System::Int64 %profile_id,
    	[System::Runtime::InteropServices::Out] double %depth,
    	[System::Runtime::InteropServices::Out] double %length,
    	[System::Runtime::InteropServices::Out] double %width,
    	[System::Runtime::InteropServices::Out] double %x,
    	[System::Runtime::InteropServices::Out] double %y,
    	[System::Runtime::InteropServices::Out] double %z
    	);
    

    The GetFeaturePlanarFace() function returns the parameters of a planar face feature, or zero if it is not that type of feature. A planar face defines material that is to be removed from a face. A planar face is defined by a length, width and depth. The same parameters define a rectangular closed pocket, but a pocket has walls and a planar face does not so the milling operation can mill beyond the edges.

    The z direction of the axis of the feature is returned by the GetFeatureAxisDirection function. The x direction of the axis of the feature is returned by the GetFeatureAxisRefDirection function. The origin of the axis is returned by this function and can also be accessed using the GetFeatureAxisOrigin function.

    Arguments

    feature_id The identity of the planar face feature.
    profile_id
    [out] 0 if this is not a planar face otherwise the id of the profile that defines the face.
    depth
    [out] Depth of the material to be removed
    length
    [out] Length (x dimension) of the face
    width
    [out] Width (y dimension) of the face
    x, y, z
    [out] Origin of the bottom of the face.

    Related Functions

    Common Errors

    GetFeaturePocketBottomFlat()

    System::Boolean GetFeaturePocketBottomFlat(	
    	System::Int64 feature_id,
    	[System::Runtime::InteropServices::Out] System::Int64 %bottom_id,
    	[System::Runtime::InteropServices::Out] double %planar_radius
    	);
    

    The GetFeaturePocketBottomFlat() function returns the parameters of a flat pocket bottom, or zero if the bottom is not that type. Open and closed pockets can have a bottom of type flat, radiused or through. This function returns the parameters that define a flat pocket bottom.

    Arguments

    feature_id
    The identity of the pocket feature.
    bottom_id
    [out] The identity of the bottom or zero if it is not this type of pocket bottom.
    planar_radius
    [out] The radius of a fillet between the bottom and the sides of the pocket.

    Related Functions

    Common Errors

    GetFeaturePocketBottomRadiused()

    System::Boolean GetFeaturePocketBottomRadiused(	
    	System::Int64 feature_id,
    	[System::Runtime::InteropServices::Out] System::Int64 %bottom_id,
    	[System::Runtime::InteropServices::Out] double %radius,
    	[System::Runtime::InteropServices::Out] double %x,
    	[System::Runtime::InteropServices::Out] double %y,
    	[System::Runtime::InteropServices::Out] double %z
    	);
    

    The GetFeaturePocketBottomRadiused() function returns the parameters of a radiused pocket bottom, or false if the bottom is not that type. Open and closed pockets can have a bottom of type flat, radiused or through. This function returns the parameters that define a radiused pocket bottom. A radiused pocket bottom is a bottom that is defined by a sphere. The center of the sphere is defined by a Cartesian point

    Arguments

    feature_id
    The identity of the pocket feature.
    bottom_id
    [out] The identity of the bottom or zero if it is not this type of pocket bottom.
    radius
    [out] The radius of the sphere that defines the bottom.
    x, y, z
    [out] The center of the sphere.

    Related Functions

    Common Errors

    GetFeaturePocketBottomThrough()

    System::Boolean GetFeaturePocketBottomThrough(	
    	System::Int64 feature_id,
    	[System::Runtime::InteropServices::Out] System::Int64 %bottom_id
    	);
    

    The GetFeaturePocketBottomThrough() function returns the parameters of a through pocket bottom, or zero if the bottom is not that type. Open and closed pockets can have a bottom of type flat, radiused or through. This function returns the parameters that define a through or open pocket bottom.

    Arguments

    feature_id
    The identity of the pocket feature.
    bottom_id
    [out] The identity of the bottom or zero if it is not this type of pocket bottom.

    Related Functions

    Common Errors

    GetFeaturePocketBottomType()

    System::String^ GetFeaturePocketBottomType(	
    	System::Int64 pocket_id
    	);
    

    The GetFeaturePocketBottomType() function returns the type of a pocket bottom as one of the following strings:

    Arguments

    feature_id
    The identity of the pocket feature (open or closed).

    Related Functions

    Common Errors

    GetFeaturePocketClosedCircular()

    System::Boolean GetFeaturePocketClosedCircular(	
    	System::Int64 feature_id,
    	[System::Runtime::InteropServices::Out] System::Int64 %profile_id,
    	[System::Runtime::InteropServices::Out] double %depth,
    	[System::Runtime::InteropServices::Out] double %diameter,
    	[System::Runtime::InteropServices::Out] double %x,
    	[System::Runtime::InteropServices::Out] double %y,
    	[System::Runtime::InteropServices::Out] double %z
    	);
    

    The GetFeaturePocketClosedCircular() function returns the parameters of a closed circular pocket or false if it is not this kind of feature. A closed circular pocket defines material that is to be removed from the inside of a part. Other closed pocket features include a closed rectangular pocket and a closed general pocket. A closed circular pocket is defined by a diameter and a depth.

    The direction of the axis of the cylinder is returned by the GetFeatureAxisDirection function.

    Arguments

    feature_id
    The identity of the closed circular pocket feature.
    profile_id
    [out] The profile that defines the cylinder or zero if this is not a closed circular pocket
    depth
    [out] Depth of the cylinder
    diameter
    [out] Diameter of the cylinder
    x, y, z
    [out] Origin of the bottom of the cylinder.

    Related Functions

    Common Errors

    GetFeaturePocketClosedGeneral()

    System::Boolean GetFeaturePocketClosedGeneral(	
    	System::Int64 feature_id,
    	[System::Runtime::InteropServices::Out] System::Int64 %profile_id,
    	[System::Runtime::InteropServices::Out] double %depth,
    	[System::Runtime::InteropServices::Out] double %x,
    	[System::Runtime::InteropServices::Out] double %y,
    	[System::Runtime::InteropServices::Out] double %z
    	);
    

    The GetFeaturePocketClosedGeneral() function returns the parameters of a closed general pocket or false if it is not this kind of feature. A closed general pocket defines material that is to be removed from the inside of a part. Other closed pocket features include a closed rectangular pocket and a closed circular pocket. The closed general pocket is defined by a closed profile which is a bounded curve and a depth.

    The z direction of the axis of the feature is returned by the GetFeatureAxisDirection function. The x direction of the axis of the feature is returned by the GetFeatureAxisRefDirection function. The origin of the axis is returned by the function and can also be accessed using the GetFeatureAxisOrigin function.

    Arguments

    feature_id
    The identity of the closed circular pocket feature.
    profile_id
    [out] The profile that defines the boundary of the removal volume. For a closed general pocket this id is used by the GetProfileSegment functions to find the geometry items that define the loop that defines the pocket. This is zero if the feature is not a closed general pocket.
    depth
    [out] Depth of the pocket.
    x, y, z
    [out] Origin of the bottom of the pocket.

    Related Functions

    Common Errors

    GetFeaturePocketClosedRectangular()

    System::Boolean GetFeaturePocketClosedRectangular(	
    	System::Int64 feature_id,
    	[System::Runtime::InteropServices::Out] System::Int64 %profile_id,
    	[System::Runtime::InteropServices::Out] double %depth,
    	[System::Runtime::InteropServices::Out] double %length,
    	[System::Runtime::InteropServices::Out] double %width,
    	[System::Runtime::InteropServices::Out] double %orthogonal_radius,
    	[System::Runtime::InteropServices::Out] double %x,
    	[System::Runtime::InteropServices::Out] double %y,
    	[System::Runtime::InteropServices::Out] double %z
    	);
    

    The GetFeaturePocketClosedRectangular() function returns the parameters of a closed rectangular pocket or false if it is not this kind of feature. A closed rectangular pocket defines material that is to be removed from the inside of a part. Other closed pocket features include a closed circular pocket and a closed general pocket. A closed circular pocket is defined by a length, width and depth.

    The z direction of the axis of the feature is returned by the GetFeatureAxisDirection function. The x direction of the axis of the feature is returned by the GetFeatureAxisRefDirection function. The origin of the axis is returned by the function and can also be accessed using the GetFeatureAxisOrigin function.

    Arguments

    feature_id
    The identity of the closed rectangular pocket feature.
    profile_id
    [out] The id of the profile that defines the pocket or zero if this is not a closed rectangular pocket otherwise
    depth
    [out] Depth of the pocket
    length
    [out] Length (x dimension) of the pocket
    width
    [out] Width (y dimension) of the pocket
    orthogonal_radius
    [out] Optional radius for a fillet between the length and width for the four corners. Zero if not used
    x, y, z
    [out] Origin of the bottom of the pocket.

    Related Functions

    Common Errors

    GetFeaturePocketOpenCircular()

    System::Boolean GetFeaturePocketOpenCircular(	
    	System::Int64 feature_id,
    	[System::Runtime::InteropServices::Out] System::Int64 %path_id,
    	[System::Runtime::InteropServices::Out] double %depth,
    	[System::Runtime::InteropServices::Out] double %radius,
    	[System::Runtime::InteropServices::Out] double %sweep_angle,
    	[System::Runtime::InteropServices::Out] double %x,
    	[System::Runtime::InteropServices::Out] double %y,
    	[System::Runtime::InteropServices::Out] double %z
    	);
    

    The GetFeaturePocketOpenCircular() function returns the parameters of an open circular pocket or false if it is not this kind of feature. An open circular pocket defines material that is to be removed from the interior of a part. Other open pocket features include a rectangular pocket profile and a general path pocket. There are also closed pocket features. An open circular pocket is defined by a sweep angle, a diameter and a depth. The sweep angle describes the material to be removed. The sweep is oriented using the axis placement of the feature.

    The z direction of the axis of the feature is returned by the GetFeatureAxisDirection function. The x direction of the axis of the feature is returned by the GetFeatureAxisRefDirection function. The origin of the axis is returned by the function and can also be accessed using the GetFeatureAxisOrigin function.

    Arguments

    feature_id
    The identity of the open pocket feature.
    profile_id
    [out] The id of the cylinder profile that defines the pocket or zero if this is not a closed rectangular pocket otherwise.
    depth
    [out] Depth of the cylinder
    radius
    [out] Radius of the cylinder
    sweep
    [out] angle Sweep angle of the cylinder
    x, y, z
    [out] Origin of the bottom of the cylinder.

    Related Functions

    Common Errors

    GetFeaturePocketOpenGeneral()

    System::Boolean GetFeaturePocketOpenGeneral(	
    	System::Int64 feature_id,
    	[System::Runtime::InteropServices::Out] System::Int64 %path_id,
    	[System::Runtime::InteropServices::Out] double %depth,
    	[System::Runtime::InteropServices::Out] double %x,
    	[System::Runtime::InteropServices::Out] double %y,
    	[System::Runtime::InteropServices::Out] double %z
    	);
    

    The GetFeaturePocketOpenGeneral() function returns the parameters of an open general pocket or false if it is not this kind of feature. An open general pocket defines material that is to be removed from the inside of a part. Other open pocket features include a rectangular pocket and a circular pocket. The open general pocket is defined by an open profile which is a bounded curve and a depth.

    The z direction of the axis of the feature is returned by the GetFeatureAxisDirection function. The x direction of the axis of the feature is returned by the GetFeatureAxisRefDirection function. The origin of the axis is returned by the function and can also be accessed using the GetFeatureAxisOrigin function.

    Arguments

    feature_id
    The identity of the open general pocket feature feature.
    profile_id
    [out] Zero if this is not a open general pocket otherwise the id of the profile that defines the boundary of the removal volume. This id is used by the GetProfileSegment functions to find the geometry items that define the loop that defines the pocket.
    depth
    [out] Depth of the pocket.
    x, y, z
    [out] Origin of the bottom of the pocket.

    Related Functions

    Common Errors

    GetFeaturePocketOpenRectangular()

    System::Boolean GetFeaturePocketOpenRectangular(	
    	System::Int64 feature_id,
    	[System::Runtime::InteropServices::Out] System::Int64 %profile_id,
    	[System::Runtime::InteropServices::Out] double %depth,
    	[System::Runtime::InteropServices::Out] double %length,
    	[System::Runtime::InteropServices::Out] double %width,
    	[System::Runtime::InteropServices::Out] double %orthogonal_radius,
    	[System::Runtime::InteropServices::Out] double %x,
    	[System::Runtime::InteropServices::Out] double %y,
    	[System::Runtime::InteropServices::Out] double %z
    	);
    

    The GetFeaturePocketOpenRectangular() function returns the parameters of an open rectangular pocket or false if it is not this kind of feature. A open rectangular pocket defines material that is to be removed from the inside of a part. Other open pocket features include a circular pocket and a general pocket. A open rectangular pocket is defined by a Square U Profile and a depth.

    The z direction of the axis of the feature is returned by the GetFeatureAxisDirection function. The x direction of the axis of the feature is returned by the GetFeatureAxisRefDirection function. The origin of the axis is returned by the function and can also be accessed using the GetFeatureAxisOrigin function.

    Arguments

    feature_id
    The identity of the open rectangular pocket feature.
    profile_id
    [out] Zero if this is not a open rectangular pocket otherwise the id of the square u profile that defines the pocket. The function GetFeatureProfileSquareU must be used to decode the parameters of the profile.
    depth
    [out] Depth of the pocket
    x, y, z
    [out] Origin of the bottom of the pocket.

    Related Functions

    Common Errors

    GetFeaturePocketTaper()

    double GetFeaturePocketTaper(	
    	System::Int64 feature_id
    	);
    

    The GetFeaturePocketTaper() function returns the taper angle (or slope) of a pocket. A value of 0 is returned if the pocket does not have a taper.

    Arguments

    feature_id
    The identity of the pocket feature.
    radius
    [out] The angle of the taper.

    Common Errors

    GetFeatureProfile()

    System::Int64 GetFeatureProfile(		
    	System::Int64 ws_id
    	);
    

    The GetFeatureProfile() function returns the identity of the profile that defines a feature. A profile defines the shape of a feature. There are many kinds of profiles but only three are directly processed by functions in the API. A general profile is described by a bounded curve and is therefore similar to a tool path. A RoundedU profile and a SquareU profile are described parametrically.

    Other profiles do not need to be decoded because their data is returned by the corresponding function. For example, the diameter of a circle profile is returned by the GetFeatureHole function.

    Arguments

    feaure_id
    The identity of the feature.

    Related Functions

    Common Errors

    GetFeatureProfileAtEnd()

    System::Int64 GetFeatureProfileAtEnd(	
    	System::Int64 ws_id
    	);
    

    The GetFeatureProfileAtEnd() function

    GetFeatureProfileAtStart()

    System::Int64 GetFeatureProfileAtStart(	
    	System::Int64 ws_id
    	);
    

    The GetFeatureProfileAtStart() function

    GetFeatureProfileRoundedU()

    System::Int64 GetFeatureProfileRoundedU(	
    	System::Int64 profile_id,
    	[System::Runtime::InteropServices::Out] double %width
    	);
    

    The GetFeatureProfileRoundedU() function returns the parameters of a rounded "u" profile or zero if it is not this kind of profile. A rounded U profile has the shape of a rounded U and is described by a width parameter. Because it is a rounded U the parameter also describes the diameter of the half circle at the end of the U. The other ends of the U are bounded by the depth of the feature that contains the profile and not by any data in the profile.

    Arguments

    profile_id
    The identity of the rounded U profile.
    width
    [out] The width between the two halves of the U.

    Related Functions

    Common Errors

    GetFeatureProfileSegmentCount/Next()

    System::Int64 GetFeatureProfileSegmentCount(	
    	System::Int64 profile_id
    	);
    
    System::Int64 GetFeatureProfileSegmentNext(
    	System::Int64 profile_id,
    	System::Int64 index,
    	[System::Runtime::InteropServices::Out] System::Boolean %is_arc
    	);
    

    The GetFeatureProfileSegmentCount() function returns the number of segments in a general profile boundary. Each segment will be a curve that can be manipulated using the functionality provided for tool path segments.

    The GetFeatureProfileSegmentNext() function iterates over the segments and returns the curve_id for the segment at a requested index. Each segment in a profile is defined by a curve. and this curve_id can be given as the input for GetPathArc or GetPathPolylinePointCount depending on the value of is_arc.

    Depending on the feature the profile may be open or closed. If it is closed the first and last point will be coincident.

    Arguments

    profile_id
    The identity of the general profile.
    index
    The position of the required segment in the profile
    is_arc
    [out] Will be 1 if this segment is an arc.

    Related Functions

    Common Errors

    GetFeatureProfileSquareU()

    System::Boolean GetFeatureProfileSquareU(	
    	System::Int64 profile_id,
    	[System::Runtime::InteropServices::Out] double %width,
    	[System::Runtime::InteropServices::Out] double %first_radius,
    	[System::Runtime::InteropServices::Out] double %first_angle,
    	[System::Runtime::InteropServices::Out] double %second_radius,
    	[System::Runtime::InteropServices::Out] double %second_angle
    	);
    

    The GetFeatureProfileSquareU() function returns the parameters of a square "u" profile or zero if it is not this kind of profile. A square U profile has a U shape with a flat base. The width describes the length of the flat base. The angle parameters describe the angles between the base and each line and the radius parameters describe the radius of a fillet between each line and the base. The other ends of the U are bounded by the depth of the feature that contains the profile and not by any data in the profile.

    Arguments

    profile_id
    The identity of the rounded U profile.
    width
    [out]The width between the two halves of the U.
    first_radius
    [out]The radius of the fillet for the first half of the U.
    first_angle
    [out]The angle between the first line and the base.
    second_radius
    [out]The radius of the fillet for the second half of the U.
    second_angle
    [out]The angle between the second line and the base.

    Related Functions

    Common Errors

    GetFeatureProfileZcoordinate()

    double GetFeatureProfileZcoordinate(	
    	System::Int64 profile_id
    	);
    

    The GetFeatureProfileZcoordinate() function

    GetFeatureRoundedEnd()

    System::Boolean GetFeatureRoundedEnd(	
    	System::Int64 feature_id,
    	[System::Runtime::InteropServices::Out] System::Int64 %profile_id,
    	[System::Runtime::InteropServices::Out] double %depth,
    	[System::Runtime::InteropServices::Out] double %radius,
    	[System::Runtime::InteropServices::Out] double %sweep_angle,
    	[System::Runtime::InteropServices::Out] double %x,
    	[System::Runtime::InteropServices::Out] double %y,
    	[System::Runtime::InteropServices::Out] double %z
    	);
    

    The GetFeatureRoundedEnd() function returns the parameters of a rounded end feature or zero if it is not this kind of feature. A rounded end defines material that is to be removed in a turning operation.

    The z direction of the axis of the feature is returned by the GetFeatureAxisDirection function. The x direction of the axis of the feature is returned by the GetFeatureAxisRefDirection function. The origin of the axis is returned by the function and can also be accessed using the GetFeatureAxisOrigin function.

    Arguments

    feature_id
    The identity of the rounded end feature.
    profile_id
    [out] 0 if this is not a rounded end otherwise the profile that defines the end.
    depth
    [out] Depth of the rounded end
    radius
    [out] The radius of the rounded end.
    sweep_angle
    [out] The sweep angle for the rounded end.
    x, y, z
    [out] Origin of the bottom of the step.

    Related Functions

    Common Errors

    GetFeatureSlot()

    System::Boolean GetFeatureSlot(		
    	System::Int64 feature_id,
    	[System::Runtime::InteropServices::Out] System::Int64 %profile_id,
    	[System::Runtime::InteropServices::Out] System::Int64 %start_id,
    	[System::Runtime::InteropServices::Out] System::Int64 %end_id,
    	[System::Runtime::InteropServices::Out] double %depth,
    	[System::Runtime::InteropServices::Out] double %x,
    	[System::Runtime::InteropServices::Out] double %y,
    	[System::Runtime::InteropServices::Out] double %z
    	);
    

    The GetFeatureSlot() function returns the parameters of a slot feature or zero if it is not this kind of feature. A slot defines material that is to be removed from the inside of a part. A slot is similar to an open rectangular pocket, but a slot is supposed to be machined with special tooling. Like an open pocket, a slot defined by a profile. A slot has ends that can be open or closed.

    The z direction of the axis of the feature is returned by the GetFeatureAxisDirection function. The x direction of the axis of the feature is returned by the GetFeatureAxisRefDirection function. The origin of the axis is returned by the function and can also be accessed using the GetFeatureAxisOrigin function.

    Arguments

    feature_id
    The identity of the open rectangular pocket feature.
    profile_id
    [out] 0 if this is not a slot otherwise the id of the square u profile that defines the pocket. The function GetFeatureProfileSquareU must be used to decode the parameters of the profile.
    start_id
    [out] Identity of the first end of the slot. The function GetSlotEnd must be used to decode the parameters.
    end_id
    [out]Identity of the second end of the slot .
    depth
    [out] Depth of the slot
    x, y, z
    [out] Origin of the bottom of the slot.

    Related Functions

    Common Errors

    GetFeatureSlotEnd()

    System::String^ GetFeatureSlotEnd(	
    	System::Int64 end_id,
    	[System::Runtime::InteropServices::Out] double %first_radius,
    	[System::Runtime::InteropServices::Out] double %second_radius
    	);
    

    The GetFeatureSlotEnd() function returns the parameters describing the end of a slot feature. A slot defines material that is to be removed from the inside of a part. A slot is similar to an open rectangular pocket, but a slot is machined with special tooling. Like an open pocket it is mostly defined by a square u profile. A slot has ends that can be open or closed. The function returns a string describing the type of the slot:

    Arguments

    slot_end_id
    The identity of the slot end (first or second).
    first_radius
    [out] Used for flat and woodruff slots
    second_radius
    [out] Used for flat slots only

    Related Functions

    Common Errors

    GetFeatureStep()

    System::Boolean GetFeatureStep(		
    	System::Int64 fe_id,
    	[System::Runtime::InteropServices::Out] System::Int64 %profile_id,
    	[System::Runtime::InteropServices::Out] double %profile_angle,
    	[System::Runtime::InteropServices::Out] double %profile_radius,
    	[System::Runtime::InteropServices::Out] double %tilt_angle,
    	[System::Runtime::InteropServices::Out] double %depth,
    	[System::Runtime::InteropServices::Out] double %x,
    	[System::Runtime::InteropServices::Out] double %y,
    	[System::Runtime::InteropServices::Out] double %z
    	);
    

    The GetFeatureStep() function returns the parameters of a step feature or zero if it is not this kind of feature.

    GetFeatureType()

    System::String^ GetFeatureType(		
    	System::Int64 feature_id
    	);
    

    The GetFeatureType() function returns a string describing the type of a feature. Features are divided into milling features, turning features and transition features. Some of the names cover multiple types of features. For example there are multiple types of open and closed pockets each with their own get function. The string “unknown” is returned if no type is found. The following type names are returned for the milling features.

    The following type name is returned for a non-specific feature.

    The following type names are returned for the turning features.

    The following type names are returned for the transition features.

    Arguments

    feature_id
    The identity of a feature.

    Common Errors

    GetFeatureTemplate()

    System::String^ GetFeatureTemplate(		
    	System::Int64 placed_id
    	);
    

    The GetFeatureTemplate() function returns the identity of the template that describes a placed feature. Two types of features are supported in the system: instanced features and template features. An instanced feature is a complete definition and a template feature is a template that can be placed at multiple locations. Template features save space when there are many instances of the same feature. Most functions in the DLL will process both instance features and templates features and go to the underlying template data for a placed feature automatically when necessary. The GetFeatureTemplate() function gets the identity of the underlying template explicitly so that the template can be modified. The function returns 0 if the given feature is not a placed feature.

    Arguments

    placed_id
    The identity of a placed feature.

    Related Functions

    Common Errors

    GetFinalpieceCount/Next()

    System::Int64 GetFinalpieceCount();	
    
    System::Int64 GetFinalpieceNext(
    	System::Int64 index
    	);
    

    The GetFinalpieceCount() function returns a count of the number of finalpieces in the project. A final workpiece is a product that is being made by a project. There may be more than one of these pieces.

    The GetFinalpieceNext() function iterates over the final workpieces of a project and returns the one at the given index.

    Arguments

    index
    The index of the desired workpiece.

    Related Functions

    Common Errors

    GetFunctionDisplayMessage()

    System::String^ GetFunctionDisplayMessage(	
    	System::Int64 exe_id
    	);
    
    string GetFunctionDisplayMessage(		
    	long id
    	);
    

    The GetFunctionDisplayMessage() function returns a string containing the message in an "display message" NC function. A display message function tells the CNC to display a message to the operator and is closely related to the PPRINT command of APT.

    Arguments

    exe_id
    The identity of the executable that is the display function.

    Related Functions

    Common Errors

    GetFunctionExtendedNcDescription()

    System::String^ GetFunctionExtendedNcDescription(	
    	System::Int64 eid
    	);
    
    string GetFunctionExtendedNcDescription(			
    	long id
    	);
    

    The GetFunctionExtendedNcDescription() function returns a string describing the contents of an extended NC function. An extended NC function is used to describe the CNC functionality that is not yet part of the AP-238 standard.

    Arguments

    exe_id
    The identity of the extended NC function.

    Related Functions

    Common Errors

    GetFunctionIndexTable()

    System::Int64 GetFunctionIndexTable(	
    	System::Int64 exe_id
    	);
    

    The GetFunctionIndexTable() function returns an integer describing the value of the index. The Index Table NC function is used to define an index value for an index table on the CNC machine.

    Arguments

    exe_id
    The identity of the Index table function in the STEP-NC program.

    Related Functions

    Common Errors

    GetJSONGeometry()

    System::String^ GetJSONGeometry(	
    	System::String^ uuid, 
    	System::Int64 usage
    	);
    
    string GetJSONGeometry(			
    	string uuid,
    	int usage
    	);
    

    The GetJSONGeometry() function returns a JSON object representing the geometry that is associated with the given uuid and type.

    Arguments

    uuid
    The uuid of the entity that the geometry is needed for.
    usage
    The geometry type in integer form.

    Related Functions

    Common Errors

    GetJSONProduct()

    System::String^ GetJSONProduct(		
    	System::Int64 eid
    	);
    
    string GetJSONProduct(			
    	int eid
    	);
    

    The GetJSONProduct() function returns a JSON object representing the product that is associated with the given eid.

    Arguments

    e_id
    The id of the entity that the geometry is needed for.

    Related Functions

    Common Errors

    GetMachineParametersFeedrate() and Unit

    double GetMachineParametersFeedrate(		
    	System::Int64 wp_id
    	);
    
    System::String^ GetMachineParamatersFeedrateUnit(
    	System::Int64 wp_id
    	);
    

    The GetMachineParametersFeedrate() function returns the maximum feedrate that the machine must be able to support in order to properly execute a given workplan. The function returns zero if a value has not been set for this workplan.

    The GetMachineParamatersFeedrateUnit() function returns the string name of the feedrate unit, or “none” if a value has not been set.

    Arguments

    wp_id
    The identity of the workplan.

    Related Functions

    Common Errors

    GetMachineParametersMachineName()

    System::String^ GetMachineParametersMachineName(		
    	System::Int64 wp_id,
    	[System::Runtime::InteropServices::Out] System::Boolean %value_set
    	);
    

    The GetMachineParametersMachineName() function returns the name of the machine assumed by a given workplan.

    Arguments

    wp_id
    The identity of the workplan.

    Related Functions

    Common Errors

    GetMachineParametersSpindlePower() and Unit

    double GetMachineParametersSpindlePower(		
    	System::Int64 wp_id
    	);
    
    System::String^ GetMachineParametersSpindlePowerUnit(
    	System::Int64 wp_id
    	);
    

    The GetMachineParametersSpindlePower() function returns the maximum spindle power that the machine must be able to deliver in order to be able to execute a given workplan. The function returns zero if a value has not been set for this workplan.

    The GetMachineParametersSpindlePowerUnit() function returns the string name of the power unit. The supported units are “watt”, “kw” and “hp”. The return value is “none” if the value has not been set for this workplan.

    Arguments

    wp_id
    The identity of the workplan.

    Related Functions

    Common Errors

    GetMachineParametersSpindleSpeed() and Unit

    double GetMachineParametersSpindleSpeed(		
    	System::Int64 wp_id
    	);
    
    System::String^ GetMachineParametersSpindleSpeedUnit(
    	System::Int64 wp_id
    	);
    

    The GetMachineParametersSpindleSpeed() function returns the maximum spindle speed that the machine must be able to deliver in order to be able to execute a given workplan. The function returns zero if a value has not been set for this workplan.

    The GetMachineParametersSpindleSpeedUnit() function returns the string name of the rotational speed unit, or “none” if a value has not been set.

    Arguments

    wp_id
    The identity of the workplan.

    Related Functions

    Common Errors

    GetMachineParametersSpindleTorque() and Unit

    double GetMachineParametersSpindleTorque(		
    	System::Int64 wp_id
    	);
    
    System::String^ GetMachineParametersSpindleTorqueUnit(
    	System::Int64 wp_id
    	);
    

    The GetMachineParametersSpindleTorque() function returns the maximum spindle torque that the machine must be able to deliver in order to be able to execute a given workplan. The function returns zero if a value has not been set for this workplan.

    The GetMachineParametersSpindleTorqueUnit() function returns the string name of the torque unit. Supported units are “newton meter”, and “pound foot”, or “none” if the value has not been set for this workplan.

    Arguments

    wp_id
    The identity of the workplan.

    Related Functions

    Common Errors

    GetMainWorkplan()

    System::Int64 GetMainWorkplan();	
    
    int GetMainWorkplan();			
    

    The GetMainWorkplan() function returns the identity of the main workplan, which is the root executable of a STEP-NC program. Like the main function in a C program, the main workplan is the place where the system starts to execute the program.

    Related Functions

    Common Errors

    GetMaterialName()

    System::String^ GetMaterialName(	
    	System::Int64 wp_id
    	);
    
    string GetMaterialName(			
    	int wp_id
    	);
    

    The GetMaterialName() function returns the name of the material used for the workpiece. The material can be set using the Material function of the Process object.

    Arguments

    wp_id
    Identity of the workpiece

    Related Functions

    Common Errors

    GetNestedExecutableCount/Next/All/AllEnabled()

    System::Int64 GetNestedExecutableCount(		
    	System::Int64 exe_id
    	);
    System::Int64 GetNestedExecutableNext(
    	System::Int64 wp_id,
    	System::Int64 index
    	);
    System::Collections::Generic::List<System::Int64>^ GetNestedExecutableAll(
    	System::Int64 wp_id
    	);
    System::Collections::Generic::List<System::Int64>^ GetNestedExecutableAllEnabled(
    	System::Int64 wp_id
    	);
    
    
    int GetNestedExecutableCount(			
    	int exe_id
    	);
    int GetNestedExecutableNext(
    	int exe_id,
    	int index
    	);
    int[] GetNestedExecutableAll(
    	int wp_id
    	);
    int[] GetNestedExecutableAllEnabled(
    	int wp_id
    	);
    

    The GetNestedExecutableCount() function returns a count of the number of executables contained in a Workplan, Selective or Parallel. An executable is something that is executed. Workplans, Selectives and Parallels contain lists of other executables. There are mulitple types of executables. The NC functions are executables and Workingsteps are executables.

    A workplan contains a list of executables that are to be executed in sequence.

    A selective contains a list of executables only one of which is to be executed. The chosen one will have its enabled flag set.

    A parallel contains a list of executables that are to be executed at the same time.

    The GetNestedExecutableNext() function iterates over the executables and returns the one at a given index.

    The GetNestedExecutableAll() function returns all the nested executables in a workplan, selective or parallel.

    The GetNestedExecutableAllEnabled() function returns all the enabled executables in a workplan, selective or parallel. For a selective this should be one but may be more if the user has not yet chosen which nested executable is to be selected.

    Arguments

    exe_id
    The identity of the executable that contains the list.
    index
    The index of the requested member.

    Related Functions

    Common Errors

    GetOperationBoring()

    System::Boolean GetOperationBoring(		
    	System::Int64 ws_id,
    	[System::Runtime::InteropServices::Out] double %cutting_depth,
    	[System::Runtime::InteropServices::Out] double %dwell_time_bottom,
    	[System::Runtime::InteropServices::Out] double %feed_on_retract,
    	[System::Runtime::InteropServices::Out] double %previous_diameter,
    	[System::Runtime::InteropServices::Out] double %waiting_x,
    	[System::Runtime::InteropServices::Out] double %waiting_y,
    	[System::Runtime::InteropServices::Out] double %waiting_z,
    	[System::Runtime::InteropServices::Out] double %depth_of_test_cut
    	);
    

    The GetOperationBoring() function returns the parameters of a boring operation and returns false if the workingstep does not contain this type of operation.

    Arguments

    ws_id
    The identity of the workingstep.
    cutting_depth
    [out] See ISO 14649-11 for documentation on these parameters
    dwell_time_bottom
    [out]
    feed_on_retract
    [out]
    previous_diameter
    [out]
    waiting_x
    [out]
    waiting_y
    [out]
    waiting_z
    [out]
    depth_of_test_cut
    [out]

    Related Functions

    Common Errors

    GetOperationDrilling()

    System::Boolean GetOperationDrilling(		
    	System::Int64 ws_id,
    	[System::Runtime::InteropServices::Out] double %cutting_depth,
    	[System::Runtime::InteropServices::Out] double %dwell_time_bottom,
    	[System::Runtime::InteropServices::Out] double %feed_on_retract,
    	[System::Runtime::InteropServices::Out] double %previous_diameter
    	);
    

    The GetOperationDrilling() function returns the parameters of a drilling operation and returns false if the workingstep does not contain this type of operation.

    Arguments

    ws_id
    The identity of the workingstep.
    cutting_depth
    [out] See ISO 14649-11 for documentation on these parameters
    dwell_time_bottom
    [out]
    feed_on_retract
    [out]
    previous_diameter
    [out]

    Related Functions

    Common Errors

    GetOperationDrillingStrategy()

    System::Boolean GetOperationDrillingStrategy(		
    	System::Int64 ws_id,
    	[System::Runtime::InteropServices::Out] double %reduced_cut_at_start,
    	[System::Runtime::InteropServices::Out] double %reduced_feed_at_start,
    	[System::Runtime::InteropServices::Out] double %depth_of_start,
    	[System::Runtime::InteropServices::Out] double %reduced_cut_at_end,
    	[System::Runtime::InteropServices::Out] double %reduced_feed_at_end,
    	[System::Runtime::InteropServices::Out] double %depth_of_end
    	);
    

    The GetOperationDrillingStrategy() function returns the parameters of the drilling strategy associated with a drilling operation and returns false if the workingstep does not contain this type of operation. A drilling strategy object can be attached to any type of drilling operation. The strategy object describes additional information that can be used to fine tune the drilling operation.

    Arguments

    ws_id
    The identity of the workingstep.
    reduced_cut_at_start
    [out] See ISO 14649-11 for documentation on these parameters
    reduced_feed_at_start
    [out]
    depth_of_start
    [out]
    reduced_cut_at_end
    [out]
    reduced_feed_at_start
    [out]
    depth_of_end
    [out]

    Related Functions

    Common Errors

    GetOperationDrillingStrategyEnd()

    System::Boolean GetOperationDrillingStrategyEnd(		
    	System::Int64 ws_id,
    	[System::Runtime::InteropServices::Out] double %reduced_cut_at_end,
    	[System::Runtime::InteropServices::Out] double %reduced_feed_at_end,
    	[System::Runtime::InteropServices::Out] double %depth_of_end
    	);
    

    The GetOperationDrillingStrategyEnd() function returns the parameters of the drilling strategy for the end of a hole associated with a drilling operation and returns false if the workingstep does not contain this type of operation. The parameters of a drilling strategy object can be divided into those that describe information about the start of the hole and those that describe information about the end. This function returns the information defined for the end.

    Arguments

    ws_id
    The identity of the workingstep.
    reduced_cut_at_end
    [out] See ISO 14649-11 for documentation on these parameters
    reduced_feed_at_start
    [out]
    depth_of_start
    [out]

    Related Functions

    Common Errors

    GetOperationDrillingStrategyParameterStatus()

    System::Boolean GetOperationDrillingStrategyParameterStatus(		
    	System::Int64 ws_id,
    	[System::Runtime::InteropServices::Out] System::Int64 %reduced_cut_at_start,
    	[System::Runtime::InteropServices::Out] System::Int64 %reduced_feed_at_start,
    	[System::Runtime::InteropServices::Out] System::Int64 %depth_of_start,
    	[System::Runtime::InteropServices::Out] System::Int64 %reduced_cut_at_end,
    	[System::Runtime::InteropServices::Out] System::Int64 %reduced_feed_at_end,
    	[System::Runtime::InteropServices::Out] System::Int64 %depth_of_end
    	);
    

    The GetOperationDrillingStrategyParameterStatus() function sets the [out] values to 1 to show which attributes of a strategy have been set. The parameters of the drilling stratey object are all optional.

    Arguments

    ws_id
    The identity of the workingstep.
    reduced_cut_at_start
    [out] 1 if set 0 otherwise.
    reduced_feed_at_start
    [out] 1 if set 0 otherwise.
    depth_of_start
    [out] 1 if set 0 otherwise.
    reduced_cut_at_end
    [out] 1 if set 0 otherwise.
    reduced_feed_at_start
    [out] 1 if set 0 otherwise.
    depth_of_start
    [out] 1 if set 0 otherwise.

    Related Functions

    Common Errors

    GetOperationDrillingStrategyStart()

    System::Boolean GetOperationDrillingStrategyStart(		
    	System::Int64 ws_id,
    	[System::Runtime::InteropServices::Out] double %reduced_cut_at_start,
    	[System::Runtime::InteropServices::Out] double %reduced_feed_at_start,
    	[System::Runtime::InteropServices::Out] double %depth_of_start
    	);
    

    The GetOperationDrillingStrategyStart() function returns the parameters of the drilling strategy for the start of a hole associated with a drilling operation and returns false if the workingstep does not contain this type of operation. The parameters of a drilling strategy object can be divided into those that describe information about the start of the hole and those that describe information about the end.

    Arguments

    ws_id
    The identity of the workingstep.
    reduced_cut_at_end
    [out] See ISO 14649-11 for documentation on these parameters
    reduced_feed_at_start
    [out]
    depth_of_start
    [out]

    Related Functions

    Common Errors

    GetOperationMilling()

    System::Boolean GetOperationMilling(		
    	System::Int64 ws_id,
    	[System::Runtime::InteropServices::Out] double %bottom_allowance,
    	[System::Runtime::InteropServices::Out] double %side_allowance,
    	[System::Runtime::InteropServices::Out] double %axial_depth,
    	[System::Runtime::InteropServices::Out] double %radial_depth
    	);
    

    The GetOperationMilling() function returns the common parameters of milling operations and returns false if the workingstep does not contain this type of operation. Toolpaths are optional for a milling operation described by parameters. If no toolpaths are given then the CNC control is expected to generate the necessary toolpaths at run time.

    For a more detailed description see GetOperationMillingBottom, GetOperationMillingSide, and GetOperationMillingBottomAndSide.

    Arguments

    ws_id
    The identity of the workingstep.
    bottom_allowance
    [out] The allowance to be left at the bottom of the feature.
    side_allowance
    [out] The allowance to be left on the side of the feature.
    axial_depth
    [out] The depth of material to be removed in each pass.
    radial_depth
    [out] The radial overlap of the tool during the cutting.

    Related Functions

    Common Errors

    GetOperationMillingBottom()

    System::Boolean GetOperationMillingBottom(		
    	System::Int64 ws_id,
    	[System::Runtime::InteropServices::Out] double %bottom_allowance,
    	[System::Runtime::InteropServices::Out] double %axial_depth
    	);
    

    The GetOperationMillingBottom() function returns the parameters of a bottom milling operation and returns false if the workingstep does not contain this type of operation. A bottom milling operation is also known as a planar face milling operation. Toolpaths are optional for a milling operation described by parameters. If no toolpaths are given then the CNC control is expected to generate the necessary toolpaths at run time.

    Arguments

    ws_id
    The identity of the workingstep.
    bottom_allowance
    [out] The allowance to be left at the bottom of the feature.
    axial_depth
    [out] The depth of material to be removed in each pass.

    Related Functions

    Common Errors

    GetOperationMillingBottomAndSide()

    System::Boolean GetOperationMillingBottomAndSide(		
    	System::Int64 ws_id,
    	[System::Runtime::InteropServices::Out] double %bottom_allowance,
    	[System::Runtime::InteropServices::Out] double %side_allowance,
    	[System::Runtime::InteropServices::Out] double %axial_depth,
    	[System::Runtime::InteropServices::Out] double %radial_depth
    	);
    

    The GetOperationMillingBottomAndSide() function returns the parameters of a bottom and side milling operation, also known as a pocket milling operation, and returns false if the workingstep does not contain this type of operation. Toolpaths are optional for a milling operation described by parameters. If no toolpaths are given then the CNC control is expected to generate the necessary toolpaths at run time.

    Arguments

    ws_id
    The identity of the workingstep.
    bottom_allowance
    [out] The allowance to be left at the bottom of the feature.
    side_allowance
    [out] The allowance to be left on the side of the feature.
    axial_depth
    [out] The depth of material to be removed in each pass.
    radial_depth
    [out] The radial overlap of the tool during the cutting.

    Related Functions

    Common Errors

    GetOperationMillingFreeform()

    System::Int64 GetOperationMillingFreeform(		
    	System::Int64 ws_id
    	);
    

    The GetOperationMillingFreeform() function returns the parameters of a freeform milling operation and returns false if the workingstep does not contain this type of operation. Freeform operations do not have any parameter data and are described by tool paths only.

    Arguments

    ws_id
    The identity of the workingstep.

    Related Functions

    Common Errors

    GetOperationMillingSide()

    System::Boolean GetOperationMillingSide(		
    	System::Int64 ws_id,
    	[System::Runtime::InteropServices::Out] double %side_allowance,
    	[System::Runtime::InteropServices::Out] double %axial_depth,
    	[System::Runtime::InteropServices::Out] double %radial_depth
    	);
    

    The GetOperationMillingSide() function returns the parameters of a side milling operation, also known as a profiling operation, and returns false if the workingstep does not contain this type of operation. Toolpaths are optional for a milling operation described by parameters. If no toolpaths are given then the CNC control is expected to generate the necessary toolpaths at run time.

    Arguments

    ws_id
    The identity of the workingstep.
    side_allowance
    [out] The allowance to be left on the side of the feature.
    axial_depth
    [out] The depth of material to be removed in each pass.
    radial_depth
    [out] The radial overlap of the tool during the cutting.

    Related Functions

    Common Errors

    GetOperationMillingStrategyApproach Functions

    System::Boolean GetOperationMillingStrategyApproachAirAngle(		
    	System::Int64 ws_id,
    	[System::Runtime::InteropServices::Out] double %angle,
    	[System::Runtime::InteropServices::Out] double %travel_length
    	);
    
    System::Boolean GetOperationMillingStrategyApproachAirTangent(
    	System::Int64 ws_id,
    	[System::Runtime::InteropServices::Out] double %radius
    	);
    
    System::Boolean GetOperationMillingStrategyApproachPlungeHelix(
    	System::Int64 ws_id,
    	[System::Runtime::InteropServices::Out] double %radius,
    	[System::Runtime::InteropServices::Out] double %angle
    	);
    
    System::Boolean GetOperationMillingStrategyApproachPlungeRamp(
    	System::Int64 ws_id,
    	[System::Runtime::InteropServices::Out] double %angle
    	);
    
    System::Boolean GetOperationMillingStrategyApproachPlungeToolaxis(
    	System::Int64 ws_id
    	);
    
    System::Boolean GetOperationMillingStrategyApproachPlungeZigzag(
    	System::Int64 ws_id,
    	[System::Runtime::InteropServices::Out] double %angle,
    	[System::Runtime::InteropServices::Out] double %width
    	);
    

    These milling strategy functions return the parameters of an approach stategy for a milling operation. Each function has a boolean return value that is true if the workingstep contains that particular type of strategy or operation. The approach strategy is a CAM-level set of parameters that describes how the tool moves from the retract plane to the start point of the operation. The available functions and the paths that they describe are summarized below

    GetOperationMillingStrategyApproachAirAngle() A path along the given angle of approach for a given travel distance. The travel distance is the hypotenuse of the triangle.
    GetOperationMillingStrategyApproachAirTangent() A path along an arc with a given radius, starting with motion along the tool axis and ending with motion tangential to the arc.
    GetOperationMillingStrategyApproachPlungeHelix() A helical path with the given angle of approach and radius.
    GetOperationMillingStrategyApproachPlungeRamp() A linear path with the given angle of approach.
    GetOperationMillingStrategyApproachPlungeToolaxis() A linear path along the axis of the tool.
    GetOperationMillingStrategyApproachPlungeZigzag() A path that zig-zags back and forth with the given angle of approach and width.

    Arguments

    ws_id
    The identity of the workingstep.
    angle
    [out] An angle measured from the plane perpendicular to the tool axis. Used by air angle. plunge ramp, helix, and zigzag strategies.
    radius
    [out] Radius of an arc or helix. Used by air tangent and plunge helix strategies.
    travel_length
    [out] Travel distance along an angled path. Used by air angle, plunge ramp, helix, and zigzag strategies.
    width
    [out] Horizontal distance measured in the plane perpendicular to the tool axis. Used by the plunge zigzag stategy.

    Related Functions

    Common Errors

    GetOperationMillingStrategyRetract Functions

    System::Boolean GetOperationMillingStrategyRetractAirAngle(		
    	System::Int64 ws_id,
    	[System::Runtime::InteropServices::Out] double %angle,
    	[System::Runtime::InteropServices::Out] double %travel_length
    	);
    
    System::Boolean GetOperationMillingStrategyRetractAirTangent(
    	System::Int64 ws_id,
    	[System::Runtime::InteropServices::Out] double %radius
    	);
    
    System::Boolean GetOperationMillingStrategyRetractPlungeHelix(
    	System::Int64 ws_id,
    	[System::Runtime::InteropServices::Out] double %radius,
    	[System::Runtime::InteropServices::Out] double %angle
    	);
    
    System::Boolean GetOperationMillingStrategyRetractPlungeRamp(
    	System::Int64 ws_id,
    	[System::Runtime::InteropServices::Out] double %angle
    	);
    
    System::Boolean GetOperationMillingStrategyRetractPlungeToolaxis(
    	System::Int64 ws_id
    	);
    
    System::Boolean GetOperationMillingStrategyRetractPlungeZigzag(
    	System::Int64 ws_id,
    	[System::Runtime::InteropServices::Out] double %angle,
    	[System::Runtime::InteropServices::Out] double %width
    	);
    

    These milling strategy functions return the parameters of a retract stategy for a milling operation. Each function has a boolean return value that is true if the workingstep contains that particular type of strategy or operation. The retract strategy is a CAM-level set of parameters that describes how the tool moves from the part back to the retract plane of the operation. The available functions and the paths that they describe are summarized below:

    GetOperationMillingStrategyRetractAirAngle()
    A path along the given angle of retract for a given travel distance. The travel distance is the hypotenuse of the triangle.
    GetOperationMillingStrategyRetractAirTangent()
    A path along an arc with a given radius, starting with motion tangential to the arc and ending with motion along the tool axis.
    GetOperationMillingStrategyRetractPlungeHelix()
    A helical path with the given angle of retract and radius.
    GetOperationMillingStrategyRetractPlungeRamp()
    A linear path with the given angle of retract.
    GetOperationMillingStrategyRetractPlungeToolaxis()
    A linear path along the axis of the tool.
    GetOperationMillingStrategyRetractPlungeZigzag()
    A path that zig-zags back and forth with the given angle of retract and width.

    Arguments

    ws_id
    The identity of the workingstep.
    angle
    [out] An angle measured from the plane perpendicular to the tool axis. Used by air angle. plunge ramp, helix, and zigzag strategies.
    radius
    [out] Radius of an arc or helix. Used by air tangent and plunge helix strategies.
    travel_length
    [out] Travel distance along an angled path. Used by air angle, plunge ramp, helix, and zigzag strategies.
    width
    [out] Horizontal distance measured in the plane perpendicular to the tool axis. Used by the plunge zigzag stategy.

    Related Functions

    Common Errors

    GetOperationMillingStrategyTwo5d Functions()

    System::Boolean GetOperationMillingStrategyTwo5dBidirectional(		
    	System::Int64 ws_id
    	);
    
    System::Boolean GetOperationMillingStrategyTwo5dBidirectionalContour(
    	System::Int64 ws_id
    	);
    
    System::Boolean GetOperationMillingStrategyTwo5dCenterMilling(
    	System::Int64 ws_id
    	);
    
    System::Boolean GetOperationMillingStrategyTwo5dContourBidirectional(
    	System::Int64 ws_id
    	);
    
    System::Boolean GetOperationMillingStrategyTwo5dContourParallel(
    	System::Int64 ws_id
    	);
    
    System::Boolean GetOperationMillingStrategyTwo5dContourSpiral(
    	System::Int64 ws_id
    	);
    
    System::Boolean GetOperationMillingStrategyTwo5dExplicitStrategy(
    	System::Int64 ws_id
    	);
    
    System::Boolean GetOperationMillingStrategyTwo5dUnidirectional(
    	System::Int64 ws_id
    	);
    

    The milling strategy functions above return a boolean value indicating whether an operation has a particular type of 2.5D milling strategy. The cutting strategy is a CAM-level set of parameters that describes how to generate toolpaths for an operation. The parameters that apply to each type of strategy are listed below and the "Parameter Functions" listed below each return a single parameter

    GetOperationMillingStrategyTwo5dBidirectional()
    A Bi-directional milling strategy cuts in a zigzag manner, starting in the feed direction and going back and forth, and moving along the stepover direction at the end of a pass. Cutting alternates between climb and conventional. Parameters: feed direction, stepover direction, stroke connection.
    GetOperationMillingStrategyTwo5dBidirectionalContour()
    A Bi-directional milling strategy as describe above, to mill the area of a feature, with a final contour pass around the perimiter of the feature. Parameters: feed direction, stepover direction, rotation direction for the final contour, and spiral cutmode describing whether the final cutmode is climb or conventional.
    GetOperationMillingStrategyTwo5dCenterMilling()
    A Center milling strategy sescribes a cut along the center of a feature. It has no additional parameters.
    GetOperationMillingStrategyTwo5dContourBidirectional()
    A contour pass around the perimiter of the feature followed by a bi-directional milling strategy to mill the area of a feature. Parameters: feed direction, stepover direction, rotation direction for the final contour, and spiral cutmode describing whether the contour cutmode is climb or conventional.
    GetOperationMillingStrategyTwo5dContourParallel()
    Multiple contour passes following the perimiter of the feature. Each pass is a complete contour with an explict stepover at the end. Parameters: rotation direction and a cutmode indicating climb or conventional.
    GetOperationMillingStrategyTwo5dContourSpiral()
    A single contour pass following the perimiter of the feature that spirals to cover the entire feature area. Parameters: rotation direction and a cutmode indicating climb or conventional.
    GetOperationMillingStrategyTwo5dExplicitStrategy()
    An explicit milling strategy has no parameters and is used when the milling is described explicitly by a toolpath.
    GetOperationMillingStrategyTwo5dUnidirectional()
    A Unidirectional milling strategy cuts in a linear manner then lifts and returns to the starting point for the next pass. Parameters: feed direction and and a cutmode indicating climb or conventional.

    Parameter Functions

    System::String^ GetOperationMillingStrategyTwo5dCutmode(		
    	System::Int64 ws_id
    	);
    
    System::Boolean GetOperationMillingStrategyTwo5dFeedDirection(
    	System::Int64 ws_id,
    	[System::Runtime::InteropServices::Out] double %fi,
    	[System::Runtime::InteropServices::Out] double %fj,
    	[System::Runtime::InteropServices::Out] double %fk
    	);
    
    System::String^ GetOperationMillingStrategyTwo5dRotationDirection(
    	System::Int64 ws_id
    	);
    
    System::String^ GetOperationMillingStrategyTwo5dStepoverDirection(
    	System::Int64 ws_id
    	);
    
    System::String^ GetOperationMillingStrategyTwo5dStrokeConnection(
    	System::Int64 ws_id
    	);
    

    These milling strategy parameter functions return values describing a aspects of the milling cutting stategy for a milling operation. All strategies have an overlap ratio parameter and the allow multiple passes flag.

    GetOperationMillingStrategyTwo5dCutmode()
    The value for the cutmode is “climb”, “conventional”, or “unset” if the information is not defined. This is used by bidirectional contour, contour bidirectional, contour parallel, contour spiral, and unidirectional strategies.
    GetOperationMillingStrategyTwo5dFeedDirection>()
    Returns a flag showing if the three components of the direction vector has been set for this strategy object. The three out parameters fi, fj, and fk are the i/j/k direction components of the feed direction. This parameter is used by bidirectional, bidirectional contour, contour bidirectional, and unidirectional strategies.
    GetOperationMillingStrategyTwo5dRotationDirection()
    Returns the string value “cw”, “ccw”, or “unset” for the rotation direction. This parameter is used by all of the stategies that include a contour milling component.
    GetOperationMillingStrategyTwo5dStepoverDirection()
    Returns “left”, “right”, or “unset” which describes the stepover direction relative to the feed direction. This parameter is used by all of the strategies that include a bidirectional milling component.
    GetOperationMillingStrategyTwo5dStrokeConnection()
    Returns “straight line”, “lift shift plunge”, “degouge”, “loop back”, or “unset” for that describes the behavior when connecting strokes in plain bidirectional milling (not the contour variants).

    Related Functions

    Common Errors

    GetOperationMultistepDrilling()

    System::Boolean GetOperationMultistepDrilling(		
    	System::Int64 ws_id,
    	[System::Runtime::InteropServices::Out] double %cutting_depth,
    	[System::Runtime::InteropServices::Out] double %dwell_time_bottom,
    	[System::Runtime::InteropServices::Out] double %feed_on_retract,
    	[System::Runtime::InteropServices::Out] double %previous_diameter,
    	[System::Runtime::InteropServices::Out] double %depth_of_step,
    	[System::Runtime::InteropServices::Out] double %first_depth,
    	[System::Runtime::InteropServices::Out] double %retract_distance,
    	[System::Runtime::InteropServices::Out] double %dwell_time_step
    	);
    

    The GetOperationMultistepDrilling() function returns the parameters of a multi-step drilling operation and returns false if the workingstep does not contain this type of operation.

    Arguments

    ws_id
    The identity of the workingstep.
    cutting_depth
    [out] See ISO 14649-11 for documentation on these parameters
    dwell_time_bottom
    [out]
    feed_on_retract
    [out]
    previous_diameter
    [out]
    depth_of_step
    [out]
    first_depth
    [out]
    retract_distance
    [out]
    dwell_time_step
    [out]

    Related Functions

    Common Errors

    GetOperationReaming()

    System::Boolean GetOperationReaming(		
    	System::Int64 ws_id,
    	[System::Runtime::InteropServices::Out] double %cutting_depth,
    	[System::Runtime::InteropServices::Out] double %dwell_time_bottom,
    	[System::Runtime::InteropServices::Out] double %feed_on_retract,
    	[System::Runtime::InteropServices::Out] double %previous_diameter,
    	[System::Runtime::InteropServices::Out] double %waiting_x,
    	[System::Runtime::InteropServices::Out] double %waiting_y,
    	[System::Runtime::InteropServices::Out] double %waiting_z,
    	[System::Runtime::InteropServices::Out] double %depth_of_test_cut
    	);
    

    The GetOperationReaming() function returns the parameters of a reaming operation and returns false if the workingstep does not contain this type of operation.

    Arguments

    ws_id
    The identity of the workingstep.
    cutting_depth
    [out] See ISO 14649-11 for documentation on these parameters
    dwell_time_bottom
    [out]
    feed_on_retract
    [out]
    previous_diameter
    [out]
    waiting_x
    [out]
    waiting_y
    [out]
    waiting_z
    [out]
    depth_of_test_cut
    [out]

    Related Functions

    Common Errors

    GetOperationTapping()

    System::Boolean GetOperationTapping(		
    	System::Int64 ws_id,
    	[System::Runtime::InteropServices::Out] double %cutting_depth,
    	[System::Runtime::InteropServices::Out] System::Int64 %chuck_required,
    	[System::Runtime::InteropServices::Out] double %dwell_time_bottom,
    	[System::Runtime::InteropServices::Out] double %feed_on_retract,
    	[System::Runtime::InteropServices::Out] double %previous_diameter
    	);
    

    The GetOperationTapping() function returns true with the parameters of a tapping operation and returns false if the workingstep does not contain this type of operation.

    Arguments

    ws_id
    The identity of the workingstep.
    cutting_depth
    [out] See ISO 14649-11 for documentation on these parameters
    chuck_required
    [out]
    dwell_time_bottom
    [out]
    feed_on_retract
    [out]
    previous_diameter
    [out]

    Related Functions

    Common Errors

    GetParallelExecutableCount/Next/All/AllEnabled()

    System::Int64 GetParallelExecutableCount(	
    	System::Int64 sl_id
    	);
     System::Int64 GetParallelExecutableNext(
    	 System::Int64 sl_id,
    	 System::Int64 index
    	 );
    System::Collections::Generic::List<System::Int64>^ GetParallelExecutableAll(
    	System::Int64 wp_id
    	);
    System::Collections::Generic::List<System::Int64>^ GetParallelExecutableAllEnabled(
    	System::Int64 wp_id
    	);
    
    
    
    int GetParallelExecutableCount(		
    	int sl_id
    	);
    int GetParallelExecutableNext(
    	int sl_id;
    	int index;
    	);
    int[] GetParallelExecutableAll(
    	int wp_id
    	);
    int[] GetParallelExecutableAllEnabled(
    	int wp_id
    	);
    

    The GetParallelExecutableCount() function returns a count of the number of executables contained in a Parallel. A parallel is a list of executables that are to be executed concurrently.

    The GetParalleExecutableNext() function returns the next executable in a Parallel using an index.

    The GetParallelExecutableAll() function returns the identity of all the nested executables in the parallel.

    The GetParallelExecutableAllEnabled() function returns the identity of the enabled executables in a parallel.

    Arguments

    sel_id
    The identity of the paralle that contains the list.
    index
    The index of the requested member.

    Related Functions

    Common Errors

    GetPathArc()

    void GetPathArc(					
    	System::Int64 curve_id,
    	[System::Runtime::InteropServices::Out] double %x,
    	[System::Runtime::InteropServices::Out] double %y,
    	[System::Runtime::InteropServices::Out] double %z,
    	[System::Runtime::InteropServices::Out] double %cx,
    	[System::Runtime::InteropServices::Out] double %cy,
    	[System::Runtime::InteropServices::Out] double %cz,
    	[System::Runtime::InteropServices::Out] double %radius,
    	[System::Runtime::InteropServices::Out] System::Boolean %ccw
    	);
    

    The GetPathArc() function returns the parameters that define an arc. These are the parameters set by the arc function of the ATPSTEPMaker object. The Related functions section below explains how to get to an arc from a workingstep.

    If the axis of the arc is not known to be in the XY plane then it can be found using the GetPathArcAxis function. This function returns the axis of the center of the arc, not the axis of the cutting tool.

    To get to an arc from a workingstep uses the following recipe:

    Arguments

    curve_id
    Identity of a curve segment in a tool path
    x, y, z
    [out] end point of the arc
    cx, cy, cz
    [out] coordinates of the arc center
    radius
    [out] radius of the arc’s circle
    ccw
    [out] true if counter clockwise, false if clockwise

    Related Functions

    Common Errors

    GetPathArcAxis()

    void GetPathArcAxis(				
    	System::Int64 curve_id,
    	[System::Runtime::InteropServices::Out] double %x,
    	[System::Runtime::InteropServices::Out] double %y,
    	[System::Runtime::InteropServices::Out] double %z,
    	[System::Runtime::InteropServices::Out] double %i,
    	[System::Runtime::InteropServices::Out] double %j,
    	[System::Runtime::InteropServices::Out] double %k
    	);
    

    The GetPathArcAxis() function returns the axis of the center of an arc. In most situations the axis will be known already because it is in the same plane as the end points and center of the arc. See GetPathArc for usage.

    Arguments

    curve_id
    Identity of the segment in a tool path
    x, y, z
    [out] end point of the arc
    ci, cj, ck
    [out] components of the axis z-direction.

    GetPathAreaCurveAll/Count/Next()

    System::Int64 GetPathAreaCurveCount(		
    	System::Int64 path_id
    	);
    
    System::Int64 GetPathAreaCurveNext(
    	System::Int64 path_id,
    	System::Int64 index
    	);
    
    System::Collections::Generic::List<System::Int64>^ GetPathAreaCurveAll(
    	System::Int64 path_id
    	);
    
    

    The GetPathAreaCurveCount() function returns the number of segments in a curve that describes the cross section of the area of intersection between the cutting tool and the workpiece. The purpose of this information is to allow an application to dynamically compute the best speeds and feeds required for a given cutting tool and material on the current machine.

    If a cross-section curve is present, this function must return the same value as GetPathCurveCount because the STEP-NC standard requires every curve to have the same parameterization.

    The GetPathAreaCurveNext() function iterates over the segments of the cross section area curve and returns the element at a given index. The GetPathCurveNext function can be used to get the corresponding geometry curve segments for each area curve.

    The GetPathAreaCurveAll() function returns all the curves in one function call and is therefore more efficient.

    Arguments

    path_id
    The identity of the cross section area curve.
    index
    Position of the requested segment in the cross section curve.

    Related Functions

    Common Errors

    GetPathAreaPolylinePointAll/Count/Next()

    System::Int64 GetPathAreaPolylinePointCount(		
    	System::Int64 curve_id
    	);
    
    System::String^ GetPathAreaPolylinePointNext(
    	System::Int64 curve_id,
    	System::Int64 index,
    	[System::Runtime::InteropServices::Out] double %RC_max,
    	[System::Runtime::InteropServices::Out] double %AC_max,
    	[System::Runtime::InteropServices::Out] double %X_offset,
    	[System::Runtime::InteropServices::Out] double %Y_offset,
    	[System::Runtime::InteropServices::Out] double %RD_max,
    	[System::Runtime::InteropServices::Out] double %RD_avg,
    	[System::Runtime::InteropServices::Out] double %RD_offset
    	);
    
    System::Collections::Generic::List<double>^ GetPathAreaPolylinePointAll (
    	System::Int64 curve_id
    	);
    

    The GetPathAreaPolylinePointCount() function returns the number of points in an area curve polyline. This number should be the same as GetPathPolylinePointCount for the corresponding segment in the geometry curve. Two functions are used because GetPathAreaPolyinePointNext returns seven values instead of the three delivered by GetPathPolylinePointNext.

    The GetPathAreaPolylinePointNext() function passes back the seven coordinates of the next point in a polyline segment belonging to a cross section area curve. The function returns the string “machining” to indicate a cross section was found or “air milling” to indicate that no cross section was found. If the cross section is “air milling” then all of the out parameters will be zero.

    The GetPathAreaPolylinePointAll() function passes back all the cross sections in a single function call. This function is much more efficient but it does not return the type of each point. The seven coordinates are encoded so that the first RC_max is at position 0, the second RC_max is at position 7 and so on.

    To get to a cross section area from a workingstep use the following recipe:

    Arguments

    curve_id
    The identity of the polyline curve.
    index
    Position of the requested segment in the polyline.
    RC_max
    [out] Maximum Radial Cross-Distance.
    AC_max
    [out] Maximum Axial Cross-Distance.
    X_offset
    [out] X Offset of Maximum RC/AC Origin.
    Y_offset
    [out] Y Offset of Maximum RC/AC Origin.
    RD_max
    [out] Maximum Radial Depth.
    RD_avg
    [out] Average Radial Depth.
    RD_offset
    [out] X Offset of Average Radial Depth.

    The following figure illustrates each of the seven parameters.

    Common Errors

    GetPathAxisAll/Count/Next()

    System::Int64 GetPathAxisCount(		
    	System::Int64 path_id
    	);
    
    System::Int64 GetPathAxisNext(
    	System::Int64 path_id,
    	System::Int64 index
    	);
    
    System::Collections::Generic::List<System::Int64>^ GetPathAxisAll(
    	System::Int64 path_id
    	);
    

    The GetPathAxisCount() function returns the number of axis segments in the tool axis curve. If the number is zero then the tool path is three-axis. If the number is non-zero then it should be the same value as GetPathCurveCount. In STEP-NC toolpath’s can be three-axis or five-axis. If they are five-axis then a vector of (i, j, k) components describing the axis direction is associated with each point of the tool path.

    The GetPathAxisNext() function returns the next segment in a tool axis curve, or zero if the index is out of range. If the tool path is five-axis then there should be one of these segements for each segment in the geometry curve. Each segment in the axis curve should be a Polyline. If the corresponding segment in the geometry curve is a polyline then both polylines should contain the same number of points. If the corresponding segment in the geometry curve is an arc then the axis curve segment should be a polyline containing two points one for the start of the arc and one for the end.

    The GetPathAxisAll() function returns all the axes in one function call and is therefore more efficient.

    Arguments

    path_id
    The identity of the five axis path.
    index
    Position of the requested curve segment in the path.

    Related Functions

    Common Errors

    GetPathAxisPolylinePointAll/Count/Next()

    System::Int64 GetPathAxisPolylinePointCount(		
    	System::Int64 curve_id
    	);
    
    void GetPathAxisPolylinePointNext(
    	System::Int64 curve_id,
    	System::Int64 index,
    	[System::Runtime::InteropServices::Out] double %i,
    	[System::Runtime::InteropServices::Out] double %j,
    	[System::Runtime::InteropServices::Out] double %k
    	);
    
    System::Collections::Generic::List<double>^ GetPathAxisPolylinePointAll(
    	System::Int64 curve_id
    	);
    
    

    The GetPathAxisPolylinePointCount() function returns the number of points in a polyline describing these components. The number should be the same as the number of points in the corresponding polyline for the toolpath or 2 if the corresponding segment of the toolpath is an arc. In STEP-NC toolpath’s can be three-axis or five-axis. If they are five-axis then a vector of (i, j, k) components describing the axis direction is associated with each point of the tool path.

    The GetPathAxisPolylinePointNext() function returns the next (i, j, k) component in a tool axis polyline.

    The GetPathAxisPolylinePointAll() function returns all the (i, j, k) components in a tool axis polyline in one function call. For large polylines this is much more efficient. The coordinates will be returned in i, j, k order with the first i at position 0, the second i at position 3 and so on.

    To get to an axis curve polyline (i, j, k) point from a workingstep uses the following recipe:

    Arguments

    curve_id
    The identity of the five axis polyline curve segment.
    index
    Position of the requested segment in the polyline.
    i,j,k
    [out] The value of the i,j,k components. To be a valid direction vector the value i * i + j * j + k * k should be 1.

    Related Functions

    Common Errors

    Get[Path]CurveAllCount/Next()

    System::Int64 GetPathCurveCount(		
    	System::Int64 path_id
    	);
    
    System::Int64 GetPathCurveNext(
    	System::Int64 path_id,
    	System::Int64 index,
    	[System::Runtime::InteropServices::Out] System::Boolean %is_arc
    	);
    
    System::Collections::Generic::List<System::Int64>^ GetPathCurveAll(
    	System::Int64 path_id
    	);
    
    System::Collections::Generic::List<System::Int64>^ GetCurveAll(
    	);
    

    The GetPathCurveCount() function returns the number of curve segments in a geometry curve. Each segment can be a polyline or an arc. If this is a five axis tool path then the GetPathAxisCount function should return the same result as this function. If not then GetPathAxisCount should return zero.

    The GetPathCurveNext() function returns the next segment in a geometry curve. In the current version of the API the segement must be a polyline or an arc. In future versions any of the bounded curve types allowed by STEP will be allowed including b-spline curve segments. If the tool path is five axis then the GetPathAxisNext function must be used to get the corresponding axis segments for each geometry curve segment.

    The GetPathCurveAll() function returns all the curves in one function call and is therefore more efficient. If the type of the curve cannot be assumed then it can be found using the GetPathCurveType function.

    The GetCurveAll() function returns all the curves in the project.

    Arguments

    path_id
    The identity of the geometry curve.
    index
    Position of the requested segment in the geometry curve.
    is_arc
    [out] Will be 1 if this segment contains an arc and 0 otherwise.

    Related Functions

    Common Errors

    GetPathCurveStartPoint()

    void GetPathCurveStartPoint(		
    	System::Int64 curve_id,
    	[System::Runtime::InteropServices::Out] double %x,
    	[System::Runtime::InteropServices::Out] double %y,
    	[System::Runtime::InteropServices::Out] double %z
    	);
    

    The GetPathCurveStartPoint() function returns the coordinates of the first point in a curve segment in the as-is units of the data or the units requested by the APIUnitsInch and APIUnitsMM.

    Arguments

    curve_id
    The identity of the toolpath.
    x
    [out] x coordinate of the start point.
    y
    [out] y coordinate of the start point.
    z
    [out] z coordinate of the start point.

    Related Functions

    Common Errors

    GetPathCurveType()

    System::String^ GetPathCurveType(		
    	System::Int64 path_id
    	);
    

    The GetPathCurveType() function returns the name of the type of a curve segment as defined by STEP Part 42. For a polyline the result will be “polyline”. For an arc the result will be “trimmed_curve”.

    Arguments

    curve_id
    The identity of the entity to be tested.

    Related Functions

    Common Errors

    GetPathDepth()

    double GetPathDepth(		
    	System::Int64 path_id
    	);
    

    The GetPathDepth() function returns the material removal depth of the path which is assumed to be a constant value across the path.

    GetPathDirection()

    System::Boolean GetPathDirection(
    	System::Int64 fe_id,
    	[System::Runtime::InteropServices::Out] double %i,
    	[System::Runtime::InteropServices::Out] double %j,
    	[System::Runtime::InteropServices::Out] double %k
    	);
    

    The GetPathDirection() function returns the direction of the path which is assumed to be a constant value across the path.

    GetPathOvercut()

    double GetPathOvercut(		
    	System::Int64 path_id
    	);
    

    The GetPathOvercut() function returns the tool diameter overcut of the path which is assumed to be a constant value across the path.

    GetPathPolylinePointAll/Count/Next()

    GetPathPolylinePointAll/Count/Next()
    System::Int64 GetPathPolylinePointCount(		
    	System::Int64 curve_id
    	);
    
    void GetPathPolylinePointNext(
    	System::Int64 curve_id,
    	System::Int64 index,
    	[System::Runtime::InteropServices::Out] double %x,
    	[System::Runtime::InteropServices::Out] double %y,
    	[System::Runtime::InteropServices::Out] double %z
    	);
    
    System::Collections::Generic::List<double>^ GetPathPolylinePointAll(
    	System::Int64 curve_id
    	);
    
    

    The GetPathPolylinePointCount() function returns the number of points in a polyline describing a toolpath.

    The GetPathPolylinePointNext() function returns the (x, y, z) coordinates of a given point in a polyline segment belonging to a geometry curve. The coordinates are returned in the as-is units of the data or converted to the units requested by the APIUnitsInch or APIUnitsMM functions.

    The GetPathPolylinePointAll() function returns all the coordinates in a single function call and is much more efficient for large polylines. The points are ordered by x, y and z so if the polyline contains 5 points then there will be 15 coordinates with the first x at position 0 and the second x at position 3.

    To get to a geometry curve polyline (x, y, z) point from a workingstep uses the following recipe:

    Arguments

    curve_id
    The identity of the polyline curve.
    index
    Position of the requested point segment in the polyline.
    x, y, z
    [out] Value of the x, y, z coordinates.

    Common Errors

    GetPathPolylinePointNextID()

    System::Int64 GetPathPolylinePointNextID(	
    	System::Int64 curve_id,
    	System::Int64 index
    	);
    

    The GetPathPolylinePointNextID() function returns the identity of the next point in a polyline curve. The function can be applied to a polyline belonging to any of the different kinds of curves allowed in a toolpath.

    Arguments

    curve_id
    The identity of the polyline curve.
    index
    Position of the requested point segment in the polyline.

    Related Functions

    Common Errors

    GetPathProcess()

    void GetPathProcess(				
    	System::Int64 path_id,
    	[System::Runtime::InteropServices::Out] double %feed,
    	[System::Runtime::InteropServices::Out] double %RPM,
    	[System::Runtime::InteropServices::Out] System::Boolean %is_rapid,
    	[System::Runtime::InteropServices::Out] System::Boolean %is_coolant_on
    	);
    

    The GetPathProcess() function returns the process parameters of a toolpath as defined by the technology entity attached to that path or the default technology entity attached to the workingstep. The function returns the id of the technology entity or 0 if this path is using the default technology defined in the workingstep. Only the values are returned not their units. If this information is required then it must be interrogated by first getting the identity of the technology entity using the GetPathTechnologyID function and then using the GetProcessXxx functions to get the required details. Every curve segment in a path has the same technology. If the technology changes then a new path must be started.

    Arguments

    path_id
    The identity of the toolpath.
    feed
    [out] The value of the feed in the as-is units of the data or in the units set requested by the APIUnitsFeed function.
    speed
    [out] The value of the speed in the as-is units of the data or in the untis requested by the APIUnitsSpeed function.
    is_rapid
    [out] Will be set to 1 if this is a rapid toolpath.

    Related Functions

    Common Errors

    GetPathRapid()

    System::Boolean GetPathRapid(			
    	System::Int64 path_id
    	);
    

    The GetPathRapid() function returns true if a tool path is rapid, or false otherwise. If a path is not rapid then the feed parameter must be determined using the GetPathProcess function.

    Arguments

    path_id
    The identity of the toolpath.

    Related Functions

    Common Errors

    GetPathReferenceDirectionAll/Count/Next()

    System::Int64 GetPathReferenceDirectionCount(	
    	System::Int64 path_id
    	);
    
    System::Int64 GetPathReferenceDirectionNext(
    	System::Int64 path_id,
    	System::Int64 index
    	);
    
    System::Collections::Generic::List<System::Int64>^ GetPathReferenceDirectionAll(
    	System::Int64 path_id
    	);
    

    The GetPathReferenceDirectionCount() function returns the number of segments in a curve that describes the reference direction for a cutting tool. Each segment will be a one dimensional polyline.

    The reference direction curve is used by advanced applications, such at tape laying, to set a direction for the cutting tool head. In these applications the tool head does not spin so the head direction can be programmed using the same curve parameters as the other five degrees of freedom. This is an uncommon case so the additional parameter is put into its own curve and not made part of the tool location (x, y, z) or tool axis (i, j, k) curves.

    If set, this function must return the same result as GetPathCurveCount because the STEP-NC standard requires every curve to have the same parameterization.

    The GetPathReferenceDirectionNext() function returns the next segment in a reference direction curve, or zero if the index is out of range.

    The GetPathReferenceDirectionAll() function returns all the reference directions in a single function call and is therefore more efficient.

    Arguments

    path_id
    The identity of the reference direction curve.
    index
    Position of the requested segment in the curve.

    Related Functions

    Common Errors

    GetPathReferenceDirectionPolylinePointAll/Count/Next()

    System::Int64 GetPathReferenceDirectionPolylinePointCount(	
    	System::Int64 curve_id
    	);
    
    void GetPathReferenceDirectionPolylinePointNext(
    	System::Int64 curve_id,
    	System::Int64 index,
    	[System::Runtime::InteropServices::Out] double %a,
    	[System::Runtime::InteropServices::Out] double %b,
    	[System::Runtime::InteropServices::Out] double %c
    	);
    
    System::Collections::Generic::List<double>^ GetPathReferenceDirectionPolylinePointAll(
    	System::Int64 curve_id
    	);
    
    

    The GetPathReferenceDirectionPolylinePointCount() function returns the number of points in a reference direction curve segment. This number should be the same as the result returned by GetPathPolylinePointCount function for the corresponding segment in the geometry curve, or 2 if the corresponding segment is an arc.

    The GetPathReferenceDirectionPolylinePointAll() function returns is more efficient because it gets all the direction data in a single function call. The data is ordered so that the first a is at position 0, the second at position 3 and so on.

    To get to a reference direction from a workingstep uses the following recipe:

    Arguments

    curve_id
    The identity of the polyline curve.
    index
    Position of the requested segment in the polyline.

    Common Errors

    GetPathSpeedOverrideCurveAll/Count/Next()

    System::Int64 GetPathSpeedOverrideCurveCount(	
    	System::Int64 path_id
    	);
    
    System::Int64 GetPathSpeedOverrideCurveNext(
    	System::Int64 path_id,
    	System::Int64 index
    	);
    
    System::Collections::Generic::List<System::Int64>^ GetPathSpeedOverrideCurveAll(
    	System::Int64 path_id
    	);
    

    The GetPathSpeedOverrideCurveCount() function returns the number of segments in a curve that describes a speed override for the cutting tool feed. Each segment will be a one dimensional polyline.

    The speed override curve is used by feed speed optimization algorithms to override the feeds programmed by the CAM system with more optimal speeds for the currently selected cutting tool and machining system. The override is described as a percentage of the feedrate of the path. For example, an override of 200 will double the speed and an override of 50 will halve it.

    If set the GetPathSpeedOverrideCurveCount function must return the same result as the GetPathCurveCount function because the STEP-NC standard requires every curve to have the same parameterization.

    The GetPathSpeedOverrideCurveNext() function returns the next segment in a speed override curve or zero if the index is out of range.

    The GetPathSpeedOverrideCurveAll() function returns all the speed override curves in one function call and is therefore more efficient.

    Arguments

    path_id
    The identity of the override speed curve.
    index
    Position of the requested segment in the speed curve.

    Related Functions

    Common Errors

    GetPathSpeedOverridePolylinePointAll/Count/Next()

    System::Int64 GetPathSpeedOverridePolylinePointCount(	
    	System::Int64 curve_id
    	);
    
    double GetPathSpeedOverridePolylinePointNext(
    	System::Int64 curve_id,
    	System::Int64 index
    	);
    
    System::Collections::Generic::List<double>^ GetPathSpeedOverridePolylinePointAll(
    	System::Int64 curve_id
    	);
    

    The GetPathSpeedOverridePolylinePointCount() function returns the number of points in a feed override curve segment. This number should be the same as the result returned by GetPathPolylinePointCount function for the corresponding segment in the geometry curve, or 2 if the corresponding segment is an arc.

    The GetPathSpeedOverridePolylinePointNext() function returns the speed override value of the next point in a polyline. The speed override is described as a percentage of the feedrate. For example, a speed override of 200 will double the feedrate and a speed override of 50 will halve the feedrate. The speed override is set using the SetOverride function of the Process object. This function needs the identifier required by the GetPathPolylinePointNextID.

    The GetPathSpeedOverridePolylinePointAll() function returns all the speed override values in a single function call.

    To get to a speed override from a workingstep uses the following recipe:

    Arguments

    curve_id
    The identity of the polyline curve.
    index
    Position of the requested segment in the polyline.

    Common Errors

    GetPathTechnologyID()

    System::Int64 GetPathTechnologyID(		
    	System::Int64 path_id
    	);
    

    The GetPathTechnologyID() function returns the identity of the technology entity attached to a tool path or to the workingstep of that path if there is no technology entity attached to the path. In STEP-NC a technology entity is used to define the speed and feed data for a tool path. The values in a technology entity can then be interrogated using the GetProcess functions.

    Arguments

    path_id
    The identity of the toolpath.

    Related Functions

    Common Errors

    GetPathTrajectoryType()

    System::String^ GetPathTrajectoryType(		
    	System::Int64 path_id
    	);
    

    The GetPathTrajectoryType() function returns the type of a tool path as a string containing one of the values "CUTTER_CONTACT_TRAJECTORY", "CUTTER_LOCATION_TRAJECTORY", "CONNECT_DIRECT" or “unknown”.

    A cutter location path defines the location of the center of the tool. A cutter contact path defines the location of contact point between the tool and the workpiece. The Connector is a path that is used to connect the end of one tool path with the start of the next. As per ISO 14649 a connector is used to show that the start of the next tool path does not depend on the end of the previous path so the order of the two paths may be changed. A connector does not contain any curve or point data.

    Arguments

    path_id
    The identity of the toolpath.

    Related Functions

    Common Errors

    GetProcessClearancePlane()

    double GetProcessClearancePlane(		
    	System::Int64 ws_id
    	);
    

    The GetProcessClearancePlane() function returns the z value of the clearance plane of a workingstep. STEP-NC allows the clearance plane to be any plane. This function assumes it is a plane normal to the Z axis.

    Arguments

    ws_id
    The identity of the workingstep.

    Related Functions

    Common Errors

    GetPathUnits()

    System::String^ GetPathUnits(		
    	System::Int64 path_id
    	);
    

    The GetPathUnits function returns a unit used for length measurements.

    Related Functions

    GetProcessCoolant()

    System::String^ GetProcessCoolant(		
    	System::Int64 ws_id
    	);
    

    The GetProcessCoolant() function returns the coolant value of a workingstep defined in the machine functions entity attached to the workingstep. The value is one of the strings “mist”, “flood” or “off”. The range of data values allowed for a coolant value is larger than the three choices currently returned by this function.

    Arguments

    en_id
    The identity of the workingstep.

    Related Functions

    Common Errors

    GetProcessFeed() and Unit

    double GetProcessFeed(		
    	System::Int64 ws_id
    	);
    System::String^ GetProcessFeedUnit(
    	System::Int64 ws_id
    	);
    
    
    double GetProcessFeed(		
    	int ws_id
    	);
    string GetProcessFeedUnit(
    	int ws_id
    	);
    

    The GetProcessFeed() function returns the feedrate value of a workingstep, toolpath or technology entity. The value is in the as-is units or in the units requested using the APIUnitsFeed function.

    If the entity is a workingstep then the feed returned is a default value that is to be used for toolpaths that do not have a technology entity. If the entity is a workingstep or toolpath then the feedrate returned will be the value defined for the technology entity attached to that workingstep or toolpath.

    The GetProcessFeedUnit() function returns the string name of the unit used for the feedrate value. The unit will be one of the following strings.

    Arguments

    ws_id
    The identity of the workingstep, toolpath or technology entity.

    Related Functions

    Common Errors

    GetProcessRetractPlane()

    double GetProcessRetractPlane(		
    	System::Int64 ws_id
    	);
    

    The GetProcessRetractPlane() function returns the retract distance for the operation in a workingstep, along the axis of the toolpath.

    Arguments

    ws_id
    The identity of the workingstep.

    Related Functions

    Common Errors

    GetProcessSpeed() and Unit

    double GetProcessSpeed(			
    	System::Int64 ws_id
    	);
    System::String^ GetProcessSpeedUnit(
    	System::Int64 ws_id
    	);
    
    
    double GetProcessSpeed(			
    	int ws_id
    	);
    string GetProcessSpeedUnit(
    	int ws_id
    	);
    

    The GetProcessSpeed() function returns the spindle speed value of a workingstep, toolpath or technology entity. The value of the spindle speed is in the as-is units or in the units requested using the APIUnitsSpeed function.

    If the entity is a workingstep then the speed returned is a default value that is to be used for toolpaths that do not have a technology entity. If the entity is a workingstep or toolpath then the spindle speed returned will be the value defined for the technology entity attached to that workingstep or toolpath.

    The GetProcessSpeedUnit() function returns the string name of the unit used for the spindle speed. The unit will be one of the following strings.

    Arguments

    en_id
    The identity of the workingstep, toolpath or technology entity.

    Related Functions

    Common Errors

    GetProjectName()

    System::String^ GetProjectName();	
    
    string GetProjectName();		
    

    The GetProjectName() function returns the string containing the project name. Every STEP-NC program contains a project entity that describes header information for the program.

    Related Functions

    Common Errors

    GetRawpieceOfWorkpiece()

    System::Int64 GetRawpieceOfWorkpiece(	
    	System::Int64 wp_id
    	);
    

    The GetRawpieceOfWorkpiece() function returns the rawpiece of a workpiece if one has been set. In complex programs many workpieces may be defined and the actual rawpiece for a workpiece may depend on the workplans that have been selected. The APT object contains functions for getting the id’s of the workpieces that define the as-is, to-be and removal volumes of an operation.

    Arguments

    wp_id
    The identity of the workpiece entity.

    Related Functions

    Common Errors

    GetSelectiveExecutableCount/Next/All/AllEnabled()

    System::Int64 GetSelectiveExecutableCount(	
    	System::Int64 sl_id
    	);
     System::Int64 GetSelectiveExecutableNext(
    	 System::Int64 sl_id,
    	 System::Int64 index
    	 );
    System::Collections::Generic::List<System::Int64>^ GetSelectiveExecutableAll(
    	System::Int64 wp_id
    	);
    System::Collections::Generic::List<System::Int64>^ GetSelectiveExecutableAllEnabled(
    	System::Int64 wp_id
    	);
    
    
    
    int GetSelectiveExecutableCount(		
    	int sl_id
    	);
    int GetSelectiveExecutableNext(
    	int sl_id;
    	int index;
    	);
    int[] GetSelectiveExecutableAll(
    	int wp_id
    	);
    int[] GetSelectiveExecutableAllEnabled(
    	int wp_id
    	);
    

    The GetSelectiveExecutableCount() function returns a count of the number of executables contained in a Selective. A selective is a list of executables, only one of which will be executed at run time.

    The GetSelectiveExecutableNext() function returns the next executable in a Selective using an index.

    The GetSelectiveExecutableAll() function returns the identity of all the nested executables in the selective.

    The GetSelectiveExecutableAllEnabled() function returns the identity of the enabled executables in a selective. In a properly defined selective this should be one, but it may be all the executables if the user has not chosen one yet, or it may be zero if the chosen one has also be disabled.

    Arguments

    sel_id
    The identity of the selective that contains the list.
    index
    The index of the requested member.

    Related Functions

    Common Errors

    GetStixExportTransformAvailable()

    System::Boolean GetStixExportTransformAvailable();	
    

    The GetStixExportTransformAvailable() function

    GetSurfacePropertyForWorkingstep()

    System::String^ GetSurfacePropertyForWorkingstep(	
    	System::Int64 ws_id
    	);
    

    The GetSurfacePropertyForWorkingstep() function returns the required surface finish requirements for the whole workpiece. If parts of the workpiece have different surface finish requirements then these can be determined using the GetSurfacePropertyForWorkpingstep function.

    Arguments

    ws_id
    The identity of the workingstep.

    Related Functions

    Common Errors

    GetSurfacePropertyForWorkpiece()

    System::String^ GetSurfacePropertyForWorkpiece();	
    

    The GetSurfacePropertyForWorkpiece() function returns a description of the surface finish required for a feature being machined by a workingstep. A related function GetSurfacePropertyForWorkpiece returns a description of the surface finish required for the whole workpiece. This function should be used if the part of the workpiece being machined by this workingstep has different surface finish requirements to the rest of the workpiece

    The process object contains functionality that can be used to set the surface finish requirements for a workingstep.

    Related Functions

    Common Errors

    GetTechnologyAllCount/Next()

    System::Int64 GetTechnologyAllCount();	
    
    System::Int64 GetTechnologyAllNext(
    	System::Int64 index,
    	[System::Runtime::InteropServices::Out] double %feed,
    	[System::Runtime::InteropServices::Out] double %speed
    	);
    

    The GetTechnologyAllCount() function returns a count of all the technology entities in the AP-238 file. Technology entities are used to describe feed and speed data for operations and tool paths. If two paths have the same feed and speed parameters then they should share the same technology entity.

    The GetTechnologyAllNext() function iterates over the technologies and returns the one at a given index, as well as key parameters. The returned identifier can be used as the argument for the GetProcess functions.

    Arguments

    index
    The position of the required technology in the list defined by GetTechnologyAllCount
    feed
    [out] Returned feedrate of the technology
    speed
    [out] Returned spindle speed of the technology

    Related Functions

    Common Errors

    GetTechnologyByValue()

    System::Int64 GetTechnologyByValue(	
    	double feed,
    	double speed
    	);
    

    The GetTechnologyByValue() function searches for the technology entity that contains the given feed and speed values and returns the identifier of the matching technology or zero if no entity was found. There should be only one technology entity with the given combination but if the data contains more than one, then the function will pick one of the instances at random. The function ignores the units of the data. If necessary these can be checked after the entity is found using the GetProcess functions.

    Arguments

    feed
    The feedrate required for the technology entity.
    speed
    The spindle speed required for the technology entity.

    Common Errors

    GetTechnologyWorkingstepCount/Next()

    System::Int64 GetTechnologyWorkingstepCount(	
    	System::Int64 tech_id
    	);
    
    System::Int64 GetTechnologyWorkingstepNext(
    	System::Int64 tech_id,
    	System::Int64 index
    	);
    

    The GetTechnologyWorkingstepCount() function returns a count of all the workingsteps that use a technology. If two workingsteps use the same technology object then any change to that object will impact both of the workingsteps.

    The GetTechnologyWorkingstepNext() function iterates over the workingsteps and returns the one at a given index.

    Arguments

    tech_id
    The identity of the technology
    index
    The position of the required workingstep

    Related Functions

    Common Errors

    GetToolAllCount/Next()

    System::Int64 GetToolAllCount();		
    
    System::Int64 GetToolAllNext(
    	System::Int64 index
    	);
    

    The GetToolAllCount() function returns a count of all the tools in the AP-238 file.

    The GetToolAllNext() function iterates over each tool and returns the one at a given index. The returned identifier can be used as the argument for the GetTool functions.

    Arguments

    index
    The position of the required tool in the list defined by GetToolAllCount

    Related Functions

    Common Errors

    GetToolCoolantThroughTool()

    System::Int64 GetToolCoolantThroughTool(		
    	System::Int64 ws_id,
    	[System::Runtime::InteropServices::Out] System::Boolean %value_set
    	);
    

    The GetToolCoolantThroughTool() function returns true if coolant through tool is supported.

    Arguments

    ws_or_tl_id
    The identity of a workingstep or tool. If the identifier defines a workingstep then the function will be applied to the tool defined for that workingstep.

    Common Errors

    GetToolCornerRadius(), Unit, Lower, Upper, and Reason

    double GetToolCornerRadius(			
    	System::Int64 ws_id,
    	[System::Runtime::InteropServices::Out] System::Boolean %value_set
    	);
    System::String^ GetToolCornerRadiusUnit(
    	System::Int64 ws_id
    	);
    double GetToolRadiusLower(
    	System::Int64 ws_id,
    	[System::Runtime::InteropServices::Out] System::Boolean %value_set
    	);
    double GetToolRadiusUpper(
    	System::Int64 ws_id,
    	[System::Runtime::InteropServices::Out] System::Boolean %value_set
    	);
    System::String^ GetToolRadiusLowerReason(
    	System::Int64 ws_id,
    	[System::Runtime::InteropServices::Out] System::Boolean %value_set
    	);
    System::String^ GetToolRadiusUpperReason(
    	System::Int64 ws_id,
    	[System::Runtime::InteropServices::Out] System::Boolean %value_set
    	);
    
    
    
    double GetToolCornerRadius(			
    	int ws_id
    	);
    string GetToolCornerRadiusUnit(
    	int ws_id
    	);
    double GetToolRadiusLower(
    	int ws_id
    	);
    double GetToolRadiusUpper(
    	int ws_id
    	);
    string GetToolRadiusLowerReason(
    	int ws_id
    	);
    string GetToolRadiusUpperReason(
    	int ws_id
    	);
    

    The GetToolCornerRadius() function returns the corner radius of a tool which is the parameter used for cutter radius compensation. The GetToolCornerRadiusUnit() function returns the unit name used for the radius value.

    The GetToolRadiusLower(), GetToolRadiusLowerReason(), GetToolRadiusUpper(), and GetToolRadiusUpperReason() functions return bounds on the recommended value for the corner radius as well as the reason for the recommendation. Note the slight change in naming convention between these functions and the base one.

    Arguments

    ws_or_tl_id
    The identity of a workingstep or tool. If the identifier defines a workingstep then the function will be applied to the tool defined for that workingstep.
    value_set
    [out] true if this value has been set

    Related Functions

    Common Errors

    GetToolCurrentCornerRadius()

    double GetToolCurrentCornerRadius(		
    	System::Int64 tl_id,
    	[System::Runtime::InteropServices::Out] System::Boolean %nominal_set,
    	[System::Runtime::InteropServices::Out] System::Boolean %current_set,
    	[System::Runtime::InteropServices::Out] double %nominal_value
    	);
    

    The GetToolCurrentCornerRadius() function returns the current corner radius of a tool. This radius may differ from the radius defined by the CAM system because a different tool was selected or because of tool wear.

    Arguments

    tl_id
    The identity of a workingstep or tool. If the identifier defines a workingstep then the function will be applied to the tool defined for that workingstep.
    nominal_set
    [out] A flag indicating whether the nominal value for the corner radius is set.
    current_set
    [out] A flag indicating whether the current value for the corner radius is set.
    nominal_value
    [out] The nominal value for the corner radius.

    Related Functions

    Common Errors

    GetToolCurrentDiameter()

    double GetToolCurrentDiameter(			
    	System::Int64 tl_id,
    	[System::Runtime::InteropServices::Out] System::Boolean %nominal_set,
    	[System::Runtime::InteropServices::Out] System::Boolean %current_set,
    	[System::Runtime::InteropServices::Out] double %nominal_value
    	);
    

    The GetToolCurrentDiameter() function returns the current diameter of a tool. This radius may differ from the diameter defined by the CAM system because a different tool was selected or because of tool wear.

    Arguments

    tl_id
    The identity of a workingstep or tool. If the identifier defines a workingstep then the function will be applied to the tool defined for that workingstep.
    nominal_set
    [out] A flag indicating whether the nominal value for the diameter is set.
    current_set
    [out] A flag indicating whether the current value for the diameter is set.
    nominal_value
    [out] The nominal value for the diameter.

    Related Functions

    Common Errors

    GetToolCurrentLength()

    double GetToolCurrentLength(			
    	System::Int64 tl_id,
    	[System::Runtime::InteropServices::Out] System::Boolean %nominal_set,
    	[System::Runtime::InteropServices::Out] System::Boolean %current_set,
    	[System::Runtime::InteropServices::Out] double %nominal_value
    	);
    
    double GetToolCurrentLength(			
    	int tl_id
    	);
    

    The GetToolCurrentLength() function returns the current length of a tool. This length may differ from the length defined by the CAM system because a different tool was selected or because of tool wear.

    Arguments

    tl_id
    The identity of a workingstep or tool. If the identifier defines a workingstep then the function will be applied to the tool defined for that workingstep.
    nominal_set
    [out] A flag indicating whether the nominal value for the length is set.
    current_set
    [out] A flag indicating whether the current value for the length is set.
    nominal_value
    [out] The nominal value for the length.

    Related Functions

    Common Errors

    GetToolDiameter(), Unit, Lower, Upper, and Reason

    double GetToolDiameter(				
    	System::Int64 ws_id,
    	[System::Runtime::InteropServices::Out] System::Boolean %value_set
    	);
    System::String^ GetToolDiameterUnit(
    	System::Int64 ws_id
    	);
    double GetToolDiameterLower(
    	System::Int64 ws_id,
    	[System::Runtime::InteropServices::Out] System::Boolean %value_set
    	);
    double GetToolDiameterUpper(
    	System::Int64 ws_id,
    	[System::Runtime::InteropServices::Out] System::Boolean %value_set
    	);
    System::String^ GetToolDiameterLowerReason(
    	System::Int64 ws_id,
    	[System::Runtime::InteropServices::Out] System::Boolean %value_set
    	);
    System::String^ GetToolDiameterUpperReason(
    	System::Int64 ws_id,
    	[System::Runtime::InteropServices::Out] System::Boolean %value_set
    	);
    
    
    
    double GetToolDiameter(				
    	int ws_id
    	);
    string GetToolDiameterUnit(
    	int ws_id
    	);
    

    The GetToolDiameter() function returns the diameter of a tool which is the parameter used for cutter diameter compensation. The GetToolDiameterUnit() function returns the unit of the diameter as a string.

    The GetToolDiameterLower(), GetToolDiameterLowerReason(), GetToolDiameterUpper() and GetToolDiameterUpperReason() functions return bounds on the recommended value for the diameter as well as the reason for the recommendation.

    Arguments

    ws_or_tl_id
    The identity of a workingstep or tool. If the identifier defines a workingstep then the function will be applied to the tool defined for that workingstep.
    value_set
    [out] true if this value has been set

    Related Functions

    Common Errors

    GetToolExpectedLife(), Unit, Lower, Upper, and Reason

    double GetToolExpectedLife(			
    	System::Int64 ws_id,
    	[System::Runtime::InteropServices::Out] System::Boolean %value_set
    	);
    
    System::String^ GetToolExpectedLifeUnit(
    	System::Int64 ws_id
    	);
    
    double GetToolExpectedLifeLower(
    	System::Int64 ws_id,
    	[System::Runtime::InteropServices::Out] System::Boolean %value_set
    	);
    
    double GetToolExpectedLifeUpper(
    	System::Int64 ws_id,
    	[System::Runtime::InteropServices::Out] System::Boolean %value_set
    	);
    
    System::String^ GetToolExpectedLifeLowerReason(
    	System::Int64 ws_id,
    	[System::Runtime::InteropServices::Out] System::Boolean %value_set
    	);
    
    System::String^ GetToolExpectedLifeUpperReason(
    	System::Int64 ws_id,
    	[System::Runtime::InteropServices::Out] System::Boolean %value_set
    	);
    

    The GetToolExpectedLife() function returns the expected remaining life of the tool cutting component, usually in minutes. The GetToolExpectedLifeUnit() function returns the unit name used for the expected remaining tool life.

    The GetToolExpectedLifeLower(), GetToolExpectedLifeLowerReason(), GetToolExpectedLifeUpper(), and GetToolExpectedLifeUpperReason() functions return bounds on the recommended value for the expected tool life as well as the reason for the recommendation.

    Arguments

    ws_or_tl_id
    The identity of a workingstep or tool. If the identifier defines a workingstep then the function will be applied to the tool defined for that workingstep.
    value_set
    [out] true if this value has been set

    Related Functions

    Common Errors

    GetToolFluteCount()

    double GetToolFluteCount(			
    	System::Int64 ws_id
    	);
    

    The GetToolFluteCount() function

    GetToolFluteLength(), Unit, Lower, Upper, and Reason

    double GetToolFluteLength(			
    	System::Int64 ws_id,
    	[System::Runtime::InteropServices::Out] System::Boolean %value_set
    	);
    System::String^ GetToolFluteLengthUnit(
    	System::Int64 ws_id
    	);
    double GetToolFluteLengthLower(
    	System::Int64 ws_id,
    	[System::Runtime::InteropServices::Out] System::Boolean %value_set
    	);
    double GetToolFluteLengthUpper(
    	System::Int64 ws_id,
    	[System::Runtime::InteropServices::Out] System::Boolean %value_set
    	);
    System::String^ GetToolFluteLengthLowerReason(
    	System::Int64 ws_id,
    	[System::Runtime::InteropServices::Out] System::Boolean %value_set
    	);
    System::String^ GetToolFluteLengthUpperReason(
    	System::Int64 ws_id,
    	[System::Runtime::InteropServices::Out] System::Boolean %value_set
    	);
    
    
    
    double GetToolFluteLength(			
    	int ws_id
    	);
    string GetToolFluteLengthUnit(
    	int ws_id
    	);
    

    The GetToolFluteLength() function returns the flute length defined for a tool, which constrains the maximum depth of cut. The GetToolFluteLengthUnit() function returns the unit name used for this length.

    The GetToolFluteLengthLower(), GetToolFluteLengthLowerReason(), GetToolFluteLengthUpper(), and GetToolFluteLengthUpperReason() functions return bounds on the recommended value for the flute length as well as the reason for the recommendation.

    Arguments

    ws_or_tl_id
    The identity of a workingstep or tool. If the identifier defines a workingstep then the function will be applied to the tool defined for that workingstep.
    value_set
    [out] true if this value has been set

    Common Errors

    GetToolFluteNumber()

    double GetToolFluteNumber(			
    	System::Int64 ws_id,
    	[System::Runtime::InteropServices::Out] System::Boolean %value_set
    	);
    

    The GetToolFluteNumber() function returns the number of flutes (effective cutting edges) defined for a tool.

    Arguments

    ws_or_tl_id
    The identity of a workingstep or tool. If the identifier defines a workingstep then the function will be applied to the tool defined for that workingstep.
    value_set
    [out] true if this value has been set

    Common Errors

    GetToolFunctionalLength(), and Unit

    double GetToolFunctionalLength(			
    	System::Int64 ws_id,
    	[System::Runtime::InteropServices::Out] System::Boolean %value_set
    	);
    
    System::String^ GetToolFunctionalLengthUnit(
    	System::Int64 ws_id
    	);
    

    The GetToolFunctionalLength() function returns the functional length defined for a tool. This length can be used for 5-axis cutter compensation. The GetToolFunctionalLengthUnit() function returns the unit name used for this length.

    Arguments

    ws_or_tl_id
    The identity of a workingstep or tool. If the identifier defines a workingstep then the function will be applied to the tool defined for that workingstep.
    value_set
    [out] true if this value has been set

    Common Errors

    GetToolGeometryLengthUnit()

    System::String^ GetToolGeometryLengthUnit(	
    	System::Int64 ws_id
    	);
    

    The GetToolGeometryLengthUnit() function returns the unit name used for length measures in the tool geometry.

    Arguments

    ws_or_tl_id
    The identity of a workingstep or tool. If the identifier defines a workingstep then the function will be applied to the tool defined for that workingstep.

    GetToolHandOfCut()

    System::String^ GetToolHandOfCut(		
    	System::Int64 ws_id,
    	[System::Runtime::InteropServices::Out] System::Boolean %value_set
    	);
    

    The GetToolHandOfCut() function returns a string describing the hand of cut of a tool. The allowed values are “left”, “right” and “neutral”.

    Arguments

    ws_or_tl_id
    The identity of a workingstep or tool. If the identifier defines a workingstep then the function will be applied to the tool defined for that workingstep.
    value_set
    [out] true if this value has been set

    Common Errors

    GetToolHorizontalDistance(), and Unit

    double GetToolHorizontalDistance(		
    	System::Int64 ws_id,
    	[System::Runtime::InteropServices::Out] System::Boolean %value_set
    	);
    
    System::String^ GetToolHorizontalDistanceUnit(
    	System::Int64 ws_id
    	);
    

    The GetToolHorizontalDistance() function returns the horizontal distance of a tool which is a rarely used parameter in APT files. The function assumes that the tool has been defined using the tool function of the APT object. STEP-NC supports a large range of other tool types.

    The GetToolHorizontalDistanceUnit() function returns the unit name used for the horizontal distance value.

    Arguments

    ws_or_tl_id
    The identity of a workingstep or tool. If the identifier defines a workingstep then the function will be applied to the tool defined for that workingstep.
    value_set
    [out] true if this value has been set

    Related Functions

    Common Errors

    GetToolISO13399NumericAttributeCount/Next()

    System::Int64 GetToolISO13399NumericAttributeCount(	
    	System::Int64 tool_id,
    	System::String^ directory
    	);
    
    System::String^ GetToolISO13399NumericAttributeNext(
    	System::Int64 tool_id,
    	System::Int64 index,
    	System::String^ directory,
    	[System::Runtime::InteropServices::Out] System::String^ %value,
    	[System::Runtime::InteropServices::Out] System::String^ %type
    	);
    

    The GetToolISO13399NumericAttributeCount() function returns the number of numeric attributes defined for a tool. The functions finds the ISO 13399 data in a file with the name of the Tool identifier in a directory that is given as one of the arguments.

    The GetToolISO13399NumericAttributeNext() function returns the name of the attribute and passes back the value and type of the next numeric attribute as [out] parameters. All the values are returned as strings. The functions finds the ISO 13399 data in a file with the name of the Tool identifier in a directory that is given as one of the arguments.

    ISO 13399 is a new standard for cutting tool data. ISO 13399 data is divided into numeric attributes that describe parametric properties of the tool such as the length and string attributes that describe other properties of the tool such as the hand_of_cut.

    Arguments

    ws_or_tl_id
    The identifier of the tool or a workingstep that uses the tool
    directory
    A file system directory that contains ISO 13399 data for the tool.
    index
    The index of the next attribute.
    value
    [out] The value in the attribute returned as a string.
    type
    [out] The type of the attribute as defined by ISO 13399.

    Related Functions

    Common Errors

    GetToolISO13399OrganizationAttributes()

    System::Boolean Finder::GetToolISO13399OrganizationAttributes (	
    	System::Int64 tool_id, 
    	[System::Runtime::InteropServices::Out] System::String^ %company_name, 
    	[System::Runtime::InteropServices::Out] System::String^ %address1, 
    	[System::Runtime::InteropServices::Out] System::String^ %address2
    	);
    

    The GetToolISO13399OrganizationAttributes() function returns true if source organization parameters for a tool are present and passes the values back in [out] fields.

    Arguments

    ws_or_tl_id
    The identifier of the tool or a workingstep that uses the tool
    company_name
    [out] The name of the source company
    address1
    [out] The first address line for the source company
    address2
    [out] The second address line for the source company

    GetToolISO13399StringAttributeCount/Next()

    System::Int64 GetToolISO13399StringAttributeCount(	
    	System::Int64 tool_id,
    	System::String^ directory
    	);
    
    System::String^ GetToolISO13399StringAttributeNext(
    	System::Int64 tool_id,
    	System::Int64 index,
    	System::String^ directory,
    	[System::Runtime::InteropServices::Out] System::String^ %value
    	);
    

    The GetToolISO13399StringAttributeCount() function returns the number of descriptive attributes defined for a tool. The functions finds the ISO 13399 data in a file with the name of the Tool identifier in a directory that is given as one of the arguments.

    The GetToolISO13399StringAttributeNext() function returns the name of the next string attribute and passes back its value in an [out] parameter. The functions finds the ISO 13399 data in a file with the name of the Tool identifier in a directory that is given as one of the arguments.

    ISO 13399 is a new standard for cutting tool data. ISO 13399 data is divided into numeric attributes that describe parametric properties of the tool such as the length and string attributes that describe other properties of the tool such as the hand_of_cut.

    Arguments

    ws_or_tl_id
    The identifier of the tool or a workingstep that uses the tool
    directory
    A file system directory that contains ISO 13399 data for the tool.
    index
    The index of the next attribute.
    value
    [out] The value in the attribute returned as a string.

    Related Functions

    Common Errors

    GetToolIdentifier()

    System::String^ GetToolIdentifier(		
    	System::Int64 ws_id
    	);
    
    string GetToolIdentifier(			
    	int ws_id
    	);
    

    The GetToolIdentifier() function returns the manufacturers name for a tool which may be different for the part name because the latter describes an instance and the former describes a category/type/sales item. The part name is more likely to be controlled by the user. The Identifier is more likley to be controlled by the maker or vendor of the tool.

    GetToolLength(), Unit, Lower, Upper, and Reason

    double GetToolLength(				
    	System::Int64 ws_id,
    	[System::Runtime::InteropServices::Out] System::Boolean %value_set
    	);
    System::String^ GetToolLengthUnit(
    	System::Int64 ws_id
    	);
    double GetToolLengthLower(
    	System::Int64 ws_id,
    	[System::Runtime::InteropServices::Out] System::Boolean %value_set
    	);
    double GetToolLengthUpper(
    	System::Int64 ws_id,
    	[System::Runtime::InteropServices::Out] System::Boolean %value_set
    	);
    System::String^ GetToolLengthLowerReason(
    	System::Int64 ws_id,
    	[System::Runtime::InteropServices::Out] System::Boolean %value_set
    	);
    System::String^ GetToolLengthUpperReason(
    	System::Int64 ws_id,
    	[System::Runtime::InteropServices::Out] System::Boolean %value_set
    	);
    
    
    
    double GetToolLength(				
    	int ws_id
    	);
    string GetToolLengthUnit(
    	int ws_id
    	);
    

    The GetToolLength() function returns the length of the tool, which is also known as the height in APT. The GetToolLengthUnit() function returns the unit name used for the value.

    The GetToolLengthLower(), GetToolLengthLowerReason(), GetToolLengthUpper(), and GetToolLengthUpperReason() functions return bounds on the recommended value for the length as well as the reason for the recommendation.

    Arguments

    ws_or_tl_id
    The identity of a workingstep or tool. If the identifier defines a workingstep then the function will be applied to the tool defined for that workingstep.
    value_set
    [out] true if this value has been set

    Related Functions

    Common Errors

    GetToolMatchingCount/Next()

    System::Int64 GetToolMatchingCount (		
    	double diameter,
    	double length,
    	double radius,
    	double flute_count,
    	System::String^ type
    	);
    
    System::Int64 GetToolMatchingNext (
    	System::Int64 index
    	);
    

    The GetToolMatchingCount() function searches the AP-238 file and returns a count of all the tools that have a required set of properties.

    The GetToolMatchingNext() function returns the identifier of each similar tool using an index.

    The two functions are intended to be used to manage the tooling. If a program is making "ideal" tooling based on feature dimensions then it may not know if the project already contains a tool with the required diemnsions. For example, an application may require the tool to have a diameter and radius but be willing to accept any length provided it is over a required minimium. In this case GetToolMatchingCount() can be used to find all the tools with the diameter and radius, and the application can filter for the minimum langth using the GetToolLength() function.

    Arguments

    diameter
    The required effective_cutting_diameter, or zero if this parameter does not matter.
    length
    The required functional length, or zero if this parameter does not matter.
    radius
    The required corner radius, or zero if this parameter does not matter.
    flute_count_flag
    The required number of flutes, or zero if this parameter does not matter.
    type
    The required type of tool, or the empty string if this parameter does not matter.
    Index
    The position of the required tool in the list defined by GetToolMatchingCount

    Related Functions

    Common Errors

    GetToolMaterial()

    System::String^ GetToolMaterial(			
    	System::Int64 ws_id,
    	[System::Runtime::InteropServices::Out] System::Boolean %value_set
    	);
    

    The GetToolMaterial() function returns a description of the material used in the cutting component of the tool.

    Arguments

    ws_or_tl_id
    The identity of a workingstep or tool. If the identifier defines a workingstep then the function will be applied to the tool defined for that workingstep.
    value_set
    [out] true if this value has been set
  • Related Functions

    Common Errors

    GetToolMaterialStandard()

    System::String^ GetToolMaterialStandard(		
    	System::Int64 ws_id,
    	[System::Runtime::InteropServices::Out] System::Boolean %value_set
    	);
    

    The GetToolMaterialStandard() function returns the standard that describes the material.

    Arguments

    ws_or_tl_id
    The identity of a workingstep or tool. If the identifier defines a workingstep then the function will be applied to the tool defined for that workingstep.
    value_set
    [out] true if this value has been set

    Related Functions

    Common Errors

    GetToolNumber()

    System::String^ GetToolNumber(			
    	System::Int64 ws_id
    	);
    
    string GetToolNumber(				
    	int ws_id
    	);
    

    The GetToolNumber() function returns the number of a tool which in APT programs corresponds to its position in the tool changer. This is returned as a string even though the value is numeric.

    Arguments

    ws_or_tl_id
    The identity of a workingstep or tool. If the identifier defines a workingstep then the function will be applied to the tool defined for that workingstep.
    value_set
    [out] true if this value has been set

    Related Functions

    Common Errors

    GetToolNumberAsNumber()

    System::Int64 GetToolNumberAsNumber(		
    	System::Int64 ws_id
    	);
    
    int GetToolNumberAsNumber(			
    	int ws_id
    	);
    

    The GetToolNumberAsNumber() function returns the tool number as an integer. The tool number can be any string in STEP-NC but in practice the tool number frequently corresponds to the position of the tool in a tool holder so it is constrained to be an integer.

    Arguments

    ws_or_tl_id
    The identity of a workingstep or tool. If the identifier defines a workingstep then the function will be applied to the tool defined for that workingstep.

    Related Functions

    Common Errors

    GetToolOverallAssemblyLength(), Unit, Lower, Upper, and Reason

    double GetToolOverallAssemblyLength(		
    	System::Int64 tl_id,
    	[System::Runtime::InteropServices::Out] System::Boolean %value_set
    	);
    System::String^ GetToolOverallAssemblyLengthUnit(
    	System::Int64 ws_id
    	);
    double GetToolOverallLengthLower(
    	System::Int64 ws_id,
    	[System::Runtime::InteropServices::Out] System::Boolean %value_set
    	);
    double GetToolOverallLengthUpper(
    	System::Int64 ws_id,
    	[System::Runtime::InteropServices::Out] System::Boolean %value_set
    	);
    System::String^ GetToolOverallLengthLowerReason(
    	System::Int64 ws_id,
    	[System::Runtime::InteropServices::Out] System::Boolean %value_set
    	);
    System::String^ GetToolOverallLengthUpperReason(
    	System::Int64 ws_id,
    	[System::Runtime::InteropServices::Out] System::Boolean %value_set
    	);
    
    
    
    double GetToolOverallAssemblyLength(		
    	int ws_id
    	);
    string GetToolOverallAssemblyLengthUnit(
    	int ws_id
    	);
    

    The GetToolOverallAssemblyLength() function returns the tool overall assembly length, which describes the complete length of the tool and is used in collision detection algorithms. The GetToolOverallAssemblyLengthUnit() function returns the unit name used for the length value.

    The GetToolOverallLengthLower(), GetToolOverallLengthLowerReason(), GetToolOverallLengthUpper(), and GetToolOverallLengthUpperReason() functions return bounds on the recommended value for the length as well as the reason for the recommendation. Note the slight change in naming convention between these and the base function.

    Arguments

    ws_or_tl_id
    The identity of a workingstep or tool. If the identifier defines a workingstep then the function will be applied to the tool defined for that workingstep.
    value_set
    [out] true if this value has been set
  • Related Functions

    Common Errors

    GetToolPartName()

    System::String^ GetToolPartName(	
    	System::Int64 ws_id
    	);
    
    string GetToolPartName(			
    	int ws_id
    	);
    

    The GetToolPartName() function returns the part name given to the geometry of the tool or null if there is no geometry defined for the tool. The tool part name is a third name for the tool derived from its geometry model (if it has one). The tool geometry is a workpiece like any other workpiece and like those other workpieces it has a part name.

    A tool can have several names. The Tool number has become a name in the STEP-NC standard but for reasons having to do with legacy APT files for the time being applications will be safer if they continue to treat this attribute as a number. The Tool Identifier is a manufacturer’s name for the file that can be used to get data about the tool from a ISO 13399 database.

    Arguments

    ws_or_tl_id
    The identity of a workingstep or tool. If the identifier defines a workingstep then the function will be applied to the tool defined for that workingstep.

    Related Functions

    Common Errors

    GetToolProductID()

    
    System::Int64 GetToolProductID(		
    	System::Int64 tl_id
    	);
    
    int GetToolProductID(			
    	int tl_id
    	);
    

    The GetToolProductID() function

    GetToolRecommendedFeed(), Unit, Lower, Upper, and Reason

    double GetToolRecommendedFeed(			
    	System::Int64 ws_id,
    	[System::Runtime::InteropServices::Out] System::Boolean %value_set
    	);
    
    System::String^ GetToolRecommendedFeedUnit(
    	System::Int64 ws_id,
    	[System::Runtime::InteropServices::Out] System::Boolean %value_set
    	);
    
    double GetToolRecommendedFeedLower(
    	System::Int64 ws_id,
    	[System::Runtime::InteropServices::Out] System::Boolean %value_set
    	);
    
    double GetToolRecommendedFeedUpper(
    	System::Int64 ws_id,
    	[System::Runtime::InteropServices::Out] System::Boolean %value_set
    	);
    
    System::String^ GetToolRecommendedFeedLowerReason(
    	System::Int64 ws_id,
    	[System::Runtime::InteropServices::Out] System::Boolean %value_set
    	);
    
    System::String^ GetToolRecommendedFeedUpperReason(
    	System::Int64 ws_id,
    	[System::Runtime::InteropServices::Out] System::Boolean %value_set
    	);
    

    The GetToolRecommendedFeed() function returns the recommended feed for a tool. The GetToolRecommendedFeedUnit() function returns the unit name used for the feed value.

    The GetToolRecommendedFeedLower(), GetToolRecommendedFeedLowerReason(), GetToolRecommendedFeedUpper(), and GetToolRecommendedFeedUpperReason() functions return bounds on the recommended value for the feed as well as the reason for the recommendation.

    Arguments

    tl_id
    The identity of the cutting tool.
    value_set
    [out] true if this value has been set

    Related Functions

    Common Errors

    GetToolRecommendedSpeed(), Unit, Lower, Upper, and Reason

    double GetToolRecommendedSpeed(			
    	System::Int64 ws_id,
    	[System::Runtime::InteropServices::Out] System::Boolean %value_set
    	);
    
    System::String^ GetToolRecommendedSpeedUnit(
    	System::Int64 ws_id,
    	[System::Runtime::InteropServices::Out] System::Boolean %value_set
    	);
    
    double GetToolRecommendedSpeedLower(
    	System::Int64 ws_id,
    	[System::Runtime::InteropServices::Out] System::Boolean %value_set
    	);
    
    double GetToolRecommendedSpeedUpper(
    	System::Int64 ws_id,
    	[System::Runtime::InteropServices::Out] System::Boolean %value_set
    	);
    
    System::String^ GetToolRecommendedSpeedLowerReason(
    	System::Int64 ws_id,
    	[System::Runtime::InteropServices::Out] System::Boolean %value_set
    	);
    
    System::String^ GetToolRecommendedSpeedUpperReason(
    	System::Int64 ws_id,
    	[System::Runtime::InteropServices::Out] System::Boolean %value_set
    	);
    

    The GetToolRecommendedSpeed() function returns the recommended spindle speed for a tool. The GetToolRecommendedSpeedUnit() function returns the unit name used by the spindle speed.

    The GetToolRecommendedSpeedLower(), GetToolRecommendedSpeedLowerReason(), GetToolRecommendedSpeedUpper(), and GetToolRecommendedSpeedUpperReason() functions return bounds on the recommended value for the feed as well as the reason for the recommendation.

    Arguments

    tl_id
    The identity of the cutting tool.
    value_set
    [out] true if this value has been set

    Related Functions

    Common Errors

    GetToolReferenceDataName()

    System::String^ GetToolReferenceDataName(	
    	System::Int64 ws_id,
    	[System::Runtime::InteropServices::Out] System::Boolean %value_set
    	);
    
    string GetToolReferenceDataName(		
    	int ws_id
    	);
    

    The GetToolReferenceDataName() function returns the reference data name for a tool. This is a unique name for the tool set by the manufacturer and can be used to find to additional data about the tool in catalogs.

    Arguments

    ws_or_tl_id
    The identity of a workingstep or tool. If the identifier defines a workingstep then the function will be applied to the tool defined for that workingstep.
    value_set
    [out] true if this value has been set

    Related Functions

    Common Errors

    GetToolReferenceDataSTRL()

    System::String^ GetToolReferenceDataSTRL(	
    	System::Int64 ws_id,
    	[System::Runtime::InteropServices::Out] System::Boolean %value_set
    	);
    

    The GetToolReferenceDataSTRL() function

    GetToolSimilarCount/Next()

    System::Int64 GetToolSimilarCount (		
    	System::Int64 ws_or_tl_id,
    	System::Int64 type_flag,
    	System::Int64 diameter_flag,
    	System::Int64 length_flag,
    	System::Int64 radius_flag,
    	System::Int64 flute_count_flag,
    	System::Int64 manufacturer_flag
    	);
    
    System::Int64 GetToolSimilarNext (
    	System::Int64 ws_or_tl_id,
    	System::Int64 index
    	);
    

    The GetToolSimilarCount() function searches the AP-238 file and returns a count of all the tools that have a required set of properties. The function is given an existing tool and finds all of the tools in the project that have the same properties.

    The GetToolSimilarNext() function returns the identifier of each similar tool using an index.

    The two functions are intended to be used to help manage the tooling. If two AP238 data sets have been merged some of the tools may be redundant. The functions find the tools that have a required set of properties. Other functions can then be used to check the other properties to see if they are within an acceptable range. For example, an application may require the tool to have a diameter and radius, but be willing to accept any length provided it is over a required minimium. In this case GetToolSimilarCount() can be used find the tools with the diameter and radius, and the application programmer can filter the found tools for the minimum langth using the GetToolLength() function.

    Arguments

    tool_or_ws_id
    The tool that is to be the basis of the search. The found tools will have the same values as this tool in the selected parameters.
    type_flag
    True (1) if the similar tool must have the same type. False (0) if the type does not matter.
    diameter_flag
    True (1) if the similar tool must have the same effective_cutting_diameter
    length_flag
    True (1) if the similar tool must have the same functional length
    radius_flag
    True (1) if the similar tool must have the same corner radius (which may be NULL for both tools).
    flute_count_flag
    True (1) if the similar tool must have the same number of flutes.
    manufacturer_flag
    True (1) if the similar tool must have the same manufacturer.
    Index
    The position of the required tool in the list defined by GetToolSimilarCount

    Related Functions

    Common Errors

    GetToolTaperAngle(), Unit, Lower, Upper, and Reason

    double GetToolTaperAngle(			
    	System::Int64 ws_id,
    	[System::Runtime::InteropServices::Out] System::Boolean %value_set
    	);
    
    System::String^ GetToolTaperAngleUnit(
    	System::Int64 ws_id
    	);
    
    double GetToolTaperAngleLower(
    	System::Int64 ws_id,
    	[System::Runtime::InteropServices::Out] System::Boolean %value_set
    	);
    
    double GetToolTaperAngleUpper(
    	System::Int64 ws_id,
    	[System::Runtime::InteropServices::Out] System::Boolean %value_set
    	);
    
    System::String^ GetToolTaperAngleLowerReason(
    	System::Int64 ws_id,
    	[System::Runtime::InteropServices::Out] System::Boolean %value_set
    	);
    
    System::String^ GetToolTaperAngleUpperReason(
    	System::Int64 ws_id,
    	[System::Runtime::InteropServices::Out] System::Boolean %value_set
    	);
    

    The GetToolTaperAngle() function returns the angle of the tool taper. The GetToolTaperAngleUnit() function returns the unit name used for the angle (degrees or radians).

    The GetToolTaperAngleLower(), GetToolTaperAngleLowerReason(), GetToolTaperAngleUpper(), and GetToolTaperAngleUpperReason() functions return bounds on the recommended value for the angle as well as the reason for the recommendation.

    Arguments

    ws_or_tl_id
    The identity of a workingstep or tool. If the identifier defines a workingstep then the function will be applied to the tool defined for that workingstep.
    value_set
    [out] true if this value has been set

    Related Functions

    Common Errors

    GetToolTechnologyCount/Next()

    System::Int64 GetToolTechnologyCount(		
    	System::Int64 tl_id
    	);
    
    System::Int64 GetToolTechnologyNext(
    	System::Int64 tl_id,
    	System::Int64 index
    	);
    

    The GetToolTechnologyCount() function returns a count of all the technologies used by a tool. The GetToolTechnologyNext() function iterates over the technologies and returns one at the given index.

    Arguments

    tl_id
    The identity of the cutting tool
    index
    The position of the required technology

    Related Functions

    Common Errors

    GetToolThreadFormType()

    System::String^ GetToolThreadFormType(		
    	System::Int64 ws_id,
    	[System::Runtime::InteropServices::Out] System::Boolean %value_set
    	);
    

    The GetToolThreadFormType() function returns the thread form type of a tool.

    Arguments

    ws_or_tl_id
    The identity of a workingstep or tool. If the identifier defines a workingstep then the function will be applied to the tool defined for that workingstep.
    value_set
    [out] true if this value has been set

    Common Errors

    GetToolThreadPitch(), Unit, Lower, Upper, and Reason

    double GetToolThreadPitch(			
    	System::Int64 ws_id,
    	[System::Runtime::InteropServices::Out] System::Boolean %value_set
    	);
    
    System::String^ GetToolThreadPitchUnit(
    	System::Int64 ws_id
    	);
    
    double GetToolThreadPitchLower(
    	System::Int64 ws_id,
    	[System::Runtime::InteropServices::Out] System::Boolean %value_set
    	);
    
    double GetToolThreadPitchUpper(
    	System::Int64 ws_id,
    	[System::Runtime::InteropServices::Out] System::Boolean %value_set
    	);
    
    System::String^ GetToolThreadPitchLowerReason(
    	System::Int64 ws_id,
    	[System::Runtime::InteropServices::Out] System::Boolean %value_set
    	);
    
    System::String^ GetToolThreadPitchUpperReason(
    	System::Int64 ws_id,
    	[System::Runtime::InteropServices::Out] System::Boolean %value_set
    	);
    

    The GetToolThreadPitch() function returns the thread pitch of a tapping tool and the GetToolThreadPitchUnit() function returns the name of the unit used for the pitch value.

    The GetToolThreadPitchLower(), GetToolThreadPitchLowerReason(), GetToolThreadPitchUpper(), and GetToolThreadPitchUpperReason() functions return bounds on the recommended value for the pitch as well as the reason for the recommendation.

    Arguments

    ws_or_tl_id
    The identity of a workingstep or tool. If the identifier defines a workingstep then the function will be applied to the tool defined for that workingstep.
    value_set
    [out] true if this value has been set

    Common Errors

    GetToolThreadSize(), Unit, Lower, Upper, and Reason

    double GetToolThreadSize(			
    	System::Int64 ws_id,
    	[System::Runtime::InteropServices::Out] System::Boolean %value_set
    	);
    
    System::String^ GetToolThreadSizeUnit(
    	System::Int64 ws_id
    	);
    
    double GetToolThreadSizeLower(
    	System::Int64 ws_id,
    	[System::Runtime::InteropServices::Out] System::Boolean %value_set
    	);
    
    double GetToolThreadSizeUpper(
    	System::Int64 ws_id,
    	[System::Runtime::InteropServices::Out] System::Boolean %value_set
    	);
    
    System::String^ GetToolThreadSizeLowerReason(
    	System::Int64 ws_id,
    	[System::Runtime::InteropServices::Out] System::Boolean %value_set
    	);
    
    System::String^ GetToolThreadSizeUpperReason(
    	System::Int64 ws_id,
    	[System::Runtime::InteropServices::Out] System::Boolean %value_set
    	);
    

    The GetToolThreadSize() function returns the thread size of a tapping tool and the GetToolThreadSizeUnit() function returns the name of the unit used for the size value.

    The GetToolThreadSizeLower(), GetToolThreadSizeLowerReason(), GetToolThreadSizeUpper(), and GetToolThreadSizeUpperReason() functions return bounds on the recommended value for the size as well as the reason for the recommendation.

    Arguments

    ws_or_tl_id
    The identity of a workingstep or tool. If the identifier defines a workingstep then the function will be applied to the tool defined for that workingstep.
    value_set
    [out] true if this value has been set

    Common Errors

    GetToolThreadTaperCount()

    double GetToolThreadTaperCount(			
    	System::Int64 ws_id,
    	[System::Runtime::InteropServices::Out] System::Boolean %value_set
    	);
    

    The GetToolThreadTaperCount() function returns the thread taper count of a tool.

    Arguments

    ws_or_tl_id
    The identity of a workingstep or tool. If the identifier defines a workingstep then the function will be applied to the tool defined for that workingstep.
    value_set
    [out] true if this value has been set

    Common Errors

    GetToolTipAngle(), Unit, Lower, Upper, and Reason

    double GetToolTipAngle(				
    	System::Int64 ws_id,
    	[System::Runtime::InteropServices::Out] System::Boolean %value_set
    	);
    
    System::String^ GetToolTipAngleUnit(
    	System::Int64 ws_id
    	);
    
    double GetToolTipAngleLower(
    	System::Int64 ws_id,
    	[System::Runtime::InteropServices::Out] System::Boolean %value_set
    	);
    
    double GetToolTipAngleUpper(
    	System::Int64 ws_id,
    	[System::Runtime::InteropServices::Out] System::Boolean %value_set
    	);
    
    System::String^ GetToolTipAngleLowerReason(
    	System::Int64 ws_id,
    	[System::Runtime::InteropServices::Out] System::Boolean %value_set
    	);
    
    System::String^ GetToolTipAngleUpperReason(
    	System::Int64 ws_id,
    	[System::Runtime::InteropServices::Out] System::Boolean %value_set
    	);
    

    The GetToolTipAngle() function returns the tip angle of a tool and the GetToolTipAngleUnit() function returns the name of the unit used for the angle (degrees or radians).

    The GetToolTipAngleLower(), GetToolTipAngleLowerReason(), GetToolTipAngleUpper(), and GetToolTipAngleUpperReason() functions return bounds on the recommended value for the tip angle as well as the reason for the recommendation.

    Arguments

    ws_or_tl_id
    The identity of a workingstep or tool. If the identifier defines a workingstep then the function will be applied to the tool defined for that workingstep.
    value_set
    [out] true if this value has been set

    Related Functions

    Common Errors

    GetToolType()

    System::String^ GetToolType(		
    	System::Int64 ws_id
    	);
    
    string GetToolType(			
    	int ws_id
    	);
    

    The GetToolType() function returns the type of a tool as a string name.

    Arguments

    ws_or_tl_id
    The identity of a workingstep or tool. If the identifier defines a workingstep then the function will be applied to the tool defined for that workingstep.

    Common Errors

    GetToolUsingIdentifier()

    System::Int64 GetToolUsingIdentifier(		
    	System::String^ identifier
    	);
    
    int GetToolUsingIdentifier(			
    	string identifier
    	);
    

    The GetToolUsingIdentifier() function returns the identity of the first tool found with the given identifier. In this case the identifier is the manufacturer's name for the category of the tool which may be different from the part name which descirbes a single instance of the tool.

    GetToolUsingNumber()

    System::Int64 GetToolUsingNumber(		
    	System::String^ id
    	);
    
    int GetToolUsingNumber(				
    	string id
    	);
    

    The GetToolUsingNumber() function returns the identity of the first tool found with the given number. The number of a tool usually corresponds to the position of that tool in the tool changer and should be unique but this is not rquired.

    Arguments

    id
    The tool_number from the APT program.

    Related Functions

    Common Errors

    GetToolVerticalDistance() and Unit

    double GetToolVerticalDistance(			
    	System::Int64 ws_id,
    	[System::Runtime::InteropServices::Out] System::Boolean %value_set
    	);
    
    System::String^ GetToolVerticalDistanceUnit(
    	System::Int64 ws_id
    	);
    

    The GetToolVerticalDistance() function returns the vertical distance of a tool which is a rarely used parameter in APT files. The function assumes that the tool has been defined using the tool function of the APT object. STEP-NC supports a large range of other tool types.

    The GetToolVerticalDistanceUnit() function returns the name of the unit used for the distance.

    Arguments

    ws_or_tl_id
    The identity of a workingstep or tool. If the identifier defines a workingstep then the function will be applied to the tool defined for that workingstep.
    value_set
    [out] true if this value has been set

    Related Functions

    Common Errors

    GetToolWorkpiec()

    System::Int64 GetToolWorkpiece(			
    	System::Int64 ws_or_tl_id
    	);
    
    

    The GetToolWorkpiece() function returns the identity of the workpiece that defines the geometry of the tool. The workpiece maybe a single part or an assembly. The workpeice may have tolerances defined.

    Arguments

    ws_or_tl_id
    The identity of a workingstep or tool. If the identifier defines a workingstep then the function will be applied to the tool defined for that workingstep.

    Related Functions

    Common Errors

    GetWorkingstep()

    System::Int64 GetWorkingstep(		
    	System::Int64 wp_id,
    	System::Int64 index
    	);
    
    int GetWorkingstep(			
    	int wp_id,
    	int index
    	);
    

    The GetWorkingstep() function returns the workingstep at a given index in a workplan.

    GetWorkingstepFinalFeatureCount/Next()

    System::Int64 GetWorkingstepFinalFeatureCount(	
    	System::Int64 ws_id
    	);
    
    System::Int64 GetWorkingstepFinalFeatureNext(
    	System::Int64 ws_id,
    	System::Int64 index
    	);
    

    The GetWorkingstepFinalFeatureCount() function returns the count of the number of final features. This count will be non-zero only if the AP-238 file was derived from an AP-224 file.

    The GetWorkingstepFinalFeatureNext() function iterates over the final features and returns the one at a particular index.

    A workingstep has one process feature and a variable number of final features. The process feature describes the data of the CAM operation that defines the workingstep. Therefore it is closely related to the operation in the workingstep – see the GetOperation functions.

    The final features describe properties of the workpiece. They are created earlier in the product life cycle to describe the goals of the machining process. Each workingstep in a STEP-NC program contributes to the manufacture to zero, one or many of the final features. This function returns a count of the number of final features that someone has determined this workingstep is helping produce. See Final Features and Process Features for more information on final and process features.

    Arguments

    ws_id
    The identity of the workingstep

    Related Functions

    Common Errors

    GetWorkingstepName()

    System::String^ GetWorkingstepName(		
    	System::Int64 ws_id
    	);
    
    string GetWorkingstepName(			
    	int ws_id
    	);
    

    The GetWorkingstepName() function returns the name of a workingstep

    Arguments

    ws_id
    The identity of the workingstep.

    Related Functions

    Common Errors

    GetWorkingstepNameInWorkplan()

    System::String^ GetWorkingstepNameInWorkplan(	
    	System::Int64 wp_id,
    	System::Int64 index
    	);
    

    The GetWorkingstepNameInWorkplan() function returns the name of a workingstep in a workplan using its position in that workplan. The Workplan may be a selective. The workingstep can be any type of executable.

    Arguments

    ws_id
    The identity of the workplan (or selective)
    index
    The position of the required executable in the plan.

    Related Functions

    Common Errors

    GetWorkingstepPathAll/Count/Next()

    System::Int64 GetWorkingstepPathCount(		
    	System::Int64 ws_id
    	);
    
    System::Int64 GetWorkingstepPathNext(
    	System::Int64 ws_id,
    	System::Int64 index,
    	[System::Runtime::InteropServices::Out] System::Boolean %is_contact
    	);
    
    System::Collections::Generic::List<System::Int64>^ GetWorkingstepPathAll(
    	System::Int64 ws_id
    	);
    

    The GetWorkingstepPathCount() function returns the number of tool paths defined for each workingstep. A new tool path is necessary in a process whenever the technology changes, for example, when the feed or speed changes or the path changes to or from rapid mode.

    The GetWorkingstepPathNext() function iterates over the tool paths in a workingstep and returns the path at a given index.

    The GetWorkingstepPathAll() function returns all the workingstep paths in one function call and is therefore more efficient. If the type of each path (center or contact) cannot be assumed then it can be determined using the IsContactPath and IsCenterPath functions.

    Arguments

    ws_id
    The identity of the workingstep
    index
    The position of the required path.
    is_contact
    [out] Returns true if the toolpath is cutter contact, false if it is a tool center point path.

    Related Functions

    Common Errors

    GetWorkingstepProcessFeature()

    System::Int64 GetWorkingstepProcessFeature(	
    	System::Int64 ws_id
    	);
    

    The GetWorkingstepProcessFeature() function returns the process feature of the operation in a workingstep. If the operation of a workingstep is not free-form milling then the process feature will describe important attributes of that operation such as the depth of a hole or pocket. See ISO 14649 for a more detailed description of these attributes.

    In STEP-NC every workingstep must have a process feature. If a workingstep is free form then its feature will be the default toolpath feature. A toolpath feature has no parametric attributes but depending on the operation it may have geometry. This geometry will show the faces being machined by the operation and can be queried using functions in the Tolerance object,

    Arguments

    ws_id
    The identity of the workingstep

    Related Functions

    Common Errors

    GetWorkingstepPropertyCount/Name/Type()

    System::Int64 GetWorkingstepPropertyCount(	
    	System::Int64 ws_id
    	);
    System::String GetWorkingstepPropertyName(	
    	System::Int64 ws_id,
    	System::Int64 index
    	);
    System::String GetWorkingstepPropertyType(	
    	System::Int64 ws_id,
    	System::Int64 index
    	);
    

    The GetWorkingstepProperty() functions return the value of a user defined property. These values describe parameters for an operation and may have been set to describe the arguments of a canned cycle or a user defined property.

    The GetWorkingstepPropertyCount() function returns a count of the process properties defined for a workingstep.

    The GetWorkingstepPropertyName() function returns the name of a parameter. If the property is defined by a cycle then this name will have been set to the name of the corresponmding cycle parameter. If the property is user defined then the name will be as set by the user.

    The GetWorkingstepPropertyType() function returns the type of a parameter. If the type is "count" then the parameter is an integer and use the GetWorkingstepPropertyCountMeasure() function to get the value. If the type is "descriptive" then the parameter is a string and use the GetWorkingstepPropertyDescriptiveMeasure() function to get the value. If the type is "length" then the parameter is a real and use the GetWorkingstepPropertyLengthMeasure() function to get the value.

    Arguments

    ws_id
    The identity of the workingstep
    index
    The index of the parameter

    Related Functions

    Common Errors

    GetWorkingstepPropertyCount/Descriptive/LengthMeasure()

    System::Int64 GetWorkingstepPropertyCountMeasure(	
    	System::Int64 ws_id,
    	System::String property_name
    	);
    System::String GetWorkingstepPropertyDescriptiveMeasure(	
    	System::Int64 ws_id,
    	System::String property_name
    	);
    double GetWorkingstepPropertyLengthMeasure(	
    	System::Int64 ws_id,
    	System::String property_name
    	);
    

    The GetWorkingstepProperty() functions return the value of a user defined property. These values describe parameters for an operation and may have been set to describe the arguments of a canned cycle or a user defined property.

    The GetWorkingstepPropertyType() function returns the type of a parameter. If the type is "count" then the parameter is an integer and use the GetWorkingstepPropertyCountMeasure() function to get the value. If the type is "descriptive" then the parameter is a string and use the GetWorkingstepPropertyDescriptiveMeasure() function to get the value. If the type is "length" then the parameter is a real and use the GetWorkingstepPropertyLengthMeasure() function to get the value.

    The GetWorkingstepPropertyName() function returns the name of a parameter. If the property is defined by a cycle then this name will have been set to the name of the corresponmding cycle parameter. If the property is user defined then the name will be as set by the user.

    Arguments

    ws_id
    The identity of the workingstep
    property
    The name of the required parameter

    Related Functions

    Common Errors

    GetWorkingstepTechnologyCount/Next()

    System::Int64 GetWorkingstepTechnologyCount(	
    	System::Int64 ws_id
    	);
    
    System::Int64 GetWorkingstepTechnologyNext(
    	System::Int64 ws_id,
    	System::Int64 index
    	);
    

    The GetWorkingstepTechnologyCount() function returns a count of the number of distinct technology entities used by all the paths in a workinstep. A technology entity is attached to each toolpath in a workingstep to define the feeds and speeds of that workingstep. It is typical for many of the tool paths to share the same technology so a workingstep might have 15 paths but only three technologies one used for the approach, one used for the maching, and one used for the retract.

    The GetWorkingstepTechnologyNext() function returns the next technology entity in a workingstep using an index

    Arguments

    ws_id
    The identity of the workingstep
    index
    The position of the required technology.

    Related Functions

    Common Errors

    GetWorkingstepTechnologyMain()

    System::Int64 GetWorkingstepTechnologyMain(	
    	System::Int64 ws_id
    	);
    

    The GetWorkingstepTechnologyMain() function returns the technology defined for the operation in a workingstep. If a toolpath in a workingstep does not have any technology then this one is used by default.

    Arguments

    ws_id
    The identity of the workingstep

    Related Functions

    Common Errors

    GetWorkingstepTool()

    System::Int64 GetWorkingstepTool(	
    	System::Int64 ws_id
    	);
    
    int GetWorkingstepTool(			
    	int ws_id
    	);
    

    The GetWorkingstepTool() function returns the identity of the tool used by a workingstep. Every workingstep should have a tool defined.

    Arguments

    ws_id
    The identity of the workingstep.

    Related Functions

    Common Errors

    GetWorkingstepToolpathOrientation()

    System::Boolean GetWorkingstepToolpathOrientation(	
    	System::Int64 ws_id,
    	[System::Runtime::InteropServices::Out] double %x,
    	[System::Runtime::InteropServices::Out] double %y,
    	[System::Runtime::InteropServices::Out] double %z,
    	[System::Runtime::InteropServices::Out] double %i,
    	[System::Runtime::InteropServices::Out] double %j,
    	[System::Runtime::InteropServices::Out] double %k,
    	[System::Runtime::InteropServices::Out] double %a,
    	[System::Runtime::InteropServices::Out] double %b,
    	[System::Runtime::InteropServices::Out] double %c
    	);
    

    The GetWorkingstepToolpathOrientation() function

    GetWorkingstepType()

    System::String^ GetWorkingstepType(	
    	System::Int64 ws_id
    	);
    

    The GetWorkingstepType() function returns placement of the toolpath in a workingstep. The orientation is often set when operations are reused. Each orientation allows the operation to be applied to a different part of the workpiece.

    The WorkingstepToolpathOrientation function in the APT object sets the toolpath orientation of a workingstep.

    Arguments

    ws_id
    The identity of the workingstep.
    x, y, z
    [out] The coordinates of the placement point.
    i, j, k
    [out] The coordinates of the placement z axis.
    a, b, c
    [out] The coordinates of the placement x axis

    Common Errors

    GetWorkpieceAsIsOfMain()

    System::Int64 GetWorkpieceAsIsOfMain();	
    
    int GetWorkpieceAsIsOfMain();		
    

    The GetWorkpieceAsIsOfMain() function returns the identity of the workpeice that defines the AS-IS model of the main workplan. The returned model defines the expected initial state of the product before any operations in the project are executed.

    Related Functions

    Common Errors

    GetWorkpieceBlock()

    System::Int64 GetWorkpieceBlock(			
    	System::Int64 wp_id,
    	[System::Runtime::InteropServices::Out] double %x,
    	[System::Runtime::InteropServices::Out] double %y,
    	[System::Runtime::InteropServices::Out] double %z,
    	[System::Runtime::InteropServices::Out] double %length,
    	[System::Runtime::InteropServices::Out] double %width,
    	[System::Runtime::InteropServices::Out] double %height
    	);
    

    The GetWorkpieceBlock() function

    GetWorkpieceCount/Next()

    System::Int64 GetWorkpieceCount();	
    
    System::Int64 GetWorkpieceNext(
    	System::Int64 index
    	);
    
    
    int[] GetWorkpieceAll(			
    	);
    

    The GetWorkpieceCount() function returns the number of workpieces in a project. These workpieces may define tools, fixtures and in-process models as well as the final products of the project. Workpieces that are components of assemblies are not counted. A similar function exists in the APT object.

    The GetWorkpieceNext() function iterates over all of the workpieces in a project and returns the one at a given index.

    Arguments

    index
    The index of the desired workpiece.

    Related Functions

    Common Errors

    GetWorkpieceCylinder()

    System::Int64 GetWorkpieceCylinder(	
    	System::Int64 wp_id,
    	[System::Runtime::InteropServices::Out] double %x,
    	[System::Runtime::InteropServices::Out] double %y,
    	[System::Runtime::InteropServices::Out] double %z,
    	[System::Runtime::InteropServices::Out] double %length,
    	[System::Runtime::InteropServices::Out] double %diameter
    	);
    

    The GetWorkpieceCylinder() function

    GetWorkpieceCylinderAsBlock()

    System::Int64 GetWorkpieceCylinderAsBlock(	
    	System::Int64 wp_id,
    	[System::Runtime::InteropServices::Out] double %x,
    	[System::Runtime::InteropServices::Out] double %y,
    	[System::Runtime::InteropServices::Out] double %z,
    	[System::Runtime::InteropServices::Out] double %length,
    	[System::Runtime::InteropServices::Out] double %width,
    	[System::Runtime::InteropServices::Out] double %height
    	);
    

    The GetWorkpieceCylinderAsBlock() function

    GetWorkpieceDeltaOfMain()

    System::Int64 GetWorkpieceDeltaOfMain();	
    
    int GetWorkpieceDeltaOfMain();			
    

    The GetWorkpieceDeltaOfMain() function returns the identity of the workpeice that defines the volume to be removed by a project.

    Related Functions

    Common Errors

    GetWorkpieceFixtureOfMain()

    System::Int64 GetWorkpieceFixtureOfMain();	
    
    int GetWorkpieceFixtureOfMain();		
    

    The GetWorkpieceFixtureOfMain() function

    GetWorkpieceImmediateSubAssemblyCount/Next()

    System::Int64 GetWorkpieceImmediateSubAssemblyCount(	
    	System::Int64 wp_id
    	);
    
    System::Int64 GetWorkpieceImmediateSubAssemblyNext(
    	System::Int64 wp_id,
    	System::Int64 index
    	);
    
    
    int[] GetWorkpieceImmediateSubAssemblyAll(		
    	int wp_id
    	);
    

    The GetWorkpieceImmediateSubAssemblyCount() function returns a count of the number of direct components in an assembly. The count will be 0 if the workpiece is a component. Each component may also be an assembly. See the GetWorkpieceSubAssemblyCount function if a complete list is needed.

    The GetWorkpieceImmediateSubAssemblyNext() function iterates over the (direct) components or subassemblies in a workpiece.

    Arguments

    wp_id
    The indentity of the parent assembly.
    index
    The index of the desired workpiece.

    Related Functions

    Common Errors

    GetWorkpieceName()

    System::String^ GetWorkpieceName(	
    	System::Int64 wp_id
    	);
    
    string GetWorkpieceName(		
    	int wp_id
    	);
    

    The GetWorkpieceName() function returns the name of the workpiece or “unknown” if the workpiece is undefined. The workpiece name can be defined using the Partno function of the APT object.

    Arguments

    wp_id
    The identity of the workpiece

    Related Functions

    Common Errors

    GetWorkpieceOfFeature()

    System::Int64 GetWorkpieceOfFeature(	
    	System::Int64 fea_id
    	);
    

    The GetWorkpieceOfFeature() function returns the workpiece that contains a feature.

    Arguments

    fea_id
    The identity of a feature.

    Related Functions

    Common Errors

    GetWorkpiecePlacement()

    void GetWorkpiecePlacement(			
    	System::Int64 wp_id,
    	[System::Runtime::InteropServices::Out] double %x,
    	[System::Runtime::InteropServices::Out] double %y,
    	[System::Runtime::InteropServices::Out] double %z,
    	[System::Runtime::InteropServices::Out] double %i,
    	[System::Runtime::InteropServices::Out] double %j,
    	[System::Runtime::InteropServices::Out] double %k,
    	[System::Runtime::InteropServices::Out] double %a,
    	[System::Runtime::InteropServices::Out] double %b,
    	[System::Runtime::InteropServices::Out] double %c
    	);
    
    
    

    The GetWorkpiecePlacement() function returns the axis placement that currently defines the position and orientation of a geometry model. This function is a duplicate of a method in APT. The APT class also has a method to set the placement.

    Arguments

    id
    The identity of a model. The model may be a fixture, tool rawpiece or workpiece and it may describe the as-is, to-be or removal volumes for a workingstep, workplan or executable.

    Result

    x, y, z
    The coordinates of the placement point.
    i, j, k
    The coordinates of the placement z axis.
    a, b, c
    The coordinates of the placement x axis

    Common Errors

    GetWorkpieceShape()

    System::Int64 GetWorkpieceShape(		
    	System::Int64 wp_id,
    	[System::Runtime::InteropServices::Out] double %x,
    	[System::Runtime::InteropServices::Out] double %y,
    	[System::Runtime::InteropServices::Out] double %z,
    	[System::Runtime::InteropServices::Out] double %length,
    	[System::Runtime::InteropServices::Out] double %width,
    	[System::Runtime::InteropServices::Out] double %height
    	);
    

    The GetWorkpieceShape() function returns estimates for the length width and height of a block surrounding the workpiece geometry by finding the largest and smallest x, y and z values in the coordinates of the geometry. Returns 0 if the workpiece is undefined or if it does not have any geometry defined and the identity of the workpiece otherwise.

    Arguments

    wp_id
    Identity of the workpiece
    x, y, z
    [out] The center of the bottom face as defined by the minimum z coordinate found and the mid point of the x and y values.
    length
    [out] length of the block (z dimension)
    width
    [out] width of the block (x dimension)
    height
    [out] height of the block (y dimension)

    Related Functions

    Common Errors

    GetWorkpieceSubAssemblyCount/Next()

    System::Int64 GetWorkpieceSubAssemblyCount(	
    	System::Int64 wp_id
    	);
    System::Int64 GetWorkpieceSubAssemblyNext(
    	System::Int64 wp_id,
    	System::Int64 index
    	);
    
    
    
    int[] GetWorkpieceSubAssemblyAll(		
    	int wp_id
    	);
    

    The GetWorkpieceSubAssemblyCount() function returns a count of the number of subassemblies in a workpiece. The count includes all the sub-assemblies and components. At least one subassembly will be counted because the given workpiece is included in the result.

    The GetWorkpieceSubAssemblyNext() function returns one of the components or subassemblies in a workpiece.

    Arguments

    wp_id
    The indentity of the parent assembly.
    index
    The index of the desired workpiece.

    Related Functions

    Common Errors

    GetWorkpieceToBeOfMain()

    System::Int64 GetWorkpieceToBeOfMain();		
    
    int GetWorkpieceToBeOfMain();			
    

    The GetWorkpieceToBeOfMain() function returns the identity of the workpeice that defines the TO-BE model of the main workplan. The returned model defines the expected final state of the product after all the operations in the project have been executed.

    Related Functions

    Common Errors

    GetWorkpieceType()

    System::String^ GetWorkpieceType(		
    	System::Int64 wp_id
    	);
    
    string GetWorkpieceType(			
    	int wp_id
    	);
    

    The GetWorkpieceType() function returns the role of the workpiece as a string (“workpiece”, “fixture” or “tool”).

    Arguments

    wp_id
    The id of the workpiece.

    Related Functions

    Common Errors

    GetWorkpieceUnits()

    System::String^ GetWorkpieceUnits(	
    	System::Int64 wp_id
    	);
    
    string GetWorkpieceUnits(		
    	int wp_id
    	);
    

    The GetWorkpieceUnits() function returns a unit used for length measurements in the geometry of a workpiece. The string will be one of “in” for inches, “ft” for feet, “mm” for millimeters, “cm” for centimeters, or “m” for meters. A complex workpiece may use many units. The function will return the first unit found.

    Arguments

    wp_id
    The indentity of the workpiece.

    Related Functions

    Common Errors

    GetWorkplanExecutableCount/Next/All/AllEnabled()

    System::Int64 GetWorkplanExecutableCount(	
    	System::Int64 wp_id
    	);
    System::Int64 GetWorkplanExecutableNext(
    	System::Int64 wp_id,
    	System::Int64 index
    	);
    System::Collections::Generic::List<System::Int64>^ GetWorkplanExecutableAll(
    	System::Int64 wp_id
    	);
    System::Collections::Generic::List<System::Int64>^ GetWorkplanExecutableAllEnabled(
    	System::Int64 wp_id
    	);
    
    
    
    int[] GetWorkplanExecutableAll(			
    	int wp_id
    	);
    int[] GetWorkplanExecutableAllEnabled(
    	int wp_id
    	);
    

    The GetWorkplanExecutableCount() function returns a count of the number of executables contained in a workplan. A workplan is a list of executables. There are many types of executables. The NC functions are executables and Workingsteps are executables. Workplans are also executables so a workplan can contain other workplans.

    The GetWorkplanExecutableNext() function returns the next executable in a workplan using an index.

    The GetWorkplanExecutableAll() function returns the ids of all the executables in the workplan.

    The GetWorkplanExecutableAllEnabled() function returns the ids of all the executables that are currently enabled in the workplan.

    Arguments

    wp_id
    The identity of the workplan.
    index
    The index of the requested member.

    Related Functions

    Common Errors

    GetWorkplanFinalFeatureCount/Next()

    System::Int64 GetWorkplanFinalFeatureCount(	
    	System::Int64 wp_id
    	);
    
    System::Int64 GetWorkplanFinalFeatureNext(
    	System::Int64 wp_id,
    	System::Int64 index
    	);
    

    The GetWorkplanFinalFeatureCount() function returns the count of the number of final features used by all of the workingsteps in the workplan including those used in nested workplans of the workplan with duplicates eliminated. Many workingsteps can contribute to the machining of a final feature, but if a feature is found twice only the first reference will be included in the count. See GetWorkingstepFinalFeatureCount for a more detailed description of the role of final features in a Workingstep.

    The GetWorkplanFinalFeatureNext() function returns the next final feature used by all of the workinsteps in a workplan using an index.

    Arguments

    wp_id
    The identity of the workplan
    index
    The position of the required feature

    Related Functions

    Common Errors

    GetWorkplanName()

    System::String^ GetWorkplanName(	
    	System::Int64 wp_id
    	);
    
    string GetWorkplanName()(		
    	int wp_id
    	);
    

    The GetWorkplanName() function returns the name of a workplan.

    Arguments

    wp_id
    The identity of the workplan.

    Related Functions

    Common Errors

    GetWorkplanProcessFeatureCount/Next()

    System::Int64 GetWorkplanProcessFeatureCount(	
    	System::Int64 wp_id
    	);
    System::Int64 GetWorkplanProcessFeatureNext(
    	System::Int64 wp_id,
    	System::Int64 index
    	);
    
    
    int GetWorkplanProcessFeatureCount(		
    	int wp_id
    	);
    int GetWorkplanProcessFeatureNext(
    	int wp_id,
    	int index
    	);
    

    The GetWorkplanProcessFeatureCount() function returns a count of all the process features used in all of the workingsteps in a workplan including the workingsteps used in any nested workplans of the given workplan. Two workingsteps may contribute to the same proces feature if one workingstep is roughing operation for that feature and the next is a finishing operation. See GetWorkingstepProcessFeature for a more detailed description of the role of the priocess feature in a Workingstep.

    The GetWorkplanProcessFeatureNext() function returns the next process feature used by all of the workinsteps in a workplan using an index.

    Arguments

    wp_id
    The identity of the workplan
    index
    The position of the required feature

    Related Functions

    Common Errors

    GetWorkplanSize()

    System::Int64 GetWorkplanSize(		
    	System::Int64 wp_id
    	);
    
    int GetWorkplanSize(			 
    	int wp_id
    	);
    

    The GetWorkplanSize() function

    GetWorkplanTechnologyCount/Next()

    System::Int64 GetWorkplanTechnologyCount(	
    	System::Int64 wp_id
    	);
    
    System::Int64 GetWorkplanTechnologyNext(
    	System::Int64 wp_id,
    	System::Int64 index
    	);
    

    The GetWorkplanTechnologyCount() function returns the number of distinct technologies used by the enclosed workingsteps of a workplan or selective. Technology entities describe feed and speed data for operations and tool paths. The GetWorkplanTechnologyNext() function iterates over these technologies and returns the one at a given index.

    Arguments

    wp_id
    The identity of the workplan
    index
    The position of the required technology

    Related Functions

    GetWorkplanToolCount/Next()

    System::Int64 GetWorkplanToolCount(		
    	System::Int64 wp_id
    	);
    System::Int64 GetWorkplanToolNext(
    	System::Int64 wp_id,
    	System::Int64 index
    	);
    
    
    int GetWorkplanToolCount(			
    	int wp_id
    	);
    int GetWorkplanToolNext(
    	int wp_id,
    	int index
    	);
    

    The GetWorkplanToolCount() function returns the number of tools used by all of the workingsteps in a workplan including any used by nested workplans of that workplan. If two workingsteps use the same tool then that tool is only counted once.

    The GetWorkplanToolNext() function returns the next tool used by the workingsteps in a workplan.

    Arguments

    wp_id
    The identity of the workplan
    index
    The position of the required path.

    Related Functions

    Common Errors

    GetWorkplanWorkpieceCount/Next()

    System::Int64 GetWorkplanWorkpieceCount(	
    	System::Int64 plan_id,
    	[System::Runtime::InteropServices::Out] System::String^ %name
    	);
    
    System::Int64 GetWorkplanWorkpieceNext(
    	System::Int64 plan_id,
    	System::Int64 index,
    	[System::Runtime::InteropServices::Out] double %x,
    	[System::Runtime::InteropServices::Out] double %y,
    	[System::Runtime::InteropServices::Out] double %z,
    	[System::Runtime::InteropServices::Out] double %i,
    	[System::Runtime::InteropServices::Out] double %j,
    	[System::Runtime::InteropServices::Out] double %k,
    	[System::Runtime::InteropServices::Out] double %a,
    	[System::Runtime::InteropServices::Out] double %b,
    	[System::Runtime::InteropServices::Out] double %c
    	);
    

    The GetWorkplanWorkpieceCount() function returns the number of workpieces defined in a workplan and used for the operations in the plan instead of the global workpiece. For some workplans there may be multiple workpieces.

    The GetWorkplanWorkpieceNext() function returns a workpiece id and placement information for the next workpiece defined by a workplan and used for the operations in the plan.

    Arguments

    wp_id
    The identity of the workplan
    index
    The position of the required workpiee
    x, y, z
    [out] The origin of the placement of the workpiece.
    i, j, k
    [out] The direction of the Z axis of the placement.
    a, b, c
    [out] The direction of the X axis of the placement.

    Common Errors

    IsCenterPath()

    System::Boolean IsCenterPath(		
    	System::Int64 path_id
    	);
    

    The IsCenterPath() function returns true if the tool path is described for the center line of the axis. This is the most common case. The alternative is for the tool path to describe the contact line between the tool and the workpiece.

    Arguments

    path_id
    The identity of the path to be tested.

    Related Functions

    Common Errors

    IsContactPath()

    System::Boolean IsContactPath(		
    	System::Int64 path_id
    	);
    

    The IsContactPath() function returns true if the tool path is described for the contact line between the tool and workpiece. In traditional machining contact paths can be compensated for tool wear. (In STEP-NC machining any type of path can be compensated because all the processes are described by models).

    For more information on cutter compensation see the AptStepMaker::Left and AptStepMaker::Right functions.

    Arguments

    path_id
    The identity of the path to be tested.

    Related Functions

    Common Errors

    IsEnabled()

    System::Boolean IsEnabled(	
    	System::Int64 exe_id
    	);
    
    boolean IsEnabled(		
    	int exe_id
    	);
    

    The IsEnabled() function returns true if the executable is enabled. During the execution of a STEP-NC program only enabled exectuables are executed and the disabled ones are ignored.

    Executables can be enabled and disabled using f the AptStepMaker::SetCNCexportExecEnabled() and AptStepMaker::SetCNCexportExecDisabled() functions.

    Arguments

    exe_id
    The identity of the executable to be tested which could be a workingstep, workplan, selective or NC_function.

    Related Functions

    Common Errors

    IsFinish()

    System::Boolean IsFinish(		
    	System::Int64 ws_id
    	);
    

    The IsFinish() function returns true if the operation in a workplan is a finishing operation. Note some operations may not be finishing or roughing but if an operation is roughing then it cannot also be finishing and vice versa.

    Arguments

    ws_id
    The identity of the workingstep containing the operation.

    Related Functions

    Common Errors

    IsMultiSpindle()

    System::Boolean IsMultiSpindle(		>	);
    
    

    The IsMultiSpindle() function returns true if the current project contains a parallel program structure.

    Related Functions

    Common Errors

    IsNcFunction()

    System::Boolean IsNcFunction(		
    	System::Int64 exe_id
    	);
    

    The IsNcFunction() function returns true if an executable is an NC Function.

    Arguments

    exe_id
    The identity of the executable.

    Related Functions

    Common Errors

    IsParallel()

    System::Boolean IsParallel(		
    	System::Int64 exe_id
    	);
    

    The IsParallel() function returns true if an executable decribes a parallel. A parallel is a program structure describing a list of executables that are to be executed concurrently.

    Arguments

    exe_id
    The identity of the executable.

    Related Functions

    Common Errors

    IsProbingWorkingstep()

    System::Boolean IsProbingWorkingstep(	
    	System::Int64 exe_id
    	);
    

    The IsProbingWorkingstep() function returns true if an executable decribes a workingstep that contains a probing operation. The Tolerance object contains functionality to manipulate probing operations and their associated tolerances.

    Arguments

    exe_id
    The identity of the executable.

    Related Functions

    Common Errors

    IsProgramStructure()

    System::Boolean IsProgramStructure(	
    	System::Int64 exe_id
    	);
    

    The IsProgramStructure() function returns true if an executable decribes a programming structure such as a workplan or selective.

    Arguments

    exe_id
    The identity of the executable.

    Related Functions

    Common Errors

    IsRough()

    System::Boolean IsRough(			
    	System::Int64 ws_id
    	);
    

    The IsRough() function returns true if the operation in a workplan is a roughing operation. Note some operations may not be finishing or roughing but if an operation is roughing then it cannot also be finishing and vice versa. See IsFinish

    Arguments

    ws_id
    The identity of the workingstep containing the operation.

    Common Errors

    IsSelective()

    System::Boolean IsSelective(		
    	System::Int64 exe_id
    	);
    
    boolean IsSelective(			
    	int exe_id
    	);
    

    The IsSelective() function returns true if an executable decribes a selective. A selective is a program structure describing a list of executables of which one is to be executed at run time.

    Arguments

    exe_id
    The identity of the executable.

    Related Functions

    Common Errors

    IsSiemensCycle81()/82()/83()/84()/840()

    System::Boolean IsSiemensCycle81(	
    	System::Int64 exe_id
    	);
    
    System::Boolean IsSiemensCycle82(	
    	System::Int64 exe_id
    	);
    
    System::Boolean IsSiemensCycle83(	
    	System::Int64 exe_id
    	);
    
    System::Boolean IsSiemensCycle84(	
    	System::Int64 exe_id
    	);
    
    System::Boolean IsSiemensCycle840(	
    	System::Int64 exe_id
    	);
    
    

    The IsSiemensCycleXXX() functions return true if the operation in a workingstep is one of the Siemens canned cycles for drilling and tapping. The cycles currently supported are Drill Centering (Cycle 81), Drill Counter Boring (Cycle 82), Deep Drilling (Cycle 83), Rigid Tapping (Cycle 84) and Rigid Tapping with compensating chuck (Cycle 840).

    Arguments

    exe_id
    The identity of an executable.

    Related Functions

    Common Errors

    IsWorkingstep()

    System::Boolean IsWorkingstep(		
    	System::Int64 exe_id
    	);
    
    boolean IsWorkingstep(			
    	int exe_id
    	);
    

    The IsWorkingstep() function returns true if an executable is a workingstep.

    Arguments

    exe_id
    The identity of the executable.

    Related Functions

    Common Errors

    IsWorkplan()

    System::Boolean IsWorkplan(		
    	System::Int64 exe_id
    	);
    
    boolean IsWorkplan(			
    	int exe_id
    	);
    

    The IsWorkplan() function returns true if an executable is a workplan.

    Arguments

    exe_id
    The identity of the executable.

    Related Functions

    Common Errors

    IsWorkplanWIthSetupAndFixture()

    System::Boolean IsWorkplanWIthSetupAndFixture(	
    	System::Int64 exe_id
    	);
    
    boolean IsWorkplanWIthSetupAndFixture(		
    	int exe_id
    	);
    

    The IsWorkplanWIthSetupAndFixture() function

    IsWorkplanWithSetup()

    System::Boolean IsWorkplanWithSetup(	
    	System::Int64 exe_id
    	);
    
    boolean IsWorkplanWithSetup(		
    	int exe_id
    	);
    

    The IsWorkplanWithSetup() function is similar to the IsWorkplan function but only returns true if an executable is a workplan with a setup.

    Arguments

    exe_id
    The identity of the workplan.

    Common Errors

    IsWorkplanWithSetupAndFixtureMount()

    System::Boolean IsWorkplanWithSetupAndFixtureMount(	
    	System::Int64 exe_id
    	);
    
    boolean IsWorkplanWithSetupAndFixtureMount(		
    	int exe_id
    	);
    

    The IsWorkplanWithSetupAndFixtureMount() function is similar to the IsWorkplan function but only returns true if an executable is a workplan with a setup and a fixture.

    Arguments

    exe_id
    The identity of the workplan.

    Common Errors

    IsWorkplanWithSetupAndWorkpieceMount()

    System::Boolean IsWorkplanWithSetupAndWorkpieceMount(	
    	System::Int64 exe_id
    	);
    
    boolean IsWorkplanWithSetupAndWorkpieceMount(		
    	int exe_id
    	);
    

    The IsWorkplanWithSetupAndWorkpieceMount() function

    NavigateExecutableToWorkplanCount/Next()

    System::Int64 NavigateExecutableToWorkplanCount(	
    	System::Int64 ex_id
    	);
    
    System::Int64 NavigateExecutableToWorkplanNext(
    	System::Int64 ex_id,
    	System::Int64 index
    	);
    

    The NavigateExecutableToWorkplanCount() function returns the count of the number of workplans that contain the given executable. An executable such as a workingstep may be used in one or more workplans. Most executables are only used in one workplan.

    The tolerance object contains navigate functions for many other types of data. In the API functions are named “navigate” when they traverse data in a direction opposite to the one defined by the STEP-NC data model.

    The NavigateExecutableToWorkplanNext() function returns the next workplan that uses an executable. An executable such as a workingstep may be used in one or more workplans. Most executables are only used in one workplan.

    Arguments

    exe_id
    The identity of the executable.
    index
    The position of the next workplan.

    Related Functions

    Common Errors

    Open224()

    void Open224(	 	
    	System::String^ file_name
    	);
    

    The Open224() function reads an AP-224 file and uses the workpiece and rawpiece data in that file to create an AP-238 project with that workpiece and rawpiece. The AP-238 project will have an empty main workplan and contain the features defined by the AP-224 file. The data can be read from both Part21 (ASCII) and Part 28 (XML) files. If the file has already been read by the APT object then it will be shared with the Finder object.

    Arguments

    file_name
    The name of the file that contains the AP-224 data.

    Related Functions

    Common Errors

    OpenProject()

    void OpenProject(			
    	System::String^ file_name
    	);
    
    void OpenProject(			
    	string file_name
    	);
    

    The OpenProject() function reads a STEP-NC data file containing an AP-238 project. The data can be read from both Part21 (ASCII) and Part 28 (XML) files. If the file has already been read by the APT object then it will be shared with the Finder object.

    In earlier versions, this function was called Open238()

    Arguments

    file_name
    The name of the file that contains the AP-238 data.

    Related Functions

    Common Errors

    OpenNewProject()

    void OpenNewProject(			
    	System::String^ file_name
    	);
    

    The OpenNewProject() function

    Opened238Strl()

    System::Int64 Opened238Strl(		
    	[System::Runtime::InteropServices::Out] System::Int64 %wp_id,
    	[System::Runtime::InteropServices::Out] System::Int64 %ws_id,
    	[System::Runtime::InteropServices::Out] System::Int64 %tp_id,
    	[System::Runtime::InteropServices::Out] double %d
    	);
    

    The Opened238Strl() function

    ProjectSpindleCount()

    System::Int64 ProjectSpindleCount(	);
    
    

    The ProjectSpindleCount() function returns the number of spindles required to execute a program that contains Parallel structures.

    If a project contains a single Parallel then the number of spindles required is the number of branches in that parallel.

    If a project contains multiple Parallel's in sequence then the number of spindles required is the number in the largest parallel.

    If a project contains nested parallels then the number of branches in the outer most parallel is computed as its number of branches plus the number of each branches in each of its nested parallels.

    Related Functions

    Common Errors

    Reset()

    void Reset();			
    

    The Reset() function resets the Finder object to its initial state. A closely related function called shutdown also resets the object but it also deletes all of the data in the object. Reset does not delete the data and this can be important in applications where multiple objects are sharing data in the same underlying file in the ROSE data management system. In this case all but the last object should execute a reset and after they have finished the last should shutdown.

    Reset and shutdown should only be used by advanced applications that are running a long time and need to conserve data resources.

    Related Functions

    SaveAsModules()

    void SaveAsModules(			
    	System::String^ file_name
    	);
    
    void SaveAsModules(			
    	string file_name
    	);
    

    The SaveAsModules() function saves the STEP-NC program as an AP-238 file in the XML (Part 28) format. A similar function called SaveAsPart21 save the STEP-NC program as an AP-238 file in the ASCII (Part 21) format. The format has to be specified in the save command but is transparent for the read commands because they will read files in either of the formats.

    Arguments

    file name
    Name of the file that is to be used to store the data.

    Related Functions

    Common Errors

    SaveAsP21()

    void SaveAsP21(			
    	System::String^ file_name
    	);
    
    void SaveAsP21(			
    	string file_name
    	);
    

    The SaveAsP21() function saves the STEP-NC program as an AP-238 file in the clear text (Part 21) format. A similar function called SaveAsModules save the STEP-NC program as an AP-238 file in the XML (Part 28) format. The format has to be specified in the save command but is transparent for the read commands because they will read files in either of the formats.

    Arguments

    file name
    Name of the file that is to be used to store the data.

    Related Functions

    Common Errors

    SetUseStixExportTransformOff/On()

    void SetUseStixExportTransformOff();	
    void SetUseStixExportTransformOn();
    

    The SetUseStixExportTransformOff() and SetUseStixExportTransformOn() functions control advanced capabilities for flexible setup.

    SiemensCycle81()/82()/83()/84()/840()

    System::Boolean SiemensCycle81(	
    	System::Int64 exe_id,
    	// Out parameters as defined by Siemens
    	[System::Runtime::InteropServices::Out] rtp, rfp, sdis, dp, dpr
    	);
    
    System::Boolean SiemensCycle82(	
    	System::Int64 exe_id,
    	// Parameters as defined by Siemens
    	[System::Runtime::InteropServices::Out]  rtp, rfp, sdis, dp, dpr, dtb
    	);
    
    System::Boolean SiemensCycle83(	
    	System::Int64 exe_id,
    	// Out parameters as defined by Siemens
    	[System::Runtime::InteropServices::Out]  rtp, rfp, sdis, dp, dpr, fdep, fdpr, dam, dtb, dps, frf, _vari, _axn, _mdep, _vrt, _dtd, _dis1
    	);
    
    System::Boolean SiemensCycle84(	
    	System::Int64 exe_id,
    	// Out parameters as defined by Siemens
    	[System::Runtime::InteropServices::Out]  rtp, rfp, sdis, dp, dpr, dtb, sdac, mpit, pit, poss, sst, sst1, _axn, _ptab, _techno, _vari, _dam, _vrt
    	);
    
    System::Boolean SiemensCycle840(	
    	System::Int64 exe_id,
    	// Out parameters as defined by Siemens
    	[System::Runtime::InteropServices::Out]  rtp, rfp, sdis, dp, dpr, dtb, sdr, sdac, enc, mpit, pit, _axn, _ptab, _techno
    	);
    
    

    The SiemensCycleXXX() functions return the values set for a Siemens operation. These parameters are defined by the Siemens canned cycles for drilling and tapping. The cycles currently supported are Drill Centering (Cycle 81), Drill Counter Boring (Cycle 82), Deep Drilling (Cycle 83), Rigid Tapping (Cycle 84) and Rigid Tapping with compensating chuck (Cycle 840).

    The functions return false if the system failed to find the corresponding cycle at the given exe_id.

    Arguments

    exe_id
    The identity of an executable.
    other parameters
    See the Siemens 840D Cycle Manual.

    Related Functions

    Common Errors

    Shutdown()

    void Shutdown();			
    

    The Shutdown() function is a version of the Reset() function that deletes all of the data in the finder object as well as resetting it to its initial state. If multiple applications are sharing the same Finder object then all but the last object should execute a reset and after they have finished the last should shut it down.