basler_fg.h File Reference |
||
|
Header file for all functions exported. More... #include <stdint.h>#include <sys/types.h>#include "fg_struct.h"#include "fg_define.h"#include "fg_error_codes.h"#include "os_type.h"#include "os_funcs.h"#include "SisoDisplay.h"Go to the source code of this file.
Detailed DescriptionHeader file for all functions exported. Copyright (c) 2021-2024 Basler AG, All Rights Reserved. Macro Definition Documentation◆ PUBLIC_API
Typedef Documentation◆ dma_memDMA buffer head control object. A variable of this type contains the control information for DMA buffers. Take this as an opaque value and just pass it around to the functions that need it. ◆ ShadingMasterShading control object. A variable of this type contains the control information for a specific shading set. Take this as an opaque value and just pass it around to the functions that need it. Function Documentation◆ DEPRECATED() [1/3]
The function int Fg_setExsync() explicitly allows a switch to on and off of the exsync signal to the camera.
This function can only be used with acquisition applets. VisualApplets generated applets do not use this interface. Please refer to the VisualApplets operator manual for documentation for trigger operators. ◆ DEPRECATED() [2/3]
The function int Fg_setFlash() explicitly allows a switch to on and off of the strobe signal.
This function can only be used with acquisition applets. VisualApplets generated applets do not use this interface. Please refer to the VisualApplets operator manual for documentation for trigger operators. ◆ DEPRECATED() [3/3]
stub to maintain interface compatibility
◆ Fg_AbortInitLibraries()
The function Fg_AbortInitLibraries() aborts and fails the initialization of internal structures and the synchronization of the startup of the application(s). . This function aborts the initialization of internal structures in the library and interrupts any pending synchronization that is requested by the user calling Fg_InitLibraries() or Fg_InitLibrariesEx(). This function can be called from within a signal handler or any other mechanism that terminates the application asynchronously to make sure the main thread will not hang indefinitely. If the call to Fg_InitLibraries() or Fg_InitLibrariesEx() was aborted, those functions will return FG_OPERATION_ABORTED. ◆ Fg_Acquire()
The function Fg_Acquire() starts a continuous grabbing. Having started the exact number of images will be grabbed (PicCount). If a timeout occurs, the grabbing will be stopped. If a continuous grabbing with manual stopping is needed (explicit stopping of the grabbing with Fg_stopAcquire()), the maximum image number has to be set to GRAB_INFINITE. When all buffers should be used exactly once GRAB_ALL_BUFFERS can be used. This is equivalent to passing the buffer count. In a multi DMA configuration the image grabbing can be started and stopped independently for each DMA channel. The grabbing mode is set to ACQ_STANDARD. The image memory is used as a ring buffer and all subbuffer will be overwritten cyclically.
◆ Fg_AcquireEx()
The function Fg_AcquireEx() starts a continuous grabbing. Having started the exact number of images will be grabbed (PicCount). If a timeout occurs, the grabbing will be stopped. If a continuous grabbing with manual stopping is needed (explicit stopping of the grabbing with Fg_stopAcquireEx()), the maximum image number has to be set to GRAB_INFINITE. When all buffers should be used exactly once GRAB_ALL_BUFFERS can be used. This is equivalent to passing the buffer count. In a multi DMA configuration the image grabbing can be started and stopped independently for each DMA channel. The grabbing mode is set by a flag. You can choose between ACQ_STANDARD, ACQ_BLOCK and ACQ_SELECT. If the mode ACQ_STANDARD is used, the image memory is used as a cyclic buffer and all subbuffers will be overwritten continuously. Fg_getLastPicNumberBlockingEx should be used to wait for new images. If the mode ACQ_BLOCK is used, the acquired frame buffer is blocked as long as it is explicitly released by the user by calling Fg_setStatusEx using FG_UNBLOCK. If all subbuffers are blocked, the acquired images will be stored in an additional, optional buffer (DummyBuffer), which is not blockable. There is no unique assignment between image number and subbuffer number in this grabbing model. For each subbuffer number, the corresponding image number can be requested by calling Fg_getParameterEx using FG_IMAGE_NUMBER. Fg_getImageEx should be used to wait for new images. If the mode ACQ_SELECT is used, every subbuffer must be selected explicitly before it is used for image data transfer by calling Fg_setStatusEx using FG_SELECT_BUFFER. There is no unique assignment between image number and subbuffer number in this grabbing model. Keeping track of the use of subbuffers is the responsibility of the user. Fg_getLastPicNumberBlockingEx should be used to wait for new images. If ACQ_NO_AUTOSTOP is used along ACQ_STANDARD, ACQ_BLOCK or ACQ_SELECT, and the number of images to be acquired was specified, then Fg_stopAcquireEx will not be called implicitly after the requested number of images was acquired. The acquisition is still stopped in the driver, however.
◆ Fg_activateEvents()
activates/disable event generation
mask may only contain valid event bits. As an exception it is allowed to pass a value where all bits are set (i.e. (uint64_t)-1) and enable set to 0 to disable all events which is explicitly allowed even if there are less than 64 events. ◆ Fg_addAppletIteratorItem()
Add an applet to applet iterator. This function add an applet to applet iterator
◆ Fg_AddMem()
To use an allocated user memory as subbuffer, a handle on the frame buffer must have been created with the function Fg_AllocMemHead(), before. Then, the function Fg_AddMem() adds an allocated memory area to the frame buffer management. The assignment between acquired images and subbuffers, which contain the images within PC memory, depends on the acquisition mode. Please note that memory limits depend on several factors, including but not limited to the amount of memory installed in the computer and operating system used.
◆ Fg_AllocMem()
The function Fg_AllocMem() reserves a defined area of the user memory as frame grabber memory and blocks it in the system memory. . The frame buffer can be subdivided in several subbuffers. The frame buffer is organized as a ring buffer. It means, if an image is written in the last subbuffer of the frame buffer, the next image will be transferred in the first subbuffer of the frame buffer. Existent images will be overwritten. Allocated memory can be released with Fg_FreeMem(). Please note, that there are memory limits existing!
◆ Fg_AllocMemEx()
The function Fg_AllocMemEx() reserves an area of the main memory as frame buffer, blocks it and makes it available for the user. . The frame buffer is organized as a ring buffer which is subdivided in several subbuffers. It is possible to allocate up to 256 different frame buffers as long as the maximum size of the configurable frame buffer is not exceeded. The assignment between acquired images and subbuffers, which contain the images within PC memory, depends on the acquisition mode. Allocated memory can be released with Fg_FreeMemEx(). The returned pointer represents the administrative data structure for all frame buffers. Please note, that there are memory limits existing!
◆ Fg_AllocMemHead()
Use an allocated user memory as frame buffer. . To transfer frames into user provided memory these memory areas have to be announced to the framegrabber system. Fg_AllocMemHead() creates the internal control stuctures to handle these memory. Afterwards you have to add the different memory buffers using Fg_AddMem(). Single buffers can be released with Fg_DelMem() from the buffer as long as this buffer is not currently used for frame transfer. The control structure must be released with Fg_FreeMemHead(). Please see the chapter "General memory limits" in the framegrabber documentation for general restrictions about the usable memory. #define BUFFERS 4
#define BUFFERSIZE (1024 * 1024)
char buf[BUFFERS + 1][BUFFERSIZE];
dma_mem *mhead = Fg_AllocMemHead(Fg, BUFFERSIZE * BUFFERS, BUFFERS);
if (mhead == NULL)
...
for (int i = 0; i < BUFFERS; i++) {
int ret = Fg_AddMem(Fg, buf[i], BUFFERSIZE, i, mhead);
if (ret < 0)
...
}
// replace buf[0] with buf[4] for frame transfer
Fg_DelMem(Fg, mhead, 0);
Fg_AddMem(Fg, buf[BUFFERS], BUFFERSIZE, 0, mhead);
Fg_AcquireEx(Fg, ..., mhead);
Fg_FreeMemHead(Fg, mhead);
PUBLIC_API dma_mem * Fg_AllocMemHead(Fg_Struct *Fg, const size_t Size, const frameindex_t BufCnt) Use an allocated user memory as frame buffer. . PUBLIC_API int Fg_DelMem(Fg_Struct *Fg, dma_mem *memHandle, const frameindex_t bufferIndex) Deleting user memory, . PUBLIC_API int Fg_AddMem(Fg_Struct *Fg, void *pBuffer, const size_t Size, const frameindex_t bufferIndex, dma_mem *memHandle) Adding user memory. . PUBLIC_API int Fg_AcquireEx(Fg_Struct *Fg, const unsigned int DmaIndex, const frameindex_t PicCount, const int nFlag, dma_mem *memHandle) Starting image grabbing. .
◆ Fg_AllocShading()
allocate shading control object
Before using the shading functionality, it is neccessary to allocate some buffer for shading calculation. Fg_AllocShading() is the first function to be used for complete shading feature. This function can only be used with acquisition applets that offer shading functionality. VisualApplets generated applets with shading functionality do not use this interface. Please refer to the VisualApplets operator manual for documentation of that shading interface. ◆ Fg_clearEvents()
drop all already queued events
mask may only contain valid event bits. As an exception it is allowed to pass a value where all bits are set (i.e. (uint64_t)-1) to clear all events which is explicitly allowed even if there are less than 64 events.
◆ Fg_DelMem()
With the function Fg_DelMem() a user memory area of the image memory management can be removed which has been created with Fg_AllocMemHead() and added with Fg_AddMem() before. The memory area won't be freed, it will only be removed from frame memory queues. Releasing of the memory are is up to the user.
◆ Fg_eventWait()
You must not call this function and Fg_registerEventCallback() on the same event. If 0 is returned Fg_getLastErrorNumber() will return the information about the error type. Usually this will be FG_TIMEOUT_ERR. The event mask can be obtained by calling Fg_getEventMask(). Several masks may be or'ed together to wait for the first of those events to happen. The return value states which events actually happened. If an info structure is passed the corresponding entries for those events will have the requested data filled in. The entries of all other events are left untouched. You are strongly encouraged to call FG_EVENT_INFO_INIT(info) before every call to Fg_eventWait() if you are using the info parameter to make sure you don't see old data in the structure.
◆ Fg_findApplet()
The function Fg_findApplet() returns the file name of the currently active applet for ME5 board. . The applet file is searched within the active Basler Framegrabber SDK environment (e.g. BASLER_FG_SDK_DIR) If the applet file name exceeds the size of the buffer of returning the information, FG_NOT_ENOUGH_MEMORY is returned. is returned.
◆ Fg_findAppletIteratorItem()
Looks for an item from applet iterator matching the applet path, file, or name. . This function gets an identifier for the n-th applet in the iterator Identifier can then be used to get different applet properties.
◆ Fg_freeAppletIterator()
This function releases an applet iterator .
◆ Fg_FreeGrabber()
Releasing frame grabber resources. . The function Fg_FreeGrabber() stops the operating frame grabber and releases the resources. Either, an already allocated frame buffer by Fg_AllocMem() will be released. The function Fg_FreeMem() will be executed internally. Otherwise, an allocated frame buffer by Fg_AllocMemEx() will be released. In this case, the function Fg_FreeMemEx() will be executed internally. All internal resources will be released.
◆ Fg_FreeLibraries()
The function Fg_FreeLibraries() releases internal structures of the library. . This function releases all internal structures that were initialized by a successful call to Fg_InitLibraries(). It is recommended to call this function just before the program leaves the main() method, or exits in any other way. ◆ Fg_FreeMem()
The function Fg_FreeMem() stops the frame grabber and releases the used memory which has been allocated with Fg_AllocMem() before.
◆ Fg_FreeMemEx()
The function Fg_FreeMemEx() releases the used memory which has been reserved with Fg_AllocMemEx() before. If the acquiring and access on the memory is still active, the function can not releases the memory area and returns with an error message.
◆ Fg_FreeMemHead()
The function Fg_FreeMemHead() releases a handle on a frame buffer that has been added with Fg_AllocMemHead(). If the acquisition and access to the memory is still active, the function is not able to release the memory area and returns with an error message. You do not need to remove the frame memory using Fg_DelMem() before calling this function as they will automatically be removed. Please note that this function will only remove the internal control structures and will not free the memory passed to Fg_AddMem().
◆ Fg_freeParameterStringWithType()
Release previously allocated frame grabber string parameter. .
This function releases the value from a string paramater that was previously allocated through a call to Fg_getParameterWithType with type FG_PARAM_TYPE_CHAR_PTR_PTR. All parameters must match the previous call to Fg_getParameterWithType(), except for the value pointer, which must be the char pointer to be released (and not a pointer to the char pointer). ◆ Fg_FreeShading()
release shading control object
This function can only be used with acquisition applets that offer shading functionality. VisualApplets generated applets with shading functionality do not use this interface. Please refer to the VisualApplets operator manual for documentation of that shading interface. ◆ Fg_getAppletId()
Get the ID of the currently running applet. .
See fg_define.h for the list of ids. The second parameter is only there to be compatible with earlier software interfaces. It is ignored and should be NULL. ◆ Fg_getAppletIntProperty()
Gets an integer applet properties . This function gets an integer property of an applet. Different properties are available within enum FgAppletIntProperty. Before getting any property, FG_AP_INT_INFO property must be read to make sure that other properties are valid, using FG_AI_IS_VALID mask. If FG_AI_IS_VALID is not set, then all other properties are not valid. The applet item should be retrieved from an Fg_AppletIterator using function Fg_getAppletIteratorItem.
◆ Fg_getAppletIterator()
This function gets an applet iterator for the applets on either the board or the filesystem Once not needed any more, the function Fg_freeAppletIterator() must be called to free the iterator.
◆ Fg_getAppletIteratorItem()
Gets an item from applet iterator by index. . This function gets an identifier for the n-th applet in the iterator Identifier can then be used to get different applet properties.
◆ Fg_getAppletStringProperty()
Gets string applet properties . This function gets a string property of an applet. Different properties are available within enum FgAppletStringProperty. Before getting any property, FG_AP_INT_INFO property must be read (using Fg_getAppletIntProperty) to make sure that other properties are valid, using FG_AI_IS_VALID mask. If FG_AI_IS_VALID is not set, then all other properties are not valid. The applet item should be retrieved from an Fg_AppletIterator using function Fg_getAppletIteratorItem.
◆ Fg_getAppletVersion()
Get the version of the currently running applet. .
See fg_define.h for the list of ids. ◆ Fg_getBitsPerPixel()
Calculate the bits per pixel for a specific output format (FG_GRAY, FG_COL24, etc.).
◆ Fg_getBoardNameByType()
Fg_getBoardNameByType() returns the name for the type of board.
See sisoboards.h for the board type definitions. ◆ Fg_getBoardType()
Fg_getBoardType() returns the type of board: If it is a microEnable III / -XXL or microEnable IV-Full x1 / -Full x4. PixelPlant is not able to be detected at the moment.
See sisoboards.h for the board type definitions. If you already have initialized the board, you can also use uint32_t boardType = BINFO_BOARDTYPE;
PUBLIC_API int Fg_getParameterWithType(Fg_Struct *Fg, const int Parameter, void *Value, const unsigned int DmaIndex, const enum FgParamTypes type) Getting frame grabber parameters with type information. . ◆ Fg_getErrorDescription()
Description of error message to an error code. . The function Fg_getErrorDescription() returns the error message, when receiving the error code.
◆ Fg_getEventCount()
◆ Fg_getEventMask()
◆ Fg_getEventName()
◆ Fg_getEventPayload()
◆ Fg_getImage()
After image acquisition, the buffer number of an image can be explicitly gotten by the help of the function Fg_getImage(). It is needed for blocking acquisition mode. But it can also be used for standard acquisition mode. The first buffer has the number 0. Depending on the parameter, the internal image counters for the last gotten image will be updated or not. A pointer to the image will be gotten by the function Fg_getImagePtr().
◆ Fg_getImageEx()
After image acquisition, the buffer number of an image can be explicitly gotten by the help of the function Fg_getImageEx(). It is needed for blocking acquisition mode. But it can also be used for standard acquisition mode. The first buffer has the number 1. Depending on the parameter, the internal image counters for the last gotten image will be updated or not. A pointer to the image will be gotten by the function Fg_getImagePtrEx().
◆ Fg_getImagePtr()
With the function Fg_getImagePtr() a pointer to an image in the frame buffer is created. Reference: The function will return only the correct image, if it still exists in the frame buffer. Example:
◆ Fg_getImagePtrEx()
With the function Fg_getImagePtrEx() a pointer to an image in the frame buffer is created. Reference: The function will return only the correct image, if it still exists in the frame buffer. Example:
◆ Fg_getLastErrorDescription()
Description of last error message. . With the function Fg_getLastErrorDescription() the last occurred error will be returned as error message.
This function is equivalent to getErrorDescription(Fg_getLastErrorNumber(Fg)). ◆ Fg_getLastErrorNumber()
Getting the last error code. . The function Fg_getLastErrorNumber() displays the error code of last occurred fault.
◆ Fg_getLastPicNumber()
Requesting the current image number (non-blocking). . The number of the last, completely transferred image can be requested with a non-blocking call of Fg_getLastPicNumber(). The first completely transferred image has the image number 1. An image number 0 means, that a complete image is still not transferred.
◆ Fg_getLastPicNumberBlocking()
Requesting the current image number (blocking) . The number of the last, completely transferred image can be requested with a blocking call of Fg_getLastPicNumberBlocking(). In contrary to Fg_getLastPicNumber() the function waits, until the transmission of the preselected image number is successfully finished or a maximum time is elapsed. If the image number is obtained before, the function returns immediately. The first image number value will be 1, if no error occurs. Attention: When working with extreme high framerates, the returned value of the function can be bigger than the preselected image number. In this case it is important to allocate enough frame buffers
◆ Fg_getLastPicNumberBlockingEx()
Requesting the current image number (blocking) . The number of the last, completely transferred image can be requested with a blocking call of Fg_getLastPicNumberBlockingEx(). In contrary to Fg_getLastPicNumberEx() the function waits, until the transmission of the preselected image number is successfully finished or a maximum time is elapsed. If the image number is obtained before, the function returns immediately. The first image number value will be 1, if no error occurs. Attention: When working with extreme high framerates, the returned value of the function can be bigger than the preselected image number. In this case it is important to allocate enough frame buffers
◆ Fg_getLastPicNumberEx()
Requesting the current image number (non-blocking). . The number of the last, completely transferred image can be requested with a non-blocking call of Fg_getLastPicNumberEx(). The first completely transferred image has the image number 1. An image number 0 means, that a complete image is still not transferred.
◆ Fg_getNrOfParameter()
The function Fg_getNrOfParameter() returns the number of parameters available within the loaded applet. .
◆ Fg_getParameter()
Getting special parameter settings. . Parameters can be read with Fg_getParameter(). The usage of this function is similar to Fg_setParameter(). Again parameters are accessed by their ID which can be determined in the way described above. In addition to the general available parameters described in Fg_setParameter(), a number of read only parameters can always be accessed with Fg_getParameter() and Fg_getParameterEx(). These parameters are listed in the following table:
◆ Fg_getParameterEx()
Getting special parameter settings. . Fg_getParameterEx() allows querying of values directly related to image transfers. These values are queried from the dma_mem pointer passed as argument. These values are available as long as the buffer memory is still available, i.e. even if the DMA transfer is no longer running or a DMA transfer is running with a different DMA buffer. As all of these values have special characteristics only a small set of parameter ids may be queried using this interface:
◆ Fg_getParameterId()
The function Fg_getParameterId() returns the parameter ID of the parameter referenced by index. . The value index is the index of the parameter. Its range is from 0 up to the value returned by Fg_getNrOfParameter() (-1).
◆ Fg_getParameterIdByName()
The function Fg_getParameterIdByName() searchs for the ID of the parameter referenced by the string name. . The string name is the full name of the parameter. The full name of the parameters is determined by VisualApplets during Applet creation. It consists of the process name, the module name in which the parameter has been defined, and the simple parameter name. Each part of the full name is separated by an underscore ('_'). Example: The parameter XOffset in module Buffer1 in process 0 is accessed by the full name "Process0_Buffer1_XOffset". When hierarchical boxes are used, the name(s) of the box(es) have to be added in front of the module name in which the parameter has been defined. Example: The parameter XOffset in module Buffer1 inside hierarchical box HBox1 in process 0 is accessed by the full name "Process0_HBox1_Buffer1_XOffset" Important: Parameters in microEnable IV applets get an additional prefix "Device1". The full name of the above example is on a microEnable IV board is "Device1_Process0_Buffer1_XOffset". Furthermore, for PixelPlant applets the prefix changes to "Device2". To get information about the parameters available inside the applet and their names, see the following snippet of code: int i;
for (i = 0; i < nrOfParameter; i++) {
fprintf(stdout, " Param %d: %s, 0x%x\n", i, name, Fg_getParameterId(fg, i));
}
PUBLIC_API int Fg_getParameterId(Fg_Struct *fg, int index) The function Fg_getParameterId() returns the parameter ID of the parameter referenced by index.... PUBLIC_API const char * Fg_getParameterName(Fg_Struct *fg, int index) The function Fg_getParameterName() informs about the name of a special parameter by index....
◆ Fg_getParameterInfoXML()
Get parameter description in a Genicam compatible XML format. . Get Parameter information in XML format This function delivers information about all parameters in a GenICam compatible XMl format. It can be used together with Genicam tools to access the parameters of an applet. Therefore the parameter ID is handled as an address. Read/write accesses are intended to be done with Fg_getParameter and Fg_setParameter with the delivered address as parameter ID. The buffer is filled with a null-terminated string containing the XML data. To be compliant against XML validation, the terminating 0 needs to be removed, when saving the data to a XML file
◆ Fg_getParameterName()
The function Fg_getParameterName() informs about the name of a special parameter by index. .
◆ Fg_getParameterNameById()
The function Fg_getParameterNameById() informs about the name of a parameter by its id. .
◆ Fg_getParameterProperty()
query the properties of a given parameter
This function allows to query additional information for a certain parameter like datatype,... The result is basically returned as a string value (null terminated string) In other cases, the type of data buffer has to be declared and a type check will be done internally When passing an null-pointer as buffer, the function will return the length of the needed buffersize (in bytes) to place the contents to.
◆ Fg_getParameterPropertyEx()
query the properties of a given parameter
This function allows to query additional information for a certain parameter like datatype,... The result is basically returned as a string value (null terminated string) In other cases, the type of data buffer has to be declared and a type check will be done internally When passing an null-pointer as buffer, the function will return the length of the needed buffersize (in bytes) to place the contents to.
◆ Fg_getParameterType()
The function Fg_getParameterType() informs about the type of a special parameter by index. .
◆ Fg_getParameterTypeById()
The function Fg_getParameterTypeById() informs about the type of a parameter by its id. .
◆ Fg_getParameterWithType()
Getting frame grabber parameters with type information. .
This function behaves like Fg_getParameter() but allows to specify the type of the given value. For compatibility reasons Fg_getParameter() only accepts 32 bit values for integer parameters. If you need to get a 64 bit int parameter you need this function or the upper 32 bit of the passed value will never be changed. Please not that when querying string parameters with type FG_PARAM_TYPE_CHAR_PTR_PTR, value must be a pointer to a char pointer variable. The memory to hold the string will be allocated and must be release using Fg_freeStringParameterWithType() after use. ◆ Fg_getSerialNumber()
The function Fg_getSerialNumber() reads the serial number of the frame grabber.
◆ Fg_getStatus()
Reading the status of frame buffer. . With the function Fg_getStatus() you are getting information about the acquisition status. The parameter data depends on the chosen flag. For details, please see tables below. By the help of Fg_setStatus() buffers can be blocked or unblocked.
◆ Fg_getStatusEx()
Reading the status of frame buffer. . With the function Fg_getStatusEx() you are getting information about the acquisition status. The parameter data depends on the chosen flag. For details, please see tables below. By the help of Fg_setStatusEx() buffers can be blocked or unblocked.
◆ Fg_getSWVersion()
The function Fg_getSWVersion() returns the version of the Framegrabber SDK running.
◆ Fg_getSystemInformation()
query information about the overall framegrabber setup returns various information about the currently present framegrabber system in form of a null-terminated string. For additional control / addressing the information to be queried, param1 can be used, depending on the value to e queried. Example: when querying information about a certain board in a multiboard system, the board has to be addressed. Param1 might be used for addressing the board When passing an null-pointer as buffer, the function will return the length of the needed buffersize (in bytes) to place the contents to.
◆ Fg_Init()
The function Fg_Init() initializes the frame grabber. . This functions is equivalent to calling Fg_InitEx(FileName, BoardIndex, 0). Please see the documentation of Fg_InitEx() for a detailed description of the parameters. An initialized frame grabber resource by Fg_Init() must be released by Fg_FreeGrabber().
If this function returns NULL you may call Fg_getLastErrorNumber(NULL) to get the error code. ◆ Fg_InitConfig()
The function Fg_InitConfig() initializes the frame grabber and loads a parameter file (microEnable configuration file *.mcf). . If more than one microEnable frame grabber is available within PC system, each hardware card will differ by a logical number, which is distributed by initialization. Sorting of the logical board number is influenced by each hardware's serial number. The serial number is printed on each board and can be displayed by microDiagnostics or microDisplay. An additional possibility for identifying several grabbers is to use a function to ask for serial number via Fg_getSerialNumber(). Attention: Each frame grabber card will be handled uniquely by a separate data structure Fg_Struct, after initialization. The selection of frame grabbers is sorted by the increasing number of slots within PC. Please note, that the unique ID can differ from PC to PC. An initialized frame grabber resource by Fg_InitConfig() will released by Fg_FreeGrabber().
◆ Fg_InitConfigEx()
The function Fg_InitConfigEx() initializes the frame grabber in master or slave mode and loads a parameter file (microEnable configuration file *.mcf). . If more than one microEnable frame grabber is available within PC system, each hardware card will differ by a logical number, which is distributed by initialization. Sorting of the logical board number is influenced by each hardware's serial number. The serial number is printed on each board and can be displayed by microDiagnostics or microDisplay. An additional possibility for identifying several grabbers is to use a function to ask for serial number via Fg_getSerialNumber(). Attention: Each frame grabber card will be handled uniquely by a separate data structure Fg_Struct, after initialization. The selection of frame grabbers is sorted by the increasing number of slots within PC. Please note, that the unique ID can differ from PC to PC. A grabber that is initialized in "master" mode will configure the FPGA. A grabber initialized as slave will not configure the FPGA. In fact it checks if the FPGA is already configured with the same design as requested. Not all applets and platforms support slave configurations, e.g. currently VA generated HAPs, mE4AD1-CL boards, and mE4AS1-CL boards do not support slave mode. A grabber initialized as slave has access to all resources of the board. Locking for concurrent accesses is left to the user to allow maximum flexibility. On the other hand some special resources will always protect themselves against concurrent usage, e.g DMA channels can't be started if they are already running. A board can only be opened in slave mode if the master is already opened, otherwise the error code is set to FG_NOT_AVAILABLE ( FG_INVALID_PARAMETER , if slave modes isn't supported at all for this applet) Please note that a configuration has to be edited manually before it can be applied in slave mode safely. Each save is supposed to touch only parameters that no other slave or the master will touch. A configuration saved from microDisplay contains all parameters, and is not master/slave aware. An initialized frame grabber resource by Fg_InitConfig() will released by Fg_FreeGrabber().
◆ Fg_InitEx()
Initialize a frame grabber in master or slave mode. . This function initializes a framegrabber with a given applet. Both standard applets as well as VisualApplets generated HAP files are supported. The BoardIndex parameter is used to address multiple framegrabbers in the same system. Board numbers depend on the system architecture and operating system. In general the board numbers depend on the PCI setup, i.e. boards with lower PCI bus and slot numbers will have lower board numbers. On Windows systems meIII grabbers will always get lower numbers than meIV devices. On Linux the order depends only on the PCI bus numbers, resulting in meIII devices usually appearing on higher device numbers as PCI buses are usually the last child bus of PCI Express bridges. The easiest way to find out the mapping from boards to their board id is using microDiagnostics which shows board type, serial number, and board index. A grabber that is initialized in "master" mode will configure the FPGA. A grabber initialized as slave will not configure the FPGA. In fact it checks if the FPGA is already configured with the same design as requested. Not all applets and platforms support slave configurations, e.g. currently VA generated HAPs, mE4AD1-CL boards, and mE4AS1-CL boards do not support slave mode. A grabber initialized as slave has access to all resources of the board. Locking for concurrent accesses is left to the user to allow maximum flexibility. On the other hand some special resources will always protect themselves against concurrent usage, e.g DMA channels can't be started if they are already running. A board can only be opened in slave mode if the master is already opened, otherwise the error code is set to FG_NOT_AVAILABLE ( FG_INVALID_PARAMETER , if slave modes isn't supported at all for this applet) An initialized frame grabber resource by Fg_InitEx() must be released by Fg_FreeGrabber().
If this function returns NULL you may call Fg_getLastErrorNumber(NULL) to get the error code. ◆ Fg_InitLibraries()
The function Fg_InitLibraries() initializes internal structures of the library. . This function initializes internal structures in the library and keeps them in memory until Fg_FreeLibraries() is called. This can help to speed up certain operations like enumerating boards or getting information about a board before calling Fg_Init(). It is recommended to call this function in the main() method before any other calls to fglib5, or any other library supplied with the Basler Framegrabber SDK. When Fg_InitLibraries() returns 0, you must call Fg_FreeLibraries() before exiting your program.
◆ Fg_InitLibrariesEx()
The function Fg_InitLibrariesEx() initializes internal structures of the library and synchronizes the startup of the application(s). . This function initializes internal structures in the library and keeps them in memory until Fg_FreeLibraries() is called. This can help to speed up certain operations like enumerating boards or getting information about a board before calling Fg_Init(). Furthermore, the startup of the application can be synchronized with the startup of the Generic Service, or with a Master or the other Slaves in a Master/Slave setup. It is recommended to call this function in the main() method before any other calls to fglib5, or any other library supplied with the Basler Framegrabber SDK. When Fg_InitLibraries() returns 0, you must call Fg_FreeLibraries() before exiting your program. Note: microDisplay can be used as a master and you can synchronize your own slave application against microDisplay. The id of microDisplay is siso-microdisplay-master and it uses (FG_INIT_LIBRARIES_MASTER | FG_INIT_LIBRARIES_AUTOSTART_ON_INIT). To synchronize your slave application against microDisplay, use the same id and FG_INIT_LIBRARIES_SLAVE. Strictly sequential startup is not supported by microDisplay, and thus slave priorities are not allowed. Note: The following flags and macros can be used to control the synchronization: FG_INIT_LIBRARIES_SINGLE Standard init, no synchronization (same as calling Fg_InitLibraries()) FG_INIT_LIBRARIES_MASTER Master init, prepare slave synchronization FG_INIT_LIBRARIES_SLAVE Slave init, wait for master FG_INIT_LIBRARIES_WAIT_FOR_SERVICE Wait for service to be started (valid only for single application and master modes) FG_INIT_LIBRARIES_SEQUENTIAL Strictly sequential startup (slaves must use unique priority; number of slaves must be given on master init) FG_INIT_LIBRARIES_AUTOSTART_ON_INIT Start next slave on Fg_Init() FG_INIT_LIBRARIES_SET_MODE(n) Set mode (single, master, slave) FG_INIT_LIBRARIES_SET_SLAVE_PRIORITY(n) Set slave priority (allowed values are 1..63; priority 0 will select priority automatically) FG_INIT_LIBRARIES_SET_NUMBER_OF_SLAVES(n) Set number of slaves (allowed values are 1..63)
◆ Fg_InitLibrariesStartNextSlave()
The function Fg_InitLibrariesStartNextSlave() signals the next slave process to start. . This function is required for synchronization of the startup of processes in master/slave mode when FG_INIT_LIBRARIES_AUTOSTART_SLAVE was not set in Fg_IitLibrariesEx. This is generally needed if the process requires further initialization beyond Fg_Init() that must be synchronized with other slave processes or the master process. Most likely, this will be applicable to initialization in the master process, but should generally not be the case for slave processes, as these should be using completely separate resources (DMA, parameters, ...). ◆ Fg_loadConfig()
Loading a frame grabber configuration. . Having initialized the frame grabber, an existing camera configuration file can be loaded with the function Fg_loadConfig(). There must be a valid frame grabber to use A configuration file can also be saved with Fg_saveConfig(). The extension of the microEnable configuration file is always *.mcf.
◆ Fg_loadFieldParameterFromFile()
Loading field parameter from file. A field parameter file can also be saved with Fg_saveFieldParameterToFile(). The extension of the field parameter file is always *.mfs.
◆ Fg_NumaAllocDmaBuffer()
NUMA aware allocation of memory. . Allocated memory can be released with Fg_NumaFreeDmaBuffer(). Please note, that there are memory limits existing! However, this function will never fail, but give you memory from other nodes, or even the page file, if you exceed the node memory limit.
◆ Fg_NumaFreeDmaBuffer()
NUMA aware freeing of memory. . Only use this function to release memory allocated with Fg_NumaAllocateDmaBuffer().
◆ Fg_NumaPinThread()
NUMA aware pinning of thread affinity. .
◆ Fg_queueBuffer()
Queues a buffer for DMA transmission. This function provides an interface in order to send buffers from a client software to the applet. Please note that when using this function, special applets which support this possibility are needed
◆ Fg_readUserDataArea()
Using Fg_readUserDataArea() you can read a block of memory from reserved space in the configuration memory of the frame grabber. Please consult the manual of your frame grabber about support for this feature. Also note that the memory might be very limited, slow and implemented on a device that only provides a limited number of write cycles.
◆ Fg_registerApcHandler()
Register an APC handler for the given DMA channel. .
This function registers an APC (asynchronous procedure call) handler to be called once images on the given DMA channel arrive. This function does not start the acquisition itself, this needs to be done using Fg_Acquire() or Fg_AcquireEx(). If an APC handler is registered for a DMA channel you can not use Fg_getLastPicNumberBlocking() or Fg_getLastPicNumberBlockingEx() to wait for images on that channel. The DMA channel will not be stopped by the APC handler thread on any circumstances even when the handler will terminate itself by those. Once the DMA is started the APC handler function will get called for new images. The exact behaviour can be controlled by setting the flags member of the control struct using the constants defined in enum Fg_Apc_Flag in fg_define.h. If you are unsure just pass Fg_Apc_Flag::FG_APC_DEFAULTS here. The handler function is stored as func in the control struct. It will be called with the image number to work on as first and the value given for data in the control struct as second argument.
If you request FG_APC_HIGH_PRIORITY through the flag member of the control structure, your application must have the necessary privileges to change the thread scheduling and priority. Note that on Linux this generally means you have to run the application as root or use setuid. The flags parameter allows future expansions of the APC operation mode. The only value value currently valid is FG_APC_CONTROL_BASIC. You must set the version number in the control struct. If you want to unregister an APC handler for a given channel call this function as: Fg_registerApcHandler(Fg, dma, NULL, FG_APC_CONTROL_BASIC);
PUBLIC_API int Fg_registerApcHandler(Fg_Struct *Fg, const unsigned int DmaIndex, const struct FgApcControl *control, enum FgApcControlFlags flags) Register an APC handler for the given DMA channel. . You must always unregister the APC handler from a DMA channel even if the APC thread was automatically stopped. This will happen e.g. if a image timeout occurs and Fg_Apc_Flag::FG_APC_IGNORE_TIMEOUTS was not set or if your handler function returns with error code and Fg_Apc_Flag::FG_APC_IGNORE_APCFUNC_RETURN was not set. You do not need to unregister the APC handler if registering failed with an error code. class MyClass {
private:
Fg_Struct *fg;
unsigned int dma;
dma_mem *mem;
int processImage(frameindex_t frame);
// more private member functions ...
public:
~MyClass();
int registerApc();
// more public member functions ...
};
{
return reinterpret_cast<MyClass *>(context)->processImage(frame);
}
int MyClass::processImage(frameindex_t frame)
{
void *data = Fg_getImagePtrEx(fg, frame, dma, mem);
size_t len = 0;
Fg_getParameterEx(fg, FG_TRANSFER_LEN, &len, dma, mem, frame);
// ... process image data
return 0;
}
: fg(fg), dma(dma), mem(nullptr)
{}
MyClass::~MyClass()
{
Fg_registerApcHandler(fg, dma, NULL, FG_APC_CONTROL_BASIC);
}
int MyClass::registerApc()
{
struct FgApcControl ctrl;
ctrl.func = &MyClass::apcFunc;
ctrl.data = this;
ctrl.flags = FG_APC_DEFAULTS;
ctrl.timeout = 10;
}
PUBLIC_API void * Fg_getImagePtrEx(Fg_Struct *Fg, const frameindex_t PicNr, const unsigned int DmaIndex, dma_mem *pMem) Access on frame buffer. . PUBLIC_API int Fg_getParameterEx(Fg_Struct *Fg, const int Parameter, void *Value, const unsigned int DmaIndex, dma_mem *pMem, const frameindex_t ImgNr) Getting special parameter settings. . Definition fg_struct.h:133 ◆ Fg_registerAsyncNotifyCallback()
register callback for asynchronous notifications
Use this function to register a callback function for asynchronous notifications sent by the driver. This will install a new callback function, but not override any callbacks that were registered before. The same callback function can be registered more than once, only if you provide a unique, non-NULL context pointer for each registration. You cannot register the same callback, if it was already registered with NULL as context. To unregister a callback, call Fg_unregisterAsyncNotifyCallback(). All callbacks of one board will be handled in the same thread. If your callback handler takes a long time to complete it will delay all further notifications until it has finished. If you need both a long running notification handler and short reaction time you must create your own worker thread and start it's execution from the callback. If your event handler returns a value other than 0 it is automatically unregistered.
◆ Fg_registerEventCallback()
You must not call this function and Fg_eventWait() on the same event. Use this function to register a callback function for any combination of event masks. This will overwrite the handler for any events in mask. Use Fg_getEventMask() to obtain the event mask corresponding to a specific event. To unregister a callback pass NULL as handler to this function. You must pass the same event mask you passed in when registering the callback. The flags argument must be set to FG_EVENT_DEFAULT_FLAGS. Fg_registerEventCallback(Fg, mask, NULL, NULL, FG_EVENT_DEFAULT_FLAGS, NULL);
PUBLIC_API int Fg_registerEventCallback(Fg_Struct *Fg, uint64_t mask, Fg_EventFunc_t handler, void *data, unsigned int flags, struct fg_event_info *info) register callback for events All callbacks of one board will be handled in the same thread. If your callback handler takes a long time to complete it will delay all further events until it has finished. If you need both a long running event handler and short reaction time you must create your own worker thread and start it's execution from the callback. You may register multiple callbacks with different event masks at the same time. You may also register the same event handler with different data arguments at the same time. If your event handler returns a value other than 0 it is automatically unregistered from all events it was registered to with the same data argument. If you pass a value different from NULL as info these structure will be filled with the requested information before handler is called. You should never use the data outside your handler as it will be overwritten before handler is called. You must not change the contents of the struct inside the handler.
◆ Fg_resetAsyncNotify()
acknowledge an asynchronous notifications
Use this function to acknowledge an asynchronous notification that was received through one of your registered handlers.
◆ Fg_saveConfig()
Saving a frame grabber configuration . The frame grabber's configuration can be saved into a file by Fg_saveConfig(). Parameterization will be handled by loading of this file. The frame grabber has to be initialized first! A configuration file can also be loaded with Fg_loadConfig(). The extension of the microEnable configuration file is always *.mcf.
◆ Fg_saveFieldParameterToFile()
Saving applet field parameter. The applet's fields parameters can be saved into a file by Fg_saveFieldParameterToFile() A field parameter file can also be loaded with Fg_loadFieldParameterFromFile(). The extension of the field parameter is always *.mfs.
◆ Fg_sendImage()
Sending images from Software to the applet . This function provides an interface in order to send images from a client software to the applet. This functions uses frame buffers which are allocated by using the Fg_allocMem() function. It shouldn't be used in combination with the Fg_allocMemEx() functions. Please note that when using this function, special applets which support this possibility are needed
◆ Fg_sendImageEx()
Sending images from Software to the applet . This function provides an interface in order to send images from a client software to the applet. Please note that when using this function, special applets which support this possibility are needed
◆ Fg_sendSoftwareTrigger()
send trigger signal to the camera
This function can be used to send immediately a single trigger pulse to the camera in softwaretrigger mode or to add one trigger to the queue in softwaretrigger queue mode. The length of the signals is determined by the exposure time and is configured by the function Fg_setParameter(). During the duration of the camera trigger, a new trigger signal can't be sent in software trigger mode. In software trigger queue mode a new trigger signal to the camera are created if the previous triggered image was fully transfered onto the grabber. Besides the camera trigger, the signal StrobePulse is activated, which can be used as control for flash lights. The delay of the StrobePulse relative to the camera trigger is set by the function Fg_getParameter() (see flash light control). This function internally calls Fg_setParameter() with parameter FG_SENDSOFTWARETRIGGER with Triggers as value. You should use that interface as this has slightly less overhead. The microEnable IV-GigE x4 currently does not support the trigger system. This function can only be used with acquisition applets. VisualApplets generated applets do not use this interface. Please refer to the VisualApplets operator manual for documentation for trigger operators. ◆ Fg_sendSoftwareTriggerEx()
send multiple trigger signals to the camera
This function can be used either to send immediately a single trigger pulse to the camera in softwaretrigger mode or to add (and send) multiple triggers to the queue in softwaretrigger queue mode. The length of the signals is determined by the exposure time and is configured by the function Fg_setParameter(). During the duration of the camera trigger, a new trigger signal can't be sent in software trigger mode. In software trigger queue mode next trigger signal to the camera is created if the previous triggered image was fully transfered onto the grabber. Besides the camera trigger, the signal StrobePulse is activated, which can be used as control for flash lights. The delay of the StrobePulse relative to the camera trigger is set by the function Fg_getParameter() (see flash light control). This function internally calls Fg_setParameter() with parameter FG_SENDSOFTWARETRIGGER with Triggers as value. You should use that interface as this has slightly less overhead. The microEnable IV-GigE x4 currently does not support the trigger system. This function can only be used with acquisition applets. VisualApplets generated applets do not use this interface. Please refer to the VisualApplets operator manual for documentation for trigger operators.
◆ Fg_setAsyncNotify()
trigger an asynchronous notifications
Use this function to trigger an asynchronous notification. This is mainly an internal function for tests.
◆ Fg_setParameter()
Setting frame grabber parameters. . Each applet, loaded by Fg_Init() or Fg_InitConfig(), has a set of parameters to change and control the applets operation. The number of available parameters, their names and functions depend on the design created with VisualApplets. The available parameters are determined by the VisualApplets operators used within the design. Applet parameters are accessed by their ID. The ID is an integer value, which can be determined using two SDK functions. These functions are: Fg_getParameterId() and Fg_getParameterIdByName(). Having the parameter ID, enables to set the parameter value inside the applet with Fg_setParameter() or to read the parameter value with Fg_getParameter(). The number of available parameters within the applet can be determined by calling Fg_getNrOfParameter(), the name of each parameter with Fg_getParameterName(). Setting applet parameters is done with Fg_setParameter(). This function takes the Fg_Struct pointer, as it has been returned by Fg_Init or Fg_InitConfig, the parameter ID, the new value, and the associated DMA number. A number of parameter IDs are already pre-defined and generally available. They can be accessed with pre-defined constants. These parameters are summarized in the following table:
◆ Fg_setParameterWithType()
Setting frame grabber parameters with type information. . This function behaves like Fg_setParameter() but allows to specify the type of the given value. For compatibility reasons Fg_setParameter() only accepts 32 bit values for integer parameters. If you need to set a 64 bit int parameter you need this function or the upper 32 bit of the passed value will be lost. ◆ Fg_setStatus()
Setting the status of frame buffer. . The function Fg_setStatus() explicitely allows, blocking or releasing of a blocked buffer (see table). By the help of Fg_getStatus() the acquisition status can be gotten.
◆ Fg_setStatusEx()
Setting the status of frame buffer. . The function Fg_setStatus() explicitely allows, blocking or releasing of a blocked buffer (see table). By the help of Fg_getStatus() the acquisition status can be gotten.
◆ Fg_startBufferQueue()
Starts transmission of queued buffers. This function starts the processing of the buffer queue. The buffer queue will keep waiting for buffers to be queued and process these until the queue is stopped by calling Fg_stopBufferQueue(). In a multi DMA configuration the buffer transmission can be started and stopped independently for each DMA channel. Every subbuffer must be queued explicitly by calling #Fg_queueBufferEx. There is no unique assignment between buffer number and subbuffer number. Keeping track of the use of subbuffers is the user's responsibility. Fg_waitForBuffers should be used to wait for buffers to become available for re-queuing.
◆ Fg_stopAcquire()
The function Fg_stopAcquire() stops the running image grabbing that has been started with Fg_Acquire(). In a dual grabber configuration, each port can be stopped separately. In a single grabber configuration only the active port. The function Fg_stopAcquire() stopps the acquiring of images asynchronous, that means, running image transfer won't be finished in every case.
◆ Fg_stopAcquireEx()
The function Fg_stopAcquireEx() stop the running image grabbing that has been started with Fg_AquireEx(). In a dual grabber configuration, each port can be stopped separately. In a single grabber configuration only the active port. The function Fg_stopAcquireEx() stopps the image acquiring asynchronous or synchronous. nFlag indicates the stop mode and also the duration of timeout in seconds. Timeout is the maximum time, the function will wait in synchronous mode to stop the acquiring.
◆ Fg_stopBufferQueue()
Stops the processing of the buffer queue. This function stops processing of the buffer queue, therefore no more buffer transmissions will happen after calling this function. In a dual grabber configuration, each port can be stopped separately. In a single grabber configuration only the active port. The function Fg_stopBufferQueueEx() can stop the buffer queue processing asynchronously or synchronously. nFlag indicates the stop mode and also the duration of timeout in seconds. Timeout is the maximum time, the function will wait in synchronous mode to stop the acquiring.
◆ Fg_unregisterAsyncNotifyCallback()
unregister callback for asynchronous notifications
Use this function to unregister a callback function for asynchronous notifications that was registered before with Fg_registerAsyncNotifyCallback(). You must provide the same parameters that you used for registering the callback. You can, however, provide NULL for the context, in which case all callbacks using the same function with different context pointers will be unregistered.
◆ Fg_waitForBuffers()
Waits for new buffers to be become available again. If any buffers were processed when calling this function, it returns immediately. Otherwise it blocks until at least one buffer becomes available. Only buffers which have become available after the last call to this function are taken into account.
◆ Fg_writeUserDataArea()
Using Fg_writeUserDataArea() you can write a block of memory to reserved space in the configuration memory of the frame grabber. Please consult the manual of your frame grabber about support for this feature. Also note that the memory might be very limited, slow and implemented on a device that only provides a limited number of write cycles.
◆ getErrorDescription()
◆ Shad_FreeAccess()
After opening the access to the shading interface and after working with the shading feature, the shading interface can be closed with Shad_FreeAccess(). This function can only be used with acquisition applets that offer shading functionality. VisualApplets generated applets with shading functionality do not use this interface. Please refer to the VisualApplets operator manual for documentation of that shading interface. ◆ Shad_GetAccess()
Before using the shading interface, it is neccessary to activate the access with Shad_GetAccess(). In detail, the registers on your grabber will be prepared for shading. Afterwards, the interface can be closed with Shad_FreeAccess(). This function can only be used with acquisition applets that offer shading functionality. VisualApplets generated applets with shading functionality do not use this interface. Please refer to the VisualApplets operator manual for documentation of that shading interface. ◆ Shad_GetMaxLine()
query current line number for shading correction
Before shading calculation for the current image can be done, the line number has to be known. Shad_GetMaxLine() returns with that information. This function can only be used with acquisition applets that offer shading functionality. VisualApplets generated applets with shading functionality do not use this interface. Please refer to the VisualApplets operator manual for documentation of that shading interface. ◆ Shad_SetFixedPatternNoiseLine()
set defective pixel interpolation value for shading correction
Before shading calculation can be done, some parameters have to be set. Shad_SetFixedPatternNoiseLine() sets parameters for the defective pixel interpolation. You can either manually set values for shading with this function or you can otherwise set a path to a file for defective pixel interpolation. This can be done with Fg_setParameter() using FG_SHADING_FPNFILE0 parameter. This function can only be used with acquisition applets that offer shading functionality. VisualApplets generated applets with shading functionality do not use this interface. Please refer to the VisualApplets operator manual for documentation of that shading interface. ◆ Shad_SetMultValueLine()
set multiplicative correction value for shading correction
Before shading calculation can be done, some parameters have to be set. Shad_SetMultValueLine() sets parameters for the gain (multiplicative correction). You can either manually set values for shading with this function or you can otherwise set a path to a file for multiplication calculation. This can be done with Fg_setParameter() using FG_SHADING_MULTFILE0 parameter. This function can only be used with acquisition applets that offer shading functionality. VisualApplets generated applets with shading functionality do not use this interface. Please refer to the VisualApplets operator manual for documentation of that shading interface. ◆ Shad_SetSubValueLine()
set substractive correction value for shading correction
Before shading calculation can be done, some parameters have to be set. Shad_SetSubValueLine() sets parameters for the offset (subtractive correction). You can either manually set values for shading with this function or you can otherwise set a path to a file for subtraction calculation. This can be done with Fg_setParameter() using FG_SHADING_SUBFILE0 parameter. This function can only be used with acquisition applets that offer shading functionality. VisualApplets generated applets with shading functionality do not use this interface. Please refer to the VisualApplets operator manual for documentation of that shading interface. ◆ Shad_WriteActLine()
write shading correction values for given line
The currently corrected line can be written with Shad_WriteActLine(). This function can only be used with acquisition applets that offer shading functionality. VisualApplets generated applets with shading functionality do not use this interface. Please refer to the VisualApplets operator manual for documentation of that shading interface. | |||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||