This factory allows you to create style expressions that can be used when styling data. More...

Static Public Member Functions
static StyleExpression< double >	Abs (StyleExpression< double > value)
	Creates an expression that returns an expression with the absolute value. More...

static StyleExpression< T >	Acos< T > (StyleExpression< T > operand)
	Creates an expression that takes the arccosine of another expression. More...

static StyleExpression< T >	Add< T, U > (StyleExpression< T > first, StyleExpression< U > second)
	Creates an expression that adds the values of the two provided expressions. More...

static StyleExpression< bool >	AndOp (StyleExpression< bool > value1, StyleExpression< bool > value2)
	Creates an expression that is the boolean 'and' of its parts. More...

static StyleExpression< T >	Asin< T > (StyleExpression< T > operand)
	Creates an expression that takes the arcsine of another expression. More...

static StyleExpression< T >	Atan< T > (StyleExpression< T > operand)
	Creates an expression that takes the arcsine of another expression. More...

static StyleExpression< bool >	Between (StyleExpression< double > lowerBound, StyleExpression< double > upperBound, StyleExpression< double > value)
	Creates an expression that evaluates whether the result of the operand is between a lower and upper bound (inclusive). More...

static StyleExpression< T >	Cases< T > (StyleExpression< T > defaultExpression, IList< StyleExpression< bool > > conditions, IList< StyleExpression< T > > expressions)
	Creates a case expression, which has a list of condition expressions and a list of corresponding result expressions, and evaluates to the first result expression whose corresponding condition is true. More...

static StyleExpression< T >	Clamp< T, U > (StyleExpression< T > operand, StyleExpression< U > lowerBound, StyleExpression< U > upperBound)
	Creates an expression that limits an operand to a range. More...

static StyleExpression< Color >	ColorAttribute (string attributeName)
	Creates an attribute expression that represents a color. More...

static StyleExpression< T >	Constant< T > (T value)
	Creates an expression that represents a 'constant' value. More...

static StyleExpression< Coordinate >	CoordinateAttribute (string attributeName)
	Creates an attribute expression that represents a coordinate. More...

static StyleExpression< T >	Cos< T > (StyleExpression< T > operand)
	Creates an expression that takes the cosine of another expression. More...

static StyleExpression< Coordinate >	CrossProduct (StyleExpression< Coordinate > first, StyleExpression< Coordinate > second)
	Creates an expression that calculates the cross product of two expressions representing Coordinate. More...

static StyleExpression< Color >	DefaultColor ()
	Creates an expression representing the default color that is applied to a mesh. More...

static StyleExpression< double >	Distance< T > (StyleExpression< T > first, StyleExpression< T > second)
	Creates an expression that calculates the Euclidean distance between two expressions representing points. More...

static StyleExpression< T >	Divide< T, U > (StyleExpression< T > first, StyleExpression< U > second)
	Creates an expression that divides the value of the first expression by the value of the second expression. More...

static StyleExpression< double >	DotProduct< T > (StyleExpression< T > first, StyleExpression< T > second)
	Creates an expression that calculates the dot product of the given expressions. More...

static StyleExpression< double >	DoubleAttribute (string attributeName)
	Creates an attribute expression that represents a double. More...

static StyleExpression< bool >	Eq (StyleExpression< double > first, StyleExpression< double > second, StyleExpression< double > threshold)
	Creates an expression that evaluates whether the two given expression evaluate to close values, given some threshold. More...

static StyleExpression< bool >	Eq< T > (StyleExpression< T > first, StyleExpression< T > second)
	Creates an expression that evaluates whether the two given expression evaluate to the same value. More...

static StyleExpression< T >	Fraction< T, U > (StyleExpression< T > operand, StyleExpression< U > lowerBound, StyleExpression< U > upperBound)
	Creates an expression that calculates the fraction of the given operand in the range [lowerBound, upperBound] evaluates to (operand - lowerBound) / (upperBound - lowerBound). More...

static StyleExpression< bool >	FrontFacing ()
	Creates an expression that determines whether a part of a mesh is facing to or away from the camera. More...

static StyleExpression< bool >	Gt (StyleExpression< double > first, StyleExpression< double > second)
	Creates an expression that evaluates whether the result of the first expression is strictly greater than the result of the second expression. More...

static StyleExpression< bool >	Gte (StyleExpression< double > first, StyleExpression< double > second)
	Creates an expression that evaluates whether the result of the first expression is greater than or equal to the result of the second expression. More...

static StyleExpression< T >	IfThenElse< T > (StyleExpression< bool > condition, StyleExpression< T > thenExpression, StyleExpression< T > elseExpression)
	Creates an expression that implements if-then-else logic. More...

static StyleExpression< double >	Length (StyleExpression< Coordinate > operand)
	Creates an expression that calculates the length of a Coordinate. More...

static StyleExpression< T >	Log< T > (StyleExpression< T > operand)
	Creates an expression that takes the natural logarithm of another expression. More...

static StyleExpression< bool >	Lt (StyleExpression< double > first, StyleExpression< double > second)
	Creates an expression that evaluates whether the result of the first expression is strictly less than the result of the second expression. More...

static StyleExpression< bool >	Lte (StyleExpression< double > first, StyleExpression< double > second)
	Creates an expression that evaluates whether the result of the first expression is less than or equal to the result of the second expression. More...

static StyleExpression< T >	Map< T > (StyleExpression< double > indexExpression, IList< StyleExpression< T > > values, StyleExpression< T > defaultExpression)
	Creates an expression that maps an index onto an expression. More...

static StyleExpression< T >	Max< T, U > (StyleExpression< T > first, StyleExpression< U > second)
	Creates an expression that returns the maximum of the given expressions. More...

static StyleExpression< T >	Min< T, U > (StyleExpression< T > first, StyleExpression< U > second)
	Creates an expression that returns the minimum of the given expressions. More...

static StyleExpression< T >	Mix< T > (StyleExpression< T > first, StyleExpression< T > second, StyleExpression< double > fraction)
	Creates an expression that calculates an interpolated or extrapolated result between the result of first and second based on the result of fraction. More...

static StyleExpression< T >	MixMap< T > (StyleExpression< double > fraction, IList< StyleExpression< T > > values)
	Creates an expression that creates an interpolated value according to a provided fraction. More...

static StyleExpression< T >	Multiply< T, U > (StyleExpression< T > first, StyleExpression< U > second)
	Creates an expression that multiplies the values of the two provided expressions. More...

static StyleExpression< bool >	Neq< T > (StyleExpression< T > first, StyleExpression< T > second)
	Creates an expression that evaluates whether the two given expression do not evaluate to the same value. More...

static StyleExpression< Coordinate >	Normalize (StyleExpression< Coordinate > operand)
	Creates an expression that normalizes a Coordinate. More...

static StyleExpression< bool >	NotOp (StyleExpression< bool > value)
	Creates an expression that is the boolean 'not' of the given expression. More...

static StyleExpression< bool >	OrOp (StyleExpression< bool > value1, StyleExpression< bool > value2)
	Creates an expression that is the boolean 'or' of its parts. More...

static StyleExpression< T >	Parameter< T > (Observable< T > observable)
	Creates a parameter expression that is a style expression that can be changed at runtime. More...

static StyleExpression< Coordinate >	PositionAttribute ()
	Creates an expression that represents the position of the data that is styled. More...

static StyleExpression< T >	Pow< T > (StyleExpression< T > first, StyleExpression< T > second)
	Creates an expression that returns the result of the first expression raised to the power of the result of the second expression. More...

static StyleExpression< T >	Sin< T > (StyleExpression< T > operand)
	Creates an expression that takes the sine of another expression. More...

static StyleExpression< T >	Subtract< T, U > (StyleExpression< T > first, StyleExpression< U > second)
	Creates an expression that subtracts the value of the second expression from the value of the first expression. More...

static StyleExpression< T >	Tan< T > (StyleExpression< T > operand)
	Creates an expression that takes the tangent of another expression. More...

Detailed Description

This factory allows you to create style expressions that can be used when styling data.

Boolean operations: and, or, not, eq, neq, lt, lte, gt, gte Numerical operations: min, max, clamp, mix, add, subtract, multiply, divide, between, fraction Control operations: ifThenElse, map, mixMap, cases Value expressions: constant, attribute (double), attribute (color), attribute (coordinate), attribute (position), parameter Trigonometric operations: sin, cos, tan, asin, acos, atan Vector operations: cross product, dot product, divide, multiply, add, substract Distance operations: distance, length

Example: if (value1 < value2) { return "Color(255, 55, 55, 127)"; else { return "Color(55, 255, 55, 127)"; } can be converted to an expression:

2022.0

Warning: C# documentation translation is incomplete. You can find more information in the C++ documentation for luciad::StyleExpressionFactory.

Member Function Documentation

◆ Abs()

Luciad.Layers.Styles.Expressions.StyleExpression< double > Luciad.Layers.Styles.Expressions.StyleExpressionFactory.Abs ( StyleExpression< double > value )

inlinestatic

Creates an expression that returns an expression with the absolute value.

value

the input for the abs function

the absolute value of the given expression

Warning: C# documentation translation is incomplete. You can find more information in the C++ documentation for luciad::StyleExpressionFactory::abs.

◆ Acos< T >()

Luciad.Layers.Styles.Expressions.StyleExpression< T > Luciad.Layers.Styles.Expressions.StyleExpressionFactory.Acos< T > ( StyleExpression< T > operand )

inlinestatic

Creates an expression that takes the arccosine of another expression.

operand

the expression of which to take the arccosine. For Coordinate, the function is applied to the individual element values.

T

the type of the operand. Can be double, Coordinate.

an expression that takes the arccosine of another expression, in radians. Results in a double, Coordinate.

Warning: C# documentation translation is incomplete. You can find more information in the C++ documentation for luciad::StyleExpressionFactory::acos.

◆ Add< T, U >()

Luciad.Layers.Styles.Expressions.StyleExpression< T > Luciad.Layers.Styles.Expressions.StyleExpressionFactory.Add< T, U >	(	StyleExpression< T >	first,
		StyleExpression< U >	second
	)

inlinestatic

Creates an expression that adds the values of the two provided expressions.

If both expressions are of the same type, the values are added as expected. If the first expression is of type Coordinate or Color, and second expression is of type double, then the value of second expression is added to every sub element of the first expression (note that for Color, each component is treated as a normalized value ([0, 1])).

first

the first expression to be added

second

the second expression to be added

T

the type of the value of the first expression. Can be double, Coordinate or Color.

U

the type of the value of the second expression. Can be the same as T, or double.

an expression of the same type as first.

Warning: C# documentation translation is incomplete. You can find more information in the C++ documentation for luciad::StyleExpressionFactory::add.

◆ AndOp()

Luciad.Layers.Styles.Expressions.StyleExpression< bool > Luciad.Layers.Styles.Expressions.StyleExpressionFactory.AndOp	(	StyleExpression< bool >	value1,
		StyleExpression< bool >	value2
	)

inlinestatic

Creates an expression that is the boolean 'and' of its parts.

value1

the first expression to which the 'and' operator is applied

value2

the second expression to which the 'and' operator is applied

an expression that is the boolean 'and' of the given expressions

Warning: C# documentation translation is incomplete. You can find more information in the C++ documentation for luciad::StyleExpressionFactory::andOp.

◆ Asin< T >()

Luciad.Layers.Styles.Expressions.StyleExpression< T > Luciad.Layers.Styles.Expressions.StyleExpressionFactory.Asin< T > ( StyleExpression< T > operand )

inlinestatic

Creates an expression that takes the arcsine of another expression.

operand

the expression of which to take the arcsine. For Coordinate, the function is applied to the individual element values.

T

the type of the operand. Can be double, Coordinate.

an expression that takes the arcsine of another expression, in radians. Results in a double, Coordinate.

Warning: C# documentation translation is incomplete. You can find more information in the C++ documentation for luciad::StyleExpressionFactory::asin.

◆ Atan< T >()

Luciad.Layers.Styles.Expressions.StyleExpression< T > Luciad.Layers.Styles.Expressions.StyleExpressionFactory.Atan< T > ( StyleExpression< T > operand )

inlinestatic

Creates an expression that takes the arcsine of another expression.

operand

the expression of which to take the arctangent. For Coordinate, the function is applied to the individual element values.

T

the type of the operand. Can be double, Coordinate.

an expression that takes the arctangent of another expression, in radians. Results in a double, Coordinate.

Warning: C# documentation translation is incomplete. You can find more information in the C++ documentation for luciad::StyleExpressionFactory::atan.

◆ Between()

Luciad.Layers.Styles.Expressions.StyleExpression< bool > Luciad.Layers.Styles.Expressions.StyleExpressionFactory.Between	(	StyleExpression< double >	lowerBound,
		StyleExpression< double >	upperBound,
		StyleExpression< double >	value
	)

inlinestatic

Creates an expression that evaluates whether the result of the operand is between a lower and upper bound (inclusive).

In other words, this expression checks whether operand is in the range [lowerBound, upperBound].

lowerBound

a double expression representing the lowerBound

upperBound

a double expression representing the upperBound

value

the double expression to test

an expression that evaluates to true if and only if value is in the range [lowerBound, upperBound].

Warning: C# documentation translation is incomplete. You can find more information in the C++ documentation for luciad::StyleExpressionFactory::between.

◆ Cases< T >()

Luciad.Layers.Styles.Expressions.StyleExpression< T > Luciad.Layers.Styles.Expressions.StyleExpressionFactory.Cases< T >	(	StyleExpression< T >	defaultExpression,
		IList< StyleExpression< bool > >	conditions,
		IList< StyleExpression< T > >	expressions
	)

inlinestatic

Creates a case expression, which has a list of condition expressions and a list of corresponding result expressions, and evaluates to the first result expression whose corresponding condition is true.

If none of the condition expressions are true, then the case expression evaluates to its default expression.

defaultExpression

the default expression

conditions

a list of conditions

expressions

a list of corresponding expressions, must be the same size as conditions

T

the type of the value of the expressions. Can be bool, double, Coordinate or Color.

an expression of the same type as defaultExpression

Warning: C# documentation translation is incomplete. You can find more information in the C++ documentation for luciad::StyleExpressionFactory::cases.

◆ Clamp< T, U >()

Luciad.Layers.Styles.Expressions.StyleExpression< T > Luciad.Layers.Styles.Expressions.StyleExpressionFactory.Clamp< T, U >	(	StyleExpression< T >	operand,
		StyleExpression< U >	lowerBound,
		StyleExpression< U >	upperBound
	)

inlinestatic

Creates an expression that limits an operand to a range.

The type of the bounds has to be the same. For Coordinate or Color, the clamping is applied to each component independently, either using the corresponding component in the bound (if of the same type as operand) or the bound value if double (note that for Color, each component is treated as a normalized value ([0, 1])).

operand

the operand to evaluate. Should result in a double, point or color.

lowerBound

a double expression representing the lowerBound

upperBound

a double expression representing the upperBound

T

the type of the operand: double, Coordinate or Color.

U

the type of lowerBound and upperBound. Must be equal to T, or double.

an expression (of the same type as operand) that limits the value of range to the range [lowerBound, upperBound]. If operand is a Color or Coordinate and bounds are doubles, the operation is applies to the individual element values.

Warning: C# documentation translation is incomplete. You can find more information in the C++ documentation for luciad::StyleExpressionFactory::clamp.

◆ ColorAttribute()

Luciad.Layers.Styles.Expressions.StyleExpression< System.Drawing.Color > Luciad.Layers.Styles.Expressions.StyleExpressionFactory.ColorAttribute ( string attributeName )

inlinestatic

Creates an attribute expression that represents a color.

Expressions are evaluated for certain objects. Those object may have attributes ascribed to them. This expression allows access to those attributes by name. Which attributes are available depends on the evaluator of the expression, and on the data itself. For example, for OGC 3D tiles point cloud data, there is no fixed set of available attributes, but data files can define certain attributes, like 'color' or 'intensity' for each of the points in the point cloud. When these attributes are known up-front, you can use them as part of the style expression, for example to give each point its actual color, or to create a color based on the intensity value. You can discover which attributes you can use in the documentation of the model decoder of the format that is used. For example: Ogc3DTilesModelDecoder::decode HspcModelDecoder::decode

When you display 3D tiles data, the layer only loads a subset of the available attributes in memory by default. To make sure that all required attributes are loaded, you must specify which attributes are used in the style expressions.

attributeName

the name of the attribute.

a color expression that represents the value for the given attribute

Warning: C# documentation translation is incomplete. You can find more information in the C++ documentation for luciad::StyleExpressionFactory::colorAttribute.

◆ Constant< T >()

Luciad.Layers.Styles.Expressions.StyleExpression< T > Luciad.Layers.Styles.Expressions.StyleExpressionFactory.Constant< T > ( T value )

inlinestatic

Creates an expression that represents a 'constant' value.

value

a value for the constant.

T

the type of the constant: double, bool, Coordinate or Color.

an expression that represents a constant value.

Warning: C# documentation translation is incomplete. You can find more information in the C++ documentation for luciad::StyleExpressionFactory::constant.

◆ CoordinateAttribute()

Luciad.Layers.Styles.Expressions.StyleExpression< Luciad.Cartesian.Coordinate > Luciad.Layers.Styles.Expressions.StyleExpressionFactory.CoordinateAttribute ( string attributeName )

inlinestatic

Creates an attribute expression that represents a coordinate.

Expressions are evaluated for certain objects. Those object may have attributes ascribed to them. This expression allows access to those attributes by name. Which attributes are available depends on the evaluator of the expression, and on the data itself. For example, for OGC 3D tiles point cloud data, there is no fixed set of available attributes, but data files can define certain attributes, like 'color' or 'intensity' for each of the points in the point cloud. When these attributes are known up-front, you can use them as part of the style expression, for example to give each point its actual color, or to create a color based on the intensity value. You can discover which attributes you can use in the documentation of the model decoder of the format that is used. For example: Ogc3DTilesModelDecoder::decode HspcModelDecoder::decode

When you display 3D tiles data, the layer only loads a subset of the available attributes in memory by default. To make sure that all required attributes are loaded, you must specify which attributes are used in the style expressions.

attributeName

the name of the attribute.

a coordinate expression that represents the value for the given attribute

Warning: C# documentation translation is incomplete. You can find more information in the C++ documentation for luciad::StyleExpressionFactory::coordinateAttribute.

◆ Cos< T >()

Luciad.Layers.Styles.Expressions.StyleExpression< T > Luciad.Layers.Styles.Expressions.StyleExpressionFactory.Cos< T > ( StyleExpression< T > operand )

inlinestatic

Creates an expression that takes the cosine of another expression.

operand

the expression of which to take the cosine. For Coordinate, the function is applied to the individual element values. Values assumed to be in radians.

T

the type of the operand. Can be double or Coordinate.

an expression that takes the cosine of another expression. Results in a double, Coordinate.

Warning: C# documentation translation is incomplete. You can find more information in the C++ documentation for luciad::StyleExpressionFactory::cos.

◆ CrossProduct()

Luciad.Layers.Styles.Expressions.StyleExpression< Luciad.Cartesian.Coordinate > Luciad.Layers.Styles.Expressions.StyleExpressionFactory.CrossProduct	(	StyleExpression< Coordinate >	first,
		StyleExpression< Coordinate >	second
	)

inlinestatic

Creates an expression that calculates the cross product of two expressions representing Coordinate.

first

The first expression to evaluate.

second

The second expression to evaluate.

An expression that calculates the cross product of the given expressions. Results in a Coordinate (vector).

Warning: C# documentation translation is incomplete. You can find more information in the C++ documentation for luciad::StyleExpressionFactory::crossProduct.

◆ DefaultColor()

Luciad.Layers.Styles.Expressions.StyleExpression< System.Drawing.Color > Luciad.Layers.Styles.Expressions.StyleExpressionFactory.DefaultColor ( )

inlinestatic

Creates an expression representing the default color that is applied to a mesh.

The result depends on what is available in the data. It can be the color of a texture, a color attribute, a constant color default, etc. This type of expression is only supported for mesh styling expressions used by TileSet3DLayer. an expression representing the default color that is applied to a mesh.

Warning: C# documentation translation is incomplete. You can find more information in the C++ documentation for luciad::StyleExpressionFactory::defaultColor.

◆ Distance< T >()

Luciad.Layers.Styles.Expressions.StyleExpression< double > Luciad.Layers.Styles.Expressions.StyleExpressionFactory.Distance< T >	(	StyleExpression< T >	first,
		StyleExpression< T >	second
	)

inlinestatic

Creates an expression that calculates the Euclidean distance between two expressions representing points.

The distance is defined as follows for the following supported types:

double: the distance between the double values: abs(second - first). Coordinate: the regular cartesian distance: sqrt(x*x + y*y + z*z).

first

the first expression

second

the second expression

T

the type of expressions: double, Coordinate.

an expression that calculates the Euclidean distance between two expressions.

Warning: C# documentation translation is incomplete. You can find more information in the C++ documentation for luciad::StyleExpressionFactory::distance.

◆ Divide< T, U >()

Luciad.Layers.Styles.Expressions.StyleExpression< T > Luciad.Layers.Styles.Expressions.StyleExpressionFactory.Divide< T, U >	(	StyleExpression< T >	first,
		StyleExpression< U >	second
	)

inlinestatic

Creates an expression that divides the value of the first expression by the value of the second expression.

If both expressions are of the same type, the values are divided component by component. If the first expression is of type Coordinate or Color, and second expression is of type double, then every sub element of the first expression is divided by the value of second expression (note that for Color, each component is treated as a normalized value ([0, 1])).

first

the dividend expression

second

the divisor expression

T

the type of the value of the first expression. Can be double, Coordinate or Color.

U

the type of the value of the second expression. Can be the same as T, or double.

an expression of the same type as first.

Warning: C# documentation translation is incomplete. You can find more information in the C++ documentation for luciad::StyleExpressionFactory::divide.

◆ DotProduct< T >()

Luciad.Layers.Styles.Expressions.StyleExpression< double > Luciad.Layers.Styles.Expressions.StyleExpressionFactory.DotProduct< T >	(	StyleExpression< T >	first,
		StyleExpression< T >	second
	)

inlinestatic

Creates an expression that calculates the dot product of the given expressions.

The type of the result of the two given expressions should be the same. You can take the dot product of doubles or Coordinate. Coordinates interpreted as vectors for this operation.

first

The first expression to evaluate. Should result in a double, Coordinate.

second

The second expression to evaluate. Should result in the same type as first.

T

the type of the first and second expressions: double, Coordinate.

An expression that calculates the dot product of the given expressions. Results in a double.

Warning: C# documentation translation is incomplete. You can find more information in the C++ documentation for luciad::StyleExpressionFactory::dotProduct.

◆ DoubleAttribute()

Luciad.Layers.Styles.Expressions.StyleExpression< double > Luciad.Layers.Styles.Expressions.StyleExpressionFactory.DoubleAttribute ( string attributeName )

inlinestatic

Creates an attribute expression that represents a double.

Expressions are evaluated for certain objects. Those object may have attributes ascribed to them. This expression allows access to those attributes by name. Which attributes are available depends on the evaluator of the expression, and on the data itself. For example, for OGC 3D tiles point cloud data, there is no fixed set of available attributes, but data files can define certain attributes, like 'color' or 'intensity' for each of the points in the point cloud. When these attributes are known up-front, you can use them as part of the style expression, for example to give each point its actual color, or to create a color based on the intensity value. You can discover which attributes you can use in the documentation of the model decoder of the format that is used. For example: Ogc3DTilesModelDecoder::decode HspcModelDecoder::decode

When you display 3D tiles data, the layer only loads a subset of the available attributes in memory by default. To make sure that all required attributes are loaded, you must specify which attributes are used in the style expressions.

attributeName

the name of the attribute.

a double expression that represents the value for the given attribute

Warning: C# documentation translation is incomplete. You can find more information in the C++ documentation for luciad::StyleExpressionFactory::doubleAttribute.

◆ Eq()

Luciad.Layers.Styles.Expressions.StyleExpression< bool > Luciad.Layers.Styles.Expressions.StyleExpressionFactory.Eq	(	StyleExpression< double >	first,
		StyleExpression< double >	second,
		StyleExpression< double >	threshold
	)

inlinestatic

Creates an expression that evaluates whether the two given expression evaluate to close values, given some threshold.

The size of the threshold depends on the values you want to compare: when you want to compare floating point values, you need to take into account that during rendering the values are represented as 32-bit floating point (float) values. So the size of the threshold depends on the magnitude of the values that are used, and the float precision. when you want to compare values that represent integers, this method should be used with a threshold of 0.5.

first

The first expression to evaluate

second

The second expression to evaluate

threshold

The Expression describing the maximum threshold before considering both values too far from each other.

An expression that evaluates to true if the two expressions evaluate to close values, given the maximum threshold.

Warning: C# documentation translation is incomplete. You can find more information in the C++ documentation for luciad::StyleExpressionFactory::eq.

◆ Eq< T >()

Luciad.Layers.Styles.Expressions.StyleExpression< bool > Luciad.Layers.Styles.Expressions.StyleExpressionFactory.Eq< T >	(	StyleExpression< T >	first,
		StyleExpression< T >	second
	)

inlinestatic

Creates an expression that evaluates whether the two given expression evaluate to the same value.

Note: in most cases, it is advised to use a threshold when comparing values. This can be done using the eq method that also takes a threshold expression as parameter.

first

the first expression to be compared

second

the second expression to be compared

T

the type of the value of both expressions. Can be bool, double, Coordinate or Color.

a boolean expression that evaluates to true if and only if both expressions evaluate to the same value.

Warning: C# documentation translation is incomplete. You can find more information in the C++ documentation for luciad::StyleExpressionFactory::eq.

◆ Fraction< T, U >()

Luciad.Layers.Styles.Expressions.StyleExpression< T > Luciad.Layers.Styles.Expressions.StyleExpressionFactory.Fraction< T, U >	(	StyleExpression< T >	operand,
		StyleExpression< U >	lowerBound,
		StyleExpression< U >	upperBound
	)

inlinestatic

Creates an expression that calculates the fraction of the given operand in the range [lowerBound, upperBound] evaluates to (operand - lowerBound) / (upperBound - lowerBound).

For values of operand outside the range [lowerBound, upperBound], the results will lie outside the range [0, 1]. If the operand is of type Coordinate or Color and the bounds are of type double, the result will be of the same type as the operand with fraction being applied on each component (note that for Color, each component is treated as a normalized value ([0, 1])).

operand

the operand to evaluate

lowerBound

the lowerBound to evaluate.

upperBound

the upperBoundBound to evaluate.

T

the type of the operand: double, Coordinate or Color.

U

the type of lowerBound and upperBound. Must be equal to T, or double.

an expression of the same type as operand

Warning: C# documentation translation is incomplete. You can find more information in the C++ documentation for luciad::StyleExpressionFactory::fraction.

◆ FrontFacing()

Luciad.Layers.Styles.Expressions.StyleExpression< bool > Luciad.Layers.Styles.Expressions.StyleExpressionFactory.FrontFacing ( )

inlinestatic

Creates an expression that determines whether a part of a mesh is facing to or away from the camera.

You can for example use it in a color expression to distinguish front-facing from back-facing pixels, and render those differently. This type of expression is only supported for mesh styling expressions used by TileSet3DLayer. The facing is determined based on triangle winding. If you simply wish to hide back-faced triangles, use MeshStyle::Builder::facetCulling with FacetCullingType::BackfaceCulling as parameter. an expression that determines whether a part of a mesh is facing to or away from the camera.

Warning: C# documentation translation is incomplete. You can find more information in the C++ documentation for luciad::StyleExpressionFactory::frontFacing.

◆ Gt()

Luciad.Layers.Styles.Expressions.StyleExpression< bool > Luciad.Layers.Styles.Expressions.StyleExpressionFactory.Gt	(	StyleExpression< double >	first,
		StyleExpression< double >	second
	)

inlinestatic

Creates an expression that evaluates whether the result of the first expression is strictly greater than the result of the second expression.

first

the first double expression to be compared

second

the second double expression to be compared

a boolean expression that evaluates to true if and only if first evaluates to a double greater than second

Warning: C# documentation translation is incomplete. You can find more information in the C++ documentation for luciad::StyleExpressionFactory::gt.

◆ Gte()

Luciad.Layers.Styles.Expressions.StyleExpression< bool > Luciad.Layers.Styles.Expressions.StyleExpressionFactory.Gte	(	StyleExpression< double >	first,
		StyleExpression< double >	second
	)

inlinestatic

Creates an expression that evaluates whether the result of the first expression is greater than or equal to the result of the second expression.

first

the first double expression to be compared

second

the second double expression to be compared

a boolean expression that evaluates to true if and only if first evaluates to a double greater than or equal to second

Warning: C# documentation translation is incomplete. You can find more information in the C++ documentation for luciad::StyleExpressionFactory::gte.

◆ IfThenElse< T >()

Luciad.Layers.Styles.Expressions.StyleExpression< T > Luciad.Layers.Styles.Expressions.StyleExpressionFactory.IfThenElse< T >	(	StyleExpression< bool >	condition,
		StyleExpression< T >	thenExpression,
		StyleExpression< T >	elseExpression
	)

inlinestatic

Creates an expression that implements if-then-else logic.

condition

the expression that decides which of the other expressions to take

thenExpression

the expression whose result will be returned if condition is true

elseExpression

the expression whose result will be returned if condition is false

T

the type of the value of thenExpression and elseExpression. Can be bool, double, Coordinate or Color.

an expression that return the result of one of the other expressions, based on the condition

Warning: C# documentation translation is incomplete. You can find more information in the C++ documentation for luciad::StyleExpressionFactory::ifThenElse.

◆ Length()

Luciad.Layers.Styles.Expressions.StyleExpression< double > Luciad.Layers.Styles.Expressions.StyleExpressionFactory.Length ( StyleExpression< Coordinate > operand )

inlinestatic

Creates an expression that calculates the length of a Coordinate.

operand

The expression to evaluate.

an expression that computes the length as a number.

Warning: C# documentation translation is incomplete. You can find more information in the C++ documentation for luciad::StyleExpressionFactory::length.

◆ Log< T >()

Luciad.Layers.Styles.Expressions.StyleExpression< T > Luciad.Layers.Styles.Expressions.StyleExpressionFactory.Log< T > ( StyleExpression< T > operand )

inlinestatic

Creates an expression that takes the natural logarithm of another expression.

operand

The expression of which to take the natural logarithm. Should result in a double, Coordinate.

T

the type of the operand expression: double, Coordinate.

an expression that takes the natural logarithm of another expression.

Warning: C# documentation translation is incomplete. You can find more information in the C++ documentation for luciad::StyleExpressionFactory::log.

◆ Lt()

Luciad.Layers.Styles.Expressions.StyleExpression< bool > Luciad.Layers.Styles.Expressions.StyleExpressionFactory.Lt	(	StyleExpression< double >	first,
		StyleExpression< double >	second
	)

inlinestatic

Creates an expression that evaluates whether the result of the first expression is strictly less than the result of the second expression.

first

the first double expression to be compared

second

the second double expression to be compared

a boolean expression that evaluates to true if and only if first evaluates to a double less than second

Warning: C# documentation translation is incomplete. You can find more information in the C++ documentation for luciad::StyleExpressionFactory::lt.

◆ Lte()

Luciad.Layers.Styles.Expressions.StyleExpression< bool > Luciad.Layers.Styles.Expressions.StyleExpressionFactory.Lte	(	StyleExpression< double >	first,
		StyleExpression< double >	second
	)

inlinestatic

Creates an expression that evaluates whether the result of the first expression is less than or equal to the result of the second expression.

first

the first double expression to be compared

second

the second double expression to be compared

a boolean expression that evaluates to true if and only if first evaluates to a double less than or equal to second

Warning: C# documentation translation is incomplete. You can find more information in the C++ documentation for luciad::StyleExpressionFactory::lte.

◆ Map< T >()

Luciad.Layers.Styles.Expressions.StyleExpression< T > Luciad.Layers.Styles.Expressions.StyleExpressionFactory.Map< T >	(	StyleExpression< double >	indexExpression,
		IList< StyleExpression< T > >	values,
		StyleExpression< T >	defaultExpression
	)

inlinestatic

Creates an expression that maps an index onto an expression.

The expression first determines an index, then evaluates the expression corresponding to the index. The indexExpression must evaluate to an integer value in the range [0, size(values) - 1] to be valid.

indexExpression

The expression that calculates the index to use.

values

an array of value expressions

defaultExpression

The expression used as default when the computed index is either not an integer or out of range.

T

the type of expressions in values: double, Coordinate or Color.

An expression that maps an index onto an expression.

Warning: C# documentation translation is incomplete. You can find more information in the C++ documentation for luciad::StyleExpressionFactory::map.

◆ Max< T, U >()

Luciad.Layers.Styles.Expressions.StyleExpression< T > Luciad.Layers.Styles.Expressions.StyleExpressionFactory.Max< T, U >	(	StyleExpression< T >	first,
		StyleExpression< U >	second
	)

inlinestatic

Creates an expression that returns the maximum of the given expressions.

first

The first expression to evaluate. Should result in a double, point or color.

second

The second expression to evaluate. Should result in the same type as first or a double.

T

the type of the first expression: double, Coordinate or Color.

U

the type of the second expression. Must be equal to T, or double.

an expression that resolves to the maximum of the two provided expressions. When a double is used with another type, the operation is applied to the individual element values and the result is of the other type (note that for Color, each component is treated as a normalized value ([0, 1])).

Warning: C# documentation translation is incomplete. You can find more information in the C++ documentation for luciad::StyleExpressionFactory::max.

◆ Min< T, U >()

Luciad.Layers.Styles.Expressions.StyleExpression< T > Luciad.Layers.Styles.Expressions.StyleExpressionFactory.Min< T, U >	(	StyleExpression< T >	first,
		StyleExpression< U >	second
	)

inlinestatic

Creates an expression that returns the minimum of the given expressions.

first

The first expression to evaluate. Should result in a double, point or color.

second

The second expression to evaluate. Should result in the same type as first or a double.

T

the type of the first expression: double, Coordinate or Color.

U

the type of the second expression. Must be equal to T, or double.

an expression that resolves to the minimum of the two provided expressions. When a double is used with another type, the operation is applied to the individual element values and the result is of the other type (note that for Color, each component is treated as a normalized value ([0, 1])).

Warning: C# documentation translation is incomplete. You can find more information in the C++ documentation for luciad::StyleExpressionFactory::min.

◆ Mix< T >()

Luciad.Layers.Styles.Expressions.StyleExpression< T > Luciad.Layers.Styles.Expressions.StyleExpressionFactory.Mix< T >	(	StyleExpression< T >	first,
		StyleExpression< T >	second,
		StyleExpression< double >	fraction
	)

inlinestatic

Creates an expression that calculates an interpolated or extrapolated result between the result of first and second based on the result of fraction.

first

the first expression that is mixed

second

the second expression that is mixed

fraction

the mixing fraction. In range [0, 1] for interpolation. May also be a value outside that interval for extrapolation.

T

the type of the value to mix. Can be double, Coordinate or Color.

an expression that calculates an interpolated or extrapolated result between the result of first and second based on the result of the fraction expression. Results in a double, point or color depending on the type of the operands.

Warning: C# documentation translation is incomplete. You can find more information in the C++ documentation for luciad::StyleExpressionFactory::mix.

◆ MixMap< T >()

Luciad.Layers.Styles.Expressions.StyleExpression< T > Luciad.Layers.Styles.Expressions.StyleExpressionFactory.MixMap< T >	(	StyleExpression< double >	fraction,
		IList< StyleExpression< T > >	values
	)

inlinestatic

Creates an expression that creates an interpolated value according to a provided fraction.

This expression is not limited to doubles, but can also be used to interpolate points or colors.

fraction

a fraction, in range [0,1]

values

an array of value expressions

T

the type of values. Can be double, Coordinate or Color.

an expression that creates an interpolated value.

Warning: C# documentation translation is incomplete. You can find more information in the C++ documentation for luciad::StyleExpressionFactory::mixMap.

◆ Multiply< T, U >()

Luciad.Layers.Styles.Expressions.StyleExpression< T > Luciad.Layers.Styles.Expressions.StyleExpressionFactory.Multiply< T, U >	(	StyleExpression< T >	first,
		StyleExpression< U >	second
	)

inlinestatic

Creates an expression that multiplies the values of the two provided expressions.

If both expressions are of the same type, the values are multiplied component by component. If the first expression is of type Coordinate or Color, and second expression is of type double, then the value of second expression is multiplied with every sub element of the first expression (note that for Color, each component is treated as a normalized value ([0, 1])).

first

the first expression to be multiplied

second

the second expression to be multiplied

T

the type of the value of the first expression. Can be double, Coordinate or Color.

U

the type of the value of the second expression. Can be the same as T, or double.

an expression of the same type as first.

Warning: C# documentation translation is incomplete. You can find more information in the C++ documentation for luciad::StyleExpressionFactory::multiply.

◆ Neq< T >()

Luciad.Layers.Styles.Expressions.StyleExpression< bool > Luciad.Layers.Styles.Expressions.StyleExpressionFactory.Neq< T >	(	StyleExpression< T >	first,
		StyleExpression< T >	second
	)

inlinestatic

Creates an expression that evaluates whether the two given expression do not evaluate to the same value.

first

the first expression to be compared

second

the second expression to be compared

T

the type of the value of both expressions. Can be bool, double, Coordinate or Color.

a boolean expression that evaluates to true if and only if the expressions evaluate to different values

Warning: C# documentation translation is incomplete. You can find more information in the C++ documentation for luciad::StyleExpressionFactory::neq.

◆ Normalize()

Luciad.Layers.Styles.Expressions.StyleExpression< Luciad.Cartesian.Coordinate > Luciad.Layers.Styles.Expressions.StyleExpressionFactory.Normalize ( StyleExpression< Coordinate > operand )

inlinestatic

Creates an expression that normalizes a Coordinate.

operand

The expression to evaluate.

an expression the computes the normalized Coordinate.

Warning: C# documentation translation is incomplete. You can find more information in the C++ documentation for luciad::StyleExpressionFactory::normalize.

◆ NotOp()

Luciad.Layers.Styles.Expressions.StyleExpression< bool > Luciad.Layers.Styles.Expressions.StyleExpressionFactory.NotOp ( StyleExpression< bool > value )

inlinestatic

Creates an expression that is the boolean 'not' of the given expression.

value

a boolean expression

an expression that is the boolean 'not' of the given expression

Warning: C# documentation translation is incomplete. You can find more information in the C++ documentation for luciad::StyleExpressionFactory::notOp.

◆ OrOp()

Luciad.Layers.Styles.Expressions.StyleExpression< bool > Luciad.Layers.Styles.Expressions.StyleExpressionFactory.OrOp	(	StyleExpression< bool >	value1,
		StyleExpression< bool >	value2
	)

inlinestatic

Creates an expression that is the boolean 'or' of its parts.

value1

the first expression to which the 'or' operator is applied

value2

the second expression to which the 'or' operator is applied

an expression that is the boolean 'or' of the given expressions

Warning: C# documentation translation is incomplete. You can find more information in the C++ documentation for luciad::StyleExpressionFactory::orOp.

◆ Parameter< T >()

Luciad.Layers.Styles.Expressions.StyleExpression< T > Luciad.Layers.Styles.Expressions.StyleExpressionFactory.Parameter< T > ( Observable< T > observable )

inlinestatic

Creates a parameter expression that is a style expression that can be changed at runtime.

When it is changed, the styling will be updated to reflect the new value without having to re-create the expressions in which it is used. This makes it possible to make changes to the styling with almost-zero overhead.

observable

an object that represents a mutable value. Users can hold on to this Observable in order to change the parameter value.

T

the type of the constant: double, bool, Coordinate or Color.

a new parameter expression

Warning: C# documentation translation is incomplete. You can find more information in the C++ documentation for luciad::StyleExpressionFactory::parameter.

◆ PositionAttribute()

Luciad.Layers.Styles.Expressions.StyleExpression< Luciad.Cartesian.Coordinate > Luciad.Layers.Styles.Expressions.StyleExpressionFactory.PositionAttribute ( )

inlinestatic

Creates an expression that represents the position of the data that is styled.

For example, for point clouds it represents for the position of an individual point in that point cloud. This for example makes it possible to adapt the transparency of points of a point cloud depending on their distance from an other location. a coordinate expression that represents the position of the data that is being styled.

Warning: C# documentation translation is incomplete. You can find more information in the C++ documentation for luciad::StyleExpressionFactory::positionAttribute.

◆ Pow< T >()

Luciad.Layers.Styles.Expressions.StyleExpression< T > Luciad.Layers.Styles.Expressions.StyleExpressionFactory.Pow< T >	(	StyleExpression< T >	first,
		StyleExpression< T >	second
	)

inlinestatic

Creates an expression that returns the result of the first expression raised to the power of the result of the second expression.

The type of the operands should be the same. The (elements of the) first argument must not be less than 0 and if it is 0, the (corresponding elements of the) second argument must be greater than 0.

first

The first expression to evaluate. Should result in a double, Coordinate or Color.

second

The second expression to evaluate. Should result in the same type as first.

T

the type of the expressions: double, Coordinate.

An expression that returns the result of the first expression to the power of the result of the second expression. Results in a double, Coordinate depending on the type of the operands.

Warning: C# documentation translation is incomplete. You can find more information in the C++ documentation for luciad::StyleExpressionFactory::pow.

◆ Sin< T >()

Luciad.Layers.Styles.Expressions.StyleExpression< T > Luciad.Layers.Styles.Expressions.StyleExpressionFactory.Sin< T > ( StyleExpression< T > operand )

inlinestatic

Creates an expression that takes the sine of another expression.

operand

the expression of which to take the sine. For Coordinate, the function is applied to the individual element values. Values assumed to be in radians.

T

the type of the operand. Can be double, Coordinate.

an expression that takes the sine of another expression. Results in a double, Coordinate.

Warning: C# documentation translation is incomplete. You can find more information in the C++ documentation for luciad::StyleExpressionFactory::sin.

◆ Subtract< T, U >()

Luciad.Layers.Styles.Expressions.StyleExpression< T > Luciad.Layers.Styles.Expressions.StyleExpressionFactory.Subtract< T, U >	(	StyleExpression< T >	first,
		StyleExpression< U >	second
	)

inlinestatic

Creates an expression that subtracts the value of the second expression from the value of the first expression.

If both expressions are of the same type, the values are subtracted as expected. If the first expression is of type Coordinate or Color, and second expression is of type double, then the value of second expression is subtracted from every sub element of the first expression (note that for Color, each component is treated as a normalized value ([0, 1])).

first

the expression to be subtracted from

second

the expression to be subtracted

T

the type of the value of the first expression. Can be double, Coordinate or Color.

U

the type of the value of the second expression. Can be the same as T, or double.

an expression of the same type as first.

Warning: C# documentation translation is incomplete. You can find more information in the C++ documentation for luciad::StyleExpressionFactory::subtract.

◆ Tan< T >()

Luciad.Layers.Styles.Expressions.StyleExpression< T > Luciad.Layers.Styles.Expressions.StyleExpressionFactory.Tan< T > ( StyleExpression< T > operand )

inlinestatic

Creates an expression that takes the tangent of another expression.

operand

the expression of which to take the tangent. For Coordinate, the function is applied to the individual element values. Values assumed to be in radians.

T

the type of the operand. Can be double, Coordinate.

an expression that takes the tangent of another expression. Results in a double, Coordinate.

Warning: C# documentation translation is incomplete. You can find more information in the C++ documentation for luciad::StyleExpressionFactory::tan.

Static Public Member Functions

Detailed Description

Member Function Documentation

◆ Abs()

◆ Acos< T >()

◆ Add< T, U >()

◆ AndOp()

◆ Asin< T >()

◆ Atan< T >()

◆ Between()

◆ Cases< T >()

◆ Clamp< T, U >()

◆ ColorAttribute()

◆ Constant< T >()

◆ CoordinateAttribute()

◆ Cos< T >()

◆ CrossProduct()

◆ DefaultColor()

◆ Distance< T >()

◆ Divide< T, U >()

◆ DotProduct< T >()

◆ DoubleAttribute()

◆ Eq()

◆ Eq< T >()

◆ Fraction< T, U >()

◆ FrontFacing()

◆ Gt()

◆ Gte()

◆ IfThenElse< T >()

◆ Length()

◆ Log< T >()

◆ Lt()

◆ Lte()

◆ Map< T >()

◆ Max< T, U >()

◆ Min< T, U >()

◆ Mix< T >()

◆ MixMap< T >()

◆ Multiply< T, U >()

◆ Neq< T >()

◆ Normalize()

◆ NotOp()

◆ OrOp()

◆ Parameter< T >()

◆ PositionAttribute()

◆ Pow< T >()

◆ Sin< T >()

◆ Subtract< T, U >()

◆ Tan< T >()