default |
* l.pixeloffset = new Cartesian2(25, 75); |
*
x value
* controls horizontal padding, and the y value controls vertical padding.
* @memberof Label.prototype
* @type {Cartesian2}
* @default new Cartesian2(7, 5)
*/
backgroundPadding : {
get : function() {
return this._backgroundPadding;
},
set : function(value) {
//>>includeStart('debug', pragmas.debug);
if (!defined(value)) {
throw new DeveloperError('value is required.');
}
//>>includeEnd('debug');
var backgroundPadding = this._backgroundPadding;
if (!Cartesian2.equals(backgroundPadding, value)) {
Cartesian2.clone(value, backgroundPadding);
repositionAllGlyphs(this);
}
}
},
/**
* Gets or sets the style of this label.
* @memberof Label.prototype
* @type {LabelStyle}
* @default LabelStyle.FILL
*/
style : {
get : function() {
return this._style;
},
set : function(value) {
//>>includeStart('debug', pragmas.debug);
if (!defined(value)) {
throw new DeveloperError('value is required.');
}
//>>includeEnd('debug');
if (this._style !== value) {
this._style = value;
rebindAllGlyphs(this);
}
}
},
/**
* Gets or sets the pixel offset in screen space from the origin of this label. This is commonly used
* to align multiple labels and billboards at the same position, e.g., an image and text. The
* screen space origin is the top, left corner of the canvas; x increases from
* left to right, and y increases from top to bottom.
* default |
* l.pixeloffset = new Cartesian2(25, 75); |
*
x points towards the viewer's right, y points up, and
* z points into the screen. Eye coordinates use the same scale as world and model coordinates,
* which is typically meters.
*  |
*  |
*
l.eyeOffset = new Cartesian3(0.0, 8000000.0, 0.0);
1.0 does not change the size of the label; a scale greater than
* 1.0 enlarges the label; a positive scale less than 1.0 shrinks
* the label.
* 
0.5, 1.0,
* and 2.0.
* x increases from
* left to right, and y increases from top to bottom.
*
* @param {Scene} scene The scene the label is in.
* @param {Cartesian2} [result] The object onto which to store the result.
* @returns {Cartesian2} The screen-space position of the label.
*
*
* @example
* console.log(l.computeScreenSpacePosition(scene).toString());
*
* @see Label#eyeOffset
* @see Label#pixelOffset
*/
Label.prototype.computeScreenSpacePosition = function(scene, result) {
//>>includeStart('debug', pragmas.debug);
if (!defined(scene)) {
throw new DeveloperError('scene is required.');
}
//>>includeEnd('debug');
if (!defined(result)) {
result = new Cartesian2();
}
var labelCollection = this._labelCollection;
var modelMatrix = labelCollection.modelMatrix;
var actualPosition = defined(this._actualClampedPosition) ? this._actualClampedPosition : this._position;
var windowCoordinates = Billboard._computeScreenSpacePosition(modelMatrix, actualPosition,
this._eyeOffset, this._pixelOffset, scene, result);
return windowCoordinates;
};
/**
* Gets a label's screen space bounding box centered around screenSpacePosition.
* @param {Label} label The label to get the screen space bounding box for.
* @param {Cartesian2} screenSpacePosition The screen space center of the label.
* @param {BoundingRectangle} [result] The object onto which to store the result.
* @returns {BoundingRectangle} The screen space bounding box.
*
* @private
*/
Label.getScreenSpaceBoundingBox = function(label, screenSpacePosition, result) {
var x = 0;
var y = 0;
var width = 0;
var height = 0;
var scale = label.totalScale;
var backgroundBillboard = label._backgroundBillboard;
if (defined(backgroundBillboard)) {
x = screenSpacePosition.x + (backgroundBillboard._translate.x);
y = screenSpacePosition.y - (backgroundBillboard._translate.y);
width = backgroundBillboard.width * scale;
height = backgroundBillboard.height * scale;
if (label.verticalOrigin === VerticalOrigin.BOTTOM || label.verticalOrigin === VerticalOrigin.BASELINE) {
y -= height;
} else if (label.verticalOrigin === VerticalOrigin.CENTER) {
y -= height * 0.5;
}
} else {
x = Number.POSITIVE_INFINITY;
y = Number.POSITIVE_INFINITY;
var maxX = 0;
var maxY = 0;
var glyphs = label._glyphs;
var length = glyphs.length;
for (var i = 0; i < length; ++i) {
var glyph = glyphs[i];
var billboard = glyph.billboard;
if (!defined(billboard)) {
continue;
}
var glyphX = screenSpacePosition.x + (billboard._translate.x);
var glyphY = screenSpacePosition.y - (billboard._translate.y);
var glyphWidth = glyph.dimensions.width * scale;
var glyphHeight = glyph.dimensions.height * scale;
if (label.verticalOrigin === VerticalOrigin.BOTTOM || label.verticalOrigin === VerticalOrigin.BASELINE) {
glyphY -= glyphHeight;
} else if (label.verticalOrigin === VerticalOrigin.CENTER) {
glyphY -= glyphHeight * 0.5;
}
if (label._verticalOrigin === VerticalOrigin.TOP) {
glyphY += SDFSettings.PADDING * scale;
}
else if (label._verticalOrigin === VerticalOrigin.BOTTOM || label._verticalOrigin === VerticalOrigin.BASELINE) {
glyphY -= SDFSettings.PADDING * scale;
}
x = Math.min(x, glyphX);
y = Math.min(y, glyphY);
maxX = Math.max(maxX, glyphX + glyphWidth);
maxY = Math.max(maxY, glyphY + glyphHeight);
}
width = maxX - x;
height = maxY - y;
}
if (!defined(result)) {
result = new BoundingRectangle();
}
result.x = x;
result.y = y;
result.width = width;
result.height = height;
return result;
};
/**
* Determines if this label equals another label. Labels are equal if all their properties
* are equal. Labels in different collections can be equal.
*
* @param {Label} other The label to compare for equality.
* @returns {Boolean} true if the labels are equal; otherwise, false.
*/
Label.prototype.equals = function(other) {
return this === other ||
defined(other) &&
this._show === other._show &&
this._scale === other._scale &&
this._outlineWidth === other._outlineWidth &&
this._showBackground === other._showBackground &&
this._style === other._style &&
this._verticalOrigin === other._verticalOrigin &&
this._horizontalOrigin === other._horizontalOrigin &&
this._heightReference === other._heightReference &&
this._renderedText === other._renderedText &&
this._font === other._font &&
Cartesian3.equals(this._position, other._position) &&
Color.equals(this._fillColor, other._fillColor) &&
Color.equals(this._outlineColor, other._outlineColor) &&
Color.equals(this._backgroundColor, other._backgroundColor) &&
Cartesian2.equals(this._backgroundPadding, other._backgroundPadding) &&
Cartesian2.equals(this._pixelOffset, other._pixelOffset) &&
Cartesian3.equals(this._eyeOffset, other._eyeOffset) &&
NearFarScalar.equals(this._translucencyByDistance, other._translucencyByDistance) &&
NearFarScalar.equals(this._pixelOffsetScaleByDistance, other._pixelOffsetScaleByDistance) &&
NearFarScalar.equals(this._scaleByDistance, other._scaleByDistance) &&
DistanceDisplayCondition.equals(this._distanceDisplayCondition, other._distanceDisplayCondition) &&
this._disableDepthTestDistance === other._disableDepthTestDistance &&
this._id === other._id;
};
/**
* Returns true if this object was destroyed; otherwise, false.
* isDestroyed will result in a {@link DeveloperError} exception.
*
* @returns {Boolean} True if this object was destroyed; otherwise, false.
*/
Label.prototype.isDestroyed = function() {
return false;
};
/**
* Determines whether or not run the algorithm, that match the text of the label to right-to-left languages
* @memberof Label
* @type {Boolean}
* @default false
*
* @example
* // Example 1.
* // Set a label's rightToLeft before init
* Cesium.Label.enableRightToLeftDetection = true;
* var myLabelEntity = viewer.entities.add({
* label: {
* id: 'my label',
* text: 'זה טקסט בעברית \n ועכשיו יורדים שורה',
* }
* });
*
* @example
* // Example 2.
* var myLabelEntity = viewer.entities.add({
* label: {
* id: 'my label',
* text: 'English text'
* }
* });
* // Set a label's rightToLeft after init
* Cesium.Label.enableRightToLeftDetection = true;
* myLabelEntity.text = 'טקסט חדש';
*/
Label.enableRightToLeftDetection = false;
function convertTextToTypes(text, rtlChars) {
var ltrChars = /[a-zA-Z0-9]/;
var bracketsChars = /[()[\]{}<>]/;
var parsedText = [];
var word = '';
var lastType = textTypes.LTR;
var currentType = '';
var textLength = text.length;
for (var textIndex = 0; textIndex < textLength; ++textIndex) {
var character = text.charAt(textIndex);
if (rtlChars.test(character)) {
currentType = textTypes.RTL;
}
else if (ltrChars.test(character)) {
currentType = textTypes.LTR;
}
else if (bracketsChars.test(character)) {
currentType = textTypes.BRACKETS;
}
else {
currentType = textTypes.WEAK;
}
if (textIndex === 0) {
lastType = currentType;
}
if (lastType === currentType && currentType !== textTypes.BRACKETS) {
word += character;
}
else {
if (word !== '') {
parsedText.push({Type : lastType, Word : word});
}
lastType = currentType;
word = character;
}
}
parsedText.push({Type : currentType, Word : word});
return parsedText;
}
function reverseWord(word) {
return word.split('').reverse().join('');
}
function spliceWord(result, pointer, word) {
return result.slice(0, pointer) + word + result.slice(pointer);
}
function reverseBrackets(bracket) {
switch(bracket) {
case '(':
return ')';
case ')':
return '(';
case '[':
return ']';
case ']':
return '[';
case '{':
return '}';
case '}':
return '{';
case '<':
return '>';
case '>':
return '<';
}
}
//To add another language, simply add its Unicode block range(s) to the below regex.
var hebrew = '\u05D0-\u05EA';
var arabic = '\u0600-\u06FF\u0750-\u077F\u08A0-\u08FF';
var rtlChars = new RegExp('[' + hebrew + arabic + ']');
/**
*
* @param {String} value the text to parse and reorder
* @returns {String} the text as rightToLeft direction
* @private
*/
function reverseRtl(value) {
var texts = value.split('\n');
var result = '';
for (var i = 0; i < texts.length; i++) {
var text = texts[i];
// first character of the line is a RTL character, so need to manage different cases
var rtlDir = rtlChars.test(text.charAt(0));
var parsedText = convertTextToTypes(text, rtlChars);
var splicePointer = 0;
var line = '';
for (var wordIndex = 0; wordIndex < parsedText.length; ++wordIndex) {
var subText = parsedText[wordIndex];
var reverse = subText.Type === textTypes.BRACKETS ? reverseBrackets(subText.Word) : reverseWord(subText.Word);
if (rtlDir) {
if (subText.Type === textTypes.RTL) {
line = reverse + line;
splicePointer = 0;
}
else if (subText.Type === textTypes.LTR) {
line = spliceWord(line, splicePointer, subText.Word);
splicePointer += subText.Word.length;
}
else if (subText.Type === textTypes.WEAK || subText.Type === textTypes.BRACKETS) {
// current word is weak, last one was bracket
if (subText.Type === textTypes.WEAK && parsedText[wordIndex - 1].Type === textTypes.BRACKETS) {
line = reverse + line;
}
// current word is weak or bracket, last one was rtl
else if (parsedText[wordIndex - 1].Type === textTypes.RTL) {
line = reverse + line;
splicePointer = 0;
}
// current word is weak or bracket, there is at least one more word
else if (parsedText.length > wordIndex + 1) {
// next word is rtl
if (parsedText[wordIndex + 1].Type === textTypes.RTL) {
line = reverse + line;
splicePointer = 0;
}
else {
line = spliceWord(line, splicePointer, subText.Word);
splicePointer += subText.Word.length;
}
}
// current word is weak or bracket, and it the last in this line
else {
line = spliceWord(line, 0, reverse);
}
}
}
// ltr line, rtl word
else if (subText.Type === textTypes.RTL) {
line = spliceWord(line, splicePointer, reverse);
}
// ltr line, ltr word
else if (subText.Type === textTypes.LTR) {
line += subText.Word;
splicePointer = line.length;
}
// ltr line, weak or bracket word
else if (subText.Type === textTypes.WEAK || subText.Type === textTypes.BRACKETS) {
// not first word in line
if (wordIndex > 0) {
// last word was rtl
if (parsedText[wordIndex - 1].Type === textTypes.RTL) {
// there is at least one more word
if (parsedText.length > wordIndex + 1) {
// next word is rtl
if (parsedText[wordIndex + 1].Type === textTypes.RTL) {
line = spliceWord(line, splicePointer, reverse);
}
else {
line += subText.Word;
splicePointer = line.length;
}
}
else {
line += subText.Word;
}
}
else {
line += subText.Word;
splicePointer = line.length;
}
}
else {
line += subText.Word;
splicePointer = line.length;
}
}
}
result += line;
if (i < texts.length - 1) {
result += '\n';
}
}
return result;
}
export default Label;