\\.\RiPT0
on Windows NT (Windows 2000) to access the device driver\\.\ECP0
on Windows 95/98 to directly access the port hardware in ECP mode\\.\LPT0
on Windows 95/98 to directly access the port hardware in bidirectional mode//hostname:servicename
on all platforms to establish a TCP/IP connectionSCN_MFRAMESTART
to enable the SCN_FRAMESTART message.SCN_MLINE
to enable the SCN_LINE message.SCN_MFRAME
to enable the SCN_FRAME message.WM_USER
,
but you are free to use any other value in case it interferes with your software. (WM_USER
is
defined as the numerical value of 1024 in the system header files of windows.)
\\.\
followed by the name of the device, which may
be one of RIPT ECP LPT
followed by a numerical identifier of the respective port. On
Windows NT/2000 you specify the mapping between this number and the port hardware in the driver
settings of RiPort device driver. On Windows 95/98 (where no device driver is used) the number 0
corresponds to address 0x378 (LPT1) and number 1 to address 0x278 (LPT2). Please
note: since on the Windows 95/98 platform no device driver is used, there is the potetial of resource
conflicts when accessing the port. Also the processor load will be rather high since no interrupts are
used and the port has to be polled constantly. So you should either use the Windows 2000 platform or
consider using a IB90ETH network unit.//
. You may omit the host and service names in which
case a default of ib90eth:scandata will be used. The mapping between hostnames and IP addresses
will depend on the network setup of your machine, as is the mapping between service name and port numbers.
(Usually they are defined in the hosts and services files.) It is possible however to directly specify
an IP address / port number pair e.g. 192.168.11.222:20001, in which case there is no need for
hosts and services files.wParam
and lParam
parameter. The wParam
contains the scanner
messages as defined in this document. The lParam
contains message specific information
such as current line number, frame number or error number. You have some control on the messages
sent to your window by specifying the uMsgType parameter: Specifying the respective constants
selects the respective messages to be sent. E.g. to enable a message on frame start and one on the end of
the frame you would specify SCN_MFRAMESTART | SCN_MFRAME
(assuming you are using the
C programming language).SCN_OPEN
message.Open, Close
and NextFrame
calls will wait until the operation has been completed. This mode is useful,
if you do not have a window handle, e.g. when calling from a console application or from a worker thread.
However, you will not be able to access the internal buffer before a complete frame has been read in. You
shoul avoid calling other functions while one of the pending operations is in progress, since this will
result in errors. Also an end of file condition will be reported as an error in this case.\\.\RiPT0
on Windows NT (Windows 2000) to access the device driver\\.\ECP0
on Windows 95/98 to directly access the port hardware in ECP mode\\.\LPT0
on Windows 95/98 to directly access the port hardware in bidirectional mode\\.\COM1:19200
specifiy the serial port. In this example COM1 with 19200 Baud//hostname:servicename
on all platforms to establish a TCP/IP connection\\.\COM1:19200
specifiy the serial port. In this example COM1 with 19200 Baud//hostname:servicename
on all platforms to establish a TCP/IP connection to
the command port.SCN_MFRAMESTART
to enable the SCN_FRAMESTART message.SCN_MLINE
to enable the SCN_LINE message.SCN_MFRAME
to enable the SCN_FRAME message.WM_USER
,
but you are free to use any other value in case it interferes with your software. (WM_USER
is
defined as the numerical value of 1024 in the system header files of windows.)
wParam = HIWORD(MESSAGE), LOWORD(wId)
.wParam = HIWORD(0), LOWORD(MESSAGE)
.
You can use this to have one window handling messages from multiple scanner sources, each
of which is identified by wId.
SCN_CLOSE
message.SCN_LOGSTARTED | signals the actual start of logging |
SCN_LOGSTOPPED | logging has stopped |
0
(or FALSE
) when you want to
pause logging. To reenable logging set to 1
(or TRUE
).
SCN_LOGSTARTED
is sent. Logging continues till
either you specify the nOn to be FALSE
in a further call to Log(FALSE)
or
close the connection. However in the first case the logging will stop on a succesfully received frame
i.e in sync with a SCN_FRAME
message, whereas in the second the log will close after the
last successully received scan line. When logging actually stops you will receive a SCN_LOGSTOPPED
message.
SCN_FRAMESTART | lParam: FrameNumber | signals start of a frame. |
SCN_LINE | lParam: LineNumber | signals receipt of a line. |
SCN_FRAME | lParam: FrameNumber | signals end of a frame |
SCN_EOF | signals end of file condition (applies to disk files) |
NextFrame
instructs the library to begin filling its internal framebuffer. You
will receive notification messages about the progress. SCN_FRAMESTART
is beeing sent
when the start of a frame is detected. SCN_LINE
is beeing sent on each received line, and
SCN_FRAME
is sent at the end of the frame. Filling of the buffer automatically stops at
this point. To acquire the following frame another NextFrame
call is required.SCN_FRAMESTART
message not necessarily is the first message you will receive after
a NextFrame
call. There may be a couple of SCN_LINE
messages before the
begin of a frame is detected. You could make use of this to get a 'life' display of the current scanning
head activity. However it is guaranteed, that the SCN_FRAMESTART
message comes before
any SCN_LINE
messages belonging to the respective frame. Also the SCN_FRAME
message is beeing sent after the last SCN_LINE
of the respective frame.SCN_LINE
messages contain valid data. All others retreive data having range set to zero (or
SetInfinity).SCN_EOF
message relates to the physical end of disk files. On receipt of this messages
no further NextFrame
calls will be possible. However the data buffer contains valid data
up to the line where this message has been received.
NextFrame
to continue acquisition unconditionally.
SCN_MODE_FILTER_NOTARGET
SCN_MODE_COLOR_NATIVE
SCN_MODE_COLOR_CONTRAST
SetMode
command affects the operational mode of the library.SCN_MODE_FILTER_NOTARGET
is specified the data retrieval functions
return only measurement points that correspond to a valid target. You would specify
this option if you need point clouds with illegal points removed. Note however, that the
rectangualar grid structure of the scandata is destroyed, when using this option. The Get*
functions will report the actual returned number of points via the pnTransferred parameter.SCN_MODE_COLOR_NATIVE
and SCN_MODE_COLOR_CONTRAST
influence the operation of the GetRGB
call. The first causes unprocessed data
to be delivered while the second prerocesses data to enhace the contrast of the image. Contrast
enhancement also is the default mode.
SCN_MODE_FILTER_NOTARGET
available.
SetMode
calls.
SCN_LINE
messages have been received
all are marked as invalid points and as such are retrieved as lying on this sphere.pnLinesPerImage
and pnMeasPerLine
are pointers to variables that receive the
number of lines and measurements per line respectively.*pnMeasPerLine
data points make
a line of the frame. The second (slower) index refers to the line number. The entire frame consists of
*pnLinesperImage
lines. You may however address the data buffer in a different manner, namely
as a single huge one dimensional array (or any part of it). This single array has a total size of
*pnLinesperImage
times *pnMeasPerLine
.GetVertex
call the transformation is applied by default.
(See also GetVertex to obtain local coordinates.)GetMatrix
call retrieves the transformation matrix. You might do this
to get the scanner position, or to do the transformation in the application program. The latter
would be necessary when you have large transformation offset values. In that case a floating
value might have not enough precision to hold the transformed data. (GetVertex retrieves only
float values.)y0 = M0*x0 + M4*x1 + M8*x2 + M12 | y1 = M1*x0 + M5*x1 + M9*x2 + M13 |
y2 = M2*x0 + M6*x1 + M10*x2 + M14 |
SCN_CARTESIAN
or SCN_POLAR
.
SCN_LOCAL
).
GetVertex
call retrieves geometry data from the internal buffer and performs polar to
cartesian conversion. (specified by SCN_CARTESIAN
or SCN_POLAR
)
The scanner data might optionally be offset (and rotated) by a coordinate transform. You will receive
data with this transform already applied. If you do not want the data to be transformed you need to combine
the type code with SCN_LOCAL
, which retrieves the vertex data in the scanners local
coordinate system. E.g.: SCN_LOCAL|SCN_CARTESIAN
to retrieve local cartesian coordinates.
This internal buffer is formatted
in the binary format of the respective scanner type. Depending on this type there might be 3-D, 2-D or
1-D information available. Despite this fact it is always possible to retrieve data in any dimensionality.
In cases where you request a higher dimension, than the device provides, the missing coordinates are filled
with constant values. This is done in such a way that provides a consistent coordinate system. Requesting
lower dimensionality than the unit is capable of, results in elimination of some coordinates:nSizenCount
elements. The GetVertex
call tries to fill in nCount
vertices, but stops, should
you try to request elements beyond the end of the buffer. The count of actually transfered items is returned
via a variable that pnTransfered
is pointing to. The elements of the returned vertex array are
ordered according to Table 1. E.g. x1, y1, z1, x2, y2, z2, x3, ...GetVertex | Instrument dimensionality | |||
---|---|---|---|---|
nSize | uType | 1-D | 2-D | 3-D |
1 | SCN_POLAR | ( r ) | ( r ) | ( r ) |
SCN_CARTESIAN | ( x ) | ( x'' ) | ( x'' ) | |
2 | SCN_POLAR | ( r, p/2 ) | ( r, J ) | ( r, J ) |
SCN_CARTESIAN | ( x, 0 ) | ( x, z ) | ( x', z ) | |
3 | SCN_POLAR | ( r, 0, p/2 ) | ( r, 0, J ) | ( r, j, J ) |
SCN_CARTESIAN | ( x, 0, 0 ) | ( x, 0, z ) | ( x, y, z ) |
![]() |
|
NULL
for the rgVertex parameter you, the call
will process as normal, but without returning any data. In particular the pnTransfered
will reflect the correct amount. You may use this to obtain the number of memory needed
when you apply the SCN_MODE_FILTER_NOTARGET
mode.
GetStdDev
call retrieves standard deviation values for the range (and angle) measurement from
the internal buffer.
You have to provide a pointer to a floating point array of nSizenCount
elements. The GetStdDev
call tries to fill in nCount
values, but stops, should
you try to request elements beyond the end of the buffer. The count of actually transfered items is returned
via a variable that pnTransfered
is pointing to.
NULL
for the rgStdDev parameter you, the call
will process as normal, but without returning any data. In particular the pnTransfered
will reflect the correct amount. You may use this to obtain the number of memory needed
when you apply the SCN_MODE_FILTER_NOTARGET
mode.
nCount
elements. The GetIntensity
call tries to fill in nCount
intensity values, but stops, should you try to request elements beyond
the end of the buffer. The count of actually transfered items is returned via a variable that pnTransfered
is pointing to.
NULL
for the rgIntensityparameter you, the call
will process as normal, but without returning any data. In particular the pnTransfered
will reflect the correct amount. You may use this to obtain the number of memory needed
when you apply the SCN_MODE_FILTER_NOTARGET
mode.
3nCount
elements. The
GetRGB
call tries to fill in nCount
RGB values, but stops, should you try to
request elements beyond the end of the buffer. The count of actually transfered items is returned via a
variable that pnTransfered
is pointing to.
SetMode
)
You can switch off this behaviour to obtain native data if desired.
NULL
for the rgRGB parameter you, the call
will process as normal, but without returning any data. In particular the pnTransfered
will reflect the correct amount. You may use this to obtain the number of memory needed
when you apply the SCN_MODE_FILTER_NOTARGET
mode.
nCount
elements. The
GetTime
call tries to fill in nCount
time values, but stops, should you try to
request elements beyond the end of the buffer. The count of actually transfered items is returned via a
variable that pnTransfered
is pointing to.
NULL
for the rgTime parameter you, the call
will process as normal, but without returning any data. In particular the pnTransfered
will reflect the correct amount. You may use this to obtain the number of memory needed
when you apply the SCN_MODE_FILTER_NOTARGET
mode.
double
array of nCount
elements. The
GetTime
call tries to fill in nCount
time values, but stops, should you try to
request elements beyond the end of the buffer. The count of actually transfered items is returned via a
variable that pnTransfered
is pointing to.
NULL
for the rgTime parameter you, the call
will process as normal, but without returning any data. In particular the pnTransfered
will reflect the correct amount. You may use this to obtain the number of memory needed
when you apply the SCN_MODE_FILTER_NOTARGET
mode.
GetRawInfo
is a helper function for GetRawHeader
and GetRawData
.
This values are the nCount
parameters you should specify in calls to these functions.
SCN_POLAR
in the GetVertex
call, since there are scanner dependent
corrections necessary to get true spherical data.
SCN_ERROR
).
The library has a sticky error behaviour. e.g. the first error is locked until you call this fuction,
which resets the error condition.GetErrNmb
is equal to the lParam
value that
you have received with the SCN_ERROR
message there have been no additional errors.Open
function.SCN_ERROR_NOERROR | No error |
SCN_ERROR_CANNOT_OPEN | Cannot open |
SCN_ERROR_CANNOT_READ | Cannot read |
SCN_ERROR_UNKNOWN_HEADER_ID | Unknown header ID |
SCN_ERROR_UNKNOWN_TRAILER_ID | Unknown trailer ID |
SCN_ERROR_UNKNOWN_MEAS_ID | Unknown measurement ID |
SCN_ERROR_UNKNOWN_PARM_ID | Unknown parameter ID |
SCN_ERROR_NOMEM | Cannot allocate memory |
SCN_ERROR_SYNC_LOST | Synchronization lost |
SCN_ERROR_NODATA | No data |
SCN_ERROR_EDOM | Argument out of function's domain |
SCN_ERROR_CREATE_LOG | Could not create log file |
SCN_ERROR_DEMO_MODE | Requested operation is not licensed |
SCN_ERROR_EOF | End of file |
SCN_ERROR_ASYNC_CALL | Unexpected behaviour, likely related to async call |
GetErrNmb
to reset the error.
The strings are stored in a windows resource that is located in scannermod.dll
and therefore
automatic language conversion will take place when possible.
SCN_SIMPLE
.
indexA1, indexB1, indexC1, indexA2, ...
where A,B,C constitute a single triangle, which has an orientation that is oriented counter clockwise.3*uCount*sizeof(UINT)
. To get the needed
buffersize in advance you may call the function with rgnTriangles=NULL. pnTransfered will
return the total number of triangles available. However this method is slower, than supplying a buffer
of size uCount=2*(nLinesPerImage-1)*(nMeasPerLine-1), and then throwing away the excess memory. IScanInfo
interface gives you access to the sync-time and current setting of the epoch
as well. The format of the epoch string is:YYYY-MM-DDTHH:MM:SS