luciad::ComplexStrokePatternFactory Class Reference

Factory to create all patterns that are used to create complex strokes. More...

#include <luciad/layers/styles/complexstrokes/ComplexStrokePatternFactory.h>

Public Member Functions
	ComplexStrokePatternFactory ()=delete
	~ComplexStrokePatternFactory ()=delete

Static Public Member Functions
static ComplexStrokePattern	allowOverlap (const ComplexStrokePattern &pattern, double overlapLeft, double overlapRight)
	Creates a pattern that allows for overlap of patterns on the left and right side of the given pattern. More...
static ComplexStrokePattern	appendPatterns (const std::vector< ComplexStrokePattern > &patterns)
	Creates a pattern consisting of multiple sub-patterns appended together, painting them next to each other. More...
static ArcPatternBuilder	arcBuilder ()
	Creates a builder used to make patterns with an arc, ellipse or circle shape. More...
static ArrowPatternBuilder	arrowBuilder ()
	Creates a builder used to make patterns with an arrow shape. More...
static ComplexStrokePattern	atomic (const ComplexStrokePattern &pattern)
	Creates a pattern that ensures that sub-patterns are always painted together. More...
static ComplexStrokePattern	combineWithFallback (const ComplexStrokePattern &pattern)
	Creates a pattern that allows the fallback pattern to be painted on top of the given pattern. More...
static ComplexStrokePattern	combineWithRegular (const ComplexStrokePattern &pattern)
	Creates a pattern that allows the regular pattern to be painted on top of the given pattern. More...
static ComplexStrokePattern	composePatterns (const std::vector< ComplexStrokePattern > &patterns)
	Creates a pattern consisting of multiple sub-patterns that are painted on top of each other. More...
static ComplexStrokePattern	gapFixed (double fixedLength)
	Creates a gap pattern, which does not paint anything. More...
static ComplexStrokePattern	gapRelative (double relativeLength)
	Creates a gap pattern, which does not paint anything. More...
static IconPatternBuilder	iconBuilder ()
	Creates a builder used to make patterns containing an icon. More...
static LinePatternBuilder	lineBuilder ()
	Creates a builder used to make patterns with a line segment shape. More...
static ParallelLinePatternBuilder	parallelLineBuilder ()
	Creates a builder used to make patterns with a line segment shape that is parallel to the base line. More...
static PolylinePatternBuilder	polylineBuilder ()
	Creates a builder used to make patterns with a polyline shape. More...
static RectanglePatternBuilder	rectangleBuilder ()
	Creates a builder used to make patterns with a rectangle shape. More...
static ComplexStrokePattern	repeat (const ComplexStrokePattern &pattern, uint32_t count)
	Creates a pattern that repeats a pattern a fixed number of times. More...
static ComplexStrokePattern	repeatOverLengthFixed (const ComplexStrokePattern &pattern, double fixedLength)
	Creates a pattern that repeats a pattern over a given length. More...
static ComplexStrokePattern	repeatOverLengthRelative (const ComplexStrokePattern &pattern, double relativeLength)
	Creates a pattern that repeats the given pattern over a given length. More...
static TextPatternBuilder	textBuilder ()
	Creates a builder used to make patterns containing text. More...
static TrianglePatternBuilder	triangleBuilder ()
	Creates a builder used to make patterns with a triangle shape. More...
static WavePatternBuilder	waveBuilder ()
	Creates a builder used to make patterns with a wave shape. More...

Detailed Description

Factory to create all patterns that are used to create complex strokes.

Since

2023.1

Constructor & Destructor Documentation

ComplexStrokePatternFactory()

luciad::ComplexStrokePatternFactory::ComplexStrokePatternFactory ( )

delete

~ComplexStrokePatternFactory()

luciad::ComplexStrokePatternFactory::~ComplexStrokePatternFactory ( )

delete

Member Function Documentation

allowOverlap()

static ComplexStrokePattern luciad::ComplexStrokePatternFactory::allowOverlap ( const ComplexStrokePattern &  pattern, double  overlapLeft, double  overlapRight  )

static

Creates a pattern that allows for overlap of patterns on the left and right side of the given pattern.

Note that the given pattern must be a pattern with a fixed (non-relative) length for the overlap to work.

In the following examples, two half circles are painted next to each other. This is done twice. The first time, no overlap is allowed. The second time, overlap is allowed:

Sample code:

    auto leftArc = ComplexStrokePatternFactory::arcBuilder().minorRadius(20).fixedLength(40).angle(180).lineColor(Color::red()).lineWidth(2).build();
    auto rightArc = ComplexStrokePatternFactory::arcBuilder()
                        .minorRadius(20)
                        .fixedLength(40)
                        .angle(180)
                        .startAngle(180)
                        .lineColor(Color::blue())
                        .lineWidth(2)
                        .build();
 
    auto arcs = ComplexStrokePatternFactory::appendPatterns({leftArc, rightArc});
    ComplexStrokeLineStyle strokeStyle = ComplexStrokeLineStyle::newBuilder()
                                             .fallback(ComplexStrokePatternFactory::parallelLineBuilder().build())
                                             .addDecoration(arcs, 0.5)
                                             .build();
 
    auto leftArcAllowOverlap = ComplexStrokePatternFactory::allowOverlap(leftArc, 0, 8);
    auto rightArcAllowOverlap = ComplexStrokePatternFactory::allowOverlap(rightArc, 8, 0);
    auto arcsOverlap = ComplexStrokePatternFactory::appendPatterns({leftArcAllowOverlap, rightArcAllowOverlap});
 
    ComplexStrokeLineStyle strokeStyleOverlap = ComplexStrokeLineStyle::newBuilder()
                                                    .fallback(ComplexStrokePatternFactory::parallelLineBuilder().build())
                                                    .addDecoration(arcsOverlap, 0.5)
                                                    .build();

Results in:

allowOverlap example

Parameters

pattern	the pattern to allow overlaps.
overlapLeft	The allowed overlap on the left, in pixels.
overlapRight	The allowed overlap on the right, in pixels.

Returns

A pattern that allows overlap with other patterns.

Exceptions

luciad::InvalidArgumentException

overlapLeft and overlapRight must be >=0.

appendPatterns()

static ComplexStrokePattern luciad::ComplexStrokePatternFactory::appendPatterns ( const std::vector< ComplexStrokePattern > &  patterns )

static

Creates a pattern consisting of multiple sub-patterns appended together, painting them next to each other.

Sample code:

    auto pattern1 = ComplexStrokePatternFactory::arcBuilder().fixedLength(40).minorRadius(20).lineWidth(2).build();
    auto pattern2 = ComplexStrokePatternFactory::arcBuilder().fixedLength(40).minorRadius(20).lineWidth(2).lineColor(Color::red()).build();
    auto appendPattern = ComplexStrokePatternFactory::appendPatterns({pattern1, pattern2});
    ComplexStrokeLineStyle strokeStyle = ComplexStrokeLineStyle::newBuilder()
                                             .fallback(ComplexStrokePatternFactory::parallelLineBuilder().build())
                                             .addDecoration(appendPattern, 0.5)
                                             .build();

Results in:

appendPatterns example

Parameters

patterns

patterns to append, may not be empty.

Returns

a new pattern consisting of the appended patterns.

Exceptions

luciad::InvalidArgumentException

patterns may not be empty.

arcBuilder()

static ArcPatternBuilder luciad::ComplexStrokePatternFactory::arcBuilder ( )

static

Creates a builder used to make patterns with an arc, ellipse or circle shape.

You can define the length and minor radius to create an ellipse (or a circle by setting the minor radius to be half of the length), and use the angle and startAngle to paint only a part of the ellipse.

angle and startAngle work counter clockwise and a startAngle of 0 means the arc starts on the baseline on the point the furthest from the start of the baselise. On a horizontal line going from left to right, this would be the right-most point of the arc. A startAngle of 90 in this case means the arc starts above the baseline.

Sample code:

    ComplexStrokePattern arc1 = ComplexStrokePatternFactory::arcBuilder().fixedLength(30).minorRadius(15).build();
 
    ComplexStrokePattern arc2 = ComplexStrokePatternFactory::arcBuilder().fixedLength(30).minorRadius(10).angle(200).fillColor(Color::red()).build();
 
    ComplexStrokePattern arc3 = ComplexStrokePatternFactory::arcBuilder()
                                    .fixedLength(40)
                                    .minorRadius(15)
                                    .startAngle(225)
                                    .angle(270)
                                    .lineWidth(3)
                                    .lineColor(Color::blue())
                                    .fillColor(Color::red())
                                    .build();
 
    ComplexStrokeLineStyle strokeStyle = ComplexStrokeLineStyle::newBuilder()
                                             .fallback(ComplexStrokePatternFactory::parallelLineBuilder().build())
                                             .addDecoration(arc1, 0.2)
                                             .addDecoration(arc2, 0.5)
                                             .addDecoration(arc3, 0.8)
                                             .build();

Results in:

arc pattern example

Returns

the pattern builder.

arrowBuilder()

static ArrowPatternBuilder luciad::ComplexStrokePatternFactory::arrowBuilder ( )

static

Creates a builder used to make patterns with an arrow shape.

Sample code:

    auto arrow = ComplexStrokePatternFactory::arrowBuilder().size(10).type(ComplexStrokePatternArrowType::PlainOutlined).build();
 
    ComplexStrokeLineStyle strokeStyle = ComplexStrokeLineStyle::newBuilder()
                                             .fallback(ComplexStrokePatternFactory::parallelLineBuilder().build())
                                             .addDecoration(arrow, 0.5)
                                             .build();

Results in:

arrow pattern example

Returns

the pattern builder.

atomic()

static ComplexStrokePattern luciad::ComplexStrokePatternFactory::atomic ( const ComplexStrokePattern &  pattern )

static

Creates a pattern that ensures that sub-patterns are always painted together.

By making a composed pattern (compose, append, repeat,...) atomic, you ensure that the composed pattern is never broken apart during painting. The sub-patterns will always be painted together, or not at all.

In the example image, the circle patterns are appended. When they are not atomic, the sub-patterns of the appendPattern can be dropped individually. This is what happens in the first pattern. If there is not enough room for a circle to be placed, it is dropped.

However, in an atomic pattern, all sub-patterns of the appendPattern are dropped together if one of them does not have enough space. This is useful when you are appending multiple patterns, where it is important that all sub-patterns are always visible at the same time.

Sample code:

    auto circle1 = ComplexStrokePatternFactory::arcBuilder().fixedLength(16).minorRadius(8).lineColor(Color::blue()).build();
    auto circle2 = ComplexStrokePatternFactory::arcBuilder().fixedLength(16).minorRadius(8).lineColor(Color::red()).build();
    auto line = ComplexStrokePatternFactory::lineBuilder().fixedLength(6).build();
    auto appendedPattern = ComplexStrokePatternFactory::appendPatterns({line, circle1, circle2, line});
    ComplexStrokeLineStyle strokeStyle = ComplexStrokeLineStyle::newBuilder()
                                             .fallback(ComplexStrokePatternFactory::parallelLineBuilder().build())
                                             .regular(appendedPattern)
                                             .build();
 
    auto atomicPattern = ComplexStrokePatternFactory::atomic(appendedPattern);
    ComplexStrokeLineStyle atomicStrokeStyle = ComplexStrokeLineStyle::newBuilder()
                                                   .fallback(ComplexStrokePatternFactory::parallelLineBuilder().build())
                                                   .regular(atomicPattern)
                                                   .build();

Results in:

atomic pattern example

Parameters

pattern

The pattern to make atomic.

Returns

An atomic version of the pattern.

combineWithFallback()

static ComplexStrokePattern luciad::ComplexStrokePatternFactory::combineWithFallback ( const ComplexStrokePattern &  pattern )

static

Creates a pattern that allows the fallback pattern to be painted on top of the given pattern.

Normally, a fallback pattern is only painted where no other pattern could be painted. This pattern wrapper adds an exception to this. When a pattern is wrapped with a combineWithFallback, this pattern can be painted in addition to a fallback pattern. This is useful when adding a non-filled arrowhead, as in the image example.

Sample code:

    auto line = ComplexStrokePatternFactory::parallelLineBuilder().lineWidth(2).build();
 
    auto arrowPattern = ComplexStrokePatternFactory::arrowBuilder().size(10).lineWidth(2).type(ComplexStrokePatternArrowType::Plain).build();
    ComplexStrokeLineStyle strokeStyleTop = ComplexStrokeLineStyle::newBuilder().fallback(line).addDecoration(arrowPattern, 1.0).build();
 
    auto combineWithFallbackPattern = ComplexStrokePatternFactory::combineWithFallback(arrowPattern);
    ComplexStrokeLineStyle strokeStyleBottom = ComplexStrokeLineStyle::newBuilder().fallback(line).addDecoration(combineWithFallbackPattern, 1.0).build();

Results in:

combineWithFallback pattern example

Parameters

pattern

The pattern to combine with the fallback pattern.

Returns

a pattern that allows the fallback pattern to be combined with this pattern.

combineWithRegular()

static ComplexStrokePattern luciad::ComplexStrokePatternFactory::combineWithRegular ( const ComplexStrokePattern &  pattern )

static

Creates a pattern that allows the regular pattern to be painted on top of the given pattern.

A regular pattern is a pattern that is repeated along the whole line. Normally, a regular pattern is only painted where no decorations could be painted. This pattern wrapper adds an exception to this. When a pattern is wrapped with a combineWithRegular pattern, the pattern can be painted in addition to the regular pattern. This is useful for adding a non-filled arrowhead,as in the example.

In the example there is still a small gap. This is because regular patterns don't get cut off but get dropped instead, while fallback patterns do get cut off.

Note that using this pattern wrapper implies that a fallback pattern can be painted as well (if part of the regular pattern cannot be painted).

Also note that if no regular pattern is specified, then this pattern is combined with the fallback pattern instead, as if you are using combineWithFallback.

Sample code:

    auto line = ComplexStrokePatternFactory::parallelLineBuilder().lineWidth(2).build();
 
    auto arrowPattern = ComplexStrokePatternFactory::arrowBuilder().size(10).lineWidth(2).type(ComplexStrokePatternArrowType::Plain).build();
    ComplexStrokeLineStyle strokeStyleTop = ComplexStrokeLineStyle::newBuilder().regular(line).addDecoration(arrowPattern, 1.0).build();
 
    auto combineWithRegularPattern = ComplexStrokePatternFactory::combineWithRegular(arrowPattern);
    ComplexStrokeLineStyle strokeStyleBottom = ComplexStrokeLineStyle::newBuilder().regular(line).addDecoration(combineWithRegularPattern, 1.0).build();

Results in:

combineWithRegular pattern example

Parameters

pattern

The pattern to combine with the regular pattern.

Returns

a pattern that allows the regular pattern to be combined with this pattern.

composePatterns()

static ComplexStrokePattern luciad::ComplexStrokePatternFactory::composePatterns ( const std::vector< ComplexStrokePattern > &  patterns )

static

Creates a pattern consisting of multiple sub-patterns that are painted on top of each other.

If one of the strokes has a different length than the other strokes, it is aligned to the center of the largest stroke.

In the following example, a horizontal red line and half a red circle are composed.

Sample code:

    auto pattern1 = ComplexStrokePatternFactory::arcBuilder().fixedLength(40).minorRadius(20).lineWidth(2).angle(180).lineColor(Color::red()).build();
    auto pattern2 = ComplexStrokePatternFactory::lineBuilder().fixedLength(40).lineWidth(2).lineColor(Color::red()).build();
    auto composedPattern = ComplexStrokePatternFactory::composePatterns({pattern1, pattern2});
    ComplexStrokeLineStyle strokeStyle = ComplexStrokeLineStyle::newBuilder()
                                             .fallback(ComplexStrokePatternFactory::parallelLineBuilder().build())
                                             .addDecoration(composedPattern, 0.5)
                                             .build();

Results in:

composePatterns example

Parameters

patterns

patterns to compose, may not be empty.

Returns

A new pattern that composes a number of sub-patterns.

Exceptions

luciad::InvalidArgumentException

patterns may not be empty.

gapFixed()

static ComplexStrokePattern luciad::ComplexStrokePatternFactory::gapFixed ( double  fixedLength )

static

Creates a gap pattern, which does not paint anything.

A gap pattern occupies space only. It can be used to add space in between other strokes.

Sample code:

    auto gapPattern = ComplexStrokePatternFactory::gapFixed(15);
    auto circle = ComplexStrokePatternFactory::arcBuilder().fixedLength(30).minorRadius(15).build();
    auto pattern = ComplexStrokePatternFactory::appendPatterns({gapPattern, circle, gapPattern});
 
    ComplexStrokeLineStyle strokeStyle = ComplexStrokeLineStyle::newBuilder()
                                             .fallback(ComplexStrokePatternFactory::parallelLineBuilder().build())
                                             .addDecoration(pattern, 0.5)
                                             .build();

Results in:

fixed length gap pattern example

Parameters

fixedLength

the length of the gap in pixels.

Returns

a gap pattern.

Exceptions

luciad::InvalidArgumentException

fixedLength must be >=0.

gapRelative()

static ComplexStrokePattern luciad::ComplexStrokePatternFactory::gapRelative ( double  relativeLength )

static

Creates a gap pattern, which does not paint anything.

A gap pattern occupies space only. It can be used to add space in between other strokes.

Sample code:

    auto gapPattern = ComplexStrokePatternFactory::gapRelative(0.05);
    auto circle = ComplexStrokePatternFactory::arcBuilder().fixedLength(30).minorRadius(15).build();
    auto pattern = ComplexStrokePatternFactory::appendPatterns({gapPattern, circle, gapPattern});
 
    ComplexStrokeLineStyle strokeStyle = ComplexStrokeLineStyle::newBuilder()
                                             .fallback(ComplexStrokePatternFactory::parallelLineBuilder().build())
                                             .addDecoration(pattern, 0.5)
                                             .build();

Results in:

relative length gap pattern example

Parameters

relativeLength

the length (relative to the length of the entire line, [0,1]) of the gap.

Returns

a gap pattern.

Exceptions

luciad::InvalidArgumentException

relativeLength must be in range [0,1].

iconBuilder()

static IconPatternBuilder luciad::ComplexStrokePatternFactory::iconBuilder ( )

static

Creates a builder used to make patterns containing an icon.

The icon must be set by calling the icon method before calling build. All other methods are optional.

Sample code:

    std::shared_ptr<IIcon> icon = ImageIcon::create("test/resources/icons/closecross.png");
    auto iconPattern = ComplexStrokePatternFactory::iconBuilder().icon(icon).build();
 
    ComplexStrokeLineStyle strokeStyle = ComplexStrokeLineStyle::newBuilder()
                                             .fallback(ComplexStrokePatternFactory::parallelLineBuilder().build())
                                             .addDecoration(iconPattern, 0.5)
                                             .build();

Results in:

icon pattern example

Returns

the pattern builder.

lineBuilder()

static LinePatternBuilder luciad::ComplexStrokePatternFactory::lineBuilder ( )

static

Creates a builder used to make patterns with a line segment shape.

A line segment is defined by:

• a length, meaning the distance between its start and end points
• the offsets of the start and end points with respect to the base line.
• styling properties: the width and color

Note that the difference with a parallel line is that a line has rounded corners, whereas a parallel line does not have rounded corners.

Sample code:

    auto lineLeft = ComplexStrokePatternFactory::lineBuilder().fixedLength(20).lineWidth(3).offset1(20).build();
    auto lineRight = ComplexStrokePatternFactory::lineBuilder().fixedLength(20).lineWidth(3).offset0(20).build();
    auto pattern = ComplexStrokePatternFactory::appendPatterns({lineLeft, lineRight});
 
    auto lineLeftFilled = ComplexStrokePatternFactory::lineBuilder().fixedLength(30).fillColor(Color::red()).offset0(20).offset1(40).build();
    auto lineRightFilled = ComplexStrokePatternFactory::lineBuilder().fixedLength(30).fillColor(Color::blue()).offset0(40).offset1(20).build();
    auto patternFilled = ComplexStrokePatternFactory::appendPatterns({lineLeftFilled, lineRightFilled});
 
    ComplexStrokeLineStyle strokeStyle = ComplexStrokeLineStyle::newBuilder()
                                             .fallback(ComplexStrokePatternFactory::parallelLineBuilder().build())
                                             .addDecoration(pattern, 0.33)
                                             .addDecoration(patternFilled, 0.66)
                                             .build();

Results in:

lineBuilder example

Returns

the pattern builder.

parallelLineBuilder()

static ParallelLinePatternBuilder luciad::ComplexStrokePatternFactory::parallelLineBuilder ( )

static

Creates a builder used to make patterns with a line segment shape that is parallel to the base line.

Note that the difference with a line is that a line has rounded corners, whereas a parallel line does not have rounded corners.

Sample code:

    auto parallelLineLeft = ComplexStrokePatternFactory::parallelLineBuilder().fixedLength(30).lineWidth(3).offset(10).build();
    auto parallelLineRight = ComplexStrokePatternFactory::parallelLineBuilder().fixedLength(30).lineWidth(3).offset(-10).build();
    auto pattern = ComplexStrokePatternFactory::appendPatterns({parallelLineLeft, parallelLineRight});
 
    ComplexStrokeLineStyle strokeStyle = ComplexStrokeLineStyle::newBuilder()
                                             .fallback(ComplexStrokePatternFactory::parallelLineBuilder().build())
                                             .addDecoration(pattern, 0.5)
                                             .build();

Results in:

parallelLine pattern example

Returns

the pattern builder.

polylineBuilder()

static PolylinePatternBuilder luciad::ComplexStrokePatternFactory::polylineBuilder ( )

static

Creates a builder used to make patterns with a polyline shape.

The polyline's points must be set by calling the points method before calling build. All other methods are optional.

Sample code:

    auto polylinePattern = ComplexStrokePatternFactory::polylineBuilder().points({{0, 10}, {20, 10}, {30, 0}, {20, -10}, {0, -10}, {0, 10}}).build();
 
    ComplexStrokeLineStyle strokeStyle = ComplexStrokeLineStyle::newBuilder()
                                             .fallback(ComplexStrokePatternFactory::parallelLineBuilder().build())
                                             .addDecoration(polylinePattern, 0.5)
                                             .build();

Results in:

polyline pattern example

Returns

the pattern builder.

rectangleBuilder()

static RectanglePatternBuilder luciad::ComplexStrokePatternFactory::rectangleBuilder ( )

static

Creates a builder used to make patterns with a rectangle shape.

Sample code:

    auto rectangleSide = ComplexStrokePatternFactory::rectangleBuilder().lineColor(Color::red()).minHeight(-10).maxHeight(10).fixedLength(10).build();
    auto rectangleCenter = ComplexStrokePatternFactory::rectangleBuilder()
                               .lineColor(Color::fromDoubles(1.0, 0.64, 0.0))
                               .minHeight(-10)
                               .maxHeight(0)
                               .fixedLength(20)
                               .build();
    auto gap = ComplexStrokePatternFactory::gapFixed(1);
    auto pattern = ComplexStrokePatternFactory::appendPatterns({rectangleSide, gap, rectangleCenter, gap, rectangleSide});
 
    auto rectangleSideFilled = ComplexStrokePatternFactory::rectangleBuilder().fillColor(Color::red()).minHeight(-10).maxHeight(10).fixedLength(10).build();
    auto rectangleCenterFilled = ComplexStrokePatternFactory::rectangleBuilder()
                                     .lineColor(Color::red())
                                     .fillColor(Color::fromDoubles(1.0, 0.64, 0.0))
                                     .minHeight(-9)
                                     .maxHeight(0)
                                     .fixedLength(20)
                                     .build();
    auto patternFilled = ComplexStrokePatternFactory::appendPatterns({rectangleSideFilled, rectangleCenterFilled, rectangleSideFilled});
 
    ComplexStrokeLineStyle strokeStyle = ComplexStrokeLineStyle::newBuilder()
                                             .fallback(ComplexStrokePatternFactory::parallelLineBuilder().build())
                                             .addDecoration(pattern, 0.33)
                                             .addDecoration(patternFilled, 0.66)
                                             .build();

Results in:

rectangle pattern example

Returns

the pattern builder.

repeat()

static ComplexStrokePattern luciad::ComplexStrokePatternFactory::repeat ( const ComplexStrokePattern &  pattern, uint32_t  count  )

static

Creates a pattern that repeats a pattern a fixed number of times.

Note that with this pattern, there is no guarantee that the given number of patterns is actually painted. This also depends on the line on which the complex stroke is painted. For example, if the line is too short, not all of the patterns may fit on it. If one of the repeated patterns crosses a sharp corner, it may be omitted as well. In that case, the regular or fallback patterns may be painted instead.

In the following example, a circular arc pattern is repeated 3 times:

Sample code:

    auto circle = ComplexStrokePatternFactory::arcBuilder().minorRadius(15).fixedLength(30).build();
    auto repeatedCircle = ComplexStrokePatternFactory::repeat(circle, 3);
 
    ComplexStrokeLineStyle strokeStyle = ComplexStrokeLineStyle::newBuilder()
                                             .fallback(ComplexStrokePatternFactory::parallelLineBuilder().build())
                                             .addDecoration(repeatedCircle, 0.5)
                                             .build();

Results in:

repeat pattern example

Parameters

pattern	the pattern to repeat.
count	the number of times to repeat the pattern. Must be greater than or equal to 1.

Returns

pattern that repeats another pattern a fixed number of times.

repeatOverLengthFixed()

static ComplexStrokePattern luciad::ComplexStrokePatternFactory::repeatOverLengthFixed ( const ComplexStrokePattern &  pattern, double  fixedLength  )

static

Creates a pattern that repeats a pattern over a given length.

This length is a fixed length (in pixels).

Sample code:

    auto circle = ComplexStrokePatternFactory::arcBuilder().minorRadius(8).fixedLength(16).build();
    auto repeatedCircle = ComplexStrokePatternFactory::repeatOverLengthFixed(circle, 100);
    ComplexStrokeLineStyle strokeStyle = ComplexStrokeLineStyle::newBuilder()
                                             .fallback(ComplexStrokePatternFactory::parallelLineBuilder().build())
                                             .addDecoration(repeatedCircle, 0.5)
                                             .build();

Results in:

repeatOverLengthFixed pattern example

Parameters

pattern	the pattern to repeat.
fixedLength	the length (in pixels) over which the pattern should be repeated.

Returns

A pattern that repeats another pattern over a given length.

Exceptions

luciad::InvalidArgumentException

fixedLength must be >0.

repeatOverLengthRelative()

static ComplexStrokePattern luciad::ComplexStrokePatternFactory::repeatOverLengthRelative ( const ComplexStrokePattern &  pattern, double  relativeLength  )

static

Creates a pattern that repeats the given pattern over a given length.

This is a length relative to the length of the line.

Sample code:

    auto circle = ComplexStrokePatternFactory::arcBuilder().minorRadius(8).fixedLength(16).build();
    auto repeatedCircle = ComplexStrokePatternFactory::repeatOverLengthRelative(circle, 0.5);
 
    ComplexStrokeLineStyle strokeStyle = ComplexStrokeLineStyle::newBuilder()
                                             .fallback(ComplexStrokePatternFactory::parallelLineBuilder().build())
                                             .addDecoration(repeatedCircle, 0.5)
                                             .build();

Results in:

repeatOverLengthRelative pattern example

Parameters

pattern	the pattern to repeat.
relativeLength	the length (relative to the length of the entire line, [0,1]) over which the pattern should be repeated.

Returns

A pattern that repeats another pattern over a given length.

Exceptions

luciad::InvalidArgumentException

relativeLength must be in range [0,1].

textBuilder()

static TextPatternBuilder luciad::ComplexStrokePatternFactory::textBuilder ( )

static

Creates a builder used to make patterns containing text.

The text must be set by calling a text method before calling build. All other methods are optional.

Sample code:

    auto textStyle = TextStyle::newBuilder().fontName("Arial Black").fontSize(16).haloWidth(0).build();
    auto textPattern = ComplexStrokePatternFactory::textBuilder().text("Read me").textStyle(textStyle).build();
 
    ComplexStrokeLineStyle strokeStyle = ComplexStrokeLineStyle::newBuilder()
                                             .fallback(ComplexStrokePatternFactory::parallelLineBuilder().build())
                                             .addDecoration(textPattern, 0.5)
                                             .build();

Results in:

text pattern example

Returns

the pattern builder.

triangleBuilder()

static TrianglePatternBuilder luciad::ComplexStrokePatternFactory::triangleBuilder ( )

static

Creates a builder used to make patterns with a triangle shape.

Sample code:

    auto triangle1 = ComplexStrokePatternFactory::triangleBuilder().lineColor(Color::blue()).lineWidth(2).p0({0, 10}).p1({0, -10}).p2({16, -10}).build();
    auto triangle2 = ComplexStrokePatternFactory::triangleBuilder().fillColor(Color::red()).p0({0, 10}).p1({16, 10}).p2({16, -10}).build();
    auto pattern = ComplexStrokePatternFactory::appendPatterns({triangle1, triangle2});
 
    ComplexStrokeLineStyle strokeStyle = ComplexStrokeLineStyle::newBuilder()
                                             .fallback(ComplexStrokePatternFactory::parallelLineBuilder().build())
                                             .addDecoration(pattern, 0.5)
                                             .build();

Results in:

triangle pattern example

Returns

the pattern builder.

waveBuilder()

static WavePatternBuilder luciad::ComplexStrokePatternFactory::waveBuilder ( )

static

Creates a builder used to make patterns with a wave shape.

More specifically, the wave shape follows a sine wave. Which part of the sine wave gets painted is determined by angle and startAngle. The amplitude (height) is set with amplitude. The wave is stretched over the given length.

In the first image below, we have horizontal lines going from left to right. As you see, a regular wave first goes up (or to the left of the baseline, if looking at it from the baseline's start towards the end), then back to the baseline, repeating the same shape below the baseline (i.e. to the right of the baseline when looking from the baseline's start).

The second wave is broken down in four separate colored segments each with an angle of 90, but with different startAngles.

wave pattern chopped in four segments

Created by the following code:

    auto wave = ComplexStrokePatternFactory::waveBuilder().angle(360).fixedLength(120).amplitude(20).startAngle(0).lineColor(Color::red()).lineWidth(2).build();
 
    //Blue from 0->90.
    auto waveSegment1 = ComplexStrokePatternFactory::waveBuilder()
                            .angle(90)
                            .fixedLength(30)
                            .amplitude(20)
                            .startAngle(0)
                            .lineColor(Color::blue())
                            .lineWidth(2)
                            .build();
    //Green from 90->180.
    auto waveSegment2 = ComplexStrokePatternFactory::waveBuilder()
                            .angle(90)
                            .fixedLength(30)
                            .amplitude(20)
                            .startAngle(90)
                            .lineColor(Color::green())
                            .lineWidth(2)
                            .build();
    //Magenta from 180->270
    auto waveSegment3 = ComplexStrokePatternFactory::waveBuilder()
                            .angle(90)
                            .fixedLength(30)
                            .amplitude(20)
                            .startAngle(180)
                            .lineColor(Color::magenta())
                            .lineWidth(2)
                            .build();
    //Yellow from 270->360
    auto waveSegment4 = ComplexStrokePatternFactory::waveBuilder()
                            .angle(90)
                            .fixedLength(30)
                            .amplitude(20)
                            .startAngle(270)
                            .lineColor(Color::yellow())
                            .lineWidth(2)
                            .build();
    auto waves = ComplexStrokePatternFactory::appendPatterns({waveSegment1, waveSegment2, waveSegment3, waveSegment4});
 
    ComplexStrokeLineStyle strokeStyleTop = ComplexStrokeLineStyle::newBuilder()
                                                .fallback(ComplexStrokePatternFactory::parallelLineBuilder().build())
                                                .addDecoration(wave, 0.5)
                                                .build();
 
    ComplexStrokeLineStyle strokeStyleBottom = ComplexStrokeLineStyle::newBuilder()
                                                   .fallback(ComplexStrokePatternFactory::parallelLineBuilder().build())
                                                   .addDecoration(waves, 0.5)
                                                   .build();

Note that, unlike most patterns, the wave can be partially drawn even as a regular or decoration pattern when there is not enough space and other patterns would be omitted in full. By making the wave atomic only the full wave pattern will be drawn.

Sample code:

    auto wave1 = ComplexStrokePatternFactory::waveBuilder().relativeLength(0.25).amplitude(20).angle(720).lineWidth(2).build();
    auto wave2 = ComplexStrokePatternFactory::waveBuilder().relativeLength(0.25).amplitude(20).fillColor(Color::green()).lineWidth(2).build();
    auto wave3 = ComplexStrokePatternFactory::waveBuilder()
                     .relativeLength(0.25)
                     .amplitude(30)
                     .lineColor(Color::red())
                     .fillColor(Color::yellow())
                     .lineWidth(2)
                     .build();
 
    auto waves = ComplexStrokePatternFactory::appendPatterns({wave1, wave2, wave3});
    ComplexStrokeLineStyle strokeStyle = ComplexStrokeLineStyle::newBuilder()
                                             .fallback(ComplexStrokePatternFactory::parallelLineBuilder().build())
                                             .addDecoration(waves, 0.5)
                                             .build();

Results in:

wave pattern example

Returns

the pattern builder.