Finder

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:

A requested value. For example, the x, y and z coordinates of the next point in a tool path.
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.
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

GetProcessFeed: Gets the feedrate of a workingstep or toolpath.
GetProcessFeedUnit: Gets the units used by a feedrate in the data.

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

APIUnitsNative: Return length values as-is.
APIUnitsMM: Always convert length values to millimeter.

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: Return length values as-is.
APIUnitsInch: Always convert length values to inch.

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

APIUnitsInch: Always convert length values to inch.
APIUnitsMM: Always convert length values to millimeter.

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

GetProcessSpeed: Gets spindle speed of a workingstep or toolpath.
GetProcessSpeedUnit: Gets units used by spindle speed in the data.

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

Project not defined: There is no AP-238 file open.

GetAxisPlacement()

System::Boolean GetAxisPlacement(				System::Int64 ax_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 GetAxisPlacement() function returns true if a given identifier is an axis placement and puts the raw data of the placement into the parameters.

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

GetFeatureType: Returns the type of a feature.
GetFeatureAxisDirection: Returns the z direction of the axis of the compound feature.
GetFeatureAxisRefDirection: Returns the x direction of the axis of the compound feature.
GetFeatureAxisOrigin: Returns the origin of the axis of the compound feature.
See Final Features and Process Features for more information about features

Common Errors

Project not defined: There is no AP-238 file open.
Not a compound feature: GetCompoundFeatureCount should have returned 0.
Invalid index: The index is not in the range [0, Count – 1]

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

GetExecutableType: Return the type of an executable.
GetExecutableOptimizedTime: The time to execute the tool paths after optimizing the feeds and speeds using the cross section area curves.
GetExecutabeTimeUnit: The unit used for the two time functions.
GetExecutableDistance: The length of the non-rapid tool paths in the executable.
GetExecutableDistanceUnit: The unit used for the GetExecutableDistance function.

Common Errors

Project not defined: There is no AP-238 file open.
Invalid identity The argument does not identify an executable.

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

GetExecutableType: Returns the type of an executable as a string.

Common Errors

Project not defined: There is no AP-238 file open.
Duplicates: two or more executables contain this executable.

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

GetExecutableType: Return the type of an executable.
GetExecutableBaseTime: The time to execute the tool paths using the feeds and speeds programmed in the CAM.
GetExecutabeTimeUnit: The unit used for the two time functions.
GetExecutableDistance: The length of the non-rapid tool paths in the executable.
GetExecutableDistanceUnit: The unit used for the GetExecutableDistance function.
GetPathAreaCurveNext: Function to get the cross section area data used for feed and speed optimization for a tool path.
GetPathSpeed OverrideCurveNext: Function to get the feed override data for a tool path.

Common Errors

Project not defined: There is no AP-238 file open.
Invalid identity The argument does not identify an executable.

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

GetProcessFeed/Speed: Functions to return the feed and speed values of a technology entity.
GetWorkingstepTechnologyCount: Function to return a count of the technology used by the tool paths in a workingstep.
GetTechnologyByValue: Function to find the technology entity that contains a given feed and speed value.
GetTechnologyWorkingstepCount: Get a count of the workingsteps that use a technology.
GetExecutableTechnologyNext: Get the next technology used by an executable

Common Errors

Project not defined: There is no AP-238 file open.
Index out of range: The given in index is not in the range [0, GetTechnologyCount – 1]

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
	);

The GetExecutableType() function returns a string summarizing the type of the executable.

The following type names are returned if the executable is an NC function.

type = DISPLAY_MESSAGE
type = EXTENDED_NC_FUNCTION
type = INDEX_TABLE
type = LOAD_TOOL
type = PROGRAM_STOP
type = OPTIONAL_STOP
type = RETURN_HOME

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

type = NON_SEQUENTIAL
type = PARALLEL
type = SELECTIVE
type = TURNING_WORKINGSTEP
type = WORKPLAN

The following type name is returned if the executable is a machining workingstep.

type = MACHINING_WORKINGSTEP

NOTE Prior to version 18.47, the DLL returned the type of the operation in a machining_workingstep and not the above string. This was redundant because the operation type is delivered by the GetWorkingstepType() function.

Arguments

exe_id: The identity of the executable.

Related Functions

GetNestedExecutableNext: Returns an executable in a workplan or selective.
GetMainWorkplan: Returns the main workplan of a project.
GetWorkingstepType: Return the type of operation in a workingstep.
IsWorkingstep:
IsNcFunction:
IsProgramStructure:

Common Errors

Project not defined: There is no AP-238 file open.

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

GetExecutableWorkpieceToBe: Function to return the to-be workpiece of an executable.
GetExecutableWorkpieceAsIsLocal: Function to return only a locally defined workpiece of an executable.

Common Errors

Project not defined: There is no AP-238 file open.
Bad identity: The given id does not identify an executable.

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

GetExecutableWorkpieceAsIs: Function to return the workpiece that best defines the intital state of an executable.

Common Errors

Project not defined: There is no AP-238 file open.
Bad identity: The given id does not identify an executable.

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

GetExecutableWorkpieceRemovalLocal: Function currently returns the same result as this function.

Common Errors

Project not defined: There is no AP-238 file open.
Bad identity: The given id does not identify an executable.

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

GetExecutableWorkpieceRemoval: Function to a computed or locally defined removal volume.

Common Errors

Project not defined: There is no AP-238 file open.
Bad identity: The given id does not identify an executable.

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

GetExecutableWorkpieceAsIs: Function to return the as-is workpiece of an executable.
GetExecutableWorkpieceToBeLocal: Function to return only a locally defined workpiece of an executable.

Common Errors

Project not defined: There is no AP-238 file open.
Bad identity: The given id does not identify an executable.

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

GetExecutableWorkpieceToBe: Function to return the workpiece that best defines the final state of an executable.

Common Errors

Project not defined: There is no AP-238 file open.
Bad identity: The given id does not identify an executable.

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

GetFeatureType: Returns a type description of the feature.
GetFeatureName: Returns the name of the feature.
GetFeatureAxisOrigin: Returns the origin of the feature axis.
GetFeatureAxisDirection: Returns the z direction of the feature axis.
GetFeatureAxisRefDirection: Returns the x direction of the feature axis.
GetWorkingstepProcessFeature: Gets the process feature of a workingstep
GetWorkingstepFinalFeatureCount: Gets a count of the final features in a workingstep.
GetWorkingstepFinalFeatureNext: Gets one of the final features in a workingstep.

Common Errors

Project not defined: There is no AP-238 file open.
Invalid index: The index is not in the range defined by GetFeatureAllCount.

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

GetFeatureType: Returns a type description of the feature.
GetFeatureName: Returns the name of the feature.
GetFeatureAxisOrigin: Returns the origin of the feature axis.
GetFeatureAxisRefDirection: Returns the x direction of the feature axis.

Common Errors

Project not defined: There is no AP-238 file open.
Bad identity The argument does not identify a feature with an axis.

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

GetFeatureType: Returns a type description of the feature.
GetFeatureName: Returns the name of the feature.
GetFeatureAxisDirection: Returns the z direction of the feature axis.
GetFeatureAxisRefDirection: Returns the x direction of the feature axis.

Common Errors

Project not defined: There is no AP-238 file open.
Bad identity The argument does not identify a feature with an axis.

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

GetFeatureType: Returns a type description of the feature.
GetFeatureName: Returns the name of the feature.
GetFeatureAxisOrigin: Returns the origin of the feature axis.
GetFeatureAxisDirection: Returns the z direction of the feature axis.

Common Errors

Project not defined: There is no AP-238 file open.
Bad identity The argument does not identify a feature with an axis.

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

GetFeatureBossCount: Function to get the bosses on a feature.
GetFeatureBossType: Function to get the type of a boss
GetFeaturePocketClosedXx: Closed pockets can have bosses
GetFeaturePocketOpenXx: Open pockets can have bosses
GetFeaturePlanarFace: Planar face features can have bosses

Common Errors

Project not defined: There is no AP-238 file open.

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

GetFeatureBossType: Function to get the type of a boss

Common Errors

Project not defined: There is no AP-238 file open.

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

GetFeatureProfileSegmentCount Functons to iterate over the segments in a closed loop profile.
GetFeatureBossCount: Function to get the number of bosses on a feature.
GetFeatureBossType: Function to get the type of a boss
GetFeaturePocketClosedXx: Closed pockets can have bosses
GetFeaturePocketOpenXx: Open pockets can have bosses
GetFeaturePlanarFace: Planar face features can have bosses

Common Errors

Project not defined: There is no AP-238 file open.

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.; [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.; [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.; [out] Length (x dimension) of the boss
width
[out] Width (y dimension) of the boss
x, y, z
[out] Bottom of the boss.; [out] Width (y dimension) of the boss
x, y, z
[out] Bottom of the boss.; [out] Bottom of the boss.

Related Functions

GetFeatureAxisDirection: Returns the z direction of the axis of the boss.
GetFeatureAxisRefDirection: Returns the x direction of the axis of the boss.
GetFeatureBossCount: Function to get the bosses on a feature.
GetFeatureBossType: Function to get the type of a boss
GetFeaturePocketClosed: Closed pockets can have bosses
GetFeaturePocketOpen: Open pockets can have bosses
GetFeaturePlanarFace: Planar face features can have bosses

Common Errors

Project not defined: There is no AP-238 file open.

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

GetFeatureBossCount: Function to get a count of the number of bosses on a feature.

Common Errors

Project not defined: There is no AP-238 file open.
Index out of range: The index is not in the range defined by GetFeatureBossCount.

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

GetFeatureType: Returns a type description of the feature.

Common Errors

Project not defined: There is no AP-238 file open.

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

GetFeatureType: Returns the type of a feature.

Common Errors

Project not defined: There is no AP-238 file open.

GetFeatureDescription()

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

The GetFeatureDescription() function returns a string describing the usage of a feature. If there is no usage then the GetFeatureType() is returned. The following ussages are recognized

type = countersunk
type = countersunk(placed)
type = counterbore
type = counterbore(placed)
type = double counterbore
type = double counterbore(placed)
type = spotface
type = spotface(placed)
type = double spotface
type = double spotface(placed)

Arguments

feature_id: The identity of a feature.

Related Functions

GetFeatureType: Returns the type of a feature which is the default if no usage is recognized.

Common Errors

Project not defined: There is no AP-238 file open.

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

GetFeatureType: Returns the type of a feature.

Common Errors

Project not defined: There is no AP-238 file open.

GetExecutableFaceCount/Next/All()

System::Int64 GetExecutableFaceCount(		
	System::Int64 exe_id
	);

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

System::Collections::Generic::List^ GetExecutableFaceAll(
	System::Int64 exe_id
	);

The GetExecutableFaceCount() function returns a count of the number of faces machined by the executable. The function returns 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.

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

The GetExecutableFaceAll() function returns all the faces in a bag.

If either function is given the id of another type of executable then it will return a count of all the faces in all of the features of all of the workingsteps in that executable. This includes workingsteps belonging to a tree of workplans or other program structures.

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

Arguments

exe_id: The identity of workingstep, workplan or other type of program executable.
index: The index of the requested face.

Common Errors

Project not defined: There is no AP-238 file open.
Invalid identifier: The id must identify a workplan, workingstep, or other type of program structure.
Invalid index The index is not in the range defined by GetFeatureFaceCount.

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

GetFeatureAxisDirection: Returns the z direction of the axis of the feature.
GetFeatureType: Returns the type of a feature.
GetFeatureHoleBottomType: Returns the type of the hole bottom

Common Errors

Project not defined: There is no AP-238 file open.

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

GetFeatureHole: Returns the parameters of the round hole.
GetFeatureHoleBottomType: Returns the type of the hole bottom.

Common Errors

Project not defined: There is no AP-238 file open.
Not a hole. The given identity does not identify a round hole.

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

GetFeatureHole: Returns the parameters of the round hole.
GetFeatureHoleBottomType: Returns the type of the hole bottom.

Common Errors

Project not defined: There is no AP-238 file open.
Not a hole. The given identity does not identify a round hole.

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

GetFeatureHole: Returns the parameters of the round hole.
GetFeatureHoleBottomType: Returns the type of the hole bottom.

Common Errors

Project not defined: There is no AP-238 file open.
Not a hole. The given identity does not identify a round hole.

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

GetFeatureHole: Returns the parameters of the round hole.
GetFeatureHoleBottomType: Returns the type of the hole bottom.

Common Errors

Project not defined: There is no AP-238 file open.
Not a hole. The given identity does not identify a round hole.

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

GetFeatureHole: Returns the parameters of the round hole.
GetFeatureHoleBottomType: Returns the type of the hole bottom.

Common Errors

Project not defined: There is no AP-238 file open.
Not a hole. The given identity does not identify a round hole.

GetFeatureHoleBottomType()/Description()

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

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

unknown
CONICAL_HOLE_BOTTOM
FLAT_HOLE_BOTTOM
FLAT_WITH_RADIUS_HOLE_BOTTOM
SPHERICAL_HOLE_BOTTOM.
THROUGH_BOTTOM_CONDITION

The GetFeatureHoleBottomDescription() function returns a high level classifcation of the bottom type as one of the following strings.

unknown
thru
blind

All holes are classified as blind except those with a "THROUGH_BOTTOM_CONDITION" which are classified as thru.

Arguments

feature_id: The identity of the round hole feature.

Related Functions

GetFeatureHole: Returns the parameters of the round hole.
GetFeatureHoleBottomCanonical: Returns the parameters of a conical hole bottom.
GetFeatureHoleBottomFlat: A flat hole bottom has no parameters,
GetFeatureHoleBottomFlatWithRadius: Returns the parameters of a radiused hole bottom.
GetFeatureHoleBottomSpherical: Returns the parameters of a spherical hole bottom.
GetFeatureHoleBottomThrough: A through hole has no parameters.

Common Errors

Project not defined: There is no AP-238 file open.

GetFeatureHoleCounterbore()

System::Boolean GetFeatureHoleCounterbore(	
	System::Int64 feature_id,
	[System::Runtime::InteropServices::Out] System::Int64 %small_hole_id,
	[System::Runtime::InteropServices::Out] System::Int64 %large_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.
small_hole_id: [out] The identity of the small hole or 0.
large_hole_id: [out] The identity of the large hole or 0.

Related Functions

GetFeatureHoleCounterboreDimensions: Returns the dimensions of a counterbore hole.
GetFeatureHoleCountersunkDimensions: Returns the dimensions of a countersunk hole.
GetFeatureHoleDoubleCounterbore: Returns the dimensions of a double counterbore hole.
GetFeatureAxisDirection: Returns the z direction of the axis of the feature.
GetFeatureAxisRefDirection: Returns the x direction of the axis of the feature.
GetFeatureAxisOrigin: Returns the origin of the feature.
GetFeatureType: Returns the type of a feature.

Common Errors

Project not defined: There is no AP-238 file open.

GetFeatureHoleCounterboreDimensions()

System::Boolean GetFeatureHoleCounterboreDimensions(	
	System::Int64 feature_id,
	[System::Runtime::InteropServices::Out] double %small_hole_depth,
	[System::Runtime::InteropServices::Out] double %small_hole_diameter,
	[System::Runtime::InteropServices::Out] double %large_hole_depth,
	[System::Runtime::InteropServices::Out] double %large_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.
small_hole_depth: [out] The small hole depth.
small_hole_diameter: [out] The small hole diameter.
large_hole_depth: [out] The large hole depth.
large_hole_diameter: [out] The large hole diameter.

Related Functions

GetFeatureHoleCounterbore: Returns the identities of the large and small hole.
GetFeatureHoleCountersunkDimensions: Returns the dimensions of a countersunk hole.
GetFeatureType: Returns the type of a feature.

Common Errors

Project not defined: There is no AP-238 file open.

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

GetFeatureHoleCountersunkDimensions: Returns the dimensions of a countersunk hole.
GetFeatureHoleCounterboreDimensions: Returns the dimensions of a counterbore hole.
GetFeatureHoleTaperAngle: Returns the angle of a tapered hole.
GetFeatureAxisDirection: Returns the z direction of the axis of the feature.
GetFeatureAxisRefDirection: Returns the x direction of the axis of the feature.
GetFeatureAxisOrigin: Returns the origin of the feature.
GetFeatureType: Returns the type of a feature.

Common Errors

Project not defined: There is no AP-238 file open.

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

GetFeatureHoleCountersunk: Returns the identity of the constant hole.
GetFeatureHoleCounterboreDimensions: Returns the dimensions of a counterbore hole.
GetFeatureType: Returns the type of a feature.

Common Errors

Project not defined: There is no AP-238 file open.

GetFeatureHoleDoubleCounterbore()

System::Boolean GetFeatureHoleDoubleCounterbore(	
	System::Int64 feature_id,
	[System::Runtime::InteropServices::Out] System::Int64 %small_hole_id,
	[System::Runtime::InteropServices::Out] System::Int64 %midle_hole_id,
	[System::Runtime::InteropServices::Out] System::Int64 %large_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.
small_hole_id: [out] The identity of the small hole or 0.
middle_hole_id: [out] The identity of the middle hole or 0.
large_hole_id: [out] The identity of the large hole or 0.

Related Functions

GetFeatureHoleDoubleCounterboreDimensions: Returns the dimensions of a double counterbore hole.
GetFeatureHoleCounterbore: Returns the properties of a single counterbore hole.
GetFeatureAxisDirection: Returns the z direction of the axis of the feature.
GetFeatureAxisRefDirection: Returns the x direction of the axis of the feature.
GetFeatureAxisOrigin: Returns the origin of the feature.
GetFeatureType: Returns the type of a feature.

Common Errors

Project not defined: There is no AP-238 file open.

GetFeatureHoleDoubleCounterboreDimensions()

System::Boolean GetFeatureHoleDoubleCounterboreDimensions(	System::Int64 feature_id,
	[System::Runtime::InteropServices::Out] double %small_hole_depth,
	[System::Runtime::InteropServices::Out] double %small_hole_diameter,
	[System::Runtime::InteropServices::Out] double %middle_hole_depth,
	[System::Runtime::InteropServices::Out] double %middle_hole_diameter,
	[System::Runtime::InteropServices::Out] double %large_hole_depth,
	[System::Runtime::InteropServices::Out] double %large_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.
small_hole_depth: [out] The small hole depth.
small_hole_diameter: [out] The small hole diameter.
middle_hole_depth: [out] The middle hole depth.
middle_hole_diameter: [out] The middle hole diameter.
large_hole_depth: [out] The large hole depth.
large_hole_diameter: [out] The large hole diameter.

Related Functions

GetFeatureHoleCounterbore: Returns the identities of the large and small hole.
GetFeatureHoleCounterboreDimensions: Returns the dimensions of a single counterbore hole.
GetFeatureType: Returns the type of a feature.

Common Errors

Project not defined: There is no AP-238 file open.

GetFeatureHoleSpotface()

System::Boolean GetFeatureHoleSpotface(	
	System::Int64 feature_id,
	[System::Runtime::InteropServices::Out] System::Int64 %small_hole_id,
	[System::Runtime::InteropServices::Out] System::Int64 %large_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.
small_hole_id: [out] The identity of the small hole or 0.
large_hole_id: [out] The identity of the large hole or 0.
bot_hole_id: [out] The identity of the hole bottom for the large hole or 0.

Related Functions

GetFeatureHoleCounterboreDimensions: Returns the dimensions of a counterbore hole.
GetFeatureHoleCountersunkDimensions: Returns the dimensions of a countersunk hole.
GetFeatureHoleSpotfaceDimensions: Returns the dimensions of a spotface hole.
GetFeatureHoleDoubleSpotface: Returns the holes in a double spotface hole.
GetFeatureAxisDirection: Returns the z direction of the axis of the feature.
GetFeatureAxisRefDirection: Returns the x direction of the axis of the feature.
GetFeatureAxisOrigin: Returns the origin of the feature.
GetFeatureType: Returns the type of a feature.

Common Errors

Project not defined: There is no AP-238 file open.

GetFeatureHoleSpotfaceDimensions()

System::Boolean GetFeatureHoleSpotfaceDimensions(	
	System::Int64 feature_id,
	[System::Runtime::InteropServices::Out] double %small_hole_depth,
	[System::Runtime::InteropServices::Out] double %small_hole_diameter,
	[System::Runtime::InteropServices::Out] double %large_hole_radius,
	[System::Runtime::InteropServices::Out] double %large_hole_depth,
	[System::Runtime::InteropServices::Out] double %large_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.
small_hole_depth: [out] The small hole depth.
small_hole_diameter: [out] The small hole diameter.
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.

Related Functions

GetFeatureHoleDoubleSpotface: Returns the identities of a double spotface hole.
GetFeatureHoleDoubleSpotfaceDimensions: Returns the dimensions of a double spotface hole.
GetFeatureType: Returns the type of a feature.

Common Errors

Project not defined: There is no AP-238 file open.

GetFeatureHoleDoubleSpotface()

System::Boolean GetFeatureHoleDoubleSpotface(	
	System::Int64 feature_id,
	[System::Runtime::InteropServices::Out] System::Int64 %small_hole_id,
	[System::Runtime::InteropServices::Out] System::Int64 %middle_hole_id,
	[System::Runtime::InteropServices::Out] System::Int64 %middle_bot_id,
	[System::Runtime::InteropServices::Out] System::Int64 %large_hole_id,
	[System::Runtime::InteropServices::Out] System::Int64 %large_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.
small_hole_id: [out] The identity of the small hole or 0.
middle_hole_id: [out] The identity of the middle hole or 0.
middle_bot_id: [out] The identity of the middle hole bottom or 0.
large_hole_id: [out] The identity of the large hole or 0.
large_bot_id: [out] The identity of the large hole bottom or 0.

Related Functions

GetFeatureHoleDoubleSpotfaceDimensions: Returns the dimensions of a double spotface hole.
GetFeatureHoleCounterbore: Returns the properties of a single counterbore hole.
GetFeatureAxisDirection: Returns the z direction of the axis of the feature.
GetFeatureAxisRefDirection: Returns the x direction of the axis of the feature.
GetFeatureAxisOrigin: Returns the origin of the feature.
GetFeatureType: Returns the type of a feature.

Common Errors

Project not defined: There is no AP-238 file open.

GetFeatureHoleDoubleSpotfaceDimensions()

System::Boolean GetFeatureHoleDoubleSpotfaceDimensions(	
	System::Int64 feature_id,
	[System::Runtime::InteropServices::Out] double %small_hole_depth,
	[System::Runtime::InteropServices::Out] double %small_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 %large_hole_radius,
	[System::Runtime::InteropServices::Out] double %large_hole_depth,
	[System::Runtime::InteropServices::Out] double %large_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.
small_hole_depth: [out] The small hole depth.
small_hole_diameter: [out] The small 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.
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.

Related Functions

GetFeatureHoleCounterbore: Returns the identities of the large and small hole.
GetFeatureHoleSpotfaceDimensions: Returns the dimensions of a single spotface hole.
GetFeatureType: Returns the type of a feature.

Common Errors

Project not defined: There is no AP-238 file open.

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

GetFeatureHole: Returns the other parameters of a round hole.
GetFeatureType: Returns the type of a feature.

Common Errors

Project not defined: There is no AP-238 file open.
Invalid identity: The given identity does not define a hole

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

GetFeatureType: Returns the type of a feature.

Common Errors

Project not defined: There is no AP-238 file open.

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

GetFeatureAxisDirection: Returns the z direction of the axis of the feature.
GetFeatureAxisRefDirection: Returns the x direction of the axis of the feature.
GetFeatureType: Returns the type of a feature.

Common Errors

Project not defined: There is no AP-238 file open.

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

GetFeatureAxisDirection: Returns the z direction of the axis of the feature.
GetFeatureAxisRefDirection: Returns the x direction of the axis of the feature.
GetFeatureType: Returns the type of a feature.
GetFeatureProfileSegmentCount/ Iterate over the segments in a closed loop profile.

Common Errors

Project not defined: There is no AP-238 file open.

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.

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

GetFeatureAxisDirection: Returns the z direction of the axis of the feature.
GetFeatureAxisRefDirection: Returns the x direction of the axis of the feature.
GetFeatureType: Returns the type of a feature.

Common Errors

Project not defined: There is no AP-238 file open.

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.

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

GetFeatureAxisDirection: Returns the z direction of the axis of the feature.
GetFeatureAxisRefDirection: Returns the x direction of the axis of the feature.
GetFeatureType: Returns the type of a feature.

Common Errors

Project not defined: There is no AP-238 file open.

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.

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

GetFeatureAxisDirection: Returns the z direction of the axis of the feature.
GetFeatureAxisRefDirection: Returns the x direction of the axis of the feature.
GetFeatureType: Returns the type of a feature.
GetFeatureProfileSegmentCount Iterate over the segments in a closed loop profile.

Common Errors

Project not defined: There is no AP-238 file open.

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.

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

GetFeatureAxisDirection: Returns the z direction of the axis of the feature.
GetFeatureAxisRefDirection: Returns the x direction of the axis of the feature.
GetFeatureType: Returns the type of a feature.

Common Errors

Project not defined: There is no AP-238 file open.

GetFeaturePlacedType()

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

The GetFeaturePlacedType() function returns the underlying feature 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.

Arguments

placed_id: The identity of a placed feature.

Related Functions

GetFeatureTemplate: Returns the identity of the template feature.
GetFeatureType: Returns the type of a feature. This will be "PLACED_FEATURE" for a placed feature.

Common Errors

Project not defined: There is no AP-238 file open.

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

GetFeatureAxisDirection: Returns the z direction of the axis of the feature.
GetFeatureAxisRefDirection: Returns the x direction of the axis of the feature.
GetFeatureType: Returns the type of a feature.

Common Errors

Project not defined: There is no AP-238 file open.

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

GetFeaturePocketBottomType: Returns a string describing the type of the pocket bottom.

Common Errors

Project not defined: There is no AP-238 file open.
Invalid identifier: The given identifier does not identify a pocket.

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

GetFeaturePocketBottomType: Returns a string describing the type of the pocket bottom.

Common Errors

Project not defined: There is no AP-238 file open.
Invalid identifier: The given identifier does not identify a pocket.

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

GetFeaturePocketBottomType: Returns a string describing the type of the pocket bottom.

Common Errors

Project not defined: There is no AP-238 file open.
Invalid identifier: The given identifier does not identify a pocket.

GetFeaturePocketBottomType()

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

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

unknown
PLANAR_POCKET_BOTTOM_CONDITION
RADIUSED_POCKET_BOTTOM_CONDITION
THROUGH_POCKET_BOTTOM_CONDITION.

Arguments

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

Related Functions

GetFeaturePocketBottomFlat: A flat hole bottom may have a fillet radius
GetFeaturePocketBottomRadiused: Returns the parameters of a radiused bottom.
GetFeaturePocketBottomThrough: A through hole has no parameters.

Common Errors

Project not defined: There is no AP-238 file open.

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

GetFeatureAxisDirection: Returns the direction of the axis of the feature.
GetFeatureType: Returns the type of a feature.
GetFeaturePocketBottomType: Returns a string describing the type of the pocket bottom.

Common Errors

Project not defined: There is no AP-238 file open.

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.

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

GetFeatureAxisDirection: Returns the direction of the axis of the feature.
GetFeatureType: Returns the type of a feature.
GetFeaturePocketBottomType: Returns a string describing the type of the pocket bottom.
GetFeatureProfileSegmentCount/Next Functions to iterate over the segments in a closed loop profile.

Common Errors

Project not defined: There is no AP-238 file open.

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.

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

GetFeatureAxisDirection: Returns the direction of the axis of the feature.
GetFeatureAxisRefDirection: Returns the direction of the X axis of the feature.
GetFeatureType: Returns the type of a feature.
GetFeaturePocketBottomType: Returns a string describing the type of the pocket bottom.

Common Errors

Project not defined: There is no AP-238 file open.

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.

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

GetFeatureAxisDirection: Returns the direction of the axis of the feature.
GetFeatureAxisRefDirection: Returns the direction of the X axis of the feature.
GetFeatureType: Returns the type of a feature.
GetFeaturePocketBottomType: Returns a string describing the type of the pocket bottom.

Common Errors

Project not defined: There is no AP-238 file open.

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.

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

GetFeatureAxisDirection: Returns the direction of the axis of the feature.
GetFeatureAxisRefDirection: Returns the direction of the X axis of the feature.
GetFeatureType: Returns the type of a feature.
GetFeaturePocketBottomType: Returns a string describing the type of the pocket bottom.
GetFeatureProfileSegmentCount/Next Functions to iterate over the segments in a closed loop profile.

Common Errors

Project not defined: There is no AP-238 file open.

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.

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

GetFeatureAxisDirection: Returns the direction of the axis of the feature.
GetFeatureAxisRefDirection: Returns the direction of the X axis of the feature.
GetFeatureType: Returns the type of a feature.
GetFeaturePocketBottomType: Returns a string describing the type of the pocket bottom.

Common Errors

Project not defined: There is no AP-238 file open.

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

Project not defined: There is no AP-238 file open.
Invalid identifier: The given identifier does not identify a pocket.

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

GetFeatureSlot: A slot can be defined by a rounded U or square U profile.
GetFeaturePocketOpenRectangular: An open rectangular pocket is defined by a square U profile.
GetFeaturePocketClosedGeneral: A general closed pocket is defined by a depth and a closed general profile.
GetFeaturePocketOpenGeneral: A general open pocket is defined by a depth and an open general profile.
GetFeatureOutsideProfileClosedGeneral: A general outside profile is defined by a depth and a closed general profile.
GetFeatureOutsideProfileOpenGeneral: A general outside profile is defined by a depth and an open general profile.

Common Errors

Project not defined: There is no AP-238 file open.

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

GetFeatureSlot: A slot can be defined by a rounded U.
GetFeatureProfile: Returns the identity of the profile of a feature.

Common Errors

Project not defined: There is no AP-238 file open.

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

GetFeatureProfile: Returns the identity of the profile of a feature.
GetFeaturePocketClosedGeneral: A general closed pocket is defined by a depth and a closed general profile.
GetFeaturePocketOpenGeneral: A general open pocket is defined by a depth and an open general profile.
GetFeatureOutsideProfileClosedGeneral: A general outside profile is defined by a depth and a closed general profile.
GetFeatureOutsideProfileOpenGeneral: A general outside profile is defined by a depth and an open general profile.
GetPathArc Returns the parameters of an arc segment
GetPathPolylinePointCount Returns the number of points in a polyline segment.
GetPathPolylinePointNext Returns a point in the polyline.
Currently the API only supports polyline and arc segments.

Common Errors

Project not defined: There is no AP-238 file open.
Invalid index: The given index is not in the range defined by GetFeatureProfileSegmentCount.

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

GetFeatureSlot: A slot can be defined by a square U.
GetFeaturePocketOpenRectangular: An open rectangular pocket is defined by a square u.
GetFeatureProfile: Returns the identity of the profile of a feature.

Common Errors

Project not defined: There is no AP-238 file open.

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.

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

GetFeatureAxisDirection: Returns the direction of the axis of the feature.
GetFeatureAxisRefDirection: Returns the direction of the X axis of the feature.
GetFeatureType: Returns the type of a feature.

Common Errors

Project not defined: There is no AP-238 file open.

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.

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

GetFeatureAxisDirection: Returns the direction of the axis of the feature.
GetFeatureAxisRefDirection: Returns the direction of the X axis of the feature.
GetFeatureType: Returns the type of a feature.
GetFeatureSlotEnd: Returns the type of the slot end.

Common Errors

Project not defined: There is no AP-238 file open.

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:

unknown
flat
radiused
open
woodruff

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

GetFeatureSlot: Returns the identities of the slot ends.

Common Errors

Project not defined: There is no AP-238 file open.

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.

type = CLOSED_POCKET
type = COMPOUND_FEATURE
type = COUNTERBORE_HOLE
type = COUNTERBORE_HOLE_TEMPLATE
type = COUNTERSUNK_HOLE
type = COUNTERSUNK_HOLE_TEMPLATE
type = DEFINED_THREAD
type = GENERAL_PATTERN
type = OPEN_POCKET
type = GENERAL_OUTSIDE_PROFILE
type = PLACED_FEATURE
type = PLANAR_FACE
type = REGION
type = ROUND_HOLE
type = ROUND_HOLE_TEMPLATE
type = ROUNDED_END
type = SLOT
type = SPHERICAL_CAP
type = STEP

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

type = TOOLPATH_FEATURE

The following type names are returned for the turning features.

type = GROOVE
type = OUTER_DIAMETER
type = OUTER_DIAMETER_TO_SHOULDER

The following type names are returned for the transition features.

type = CHAMFER
type = EDGE_ROUND

Arguments

feature_id: The identity of a feature.

Related Functions

GetFeatureDescription: Returns a description of the usage of a feature.
GetFeatureTemplate: Returns the identity of the template used to make a feature or 0.

Common Errors

Project not defined: There is no AP-238 file open.

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. 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

GetFeaturePlacedType: Returns the type of the template in a placed feature.
GetFeatureType: Returns the type of the feature.
GetFeatureDescription: Returns a description of the usage of the feature.

Common Errors

Project not defined: There is no AP-238 file open.

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

GetFinalpieceCount: A count of the number of finalpieces in the project.
GetWorkpieceCount: Get a count of all the workpieces in a project.

Common Errors

Project not defined: There is no AP-238 file open.
Invalid index Must be in the range [0, GetFinalpieceCount – 1]

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

GetExecutableType: Returns the type of an executable. If the executable is a Display message function then the function will return the value DISPLAY_MESSAGE.
GetNestedExecutableNext: Returns the identifier of an executable in a workplan using an index.
GetExecutableName: Returns the name the display function.
IsNcFunction: Returns true if an executable is an NC function.

Common Errors

Project not defined: There is no AP-238 file open.
Not a display function: The argument does not identify a display function.

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

GetExecutableType: Returns the type of an executable. If the executable is a Display message function then the function will return the value EXTENDED_NC_FUNCTION.
GetNestedExecutableNext: Returns the identifier of an executable in a workplan using an index.
GetExecutableName: Returns the name the display function.
IsNcFunction: Returns true if an executable is an NC function.

Common Errors

Project not defined: There is no AP-238 file open.
Not an Extended function: The argument does not identify an extended NC function.

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

GetExecutableType: Returns the type of an executable. If the executable is a index table function then the function will return the value INDEX_TABLE.
GetNestedExecutableNext: Returns the identifier of an executable in a workplan using an index.
GetExecutableName: Returns the name the display function.
IsNcFunction: Returns true if an executable is an NC function.

Common Errors

Project not defined: There is no AP-238 file open.
Not a index table function: The argument does not identify an index table function.

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

IsWorkplan: Returns true if an executable is a workplan.

Common Errors

Project not defined: There is no AP-238 file open.
Wrong type: The argument does not identify a workplan.

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. If no nmae has been set then the value_set parameter is set to false.

Arguments

wp_id: The identity of the workplan.

Related Functions

IsWorkplan: Returns true if an executable is a workplan.

Common Errors

Project not defined: There is no AP-238 file open.
Wrong type: The argument does not identify a workplan.

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

IsWorkplan: Returns true if an executable is a workplan.

Common Errors

Project not defined: There is no AP-238 file open.
Wrong type: The argument does not identify a workplan.

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

IsWorkplan: Returns true if an executable is a workplan.

Common Errors

Project not defined: There is no AP-238 file open.
Wrong type: The argument does not identify a workplan.

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

IsWorkplan: Returns true if an executable is a workplan.

Common Errors

Project not defined: There is no AP-238 file open.
Wrong type: The argument does not identify a workplan.

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

GetWorkplanExecutableCount: Returns the number of executables in a workplan.
GetWorkplanExecutableNext: Returns the next executable in a workplan using an index.
GetExecutableType: Return the type of an executable as a string.
GetExecutableName: Returns the name of an executable.

Common Errors

Project not defined: There is no AP-238 file open.

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

GetSurfacePropertyForWorkpiece: The surface property of a workpiece.
GetSurfacePropertyForWorkingstep: The surface property for a workingstep.

Common Errors

Project not defined: There is no AP-238 file open.
Multiple workpieces: If there are multiple workpieces then the function cannot pick the material.

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, Non-sequential, Selective or Parallel. An executable is something that is executed. Workplans, Non-sequentials, 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 Non-sequential contains a list of executables whose order does not matter or has not yet been set.

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, non-sequential, selective or parallel.

The GetNestedExecutableAllEnabled() function returns all the enabled executables in a workplan, non-sequential, 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

GetExecutableType: Return the type of an executable as a string.
GetExecutableName: Returns the name of an executable.
GetWorkplanExecutableCount: Returns the number of executables in a workplan.
GetSelectiveExecutableCount: Returns the number of executables in a selective.
IsEnabled: Returns true if an executable is enabled.

Common Errors

Project not defined: There is no AP-238 file open.
Invalid index: The index is not in the range defined by GetNestedExecutableCount

GetNonSequentialExecutableCount/Next/All/AllEnabled()

System::Int64 GetNonSequentialExecutableCount
	System::Int64 ns_id
	);
System::Int64 GetNonSequentialExecutableNext(
	 System::Int64 ns_id,
	 System::Int64 index
	 );
System::Collections::Generic::List<System::Int64>^ GetNonSequentialExecutableAll(
	System::Int64 ns_id
	);
System::Collections::Generic::List<System::Int64>^ GetNonSequentialExecutableAllEnabled(
	System::Int64 ns_id
	);

The GetNonSequentialExecutableCount() function returns a count of the number of executables contained in a NonSequential. A NonSequential is a list of executables for which the order of execution does not matter or has not yet been set.

The GetNonSequentialExecutableNext() function returns the next executable in a NonSequential using an index.

The GetNonSequentialExecutableAll() function returns the identity of all the nested executables in the non-sequential.

The GetNonSequentialExecutableAllEnabled() function returns the identity of the enabled executables in a non-sequential.

Arguments

ns_id: The identity of the NonSequential that contains the list.
index: The index of the requested member. The index is used to define an order of access only.

Related Functions

GetExecutableName: Returns the name of one executable in the selective
GetExecutableType: Returns the type of one executable in the selective.
GetNestedExecutableCount: Returns the number of executables in a program structure.
IsEnabled: Returns true if an executable is enabled.

Common Errors

Project not defined: There is no AP-238 file open.
Invalid identity: The input does not identify a non-sequential.
Invalid index: The index is not in the range defined by GetSelectiveExecutableCount

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

IsWorkingstep: Returns true if an executable is a Machining workingstep.
GetNestedExecutableNext: Iterates over the contents of a workplan or selective.
GetFeatureHole: Returns data about the hole being bored.

Common Errors

Project not defined: There is no AP-238 file open.
Incorrect type: The parameter does not identify a workingstep.

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

IsWorkingstep: Returns true if an executable is a Machining workingstep.
GetNestedExecutableNext: Iterates over the contents of a workplan or selective.
GetFeatureHole: Returns data about the hole being bored.

Common Errors

Project not defined: There is no AP-238 file open.
Incorrect type: The parameter does not identify a workingstep.

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

IsWorkingstep: Returns true if an executable is a Machining workingstep.
GetFeatureHole: Returns data about the hole being bored.
GetOperationDrilling: Returns data about a drilling operation.
GetOperationDrillingStrategyParameterStatus:
Returns flags indicating which parameters are set. For C++ applications unset parameters are set to the value ROSE_NULL_REAL.

Common Errors

Project not defined: There is no AP-238 file open.
Incorrect type: The parameter does not identify a workingstep.
No operation: The workingstep does not have an operation defined.

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

GetOperationDrilling: Returns data about a drilling operation.
GetOperationDrillingStrategyParameterStatus: Returns flags indicating which parameters are set including the end parameters. For C++ applications unset parameters are set to the value ROSE_NULL_REAL.

Common Errors

Project not defined: There is no AP-238 file open.
Incorrect type: The parameter does not identify a workingstep.
No operation: The workingstep does not have an operation defined.

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

IsWorkingstep: Returns true if an executable is a Machining workingstep.
GetFeatureHole: Returns data about the hole being bored.
GetOperationDrilling: Returns data about a drilling operation.
GetOperationDrillingStrategy: Returns the strategy data.
GetOperationDrillingStrategyStart: Returns the data set in the strategy object for the start.
GetOperationDrillingStrategyEnd: Returns the data set in the strategy object for the end.

Common Errors

Project not defined: There is no AP-238 file open.
Incorrect type: The parameter does not identify a workingstep.
No operation: The workingstep does not have an operation defined.

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

GetOperation Drilling: Returns data about a drilling operation.
GetOperationDrillingStrategyParameterStatus:
Returns flags indicating which parameters are set including the start parameters. For C++ applications unset parameters are set to the value ROSE_NULL_REAL.

Common Errors

Project not defined: There is no AP-238 file open.
Incorrect type: The parameter does not identify a workingstep.
No operation: The workingstep does not have an operation defined.

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

IsWorkingstep: Returns true if an executable is a Machining workingstep.
GetNestedExecutableNext: Iterates over the contents of a workplan or selective.
IsRough: Returns true if this is a roughing operation.
IsFinish: Returns true if this is a finishing operation.
GetWorkingstepPathNext: Iterates over the optional tool paths in a milling operation.

Common Errors

Project not defined: There is no AP-238 file open.
Incorrect type: The parameter does not identify a workingstep.

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

IsWorkingstep: Returns true if an executable is a Machining workingstep.
GetNestedExecutableNext: Iterates over the contents of a workplan or selective.
IsRough: Returns true if this is a roughing operation.
IsFinish: Returns true if this is a finishing operation.
GetWorkingstepPathNext: Iterates over the optional tool paths in a milling operation.
GetFeaturePlanarFace: Returns the parameters desribing a planar face.

Common Errors

Project not defined: There is no AP-238 file open.
Incorrect type: The parameter does not identify a workingstep.

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

IsWorkingstep: Returns true if an executable is a Machining workingstep.
GetNestedExecutableNext: Iterates over the contents of a workplan or selective.
IsRough: Returns true if this is a roughing operation.
IsFinish: Returns true if this is a finishing operation.
GetWorkingstepPathNext: Iterates over the optional tool paths in a milling operation.
GetFeaturePocketClosed: Returns the parameters desribing a closed pocket.
GetFeaturePocketOpen: Returns the parameters describing an open pocket.

Common Errors

Project not defined: There is no AP-238 file open.
Incorrect type: The parameter does not identify a workingstep.

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

IsWorkingstep: Returns true if an executable is a Machining workingstep.
GetNestedExecutableNext: Iterates over the contents of a workplan or selective.
IsRough: Returns true if this is a roughing operation.
IsFinish: Returns true if this is a finishing operation.
GetWorkingstepPathNext: Iterates over the tool paths in a free form operation.

Common Errors

Project not defined: There is no AP-238 file open.
Incorrect type: The parameter does not identify a workingstep.

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

IsWorkingstep: Returns true if an executable is a Machining workingstep.
GetNestedExecutableNext: Iterates over the contents of a workplan or selective.
IsRough: Returns true if this is a roughing operation.
IsFinish: Returns true if this is a finishing operation.
GetWorkingstepPathNext: Iterates over the optional tool paths in a milling operation.
GetFeatureOutsideProfileClosed: Returns the parameters desribing a closed profile.
GetFeatureOutsideProfileOpen: Returns the parameters describing an open profile.

Common Errors

Project not defined: There is no AP-238 file open.
Incorrect type: The parameter does not identify a workingstep.

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

IsWorkingstep: Returns true if an executable is a Machining workingstep.
GetNestedExecutableNext: Iterates over the contents of a workplan or selective.
IsRough: Returns true if this is a roughing operation.
IsFinish: Returns true if this is a finishing operation.
GetOperationMilling: Get the parameters of a milling operation.

Common Errors

Project not defined: There is no AP-238 file open.
Incorrect type: The parameter does not identify a workingstep.
No operation: The workingstep does not have an operation defined.

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

IsWorkingstep: Returns true if an executable is a Machining workingstep.
GetNestedExecutableNext: Iterates over the contents of a workplan or selective.
IsRough: Returns true if this is a roughing operation.
IsFinish: Returns true if this is a finishing operation.
GetOperationMilling: Get the parameters of a milling operation.

Common Errors

Project not defined: There is no AP-238 file open.
Incorrect type: The parameter does not identify a workingstep.
No operation: The workingstep does not have an operation defined.

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

IsWorkingstep: Returns true if an executable is a Machining workingstep.
GetNestedExecutableNext: Iterates over the contents of a workplan or selective.
IsRough: Returns true if this is a roughing operation.
IsFinish: Returns true if this is a finishing operation.
GetOperationMilling: Get the parameters of a milling operation.

Common Errors

Project not defined: There is no AP-238 file open.
Incorrect type: The parameter does not identify a workingstep.
No operation: The workingstep does not have an operation defined.

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

IsWorkingstep: Returns true if an executable is a Machining workingstep.
GetNestedExecutableNext: Iterates over the contents of a workplan or selective.
GetFeatureHole: Returns data about the hole being drilled.

Common Errors

Project not defined: There is no AP-238 file open.
Incorrect type: The parameter does not identify a workingstep.

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

IsWorkingstep: Returns true if an executable is a Machining workingstep.
GetNestedExecutableNext: Iterates over the contents of a workplan or selective.
GetFeatureHole: Returns data about the hole being drilled.

Common Errors

Project not defined: There is no AP-238 file open.
Incorrect type: The parameter does not identify a workingstep.

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

IsWorkingstep: Returns true if an executable is a Machining workingstep.
GetNestedExecutableNext: Iterates over the contents of a workplan or selective.
GetFeatureHole: Returns data about the hole being drilled.

Common Errors

Project not defined: There is no AP-238 file open.
Incorrect type: The parameter does not identify a workingstep.

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

GetExecutableName: Returns the name of one executable in the selective
GetExecutableType: Returns the type of one executable in the selective.
GetNestedExecutableCount: Returns the number of executables in a workplan or selective.
IsEnabled: Returns true if an executable is enabled.

Common Errors

Project not defined: There is no AP-238 file open.
Invalid identity: The input does not identify a parallel.
Invalid index: The index is not in the range defined by GetSelectiveExecutableCount

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:

Find the number of paths in the workingstep using GetWorkingstepPathCount.
Iterate over the toolpaths using GetWorkingstepPathNext.
Find the number of curves in a path using GetPathCurveCount.
Iterate over the curves using GetPathCurveNext, which returns an argument indicating if the current curve is an arc and if so you can use the GetPathArc function to get the parameters of the arc.

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

GetPathCurveNext: Returns each curve segment in a path geometry curve using an index. Also returns a flag indicating if the segment contains an arc.
GetPathCurveCount: Returns the number of segments in a geometry curve.
GetWorkingstepPathNext: Returns each path in a workingstep using an index and indicates if it is a cutter location or cutter contact path.
GetWorkingstepPathCount: Returns the number of tool paths in a workingstep
GetPathPolylinePointCount: A related function for manipulating segments that are polylines.

Common Errors

Project not defined: There is no AP-238 file open.
Invalid identifier: The curve_id does not identify a trimmed curve (an arc is a type of trimmed curve where the curve is a circle).

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

GetPathCurveCount: Should return the same result as this function.
GetPathCurveNext: Returns one of the curve segements in the geometry curve.
GetWorkingstepPathNext: Returns the path-id’s needed by this function and indicates if this path is a cutter location or cutter contact path.
GetPathAxisNext Returns the corresponding segment in the tool axis curve.
GetPathAreaPolylinePointCount: Returns the number of points in an area curve polyline segement.

Common Errors

Project not defined: There is no AP-238 file open.
Invalid type: The input does not identify a tool path.

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:

Find the number of paths in the workingstep using GetWorkingstepPathCount.
Iterate over the toolpaths using GetWorkingstepPathNext.
Find the number of curve segments in each path using GetPathAreaCurveCount. This number will be 0 for paths that have no cross-section area parameters set.
Iterate over the polyline curve segments using GetPathAreaCurveNext.
Find the number of points in each polyline using GetPathAreaPolylinePointCount.
Iterate over the points using this function testing to see if the result is machining or air milling and reading the value returned if it is machining.
If you do not need to know the type of each point then get them all using a single call to GetPathAreaPolylinePointAll().

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

Project not defined: There is no AP-238 file open.
Invalid type: The input does not identify a polyline curve segment.
Out of range: The given index is not in the range [0, PathPolylineCount]

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

GetPathCurveCount: Should be the same result as this function.
GetWorkingstepPathNext: Returns the path-id’s needed by this function.
GetPathAxisPolylinePointCount: Returns the number of points in the polyline defining the axis curve segment.

Common Errors

Project not defined: There is no AP-238 file open.
Invalid type: The input does not identify a tool path.

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:

Find the number of paths in the workingstep using GetWorkingstepPathCount.
Iterate over the toolpaths using GetWorkingstepPathNext.
Find the number of curve segments in a path using GetPathAxisCount. If the number is 0 then this is not a five-axis tool path.
Iterate over the curve segments using GetPathAxisNext. They will all be polylines. For axis curve segments that correspond to an arc in the geometry curve they will be a polyline with two points.
Find the number of points for each segment using GetPathAxisPolylinePointCount.
Iterate over the points using GetPathAxisPolylinePointNext or use the much more efficient GetPathAxisPolylinePointAll function to get all the points in one function call.

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

GetPathPolylinePointCount: Should be the same result as this function if the corresponding segment of the toolpath is a polyline as well.
GetPathAxisNext: Returns the curve-id’s needed by this function.

Common Errors

Project not defined: There is no AP-238 file open.
Invalid type: The input does not identify a tool path.

Get[Path]Curve[EdgeLoop]AllCount/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(
	);

System::Collections::Generic::List<System::Int64>^ GetCurveEdgeLoopAll(
    System::Collections::Generic::List<System::Int64>^ curves
	);

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.

The GetCurveEdgeLoopAll() function returns all the edge loops that contain a given set of curves. If the argument only contains one curve then it may be contained in multiple edge loops. If the argument contains two loops then there is still the possibility the two curves might be in two loops. For more than three curves it would be unusual for more that one loop to be selected. The function can be used to check a loop by giving all of its curves and making sure it is selected.

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.
curves: The curves that must be contained by the selected loops.

Related Functions

GetPathAxisCount: Should return the same result as this function or 0.
GetPathCurveType: Returns the type of a curve segment (polyline or arc).
GetPathPolylinePointCount: Returns the number of points in a polyline segement.
GetPathArc: Returns the parameters describing an arc segement.
GetWorkingstepPathNext: Returns the path-id’s needed by this function and indicates if this path is a cutter location or cutter contact path.

Common Errors

Project not defined: There is no AP-238 file open.
Invalid type: The input does not identify a tool path.

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

GetPathCurveNext: Returns the curve-id’s needed by this function.

Common Errors

Project not defined: There is no AP-238 file open.
Invalid type: The input does not identify a curve.

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

GetPathCurveNext: Returns the identity of the curve segment required by this function.
GetPathAxisNext: Also returns a result that can be used as the input to this function but for axis segments the result of this function should always be polyline.

Common Errors

Project not defined: There is no AP-238 file open.
Invalid type: The input does not identify an entity in the database.

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.

GetPathFeedstop()/DwellValue()/DwellUnit()

System::Boolean GetPathFeedstop(
	System::Int64 tp_id
	);
double GetPathFeedstopDwellValue(
	System::Int64 tp_id
	);
System::String^  GetPathFeedstopDwellUnit(
	System::Int64 tp_id
	);

The GetPathFeedstop() function returns true if the given toolpath is a feedstop.

The GetPathFeedstopDwellValue() function returns the duration of the feedstop.

The GetPathFeedstopDwellUnit() function returns the time unit which will normally be seconds. The supported units are "sec" and "rev". The revolution unit describes the number of spindle revolutions to be completed before the dwell finishes.

Arguments

tp_id: The identity of the toolpath. Feedstop is a special kind of toolpath that stops the machine tool moving for a given time.

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()

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:

Find the number of paths in the workingstep using GetWorkingstepPathCount.
Iterate over the toolpaths using GetWorkingstepPathNext.
Find the number of curve segments in each path using GetPathCurveCount.
Iterate over the curve segments using GetPathCurveNext and find out if each is an arc or polyline.
If the curve segement is a polyline find the number of points using GetPathPolylinePointCount.
Iterate over the points using GetPathPolylinePointNext()
Or use the more efficient GetPathPolylinePointAll() to get all the points in one call

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

Project not defined: There is no AP-238 file open.
Invalid type: The input does not identify a polyline curve segment.
Out of range: The given index is not in the range [0, PathPolylineCount]

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.

Common Errors

Project not defined: There is no AP-238 file open.
Invalid type: The input does not identify a polyline curve segment.

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

GetWorkingstepPathNext: Returns the path-id’s needed by this function.
GetPathTechnologyID: Returns the identity of the technology entity for interrogation using the GetProcessXxx functions.
GetProcessFeedUnit: Returns the unit of the feed in a technology entity.
GetProcessSpeedUnit: Returns the unit of the speed in a technology entity.

Common Errors

Project not defined: There is no AP-238 file open.
Invalid type: The input does not identify a tool path.

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

GetWorkingstepPathNext: Returns the path-id’s needed by this function.
GetPathProcess: Returns all the process parameters of a path.

Common Errors

Project not defined: There is no AP-238 file open.
Invalid type: The input does not identify a tool path.

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

GetPathCurveNext: Returns the corresponding segment in the geometry curve.
GetPathAxisNext: Returns the corresponding segment in the tool axis curve.
GetPathReferenceDirectionPolylinePointCount: Returns the number of points in an reference direction curve.
GetWorkingstepPathNext: Returns the path-id’s needed by this function and indicates if this path is a cutter location or cutter contact path.

Common Errors

Project not defined: There is no AP-238 file open.
Invalid type: The input does not identify a tool path.

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:

Find the number of paths in the workingstep using GetWorkingstepPathCount.
Iterate over the toolpaths using GetWorkingstepPathNext.
Find the number of curve segments in each override path using GetPathReferenceDirectionCurveCount.
Iterate over the curve segments using GetPathReferenceDirectionCurveNext.
Or get all the data in one function call using GetPathReferenceDirectionCurveAll

Arguments

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

Common Errors

Project not defined: There is no AP-238 file open.
Invalid type: The input does not identify a polyline curve segment containing override values.
Out of range: The given index is not in the range [0, PathPolylineCount]

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

GetPathCurveNext: Returns the corresponding segment in the geometry curve.
GetPathAxisNext: Returns the corresponding segment in the tool axis curve.
GetPathAreaCurveNext: Returns the corresponding segment in the cross section area curve.
GetPathSpeedOverridePolylinePointCount: Returns the number of points in an override curve.
GetWorkingstepPathNext: Returns the path-id’s needed by this function and indicates if this path is a cutter location or cutter contact path.

Common Errors

Project not defined: There is no AP-238 file open.
Invalid type: The input does not identify a tool path.

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:

Find the number of paths in the workingstep using GetWorkingstepPathCount.
Iterate over the toolpaths using GetWorkingstepPathNext.
Find the number of curve segments in each override path using GetPathSpeedOverrideCurveCount. If there is no override curve then this function will return 0.
Iterate over the curve segments using GetPathSpeedOverrideCurveNext.
Find the number of override values using GetPathSpeedOverridePolylinePointCount()
Iterate over the override values using GetPathSpeedOverridePolylinePointNext()
Or get them all in a single function call using GetPathSpeedOverridePolylinePointAll()

Arguments

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

Common Errors

Project not defined: There is no AP-238 file open.
Invalid type: The input does not identify a polyline curve segment containing override values.
Out of range: The given index is not in the range [0, PathPolylineCount]

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

GetWorkingstepPathNext: Returns the path-id’s needed by this function.

Common Errors

Project not defined: There is no AP-238 file open.
Invalid type: The input does not identify a tool path.

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

GetWorkingstepPathNext: Returns the path-id’s needed by this function.

Common Errors

Project not defined: There is no AP-238 file open.
Invalid type: The input does not identify a tool path.

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

IsWorkingstep: Returns true if an executable is a Machining workingstep.
GetNestedExecutableNext: Iterates over the contents of a workplan or selective returning executables that may be workingsteps.

Common Errors

Project not defined: There is no AP-238 file open.
Incorrect type: The parameter does not identify a workingstep

GetPathUnits()

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

The GetPathUnits function returns a unit used for length measurements.

Related Functions

GetWorkpieceUnits

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

double GetProbeBallRadius(				
	System::Int64 ws_id,
	[System::Runtime::InteropServices::Out] System::Boolean %value_set
	);
System::String^ GetProbeBallRadiusUnit(
	System::Int64 ws_id
	);
double GetProbeBallRadiusLower(
	System::Int64 ws_id,
	[System::Runtime::InteropServices::Out] System::Boolean %value_set
	);
double GetProbeBallRadiusUpper(
	System::Int64 ws_id,
	[System::Runtime::InteropServices::Out] System::Boolean %value_set
	);
System::String^ GetProbeBallRadiusLowerReason(
	System::Int64 ws_id,
	[System::Runtime::InteropServices::Out] System::Boolean %value_set
	);
System::String^ GetProbeBallRadiusUpperReason(
	System::Int64 ws_id,
	[System::Runtime::InteropServices::Out] System::Boolean %value_set
	);

The GetGetProbeBallRadius() function returns the radius of the ball at the bottom of a touch probe. The GetGetProbeBallRadiusUnit() function returns the unit of the radius.

The GetProbeBallRadiusLower(), GetProbeBallRadiusReason(), GetProbeBallRadiusUpper() and GetProbeBallRadiusUpperReason() functions return bounds on the recommended value for the radius 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 probe selected for that workingstep.
value_set: [out] true if this value has been set

Related Functions

GetProbeStylusDiameter: The diameter of the stick that holds the ball.
GetToolXXX: The parameters of a cutting tool.
GetWorkingstepTool: The tool used by a workingstep.
GetToolNumber: Function to return the tool number for the probe.
GetToolOverallAssembly: Function to return the overall assembly length of the probe from the top of the stick to the base of the ball.

Common Errors

Project not defined: There is no AP-238 file open.
Invalid identity: The input does not identify a tool or workingstep.

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

double GetProbetylusDiameter(				
	System::Int64 ws_id,
	[System::Runtime::InteropServices::Out] System::Boolean %value_set
	);
System::String^ GetProbeStylusDiameterUnit(
	System::Int64 ws_id
	);
double GetProbeStylusDiameterLower(
	System::Int64 ws_id,
	[System::Runtime::InteropServices::Out] System::Boolean %value_set
	);
double GetProbeStylusDiameterUpper(
	System::Int64 ws_id,
	[System::Runtime::InteropServices::Out] System::Boolean %value_set
	);
System::String^ GetProbeStylusDiameterLowerReason(
	System::Int64 ws_id,
	[System::Runtime::InteropServices::Out] System::Boolean %value_set
	);
System::String^ GetProbeStylusDiameterUpperReason(
	System::Int64 ws_id,
	[System::Runtime::InteropServices::Out] System::Boolean %value_set
	);

The GetGetProbeStylusDiameter() function returns the diameter of the stick that holds the ball. The GetGetProbeStylusDiameterUnit() function returns the unit of the diameter.

The GetProbeStylusDiameterLower(), GetProbeStylusDiameterReason(), GetProbeStylusDiameterUpper() and GetProbeStylusDiameterUpperReason() 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 probe selected for that workingstep.
value_set: [out] true if this value has been set

Related Functions

GetProbeBallRadius: The radius of the touch probe ball.
GetToolXXX: The parameters of a cutting tool.
GetWorkingstepTool: The tool used by a workingstep.
GetToolNumber: Function to return the tool number for the probe.
GetToolOverallAssembly: Function to return the overall assembly length of the probe from the top of the stick to the base of the ball.

Common Errors

Project not defined: There is no AP-238 file open.
Invalid identity: The input does not identify a tool or workingstep.

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

IsWorkingstep: Returns true if an executable is a Machining workingstep.
GetNestedExecutableNext: Iterates over the contents of a workplan or selective returning executables that may be workingsteps.

Common Errors

Project not defined: There is no AP-238 file open.

GetProcessFeed() and Unit

double GetProcessFeed(
	System::Int64 tp_id,
	System::Int64 ws_id
	);
System::String^ GetProcessFeedUnit(
	System::Int64 tp_id,
	System::Int64 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 toolpath then the feedrate returned will be the value defined for the technology entity attached to that toolpath, if one exists, but if it does not, then the feedrate attached to the workingsetp is returned if it exists.

If tp_id is zero and the ws_id identifies a technology then the value returned will be the feedrate of the technology.

If no feedrate exists then the value 0 is returned. In most cases, the corresponding toolpath will be a rapid.

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

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
unknown if no technology was found

Arguments

tp_id: The identity of a toolpath or 0.
ws_id: The identity of the workingstep or technology.

Related Functions

GetWorkingstepPathNext: Returns the next toolpath in a machining workingstep.
GetPathProcess: Returns the process parameters used by a toolpath including the feedrate.
GetPathRapid: Returns true if the toolpath is a rapid.
APIUnitsFeed: Feed value will be converted to the requested units.

Common Errors

Project not defined: There is no AP-238 file open.
Invalid type: The argument does not identify a machining working step, tool path or technology entity.

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

IsWorkingstep: Returns true if an executable is a Machining workingstep.
GetNestedExecutableNext: Iterates over the contents of a workplan or selective to get executables that may be workingsteps.

Common Errors

Project not defined: There is no AP-238 file open.
Incorrect type: The parameter does not identify a workingstep.

GetProcessSpeed() and Unit

double GetProcessSpeed(			
	System::Int64 tp_id,
	System::Int64 ws_id
	);
System::String^ GetProcessSpeedUnit(
	System::Int64 tp_id,
	System::Int64 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 a tp_id is given then the value returned will be the value of the technology on that toolpath if one is given. If the toolpath does not have a technology defined then, if it exists, the value of the technology on the workingstep will be given.

If tp_id is zero and ws_id is a technology then the value of the speed in the technology will be returned.

If no technology is found then 0 will be returned.

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

hertz cycles per second
rpm revolutions per minute
unknown if no technology was found

Arguments

tp_id: The identity of a toolpath or 0.
ws_id: The identity of the workingstep or technology.

Related Functions

GetWorkingstepPathNext: Returns the next toolpath in a machining workingstep.
APIUnitsSpeed: Speed value will be converted to the requested units.

Common Errors

Project not defined: There is no AP-238 file open.
Wrong type: The argument does not identify a machining working step, tool path or technology entity.

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

GetMainWorkplan: Returns the main workplan of the project.
GetExectutableName: Returns the names of workplans and other executables.
GetWorkpieceName: Returns the name of the workpiece.
Use the APT object to get the workpiece and rawpiece of the project.

Common Errors

Project not defined: There is no AP-238 file open.

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

GetWorkplanWorkpieceNext: Get the id of a workpiece in the setup of a workplan.

Common Errors

Project not defined: There is no AP-238 file open.

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

GetExecutableName: Returns the name of one executable in the selective
GetExecutableType: Returns the type of one executable in the selective.
GetNestedExecutableCount: Returns the number of executables in a workplan or selective.
IsEnabled: Returns true if an executable is enabled.

Common Errors

Project not defined: There is no AP-238 file open.
Invalid identity: The input does not identify a selective.
Invalid index: The index is not in the range defined by GetSelectiveExecutableCount

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

GetWorkpieceShape: Returns summary data about the shape of a workpiece.
GetWorkpieceUnits: Returns the units of the workpiece.
GetMaterialName: Returns a description of the workpiece material.

Common Errors

Project not defined: There is no AP-238 file open.

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

IsWorkingstep: Returns a flag indicating if an object is a workingstep.
GetSurfacePropertyWorkpiece: Returns the surface finish requirements for the whole workpiece.
GetMaterialName: Returns a description of the workpiece material.

Common Errors

Project not defined: There is no AP-238 file open.
Invalid identity: The input does not identify a workingstep.

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

GetProcessFeed/Speed: Functions to return the feed and speed values of a technology entity.
GetWorkingstepTechnologyCount: Function to return a count of the technology used by the tool paths in a workingstep.
GetTechnologyByValue: Function to find the technology entity that contains a given feed and speed value.

Common Errors

Project not defined: There is no AP-238 file open.
Index out of range: The given in index is not in the range [0, GetTechnologyAllCount – 1]

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

Project not defined: There is no AP-238 file open.

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

GetProcessFeed/Speed: Functions to return the feed and speed values of a technology entity.
GetWorkingstepTechnologyCount: Function to return a count of the technology used by the tool paths in a workingstep.
GetTechnologyByValue: Function to find the technology entity that contains a given feed and speed value.

Common Errors

Project not defined: There is no AP-238 file open.
Index out of range: The given in index is not in the range [0, GetTechnologyCount – 1]

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

GetToolxx: Functions to return the parameters that define a tool.
GetWorkingstepTool Function to return the tool used by a workingstep
GetWorkplanToolCount Function to return a count of the tools used in a workplan

Common Errors

Project not defined: There is no AP-238 file open.
Index out of range: The given in index is not in the range [0, GetToolAllCount – 1]

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

Project not defined: There is no AP-238 file open.
Invalid identity: The input does not identify a tool or workingstep.

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

The GetToolCurrentCornerRadius: function returns the current corner radius of a tool.
GetToolDiameter: Function to return the tool diameter.
GetToolExpectedLife: Function to return the expected remaining life of the tool.
GetToolHorizontalDistance: See APT documentation.
GetToolReferenceDataName: Function to return the manufacturers name for a tool.
GetToolLength: Function to return the tool length.
GetToolMaterial: Function to return the tool material.
GetToolNumber: Function to return the tool number.
GetToolOverallAssembly: Function to return the overall assembly length
GetToolTipAngle: Function to return the tool tip angle.
GetToolVerticalDistance: See APT documentation.

Common Errors

Project not defined: There is no AP-238 file open.
Invalid identity: The input does not identify a tool or workingstep.

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

GetToolCornerRadius: Function to return the tool corner radius as defined by CAM.
GetToolCurrentDiameter: Function to return the current diameter of a tool.
GetToolCurrentLength: Function to return the current length of a tool.

Common Errors

Project not defined: There is no AP-238 file open.
Invalid identity: The input does not identify a tool or workingstep.

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

GetToolDiameter: Function to return the tool diameter as defined by CAM.
GetToolCurrentCornerRadius: Function to return the current radus of a tool.
GetToolCurrentLength: Function to return the current length of a tool.

Common Errors

Project not defined: There is no AP-238 file open.
Invalid identity: The input does not identify a tool or workingstep.

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

GetToolLength: Function to return the tool length as defined by CAM.
GetToolCurrentCornerRadius: Function to return the current radus of a tool.
GetToolCurrentDiameter: Function to return the current diameter of a tool.

Common Errors

Project not defined: There is no AP-238 file open.
Invalid identity: The input does not identify a tool or workingstep.

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
	);

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

GetProbeBallRadius: The ball radius of a touch probe.
GetProbeStylusDiameter: The diameter of the stick that holds the ball.
GetWorkingstepTool: The tool used by a workingstep.
GetToolCornerRadius: The corner/edge radius of a cutter.
GetToolExpectedLife: Function to return the expected remaining life of the tool.
GetToolHorizontalDistance: See APT documentation.
GetToolReferenceDataName: Function to return the manufacturers name for a tool.
GetToolLength: Function to return the tool length.
GetToolMaterial: Function to return the tool material.
GetToolNumber: Function to return the tool number.
GetToolOverallAssembly: Function to return the overall assembly length
GetToolTipAngle: Function to return the tool tip angle.
GetToolVerticalDistance: See APT documentation.

Common Errors

Project not defined: There is no AP-238 file open.
Invalid identity: The input does not identify a tool or workingstep.

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

GetToolCornerRadius: The unit of the corner radius
GetToolDiameter: Function to return the tool diameter.
GetToolHorizontalDistance: See APT documentation.
GetToolReferenceDataName: Function to return the manufacturers name for a tool.
GetToolLength: Function to return the tool length.
GetToolMaterial: Function to return the tool material.
GetToolNumber: Function to return the tool number.
GetToolOverallAssembly: Function to return the overall assembly length
GetToolTipAngle: Function to return the tool tip angle.
GetToolVerticalDistance: See APT documentation.

Common Errors

Project not defined: There is no AP-238 file open.

GetToolFluteCount()

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

The GetToolFluteCount() function returns the number of flutes on a tool. If the value has been set then the value_set parameter is set to true. If the value has not been send then false is returned and the result of the function is set to special number. The function returns a double when the flute count is fractional.

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
	);

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

Project not defined: There is no AP-238 file open.
Invalid identity: The input does not identify a tool or workingstep.

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

Project not defined: There is no AP-238 file open.
Invalid identity: The input does not identify a tool or workingstep.

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

Project not defined: There is no AP-238 file open.
Invalid identity: The input does not identify a tool or workingstep.

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

Project not defined: There is no AP-238 file open.
Invalid identity: The input does not identify a tool or workingstep.

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

GetToolCornerRadius: The unit of the corner radius
GetToolDiameter: Function to return the tool diameter.
GetToolExpectedLife: Function to return the expected remaining life of the tool.
GetToolReferenceDataName: Function to return the manufacturers name for a tool.
GetToolLength: Function to return the tool length.
GetToolMaterial: Function to return the tool material.
GetToolNumber: Function to return the tool number.
GetToolOverallAssembly: Function to return the overall assembly length
GetToolTipAngle: Function to return the tool tip angle.
GetToolVerticalDistance: See APT documentation.

Common Errors

Project not defined: There is no AP-238 file open.
Invalid identity: The input does not identify a tool or workingstep.

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

GetToolISO13399StringAttributeCount/Next: Get the ISO 13399 string attributes.
GetToolReferenceDataName: Name of the ISO 13399 file.

Common Errors

Invalid identity The ws_or_tl_id does not identity a tool.

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.

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

GetToolISO13399NumericAttributeCount/Next: Get the ISO 13399 numeric attributes.
GetToolReferenceDataName: Name of the ISO 13399 file.

Common Errors

Invalid identity The ws_or_tl_id does not identity a tool.

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

GetToolCornerRadius: The unit of the corner radius
GetToolDiameter: Function to return the tool diameter.
GetToolExpectedLife: Function to return the expected remaining life of the tool.
GetToolHorizontalDistance: See APT documentation.
GetToolReferenceDataName: Function to return the manufacturers name for a tool.
GetToolLength: Function to return the tool length.
GetToolMaterial: Function to return the tool material.
GetToolNumber: Function to return the tool number.
GetToolOverallAssembly: Function to return the overall assembly length
GetToolTipAngle: Function to return the tool tip angle.
GetToolVerticalDistance: See APT documentation.

Common Errors

Project not defined: There is no AP-238 file open.
Invalid identity: The input does not identify a tool or workingstep.

GetTool(Mill/Drill)MatchingCount/Next()

System::Int64 GetToolMillMatchingCount (		
	double diameter,
	double length,
	double radius,
	double flute_count,
	System::String^ type
	);

System::Int64 GetToolDrillMatchingCount (		
	double diameter,
	double length,
	double tip_angle,
	System::String^ type
	);


System::Int64 GetToolMillMatchingNext (
	System::Int64 index
	);

System::Int64 GetToolDrillMatchingNext (
	System::Int64 index
	);

The GetTool(Mill/Drill)MatchingCount() functions search the AP-238 file and returns a count of all the tools that have a required set of properties.

The GetTool(Mill/Drill)MatchingNext() functions return the identifier of each similar tool using an index.

The maching functions are used to find similar tooling. 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 GetTool(Mill/Drill)MatchingCount() functions 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.
tip_angle: The required tip_angle (for drills), or zero if this parameter does not matter.
flute_count_flag: The required number of flutes (can be a fraction), 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 GetToolMillMatchingCount or GetToolDrillMatchingCount

Related Functions

GetAllToolCount: Functions to return all the tools in the project.
GetToolxxx: Functions to return the parameters that define a tool.
GetWorkingstepTool: Function to return the tool used by a workingstep
GetWorkplanToolCount/Next: Functions to return the tools used in a workplan

Common Errors

Project not defined: There is no AP-238 file open.
Index out of range: The given in index is not in the range [0, GetToolMatchingCount – 1]

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

GetToolMaterialStandard: Function to return the material standard that defines the description.

Common Errors

Project not defined: There is no AP-238 file open.
Invalid identity: The input does not identify a tool or workingstep.

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

GetToolMaterial: Function to return the material description as defined by this standard.

Common Errors

Project not defined: There is no AP-238 file open.
Invalid identity: The input does not identify a tool or workingstep.

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

GetToolNumberAsNumber: Get the tool number as a number (normally the case).
GetToolCornerRadius: Function to return the tool corner radius.
GetToolDiameter: Function to return the tool diameter.
GetToolExpectedLife: Function to return the expected remaining life of the tool.
GetToolHorizontalDistance: See APT documentation.
GetToolReferenceDataName: Function to return the manufacturers name for a tool.
GetToolLength: Function to return the tool length.
GetToolMaterial: Function to return the tool material.
GetToolOverallAssembly: Function to return the overall assembly length
GetToolTipAngle: Function to return the tool tip angle.
GetToolVerticalDistance: See APT documentation.

Common Errors

Project not defined: There is no AP-238 file open.
Invalid identity: The input does not identify a tool or workingstep.

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

GetToolNumber: Function to return the tool taper angle.

Common Errors

Project not defined: There is no AP-238 file open.
Invalid identity: The input does not identify a tool or workingstep.

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

GetToolFunctionLength: The functional length of the tool for cutter compensation calculations.
GetToolFluteLength: The flute length of the tool for maximum depth of cut calculations.

Common Errors

Project not defined: There is no AP-238 file open.
Invalid identity: The input does not identify a tool or workingstep.

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

GetToolReferenceDataName: Function to return the manufacturers name for a tool.
GetToolNumber: Function to return the tool number.
GetWorkpieceName: Function to get the name of a workpiece.

Common Errors

Project not defined: There is no AP-238 file open.
Invalid identity: The input does not identify a tool or workingstep.

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

GetToolRecommendedFeedUnit: Unit of the recommended feed e.g. ips
GetToolTechnologyCount: Function to return a count of the technology used by a tool path.
GetTechnologyByValue: Function to find the technology entity that contains a given feed and speed value.

Common Errors

Project not defined: There is no AP-238 file open.
Invalid identity: The input does not identify a tool or workingstep.

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

GetToolTechnologyCount: Function to return a count of the technology used by a tool path.
GetTechnologyByValue: Function to find the technology entity that contains a given feed and speed value.

Common Errors

Project not defined: There is no AP-238 file open.
Invalid identity: The input does not identify a tool or workingstep.

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

GetToolTipAngle: Function to return the angle of the tool tip.
GetToolCornerRadius: Function to return the tool corner radius.
GetToolDiameter: Function to return the tool diameter.
GetToolExpectedLife: Function to return the expected remaining life of the tool.
GetToolHorizontalDistance: See APT documentation.
GetToolReferenceDataName: Function to return the manufacturers name for a tool.
GetToolLength: Function to return the tool length.
GetToolMaterial: Function to return the tool material.
GetToolNumber: Function to return the tool number.
GetToolOverallAssembly: Function to return the overall assembly length
GetToolVerticalDistance: See APT documentation.
GetToolPartName: Name of the geometry model for the tool

Common Errors

Project not defined: There is no AP-238 file open.
Invalid identity: The input does not identify a tool or workingstep.

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

GetToolMatchingCount/Next: Functions to return the tools that have a given set of values.
GetAllToolCount: All the tools in the project.
GetToolxxx: Functions to return the parameters that define a tool.
GetWorkingstepTool: Function to return the tool used by a workingstep
GetWorkplanToolCount/Next: Functions to return the tools used in a workplan

Common Errors

Project not defined: There is no AP-238 file open.
Index out of range: The given in index is not in the range [0, GetToolSimilarCount – 1]

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

GetToolTipAngle: Function to return the angle of the tool tip.
GetToolCornerRadius: Function to return the tool corner radius.
GetToolDiameter: Function to return the tool diameter.
GetToolExpectedLife: Function to return the expected remaining life of the tool.
GetToolHorizontalDistance: See APT documentation.
GetToolReferenceDataName: Function to return the manufacturers name for a tool.
GetToolLength: Function to return the tool length.
GetToolMaterial: Function to return the tool material.
GetToolNumber: Function to return the tool number.
GetToolOverallAssembly: Function to return the overall assembly length
GetToolVerticalDistance: See APT documentation.

Common Errors

Project not defined: There is no AP-238 file open.
Invalid identity: The input does not identify a tool or workingstep.

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

GetProcessFeed/Speed: Functions to return the feed and speed values of a technology entity.
GetWorkingstepTechnologyCount: Function to return a count of the technology used by the tool paths in a workingstep.
GetTechnologyByValue: Function to find the technology entity that contains a given feed and speed value.
GetTechnologyWorkingstepCount: Get a count of the workingsteps that use a technology.
GetExecutableTechnologyCount: Get a count of the number of technologies used by an executable

Common Errors

Project not defined: There is no AP-238 file open.
Index out of range: The given in index is not in the range [0, GetTechnologyCount – 1]

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

Project not defined: There is no AP-238 file open.
Invalid identity: The input does not identify a tool or workingstep.

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

Project not defined: There is no AP-238 file open.
Invalid identity: The input does not identify a tool or workingstep.

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

Project not defined: There is no AP-238 file open.
Invalid identity: The input does not identify a tool or workingstep.

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

Project not defined: There is no AP-238 file open.
Invalid identity: The input does not identify a tool or workingstep.

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

GetToolCornerRadius: Function to return the tool corner radius.
GetToolDiameter: Function to return the tool diameter.
GetToolExpectedLife: Function to return the expected remaining life of the tool.
GetToolHorizontalDistance: See APT documentation.
GetToolReferenceDataName: Function to return the manufacturers name for a tool.
GetToolLength: Function to return the tool length.
GetToolMaterial: Function to return the tool material.
GetToolNumber: Function to return the tool number.
GetToolOverallAssembly: Function to return the overall assembly length
GetToolVerticalDistance: See APT documentation.
GetToolPartName: Name of the geometry model for the tool

Common Errors

Project not defined: There is no AP-238 file open.
Invalid identity: The input does not identify a tool or workingstep.

GetToolType()

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

string GetToolCategory(		
	int ws_id
	);

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

The GetToolCategory() function returns a summary description of the type of a tool as a string name. The following categories are returned.

category = MILLING
category = DRILLING
category = PROBING
category = MISSING
category = UNKNOWN

Missing is returned if the workingstep has no tool and is in an error state. Unknown is returned if the tool does not belong to one of the currently recognized categories.

Arguments

ws_or_tl_id: The identity of a workingstep or tool. If the id is a ws_id then the function is applied to the tool of the workingstep.

Related Functions

GetToolxx: Functions to return the parameters that define a tool for milling or drilling.
GetProbexx: Functions to return the parameters that define a touch probe.
GetToolAllCount/Next: Functions to traverse through all the tools and probes.
GetToolNumber: Function to return the tool number.
GetWorkingstepType/Category: Functions to return the type and category of a workingstep.

Common Errors

Project not defined: There is no AP-238 file open.
Invalid identity: The input does not identify a tool or workingstep.

GetToolUsingIdentifier()

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

int GetToolUsingIdentifier(			
	string identifier
	);

The GetToolUsingIdentifier() function returns the identity of the first tool or probe 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 or probe 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 required.

Arguments

id: The tool_number from the APT program.

Related Functions

GetToolxx: Functions to return the parameters that define a tool.
GetToolAllCount/Next: Functions to traverse through all the tools and probes.
GetToolNumber: Function to return the tool number.

Common Errors

Project not defined: There is no AP-238 file open.

GetToolUsingWorkpiece()

System::Int64 GetToolUsingWorkpiece(	
	System::Int64 wp_id
	);

The GetToolUsingWorkpiece() function returns the identity of the first tool or probe that uses the given workpiece to define its geometry.

Arguments

wp_id: The identity of the workpiece.

Related Functions

GetToolxx: Functions to return the parameters that define a tool.
GetToolAllCount/Next: Functions to traverse through all the tools and probes.
GetToolNumber: Function to return the tool number.

Common Errors

Project not defined: There is no AP-238 file open.

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

GetToolCornerRadius: Function to return the tool corner radius.
GetToolDiameter: Function to return the tool diameter.
GetToolExpectedLife: Function to return the expected remaining life of the tool.
GetToolHorizontalDistance: See APT documentation.
GetToolReferenceDataName: Function to return the manufacturers name for a tool.
GetToolLength: Function to return the tool length.
GetToolMaterial: Function to return the tool material.
GetToolNumber: Function to return the tool number.
GetToolOverallAssembly: Function to return the overall assembly length
GetToolPartName: Name of the geometry model for the tool

Common Errors

Project not defined: There is no AP-238 file open.
Invalid identity: The input does not identify a tool or workingstep.

GetToolWorkpiece()

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

GetWorkpieceShapeCount?next: Function to get the shapes that define a tool.
GetToolIdentifier: Manufacturers name for the tool.
GetToolNumber: Function to return the tool number.
GetToolPartName: User name of the workpiece for the tool

Common Errors

Project not defined: There is no AP-238 file open.
Invalid identity: The input does not identify a tool or workingstep.

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

GetFeatureType: Returns the type of the feature
GetFeatureName: Returns the name of the feature
GetFeatureXxx: A set of functions to get the attributes of the different types of features.
GetWorkingstepProcessFeature: Returns the process feature of the workingstep.
IsWorkingstep : Returns true if an executable is a workingstep
GetWorkplanExecutableNext: Returns the next executable in a workplan

Common Errors

Project not defined: There is no AP-238 file open.
Invalid type: The given identifier does not define a workingstep.
Not in range: The given index is not in the range defined by GetWorkinstepFinalFeatureCount

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

GetWorkingstepNameInWorkplan: Returns the name of a workingstep using its position in a workplan.
IsWorkingstep: Returns true if an executable is a workingstep
GetWorkplanExecutableNext: Returns the next executable in a workplan
The SetNameXXX family of functions in the APT object can be used to get and set the names of many types of objects.

Common Errors

Project not defined: There is no AP-238 file open.
Invalid type: The given identifier does not define a workingstep.

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

GetWorkingstepName: Returns the name of a workingstep using its id.
The SetNameXXX family of functions in the APT object can be used to get and set the names of many types of objects.

Common Errors

Project not defined: There is no AP-238 file open.
Invalid type: The given identifier does not define a workplan.
Invalid range: The given position is out of the range [0, size -1].

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

IsWorkingstep: Returns true if an executable is a workingstep
GetWorkplanExecutableNext: Returns the next executable in a workplan
GetPathXxx: A set of functions to manipulate tool paths
GetProcessXX: These functions return information about the tool path speeds and feeds.

Common Errors

Project not defined: There is no AP-238 file open.
Invalid type: The given identifier does not define a workingstep.

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

GetFeatureType: Returns the type of the feature. This type will be TOOLPATH_FEATURE if the process is the default toolpath feature.
GetFeatureXxx: Functions to return the parametric attributes of the other types of features.

Common Errors

Project not defined: There is no AP-238 file open.
Invalid type: The given identifier does not define a workingstep.

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

GetWorkingstepPropertyCountMeasure: Returns the value of an integer property.
GetWorkingstepPropertyDescriptiveMeasure: Returns the value of a string property.
GetWorkingstepPropertyLengthMeasure: Returns the value of a real property.
IsSiemensCycle81/82/83/84/840: Returns true if the property is defined by a Siemens canned cycle.

Common Errors

Project not defined: There is no AP-238 file open.
Not a workingstep: The ws_id does not identify a workingstep.
Not a process property workingstep: The ws_id does not identify a workingstep with a process property.
Invalide index: The index is not in the range defined by GetWorkingstepPropertyCount()

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
	);

Arguments

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

Related Functions

GetWorkingstepPropertyCount: Returns the number of parameters on the process property.
GetWorkingstepPropertyName: Returns the name of a parameter on the process property. If the process is defined by a canned cycle then this name will have been fixed by the cycle to correspond to one of the arguments of the cycle.
GetWorkingstepPropertyType: Returns the type of a parameter on the process property. The type can be "count" for integer parameters, "descriptive" for string parameters or "length" for real parameters.
IsSiemensCycle81/82/83/84/840: Returns true if the property is defined by a Siemens canned cycle.

Common Errors

Project not defined: There is no AP-238 file open.
Not a workingstep: The ws_id does not identify a workingstep.
Not a process property workingstep: The ws_id does not identify a workingstep with a process property.
Property name not found: The process does not contain a property with this name.
Invalid type: The property does not have the required type.

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

IsWorkingstep: Returns true if an executable is a workingstep
GetWorkplanExecutableNext: Returns the next executable in a workplan

Common Errors

Project not defined: There is no AP-238 file open.
Invalid type: The given identifier does not define a workingstep.
Index out of range: The index is not in the range defined by GetWorkingstepTechnologyCount.

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

GetProcessFeed/Speed: Returns the speed and feed values in a technology entity

Common Errors

Project not defined: There is no AP-238 file open.
Invalid type: The given identifier does not define a workingstep.

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

GetToolXxx: Functions to return the attributes of a tool.

Common Errors

Project not defined: There is no AP-238 file open.
Invalid type: The given identifier does not define a workingstep.

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()/Category()

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

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

The GetWorkingstepType() function returns the type of the operation in a workingstep.

If the executable is a MACHINING_WORKINGSTEP then one of the following type names will be returned.

type = CONTOURING_ROUGH
type = BORING
type = BOTTOM_AND_SIDE_FINISH_MILLING
type = BOTTOM_AND_SIDE_ROUGH_MILLING
type = CONTOURING_FINISH
type = CONTOURING_ROUGH
type = DEFINED_MARKING
type = DRILLING
type = FACING_FINISH
type = FACING_ROUGH
type = FREEFORM_OPERATION
type = PLANE_ROUGH_MILLING
type = PLANE_FINISH_MILLING
type = MULTISTEP_DRILLING
type = REAMING
type = SIDE_FINISH_MILLING
type = SIDE_ROUGH_MILLING
type = WORKPIECE_PROBING

If the operation is not MACHINING_WORKINGSTEP then the following string will be returned.

type = INVALID WORKINGSTEP

The GetWorkingstepCategory() function returns a higher level description of the operation in a workingstep. The category can be used in display operations to select icons, and in checking operations to make sure the right type of tool has been selected for the workingstep.

If the executable is a MACHINING_WORKINGSTEP then one of the following category names will be returned.

category = MILLING_TYPE_OPERATION
category = DRILLING_TYPE_OPERATION
category = ADDITIVE_TYPE_OPERATION
category = TURNING_TYPE_OPERATION
category = EXTENDED_TYPE_OPERATION
category = MACHINING_RAPID_MOVEMENT
category = MACHINING_TOUCH_PROBING
category = MACHINING_UNKNOWN_OPERATION

Arguments

ws_id: The identity of the workingstep.

Related Functions

GetExecutableType:The type of an executable.
IsWorkingstep:
IsNcFunction:
IsProgramStructure:
GetToolType/Category:Return the type and category of a tool.

Common Errors

Project not defined: There is no AP-238 file open.

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

GetWorkpieceNext: Get any workpiece in the project.

Common Errors

Project not defined: There is no AP-238 file open.

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 returns the parameters that define a block workpiece. If the parameters are not set then the function returns zeros.

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

GetWorkpieceNext: Get the next workpiece.
GetWorkpieceType: The role of the workpiece (workpiece, fixture or tool).

Common Errors

Project not defined: There is no AP-238 file open.
Invalid index Must be in the range [0, GetWorkpieceCount – 1]

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 returns the parameters that define a cylinder workpiece. If the parameters are not set then the function returns zeros.

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

GetWorkpieceNext: Get any workpiece in the project.

Common Errors

Project not defined: There is no AP-238 file open.

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

GetWorkpieceSubassemblyCount: A count of all the components in an assembly incuding components that are subassemblies of a subassembly.
GetWorkpieceType: The role, if any, of the workpiece (workpiece, fixture or tool).

Common Errors

Project not defined: There is no AP-238 file open.
Invalid index Must be in the range [0, GetWorkpieceCount – 1]

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

GetWorkpieceShape: Function to return a summary of the workpiece dimensions.
GetWorkpieceUnits: Function to return the workpiece units.
GetWorkpiecePlacement: Function to return the workpiece placement.

Common Errors

Project not defined: There is no AP-238 file open.
Bad identity: The given id does not identify a workpiece,

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

GetFeatureAllCount: Get a list of all the features in a project.

Common Errors

Project not defined: There is no AP-238 file open.

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

No project open: An AP-238 file must be open.

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

GetWorkpieceShape: Function to return a summary of the workpiece dimensions.
GetWorkpieceUnits: Function to return the workpiece units.
GetWorkpiecePlacement: Function to return the workpiece placement.

Common Errors

Project not defined: There is no AP-238 file open.

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

GetWorkpieceType: The role, if any, of the workpiece (workpiece, fixture or tool).
GetWorkpieceImmediateSubassemblyCount: A count of just the immediate sub-assemblies and components in this assembly. Will be 0 if the workpiece is a component.

Common Errors

Project not defined: There is no AP-238 file open.
Invalid index Must be in the range [0, GetWorkpieceCount – 1]

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

GetWorkpieceNext: Get any workpiece in the project.
GetFinalpieceNext: If the project makes multiple final products then they will be listed here.

Common Errors

Project not defined: There is no AP-238 file open.

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

GetWorkpieceCount: A count of the number of workpieces.
GetWorkpieceNext: Function to get the id of a workpiece

Common Errors

Project not defined: There is no AP-238 file open.
Bad identity: Invalid identity for workpiece argument.

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

GetWorkpieceShape: Function to return a summary of the workpiece dimensions.
GetWorkpieceUnits: Function to return the workpiece units.
GetWorkpiecePlacement: Function to return the workpiece placement.

Common Errors

Project not defined: There is no AP-238 file open.

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

GetMainWorkplan: Returns the identity of the main workplan of a project
GetExecutableName: Returns the identifier of an executable
GetExecutableType: Returns the type of an executable. This function can be used to decode the contents of a workplan.
IsWorkingstep: Returns true if the executable is a workingstep
IsWorkplan: Returns true if the executable is a workplan.
IsEnabled: Returns true if the executable is enabled.

Common Errors

Project not defined: There is no AP-238 file open.
Invalid identity: The input does not identify a workplan.
Invalid index: The index is not in the range defined by GetWorkplanExecutableCount

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

GetFeatureType: Returns the type of the feature
GetFeatureName: Returns the name of the feature

Common Errors

Project not defined: There is no AP-238 file open.
Invalid type: The given identifier does not define a workplan.
Not in range: The given index is not in the range defined by GetWorkplanFinalFeatureCount

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

GetWorkingstepNameInWorkplan: Returns the name of a workingstep using its position in a workplan.
IsWorkplan: Returns true if an executable is a workplan.
GetWorkplanExecutableNext: Returns the next executable in a workplan
The SetNameXXX family of functions in the APT object can be used to get and set the names of many types of objects.

Common Errors

Project not defined: There is no AP-238 file open.
Invalid type: The given identifier does not define a workplan.

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

GetFeatureType: Returns the type of the feature
GetFeatureName: Returns the name of the feature

Common Errors

Project not defined: There is no AP-238 file open.
Invalid type: The given identifier does not define a workplan.
Not in range: The given index is not in the range defined by GetWorkplanFinalFeatureCount

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

GetProcessFeed/Speed: Functions to return the feed and speed values of a technology entity.
GetWorkingstepTechnologyCount/Next: Function to return a count of the technology used by the tool paths in a workingstep.
GetTechnologyByValue: Function to find the technology entity that contains a given feed and speed value.

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

GetWorkingstepTool: Returns the tool for one workingstep
GetMainWorkplan: Returns the main workplan of a STEP-NC project.
GetWorkplanExecutableNext: Returns the next executable in a workplan.
IsWorkplan: Returns true if the next executable is a workplan

Common Errors

Project not defined: There is no AP-238 file open.
Invalid type: The given identifier does not define a workplan.
Invalide range: The index is not in the range defined by GetWorkplanToolCount.

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

Project not defined: There is no AP-238 file open.
Invalid type: The given identifier does not define a workplan.
Invalid index: The index is not in the range defined by the count function.

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

GetWorkingstepPathCount: This function returns a count of the number of toolpaths in a workingstep.
GetWorkingstepPathNext: This function returns the next toolpath in a workingstep. The path returned can then be tested using the current function
IsWorkingstep: Returns true if an executable is a workingstep.
IsContactPath: Returns true for the alternative tool path type which is the contact line between the tool and the workpiece.

Common Errors

Project not defined: There is no AP-238 file open.
Invalid type: The given identifier does not define a tool path.

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

GetWorkingstepPathCount: This function returns a count of the number of toolpaths in a workingstep.
GetWorkingstepPathNext: This function returns the next toolpath in a workingstep. The path returned can then be tested using the current function
IsWorkingstep: Returns true if an executable is a workingstep.
IsCenterPath: Returns true for the simpler type of tool path which describes the center line of the tool axis

Common Errors

Project not defined: There is no AP-238 file open.
Invalid type: The given identifier does not define a toolpath.

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

GetWorkplanExecutableAllEnabled: This function returns only the enabled executables in a workplan.
IsWorkingstep: Returns true if an executable is a workingstep.
GetMainWorkplan: Gets the main workplan that leads to all other executables.

Common Errors

Project not defined: There is no AP-238 file open.
Invalid type: The given identifier does not define a workingstep.

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

GetWorkplanExecutableNext: This function returns each executable in a workplan.
IsWorkingstep: Returns true if an executable is a workingstep.
GetMainWorkplan: Gets the main workplan that leads to all other executables.

Common Errors

Project not defined: There is no AP-238 file open.
Invalid type: The given identifier does not define a workingstep.

IsMultiSpindle()

System::Boolean IsMultiSpindle(		>	);

The IsMultiSpindle() function returns true if the current project contains a parallel program structure.

Related Functions

ProjectSpindleCount: The number of spindles required by this program.
IsParallel: Returns true if the given executable is a Parallel (concurrent) program stucture.
IsWorkplan:Returns true if the given executable is a Workplan (sequential) program stucture.

Common Errors

Project not defined: There is no AP-238 file open.

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

GetWorkplanExecutableNext: This function returns each executable in a workplan.
GetMainWorkplan: Gets the main workplan that leads to all other executables.

Common Errors

Project not defined: There is no AP-238 file open.

IsNonSequential()

System::Boolean IsNonSequential(
	System::Int64 exe_id
	);

The IsNonSequential() function returns true if an executable decribes a non-sequential. A non-sequential is a program structure describing a list of executables that are to be executed in any order.

Arguments

exe_id: The identity of the executable.

Related Functions

GetWorkplanExecutableNext: This function returns each executable in a workplan.
GetSelectiveExecutableNext: This function returns each executable in a selective.
GetParallelExecutableNext: This function returns each executable in a parallel.
GetMainWorkplan: Gets the main workplan that leads to all other executables.
IsWorkplan: This function returns 1 if the program structure is a workplan.
IsSelective: This function returns 1 if the program structure is a selective.

Common Errors

Project not defined: There is no AP-238 file open.

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

GetWorkplanExecutableNext: This function returns each executable in a workplan.
GetSelectiveExecutableNext: This function returns each executable in a selective.
GetParallelExecutableNext: This function returns each executable in a parallel.
GetMainWorkplan: Gets the main workplan that leads to all other executables.
IsWorkplan: This function returns 1 if the program structure is a workplan.
IsSelective: This function returns 1 if the program structure is a selective.

Common Errors

Project not defined: There is no AP-238 file open.

IsPlyAssembly()

System::Boolean IsPlyAssembly(	
	System::Int64 wp_id
	);

The IsPlyAssembly() function returns true if the given workpiece is in an assembly that includes a ply workpiece or a composite assembly.

Arguments

wp_id: The identity of the workpiece.

Related Functions

IsPlyWorkpiece(): This function returns true if a workpiece is a ply.

Common Errors

wp_id is not a workpiece.

IsPlyWorkpiece()

System::Boolean IsPlyWorkpiece(	
	System::Int64 wp_id
	);

The IsPlyWorkpiece() function returns true if a workpiece is categorized as a ply.

Arguments

wp_id: The identity of the workpiece.

Related Functions

IsPlyAssembly(): This function returns true if a workpiece is an assembly of plys.

Common Errors

wp_id is not a workpiece.

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

GetNestedExecutableNext: This function returns each executable in a workplan or selective.
GetMainWorkplan: Gets the main workplan that leads to all other executables.
IsWorkingstep: This function returns a 1 if an executable is a workingstep. Any executable that is a probing workingstep is also a workingstep so IsWorkingstep will always return 1 if IsProbingWorkingstep returns 1 but not vice versa.

Common Errors

Project not defined: There is no AP-238 file open.

IsProgramStructure()

System::Boolean IsProgramStructure(	
	System::Int64 exe_id
	);

The IsProgramStructure() function returns true if an executable decribes a programming structure such as a workplan, non-sequential, parallel or selective.

Arguments

exe_id: The identity of the executable.

Related Functions

GetNestedExecutableNext: This function returns each executable in a program structure.
GetMainWorkplan: Gets the main workplan that leads to all other executables.
IsWorkplan: This function returns a 1 if the program structure is a workplan.

Common Errors

Project not defined: There is no AP-238 file open.

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

Project not defined: There is no AP-238 file open.
Invalid type: The given identifier does not define a workingstep.

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

GetWorkplanExecutableNext: This function returns each executable in a workplan.
GetSelectiveExecutableNext: This function returns each executable in a selective.
GetMainWorkplan: Gets the main workplan that leads to all other executables.
IsWorkplan: This function returns 1 if the program structure is a workplan.

Common Errors

Project not defined: There is no AP-238 file open.

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

SiemensCycleXXX: Functions to get the parameters of a Siemens cycle.
GetWorkingstepPropertyLengthMeasure: Function to get one of the properties of a Siemens Cycle.

Common Errors

Project not defined: There is no AP-238 file open.

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

GetWorkplanExecutableNext: This function returns each executable in a workplan.
GetSelectiveExecutableNext: This function returns each executable in a selective.
GetMainWorkplan: Gets the main workplan that leads to all other executables.

Common Errors

Project not defined: There is no AP-238 file open.

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

GetWorkplanExecutableNext: This function returns each executable in a workplan.
GetSelectiveExecutableNext: This function returns each executable in a selective.
GetMainWorkplan: Gets the main workplan that leads to all other executables.

Common Errors

Project not defined: There is no AP-238 file open.

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

Project not defined: There is no AP-238 file open.

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

Project not defined: There is no AP-238 file open.

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

GetWorkplanExecutableCount: The number of executables contains by a workplan.
GetWorkplanExecutableNext: This function returns the next executable in a workplan.
GetMainWorkplan: Gets the main workplan that leads to all other executables.

Common Errors

Project not defined: There is no AP-238 file open.
Bad identity: The exe_id does not identify an executable.

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

Open238: Reads an AP-238 file.
SaveAsModules: Stores the current project in an AP-238 file using the Part 28 XML format.
SaveAsPart21: Stores the current project in an AP-238 file using the Part 21 ASCII format.
GetFeatureAllCount/Next: Functions to get all the features in a project.
GetMainWorkplan: Function to get the main workplan which will be empty if the file has been opened using Open224.

Common Errors

File not found. The file name may use the common syntax to define directories and network locations.

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

Open224: Starts a new project by reading an AP-224 file.
SaveAsModules: Stores the current project in an AP-238 file using the Part 28 XML format.
SaveAsPart21: Stores the current project in an AP-238 file using the Part 21 ASCII format.
GetMainWorkplan: Returns the main workplan of the project.

Common Errors

File not found. The file name may use the common syntax to define directories and network locations.

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

IsMultiSpindle():Returns true if the project requires more than one spindle.
IsParallel: Returns true if the given executable is a Parallel (concurrent) program stucture.
IsWorkplan:Returns true if the given executable is a Workplan (sequential) program stucture.
IsSelective:Returns true if the given executable is a Selective (pick one) program stucture.

Common Errors

Project not defined: There is no AP-238 file open.

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

Shutdown: Deletes all the data in the object as well as setting it back to its initial state.

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

SaveAsPart21: Saves current project into a file in the Part 21 format
Open238: Reads an AP-238 file from XML and Part 21 format files.

Common Errors

No project open: An AP-238 file must be open.

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

SaveAsModules: Saves current project into a file in the Part 28 format
Open238: Reads an AP-238 file from Part 28 and Part 21 format files.

Common Errors

No project open: An AP-238 file must be open - see the NewProject function.

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

IsSiemensCycleXXX: Functions to test if a workingstep is defined by a Siemens Cycle.

Common Errors

Project not defined: There is no AP-238 file open.
Invalid identifier. Exe_id does not identify an entity.

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.