9.4 Bitmaps

For bitmap marking three different algorithms are available:

Algorithm	Implementation	Description
Sprint	AppendBitmapLineAbs(Point2D, Point2D, IEnumerableUInt16), etc.	The scanner is accelerated to the currently specified MarkSpeed prior to the actual bitmap segment. Then it travels at constant velocity while simultaneously firing the laser with a power that corresponds to the pixel value as defined in the powerValues array. Finally, the scanner is decelerated.
Point‑and‑Shoot	AppendPointAndShootLineAbs(Point2D, Point2D, IEnumerableDouble, IEnumerableUInt16), etc.	The scanner jumps to each non-empty pixel position in turn, fires N pulses at that position, and then moves on to the next pixel. The number of pulses N fired at each location is determined by either the single exposureTime parameter, or the exposureTimes array parameter. The algorithm automatically skips pixels whose number of laser pulses is 0.
Jump‑and‑Shoot	AppendJumpAndShoot(IListJumpAndShootItemPoint2D), etc.	The scanner jumps abruptly to each pixel, waits there for a delay that can be set per pixel, fires N pulses at that position, and then jumps to the next pixel. The number of pulses N fired at each location is determined by the exposure time parameter.

Algorithm

Implementation

Description

AppendBitmapLineAbs(Point2D, Point2D, IEnumerableUInt16), etc.

The scanner is accelerated to the currently specified MarkSpeed prior to the actual bitmap segment.

Then it travels at constant velocity while simultaneously firing the laser with a power that corresponds to the pixel value as defined in the powerValues array.

Finally, the scanner is decelerated.

Point‑and‑Shoot

AppendPointAndShootLineAbs(Point2D, Point2D, IEnumerableDouble, IEnumerableUInt16), etc.

The scanner jumps to each non-empty pixel position in turn, fires N pulses at that position, and then moves on to the next pixel.

The number of pulses N fired at each location is determined by either the single exposureTime parameter, or the exposureTimes array parameter.

The algorithm automatically skips pixels whose number of laser pulses is 0.

Jump‑and‑Shoot

AppendJumpAndShoot(IListJumpAndShootItemPoint2D), etc.

The scanner jumps abruptly to each pixel, waits there for a delay that can be set per pixel, fires N pulses at that position, and then jumps to the next pixel.

The number of pulses N fired at each location is determined by the exposure time parameter.

Sprint Algorithm Details

The laser fires at a fixed time interval while the scanner moves at a constant velocity, specifically the mark velocity.

In order to guarantee constant velocity during marking, both an acceleration segment and deceleration segment are placed around the actual bitmap segment.

The acceleration and deceleration segments are of equal length, that length being one half of the product of mark velocity ( V_Mark) and the largest of the acceleration times assigned to the scanner axes ( T_AccMax) :
- only head 0, if operating in “Single3D”
- both head 0 and 1, if operating in “Dual 2D” mode
The acceleration times are defined in ScanHeadConfig.

The entire length of the bitmap line is divided by the count of elements in the powerValues array, thus defining the spacing between marked pixels. The first and last pixels will be marked at the start and end positions of the line, respectively.

The rate of the laser pulses, i.e. the LM frequency, will be automatically calculated as the inverse of the time it takes to travel the distance between two pixels (dx) at the currently specified MarkSpeed.

Bitmap - Sprint

Gate is asserted and de-asserted at the beginning and end of the bitmap segment, respectively, while honouring the LaserConfigGateSetup and LaserConfigGateHold parameters.
Regardless of the power, a single LM pulse is produced at every pixel, shifted in time by LaserConfigLaserTriggerDelay.
Power is set corresponding to the p-th element of the powerValues array, and is updated by PowerChangeSetup in advance.
Power Calibration and Power Corrections (see: 9.5.3 Dynamic Power Correction), if enabled, remain active during bitmap marking and consequently influence the actual power sent to the laser.

Point-and-Shoot Algorithm Details

The entire length of the bitmap line is divided by the count of elements in the array passed to powerValues, thus defining the spacing between successive pixel positions.
The first and last pixels correspond to the start and end positions of the line, respectively.

For each pixel, p, the number of pulses to be fired, N, is determined by the product of the ProcessVariablesLmFrequency and p’s exposure time, rounded to the nearest integer number.

If N = 0, p is skipped: specifically, the laser is not fired, and the scanner does not move to p’s position.
If, however, N > 0, the scanner moves at ProcessVariablesJumpSpeed to p’s Position, where it settles for the time given by ProcessVariablesJumpDelay.
Then the laser fires N pulses, at the rate defined by ProcessVariablesLmFrequency, and at the power level given by the p-th element of the array passed to powerValues.

After the bitmap line has been processed, the scanner will not necessarily be positioned at the specified end position, but at the last pixel where at least one pulse has been fired.

Bitmap - Point-and-Shoot

Gate is asserted and de-asserted at the beginning and end of each pixel, respectively, while honouring the GateSetup and GateHold parameters. Gate remains de-asserted when jumping from one pixel to the next.
Depending on the exposure time for a particular pixel, LM may be activated just once or multiple times for that pixel. In either case, LaserTriggerDelay will take effect.
Power is set corresponding to the p-th element of the powerValues array, and is updated by PowerChangeSetup in advance.
Power Calibration and Power Corrections (see: 9.5.3 Dynamic Power Correction), if enabled, remain active during bitmap marking and consequently influence the actual power sent to the laser.

Jump-and-Shoot Algorithm Details

Note
In contrast to Point-And-Shoot, the Jump-And-Shoot algorithm ignores the current ProcessVariablesJumpSpeed and ProcessVariablesJumpDelay completely. Furthermore, there is no requirement for all of the pixels' Positions to be co-linear.

Note

In contrast to Point-And-Shoot, the Jump-And-Shoot algorithm ignores the current ProcessVariablesJumpSpeed and ProcessVariablesJumpDelay completely.

Furthermore, there is no requirement for all of the pixels' Positions to be co-linear.

For each pixel, p:

The number of pulses to be fired, N, is determined by the product of the ProcessVariablesLmFrequency and the pixel’s ExposureTime, rounded to the nearest integer number.
The scanner is commanded to jump abruptly to p’s Position, and is then allowed to settle there for the time given by p's individual Delay parameter.
The laser then fires N pulses, with the power level determined by ProcessVariablesPower.
If ProcessVariablesMarkDelay has a non-zero value, it will take effect after the last (or only) laser pulse.

Bitmap - JumpAndShoot

Gate is asserted and de-asserted at the beginning and end of each pixel, respectively, while honouring the LaserConfigGateSetup and LaserConfigGateHold parameters. Gate remains de-asserted when jumping from one pixel to the next.
Depending on the exposure time for a particular pixel, LM may be activated just once or multiple times for that pixel. In either case, LaserConfigLaserTriggerDelay will take effect.
The power level of the LM pulses is set by ProcessVariablesPower.
Power Calibration and Power Corrections (see: 9.5.3 Dynamic Power Correction), if enabled, remain active during bitmap marking and consequently influence the actual power sent to the laser.

Reference

JumpAndShootItemT