GDK

The Gocator Development Kit (GDK) is a framework for developing and testing custom Gocator tools
containing your own algorithms, and then deploying them to Gocator sensors.

Custom tools created with the GDK act much like native Gocator data output tools (providing
measurements, geometric features, data and generic outputs) with support for multiple input
parameters), running at native speeds and taking advantage of features such as anchoring. The
GDK supports all data types, and tools created with the GDK use the same data visualization as native
tools.

Benefits
When you use the GDK to create custom measurement tools, you have complete control over how and
where your custom measurement tools can be used, which protects your intellectual property.

You can also easily troubleshoot and modify your tools on-site, letting you respond quickly to your
customers' urgent issues.

Supported Sensors
The GDK is available for free for the following Gocator sensors:

Gocator Line Profile Sensors: User Manual 823

 l Gocator 1300 series
l Gocator 2100 series
l Gocator 2300 series
l Gocator 2400 series
l Gocator 2500 series
l Gocator 2880
l Gocator 3210 and Gocator 3500 series

Typical Workflow
The following is the typical workflow for creating and deploying custom measurement tools:

l Develop and build tools using the GDK project files and libraries in Microsoft Visual Studio, targeting
Win32.

l Debug the tools using the emulator on a PC.

l Build the tools into a custom firmware binary.

l Upload the custom firmware to a sensor.

Installation and Class Reference

The GDK project and library files are in the GDK package (14524-x.x.x.xx_SOFTWARE_GDK.zip). To
download the package, go to http://lmi3d.com/support, choose your product from the Product
Downloads section, and download it from the Download Center.

After downloading the package, extract the package to a directory.

You can access full installation and setup instructions, as well as the complete class reference
documentation, by double-clicking the Guide shortcut under the root directory.

Required Tools
The GDK requires Microsoft Visual Studio 2017, as well as various other tools provided in the
GDK Prerequisites package (14525_x.x.x.x_SOFTWARE_GDK_Prerequisites.zip). This package is
available in LMI's Downloads Center (see above for download location).

Getting Started with the Example Code

The best way to get started is with the GDK sample code. You can find the sample projects under
Gocator\GDKSampleApp. This project is ready for you to build and use as a template for new projects.

Start by opening GDK.sln in Visual Studio 2017.

Gocator Line Profile Sensors: User Manual • 824

Building the Sample Code
You can build the sample code for working with either the emulator or a sensor. To do this, choose the
target and then build the solution.

The following targets are available:

l Win32/x64 for debugging code and emulating a sensor to test tools (on a PC)
l Arm7 for building for Gocator 2300C and 2400 series sensors
l C64x for Gocator 1300, 2300A, 2300B, 3210, and 3506 series sensors
The Win32 target supports Debug and Release builds. The Arm7 and C64x targets (sensors) only the
support Release builds.

Tool Registration
For a tool to be available to a user in the sensor web interface, you must add it to the project assembly in
Asm.c.

#include <GdkSampleApp/Asm.h>
#include <GdkSampleApp/TestProfileSelect.h>
#include <GdkSampleApp/TestSurfaceSelect.h>
#include <GdkSampleApp/TestSurfaceConfiguration.h>
#include <GdkSampleApp/TestSurfaceGraphics.h>
#include <Gdk/GdkLib.h>
#include <GoSensor/Version.h>
#include <GoSensorAppLib/GsaDef.h>
#include <GoSensorAppLib/GsaAsm.h>

kBeginAssembly(Tool, ToolAsm, TOOL_VERSION, GOCATOR_VERSION)

kAddDependency(GdkLib)
kAddType(TestProfileSelect)
kAddType(TestSurfaceSelect)
kAddType(TestSurfaceConfiguration)
kAddType(TestSurfaceGraphics)
kEndAssembly()

You can add multiple tools in a GDK project. As seen above, TestProfileSelect,
TestSurfaceSelect, TestSurfaceConfiguration, etc. will be available for users from the drop-
down menu in the Tools panel in sensor's web interface.

Gocator Line Profile Sensors: User Manual • 825

Tool Definitions
You must add standard entry functions (methods) for each tool. The class table declares the entry
functions:

kBeginClass(Tool, TestTool, GdkTool)

kAddVMethod(TestTool, kObject, VRelease)
kAddVMethod(TestTool, GdkTool, VInit)
kAddVMethod(TestTool, GdkTool, VName)
kAddVMethod(TestTool, GdkTool, VDescribe)
kAddVMethod(TestTool, GdkTool, VNewToolConfigInstanced)
kAddVMethod(TestTool, GdkTool, VNewMeasurementConfigInstanced)
kAddVMethod(TestTool, GdkTool, VUpdateConfigInstanced)
kAddVMethod(TestTool, GdkTool, VNewFeatureConfigInstanced)
kAddVMethod(TestTool, GdkTool, VNewToolDataOutputConfigInstanced)
kAddVMethod(TestTool, GdkTool, VIsVisible)
kAddVMethod(TestTool, GdkTool, VCalcDataOutputRegionInstanced)
kAddVMethod(TestTool, GdkTool, VStart)
kAddVMethod(TestTool, GdkTool, VStop)
kAddVMethod(TestTool, GdkTool, VProcess)
kEndClass()

ToolFx (kStatus) TestTool_VDescribe(GdkToolInfo toolInfo)

{
GdkMeasurementInfo mmt;
GdkParamsInfo params;
GdkParamInfo paramInfo;

kCheck(GdkToolInfo_SetTypeName(toolInfo, TEST_PROFILE_SELECT_TOOL_NAME));
kCheck(GdkToolInfo_SetLabel(toolInfo, TEST_PROFILE_SELECT_TOOL_LABEL));

kCheck(GdkToolInfo_SetSourceType(toolInfo, GDK_DATA_TYPE_UNIFORM_PROFILE));

...

The function <Tool Name>_VDescribe describes the tool and its basic configuration. This function is
called during sensor start-up. For more information on entry functions, see Entry Functions below.

Make sure the VDescribe function for each tool is properly formed. Significant issues with this
function (for example, overwriting memory) could prevent the sensor from starting.

You should use the emulator to debug tools before deploying tools to sensors.

Entry Functions
The following table describes the main entry functions.

Function Description

VDescribe Defines the tool's name, data types, acceptable source options, configuration
parameters, and at least one measurement.

VStart Called when the sensor starts running (that is, the user clicks the Run button). The
function gets parameters from GtTool. You typically allocate memory in this function.

VProcess Called every time data is received while the sensor is running.

Gocator Line Profile Sensors: User Manual • 826

Function Description

VStop Called when the user clicks the Stop button.

The TestSurfaceConfiguration example shows how to create and modify parameters based on
other user settings.

For full descriptions of these functions, see the GDK class reference documentation (see Installation and
Class Reference on page 824 for information on installing the documentation).

Parameter Configurations
Each tool has two levels of parameters: tool parameters and measurement parameters.

A tool can contain multiple measurements. In the image above, the Groove tool contains four
measurements: X, Z, Width, and Depth. Each tool has one set of tool parameters and each measurement
in a tool has one set of measurement parameters.

The following table lists the functions that provide advanced or interactive control for setting up tool
and measurement parameters:

Function Description

VNewToolConfig Advanced method for setting default values of tool parameters based on the current
sensor configuration (for example, active area). Called when a new tool is added in the
interface.

Gocator Line Profile Sensors: User Manual • 827

Function Description

VNewMeasurementConfig Advanced method for setting default values of measurement parameters based on the
current sensor configurations (for example, active area). Called when measurements in
a tool is are added in the interface.

VUpdateConfig Advanced method for updating the configuration based on parameters set by users.

For full descriptions of these functions, see the GDK class reference documentation (see Installation and
Class Reference on page 824 for information on installing the documentation).

Graphics Visualization
The GdkGraphic function supports points and lines.

Point graphics

Gocator Line Profile Sensors: User Manual • 828

 Line graphics

To create graphics:
1. Use GdkGraphic_Construct to create a graphic object.

2. Use GdkGraphicPointSet_Construct to create points or GdkGraphicLineSet_Construct to create

lines.

3. Add the points and lines to the graphic object using GdkGraphic_AddPointSet and GdkGraphic_
AddLineSet.

4. Output using GdkToolOutput_SetRendering.

The following illustrates the process:

kTest(GdkGraphic_Construct(&graphic, kObject_Alloc(tool)));

kTest(GdkGraphicPointSet_Construct(&pointSet, 4.0, kMARKER_SHAPE_CROSS, kCOLOR_LIME,

&point32f, 1, kObject_Alloc(tool)));

kTest(GdkGraphic_AddPointSet(graphic, pointSet));

kTest(GdkToolOutput_SetRendering(output, measurementIndex, graphic));

The GDK example TestSurfaceGraphics shows how to use the graphics functions.

Gocator Line Profile Sensors: User Manual • 829

 Graphic functions take an array of kPoint3d32f. It does NOT accept kPoint3d64f.

Debugging Your Tools

We highly recommend using the emulator to debug tools you create with the GDK. By using a sensor
support file and previously recorded scan data, downloaded from a physical sensor, you can completely
simulate standalone and multi-sensor configurations on a PC to test your tools.

To debug your tools in the emulator:

1. Compile your code using the Win32 target (Debug or Release).

2. In the output directory, rename the DLL with the same name as your project to GdkApp.dll.
For example, if your project is called MyGDKTools, the resulting DLL should be called MyGDKTools.dll. You
rename this DLL to GdkApp.dll.
The output directories are as follows:
Release: win32
Debug: win32d

3. Launch the emulator from same output directory as in step 2.

4. In the emulator, choose a scenario and start it.

5. In Visual Studio, attach the debugger to the kFramework.exe process.

Gocator Line Profile Sensors: User Manual • 830

 kFramework.exe is only loaded after a user selects a scenario and starts the emulator
session.

Debugging Entry Functions

VStart, VProcess, and VStop are called whenever a data record is played back in the emulator (that is,
when a user clicks on the Next button or types the frame number in the frame field) with at least one
tool instance. For more information on playback controls, see Recording, Playback, and Measurement
Simulation in the Gocator user manual.

VDescribe however is called when the DLL loads, before the debugger can attach to the
kFramework.exe process. To debug VDescribe, we recommend testing the function calls by putting
them in VInit.

For information on building targets for testing in the emulator, see the GDK class reference
documentation.

Tips
The following sections provide useful information for creating custom measurement tools.

Backward Compatibility with Older Versions of Tools

When loading a recording or job file that contains a custom measurement tool, the parameters in the
loaded recording or job file must match those in the firmware.

By default, if declared parameters are missing from the configuration, a job file or a recording will fail to
load.

There are two ways to provide backward compatibility with older parameter sets.

Define new parameters as optional

Mark a parameter as optional with the function GdkParamInfo_SetIsOptional. When a parameter is
marked as optional, parameter parsing functions succeed even if the parameter is missing from the
configuration. The missing parameter is initialized with default value.

Configuration Versioning
Over the lifetime of a tool, you may need to make changes to its interface (for example, changing or
removing parameters). The user-defined aspects of a tool interface—its parameters and

Gocator Line Profile Sensors: User Manual • 831

measurements—are captured by GDKToolVersionInfo objects.

By default, a tool has just one version (GdkToolInfo_FirstVersion), but more versions may be
added using GdkToolInfo_AddVersion. Whenever the interface of a tool has changed, a new version
can be registered so that the new interface can be correctly parsed by the framework.

When the configuration of a tool instance is saved, the version used at the time is also saved. This saved
version is used by the framework to parse the configuration. If a version is not defined by the firmware
implementation, then that tool instance will not be active.

During run-time, you can query the version of the configuration of a tool instance by using
GdkToolCfg_Version. You can then interpret the parameters depending on the version the
configuration is saved in.

GdkFx(kStatus) GdkExampleTool_VDescribe(GdkToolInfo info)

{
kCheck(GdkToolInfo_SetLabel(info, "Example"));

kCheck(GdkToolInfo_SetSourceType(info, GDK_DATA_TYPE_UNIFORM_PROFILE));
kCheck(GdkToolInfo_AddSourceOption(info, GDK_DATA_SOURCE_TOP));

kCheck(GdkExampleTool_DescribeV0(info));
kCheck(GdkExampleTool_DescribeV1(info));

kCheck(GdkToolInfo_SetDefaultVersion(info, GdkToolInfo_VersionAt(info, 1)));

return kOK;
}

GdkFx(kStatus) GdkExampleTool_DescribeV0(GdkToolInfo info)

{
kCheck(GdkParamsInfo_Add(GdkToolInfo_Params(info), "RefRegion", GDK_PARAM_TYPE_PROFILE_
REGION, "Ref Region", kNULL));
kCheck(GdkParamsInfo_Add(GdkToolInfo_Params(info), "Region", GDK_PARAM_TYPE_PROFILE_
REGION, "Region", kNULL));
kCheck(GdkToolInfo_SetFirstVersionName(info, ""));

return kOK;
}

GdkFx(kStatus) GdkExampleTool_DescribeV1(GdkToolInfo info)

{
GdkToolVersionInfo versionInfo;

// Auto-version

kCheck(GdkToolInfo_AddVersion(info, kNULL, &versionInfo));

kCheck(GdkToolVersionInfo_UseBase(versionInfo, GdkToolInfo_FirstVersion(info)));
kCheck(GdkParamsInfo_AddFloat(GdkToolVersionInfo_Params(versionInfo), "BaseScale",
kNULL, 2.0, kNULL));

return kOK;
}

Gocator Line Profile Sensors: User Manual • 832

Adding a new measurement does not require special handling. The new measurement is just not
instantiated in a previous configuration.

Version
You can define the version number of your tools in Asm.x.h.

#define TOOL_VERSION kVersion_Stringify_(1, 0, 0, 23)

The version is displayed on the Manage page, in the Support category.

Common Programming Operations

The following sections describe common programming operations.

Input Data Objects

The VProcess function receives a GdkToolInput object as input. This object is a container where the
information and actual data of the received input is stored.

GdkInputItem item = GdkToolInput_Find(input, obj->dataSource);

GdkDataInfo itemInfo = GdkInputItem_Info(item);

The GdkToolInput_Find and GdkInputItem_Info functions are used to extract the item and info
objects. These objects can then be used to retrieve the input data and information (for example, offset
and resolution) associated to the input. The following are some examples:

Computing actual height information using offset and scale

Gocator Line Profile Sensors: User Manual • 833

k64f height = rangeSrc[index] * scale->z + offset->z;

Extracting height information from profiles and surfaces.

The TestProfileSelect and TestSurfaceSelect examples show how to perform these

operations.

Setup and Region Info during Tool Initialization

Memory allocation is often done in the VInit or VStart function. To retrieve sensor and data
information such as active area settings and data scale outside of VProcess, you can use the following
function:

GdkDataInfo info = GdkSensorInfo_DataSource(GdkTool_SensorInfo(tool), GDK_DATA_SOURCE_

TOP);

Computing Region Based on the Offset from an Anchor Source

Just like built-in measurement tools, custom tools created with the GDK can be anchored to another tool
(GDK-based tools or built-in tools).

To compute the offset region:

TestToolClass* obj = TestTool_Cast_(tool);

GdkParams params = GdkToolCfg_Parameters(config);
const kPoint3d64f* anchor = GdkToolInput_AnchorPosition(input);
GdkRegionXZ64f offsetRegion = { k64F_NULL, k64F_NULL, k64F_NULL, k64F_NULL };

param = GdkParams_Find(params, "Region");

obj->region = *GdkParam_AsProfileRegion(param);

offsetRegion = obj->region;
offsetRegion.x += anchor->x;
offsetRegion.z += anchor->z;

In the code above, we first retrieve the tool’s region settings (before anchoring is applied), and then
adjust the region based on the results from the anchored source in VProcess. If the anchored source
fails, the tools will not be invoked.

The TestProfileSelect and TestSurfaceSelect examples show how to extract height

information from anchored regions.

For more information on anchoring, see Measurement Anchoring in the Gocator user manual.

Part Matching
When part matching is enabled, the tool receives translated and corrected surface data. If part matching
fails for the current scan (for example, the quality score is too low), the tools will not be invoked.

For more information on part matching, see Part Matching in the user manual.

Accessing Sensor Local Storage

You can access a sensor's local storage by using the kFile API.

For example, to read and write a file to a sensor's storage, you could use the following:

Gocator Line Profile Sensors: User Manual • 834

#include <kApi/Io/kFile.h>

ToolFx(kStatus) TestTool_VStart(TestTool tool)

{
…

kFile_Save("test.txt", stringBuf, (kSize) 1024);

kFile_Load("test.txt", stringBuf, &bufLen, kNULL);

Print Output
In the emulator, you can send output to Visual Studio or to programs such as DebugView by using the
OutputDebugString function.

GtsFx(kStatus) TestTool_Trace(const kChar* format, ...)

{
kStatus status = kOK;
kChar debugLine[256];

kVarArgList argList;
kVarArgList_Start_(argList, format);
{
status = kStrPrintvf(debugLine, 256, format, argList);
}
kVarArgList_End_(argList);
OutputDebugStringA(debugLine);
return status;
}

OutputDebugString is NOT supported on sensor targets. Use #ifdef to comment out the code
when compiling against sensor targets.

Gocator Line Profile Sensors: User Manual • 835

Tools

The following sections describe some of the tools provided with a Gocator sensor, as well as the
CSV format that a sensor can export. For information on the integrations available with a sensor, see
Integrations on page 647.

l Sensor Discovery Tool: Used to find sensors on a network. See Sensor Discovery Tool below.

l CSV Converter Tool: Used to convert CSV data exported from a sensor to several formats. See CSV
Converter Tool on the next page.

l Bandwidth Tool: Use this tool to diagnose bandwidth-related issues.

Sensor Discovery Tool

If a sensor's network address or administrator password is forgotten, the sensor can be discovered on
the network and/or restored to factory defaults by using the Sensor Discovery software tool. This tool
can be obtained from the downloads area of the LMI Technologies website: http://www.lmi3D.com.

After downloading the utility package [14405-x.x.x.x_SOFTWARE_GO_Utilities.zip], unzip the file and run
the Sensor Discovery Tool [Tools > Discovery > kDiscovery.exe].

Any sensors that are discovered on the network will be displayed in the Devices list.

To change the network address of a sensor:

1. Select the Custom option.

2. Enter the new network address information.

3. Click Set Address.

Gocator Line Profile Sensors: User Manual 836

To restore a sensor to factory defaults:

1. Select the sensor serial number in the Devices list.

2. Press the Factory Restore... button.

Confirm when prompted.

The Sensor Discovery tool uses UDP broadcast messages to reach sensors on different subnets.
This enables the Sensor Discovery tool to locate and re-configure sensors even when the sensor IP
address or subnet configuration is unknown.

CSV Converter Tool

The CSV Converter tool lets you convert data exported from a Gocator sensor in the CSV format to
several formats (see table below). For more information on exporting recorded data, see Downloading,
Uploading, and Exporting Replay Data on page 92.

For information on the CSV file format that the sensor exports, see the next section.

The tool supports data exported from Profile or Surface mode.

To get the utility package (), go to http://lmi3d.com/support, choose your product from the Product
Downloads section, and download it from the Download Center.

After downloading the tool package, unzip the file and run the Gocator CSV Converter tool [Tools
> CSV Converter > kCsvConverter.exe].

The tool supports the following output formats:

Output formats
Format Description

ASCII (XYZI) Comma-separated points in X, Y, Z, Intensity (if available)

format.

16-bit BMP Heightmap with 16bit height values in a 5-5-5 RGB image.
Not intended for visualization.

Gocator Line Profile Sensors: User Manual Tools • 837

Format Description

16-bit TIFF Heightmap as grayscale image.

16-bit PNG Heightmap as grayscale image.

GenTL RGB For more information, see 16-bit RGB Image on page 797

GenTL Mono For more information, see 16-bit Grey Scale Image on

page 798.

Raw CSV LMI Gocator CSV format for a single frame.

HexSight HIG LMI HexSight heightmap.

STL ASCII Mesh in standard STL text format (can become very large).

STL Binary Mesh in binary STL format.

Wavefront OBJ Mesh with comma-separated vertices and facets in text

format.

ODSCAD OMC ODSCAD heightmap.

MountainsMap SUR DigitalSurf MountainsMap heightmap.

24-bit Spectrum Color spectrum bitmap for visualization of heightmap.

Does not contain height values.

With some formats, one or more of the following options are available:

Output options
Option Description

Scale Z Resamples the Z values to use the full value range.

Swap X/Y Swaps the X and Y axes to obtain a right-handed

coordinate system.

Keep Aspect Ratio Resamples the X and Y axes to obtain the proper aspect
ratio.

The GenTL format is a 48-bit RGB or grey scale PNG. Height map, intensity and stamp
information are stored as defined in the GenTL Driver section (GenICam GenTL Driver on
page 793). You can load the exported data into image processing software to provide simulation
data for developing applications using the GenTL driver.

To convert exported CSV into different formats:

1. Select the CSV file to convert in the CSV field.

2. (Optional) If intensity information is required, check the Intensity box and select the intensity bitmap.
Intensity information is only used when converting to ASCII or GenTL format. If intensity is not selected,
the ASCII format will only contain the point coordinates (XYZ).

3. If a dual-sensor system was used, choose the source sensor next to Image.

4. Select the output format.

For more information on output formats, see Output formats on the previous page.

Gocator Line Profile Sensors: User Manual Tools • 838

5. (Optional) Set the Scale Z, Swap X/Y, and Keep Aspect Ratio options.
Availability of these options depends on the output format you have chosen. For more information, see
Output options on the previous page.

6. Click Convert.
The converter converts the input files.
The converted file will be in the same directory as the input file. It will also have the same name as the
input file but with a different file extension. The converted file name is displayed in the Output File
field.

CSV File Format

The CSV Converter tool can convert from the CSV format that a sensor can export to several other
formats. If you want to work with the exported file directly, use the following information.

An exported CSV file contains a series of "sections." Each section begins with a row containing the name
of the section, and ends with a row containing the string "End." An empty line separates each section.

Each section usually contains one or more subsections. Each subsection has a header row containing a
list of field names, followed by one or more rows of data. There is usually no empty line between the
subsections.

Other structures within sections are possible.

Example:

Info
CSV Version,Sensor Count,Trigger Mode,...
2,1,0,32000.00000,...
End

DeviceInfo
ID,Model,Version,...
13434,311320-2M-01,4.8.2.29,...
End

Ranges
...
End
Usually all available data in the recording buffer is exported. The exceptions are Surface and
SurfacePointCloud. For these sections, only the currently selected frame is exported.

Info
This section contains basic system information. It has one header row and one value row. The fields are
described below:

Gocator Line Profile Sensors: User Manual Tools • 839

Info Fields
Field Description

CSV Version Version of the CSV file format.

Sensor Count Number of sensors in the system.
Trigger Mode Trigger source:
0 – Time
1 – Encoder
2 – Digital input
3 – Software

Trigger Rate Frame rate for time trigger (Hz).

Trigger Delay Domain Output delay domain:
0 – Time (µs)
1 – Encoder (mm)

Trigger Delay Output delay (µs or mm, depending on delay domain defined above).
Operation Mode The scan mode.
XResolution System X resolution (mm).
YResolution System Y resolution (mm).
ZResolution System Z resolution (mm).
Yspeed Y Speed (mm/s).
Layout Sensor orientation:
0 – Normal (single-sensor system) / Wide (dual-sensor system)
1 – Opposite
2 – Reverse
3 – Grid

DeviceInfo
This section contains information about each device in the system. There is one header row, and one
value row per device.

DeviceInfo Fields
Field Description

ID Device serial number

Model Device part number
Version Firmware version
Exposure Mode Exposure mode:
0 – Single exposure
1 – Multiple exposures
2 – Dynamic exposure

Exposure 0 through Exposure 4 Multiple exposures

Gocator Line Profile Sensors: User Manual Tools • 840

Field Description

Exposure Min Dynamic exposure min

Exposure Max Dynamic exposure max
FOV X Active area X
FOV Y Active area Y
FOV Z Active area Z
FOV Width Active area width
FOV Height Active area length (Y). (Note difference in terminology.)
FOV Depth Active area height (Z). (Note difference in terminology.)
Transform X Transform X offset (mm)
Transform Y Transform Y offset (mm)
Transform Z Transform Z offset (mm)
Transform X Angle Transform X Angle (degrees)
Transform Y Angle Transform Y angle (degrees)
Transform Z Angle Transform Z angle (degrees)

RecordingFilter
This section lists the filters used during recording. Unlike the other sections, it contains multiple sub-
sections within, separated by spaces (but not the “End” keyword).

Example:

RecordingFilter
Section1 Param 1, Section1 Param2
value, value
Section2 Param 1
value
Section3 Param1, Section3 Param2
value
End
Each section will be described by a separate table below. They appear in the same order as documented.

RecordingFilter Fields
Field Description

Condition Combination Type Any or All

"Any Measurement" Filter Fields

Field Description

Type Any Measurement

Enabled Whether or not is enabled. Yes/No
Result Accepted result type: Pass/Fail/Invalid/Valid

Gocator Line Profile Sensors: User Manual Tools • 841

"Any Data" Filter Fields
Field Description

Type Any Data

Enabled Whether or not is enabled: Yes/No
Threshold Case How to threshold: At or Above, or Below
Range Count Threshold Threshold value (point count)

"Measurement" Filter Fields

Field Description

Type Measurement
Enabled Whether or not is enabled: Yes/No
Result Accepted result type: Pass/Fail/Invalid/Valid
Selection ID First measurement ID

Ranges
This section describes single-point range data. It has two sub-sections: attributes and data.

The attribute section has only one row of data

Attribute Section Fields

Field Description

Frame Count Total number of frames

X Offset X offset (mm)
Y Offset Y offset (mm)
Z Offset Z offset (mm)

The data section has one or more rows of data per frame (for example, range and intensity).

Data Section Fields

Field Description

Frame Frame index

Source Source (for example, 0 for Top)
Time Stamp time
Encoder Stamp encoder
Z Encoder Stamp encoder Z
Inputs Stamp inputs
Exposure Stamp exposure (us)
Y Y value (mm)
Axis Axis: Z (range) or I (Intensity)
Value Range value (mm) or intensity (count)

Profile
This section describes uniform (or resampled) profile data, which is produced when the sensor is in

Gocator Line Profile Sensors: User Manual Tools • 842

Profile mode and uniform spacing is enabled. It has two sub-sections: attributes and data.

The attribute section has only one row of data.

Attribute Section Fields

Field Description

Frame Count Total number of frames

Column Count Number of columns
X Offset X offset (mm)
Y Offset Y offset (mm)
Z Offset Z offset (mm)

The data section has one or more rows of data per frame (for example, range and intensity).

Data Section Fields

Field Description

Frame Frame index

Source Source (for example, 0 for Top)
Time Stamp time
Encoder Stamp encoder
Z Encoder Stamp encoder Z
Inputs Stamp inputs
Exposure Stamp exposure (µs)
Y Y value (mm)
Axis Axis: Z (range) or I (Intensity)
(x values) Each column in header is a resampled X position
Each column in data is the range (mm) or intensity (count)

RawProfile
This section describes point cloud profile data (or unresampled / raw data), which is produced when the
sensor is in Profile mode and uniform spacing is disabled. It has two sub-sections: attributes and data.

The attribute section has only one row of data.

Attribute Section Fields

Field Description

Frame Count Total number of frames

Column Count Number of columns
X Offset X offset (mm)
Y Offset Y offset (mm)
Z Offset Z offset (mm)

The data section has one or more rows of data per frame (for example, range and intensity).

Gocator Line Profile Sensors: User Manual Tools • 843

Data Section Fields
Field Description

Frame Frame index

Source Source (for example, 0 for Top)
Time Stamp time
Encoder Stamp encoder
Z Encoder Stamp encoder Z
Inputs Stamp inputs
Exposure Stamp exposure (µs)
Y Y value (mm)
Axis Axis: X, Z, or I (Intensity)
(x values) Each column in header is an index.
Each column in data is the X/Z value (mm) or intensity (count)

Part
This section describes uniform (or resampled) surface data, which is produced when the sensor is in
Surface mode and uniform spacing is enabled.

Only the data for the frame currently selected in the UI is exported when you export part data to
a CSV file.

The section has two sub-sections: attributes and data.

The attribute section has only one row of data.

Attribute Section Fields

Field Description

Frame Frame index

Source Source (for example, 0 for Top)
Time Stamp time
Encoder Stamp encoder
Z Encoder Stamp encoder Z
Inputs Stamp inputs
Row Count Number of rows
Column Count Number of columns
X Offset X offset (mm)
Y Offset Y offset (mm)
Z Offset Z offset (mm)

The data section contains the data of a single surface scan. Each data row corresponds to one Y position.
The first row contains the X values, and the first column contains the Y values. The region inside contains
the range values (mm) for the corresponding row and column.

Gocator Line Profile Sensors: User Manual Tools • 844

Surface Section
This section describes surface section data, which is produced when a section is added to uniform
surface data. A surface section is similar to a uniform profile.

The data section contains the following fields.

Data Section Fields

Field Description

Frame Frame Index

Source Source (e.g. 0 for Top)
Time Stamp time
Encoder Stamp encoder
Z Encoder Stamp encoder Z
Inputs Stamp inputs
Exposure Exposure
Column Count Number of columns
Start X X Start
Start Y Y Start
End X X End
End Y Y End
Pose Angle Pose Angle
Pose X Pose X Offset
Pose Y Pose Y Offset
X Offset X Offset
Y Offset Y Offset
Z Offset Z Offset
XResolution X Resolution
ZResolution Y Resolution
Axis Axis: Z (range) or I (Intensity)
(x values) Each column in header is a resampled X position
Each column in data is the range (mm) or intensity (count)

Gocator Line Profile Sensors: User Manual Tools • 845