Overview

The Tolerance class is used to create and manipulate tolerance data. Applications that can be implemented using the tolerance object include:

The Tolerance object uses the APT object to read and write data so any program that contains the tolerance object must also contain the APT object.

The Tolerance object combines CAD and CAM system data to enable new functionality on the CNC. CAM systems define a process for making a part that includes information, given either implicitly or explicitly, about which faces are being machined in each operation. CAD systems define tolerance constraints that are applied to faces in the part. The Tolerance object provided navigation functions that bridges the two information domains so that:

Next:

The following figure shows how the functions in the Tolerance object enable the functionality. In the figure a subset of the entities defined in the STEP-NC model are shown. These entities are the ones that provide the key functionality for the tolerance object. The functions that navigate between those entities are shown with an arrow in the direction of the navigation.

The datum entity defines one or more faces that are a reference point for a tolerance. See the AddTolerance functions for a description of how each tolerance uses its datums.

The Tolerance entity defines a constraint on the part being machined. A tolerance is applied to one or more faces. If a tolerance is geometric then it may have one or more datums.

A face entity defines a region on the surface of a part. Face is the key entity that is shared between the CAD and the CAM data.

A geometry entity defines a mathematical surface such as a plane, cylinder or b-spline. Measurements are made by comparing the mathematical definition of the surface with the definition that can be computed by measuring points on the surface.

A workingstep entity defines a machining operation that is applied to one or more faces. If there are errors in the tolerances applied to a face then it must have been caused by errors in the machining process defined by the workingstep.

A cutting tool is used by a workingstep to machine a feature on the part. If there are errors in the tolerances then those errors are most likely caused by wear on the cutting tools and geometric reasoning performed by an application or by the API can correct the tolerances by compensating for the wear.

A probing workingstep is a speial type of workingstep that uses a probe to touch a part. The difference between the expected value of the touch point and the actual value of the point can be used as the “raw” material for evaluating the faces, measuring the tolerances and compensating the tools.

The figure shows some of the functions in the Tolerance object. In the figure the functions that begin with “Get” define functionality that was put into the STEP-NC data model during its definition. The functions that begin with “Navigate” are value added provided by the Tolerance object. These functions were implicit in the STEP-NC model and they are defined explicitly in the API to enable the evaluation, measurement and compensation functionality.

Finding Tolerance Data

The following code segment shows how to find the tolerances in a workpiece and print out their type and current value. The program starts by using the APT object to read a STEP geometry file into the workpiece. The program then finds the number of tolerances and loops over each tolerance printing its value for a geometric tolerance and a surface texture parameter, or its lower and upper limits for a size dimension and location dimension.

apt->Workpiece ("example.stp");
int wp_id = apt->GetCurrentWorkpiece ();
int count = tol->GetWorkpieceToleranceCount (wp_id);
printf ("Tolerance count is %d\n", count);
double value, lower, upper;

for (int i = 0; i < count; i++) {
   int tol_id = tol->GetWorkpieceToleranceNext (wp_id, i);
   CString type = tol->GetToleranceType (tol_id);
   value = tol->GetToleranceValue (tol_id);

   if (tol->IsSizeDimension (tol_id) ||
tol->IsLocationDimension (tol_id)) {
      tol->GetTolerancePlusMinus (tol_id, &lower, &upper);
	 printf ("lower = %f, upper = %f, type = %s\n", 
value + lower, value + upper, type);
   }
   else if (tol->IsGeometricTolerance(tol_id) || 
tol->IsSurfaceTextureParameter (tol_id)) {
	    printf ("value = %f, type = %s\n", value, type);
   }
}

There are four types of tolerances in STEP. Geometric tolerances such as flatness define a tolerance value. Size dimension tolerances such as Diameter_size_dimension define a dimension wth an upper and lower bound. Location dimension tolerances define a distance between two items also using an upper and lower bound. Surface texture parameter tolerances define the allowed properties for a surface using a tolerance value. You can argue that only Geometric Tolerances are “real” tolerances but all four types count as tolerances within the context of the functionality of the Tolerance object.

The figure below lists the types of tolerances allowed in each category.

Finding Toleranced Surfaces

Each tolerance is applied to one or more surfaces. The following program shows how to find these toleranced surfaces. It also prints out the geometric type of each surface. In this example the data is read from an AP-238 file and all of the geometry models in that file are searched including the workpieces, rawpieces, fixtures and cutting tools.

apt->Open238 ("example.238");
int count = tol->GetToleranceAllCount ();
printf ("Tolerance count is %d\n", count);
for (int i = 0; i < count; i++) {
   int tol_id = tol->GetToleranceAllNext (i);
   int count2 = tol->GetToleranceFaceCount (tol_id);
   printf ("Face count for tol at id %d is %d\n\t", 
			tol_id, count2);
   for (int j = 0; j < count2; j++) {
      int fid = tol->GetToleranceFaceNext (tol_id, j);
	 CString type = tol->GetFaceGeometryType (fid);
      printf ("%s ", face_type);
   }
   printf ("\n");
}

Location dimension tolerances have both a source and target set of faces. The GetToleranceFaceCount/Next functions return both sets of faces. If your program needs to be more specific then use the GetToleranceOriginFaceCount/Next and GetToleranceTargetFaceCount/Next functions.

The faces in a tolerance are important for many reasons. When a tolerance is tested using a guage or probes the testing is implemented by measuring the surfaces of the faces. When tolerances are corrected by changing tool compensations, the tool to be corrected is found by comparing the faces in the tolerance with the faces in the features being machined by the tool.

Finding Datums of Geometric Tolerances

The datum of a tolerance defines reference geometry that is used in the measurement of the tolerance. The following program lists out the datums of each tolerance on the fixture. The GetCurrentFixture function of the APT object is used to get the identity of the fixture. Only geometric tolerances have datums. If one of the other kinds of tolerances is used as the argument for the GetToleranceDatumCount then the result returned will be 0.

apt->Open238 ("example.238");
int wp_id = apt->GetCurrentFixture ();
int count = tol->GetWorkpieceToleranceCount (wp_id);
printf ("Tolerance count is %d\n", count);
for (int i = 0; i < count; i++) {
   int td = tol->GetWorkpieceToleranceNext (wp_id, i);
   int count2 = tol->GetToleranceDatumCount (tol_id);
   printf ("Datum count for tol at id %d is %d\n\t",
tol_id, count2);
   for (int j = 0; j < count2; j++) {
      CString l = tol->GetToleranceDatumNextLabel (td, j);
      printf ("(%s)", l);
   }
   printf ("\n");
}

Datums also have a set of one or more faces. You can get the faces of a datum using the GetDatumFaceCount/Next functions. These functions require a datum_id which is delivered by the GetToleranceDatumNext function.

Defining Tolerances

STEP data containing tolerances is not yet widely available from CAD vendors. Therefore, many applications will need to create their own tolerances. This can be done using the user interface of the STEP-NC Explorer or using the AddToleranceXXX functions of the API which are also used by the Explorer.

Some of the AddTolerance functions require datum’s. The following code fragment uses the GetFaceXXX functions to define faces for three datums and then creates a position tolerance of value 0.1 that uses the three datums. The last parameter of the AddTolerancePosition function names the three datums. This function and all of the other functions to make geometric tolerances assume the datums will be given by names that consist of a single letter. If this condition cannot be met then the datums must added individually using the AddDatumToTolerance function. The C datum has the Maximum Material Condition modifier set.

tol->AddDatum ("A", tol->GetFaceTop());
tol->AddDatum ("B", tol->GetFaceLeft());
tol->AddDatumMax ("C", tol->GetFaceFront());
tol->AddTolerancePosition (tol->GetFaceBottom (), 0.1, "ABC");

The next code fragment builds a diameter size tolerance. The code finds all the cylinders in the file and applies the same tolerance to every cylinder which may not be very realistic. Size dimension tolerances do not require datum’s.

int count = tol->GetFaceAllCount ();
printf ("File contains %d faces\n", count);
for (int i = 0; i < count; i++) {
   int fid = tol->GetFaceAllNext (i);
   CString type = tol->GetFaceGeometryType (fid);
   if (type == "cylindrical_surface") {
      int gid = tol->GetFaceMeasureGeometry (fid);
	 double rad = tol->GetMeasureGeometryRadius (gid);
	 tol->AddToleranceSizeDiameter (fid, 2 * rad, 0.01, -0.005);
   }
}

Our last code fragment for this section creates a linear distance tolerance. This code illustrates how to create a tolerance with origin and target faces. It also shows how to create a tolerance that applies to multiple faces using a Callout. A Callout is a collection of faces on a workpiece. Every tolerance is applied to a Callout but most callout’s only contain one face so the callout is created implicitly by the functions. In this code we use the AddFaceToCalloutAdd function to add a second face to the Callout created for the origin. Location dimension tolerances also do not require datums.

int origin = tol->GetFaceTop();
tol->AddFaceToCalloutAdd (source, tol->GetFaceLeft ());
int target = tol->GetFaceFront ();
tol->AddToleranceDistanceLinear (origin, target, 10, 0.01, -0.02);

Defining Probing Operations

Probes are an on machine device to test the location of a point. By defining a probing operation a program can determine the difference between the actual and predicted location of the point and use the difference to determine the accuracy of a tolerance.

The following progam fragement defines a profile tolerance for every b_spline surface in the workpiece and then picks twenty points on each surface for probing. The probing operations are put into a nested workplan and each of these workplans is added to the start of the main workplan.

int wp_id = apt->GetCurrentWorkpiece ();
int plan_id = apt->GetCurrentWorkplan ();
int count = tol->GetWorkpieceFaceCount (wp_id);
printf ("File contains %d faces in piece at %d\n", 
count, wp_id);
for (int i = 0; i < count; i++) {
   int fid = tol->GetWorkpieceFaceNext (wp_id, i);
   CString type = tol->GetFaceGeometryType (fid);
   if (type == "b_spline_surface_with_knots") {
      tol->AddToleranceSurfaceProfile (face_id, 0.1, "");
      tol->PlanBSplineProbing (plan_id, -1, "test", face_id, 4, 5);
	 break;
   }
}

Measurements

After a tolerance has been evaluated its measured value can be set using the PutToleranceMeasuredValue () function. The following code fragment illustrates by setting the current value of all of the tolerances defined for the workpiece to 5% more than their programmed value.

In general measuring tolerances can be quite complex. Depending on the type of the tolerance, and the type of the faces constrained by the tolerance, there may be a special type of device that can measure that tolerance (for example a circular_runout tolerance is measured by a special device), or there may be an algorithm that can compute a measured value for the tolerance by comparing the expected geometry of the faces with the actual geometry evaluated from the measurements made by touch probing.

int count = tol->GetWorkpieceToleranceCount (wp_id);
printf ("Workpiece contains %d tolerances\n", count);
for (int i = 0; i < count; i++) {
   int tol_id = tol->GetWorkpieceToleranceNext (wp_id, i);
   double value = tol->GetToleranceValue (tol_id);
   tol->PutToleranceMeasuredValue (tol_id, value * 1.05);
}

Defining the Faces Machined by a Tool

Tool compensations are computed by finding the faces machinined by the tool and comparing them with the faces measured by a tolerance.

If the “raw” STEP-NC data created by combining STEP geometery with APT-CL files does NOT include a description of the faces being machined by each tool then this must be added. There are three methods for doing this in the STEP-NC API.

apt->Open238 ("example.238");
find->Open238 ("example.238");
int wp_id = find->GetMainWorkplan ();
int size = find->GetNestedExecutableCount (wp_id);
for (int i = 0; i < size; i++) {
   int exe_id = find->GetNestedExecutableNext (wp_id, i);
   printf ("i = %d, ws = %s\n", i, find->GetExecutableName (exe_id));
   if (find->IsWorkingstep (exe_id))
      tol->AddFacesWithinThresholdToWorkingstep (exe_id, 1.01);
}	

Values are very rarely exact in CNC machining so the parameter “1.01” of the function defines a fudge factor that allowsa face to be found if the gap distance between the tool and the face is within 1% of the diameter of the tool.

Finding the Faces Machined by a Tool

After faces have been assigned to the workingsteps, several new navigation paths become available. In particular from a face we can find both the tools responsible for machining that face using the NavigateFaceToToolCount/Next functions, and the tolerances that constrain a face using the NavigateFaceToToleranceCount/Next functions.

The following code illustrates by iterating over all of the faces in a workpiece and listing the tools and tolerances that apply to each face.

int count = tol->GetWorkpieceFaceCount (wp_id);
for (i = 0; i < count; i++) {
   int fid = tol->GetWorkpieceFaceNext (wp_id, i);
   int size = tol->NavigateFaceToToolCount (face_id);
   for (int j = 0; j < size; j++) {
      int tool_id = tol->NavigateFaceToToolNext (fid, j);
	 printf ("Face at '%d' is machined by Tool at '%d'\n", fid, tool_id);
   }
   size = tol->NavigateFaceToToleranceCount (face_id);
   for (j = 0; j < size; j++) {
      int tid = tol->NavigateFaceToToleranceNext (fid, j);
	 printf ("Face at '%d' is belongs to Tol at '%d'\n", fid, tid);
   }
}

Finding the Tolerances Machined by a Tool

The connection between tools and tolerances enabled by their common faces allows other navigation functions to be implemented such as NavigateToleranceToToolCount/Next and NavigateToolToToleranceCount/Next. These functions combine the functionality of the navigation functions shown in the figure found in the Overview and have the added advantage of removing duplicates from the result.

The following function illustrates by finding the tool(s) responsible for machining each tolerance in a STEP-NC file.

int count = tol->GetToleranceAllCount ();
for (int j = 0; j < count; j++) {
   int tol_id = tol->GetToleranceAllNext (j);
   int size = tol->NavigateToleranceToToolCount (tol_id);
   for (int j = 0; j < size; j++) {
      int tool_id = tol->NavigateToleranceToToolNext (tol_id, j);
	 printf ("Tolerance '%d' is machined by Tool'%d'\n", tol_id, tool_id);
   }
}

If only one tool is responsible for machining a tolerance then obviously that tool is the one that must be compensated to correct the tolerance.

Determining the Type of Compensation

For 2.5D machining the compensation required to correct a tolerance will depend on the type and direction of the face. If the face is a horizontal plane then the tool length should be compensated. If the face is a vertical plane or a cylinder then the tool diameter should be compensated.

The following code fragement gets the first surface in the first tolerance of the workpiece and if it is a plane determines if the plane is horizontal or vertical using a simple test on the value of the z axis.

int tol_id = tol->GetWorkpieceToleranceNext (wp_id, 0);
int face_id = tol->GetToleranceFaceNext (tol_id, 0);

double x, y, z, i, j, k, a, b, c;
int geo_id = tol->GetFaceMeasureGeometry (face_id);
CString type = tol->GetFaceGeometryType (geo_id);
if (type == "plane") {
   tol->GetMeasureGeometryPlacement (
	geo_id, &x, &y, &z, &i, &j, &k, &a, &b, &c
	);
   if (k == 1 || k == -1)
      printf ("Tol '%d' is for a horizontal plane\n", tol_id);
   else
	 printf ("Tol '%d' is for a vertical plane\n", tol_id);
}

Determining the Compensation Value

The method used to correct a tolerance depends on the type of the tolerance. In this section we will assume we are correcting a linear distance tolerance. Ideally the measured value of the tolerance should be at the mid-point of the lower and upper values.

wp_id = find->GetWorkpieceID ();
int tol_id = tol->GetWorkpieceToleranceNext (wp_id, 1);
if (!tol->IsLocationDimension (tol_id)) {
   printf ("'%d' is not a location distance dimension\n", tol_id);
   return 0;
}

double upper, lower;
tol->GetTolerancePlusMinus (tol_id, &lower, &upper);

long defined_set, measured_set, nominal_set, current_set;
double defined_value, measured_value, 
double nominal_value, current_value;
measured_value = tol->GetToleranceMeasuredValue (tol_id, 
		&defined_set, &measured_set, &defined_value);
if (!measured_set) {
   printf ("Tolerance at '%d' has no measured value\n", tol_id);	
   return 0;
}

double mid_point_value = defined_value + (upper + lower)/2;
printf ("Measured value is %f desired value is %f\n", 
	measured_value, mid_point_value);

double compensate = measured_value - mid_point_value;
int tool_id = tol->NavigateToleranceToToolNext (tol_id, 0);
tol->GetToolCurrentLength (tool_id, &nominal_set, ¤t_set, &nominal_value);
printf ("Setting tool length to %f from %f\n", 
	nominal_value, nominal_value - compensate);
tol->PutToolCurrentLength (tool_id, 
nominal_value - compensate);

When the compensation value has been determined, the tool responsible for the tolerance is found and its length is adjusted because this is assumed to be a vertical tolerance for a planar face. The code also assumes the face being measured is the top one for the tolerance.

A more complete piece of code would have to test for all of these cases. A more robust solution is to use the TakeToolAdvice function to correct the tool compensations. This function compares all the toleances for all of the tools and computes a best order for making the compensations so that a compensation made for one face can be used to adjust the compensation for the next face.

Tolerance Flags for Extra Parameters

Geometric tolerances can contain a variety of extra parameters that must be announced at creation time. The values can be set later.

The tolerance creation functions have a simple version that creates a basic tolerance, and a "WithFlags" version that takes a bit flag is assembled from the "WITH_" values below.

WITH_MODS
For tolerances that have one or more modifiers associated with them. Modifiers are added with AddModifierToTolerance()
WITH_MAX
For tolerances that have a maximum value. Set the value with PutToleranceMax(). Test whether the value is supported and retrieve it using GetToleranceMax(). A maximum value is associated with Ⓜ or Ⓛ. This implies WITH_MODS
WITH_DEFINED_UNIT
For unit-basis tolerances that can only vary by the given amount over a given length. Set the distance value with PutToleranceDefinedUnit(). Test whether the value is supported and retrieve it using GetToleranceDefinedUnit().
WITH_DEFINED_AREA
For unit-basis tolerances that can only vary by the given amount over a two dimensional area unit. This implies WITH_DEFINED_UNIT. Set the dimensions and shape with PutToleranceDefinedAreaUnit(). Test whether the value is supported and retrieve it using GetToleranceDefinedAreaUnit().
WITH_UNEQUAL
For tolerances that will have an unequally disposed value Ⓤ Set the displacement value with PutToleranceUnequal(). Test whether the value is supported and retrieve it using GetToleranceUnequal().
ORIG_MODIFIER
This is not used. For old-style AP214 tolerances with a single modifier.
WITH_DATUMS
This is not normally used. The tolerance creation functions will add this flag automatically if you specify a set of datums "ABC" when creating a tolerance.

Use these flags when calling AddToleranceAngularityWithFlags(), AddToleranceCircularRunoutWithFlags(), etc. See AddToleranceWithFlags() for a more general function with additional flags for the geometric type of the tolerance.

Int64 callout_id;
Int64 tol_id = tol->AddTolerancePositionWithFlags(
    callout_id, 0.01, "ABC", WITH_MODS + WITH_DEFINED_AREA
    );

// add a square 0.02 X 0.02 defined area unit
tol->PutToleranceDefinedAreaUnit(
    tol_id, 0.02, 0.02, "square"
    );

// add maximum material condition modifier to the tolerance
tol->AddToleranceModifier(
    tol_id, "maximum_material_requirement"
    );


//
// Create another tolerance with max and unequal disposition.
// The MAX flag implies WITH_MODS.
//
tol_id = tol->AddTolerancePositionWithFlags(
    callout_id, 0.01, "ABC", WITH_MAX + WITH_UNEQUAL
    );

// add a maximum tolerance value and MMC modifier
tol->PutToleranceMax( tol_id, 0.05 );"
tol->AddToleranceModifier( tol_id, "maximum_material_requirement" );
tol->AddToleranceUnequal( tol_id, 0.007 );

AddDatum()

System::Int64 AddDatum(
	System::String^ label,
	System::Int64 face_id
	);

The AddDatum() function creates a new datum with the given label and returns the id of the new object.

Arguments

label
The name of the datum. Other functionality in the API will work best if this label is a single letter.
face_id
The identity of a face to be used in the datum.

Related Functions

Common Errors

AddDatumTarget()

System::Int64 AddDatumTarget(
	System::String^ label,
	System::Int64 target_id
	);

The AddDatumTarget() function creates a new target datum with the given label and returns the identity of the new datum.

Arguments

label
The name of the datum. Other functionality in the API will work best if this label is a single letter.
target_id
The identity of a target to be used in the datum.

Related Functions

Common Errors

AddDatumToTolerance()

void AddDatumToTolerance(
	System::Int64 tol_id,
	System::Int64 dat_id,
	);
void AddDatumToTolerance(
	System::Int64 tol_id,
	System::String^ label,
	);

The AddDatumToTolerance() function adds a datum to a tolerance. (Note: In AP242 the precedence of a datum is determined by its position in a list which corresponds to the order in which it was added.)

Arguments

tol_id
The identity of the tolerance that is have the datum.
datum_id
The identity of the datum.
label
The datum label.

Related Functions

Common Errors

AddDatumToToleranceRemove()

void AddDatumToToleranceRemove(
	System::Int64 tol_id,
	System::Int64 dat_id
	);

The AddDatumToToleranceRemove() function deletes a datum from a tolerance.

Arguments

tol_id
The identity of the tolerance.
datum_id
The identity of the datum.

Related Functions

Common Errors

AddDatumToToleranceRemoveAll()

void AddDatumToToleranceRemoveAll(
	System::Int64 tol_id
	);

The AddDatumToToleranceRemoveAll() function removes all the datums from a tolerance.

Arguments

tol_id
The identity of the tolerance.

Related Functions

Common Errors

AddFaceToCalloutAdd()

void AddFaceToCalloutAdd(
	System::Int64 id,
	System::Int64 face_id
	);

The AddFaceToCalloutAdd() function adds an item to a callout. The item can be any kind of geometric representation item, but is most commonly an advanced face. The callout can be a datum, a tolerance or a feature. The callout is most commonly identified by giving the identity of a face already in the callout.

Arguments

callout_id
The identity of a workingstep, tolerance, datum or face. If a face or other item is given then the system will look for a callout containing the face or make a new callout.
face_id
The geometric representation item to be added to the callout.

Related Functions

Common Errors

AddFaceToCalloutAddOrigin()

void AddFaceToCalloutAddOrigin(
	System::Int64 loc_id,
	System::Int64 face_id
	);

The AddFaceToCalloutAddOrigin() function adds a face or other type of geometric representation item to a callout. The callout must be the origin of a dimension. The callout is most commonly identified by giving the identity of a face already in the callout.

Arguments

target_id
The identity of a dimension that has an origin.
face_id
The geometric item to be added to the callout.

Related Functions

Common Errors

AddFaceToCalloutAddTarget()

void AddFaceToCalloutAddTarget(
	System::Int64 loc_id,
	System::Int64 face_id
	);

The AddFaceToCalloutAddTarget() function adds a face or other type of geometric representation item to a callout. The callout must be the target of a dimension. The callout is most commonly identified by giving the identity of a face already in the callout.

Arguments

target_id
The identity of a dimension that has a target.
face_id
The face or other type of item to be added to the callout.

Related Functions

Common Errors

AddFaceToCalloutRemove()

void AddFaceToCalloutRemove(
	System::Int64 id,
	System::Int64 face_id
	);

The AddFaceToCalloutRemove() function removes a face or other item from a callout. The callout can be a datum, a tolerance or a feature. The callout is most commonly identified by giving the identity of a face already in that callout.

Arguments

callout_id
The identity of a workingstep, tolerance, datum or item. If an item is given then the system will look for a callout containing the item.
face_id
The item to be removed from the callout.

Related Functions

Common Errors

AddFaceToCalloutRemoveAll()

void AddFaceToCalloutRemoveAll(
	System::Int64 id
	);

The AddFaceToCalloutRemoveAll() function removes all the items from a callout. The callout can be a datum, a tolerance or a feature.

Arguments

callout_id
The identity of a workingstep, feature, tolerance or datum.

Related Functions

Common Errors

AddFaceToCalloutRemoveAllOrigin()

void AddFaceToCalloutRemoveAllOrigin(
	System::Int64 loc_id
	);

The AddFaceToCalloutRemoveAllOrigin() function removes all the items from a callout. The callout must be the orogin of a dimension.

Arguments

callout_id
The identity of a dimension with an origin.

Related Functions

Common Errors

AddFaceToCalloutRemoveAllTarget()

void AddFaceToCalloutRemoveAllTarget(
	System::Int64 loc_id
	);

The AddFaceToCalloutRemoveAllTarget() function removes all the items from a callout. The callout must be the target of a dimension.

Arguments

callout_id
The identity of a dimension with a target.

Related Functions

Common Errors

AddFaceToCalloutRemoveOrigin()

void AddFaceToCalloutRemoveOrigin(
	System::Int64 loc_id,
	System::Int64 face_id
	);

The AddFaceToCalloutRemoveOrigin() function removes an item from a callout. The callout must be the target of a dimension.

Arguments

callout_id
The identity of a dimension with a target.
face_id
The item to be removed from the callout.

Related Functions

Common Errors

AddFaceToCalloutRemoveTarget()

void AddFaceToCalloutRemoveTarget(
	System::Int64 loc_id,
	System::Int64 face_id
	);

The AddFaceToCalloutRemoveTarget() function removes an item from a callout. The callout must be the target of a dimension.

Arguments

callout_id
The identityof a dimension with a target.
face_id
The item to be removed from the callout.

Related Functions

Common Errors

AddFacesWithinThresholdToWorkingstep()

void AddFacesWithinThresholdToWorkingstep(
	System::Int64 ws_id,
	double fudge_factor
	);

The AddFacesWithinThresholdToWorkingstep() function uses the tool paths in a working step to determine which faces should be added to the process feature in that workingstep.

Arguments

ws_id
The identity of the workingstep.
fudge_factor
A percentage to be applied to the tool diameter to allow for the selection of faces that are not quite touching the tool. The default is 1.01 or 1%. This default will be used if the given fudge_factor is zero or less than zero.

Related Functions

Common Errors

AddModifierToDatumTolerance()

void AddModifierToDatumTolerance(
	System::Int64 tol_id,
	System::Int64 dat_id,
	System::String^ modifier
	);
void AddModifierToDatumTolerance(
	System::Int64 tol_id,
	System::String^ datum_label,
	System::String^ modifier
	);

The AddModifierToDatumTolerance() function adds a modifier to a datum of a tolerance.

Arguments

tol_id
The identity of the tolerance that is have the datum.
dat_id
The identity of the datum that is to have the modifier.
datum_label
The lable the datum that is to have the modifier.
modifier
The new modifier, specified as one of the strings listed below.

The modifiers are specified using the following names:

Related Functions

Common Errors

AddModifierToDatumToleranceRemove()

void AddModifierToDatumToleranceRemove(
	System::Int64 tol_id,
	System::Int64 dat_id,
	System::String^ modifier
	);

The AddModifierToDatumToleranceRemove() function removes a modifier to a datum of a tolerance.

Arguments

tol_id
The identity of the tolerance that is have the datum.
dat_id
The identity of the datum that is to have the modifier.
modifier
The modifier.

Common Errors

AddModifierToDatumToleranceRemoveAll()

void AddModifierToDatumToleranceRemoveAll(
	System::Int64 tol_id,
	System::Int64 dat_id
	);

The AddModifierToDatumToleranceRemoveAll() function removes all the modifier of a datum of a tolerance.

Arguments

tol_id
The identity of the tolerance that is have the datum.
dat_id
The identity of the datum that is to have the modifier.

Common Errors

AddModifierToTolerance()

void AddModifierToTolerance(
	System::Int64 tol_id,
	System::String^ modifier
	);

The AddModifierToTolerance() function adds an additional modifier to a tolerance that has modifiers. Only modifiers without parameters can be added to a tolerance, although the STEP standard also allows several with numeric parameters. These modifiers are listed below. Contact us if this is an issue for your application.

The modifiers are specified using the following names:

Arguments

tol_id
The identity of the tolerance that is have the datum.
modifier
The string name for the modifier, as shown in the list above.

Related Functions

Common Errors

AddModifierToToleranceRemove()

void AddModifierToToleranceRemove(
	System::Int64 tol_id,
	System::String^ modifier
	);

The AddModifierToToleranceRemove() function removes the modifier from a tolerance

Arguments

tol_id
The identity of the tolerance that is have the datum.
modifier
The modifier.

Common Errors

AddModifierToToleranceRemoveAll()

void AddModifierToToleranceRemoveAll(
	System::Int64 tol_id
	);

The AddModifierToTolerance() function removes all the modifiers from a tolerance.

Arguments

tol_id
The identity of the tolerance that is have the datum.

Common Errors

AddSurfaceTextureParameter()

System::Int64 AddSurfaceTextureParameter(
	System::Int64 face_id,
	System::String^ parameter_name,
	double value,
	System::String^ measuring_method
	);

The AddSurfaceTextureParameter() function creates a new surface texture parameter. See the GetSurfaceTextureParameter functions for a description of the parameters. This function adds the new parameter to the current workpiece. If the parameter needs to be added to a different type of workpiece such as the rawpiece, fixture or cutting tool then it should be imported and exported as the workpiece using the APT functionality and then imported as the required type of workpiece.

Arguments

face_id
The identity of a face, workingstep, tolerance, datum or feaure. If a face is given then the system will look for a callout containing the face or make a new callout.
parameter_name
The name of the parameter e.g. “Ra” see GetSurfaceTextureParameterName for a description of the allowed names.
value
The value of the texture. The unit will be micoinches if the APT object is currently in inch mode and micrometers if the APT object is currently in millimeter mode.
measurement_method
The ISO standard that defines the measurement method e.g. “ISO 2487” see the GetSurfaceParameterMeasurementMethod function for a description of the allowed measurement methods.

Related Functions

Common Errors

AddTargetCircle()

System::Int64 AddTargetCircle(
	System::Int64 wp_id,
	double diameter,
	double x,
	double y,
	double z,
	double i,
	double j,
	double k
	);

The AddTargetCircle() function creates a circlular target for a datum and returns the target_id of the new target point.

Arguments

wp_id
The workpiece containing the datum
x, y, z
The coordinates of the center
i, j, k
The axis of the center
diameter
The diameter of the circle

Related Functions

Common Errors

AddTargetPoint()

System::Int64 AddTargetPoint(
	System::Int64 wp_id,
	double x,
	double y,
	double z
	);

The AddTargetPoint() function creates a point target for a datum and returns the target_id of the new target point.

Arguments

wp_id
The workpiece containing the datum
x, y, z
The coordinates of the point

Related Functions

Common Errors

AddTargetRectangle()

System::Int64 AddTargetRectangle(
	System::Int64 wp_id,
	double length,
	double width,
	double x,
	double y,
	double z,
	double i,
	double j,
	double k,
	double a,
	double b,
	double c
	);

The AddTargetRectangle() function creates a rectangular target for a datum and returns the target_id of the new target point.

Arguments

wp_id
The workpiece containing the datum
x, y, z
The coordinates of the center
i, j, k
The axis of the center
a, b, c
The rotation around the center
length
The length of the rectangle
width
The width of the rectangle

Related Functions

Common Errors

AddTargetStraightLine()

System::Int64 AddTargetStraightLine(
	System::Int64 wp_id,
	double length,
	double x,
	double y,
	double z,
	double i,
	double j,
	double k
	);

The AddTargetStraightLine() function creates a straight line target for a datum and returns the target_id of the new target point.

Arguments

wp_id
The workpiece containing the datum
x, y, z
The coordinates of the point
i, j, k
The direction of the line
length
The length of the line

Related Functions

Common Errors

AddTargetToDatumAdd()

void AddTargetToDatumAdd(
	System::Int64 dat_id,
	System::Int64 target_id
	);

The AddTargetToDatumAdd() function adds a target to a datum.

Arguments

datum_id
The identity of a target datim.
target_id
The target to be added to the datum.

Related Functions

Common Errors

AddTargetToDatumRemove()

void AddTargetToDatumRemove(
	System::Int64 dat_id,
	System::Int64 target_id
	);

The AddTargetToDatumRemove() function removes a target from a datum.

Arguments

datum_id
The identity of a target datum.
target_id
The target to be removed from the datum.

Related Functions

Common Errors

AddTargetToDatumRemoveAll()

void AddTargetToDatumRemoveAll(
	System::Int64 dat_id
	);

The AddTargetToDatumRemoveAll() function removes all the targets from a datum.

Arguments

datum_id
The identity of a target datum

Related Functions

Common Errors

AddToleranceAngularity[WithFlags]()

System::Int64 AddToleranceAngularity[WithFlags](
	System::Int64 fea_id,
	double value,
	System::String^ datums,
	[System::Int64 flags]
	);

The AddToleranceAngularity() function creates a new angularity tolerance as shown in the figure below, and returns the identity of the new tolerance. The size of the angle (25 degree’s) in the example below is computed by examining the underlying geometry in the toleranced face and the datum. The tolerance describes the range in which the toleranced face must exist if the part is to be considered correct.

Arguments

face_id
The identity of the face (or callout) to be toleranced.
value
The size of the tolerance zone (0.08 in above figure)
datums
A list of datums given as a string (“A” in the above figure). Each datum name must be given as a single letter and must correspond to the name of a datum in the model
flags
When using the WithFlags version, this is a bit flag to declare that the tolerance has modifiers or other extra parameters

Related Functions

Common Errors

AddToleranceCircularRunout[WithFlags]()

System::Int64 AddToleranceCircularRunout[WithFlags](
	System::Int64 fea_id,
	double value,
	System::String^ datums,
	[System::Int64 flags]
	);

The AddToleranceCircularRunout() function creates a new circular runout tolerance as shown in the figure below and returns the identity of the new tolerance. The tolerance zone defines a maximum and minimum range for the path of the circle created by rotating the feature.

Arguments

face_id
The identity of the face (or callout) to be toleranced
value
The size of the tolerance zone (0.08 in above figure)
datums
A list of datums given as a string (“AB” in the above figure). Each datum name must be given as a single letter and must correspond to the name of a datum in the model
flags
When using the WithFlags version, this is a bit flag to declare that the tolerance has modifiers or other extra parameters

Related Functions

Common Errors

AddToleranceCoaxiality[WithFlags]()

System::Int64 AddToleranceCoaxiality[WithFlags](
	System::Int64 fea_id,
	double value,
	System::String^ datums,
	[System::Int64 flags]
	);

The AddToleranceCoaxiality() function creates a new coaxality tolerance as shown in the figure below and returns the identity of the new tolerance. The tolerance zone defines a cylinder that must contain the axis of the circle.

Arguments

face_id
The identity of the face (or callout) to be toleranced.
value
The diameter of the tolerance zone
datums
A list of datums given as a string (“A” in the above figure). Each datum name must be given as a single letter and must correspond to the name of a datum in the model
flags
When using the WithFlags version, this is a bit flag to declare that the tolerance has modifiers or other extra parameters

Related Functions

Common Errors

AddToleranceConcentricity[WithFlags]()

System::Int64 AddToleranceConcentricity[WithFlags](
	System::Int64 fea_id,
	double value,
	System::String^ datums,
	[System::Int64 flags]
	);

The AddToleranceConcentricity() function creates a new concentricity tolerance as in the figure below and returns the identity of the new tolerance. The tolerance zone defines a ball where the center of two spheres must coincide or a cylinder for the common axis of one or more surfaces of revolution.

Arguments

face_id
The identity of the face (or callout) to be toleranced
value
The size of the tolerance zone (0.08 in above figure)
datums
A list of datums given as a string (“AB” in the above figure). Each datum name must be given as a single letter and must correspond to the name of a datum in the model
flags
When using the WithFlags version, this is a bit flag to declare that the tolerance has modifiers or other extra parameters

Related Functions

Common Errors

AddToleranceCylindricity[WithFlags]()

System::Int64 AddToleranceCylindricity[WithFlags](
	System::Int64 fea_id,
	double value,
	[System::Int64 flags]
	);

The AddToleranceCylindricity() function creates a new cylindricity tolerance as in the figure below and returns the identity of the new tolerance. The tolerance zone defines an inner and outer cylinder for all points on the cylindrical face. Note: no datums.

Arguments

face_id
The identity of the face (or callout) to be toleranced
value
The size of the tolerance zone defined as the difference in radius between the inner and out cylinders
flags
When using the WithFlags version, this is a bit flag to declare that the tolerance has modifiers or other extra parameters

Related Functions

Common Errors

AddToleranceDistanceAngularLocation()

System::Int64 AddToleranceDistanceAngularLocation(
	System::Int64 fea1_id,
	System::Int64 fea2_id,
	double value,
	double plus,
	double minus
	);

The AddToleranceDistanceAngularLocation() function creates a new tolerance describing an angle between a source and target. Distance tolerances defined a value with a plus and minus range. Note: no datums.

Arguments

source_id
The identity of the source face or callout to be toleranced.
target_id
The identity of the target face or callout to be toleranced.
value
The defined value of the tolerance.
plus
delta The upper value allowed for the tolerance given as a delta for the defined value.
minus
delta The lower value allowed for the tolerance (value given should normally be negative) also given as a delta.

Related Functions

Common Errors

AddToleranceDistanceCurved()

System::Int64 AddToleranceDistanceCurved(
	System::Int64 fea1_id,
	System::Int64 fea2_id,
	double value,
	double plus,
	double minus
	);

The AddToleranceDistanceCurved() function creates a new tolerance describing a curved distance between a source and target. Distance tolerances defined a value with a plus and minus range. Note: no datums.

Arguments

source_id
The identity of the source face to be toleranced.
target_id
The identity of the target face to be toleranced.
value
The defined value of the tolerance.
plus
delta The upper value allowed for the tolerance given as a delta for the defined value.
minus
delta The lower value allowed for the tolerance (value given should normally be negative) also given as a delta.

Related Functions

Common Errors

AddToleranceDistanceLinear()

System::Int64 AddToleranceDistanceLinear(
	System::Int64 fea1_id,
	System::Int64 fea2_id,
	double value,
	double plus,
	double minus
	);

The AddToleranceDistanceLinear() function creates a new tolerance describing a linear distance between a source and target. Distance tolerances defined a value with a plus and minus range. Note: no datums.

Arguments

source_id
The identity of the source face to be toleranced.
target_id
The identity of the target face to be toleranced.
value
The defined value of the tolerance.
plus
delta: The upper value allowed for the tolerance given as a delta for the defined value.
minus
delta: The lower value allowed for the tolerance (value given should normally be negative) also given as a delta.

Related Functions

Common Errors

AddToleranceFlatness[WithFlags]()

System::Int64 AddToleranceFlatness[WithFlags](
	System::Int64 fea_id,
	double value,
	[System::Int64 flags]
	);

The AddToleranceFlatness() function creates a new tolerance describing a flatness constraint on a surface. All points on the surface should be between two parallel lines that are the given distance apart. Note: no datums.

Arguments

face_id
The identity of the face (or callout) to be toleranced.
value
The size of the tolerance zone defined as the difference between two planes parallel to the surface.
flags
When using the WithFlags version, this is a bit flag to declare that the tolerance has modifiers or other extra parameters

Related Functions

Common Errors

AddToleranceLineProfile[WithFlags]()

System::Int64 AddToleranceLineProfile[WithFlags](
	System::Int64 fea_id,
	double value,
	System::String^ datums,
	[System::Int64 flags]
	);

The AddToleranceLineProfile() function creates a new line profile tolerance as in the figure below and returns the identity of the new tolerance. The tolerance zone defines a two dimensional zone for the profile.

Arguments

face_id
The identity of the face (or callout) to be toleranced.
value
The size of the tolerance zone (0.08 in above figure)
datums
A list of datums given as a string (“AB” in the above figure). Each datum name must be given as a single letter and must correspond to the name of a datum in the model.
flags
When using the WithFlags version, this is a bit flag to declare that the tolerance has modifiers or other extra parameters

Related Functions

Common Errors

AddToleranceParallelism[WithFlags]()

System::Int64 AddToleranceParallelism[WithFlags](
	System::Int64 fea_id,
	double value,
	System::String^ datums,
	[System::Int64 flags]
	);

The AddToleranceParallelism() function creates a new parallelism tolerance as in the figure below and returns the identity of the new tolerance. The tolerance zone defines a two parallel planes in which all of the points of the surface must lie.

Arguments

face_id
The identity of the face (or callout) to be toleranced.
value
The size of the tolerance zone (0.02 in above figure)
datums
A list of datums given as a string (“A” in the above figure). Each datum name must be given as a single letter and must correspond to the name of a datum in the model.
flags
When using the WithFlags version, this is a bit flag to declare that the tolerance has modifiers or other extra parameters

Related Functions

Common Errors

AddTolerancePerpendicularity[WithFlags]()

System::Int64 AddTolerancePerpendicularity[WithFlags](
	System::Int64 fea_id,
	double value,
	System::String^ datums,
	[System::Int64 flags]
	);

The AddTolerancePerpendicularity() function creates a new perpendicularity tolerance as shown in the figure below and returns the identity of the new tolerance. The tolerance zone defines a two parallel planes in which all of the points of the surface must lie.

Arguments

face_id
The identity of the face (or callout) to be toleranced.
value
The size of the tolerance zone (0.02 in above figure)
datums
A list of datums given as a string (“A” in the above figure). Each datum name must be given as a single letter and must correspond to the name of a datum in the model.
flags
When using the WithFlags version, this is a bit flag to declare that the tolerance has modifiers or other extra parameters

Related Functions

Common Errors

AddTolerancePosition[WithFlags]()

System::Int64 AddTolerancePosition[WithFlags](
	System::Int64 fea_id,
	double value,
	System::String^ datums,
	[System::Int64 flags]
	);

The AddTolerancePosition() function creates a new position tolerance as in the figure below and returns the identity of the new tolerance. The position of the toleranced item must lie within the tolerance zone sphere defined by the tolerance value.

Arguments

face_id
The identity of the face (or callout) to be toleranced.
value
The size of the tolerance zone (0.08 in above figure)
datums
A list of datums given as a string (“ABC” in the above figure). Each datum name must be given as a single letter and must correspond to the name of a datum in the model.
flags
When using the WithFlags version, this is a bit flag to declare that the tolerance has modifiers or other extra parameters

Related Functions

Common Errors

AddToleranceRoundness[WithFlags]()

System::Int64 AddToleranceRoundness(
	System::Int64 fea_id,
	double value,
	[System::Int64 flags]
	);

The AddToleranceRoundness() function creates a new roundness tolerance as in the figure below and returns the identity of the new tolerance. For a sphere the roundness applies to all points on any plane intersecting the sphere. For other geometry the roundness applies to all points on a plane defined by the axis.

Arguments

face_id
The identity of the face (or callout) to be toleranced.
value
The size of the tolerance zone (0.04 in above figure)
flags
When using the WithFlags version, this is a bit flag to declare that the tolerance has modifiers or other extra parameters

Related Functions

Common Errors

AddToleranceSizeAngular()

System::Int64 AddToleranceSizeAngular(
	System::Int64 fea_id,
	double value,
	double plus,
	double minus
	);

The AddToleranceSizeAngular() function creates a new angular size tolerance. The angle to be measured is determined by the geometry of the toleranced face. Note: no datums.

Arguments

face_id
The identity of the face to be toleranced.
value
The nominal value of the tolerance.
plus
delta The upper value allowed for the tolerance given as a delta for the nominal value.
minus
delta The lower value allowed for the tolerance (value given should normally be negative) also given as a delta.

Related Functions

Common Errors

AddToleranceSizeCurved()

System::Int64 AddToleranceSizeCurved(
	System::Int64 fea_id,
	double value,
	double plus,
	double minus
	);

The AddToleranceSizeCurved() function creates a new curved size tolerance. The tolerance is applied to a curve and describes the upper and lower bounds allowed for the length of that curve. Note: no datums.

Arguments

curve_id
The identity of the curve to be toleranced.
value
The defined value of the tolerance.
plus
delta The upper value allowed for the tolerance given as a delta for the defined value.
minus
delta The lower value allowed for the tolerance (value given should normally be negative) also given as a delta.

Related Functions

Common Errors

AddToleranceSizeDiameter()

System::Int64 AddToleranceSizeDiameter(
	System::Int64 fea_id,
	double value,
	double plus,
	double minus
	);

The AddToleranceSizeDiameter() function creates a new diameter size tolerance. The tolerance is applied to a shape that has a diameter. Note: no datums.

Arguments

face_id
The identity of the face to be toleranced.
value
The defined value of the tolerance.
plus
delta: The upper value allowed for the tolerance given as a delta for the defined value.
minus
delta: The lower value allowed for the tolerance (value given should normally be negative) also given as a delta.

Related Functions

Common Errors

AddToleranceSizeHeight()

System::Int64 AddToleranceSizeHeight(
	System::Int64 fea_id,
	double value,
	double plus,
	double minus
	);

The AddToleranceSizeHeight() function creates a new height size tolerance. The tolerance is applied to a shape that has a height. See AddToleranceSizeThickness.

AddToleranceSizeLength()

System::Int64 AddToleranceSizeLength(
	System::Int64 fea_id,
	double value,
	double plus,
	double minus
	);

The AddToleranceSizeLength() function creates a new length size tolerance. The tolerance is applied to a shape that has a length. See AddToleranceSizeThickness.

AddToleranceSizeRadial()

System::Int64 AddToleranceSizeRadial(
	System::Int64 fea_id,
	double value,
	double plus,
	double minus
	);

The AddToleranceSizeRadial() function creates a new radius size tolerance. The tolerance is applied to a shape that has a radius. See AddToleranceSizeDiameter.

AddToleranceSizeThickness()

System::Int64 AddToleranceSizeThickness(
	System::Int64 fea_id,
	double value,
	double plus,
	double minus
	);

The AddToleranceSizeThickness() function creates a new thickness size tolerance. The tolerance is applied to a shape that has a thickness. Note: no datums.

Arguments

face_id
The identity of the shape to be toleranced.
value
The defined value of the tolerance.
plus
delta The upper value allowed for the tolerance given as a delta for the defined value.
minus
delta The lower value allowed for the tolerance (value given should normally be negative) also given as a delta.

Related Functions

Common Errors

AddToleranceSizeWidth()

System::Int64 AddToleranceSizeWidth(
	System::Int64 fea_id,
	double value,
	double plus,
	double minus
	);

The AddToleranceSizeWidth() function creates a new width size tolerance. The tolerance is applied to a shape that has a width. See AddToleranceSizeThickness.

AddToleranceStraightness[WithFlags]()

System::Int64 AddToleranceStraightness[WithFlags](
	System::Int64 fea_id,
	double value,
	[System::Int64 flags]
	);

The AddToleranceStraightness() function creates a new straightness tolerance. The tolerance is applied to a curve or a curve on a surface and defines a straighness constraint for that surface as in the figure below and returns the identity of the new tolerance. Note no datums.

Arguments

curve_id
The identity of the curve to be toleranced.
value
The size of the tolerance zone (0.02 in above figure)
flags
When using the WithFlags version, this is a bit flag to declare that the tolerance has modifiers or other extra parameters

Related Functions

Common Errors

AddToleranceSurfaceProfile[WithFlags]()

System::Int64 AddToleranceSurfaceProfile[WithFlags](
	System::Int64 fea_id,
	double value,
	System::String^ datums,
	[System::Int64 flags]
	);

The AddToleranceSurfaceProfile() function creates a new surface profile tolerance as shown in the figure below, and returns the identity of the new tolerance. The tolerance zone defines a boundary along a profile in which all of the points of the surface must lie.

Arguments

face_id
The identity of the face (or callout) to be toleranced.
value
The size of the tolerance zone (0.08 in above figure)
datums
A list of datums given as a string (“AB” in the above figure). Each datum name must be given as a single letter and must correspond to the name of a datum in the model.
flags
When using the WithFlags version, this is a bit flag to declare that the tolerance has modifiers or other extra parameters

Related Functions

Common Errors

AddToleranceSymmetry[WithFlags]()

System::Int64 AddToleranceSymmetry[WithFlags](
	System::Int64 fea_id,
	double value,
	System::String^ datums,
	[System::Int64 flags]
	);

The AddToleranceSymmetry() function creates a new symmetry tolerance as in the figure below and returns the identity of the new tolerance. The tolerance zone defines two parallel planes about which the feature must be symmetric.

Arguments

face_id
The identity of the face (or callout) to be toleranced.
value
The size of the tolerance zone (0.02 in above figure)
datums
A list of datums given as a string (“A” in the above figure). Each datum name must be given as a single letter and must correspond to the name of a datum in the model.
flags
When using the WithFlags version, this is a bit flag to declare that the tolerance has modifiers or other extra parameters

Related Functions

Common Errors

AddToleranceTotalRunout[WithFlags]()

System::Int64 AddToleranceTotalRunout[WithFlags](
	System::Int64 fea_id,
	double value,
	System::String^ datums,
	[System::Int64 flags]
	);

The AddToleranceTotalRunout() function creates a new total runout tolerance as in the figure below and returns the identity of the new tolerance. The tolerance zone defines a boundary that must be exceeded by the runout.

Arguments

face_id
The identity of the face (or callout) to be toleranced.
value
The size of the tolerance zone (0.08 in above figure)
datums
A list of datums given as a string (“AB” in the above figure). Each datum name must be given as a single letter and must correspond to the name of a datum in the model.
flags
When using the WithFlags version, this is a bit flag to declare that the tolerance has modifiers or other extra parameters

Related Functions

AddToleranceWithFlags()

System::Int64 AddToleranceWithFlags(
	System::Int64 fea_id,
	double value,
	System::String^ datums,
	System::Int64 flags
	);

The AddToleranceWithFlags() function creates a geometric tolerance associated with a particular callout feature and returns the identity of the new tolerance. The function also takes a numeric value for the tolerance and a string containing a list of single character datum names, like "ABC". The string should be empty if no datums are to be associated.

The geometric type of the tolerance and any additional parameters are specified as a bit flag. As with all of the other "WithFlags" functions, you can declare that the tolerance with have modifiers by passing "WITH_MODS". The full list of extra parameter is described in Tolerance Flags for Extra Parameters

In addition to the flags for extra parameters, you must specify the geometric type of the tolerance by adding one of the following to the flags value.

So for example, to specify a flatness tolerance with modifiers, pass TOL_FLATNESS + WITH_MODS as the flag value. This will return the same result as calling AddToleranceFlatnessWithFlags and just passing WITH_MODS.

CalloutApex()

System::Int64 CalloutApex(
	System::Int64 face_id
	);

The CalloutApex() function creates a callout at the apex of a cone.

Arguments

face_id
The identity of the first face for the callout.

Related Functions

CalloutBasic()

System::Int64 CalloutBasic(
	System::Int64 face_id
	);

The CalloutBasic() function explicitly creates a new callout to represent the faces in a feature. Many functions implicitly create a callout containing a single face. This function lets you make the definition more explicit. The callout creaed by this function has general semantics. The related functions listed below describe how to make callouts with more speific semantics.

Arguments

face_id
The identity of the first face for the callout.

Related Functions

CalloutCenterOfSymmetry()

System::Int64 CalloutCenterOFSymmetry(
	System::Int64 face_id
	);

The CalloutCenterOfSymmetry() function creates a callout at the center of symmetry of the faces in the callout

Arguments

face_id
The identity of the first face for the callout.

Related Functions

CalloutComposite()

System::Int64 CalloutComposite(
	System::Int64 face_id
	);

The CalloutComposite() function creates a pattern of callouts.

Arguments

face_id
The identity of the first face in the first feature of the callout.

Related Functions

CalloutCompositeAddRelated()

void CalloutCompositeAddRelated(
	System::Int64 composite_callout_id,
	System::Int64 related_callout_id
	);

The CalloutCompositeAddRealated() function adds a second feature to a callout patter.

Arguments

composite_callout_id
The identity of the composite callout to be extended.
relasted_callout_id
The identity of the callout that is to be added.

Related Functions

CalloutExtension()

System::Int64 CalloutExtension(
	System::Int64 face_id
	);

The CalloutExtension() function creates a callout where the faces in the callout are interupted by slot or other cutout.

Arguments

face_id
The identity of the first face for the callout.

Related Functions

CalloutGeometricAlignment()

System::Int64 CalloutGeometricAlignment(
	System::Int64 face_id
	);

The CalloutGeomericAlignment() function creates a callout where the faces in the callout are aligned.

Arguments

face_id
The identity of the first face for the callout.

Related Functions

CalloutParallelOffset()

System::Int64 CalloutParallelOffset(
	System::Int64 face_id,
	double offset
	);

The CalloutParallelOffset() function creates a callout at a given offset from the faces.

Arguments

face_id
The identity of the first face for the callout.
offset
The value of the offset in the current unit.

Related Functions

CalloutPerpendicularTo()

System::Int64 CalloutPerpendicularTo(
	System::Int64 face_id
	);

The CalloutPerpendicularTo() function creates a callout that is perpendicular to the faces.

Arguments

face_id
The identity of the first face for the callout.

Related Functions

CalloutTangent()

System::Int64 CalloutTangent(
	System::Int64 face_id
	);

The CalloutPerpendicularTo() function creates a callout that is tangential to the faces.

Arguments

face_id
The identity of the first face for the callout.

Related Functions

CompensationWorkingstepApply()

void CompensationWorkingstepApply(
	System::Int64 cws_or_frame_id
	);

The CompensationWorkingstepApply() function

CompensationWorkingstepChangeNominalFaces()

System::Int64 CompensationWorkingstepChangeNominalFaces(
	System::Int64 cws_or_frame_id,
	System::Int64 facea_id,
	System::Int64 faceb_id,
	System::Int64 facec_id
	);

The CompensationWorkingstepChangeNominalFaces() function

CompensationWorkingstepFrameDefinition()

System::Int64 CompensationWorkingstepFrameDefinition(
	System::Int64 wp_id,
	System::Int64 index,
	System::String^ ws_name,
	System::Int64 facea_id,
	System::Int64 faceb_id,
	System::Int64 facec_id
	);

The CompensationWorkingstepFrameDefinition() function

CompensationWorkingstepGetMeasurementCornerEvaluatedFaces()

System::Int64 CompensationWorkingstepGetMeasurementCornerEvaluatedFaces(
	System::Int64 ws_id,
	[System::Runtime::InteropServices::Out] System::Int64 %face_1,
	System::Int64 face_2,
	System::Int64 face_3
	);

The CompensationWorkingstepGetMeasurementCornerEvaluatedFaces() function

CompensationWorkingstepGetMeasurementCornerFrameEvaluatedFaces()

System::Int64 CompensationWorkingstepGetMeasurementCornerFrameEvaluatedFaces(
	System::Int64 ws_id,
	[System::Runtime::InteropServices::Out] System::Int64 %face_1,
	System::Int64 face_2,
	System::Int64 face_3
	);

The CompensationWorkingstepGetMeasurementCornerFrameEvaluatedFaces() function

CompensationWorkingstepGetMeasurementCornerFrameNominalFaces()

System::Int64 CompensationWorkingstepGetMeasurementCornerFrameNominalFaces(
	System::Int64 ws_id,
	[System::Runtime::InteropServices::Out] System::Int64 %face_1,
	System::Int64 face_2,
	System::Int64 face_3
	);

The CompensationWorkingstepGetMeasurementCornerFrameNominalFaces() function

CompensationWorkingstepGetMeasurementCornerNominalFaces()

System::Int64 CompensationWorkingstepGetMeasurementCornerNominalFaces(
	System::Int64 ws_id,
	[System::Runtime::InteropServices::Out] System::Int64 %face_1,
	System::Int64 face_2,
	System::Int64 face_3
	);

The CompensationWorkingstepGetMeasurementCornerNominalFaces() function

CompensationWorkingstepGetMeasurementWorkpiece()

System::Int64 CompensationWorkingstepGetMeasurementWorkpiece(
	System::Int64 ws_id
	);

The CompensationWorkingstepGetMeasurementWorkpiece() function

CompensationWorkingstepIsApplied()

System::Int64 CompensationWorkingstepIsApplied(
	System::Int64 cws_or_frame_id
	);

The CompensationWorkingstepIsApplied() function

CompensationWorkingstepSetup()

System::Int64 CompensationWorkingstepSetup(
	System::Int64 wp_id,
	System::Int64 index,
	System::String^ ws_name,
	System::Int64 setup_id,
	System::Int64 frame_id,
	System::Int64 facea_id,
	System::Int64 faceb_id,
	System::Int64 facec_id
	);

The CompensationWorkingstepSetup() function

CompensationWorkingstepUnapply()

void CompensationWorkingstepUnapply(
	System::Int64 cws_or_frame_id
	);

The CompensationWorkingstepUnapply() function

DeleteDatum()

void DeleteDatum(
	System::Int64 dat_id
	);

The DeleteDatum() function deletes a datum. The datum is removed from any tolerance that uses the datum.

Arguments

dat_id
Identity of the datum

Related Functions

Common Errors

DeleteDatumTarget()

void DeleteDatumTarget(
	System::Int64 tag_id
	);

The DeleteDatumTarget() function deletes a datum target. The target is removed from any datum that uses the target.

Arguments

target_id
Identity of the target

Related Functions

Common Errors

DeleteTolerance()

void DeleteTolerance(
	System::Int64 tol_id
	);

The DeleteTolerance() function deletes a tolerance.

Arguments

tol_id
Identity of the tolerance

Related Functions

Common Errors

EvaluateToleranceUsingProbeResults()

void EvaluateToleranceUsingProbeResults(
	System::Int64 tol_id
	);

The EvaluateToleranceUsingProbeResults() function evaluates the status of a tolerance using the results of a series of probing operations. The results are evaluated against the definition of the underlying surface and the type of the tolerance.

Arguments

tol_id
The identity of the tolerance.

Related Functions

Common Errors

ExportConfiguration()

void ExportConfiguration(
	System::String^ config_file_name,
	System::String^ stepnc_file_name,
	System::String^ directory_name
	);

The ExportConfiguration() function divides a STEP-NC AP238 file into constituent parts. The geometries of the workpiece, rawpiece, fixture and cutting tools are put into STEP geometry files so that they can be read by CAD systems. A configuration file is created in XML so that a new AP-238 file can be assembled from new versions of the STEP geometry components.

Arguments

xml_file_name
Name of the XML file that describes how to put the AP238 file back together from the pieces.
stepnc_file_name
Name of the STEP-NC file that is to be created by the XML script.
directory_name
Name of the directory where the STEP geometry files are to be stored.

Related Functions

ExportProbeInitialData()

void ExportProbeInitialData(
	System::String^ filename,
	System::String^ unit
	);

The ExportProbeInitialData() function exports start point data for a series of probing operations so that they can be used to compute probe result data.

Arguments

file_name
Name of the file that is to hold the initial point data.
unit
Unit (e.g. “in” or “mm”) for the coordinates of the point data

Related Functions

Common Errors

ExportProbeResultData()

void ExportProbeResultData(
	System::String^ filename,
	System::String^ unit
	);

The ExportProbeResultData() function exports result data for the probing operations in a project.

Arguments

file_name
Name of the file that is to hold the result data.
unit
Unit (e.g. “in” or “mm”) for the coordinates of the point data

Related Functions

Common Errors

ExportToolStatus()

void ExportToolStatus(
	System::String^ xml_file_name
	);

The ExportToolStatus() function saves the current status of the Tool Properties tab of the STEP-NC Explorer as an XML file so that its information can be processed by other systems. The saved data includes the current value of any measured tolerance and the current settings of the tool compensation registers.

Arguments

xml_file_name
Name of the XML file where the information is to be saved.

FindCylindricalFace()

System::Int64 FindCylindricalFace(
	System::Int64 wp_id,
	double x,
	double y,
	double z,
	double i,
	double j,
	double k,
	double radius,
	[System::Runtime::InteropServices::Out] System::Int64 %count,
	[System::Runtime::InteropServices::Out] System::Int64 %surface_id
	);

The FindCylindricalFace() function finds a cylinder using the coordinates of its axis in the STEP-NC model. This functionality is used by the ImportUsingConfiguration function to find cylinders in the workpiece that belong to features of the workplan. Returns the identity of a face that contains the cylinder (null if no faces found).

Arguments

wp_id
The identity of the piece that is to be searched.
x, y, z
The position of the axis (required).
i, j, k
The direction of the axis (optional if set to (0, 0, 0))
radius
The radius of the cylinder (required).
count
[out] Number of faces in the model that contain the found cylinder.
surface_id
[out] The identity of the cylinder.

Related Functions

FindFeature()

System::Int64 FindFeature(
	double x,
	double y,
	double z,
	double i,
	double j,
	double k,
	System::String^ type
	);

The FindFeature() function finds a feature using the raw coordinates of its axis. (The raw coordinates are the coordinates defined in the data and not necessarily the coordinates used in the model after transformations have been applied). This functionality is used by the ImportUsingConfiguration function to find features of the workplan.

Arguments

wp_id
The identity of the piece that is to be searched.
x, y, z
The position of the axis (required).
i, j, k
The direction of the axis (optional if set to (0, 0, 0))
type
The type of the feature (optional if set to empty string).

Related Functions

FindPlanarFace()

System::Int64 FindPlanarFace(
	System::Int64 wp_id,
	double x,
	double y,
	double z,
	double i,
	double j,
	double k,
	[System::Runtime::InteropServices::Out] System::Int64 %count,
	[System::Runtime::InteropServices::Out] System::Int64 %surface_id
	);

The FindPlanarFace() function finds a plane using the coordinates of its axis in the STEP-NC model. This functionality is used by the ImportUsingConfiguration function to find planes in the workpiece that belong to features of the workplan.

Arguments

wp_id
The identity of the piece that is to be searched.
x, y, z
The position of the axis (required).
i, j, k
The direction of the axis (optional if set to (0, 0, 0))
count
[out] Number of faces in the model that contain the found plane.
surface_id
[out] The identity of the plane.

Related Functions

GetCalloutDraughtingCount/Next()

System::Int64 GetCalloutDraughtingCount (
	System::Int64 ent_id
	);

System::Int64 GetCalloutDraughtingNext (
	System::Int64 ent_id,
	System::Int64 index
	);

The GetCalloutDraughtingCount() function

The GetCalloutDraughtingNext() function

GetCalloutFaceCount/Next()

System::Int64 GetCalloutFaceCount(
	System::Int64 ent_id
	);

System::Int64 GetCalloutFaceNext(
	System::Int64 ent_id,
	System::Int64 index
	);

The GetCalloutFaceCount() function returns the number of faces in a callout. For most callouts the number will be one. This function can be used to get the faces in features, tolerances and datums, and is designed to be used in conjunction with the AddFaceToCalloutXxx functions.

The GetCalloutFaceNext() function returns the next face defined in a callout model.

Arguments

callout_id
The identify of the callout.
index
The position of the required face.

Related Functions

GetCalloutFaceCountOrigin()

System::Int64 GetCalloutFaceCountOrigin(
	System::Int64 loc_id
	);

The GetCalloutFaceCountOrigin() function returns the number of faces in a dimension origin callout.

Arguments

callout_id
The identify of a dimension with an origin.

Related Functions

GetCalloutFaceCountTarget()

System::Int64 GetCalloutFaceCountTarget(
	System::Int64 loc_id
	);

The GetCalloutFaceCountTarget() function returns the number of faces in a dimension target callout.

Arguments

callout_id
The identify of a dimension with an origin.

Related Functions

GetCalloutFaceNextOrigin()

System::Int64 GetCalloutFaceNextOrigin(
	System::Int64 loc_id,
	System::Int64 index
	);

The GetCalloutFaceNextOrigin() function Returns the next face defined in a dimension origin.

Arguments

callout_id
The identify of the callout.
index
The position of the required face.

Related Functions

GetCalloutFaceNextTarget()

System::Int64 GetCalloutFaceNextTarget(
	System::Int64 loc_id,
	System::Int64 index
	);

The GetCalloutFaceNextTarget() function returns the next face defined in a dimension origin.

Arguments

callout_id
The identify of the callout.
index
The position of the required face.

Related Functions

GetCompensationMeasurementWorkpiece()

System::Int64 GetCompensationMeasurementWorkpiece(
	System::Int64 exe_id
	);

The GetCompensationMeasurementWorkpiece() function

GetDatumCount/Next()

System::Int64 GetDatumCount();

System::Int64 GetDatumNext(
	System::Int64 index,
	[System::Runtime::InteropServices::Out] System::String^ %label,
	[System::Runtime::InteropServices::Out] System::String^ %modifier
	);

The GetDatumCount() function returns a count of the number of datums defined in the model and GetDatumNext() iterates over the datum returning the object identifier of the datum and several attributes as out parameters.

Arguments

index
The position of the required datum.
label
[out] The name of the datum.
modifier
[out] The string “Maximum material condition”, “Least material condition”, “Regardless of feature size” or “none”.

Related Functions

GetDatumDraughtingCount/Next()

System::Int64 GetDatumDraughtingCount (
	System::Int64 dat_id
	);

System::Int64 GetDatumDraughtingLocalCount (
	System::Int64 dat_id
	);

System::Int64 GetDatumDraughtingNext (
	System::Int64 dat_id,
	System::Int64 index
	);

System::Int64 GetDatumDraughtingLocalNext (
	System::Int64 dat_id,
	System::Int64 index
	);

The GetCalloutDraughtingCount() and GetCalloutDraughtingNext() functions return a list of the draughting items connected to a datum.

The GetCalloutDraughtingLocalCount/Next() return a list of the draughting items directly connected to the datum. The non local versions return a list of the faces directly and indirectly connected.

Arguments

dat_id
The identity of the datum.
index
The position of the next draughting item.

Related Functions

GetDatumFaceCount/Next()

System::Int64 GetDatumFaceCount(		
	System::Int64 dat_id
	);
System::Int64 GetDatumFaceLocalCount(
	System::Int64 dat_id
	);
System::Int64 GetDatumFaceNext(
	System::Int64 dat_id,
	System::Int64 index
	);
System::Int64 GetDatumFaceLocalNext(
	System::Int64 dat_id,
	System::Int64 index
	);


int [] GetDatumFaceAll(			
	int dat_id
	);

The GetDatumFaceCount() function returns a count of the number of faces defined in a datum and GetDatumFaceNext() iterates over the faces in that datum.

The GetDatumFaceLocalCount/Next() functions returns the faces directly connected to the datum. The non local versions returns the directly and indirectly connected faces. In most applications the non local versions are more useful.

The functions normally return the identity of a face but any kind of geometric representation item may be returned.

Arguments

dat_id
The identity of the datum.
index
The position of the next datum face.

Related Functions

GetDatumLabel()

System::String^ GetDatumLabel(		
	System::Int64 dat_id
	);

string GetDatumLabel(			
	int dat_id
	);

The GetDatumLabel() function returns the label on a datum (e.g. “A”).

Arguments

dat_id
The identity of the datum.

Related Functions

GetDatumSurface()

System::Int64 GetDatumSurface(
	System::Int64 datum_id
	);

The GetDatumSurface() function

GetDatumTargetCircle()

System::Int64 GetDatumTargetCircle(
	System::Int64 target_id,
	[System::Runtime::InteropServices::Out] double %diameter,
	[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 GetDatumTargetCircle() function returns nonzero if the target is a circle and passes back the parameters of the target.

Arguments

target_id
The identity of the target.
diameter
[out] The diameter of the circle
x, y, z
[out] The coordinates of the center
i, j, k
[out] The axis of the center

Related Functions

GetDatumTargetCount/Next()

System::Int64 GetDatumTargetCount(
	System::Int64 dat_id
	);

System::Int64 GetDatumTargetNext(
	System::Int64 dat_id,
	System::Int64 index
	);

The GetDatumTargetCount() function returns the number of targets in a target.

The GetDatumTargetNext() function Returns the next target in a datum.

Arguments

dat_id
The identity of the datum.
index
The position of the next target.

Related Functions

GetDatumTargetPoint()

System::Int64 GetDatumTargetPoint(
	System::Int64 target_id,
	[System::Runtime::InteropServices::Out] double %x,
	[System::Runtime::InteropServices::Out] double %y,
	[System::Runtime::InteropServices::Out] double %z
	);

The GetDatumTargetPoint() function returns nonzero if the target is a point and passes back the coordinates of a target point.

Arguments

target_id
The identity of the target.
x, y, z
[out] The coordinates of the point

Related Functions

GetDatumTargetRectangle()

System::Int64 GetDatumTargetRectangle(
	System::Int64 target_id,
	[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,
	[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 GetDatumTargetRectangle() function returns nonzero if the target is a rectangle and passes back the parameters of the target.

Arguments

target_id
The identity of the target.
length
[out] The length of the rectangle
width
[out] The width of the rectangle
x, y, z
[out] The coordinates of the center
i, j, k
[out] The axis of the center
a, b, c
[out] The rotation around the center

Related Functions

GetDatumTargetStraightLine()

System::Int64 GetDatumTargetStraightLine(
	System::Int64 target_id,
	[System::Runtime::InteropServices::Out] double %length,
	[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 GetDatumTargetStraightLine() function returns nonzero if the target is a straight line and passes back the parameters of the target.

Arguments

target_id
The identity of the target.
length
[out] The length of the line
x, y, z
[out] The coordinates of the line
i, j, k
[out] Direction of the line

Related Functions

GetDatumTargetType()

System::String^ GetDatumTargetType(
	System::Int64 target_id
	);

The GetDatumTargetType() function returns the type of a datum target (point, line, circle or rectangle).

Arguments

target_id
The identity of the target.

Related Functions

GetDatumType()

System::String^ GetDatumType(
	System::Int64 dat_id
	);

The GetDatumType() function returns the type of the datum as a string.

Arguments

datum_id
The identity of the datum.

Related Functions

GetDatumUsingLabel()

System::Int64 GetDatumUsingLabel(
	System::String^ label,
	[System::Runtime::InteropServices::Out] System::String^ %modifier
	);

The GetDatumUsingLabel() function returns the datum with the defined label.

Arguments

label
The label of the required datum.
modifier
[out] The string “Maximum material condition”, “Least material condition”, “Regardless of feature size” or “none”.

Related Functions

GetEdgeBack()

System::Int64 GetEdgeBack(
	System::Int64 face_id
	);

The GetEdgeBack() function returns the identity of the rearmost edge on a face. The edge chosen is the one with the largest sum for its Y coordinates

Arguments

face_id
The identity of a face.

GetEdgeBottom()

System::Int64 GetEdgeBottom(
	System::Int64 face_id
	);

The GetEdgeBottom() function returns the identity of the right edge on a face. The edge chosen is the one with the smallest sum for its Z coordinates. See GetEdgeBack for other details.

GetEdgeFront()

System::Int64 GetEdgeFront(
	System::Int64 face_id
	);

The GetEdgeFront() function returns the identity of the left edge on a face. The edge chosen is the one with the smallest sum for its Y coordinates. See GetEdgeBack for other details.

GetEdgeLeft()

System::Int64 GetEdgeLeft(
	System::Int64 face_id
	);

The GetEdgeLeft() function returns the identity of the left edge on a face. The edge chosen is the one with the smallest sum for its X coordinates. See GetEdgeBack for other details.

GetEdgeRight()

System::Int64 GetEdgeRight(
	System::Int64 face_id
	);

The GetEdgeRight() function returns the identity of the right edge on a face. The edge chosen is the one with the largest sum for its X coordinates. See GetEdgeBack for other details.

GetEdgeTop()

System::Int64 GetEdgeTop(
	System::Int64 face_id
	);

The GetEdgeTop() function returns the identity of the right edge on a face. The edge chosen is the one with the largest sum for its Z coordinates. See GetEdgeBack for other details.

GetFaceAllCount/Next()

System::Int64 GetFaceAllCount();

System::Int64 GetFaceAllNext(
	System::Int64 index
	);

The GetFaceAllCount() function returns a count of the total number of faces in the model. The faces can belong to any of the parts in the model including the workpieces, the rawpieces, the fixtures and the cutting tools.

The GetFaceAllNext() function returns the next face in the STEP-NC model.

Arguments

index
The position of the next face.

Related Functions

GetFaceBack()

System::Int64 GetFaceBack();

The GetFaceBack() function returns the identity of the back face. All the y coordinates on the chosen face must have the same value. If two or more faces meet this criteria then the face chosen will be the one with the largest y value.

GetFaceBottom()

System::Int64 GetFaceBottom();

The GetFaceBottom() function returns the identity of the bottom face. All the z coordinates on the chosen face must have the same value. If two or more faces meet this criteria then the face chosen will be the one with the smallest z value. . See GetFaceBack for more details.

GetFaceFront()

System::Int64 GetFaceFront();

The GetFaceFront() function returns the identity of the front face. All the y coordinates on the chosen face must have the same value. If two or more faces meet this criteria then the face chosen will be the one with the smallest y value. See GetFaceBack for more details.

GetFaceLeft()

System::Int64 GetFaceLeft();

The GetFaceLeft() function returns the identity of the left face. All the x coordinates on the chosen face must have the same value. If two or more faces meet this criteria then the face chosen will be the one with the smallest x value. . See GetFaceBack for more details.

GetFaceDefinitionCylinder/Plane()

System::Int64 GetFaceDefinitionCylinder (
	System::Int64 face_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 %radius
	);

System::Int64 GetFaceDefinitionPlane (
	System::Int64 face_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 %radius
	);

The GetFaceDefinition() functions return the definition of a plane or cylindrical surface. The parameters are as defined by Part 42 of the STEP standard. The coordinates are in part space which means they are in the space defined by the CAD model.

Arguments

face_id
The identify of the face.

Related Functions

GetFaceGeometryType()

System::String^ GetFaceGeometryType(
	System::Int64 face_id
	);

The GetFaceGeometryType() function returns a string describing the type of the surface used to define a face. The range of surface types is given by the EXPRESS surface definition. The type name will be in lower case letters.

Arguments

face_id
The identify of the face.

Related Functions

Common Errors

GetFaceMeasuredCount/Next/All()

System::Int64 GetFaceMeasuredCount (
	);

System::Int64 GetFaceMeasuredNext (
	System::Int64 index
	);

System::Collections::Generic::List^ GetFaceMeasuredAll (
	);

The GetFaceMeasured() functions return a list of all the measured faces in a project. A measured faces is one that has touch probe points defined.

Arguments

index
For iterating thru the identity of the faces.

Related Functions

GetFaceMeasuredPointCount/Next/All()

System::Int64 GetFaceMeasuredPointCount (
	System::Int64 face_id
	);

System::Int64 GetFaceMeasuredPointNext (
	System::Int64 face_id
	System::Int64 index
	[System::Runtime::InteropServices::Out] double %measured_x,
	[System::Runtime::InteropServices::Out] double %measured_y,
	[System::Runtime::InteropServices::Out] double %rmeasured_z,
	[System::Runtime::InteropServices::Out] double %expected_x,
	[System::Runtime::InteropServices::Out] double %rexpected_y,
	[System::Runtime::InteropServices::Out] double %expected_z,
	[System::Runtime::InteropServices::Out] double %touch_i,
	[System::Runtime::InteropServices::Out] double %touch_j,
	[System::Runtime::InteropServices::Out] double %rtouch_k
	);

The GetFaceMeasuredPoint() functions return information about the measured points on a given face. The returned information may change each time the point is touched. The function will return false if the point has not yet been touched.

The coordinates are in the space defined for the part in the CAD model. The expected and normal values are computed from the planning data. The measured values are the ones reported by the tocuh probe.

All values are for the coordinates of the touch point, not the center of the ball.

Arguments

face_id
The identity of the face.
index
next face.
measured_x/y/z
The measured value
expected_x/y/z
The expected value
normal_i/j/k
The normal of the touched value

Related Functions

GetFaceMeasureGeometry()

System::Int64 GetFaceMeasureGeometry(
	System::Int64 face_id
	);

The GetFaceMeasureGeometry() function returns the identity of the surface used to define a face. In STEP a face is defined as a bounded loop on a surface. The surfaces can be planes, cylinders, torii, bspline’s and other types.

Arguments

face_id
The identify of the face.

Related Functions

GetFacePlacement()

System::Int64 GetFacePlacement(
	System::Int64 face_id,
	[System::Runtime::InteropServices::Out] double %x,
	[System::Runtime::InteropServices::Out] double %y,
	[System::Runtime::InteropServices::Out] double %z
	);

The GetFacePlacement() function returns the model coordinates of the axis that defines a face. The function returns nonzero if the face is defined by an elementary surface. If zero then the face is not defined by a surface with an axis so the origin coordinate data will be unset/invalid.

Arguments

face_id
The identity of the face.
x, y, z
[out] Coordinates of the origin of the axis.

Related Functions

Common Errors

GetFacePlacementInSetup()

System::Int64 GetFacePlacementInSetup(
	System::Int64 ex_id,
	System::Int64 face_id,
	[System::Runtime::InteropServices::Out] double %x,
	[System::Runtime::InteropServices::Out] double %y,
	[System::Runtime::InteropServices::Out] double %z
	);

The GetFacePlacementInSetup() function

GetFaceRight()

System::Int64 GetFaceRight();

The GetFaceRight() function returns the identity of the left face. All the x coordinates on the chosen face must have the same value. If two or more faces meet this criteria then the face chosen will be the one with the largest x value. . See GetFaceBack for more details.

GetFaceStatus()

System::String^ GetFaceStatus(
	System::Int64 face_id
	);

The GetFaceStatus() function determines the status of a face with respect to the tolerances defined on that face and returns one of the following strings describing the status.

Arguments

face_id
The identity of the face.

Related Functions

Common Errors

GetFaceStatusCount/Next()

System::Int64 GetFaceStatusCount();

System::String^ GetFaceStatusNext(
	System::Int64 index,
	[System::Runtime::InteropServices::Out] System::Int64 %face_id
	);

The GetFaceStatusCount() function returns the number of faces in the project with a status other than “none”.

The GetFaceStatusNext() function returns the next face with a status.

Arguments

index
Index for the selected face

Related Functions

GetFaceStatusTolerance()

System::String^ GetFaceStatusTolerance(
	System::Int64 face_id,
	System::Int64 tol_id
	);

The GetFaceStatusTolerance() function determines the status of a face with respect to a specific tolerance.

Arguments

face_id
The identity of the face.
tol_id
The identity of the tolerance.

Related Functions

Common Errors

GetFaceStatusTool()

System::String^ GetFaceStatusTool(
	System::Int64 face_id,
	System::Int64 tool_id
	);

The GetFaceStatusTool() function determines the status of a face with respect to the tolerances associated with a tool.

Arguments

face_id
The identity of the face.
tool_id
The identity of the tool

Related Functions

Common Errors

GetFaceTop()

System::Int64 GetFaceTop();

The GetFaceTop() function returns the identity of the top face. All the z coordinates on the chosen face must have the same value. If two or more faces meet this criteria then the face chosen will be the one with the largest z value. . See GetFaceBack for more details.

GetFeatureAllCount/Next()

System::Int64 GetFeatureAllCount();

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

The GetFeatureAllCount() function returns a count of the total number of features in the model. The featuress can belong to any of the workpieces.

The GetFeatureAllNext() function returns the next feature in the STEP-NC model.

Arguments

index
The position of the next feature.

Related Functions

GetFeatureFaceCount/Next()

System::Int64 GetFeatureFaceCount(
	System::Int64 fea_id
	);

System::Int64 GetFeatureFaceNext(
	System::Int64 fea_id,
	System::Int64 index
	);

The GetFeatureFaceCount() function returns a count of the faces on a feature and GetFeatureFaceNext() iterates over the faces and returns the one for a given index.

Arguments

fea_id
The identity of the feature.
index
The position of the next face.

Arguments

fea_id
The identity of the feature.

Related Functions

GetMeasureGeometryCount/Next()

System::Int64 GetMeasureGeometryCount();

System::Int64 GetMeasureGeometryNext(
	System::Int64 index
	);

The GetMeasureGeometryCount() function returns a count of the number of surfaces in a STEP-NC project. The surfaces can belong to the workpiece, rawpiece, fixture or cutting tools. The GetMeasureGeometryNext() function iterates over the surfaces and returns one for a specific index.

Arguments

index
The position of the next surface.

Related Functions

GetMeasureGeometryFaceCount/Next()

System::Int64 GetMeasureGeometryFaceCount(
	System::Int64 geometry_id
	);

System::Int64 GetMeasureGeometryFaceNext(
	System::Int64 geometry_id,
	System::Int64 index
	);

The GetMeasureGeometryFaceCount() function returns a count of the faces that use a surface. In STEP a solid model is defined as a set of faces whuch define bounded loops on surfaces. The surfaces can be planes, cylinders, touruses, bspline’s and other types. In some situations several faces are defined on the same surface. For example, a cylinder may be defined as two faces on a cylindrical surface.

The GetMeasureGeometryFaceNext() function returns the next face that uses a surface

Arguments

geometry_id
The identity of the geometry.
index
The position of the face.

Related Functions

GetMeasureGeometryPlacement()

System::Int64 GetMeasureGeometryPlacement(
	System::Int64 geo_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 GetMeasureGeometryPlacement() function returns the origin, z direction and x direction that define the location and orientation of STEP elementary surfaces The values returned are the “raw” values stored in the data. No transformations are applied. For a plane this is all the data defined for the surface. For a cylinder this data plus the radius returned by GetMeasureGeometryRadius function defines the surface. Planes and cylinders are the most important types of surfaces for measurement applications. The function returns the identity of the axis or 0 if this is not an elementary surface.

Arguments

geometry_id
The identity of the geometry.
x, y, z
[out] Origin of the axis.
i, j, k
[out] Components of the Z direction.
a, b, c
[out] Components of the X direction.

Related Functions

GetMeasureGeometryRadius()

double GetMeasureGeometryRadius(
	System::Int64 geo_id
	);

The GetMeasureGeometryRadius() function returns the radius of that cylinder if the surface is defined by a cylinder. In STEP geometry surfaces can be planes, cylinders, touruses, bspline’s and other types as defined by the surface entity in STEP Part 42. For a cylinder this data plus the data returned by GetMeasureGeometryPlacement completely define the surface.

Arguments

geometry_id
The identity of the geometry.

Related Functions

Common Errors

GetMeasureGeometryType()

System::String^ GetMeasureGeometryType(
	System::Int64 geo_id
	);

The GetMeasureGeometryType() function returns a string describing the type of the surface used to define a face. The range of surface types is given by the EXPRESS surface definition. The type name will be in lower case letters.

Arguments

geometry_id
The identity of the geometry.

Related Functions

GetProbeAllCount/Next()

System::Int64 GetProbeAllCount();

System::Int64 GetProbeAllNext(
	System::Int64 index
	);

The GetProbeAllCount() function returns a count of all of the probing operations in the STEP-NC program so that other functions can put and set the values of these operations

The GetProbeAllNext() function returns the identity of the next probing operation.

Arguments

index
The position of the probing operation.

Related Functions

  • GetProbeFace Get the face being probed.
  • GetProbeGrade Is the probe in or out of tolerance?
  • GetProbeInitialData Start point of the probing operation.
  • GetProbeResultData Result data of the probing operation.
  • GetProbeSurfacePosition The point “touched” on the surface.

    GetProbeFace()

    System::Int64 GetProbeFace(
    	System::Int64 ws_id
    	);
    

    The GetProbeFace() function returns the identity of the face “touched” by a probing operation.

    Arguments

    probe_or_ws_id
    The identity of the workingstep or probing operation.

    Related Functions

    Common Errors

    GetProbeGrade()

    System::String^ GetProbeGrade(
    	System::Int64 probe_or_ws_id
    	);
    

    The GetProbeGrade() function compares the measured value of a probing operation against the tolerances defined for the face “touched” by that probing operation.

    Arguments

    probe_or_ws_id
    The identity of the workingstep or probing operation.

    Related Functions

    Common Errors

    GetProbeInitialData()

    System::String^ GetProbeInitialData(
    	System::Int64 probe_or_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
    	);
    

    The GetProbeInitialData() function returns label of the workingstep or probing operation and the start point and direction. A probe is programmed to start at an initial point and move in a given direction until it “touches” the part. The expected and actual distance of the move can be found the GetProbeResultData function.

    Arguments

    probe_or_ws_id
    The identity of the workingstep or probing operation.
    x, y, z
    [out] The initial position of the probing operation.
    i, j, k
    [out] The initial direction of the probing operation.

    Related Functions

    Common Errors

    GetProbeResultData()

    double GetProbeResultData(
    	System::Int64 probe_or_ws_id,
    	[System::Runtime::InteropServices::Out] double %expected_value
    	);
    

    The GetProbeResultData() function returns the actual distance moved by the probe before it “touched” a surface, and passes back the expected value in an out parameter.

    Arguments

    probe_or_ws_id
    The identity of the workingstep or probing operation.
    expected_value
    [out] The expected value of the probe distance.

    Related Functions

    Common Errors

    GetProbeSurfacePosition()

    System::String^ GetProbeSurfacePosition(
    	System::Int64 probe_or_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
    	);
    

    The GetProbeSurfacePosition() function uses the expected and actual distance of the moved by the probe and the initial position and direction to compute the location where the probe touched the surface

    Arguments

    probe_or_ws_id
    The identity of the workingstep or probing operation.
    x, y, z
    [out] The position where the probe touched the surface.
    i, j, k
    [out] The direction where the probe touched the surface.

    Related Functions

    Common Errors

    GetSurfaceTextureParameterMeasuringMethod()

    System::String^ GetSurfaceTextureParameterMeasuringMethod(
    	System::Int64 face_id
    	);
    

    The GetSurfaceTextureParameterMeasuringMethod() function returns the measuring method, which defines the ISO standard used to measure the surface texture. The methods are “ISO 4287”, “ISO 12085” and “ISO 13565”. Each standard describes a set of parameters that can be measured. The GetSurfaceTextureParameterName function returns this parameter.

    Arguments

    tol_id
    The identity of the surface texture parameter.

    Related Functions

    Common Errors

    GetSurfaceTextureParameterName()

    System::String^ GetSurfaceTextureParameterName(
    	System::Int64 face_id
    	);
    

    The GetSurfaceTextureParameterName() function returns the parameter name, which defines how to use the ISO standard described by the measuring method to measure the surface texture. The methods are “ISO 4287”, “ISO 12085” and “ISO 13565”. Each standard describes a set of similar parameters that can be measured.

    Arguments

    tol_id
    The identity of the surface texture parameter.

    Related Functions

    Common Errors

    GetSurfaceTextureParameterValue()

    double GetSurfaceTextureParameterValue(
    	System::Int64 face_id
    	);
    

    The GetSurfaceTextureParameterValue() function returns the value of the surface texture parameter. See GetSurfaceTextureParameterName for a description of the allowed parameters. This value is also returned by the GetToleranceValue function. See GetSurfaceTextureParameterUnit for a description of the units used for the value.

    Arguments

    tol_id
    The identity of the surface texture parameter.

    Related Functions

    Common Errors

    GetSurfaceTextureParameterValueUnit()

    System::String^ GetSurfaceTextureParameterValueUnit(
    	System::Int64 face_id
    	);
    

    The GetSurfaceTextureParameterValueUnit() function returns the unit of the value of the surface texture parameter. See GetSurfaceTextureParameterName for a description of the allowed parameters. The most common units are “micrometer” and “microinch”

    Arguments

    tol_id
    The identity of the surface texture parameter.

    Related Functions

    Common Errors

    GetToleranceAllCount/Next()

    System::Int64 GetToleranceAllCount();
    
    System::Int64 GetToleranceAllNext(
    	System::Int64 index
    	);
    

    The GetToleranceAllCount() function returns a count of the number of tolerances defined in a STEP-NC model. The count includes the surface texture parameters, size dimensions and location dimensions as well as the geometry tolerances. The same broad definition for a tolerance is used for every function that applies to any type of tolerance. The IsGeometryTolerance, IsSizeDimension, IsLocationDimension and IsSurfaceTextureParameter functions can be used to select between the different types of tolerances.

    The GetToleranceAllNext() function returns the next tolerance in the STEP-NC model, which may be a surface texture parameter, size dimension, location dimension or geometric tolerance.

    Arguments

    index
    The position of the tolerance in the list.

    Related Functions

    Common Errors

    GetToleranceAndToolFaceCount/Next()

    System::Int64 GetToleranceAndToolFaceCount(
    	System::Int64 tol_id,
    	System::Int64 tool_id
    	);
    
    System::Int64 GetToleranceAndToolFaceNext(
    	System::Int64 tol_id,
    	System::Int64 tool_id,
    	System::Int64 index
    	);
    

    The GetToleranceAndToolFaceCount() function returns a count of the number of faces that are machined by a tool and constrained by a tolerance.

    The GetToleranceAndToolFaceNext() function returns the next face that is shared by a tolerance and tool. A face is shared if it is machined by a tool and constrained by the tolerance.

    Arguments

    tol_id
    Identity of the tolerance
    tool_id
    Identity of the cutting tool
    index
    Position of the required face

    Related Functions

    Common Errors

    GetToleranceAppliedTo()

    System::Int64 GetToleranceAppliedTo(
    	System::Int64 tol_id
    	);
    

    The GetToleranceAppliedTo() function returns the identity of the callout containing the faces that are constrained by the tolerance. If the tolerance is a location dimension then the id of the target callout is returned.

    Arguments

    tol_id
    Identity of the tolerance

    Related Functions

    Common Errors

    GetToleranceAppliedToOrigin()

    System::Int64 GetToleranceAppliedToOrigin(
    	System::Int64 tol_id
    	);
    

    The GetToleranceAppliedToOrigin() function returns the identity of the callout containing the faces that are constrained by the origin of a location tolerance.

    Arguments

    tol_id
    Identity of the tolerance

    Related Functions

    Common Errors

    GetToleranceAppliedToTarget()

    System::Int64 GetToleranceAppliedToTarget(
    	System::Int64 tol_id
    	);
    

    The GetToleranceAppliedToTarget() function returns the identity of the callout containing the faces that are constrained by the target of a location tolerance.

    Arguments

    tol_id
    Identity of the tolerance

    Related Functions

    Common Errors

    GetToleranceDatumCount/Next()

    System::Int64 GetToleranceDatumCount(	
    	System::Int64 tol_id
    	);
    System::Int64 GetToleranceDatumNext(
    	System::Int64 tol_id,
    	System::Int64 index
    	);
    
    
    string[] GetToleranceDatumAll(		
    	int tol_id
    	);
    

    The GetToleranceDatumCount() function returns the number of datums defined for a tolerance.

    The GetToleranceDatumNext() function returns the identity and of the next datum.

    Arguments

    tol_id
    Identity of the tolerance,
    index
    Position of the required datum

    Related Functions

    Common Errors

    GetToleranceDatumModifierCount/Next()

    System::Int64 GetToleranceDatumModifierCount(
    	System::Int64 tol_id,
    	System::Int64 dat_id
    	);
    
    System::Int64 GetToleranceDatumModifierNext(
    	System::Int64 tol_id,
    	System::Int64 dat_id,
    	System::Int64 index
    	);
    

    The GetToleranceDatumModifierCount() function returns the number of modifiers defined for a datum in a tolerance.

    The GetToleranceDatumModifierNext() function returns the type of the next modifier on a datum as a string. The string will be one of the following values

    Arguments

    tol_id
    Identity of the tolerance,
    dat_id
    Identity of the datum,
    index
    Position of the required datum

    Related Functions

    Common Errors

    GetToleranceDatumNextLabel()

    System::String^ GetToleranceDatumNextLabel(
    	System::Int64 tol_id,
    	System::Int64 index
    	);
    

    The GetToleranceDatumNextLabel() function returns the label of the next datum. Because of the way the AddTolerance functions operate it is best if the label is a single character.

    Arguments

    Tol_id
    Identity of the tolerance,
    index
    Position of the required datum

    Related Functions

    Common Errors

    GetToleranceDefinedAreaUnit()

    System::Boolean GetToleranceDefinedAreaUnit(
    	System::Int64 tol_id,
    	[System::Runtime::InteropServices::Out] double %value1,
    	[System::Runtime::InteropServices::Out] double %value2,
    	[System::Runtime::InteropServices::Out] System::String^ %area_type
    	);
    

    The GetToleranceDefinedAreaUnit() function returns true for tolerances with a defined area unit and fills parameters with both dimensions of the area as well as the area type.

    The area type will be an empty string or one of the following strings: "square", "circular", or "rectangular".

    GetToleranceDefinedUnit()

    System::Boolean GetToleranceDefinedUnit(
    	System::Int64 tol_id,
    	[System::Runtime::InteropServices::Out] double %value
    	);
    

    The GetToleranceDefinedUnit() function returns true for tolerances with a defined unit and fills a parameter with the linear dimension defined unit. This function will also work on a tolerance that has a defined area unit, but it will only return the first of the two dimensions. Use GetToleranceDefinedAreaUnit() first to check if a tolerance has an area unit.

    GetToleranceDraughtingCount/Next()

    System::Int64 GetToleranceDraughtingCount (
    	System::Int64 tol_id
    	);
    
    System::Int64 GetToleranceDraughtingNext (
    	System::Int64 tol_id,
    	System::Int64 index
    	);
    

    The GetToleranceDraughtingCount() and GetToleranceDraughtingNext() functions return the ids of any presentation tolerances (polyline callouts) that are associated with a semantic tolerance.

    GetToleranceFace[Local]Count/Next()

    System::Int64 GetToleranceFaceCount(	
    	System::Int64 tol_id
    	);
    System::Int64 GetToleranceFaceNext(
    	System::Int64 tol_id,
    	System::Int64 index
    	);
    System::Int64 GetToleranceFaceLocalCount(
    	System::Int64 tol_id
    	);
    System::Int64 GetToleranceFaceLocalNext(
    	System::Int64 tol_id,
    	System::Int64 index
    	);
    
    
    int[] GetToleranceFaceAll(		
    	int tol_id
    	);
    

    The GetToleranceFaceCount() function returns the number of faces constrained by a tolerance. For a location tolerance these will be faces in both the origin and target of the tolerance.

    The Local versions get only the faces directly connected to the tolerance. The other versions get the faces directly and indirectly connected. In practice, the other versions are more useful.

    The functions return any type of geometric representation item connected to the tolerance not just faces.

    The GetToleranceFaceNext() function returns the next face constrained by a tolerance.

    Arguments

    tol_id
    Identity of the tolerance
    index
    The position of the required face

    Related Functions

    Common Errors

    GetToleranceGeometryCount/Next()

    System::Int64 GetToleranceGeometryCount(
    	System::Int64 tol_id
    	);
    
    System::Int64 GetToleranceGeometryNext(
    	System::Int64 tol_id,
    	System::Int64 index
    	);
    

    The GetToleranceGeometryCount() function returns the number of surfaces in the faces constrained by a tolerance. For a location tolerance these will be surfaces in both the origin and target of the tolerance. This function is a shortcut that goes directly to the surfaces without requiring the application to first get the identity of the faces.

    The GetToleranceGeometryNext() function returns the next surface face constrained by a tolerance.

    Arguments

    tol_id
    Identity of the tolerance
    index
    The position of the required surface

    Related Functions

    Common Errors

    GetToleranceMax()

    System::Boolean GetToleranceMax(
    	System::Int64 tol_id,
    	[System::Runtime::InteropServices::Out] double %value
    	);
    

    The GetToleranceMax() function returns true for tolerances with a maximum tolerance value and fills a parameter with the value. Tolerances with this value should also have either a maximum material condition or least material condition modifier.

    GetToleranceMeasuredAll()

    System::Collections::Generic::List^ GetToleranceMeasuredAll(
    	);
    
    

    The GetToleranceMeasuredAll() function returns a list of the tolerances that have been measured.

    Related Functions

    Common Errors

    GetToleranceMeasuredChangedAll()

    System::Collections::Generic::List^ GetToleranceMeasuredChangedAll(
    	);
    
    

    The GetToleranceChangedAll() function returns a list of the tolerances that have changed since the function was last called. The assumption is that the since the last call tolerances have been changed because of additional measurements that have been made.

    Related Functions

    Common Errors

    GetToleranceMeasuredColor()

    System::String^ GetToleranceMeasuredColor(
    	System::Int64 tol_id
    	);
    

    The GetToleranceMeasuredColor() function returns one of the following values.

    Arguments

    tol_id
    Identity of the tolerance

    Related Functions

    Common Errors

    GetToleranceMeasuredFaceColor()

    System::Int64 GetToleranceMeasuredFaceColor(
    	System::Int64 tol_id
    	System::Int64 face_id
    	);
    
    System::Int64 GetToleranceMeasuredFaceAll(
    	);
    
    System::Int64 GetToleranceMeasuredFaceAllColor(
    	);
    

    The GetToleranceMeasuredFace functions returns a color for a face in a tolerance. If the face is not in any measured tolerances then the value returned is zero (0) for unknown. If the face is only in tolerances that are meeting their requirements then the value returned is one (1) for green. If the face is in tolerances that are both meeting and failing their requirements then the value returned is two (2) for yellow. If the face is only in tolerances that are failing their requirements then the value returned is three (3) for red.

    The GetToleranceMeasuredFaceColor function returns the color of a face with respect to a single tolerance so the value returned can never be yellow (2).

    The GetToleranceMeasuredFaceAll function returns a list of the faces that have a measured color. Only the colored faces are returned so the function is very efficient for applications that want to color a model.

    The GetToleranceMeasuredFaceAllColor function returns a list of the colors for the faces that have a measured color.

    Arguments

    tol_id
    Identity of the tolerance
    face_id
    Identity of the face

    Related Functions

    Common Errors

    GetToleranceMeasuredValue()/LowerUpper()

    System::Boolean GetToleranceMeasuredValue(
    	System::Int64 tol_id,
    	[System::Runtime::InteropServices::Out] double %measured_value
    	);
    
    System::Boolean GetToleranceMeasuredValueLowerUpper(
    	System::Int64 tol_id,
    	[System::Runtime::InteropServices::Out] double %lower_value
    	);
    	[System::Runtime::InteropServices::Out] double %upper_value
    	);
    

    The GetToleranceMeasuredValue()/LoweUpper() functions returns the estimated value of a tolerance. The value is estimated from a series of touch points measured on the surface(s) of the tolerance.

    The GetToleranceMeasuredValue() function returns the estimated value of a geometric tolerance. For example, if the tolerance is a surface profile then this value is the maximum deviation from the required profile.

    The GetToleranceMeasuredValueLowerUpper() function returns the lower and upper estimated values of a size dimension or location dimension. For example, if the tolerance is a diameter size then the lower value is the smallest measured estimate and the upper value is the largest estimate.

    The functions return true if enough points have been measured to enable an estimate of the tolerance and false otherwise.

    Arguments

    tol_id
    Identity of the dimension or tolerance
    measured_value
    [out] The as-measured value of a geometric tolerance.
    lower_value
    [out] The as-measured lower value for a dimension (size or location).
    upper_value
    [out] The as-measured upper value for a dimension (size or location).

    Related Functions

    Common Errors

    GetToleranceMeasuredProbeAllSets/Colors()

    System::Collections::Generic::List^ GetToleranceMeasuredProbeAllSets(
    	System::Int64 tol_id
    	);
    
    System::Collections::Generic::List^ GetToleranceMeasuredProbeAllColors(
    	System::Int64 tol_id
    	);
    
    

    The GetToleranceMeasuredProbe() functions returns color codings for the probe points that have been used to measure a tolerance. The points are graded as good ("green"), too deep ("red") or too shallow ("blue"). If they are "red" then too much material has been removed. If they are "blue" then too little material has been removed.

    The GetToleranceMeasuredProbe() functions return detail to help the user understand why a tolerance is meeting or not meeting its defined constraints.

    The GetToleranceMeasuredProbeAllSets() returns the identity of zero, one or more geometric sets. Each set will contain a list of probe points that have been assigned the same color.

    The GetToleranceMeasuredProbeAllColorss() returns the corresponding color for each set encoded as 1=green, 2=yellow (not used), 3=red and 4=blue.

    Arguments

    tol_id
    Identity of the dimension or tolerance

    Related Functions

    Common Errors

    GetToleranceModifierCount/Next()

    System::Int64 GetToleranceModifierCount(	
    	System::Int64 tol_id,
    	);
    System::String^ GetToleranceModifierNext(
    	System::Int64 tol_id,
    	System::Int64 index
    	);
    
    
    string[] GetToleranceModifierAll(		
    	int tol_id
    	);
    

    The GetToleranceDatumModifierCount() function returns the number of modifiers defined for a tolerance.

    The GetToleranceModifierNext() function returns the type of the next modifier on a tolerance as a string. The modifiers will be one of the following strings:

    Arguments

    tol_id
    Identity of the tolerance,
    index
    Position of the required modifier

    Related Functions

    Common Errors

    GetToleranceOriginFace[Local]Count/Next()

    System::Int64 GetToleranceOriginFaceCount(
    	System::Int64 tol_id
    	);
    
    System::Int64 GetToleranceOriginFaceNext(
    	System::Int64 tol_id,
    	System::Int64 index
    	);
    
    System::Int64 GetToleranceOriginFaceLocalCount(
    	System::Int64 tol_id
    	);
    
    System::Int64 GetToleranceOriginFaceLocalNext(
    	System::Int64 tol_id,
    	System::Int64 index
    	);
    

    The GetToleranceOriginFaceCount() function returns the number of faces in the origin. Location dimensions describe a distance between an origin and target.

    The local versions get the faces directly connected to the dimension. In practice the other versions are more useful.

    The functions return any type of geometric representation item connected to the dimension not just faces.

    The GetToleranceOriginFaceNext() function returns the next face in the origin of a location dimension.

    Arguments

    Tol_id
    Identity of the dimension
    index
    The position of the required face

    Common Errors

    GetTolerancePlusMinus()

    System::Int64 GetTolerancePlusMinus(	
    	System::Int64 tol_id,
    	[System::Runtime::InteropServices::Out] double %lower,
    	[System::Runtime::InteropServices::Out] double %upper
    	);
    
    
    object GetTolerancePlusMinus(		
    	int tol_id
    	);
    Returns:
    {
    	flag: boolean,
    	lower: double,
    	upper: double
    }
    

    The GetTolerancePlusMinus() function returns the upper and lower delta’s for a location or dimension tolerance. The function returns true if the tolerance has lower or upper values.

    Arguments

    tol_id
    Identity of the tolerance
    lower
    [out] The lower delta e.g “-0.01”
    upper
    [out] The upper delta e.g “0.005”

    Related Functions

    Common Errors

    GetTolerancePrecision()

    int GetTolerancePrecision(
    	System::Int64 tol_id
    	);
    

    The GetTolerancePrecision() function returns the number of digits allowed after the decimal point. The value may be represented as a precision quaifier (legacy) or as a value format type (prefered). In the latter case the value is decoded if the format is specified as described in Part 45 clause 6.4.14 for NR2 and NR5 control strings.

    Arguments

    tol_id
    Identity of the tolerance or dimension

    Related Functions

    Common Errors

    GetToleranceProbeCount/Next()

    System::Int64 GetToleranceProbeCount(
    	System::Int64 tol_id
    	);
    
    System::Int64 GetToleranceProbeNext(
    	System::Int64 tol_id,
    	System::Int64 index
    	);
    

    The GetToleranceProbeCount() function returns the number of probing workingsteps that “touch” the face(s) in a tolerance.

    The GetToleranceProbeNext() function returns the next probing workingstep that “touches” a tolerance.

    Arguments

    tol_id
    Identity of the tolerance
    index
    The position of the workingstep

    Common Errors

    GetToleranceRelatedToleranceCount/Next()

    System::Int64 GetToleranceRelatedToleranceCount (
    	System::Int64 tol_id
    	);
    
    System::Int64 GetToleranceRelatedToleranceNext (
    	System::Int64 tol_id,
    	System::Int64 index
    	);
    

    The GetToleranceRelatedToleranceCount() function

    The GetToleranceRelatedToleranceNext() function

    GetToleranceTargetFace[Local]Count/Next()

    System::Int64 GetToleranceTargetFaceCount(
    	System::Int64 tol_id
    	);
    
    System::Int64 GetToleranceTargetFaceNext(
    	System::Int64 tol_id,
    	System::Int64 index
    	);
    
    System::Int64 GetToleranceTargetFaceLocalCount(
    	System::Int64 tol_id
    	);
    
    System::Int64 GetToleranceTargetFaceLocalNext(
    	System::Int64 tol_id,
    	System::Int64 index
    	);
    
    

    The GetToleranceTargetFaceCount() function returns the number of faces in the target. Location dimensions describe a distance between an origin and target.

    The local versions return only the faces directly connected to the tolerance. In practice the other versions are more useful.

    The functions return any type of geometric representation item not just faces.

    The GetToleranceFaceTargetNext() function returns the next face in the target of a location dimension.

    Arguments

    Tol_id
    Identity of the tolerance
    index
    The position of the required face

    Common Errors

    GetToleranceType()

    System::String^ GetToleranceType(
    	System::Int64 tol_id
    	);
    

    The GetToleranceType() function returns the type of the tolerance. See Finding Tolerance Data for a list of the allowed types. Each type is returned as an upper case string. The strings are documented in the Add functions for each type of tolerance. See for example AddTolerancePosition. In the API tolerances are classified into geometric tolerances, size dimension tolerances, location dimension tolerances and surface texture parameter tolerances. The type of a tolerance can be tested using the IsGeometricTolerance, IsSizeDimension, IsLocationDimension and IsSurfaceTextureParameter functions.

    Arguments

    tol_id
    Identity of the tolerance

    Related Functions

    Common Errors

    GetToleranceUnequal()

    System::Boolean GetToleranceUnequal(
    	System::Int64 tol_id,
    	[System::Runtime::InteropServices::Out] double %value
    	);
    

    The GetToleranceUnequal() function returns true for tolerances that have an unequally-disposed tolerance zone Ⓤ and fills a parameter with the displacement value.

    GetToleranceUnit()

    System::String^ GetToleranceUnit(	
    	System::Int64 tol_id
    	);
    
    string GetToleranceUnit(		
    	int tol_id
    	);
    

    The GetToleranceUnit() function return the value unit (e.g “in” or “mm”) for a tolerance.

    Arguments

    tol_id
    Identity of the tolerance

    Related Functions

    Common Errors

    GetToleranceValue()

    double GetToleranceValue(
    	System::Int64 tol_id
    	);
    

    The GetToleranceValue() function returns the defined or nominal value of the tolerance or dimension.

    Arguments

    tol_id
    Identity of the tolerance

    Related Functions

    Common Errors

    GetToleranceValueFormatType()

    string GetToleranceValueFormatType(
    	System::Int64 tol_id
    	);
    

    The GetToleranceValueFormatType() function returns the format type of a string. As per Part 45. 6.4.14, this format should conform to the requirements of an NR2 or NR5 control string.

    Arguments

    tol_id
    Identity of the tolerance or dimension

    Related Functions

    Common Errors

    GetToleranceZone()

    string GetToleranceZone(
    	System::Int64 tol_id
    	);
    

    The GetToleranceZone() function returns the type of the tolerance zone. The default is for the tolerance to be measured over a plane. The zone must be set if the geometry to be measured is not a plane. The following values are also allowed, some of them may or may not make sense depending on the type of tolerance or dimension being measured.

    Arguments

    tol_id
    Identity of the tolerance or dimension

    Related Functions

    Common Errors

    GetToolCurrentDiameter()

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

    The GetToolCurrentDiameter() function returns the current value of the diameter as last measured. The STEP-NC API stores two values for the tool diameter. The nominal value is the value defined by the CAM system. The current value is the as measured value of the tool obtained from an ISO13399 tool database, by measuring the tool on the machine, or by applying computations to the tolerance measurements machined by the tool and calculating an adjustment tht will compensate for any errors.

    Arguments

    tool_id
    Identity of the toool
    nominal_set
    [out] True if tool has a nominal diameter
    measured_set
    [out] True if tolerance has a measured diameter
    nominal_value
    [out] The nominal value (also returned by the GetToolDiameter function of the Finder object).

    Related Functions

    Common Errors

    GetToolCurrentLength()

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

    The GetToolCurrentLength() function returns the current value of the length as last measured. The STEP-NC API stores two values for the tool length. The nominal value is the value defined by the CAM system. The current value is the as measured value of the tool obtained from an ISO13399 tool database, by measuring the tool on the machine, or by applying computations to the tolerance measurements machined by the tool and calculating an adjustment tht will compensate for any errors.

    Arguments

    tool_id
    Identity of the toool
    nominal_set
    [out] True if tool has a nominal length
    measured_set
    [out] True if tolerance has a measured length
    nominal_value
    [out] The nominal value (also returned by the GetToolLength function of the Finder object).

    Related Functions

    Common Errors

    GetToolCurrentRadius()

    double GetToolCurrentRadius(
    	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 GetToolCurrentRadius() function returns the current value of the radius as last measured. The STEP-NC API stores two values for the tool radius. The nominal value is the value defined by the CAM system. The current value is the as measured value of the tool obtained from an ISO13399 tool database, by measuring the tool on the machine, or by applying computations to the tolerance measurements machined by the tool and calculating an adjustment tht will compensate for any errors. The radius of a tool describes the radius of the fillet between the length and the diameter and is sometimes known more precisely as the corner radius.

    Arguments

    tool_id
    Identity of the toool
    nominal_set
    [out] True if tool has a nominal corner radius value
    measured_set
    [out] True if tolerance has a measured corner radius value
    nominal_value
    [out] The nominal value (also returned by the GetToolCornerRadius function of the Finder object).

    Related Functions

    Common Errors

    GetToolDiameterAdvice()

    double GetToolDiameterAdvice(
    	System::Int64 tool_id,
    	[System::Runtime::InteropServices::Out] System::Boolean %advice_given
    	);
    

    The GetToolDiameterAdvice() function returns the recommended change for the tool diameter. The tool diameter advice is a recommendation for an adjustment that will correct the errors found in the tolerances of the faces machined by the tool. If possible the recommendations given are ones that will adjust the measured values of the all tolerances machined by the tool to the mid point of their defined range. If one value will not correct them all then an average is computed.

    Arguments

    tool_id
    Identity of the toool
    advice_given
    [out] The system has some advice to recommend because one or more faces machined by the tool are not in tolerance.

    Related Functions

    Common Errors

    GetToolDiameterAdviceStatus()

    System::String^ GetToolDiameterAdviceStatus(
    	System::Int64 tool_id
    	);
    

    The GetToolDiameterAdviceStatus() function decides if the user has accepted the given advice by changing the current value of the tool diameter. The tool diameter advice is a recommendation for an adjustment that will correct the errors found in the tolerances of the faces machined by the tool.

    Arguments

    tool_id
    Identity of the toool

    Related Functions

    Common Errors

    GetToolLengthAdvice()

    double GetToolLengthAdvice(
    	System::Int64 tool_id,
    	[System::Runtime::InteropServices::Out] System::Boolean %advice_given
    	);
    

    The GetToolLengthAdvice() function returns the recommended change for the tool length. The tool length advice is a recommendation for an adjustment that will correct the errors found in the tolerances of the faces machined by the tool. If possible the recommendations given are ones that will adjust the measured values of the tolerances to the mid point of their defined range. If one value will not correct them all then an average is computed.

    Arguments

    Tool_id
    Identity of the toool
    advice_given
    [out] The system is able to recommend an adjustment because one or more faces machined by the tool are not in tolerance.

    Related Functions

    Common Errors

    GetToolLengthAdviceStatus()

    System::String^ GetToolLengthAdviceStatus(
    	System::Int64 tool_id
    	);
    

    The GetToolLengthAdviceStatus() function decides if the user has accepted the given advice by changing the current value of the tool length. The tool length advice is a recommendation for an adjustment that will correct the errors found in the tolerances of the faces machined by the tool.

    Arguments

    tool_id
    Identity of the toool

    Related Functions

    Common Errors

    GetToolRadiusAdvice()

    double GetToolRadiusAdvice(
    	System::Int64 tool_id,
    	[System::Runtime::InteropServices::Out] System::Boolean %advice_given
    	);
    

    The GetToolRadiusAdvice() function returns the recommended change for the tool corner radius. The tool radius advice is a recommendation for an adjustment that will correct the errors found in the tolerances of the faces machined by the tool. If possible the recommendations given are ones that will adjust the measured values of the tolerances to the mid point of their defined range. If one value will not correct them all then an average is computed. The radius of a tool describes the radius of the fillet between the length and the diameter and is sometimes known more precisely as the corner radius.

    Arguments

    tool_id
    Identity of the toool
    advice_given
    [out] The system is able to recommend an adjustment because one or more faces machined by the tool are not in tolerance.

    Related Functions

    Common Errors

    GetToolRadiusAdviceStatus()

    System::String^ GetToolRadiusAdviceStatus(
    	System::Int64 tool_id
    	);
    

    The GetToolRadiusAdviceStatus() function decides if the user has accepted the given advice by changing the current value of the tool radius. The tool radius advice is a recommendation for an adjustment that will correct the errors found in the tolerances of the faces machined by the tool. The tool radius defined the radius of a fillet between the length and the diameter and is more aptly described as the corner radius.

    Arguments

    tool_id
    Identity of the toool

    Related Functions

    Common Errors

    GetWorkingstepFaceCount/Next()

    System::Int64 GetWorkingstepFaceCount(
    	System::Int64 ws_id
    	);
    
    System::Int64 GetWorkingstepFaceNext(
    	System::Int64 ws_id,
    	System::Int64 index
    	);
    

    The GetWorkingstepFaceCount() function returns the number of faces machined during this workingstep. To be counted the face must belong to process manufacturing feature of the workingstep. The GetFeatureFaceCount function of the finder object provides similar functionality but it returns the faces belonging to both the process feature and the final features.

    The GetWorkingstepFaceNext() function returns the next face machined by this workingstep.

    Arguments

    ws_id
    The identity of the workingstep.
    index
    The position of the face.

    Related Functions

    Common Errors

    GetWorkplanProbeFeatureUUID()

    System::String^ GetWorkplanProbeFeatureUUID(
    	System::Int64 wp_id
    	);
    void SetWorkplanProbeFeatureUUID(
    	System::Int64 wp_id,
    	System::String^ uuid
    	);
    System::String^ GetWorkingstepProbePointUUID(
    	System::Int64 ws_id
    	);
    void SetWorkingstepProbePointUUID(
    	System::Int64 ws_id,
    	System::String^ uuid
    	);
    
    

    The GetWorkplanProbeFeatureUUID() function gets the identity of the feature measured by a workplan containing probing workinsteps.

    The GetWorkingstepProbePointUUID() function gets the identity of the point measured by a probing workinstep.

    The Setxxx functions allow the identifier to be updated when a probing program migrates between versions. You must determine when the feature and/or points are the same between versions.

    Arguments

    ws_id
    The identity of the workingstep.
    wp_id
    The identity of the workplan.
    uuid
    The universally unique identifier.

    Related Functions

    Functions to get and set the UUID of an object are in the APT library.

    Common Errors

    GetWorkingstepToleranceCount/Next()

    System::Int64 GetWorkingstepToleranceCount(
    	System::Int64 ws_id
    	);
    
    System::Int64 GetWorkingstepToleranceNext(
    	System::Int64 ws_id,
    	System::Int64 index
    	);
    

    The GetWorkingstepToleranceCount() function returns the number of tolerances machined during this workingstep. To be counted the tolerance must have at least one face in common with the manufacturing feature of the workingstep. The tolerance count includes size dimensions, location dimensions and surface texture parameters.

    The GetWorkingstepToleranceNext() function returns the next tolerance machined by this workingstep. To be counted the tolerance must have at least one face in common with the manufacturing feature of the workingstep. The tolerance can be a size dimension, location dimension or surface texture parameters.

    Arguments

    ws_id
    The identity of the workingstep.
    index
    The position of the next tolerance

    Related Functions

    Common Errors

    GetWorkpieceCalloutCount/Next()

    System::Int64 GetWorkpieceCalloutCount (
    	System::Int64 wp_id
    	);
    
    System::Int64 GetWorkpieceCalloutNext (
    	System::Int64 wp_id,
    	System::Int64 index
    	[System::Runtime::InteropServices::Out] System::String^ %callout_name
    	);
    

    The GetWorkpieceCalloutCount() function

    The GetWorkpieceCalloutNext() function

    GetWorkpiece[Tree]DatumCount/Next/All()

    System::Int64 GetWorkpieceTreeDatumCount(	
    	System::Int64 wp_id
    	);
    System::Int64 GetWorkpieceTreeDatumAllNext(
    	System::Int64 wp_id,
    	System::Int64 index
    	);
    int[] GetWorkpieceTreeDatumAll(			
    	int wp_id
    	);
    System::Int64 GetWorkpieceDatumCount(	
    	System::Int64 wp_id
    	);
    System::Int64 GetWorkpieceDatumAllNext(
    	System::Int64 wp_id,
    	System::Int64 index
    	);
    int[] GetWorkpieceDatumAll(			
    	int wp_id
    	);
    

    The GetWorkpieceTreeDatumCount/Next/All() functions gets all the datums on a workpiece including any subassemblies For most STEP-NC applications this is the more useful function. The exception is if you are writing code to traverse the details of the components in an assembly tree and in this case the GetWorkpieceDatumCount/Next/All() functions are more useful.

    Arguments

    wp_id
    The identity of the workpiece. See the GetWorkpieceID, GetFixtureID, GetRawpiceID and GetToolProductID functions of the Finder object, or the GetCurrentWorkpiece, GetCurrentRawpiece, GetCurrentFixture and GetCurrentTool functions of the APT object.
    index
    The position of the next datum.

    Related Functions

    Common Errors

    GetWorkpieceDraughtingCount/Next()

    System::Int64 GetWorkpieceDraughtingCount (
    	System::Int64 wp_id
    	);
    
    System::Int64 GetWorkpieceDraughtingNext (
    	System::Int64 wp_id,
    	System::Int64 index
    	);
    

    The GetWorkpieceDraughting functions return the draughting callouts on a workpiece and its sub-assemblies.

    GetWorkpieceFaceCount/Next()

    System::Int64 GetWorkpieceFaceCount(
    	System::Int64 wp_id
    	);
    
    System::Int64 GetWorkpieceFaceNext(
    	System::Int64 wp_id,
    	System::Int64 index
    	);
    

    The GetWorkpieceFaceCount() function returns the number of faces on the workpiece.

    The GetWorkpieceFaceNext() function iterates over the faces and returns the one at a given index.

    The finder object has a range of functions to get the different types of workpieces. In STEP-NC workpieces can represent the rawpiece, the fixture and the cutting tools as well as the part being machined by the program.

    Arguments

    wp_id
    The identity of the workpiece. See the GetWorkpieceID, GetFixtureID, GetRawpiceID and GetToolProductID functions of the Finder object, or the GetCurrentWorkpiece, GetCurrentRawpiece, GetCurrentFixture and GetCurrentTool functions of the APT object.
    index
    The position of the next face.

    Related Functions

    Common Errors

    GetWorkpieceGeometricSetCount/Next()

    System::Int64 GetWorkpieceGeometricSetCount(
    	System::Int64 wp_id
    	);
    
    System::Int64 GetWorkpieceGeometricSetNext(
    	System::Int64 wp_id,
    	System::Int64 index
    	);
    

    The GetWorkpieceGeometricSetCount() function returns the number of elements in a geometric set. A geometric set is a set of geometry that can be associated with a workpiece. For example it might describe a set of points that are to be measured.

    The GetWorkpieceGeometricSetNext() function returns the next element of the geometric set.

    Arguments

    wp_id
    The identity of the workpiece. See the GetWorkpieceID, GetFixtureID, GetRawpiceID and GetToolProductID functions of the Finder object, or the GetCurrentWorkpiece, GetCurrentRawpiece, GetCurrentFixture and GetCurrentTool functions of the APT object.
    index
    The position of the next set.

    Related Functions

    Common Errors

    GetWorkpieceGeometricSetPointCount/Next()

    System::Int64 GetWorkpieceGeometricSetPointCount(
    	System::Int64 set_id
    	);
    
    System::String^ GetWorkpieceGeometricSetPointNext(
    	System::Int64 set_id,
    	System::Int64 index,
    	[System::Runtime::InteropServices::Out] double %x,
    	[System::Runtime::InteropServices::Out] double %y,
    	[System::Runtime::InteropServices::Out] double %z
    	);
    

    The GetWorkpieceGeometricSetPointCount() function returns the number of points in the geometric set. A geometric set is a set of geometry that can be associated with a workpiece. For example it might describe a set of points that are to be measured.

    The GetWorkpieceGeometricSetPointNext() function returns the next point in a geometric set. The return value is the name of the point (or null) and the coordinates are returned as out parameters.

    Arguments

    set_id
    The identity of the geometric set.
    index
    The position of the next point.
    x, y, z
    [out] The coordinates of the point.

    Related Functions

    Common Errors

    GetWorkpieceOfDatum()

    System::Int64 GetWorkpieceOfDatum(
    	System::Int64 dat_id
    	);
    

    The GetWorkpieceOfDatum() function returns the workpiece of a datum.

    Arguments

    dat_id
    The identity of the datum.

    Related Functions

    Common Errors

    GetWorkpieceOfTolerance()

    System::Int64 GetWorkpieceOfTolerance(	
    	System::Int64 tol_id
    	);
    
    int GetWorkpieceOfTolerance(		
    	int tol_id
    	);
    

    The GetWorkpieceOfTolerance() function returns the workpiece of a tolerance.

    Arguments

    tol_id
    The identity of the datum.

    Related Functions

    Common Errors

    GetWorkpiece[Tree]ToleranceCount/Next/All()

    System::Int64 GetWorkpieceTreeToleranceCount(		System::Int64 wp_id
    	);
    System::Int64 GetWorkpieceTreeToleranceNext(
    	System::Int64 wp_id,
    	System::Int64 index
    	);
    int[] GetWorkpieceTreeToleranceAll(			
    	int wp_id
    	);
    System::Int64 GetWorkpieceToleranceCount(		System::Int64 wp_id
    	);
    System::Int64 GetWorkpieceToleranceNext(
    	System::Int64 wp_id,
    	System::Int64 index
    	);
    int[] GetWorkpieceToleranceAll(			
    	int wp_id
    	);
    

    The GetWorkpieceTreeTolerance() functions return the tolerances defined on a workpiece and its sub-assemblies. The tolerances include surface texture parameters, size dimensions, location dimensions and geometric tolerances. To be defined on a workpiece the tolerance must be applied to faces that belong to the workpiece.

    The GetWorkpieceTolerance() functions get the same results but without visiting any sub-assemblies.

    Arguments

    wp_id
    The identity of the workpiece. See the GetWorkpieceID, GetFixtureID, GetRawpiceID and GetToolProductID functions of the Finder object, or the GetCurrentWorkpiece, GetCurrentRawpiece, GetCurrentFixture and GetCurrentTool functions of the APT object.
    index
    The position of the next tolerance.

    Related Functions

    GetWorkpieceToleranceFaceCount/Next()

    System::Int64 GetWorkpieceToleranceFaceCount(
    	System::Int64 wp_id
    	);
    
    System::Int64 GetWorkpieceToleranceFaceNext(
    	System::Int64 wp_id,
    	System::Int64 index
    	);
    

    The GetWorkpieceToleranceFaceCount() function returns the number of toleranced faces on the workpiece. The faces can belong to any of the tolerances defined in the model. In STEP-NC all of the faces in the same tolerance must belong to the same workpiece.

    The GetWorkpieceToleranceFaceNext() function returns the next toleranced face on the workpiece.

    Arguments

    wp_id
    The identity of the workpiece.
    index
    The position of the next face.

    Related Functions

    Common Errors

    GetWorkpieceUnusedCalloutCount/Next()

    System::Int64 GetWorkpieceUnusedCalloutCount (
    	System::Int64 wp_id
    	);
    
    System::Int64 GetWorkpieceUnusedCalloutNext (
    	System::Int64 wp_id,
    	System::Int64 index
    	[System::Runtime::InteropServices::Out] System::String^ %callout_name
    	);
    

    The GetWorkpieceUnusedCallout functions returns a list of the "orphaned" draughting callouts on a workpiece that are not attached to a specific tolerance or datum.

    GetWorkplanFaceCount/Next()

    System::Int64 GetWorkplanFaceCount(
    	System::Int64 wp_id
    	);
    
    System::Int64 GetWorkplanFaceNext(
    	System::Int64 wp_id,
    	System::Int64 index
    	);
    

    The GetWorkplanFaceCount() function returns the number of faces machined during this workplan. To be counted the face must belong to a manufacturing feature of one of the workingsteps in the workplan. Any nested workplans in the given workplan will also be searched. The functionality of GetWorkplanFaceCount is similar to the GetFeatureFaceNext function of the Finder object but only process feature faces are found in Tolerance, final features are ignored.

    The GetWorkplanFaceNext() function returns the next tolerance machined by this workplan.

    Arguments

    wp_id
    The identity of the workplan.
    index
    The position of the next face.

    Related Functions

    Common Errors

    GetWorkplanToleranceCount/Next()

    System::Int64 GetWorkplanToleranceCount(
    	System::Int64 wp_id
    	);
    
    System::Int64 GetWorkplanToleranceNext(
    	System::Int64 wp_id,
    	System::Int64 index
    	);
    

    The GetWorkplanToleranceCount() function returns the number of tolerances machined during this workplan. To be counted the tolerance must have at least one face in common with the manufacturing feature of one of the workingsteps in the workplan. Any nested workplans in the given workplan will also be searched. The tolerance count includes size dimensions, location dimensions and surface texture parameters.

    The GetWorkplanToleranceNext() function returns the next tolerance machined by this workingstep. To be counted the tolerance must have at least one face in common with the manufacturing feature of a workingstep somewhere in the workplan. The tolerance can be a size dimension, location dimension or surface texture parameters.

    Arguments

    wp_id
    The identity of the workplan.
    index
    The position of the next tolerance

    Related Functions

    Common Errors

    ImportProbeResultData()

    void ImportProbeResultData(
    	System::String^ filename,
    	System::String^ unit
    	);
    

    The ImportProbeResultData() function reads result data for the probing operations in a project.

    Arguments

    file_name
    Name of the file that holds the result data.
    unit
    Unit (e.g. “in” or “mm”) for the coordinates of the point data

    Related Functions

    Common Errors

    ImportUsingConfiguration()

    System::String^ ImportUsingConfiguration(
    	System::String^ config_file_name
    	);
    

    The ImportUsingConfiguration() function finds each of the files references by the XML file and converts it into the type of workpiece described by that file. The function returns the name of the AP238 file made by the configuration.

    The XML file also recreates the associations between the operations in the machining program and the faces on the workpieces. A STEP-NC file can be divided into components to allow for individual editing by CAD and CAM systems. This command reassembles the STEP-NC file after it has been edited. The XML file used by this command contains a description of all of the data.

    Arguments

    File name
    The XML file describing the configuration.

    Related Functions

    Common Errors

    IsGeometricTolerance()

    System::Boolean IsGeometricTolerance(
    	System::Int64 tol_id
    	);
    

    The IsGeometricTolerance() function returns true if the tolerance is geometric. A tolerance may be a geometric tolerance, a size dimension, a location dimension or a suface texture parameter. See Finding Tolerance Data for a list of the types allowed under each category.

    Arguments

    tol_id
    Identity of the tolerance

    Related Functions

    Common Errors

    IsLocationDimension()

    System::Boolean IsLocationDimension(
    	System::Int64 tol_id
    	);
    

    The IsLocationDimension() function returns true if the tolerance is a location dimension. A tolerance may be a geometric tolerance, a size dimension, a location dimension or a suface texture parameter.

    Arguments

    tol_id
    Identity of the tolerance

    Related Functions

    Common Errors

    IsSizeDimension()

    System::Boolean IsSizeDimension(
    	System::Int64 tol_id
    	);
    

    The IsSizeDimension() function returns true if the tolerance is a size dimension. A tolerance may be a geometric tolerance, a size dimension, a location dimension or a suface texture parameter.

    Arguments

    Tol_id
    Identity of the tolerance

    Related Functions

    Common Errors

    IsSurfaceTextureParameter()

    System::Boolean IsSurfaceTextureParameter(
    	System::Int64 tol_id
    	);
    

    The IsSurfaceTextureParameter() function returns a true (1) if the given identity is for a surface texture parameter. A tolerance may be a geometric tolerance, a size dimension, a location dimension or a suface texture parameter.

    Arguments

    tol_id
    Identity of the tolerance

    Related Functions

    Common Errors

    IsTolerance/Datum()

    System::Boolean IsTolerance(
    	System::Int64 tol_id
    	);
    
    System::Boolean IsDatum(
    	System::Int64 tol_id
    	);
    

    The IsTolerance() function returns true if the entity is any kind of tolerance including a geometric tolerance, a size dimension, or a location dimension or a suface texture parameter.

    The IsDatum() function returns true if the entity is any kind of datum.

    Arguments

    tol_id
    Identity of the tolerance

    Related Functions

    Common Errors

    IsToleranceFace/DatumFace()

    System::Int64 IsToleranceFace(
    	System::Int64 face_id
    	);
    
    System::Int64 IsDatumFace(
    	System::Int64 face_id
    	);
    

    The IsToleranceFace() function returns the identity of the first tolerance on this face. A face may be in many types of tolerances so the selection of the tolerance returned is randon. If the face If no tolerance is found then 0 is returned.

    The IsDatumFace() function returns the identity of the first datum on this face. A face is usually in zero or one datums. If no datum is found then 0 is returned.

    Arguments

    face_id
    Identity of the face

    Related Functions

    Common Errors

    MTConnectReportProbeResult()

    System::Int64 MTConnectTestPointResult(
    	System::String^ feature_uuid,
    	System::Int64 order,
    	System::Int64 count,
    	double x,
    	double y,
    	double z
    	);
    
    System::String^ MTConnectTestPointResult(
    	System::String^ feature_uuid,
    	System::Int64 order,
    	System::Int64 count,
    	double distance
    	);
    

    The MTConnectReportProbeResult() functions report the measured position of a probe point. The probe value can be reported as xyz coordinates or as a distance travelled from the start point. The functions lookup the feature being measured and when all the probe points have been reported they compute estimates for the tolerances that apply to that feature. If tolerances are evaluated then the function returns (1) otherwise it returns 0.

    Arguments

    feature_id
    The UUID of the feature being measured.
    order
    The order of this probe point within the count.
    count
    The total count of the probe points on this feature.
    xyz
    The as-measured coordinates of the probe point.
    distance
    The distance travelled to the probe point.

    Related Functions

    Common Errors

    MTConnectTestPointResult/PerfectResult()

    System::String^ MTConnectTestPointResult(
    	System::Int64 face_id,
    	System::Int64 index,
    	double x,
    	double y,
    	double z
    	);
    
    System::String^ MTConnectTestPerfectResult(
    	System::Int64 face_id,
    	System::Int64 index
    	);
    

    The MTConnectTest() functions return the MTConnect test results for a touch point on the face. The results are returned for a given point or for the perfect point if the probe touched the surface at exactly the planned location.

    The results are returned in a string in the SHDR format

    Arguments

    face_id
    The identity of the face.
    index
    The position of the next touch point.

    Related Functions

    Common Errors

    MTConnectWorkingstepProbeResult()

    System::String^ MTConnectWorkingstepProbeResult(
    	System::Int64 ws_id,
    	double measured_x,
    	double measrued_y,
    	double measured_z
    	);
    

    The MTConnectWorkingstepProbeResult() functions return the MTConnect result for a single touch point in the SHDR format

    Arguments

    ws_id
    The identity of the workingstep.
    measured_xyz
    As measured point values.

    Related Functions

    Common Errors

    NavigateFaceToCalloutCount/Next()

    System::Int64 NavigateFaceToCalloutCount (
    	System::Int64 face_id
    	);
    
    System::Int64 NavigateFaceToCalloutNext (
    	System::Int64 face_id,
    	System::Int64 index
    	);
    

    The NavigateFaceToCalloutCount() function

    The NavigateFaceToCalloutNext() function

    NavigateFaceToProbingCount/Next()

    System::Int64 NavigateFaceToProbingCount(
    	System::Int64 face_id
    	);
    
    System::Int64 NavigateFaceToProbingNext(
    	System::Int64 face_id,
    	System::Int64 index
    	);
    

    The NavigateFaceToProbingCount() function returns the number of probing operations that test the location of a face.

    The NavigateFaceToProbingNext() function returns the next probing operation that touches a face. After evaluating the results of all the probing operations for a face, a function can determine an estimate for the tolerances of that face and set their measured values using the PutMeasuredValue function. Other functions can then determine how to compensate the dimensions of the tools to correct any errors in the tolerances.

    Arguments

    face_id
    The identity of the face.
    index
    The position of the next probing operation.

    Related Functions

    Common Errors

    NavigateFaceToToleranceCount/Next()

    System::Int64 NavigateFaceToToleranceCount(
    	System::Int64 face_id
    	);
    
    System::Int64 NavigateFaceToToleranceNext(
    	System::Int64 face_id,
    	System::Int64 index
    	);
    

    The NavigateFaceToToleranceCount() function returns the number of tolerances that are applied to a face. The tolerances can be geometric, size dimension, location dimension and surface texture parameters

    The NavigateFaceToToleranceNext() function returns the next tolerance applied to a face.

    Arguments

    face_id
    The identity of the face.
    index
    The position of the tolerance.

    Related Functions

    Common Errors

    NavigateFaceToToolCount/Next()

    System::Int64 NavigateFaceToToolCount(
    	System::Int64 face_id
    	);
    
    System::Int64 NavigateFaceToToolNext(
    	System::Int64 face_id,
    	System::Int64 index
    	);
    

    The NavigateFaceToToolCount() function returns the number of tools that machine a face. The tools are determined by looking at the faces belonging to the feature of each workingstep.

    The NavigateFaceToToolNext() function returns the next tool that machined a face.

    Arguments

    face_id
    The identity of the face.
    index
    The position of the next tool.

    Related Functions

    Common Errors

    NavigateFaceToWorkingstepCount/Next()

    System::Int64 NavigateFaceToWorkingstepCount(
    	System::Int64 face_id
    	);
    
    System::Int64 NavigateFaceToWorkingstepNext(
    	System::Int64 face_id,
    	System::Int64 index
    	);
    

    The NavigateFaceToWorkingstepCount() function returns the number of workingstep that machine a face.

    The NavigateFaceToWorkingstepNext() function returns the next tool that machines a face. The finder object contains many functions for manipulating workingsteps.

    Arguments

    face_id
    The identity of the face.
    index
    The position of the next workingstep.

    Related Functions

    Common Errors

    NavigateFeatureToToleranceCount/Next()

    System::Int64 NavigateFeatureToToleranceCount(
    	System::Int64 fea_id
    	);
    
    System::Int64 NavigateFeatureToToleranceNext(
    	System::Int64 fea_id,
    	System::Int64 index
    	);
    

    The NavigateFeatureToToleranceCount() function returns the number of tolerances applied to the faces in a feature.

    The NavigateFeatureToToleranceNext() function returns the next tolerance that applies to a feature.

    Arguments

    fea_id
    The identity of the feature.
    index
    The position of the next tolerance.

    Related Functions

    Common Errors

    NavigateFeatureToToolCount/Next()

    System::Int64 NavigateFeatureToToolCount(
    	System::Int64 fea_id
    	);
    
    System::Int64 NavigateFeatureToToolNext(
    	System::Int64 fea_id,
    	System::Int64 index
    	);
    

    The NavigateFeatureToToolCount() function returns the number of tools that operate on a feature.

    The NavigateFeatureToToolNext() function returns the next tool that operates on a feature.

    Arguments

    fea_id
    The identity of the feature.
    index
    The position of the next tool.

    Related Functions

    Common Errors

    NavigateFeatureToWorkingstepCount/Next()

    System::Int64 NavigateFeatureToWorkingstepCount(
    	System::Int64 fea_id
    	);
    
    System::Int64 NavigateFeatureToWorkingstepNext(
    	System::Int64 fea_id,
    	System::Int64 index
    	);
    

    The NavigateFeatureToWorkingstepCount() function returns the number of workingsteps that operate on a feature.

    The NavigateFeatureToWorkingstepNext() function returns the next workingstep that operates on a feature.

    Arguments

    fea_id
    The identity of the feature.
    index
    The position of the next workingstep.

    Related Functions

    Common Errors

    NavigateToleranceAndToolToWorkingstepCount/Next()

    System::Int64 NavigateToleranceAndToolToWorkingstepCount(
    	System::Int64 tol_id,
    	System::Int64 tool_id
    	);
    
    System::Int64 NavigateToleranceAndToolToWorkingstepNext(
    	System::Int64 tol_id,
    	System::Int64 tool_id,
    	System::Int64 index
    	);
    

    The NavigateToleranceAndToolToWorkingstepCount() function returns the number of workingsteps that machine a particular tolerance using a particular tool.

    The NavigateToleranceAndToolToWorkingstepNext() function returns the next workingstep that machines a tolerance using a given tool. The finder object contains many functions for manipulating workingsteps.

    Arguments

    tol_id
    The identity of the tolerance.
    tool_id
    The identify of the tool.
    index
    The position of the tolerance.

    Related Functions

    Common Errors

    NavigateToleranceToFeatureCount/Next()

    System::Int64 NavigateToleranceToFeatureCount(
    	System::Int64 tol_id
    	);
    
    System::Int64 NavigateToleranceToFeatureNext(
    	System::Int64 tol_id,
    	System::Int64 index
    	);
    

    The NavigateToleranceToFeatureCount() function returns the number of features that use a tolerance.

    The NavigateToleranceToFeatureNext() function returns the next tool that machines a tolerance. The finder object contains many functions for manipulating tools.

    Arguments

    tol_id
    The identity of the tolerance.
    index
    The position of the required feature.

    Related Functions

    Common Errors

    NavigateToleranceToToolCount/Next()

    System::Int64 NavigateToleranceToToolCount(
    	System::Int64 tol_id
    	);
    
    System::Int64 NavigateToleranceToToolNext(
    	System::Int64 tol_id,
    	System::Int64 index
    	);
    

    The NavigateToleranceToToolCount() function returns the number of tools that machine a particular face.

    The NavigateToleranceToToolNext() function returns the next tool that machines a tolerance. The finder object contains many functions for manipulating tools.

    Arguments

    tol_id
    The identity of the tolerance.
    index
    The position of the tolerance.

    Related Functions

    Common Errors

    NavigateToleranceToWorkingstepCount/Next()

    System::Int64 NavigateToleranceToWorkingstepCount(
    	System::Int64 tol_id
    	);
    
    System::Int64 NavigateToleranceToWorkingstepNext(
    	System::Int64 tol_id,
    	System::Int64 index
    	);
    

    The NavigateToleranceToWorkingstepCount() function returns the number of workingsteps that machine a particular tolerance.

    The NavigateToleranceToWorkingstepNext() function returns the next workingstep that machines a tolerance.

    Arguments

    tol_id
    The identity of the tolerance.
    index
    The position of the tolerance.

    Related Functions

    Common Errors

    NavigateToolToFaceCount/Next()

    System::Int64 NavigateToolToFaceCount(
    	System::Int64 tool_id
    	);
    
    System::Int64 NavigateToolToFaceNext(
    	System::Int64 tool_id,
    	System::Int64 index
    	);
    

    The NavigateToolToFaceCount() function returns the number of faces machined by a tool. The number of faces is determined by the features in the workingsteps that use the tool.

    The NavigateToolToFaceNext() function returns the next face machined by a tool.

    Arguments

    tool_id
    The identity of the tool.
    index
    The position of the next face.

    Related Functions

    Common Errors

    NavigateToolToToleranceCount/Next()

    System::Int64 NavigateToolToToleranceCount(
    	System::Int64 tool_id
    	);
    
    System::Int64 NavigateToolToToleranceNext(
    	System::Int64 tool_id,
    	System::Int64 index
    	);
    

    The NavigateToolToToleranceCount() function returns the number of tolerances machined by a tool. The number of tolerances is determined by the faces in the features in the workingsteps that use the tool and the faces in tolerances. In order to be counted the tolerance and feature must have at least one face in common

    The NavigateToolToToleranceNext() function returns the next tolerance machined by a tool.

    Arguments

    tool_id
    The identity of the tool.
    index
    The position of the next tolerance.

    Related Functions

    Common Errors

    NavigateToolToWorkingstepCount/Next()

    System::Int64 NavigateToolToWorkingstepCount(
    	System::Int64 tool_id
    	);
    
    System::Int64 NavigateToolToWorkingstepNext(
    	System::Int64 tool_id,
    	System::Int64 index
    	);
    

    The NavigateToolToWorkingstepCount() function returns the number of workingsteps that use a tool. The same tool may be used by many different workingsteps.

    The NavigateToolToWorkingstepNext() function returns the next workingstep that uses a tool.

    Arguments

    tool_id
    The identify of the tool.
    index
    The position of the next workingstep.

    Related Functions

    Common Errors

    PickToolpath()

    void PickToolpath(
    	System::Int64 ws_id,
    	System::Int64 tp_id,
    	double ws_param,
    	double tp_param,
    	double x,
    	double y,
    	double z
    	);
    

    The PickToolpath() function

    PlanAnyProbing()

    System::Int64 PlanBSplineProbing(
    	System::Int64 wp_id,
    	System::Int64 index,
    	System::String^ wp_name,
    	System::Int64 face_id,
    	System::Int64 point_count,
    	double edge_tol
    	);
    

    The PlanAnyProbing() function creates probing workingsteps to test the position and surface profile of any type of surface.

    The probing operations are put into a new nested workplan that is created by the function. All of the probing operations are made to operate on a new feature that contains the face being probed.

    The number of points generated depends on the available area on the surface. It also depends on the size of the edge_tol because the points generated should not be within this distance of the edge. Provided these conditions can be met then point_count points will be geneated. If not then fewer points will be created. The number so made will be returned by the function. The PlanBSplineProbing(), PlanCylinderProbing() and PlanPlaneProbing() functions create probing points in regular grids. PlanAnyProbing selects points at random from the underlying mesh and tries to keep them well spaced.

    Arguments

    wp_id
    The workplan that is to contain the new nested workplan.
    wp_name
    Name for the new workplan
    index
    The position where the new workplan is to be placed. -1 means at the start, 0 means after the current first executable, any number greater than the current size means at the end of the workplan.
    face_id
    The identity of a face.
    point_count
    The desired number points.
    edge_tol
    A desired minimum distance from the boundary for any point chosen on the face.

    Related Functions

    Common Errors

    PlanBSplineProbing()

    System::Int64 PlanBSplineProbing(
    	System::Int64 wp_id,
    	System::Int64 index,
    	System::String^ wp_name,
    	System::Int64 face_id,
    	System::Int64 num_u_points,
    	System::Int64 num_v_points
    	);
    

    The PlanBSplineProbing() function creates probing workingsteps to test the location and profile of a b-spline surface, and returns the identity of the new feature that contains the spline face.

    The probing operations are put into a new nested workplan that is created by the function. All of the probing operations are made to operate on a new feature that contains the face being probed. Ideally one probe point is generated for each u, v combination. For example, if u is 3 and v is 5 then there will be 15 points. However, if the point is inside a hole, or outside the boundary of the face then it will be omitted. If necessary the location of the u and v can be “nudged” using the PlanSetDeltaUandV function.

    Arguments

    wp_id
    The workplan that is to contain the new nested workplan.
    wp_name
    Name for the new workplan
    index
    The position where the new workplan is to be placed. -1 means at the start, 0 means after the current first executable, any number greater than the current size means at the end of the workplan.
    face_id
    The identity of a face defined on a b-spline.
    num_u_points
    The desired number of u_points.
    num_v_points
    The desired number of v_points.

    Related Functions

    Common Errors

    PlanCylinderProbing()

    System::Int64 PlanCylinderProbing(
    	System::Int64 wp_id,
    	System::Int64 index,
    	System::String^ wp_name,
    	System::Int64 face_id,
    	System::Int64 num_u_points,
    	System::Int64 num_v_points
    	);
    

    The PlanCylinderProbing() function creates probing workingsteps to test the tolerances of a cylindrical surface and returns the identity of the new feature that contains the cylindrical face.

    The probing operations are put into a new nested workplan that is created by the function. All of the probing operations are made to operate on a new feature that contains the face being probed. Ideally one probe point is generated for each u, v combination. For example, if u is 3 and v is 5 then there will be 15 points. However, if the point is inside a hole, or outside the boundary of the face then it will be omitted. If necessary the location of the u and v can be “nudged” using the PlanSetDeltaUandV function.

    Arguments

    wp_id
    The workplan that is to contain the new nested workplan.
    wp_name
    Name for the new workplan
    index
    The position where the new workplan is to be placed. -1 means at the start, 0 means after the current first executable, any number greater than the current size means at the end of the workplan.
    face_id
    The identity of a face defined on a cylinder.
    num_u_points
    The desired number of u_points.
    num_v_points
    The desired number of v_points.

    Related Functions

    Common Errors

    PlanPlane3PointProbing()

    System::Int64 PlanPlane3PointProbing(
    	System::Int64 wp_id,
    	System::Int64 index,
    	System::String^ wp_nme,
    	System::Int64 face_id,
    	double space_a,
    	double space_b,
    	System::Int64 reverse_ab
    	);
    

    The PlanPlane3PointProbing() function creates three probing workingsteps to test the location of a planar surface and return the identity of the new feature that contains the planar face.

    The probing operations are put into a new nested workplan that is created by the operation. All of the probing operations are made to operate on a new feature that contains the face being probed. The goal of this version of the planning functions is to generate three probe points that are far from each other as possible in order to get the best possible error detection for face.

    Arguments

    wp_id
    The workplan that is to contain the new nested workplan.
    index
    The position where the new workplan is to be placed. -1 means at the start, 0 means after the current first executable, any number greater than the current size means at the end of the workplan.
    wp_name
    Name for the new workplan
    face_id
    The identity of a face defined on a plabe.
    space_a
    The distance between two points at the base of a triangle.
    space_b
    The distance between the top and base of the triangle.
    reverseab
    Swap the a and b directions.

    Related Functions

    Common Errors

    PlanPlaneProbing()

    System::Int64 PlanPlaneProbing(
    	System::Int64 wp_id,
    	System::Int64 index,
    	System::String^ wp_name,
    	System::Int64 face_id,
    	System::Int64 num_u_points,
    	System::Int64 num_v_points
    	);
    

    The PlanPlaneProbing() function creates probing workingsteps to test the tolerances of a planar surface and returns the identity of the new feature that contains the planar face.

    The probing operations are put into a new nested workplan that is created by the function. All of the probing operations are made to operate on a new feature that contains the face being probed. Ideally one probe point is generated for each u, v combination. For example, if u is 3 and v is 5 then there will be 15 points. However, if the point is inside a hole, or outside the boundary of the face then it will be omitted. If necessary the location of the u and v can be “nudged” using the PlanSetDeltaUandV function.

    Arguments

    wp_id
    The workplan that is to contain the new nested workplan.
    wp_name
    Name for the new workplan
    index
    The position where the new workplan is to be placed. -1 means at the start, 0 means after the current first executable, any number greater than the current size means at the end of the workplan.
    face_id
    The identity of a face defined on a cylinder.
    num_u_points
    The desired number of u_points.
    num_v_points
    The desired number of v_points.

    Related Functions

    Common Errors

    PlanProbingAddPoint()

    System::Int64 PlanProbingAddPoint(
    	System::Int64 wp_id,
    	System::Int64 index,
    	System::String^ ws_name,
    	System::Int64 face_id,
    	double x,
    	double y,
    	double z,
    	double i,
    	double j,
    	double k
    	);
    

    The PlanProbingAddPoint() function

    PlanSetDeltaUandV()

    void PlanSetDeltaUandV(
    	double u,
    	double v
    	);
    

    The PlanSetDeltaUandV() function enables the initial values of the grid points to be “nudged” to a location where they may encounter less holes or fit better with the shape of the boundary

    The plan probing operations use the face edge loop to compute maximum and minimum values for initial points on the face and then generating a grid of points between these maxima and minima. However this procedure does not guarantee that every point will be on the face. If the edge loop is not rectangular then some of the points may be outside of the edge and if the face contains holes then some of the points may be in a hole.

    Arguments

    u
    Delta for the U direction.
    v
    Delta for the V direction.

    Related Functions

    PlanSetStartClear()

    void PlanSetStartClear(
    	double start,
    	double clear
    	);
    

    The PlanSetStartClear() function defines the distance of the start point from the touch point in that direction. The function also defines a clearance plane for the first and last operation. A probing operation first moves the probe to a start location and then moves the probe from that location in a defined direction until it “touches” the surface. The PlanUsingNormal, PlanUsingXandY and PlanUsingXorY define the direction.

    Arguments

    start
    Distance from the “touched” point for the start point.
    clear
    Clearance distance above the start and end points in for the first and last probing operations. The first probe operation will move to this location before going to the first probe start point. The last probe operation will retract to this point at the end of the plan.

    Related Functions

    Common Errors

    PlanUsingClearAlways()

    void PlanUsingClearAlways();
    

    The PlanUsingClearAlways() function

    PlanUsingClearAtStartEndOnly()

    void PlanUsingClearAtStartEndOnly();
    

    The PlanUsingClearAtStartEndOnly() function

    PlanUsingNormal()

    void PlanUsingNormal();
    

    The PlanUsingNormal() function sets the probe direction to be defined by the normal to the surface at the point being probed. The probing operation will move the probe along this normal until it touches the surface. The other method for defining the probe direction is defined by the PlanUsingZAxis function. If PlanUsingNormal is being used then PlanUsingXandY is also assumed.

    Related Functions

    PlanUsingXandY()

    void PlanUsingXandY();
    

    The PlanUsingXandY() function

    PlanUsingXorY()

    void PlanUsingXorY();
    

    The PlanUsingXorY() function sets the probing strategy so that if PlanUsingZAxis is ON then PlanUsingXorY determines the direction to be taken for the probe once it is at the correct Z height. If this function is on then the probe can only move in the X or Y direction so the probe is moved to a start position that allows the probe to move in one axis only. The axis chosen is the one that will minimize any tangent errors.

    Related Functions

    PlanUsingZAxis()

    void PlanUsingZAxis();
    

    The PlanUsingZAxis() function sets the strategy so PlanUsingXandY determines the direction to be taken for the probe once it is at the correct Z height. If this function is on then the probe can be moved in the X and Y direction simulataneously. If the system is in PlanUsingXorY then only one of the axes can be moved because of restrictions on the control.

    If PlanUsingZAxis is on and the surface being probed is more horizontal than vertical then the probe is first moved over the point and then moved down vertically until it touches the surface.

    If PlanUsingZaxis is on and the surface being probed is more vertical than horizontal then the probe is first moved to the correct height and then moved to the point using the XY normal if PlanUsingXandY is on, or just one axis if PlanUsingXorY is on.

    Related Functions

    PutMeasurementWorkpiece()

    void PutMeasurementWorkpiece(
    	System::Int64 ws_id,
    	System::String^ file_name
    	);
    

    The PutMeasurementWorkpiece() function

    PutMeasurementWorkpieceRaw()

    void PutMeasurementWorkpieceRaw(
    	System::Int64 ws_id,
    	System::String^ file_name
    	);
    

    The PutMeasurementWorkpieceRaw() function

    PutProbeResult()

    void PutProbeResult(
    	System::Int64 index,
    	double value
    	);
    

    The PutProbeResult() function puts the result of a probing operation into the STEP-NC file so that it can be used to evaluate the quality of the tolerances on the part. There are several versions of this function. PutProbeResult is the simplest because it takes the value given and makes it the probe result. The other functions perform a calculation using the coordinates of the touched point.

    Arguments

    index
    The position of this probe in the sequence
    value
    The distance traveled by the probe before it touched the surface.

    Related Functions

    Common Errors

    PutProbeResultXPos()

    void PutProbeResultXPos(
    	System::Int64 index,
    	double x
    	);
    

    If the operation moved the probe in the x direction then the PutProbeResultXPos() function uses the value of the x coordinate to determine the “touch” point.

    Arguments

    index
    The position of this probe in the sequence
    x
    The value of the X coordinate when the probe touched the surface.

    Related Functions

    Common Errors

    PutProbeResultXYZPos()

    void PutProbeResultXYZPos(
    	System::Int64 index,
    	double x,
    	double y,
    	double z
    	);
    

    Depending on the control it may be easier to either use the distance traveled or the coordinates of the touch point to set the result of a probing operations. The PutProbeResultXYZPos() function allows the result to be set using the three coordinates.

    Arguments

    index
    The position of this probe in the sequence
    x
    The value of the X coordinate when the probe touched the surface.
    y
    The value of the Y coordinate when the probe touched the surface.
    z
    The value of the Z coordinate when the probe touched the surface.

    Related Functions

    Common Errors

    PutProbeResultYPos()

    void PutProbeResultYPos(
    	System::Int64 index,
    	double y
    	);
    

    If the operation moved the probe in the y direction then the PutProbeResultYPos() function uses the value of the y coordinate to determine the “touch” point.

    Arguments

    index
    The position of this probe in the sequence
    y
    The value of the Y coordinate when the probe touched the surface.

    Related Functions

    Common Errors

    PutProbeResultZPos()

    void PutProbeResultZPos(
    	System::Int64 index,
    	double z
    	);
    

    If the operation moved the probe in the z direction then the PutProbeResultZPos() function uses the value of the z coordinate to determine the “touch” point.

    Arguments

    index
    The position of this probe in the sequence
    z
    The value of the Z coordinate when the probe touched the surface.

    Related Functions

    Common Errors

    PutToleranceDefinedAreaUnit()

    void PutToleranceDefinedAreaUnit(
    	System::Int64 tol_id,
    	double value1,
    	double value2,
    	System::String^ area_type
    	);
    

    The PutToleranceDefinedAreaUnit() function assigns an area unit basis to a tolerance. This means that the controlled feature can only vary by the tolerance amount per area of a given size and shape, rather than over the entire feature.

    The tolerance must have been created with the WITH_DEFINED_AREA flag. The parameters are the tolerance, the two numeric values, and a string describing the shape of the unit basis area. The strings accepted for the area type are "square", "circular", or "rectangular" and these control how the numeric parameters are interpreted.

    An area type of "rectangular" requires both numeric values to describe a rectangular area. This appears in a feature control frame as "value1 X value2". This is equivalent to calling the PutToleranceDefinedRectangularUnit() function.

    An area type of "square" requires the first numeric value to describe a square area with sides of that length. The second numeric value is ignored. This appears in a feature control frame as "□ value1". Thie is equivalent to calling the PutToleranceDefinedSquareUnit() function.

    An area type of "circular" requires the first numeric value to describe a circular area with [diameter?] of that length. The second numeric value is ignored. This appears in a feature control frame as "ø value1". Thie is equivalent to calling the PutToleranceDefinedCircularUnit() function.

    Int64 callout_id;
    Int64 tol_id = tol->AddTolerancePositionWithFlags(
        callout_id, 0.01, "ABC", WITH_DEFINED_AREA
        );
    
    // add a square 0.02 X 0.02 defined area unit
    tol->PutToleranceDefinedAreaUnit(
        tol_id, 1.0, 0.5, "rectangular"
        );
    

    PutToleranceDefinedCircularUnit()

    void Tolerance::PutToleranceDefinedCircularUnit(
    	System::Int64 tol_id,
    	double value1
    	);
    

    The PutToleranceDefinedCircularUnit() function assigns a circular area unit basis to a tolerance. This means that the controlled feature can only vary by the tolerance amount per circular area of a given size, rather than over the entire feature.

    The tolerance must have been created with the WITH_DEFINED_AREA flag. The parameters are the tolerance, the [presumably diameter, but ISO 1101 is unclear] of the circular area.

    PutToleranceDefinedRectangularUnit()

    void Tolerance::PutToleranceDefinedRectangularUnit(
    	System::Int64 tol_id,
    	double value1,
    	double value2
    	);
    

    The PutToleranceDefinedRectangularUnit() function assigns a rectangular area unit basis to a tolerance. This means that the controlled feature can only vary by the tolerance amount per rectangular area of a given size, rather than over the entire feature.

    The tolerance must have been created with the WITH_DEFINED_AREA flag. The parameters are the tolerance and the lengths of both sides of the rectangular area.

    PutToleranceDefinedSquareUnit()

    void Tolerance::PutToleranceDefinedSquareUnit(
    	System::Int64 tol_id,
    	double value1
    	);
    

    The PutToleranceDefinedSquareUnit() function assigns a square area unit basis to a tolerance. This means that the controlled feature can only vary by the tolerance amount per square area of a given size, rather than over the entire feature.

    The tolerance must have been created with the WITH_DEFINED_AREA flag. The parameters are the tolerance and the length of the side of the square area.

    PutToleranceDefinedUnit()

    void PutToleranceDefinedUnit(
    	System::Int64 tol_id,
    	double value
    	);
    

    The PutToleranceDefinedUnit() function assigns a unit basis length to a tolerance, which means that the controlled feature can only vary by the tolerance amount over the given length, rather than over the entire feature.

    The tolerance must have been created with the WITH_DEFINED_UNIT flag. The parameters are the tolerance and the length of the unit basis.

    Int64 callout_id;
    Int64 tol_id = tol->AddTolerancePositionWithFlags(
        callout_id, 0.01, "ABC", WITH_DEFINED_UNIT
        );
    
    tol->PutToleranceDefinedUnit( tol_id, 0.5 );
    

    PutToleranceMax()

    void PutToleranceMax(
    	System::Int64 tol_id,
    	double value
    	);
    

    The PutToleranceMax() function assigns a maximum tolerance value to a tolerance. The tolerance must have been created with the WITH_MAX flag. Use the AddModifierToTolerance() function to give the tolerance either "maximum_material_requirement" or the "least_material_requirement" modifier.

    The parameters are the tolerance and the maximum value.

    Int64 callout_id;
    Int64 tol_id;
    
    //
    // Create tolerance with max. The MAX flag implies WITH_MODS.
    //
    tol_id = tol->AddTolerancePositionWithFlags(
        callout_id, 0.01, "ABC", WITH_MAX
        );
    
    // add a maximum tolerance value and MMC modifier
    tol->PutToleranceMax( tol_id, 0.05 );"
    tol->AddToleranceModifier( tol_id, "maximum_material_requirement" );
    

    PutToleranceMeasuredValue()

    void PutToleranceMeasuredValue(
    	System::Int64 tol_id,
    	double current_value
    	);
    

    The PutToleranceMeasuredValue() function sets the measured value of a tolerance. The value can be computed using a guage or by applying an algorithm to the result of the probing operations that have been applied to the faces in the tolerance.

    Arguments

    tol_id
    The identity of the tolerance
    value
    The measured value

    Related Functions

    Common Errors

    PutTolerancePrecision()

    void PutTolerancePrecision(
    	System::Int64 tol_id,
    	System::Int64 num_digits
    	);
    

    The PutTolerancePrecision() sets the precision of a tolerance value to the number of digits given by setting the tolerance value format type to "NR5 d" where d is the number of digits.

    Arguments

    tol_id
    The identity of the tolerance
    num_digits
    The precision as a number of digits after the decimal point

    Related Functions

    Common Errors

    PutToleranceValue()

    void PutToleranceValue(
    	System::Int64 tol_id,
    	double value
    	);
    

    The PutToleranceValue() sets or corrects the nominal value of a tolerance.

    Arguments

    tol_id
    The identity of the tolerance
    value
    The new nominal value for the tolerance, dimension or surface texture.

    Related Functions

    Common Errors

    PutToleranceValueFormatType()

    void PutToleranceValueFormatType(
    	System::Int64 tol_id,
    	System::String^
    	);
    

    The PutToleranceValueFormatType() sets the precision of a tolerance value to the given string. The string should be formatted as described in Part 45 clause 6.4.14 if possible using the NR5 or NR2 encoding so that the precision can be determined using the GetTolerancePrecision() function.

    Arguments

    tol_id
    The identity of the tolerance
    num_digits
    The required format as a string

    Related Functions

    Common Errors

    PutToleranceUnequal()

    void PutToleranceUnequal(
    	System::Int64 tol_id,
    	double value
    	);
    

    The PutToleranceUnequal() function assigns an unequal disposition to a tolerance. The tolerance must have been created with the WITH_UNEQUAL flag.

    The parameters are the tolerance and the displacement of the unequal disposition.

    Int64 callout_id;
    Int64 tol_id;
    
    
    // Create tolerance with unequal disposition.
    //
    tol_id = tol->AddTolerancePositionWithFlags(
        callout_id, 0.01, "ABC", WITH_UNEQUAL
        );
    
    tol->AddToleranceUnequal( tol_id, 0.007 );
    

    PutToleranceZone()

    void PutToleranceZone(
    	System::Int64 tol_id,
    	System::String zone_type
    	);
    

    The PutToleranceZone() sets the zone type to be measured for a tolerance or dimension. By default a measurement system will assume the zone to be measured is planar. The PutToleranceZone() function allows other types of surfaces to be measured.

    Arguments

    tol_id
    The identity of the tolerance
    num_digits
    The zone which must be one of the strings listed below

    Related Functions

    Common Errors

    PutToolCurrentDiameter()

    void PutToolCurrentDiameter(
    	System::Int64 tl_id,
    	double current_diameter
    	);
    

    The PutToolCurrentDiameter() function sets the new current diameter of a tool. Ideally it is set to the value recommended by the GetToolDiameterAdvice function, but if more than one tolerance depends on the tool then a compromise may be necessary.

    Arguments

    tool_id
    The identity of the tool.
    value
    The new current value for the diameter.

    Related Functions

    Common Errors

    PutToolCurrentLength()

    void PutToolCurrentLength(
    	System::Int64 tl_id,
    	double current_length
    	);
    

    The PutToolCurrentLength() function sets the new current length of a tool. Ideally it is set to the value recommended by the GetToolLengthAdvice function, but if more than one tolerance depends on the tool then a compromise may be necessary.

    Arguments

    tool_id
    The identity of the tool
    value
    The new current value for the length

    Related Functions

    Common Errors

    PutToolCurrentRadius()

    void PutToolCurrentRadius(
    	System::Int64 tl_id,
    	double current_corner_radius
    	);
    

    The PutToolCurrentRadius() function sets the new current radius of a tool. Ideally it is set to the value recommended by the GetToolRadiusAdvice function, but if more than one tolerance depends on the tool then a compromise may be necessary. The tool radius defines a fillet between the tool length and the tool diameter.

    Arguments

    tool_id
    The identity of the tool
    value
    The new current value for the radius.

    Related Functions

    Common Errors

    ResetTolerance()

    void ResetTolerance();
    

    The ResetTolerance() function unsets the measured values of all the tolerances so that they can be measured again. This function should be executed just before or after the part is machined to make sure that all the new measurements are for the new part. It should not be executed before the new tool compensation values have been set.

    Related Functions

    ResetTool()

    void ResetTool();
    

    The ResetTool() function resets the tool dimensions so that the current dimensions are used as the base line for future measurements and compensations. This function should be called immediately after the tool dimensions have been loaded from an ISO 13399 file, and after each round of machining.

    Related Functions

    TakeToolAdvice()

    void TakeToolAdvice();
    

    If there are no conflicts between the corrections required for each tolerance then the TakeToolAdvice() function is the simple way to fix all of the tool compensations because it sets all the compensation registers to the values that will best correct all the errors measured in the tolerances.

    Related Functions

    ToleranceOn()

    System::Int64 ToleranceOn();
    

    The ToleranceOn() function returns a flag indicating if there are any tolerances in the STEP-NC model data. If there are no tolerances then the application need not be concerned with any of the functionality in the tolerance object and may be able to run faster.

    Related Functions

    ToolMonitoringIsOn()

    System::Int64 ToolMonitoringIsOn();
    

    The ToolMonitoringIsOn() function

    ToolMonitoringOff()

    void ToolMonitoringOff();
    

    The ToolMonitoringOff() function

    ToolMonitoringOn()

    void ToolMonitoringOn();
    

    The ToolMonitoringOn() function

    WorkpieceCompleteProbing()

    void WorkpieceCompleteProbing();
    

    When WorkpieceCompleteProbing() function is called, if the STEP-NC model contains three workplans that probe three planes then they are used to compute a three dimensional transformation for the part. If it only contains two then a two dimensional transformation is computed. Otherwise an error is reported. The computed transformation is used to modify any subsequently executed CNC code.

    Related Functions

    Common Errors

    WorkpiecePlacementUsingDatum()

    void WorkpiecePlacementUsingDatum(
    	System::Int64 reference_wp_id,
    	System::String^ datum_select_1,
    	System::Int64 move_wp_id,
    	System::String^ datum_select_2
    	);
    

    The WorkpiecePlacementUsingDatum() function

    WorkpiecePlacementUsingFaces()

    void WorkpiecePlacementUsingFaces(
    	System::Int64 wp_id,
    	System::Int64 face1a_id,
    	System::Int64 face1b_id,
    	System::Int64 face1c_id,
    	System::Int64 face2a_id,
    	System::Int64 face2b_id,
    	System::Int64 face2c_id
    	);
    

    The WorkpiecePlacementUsingFaces() function

    WorkplanSetupPlacementUsingFaces()

    void WorkplanSetupPlacementUsingFaces(
    	System::Int64 plan_id,
    	System::Int64 faceA_id,
    	System::Int64 faceB_id,
    	System::Int64 faceC_id
    	);
    

    The WorkplanSetupPlacementUsingFaces() function