Internally used compute the label positions
@param int $X
@param int $Y
@param string $Label
@param int|float $Angle
@param array $Settings
@param boolean $Stacked
@param int $Xc
@param int $Yc
@param int $Radius
@param boolean $Reversed
962163
public function writePieLabel(
        $X,
        $Y,
        $Label,
        $Angle,
        $Settings,
        $Stacked,
        $Xc = 0,
        $Yc = 0,
        $Radius = 0,
        $Reversed = false
    ) {
        $LabelOffset = 30;
        $FontName = $this->pChartObject->FontName;
        $FontSize = $this->pChartObject->FontSize;

        if (!$Stacked) {
            $Settings["Angle"] = 360 - $Angle;
            $Settings["Length"] = 25;
            $Settings["Size"] = 8;

            $this->pChartObject->drawArrowLabel($X, $Y, " " . $Label . " ", $Settings);
        } else {
            $X2 = cos(deg2rad($Angle - 90)) * 20 + $X;
            $Y2 = sin(deg2rad($Angle - 90)) * 20 + $Y;

            $TxtPos = $this->pChartObject->getTextBox($X, $Y, $FontName, $FontSize, 0, $Label);
            $Height = $TxtPos[0]["Y"] - $TxtPos[2]["Y"];
            $YTop = $Y2 - $Height / 2 - 2;
            $YBottom = $Y2 + $Height / 2 + 2;

            if (count($this->LabelPos)) {
                $Done = false;
                foreach ($this->LabelPos as $Key => $Settings) {
                    if (!$Done) {
                        $yTopAboveTopBelowBottom = ($YTop >= $Settings["YTop"] && $YTop <= $Settings["YBottom"]);
                        $yBottomAboveTopBelowBottom = ($YBottom >= $Settings["YTop"]
                            && $YBottom <= $Settings["YBottom"]
                        );

                        if ($Angle <= 90
                            && ($yTopAboveTopBelowBottom || $yBottomAboveTopBelowBottom)
                        ) {
                            $this->shift(0, 180, -($Height + 2), $Reversed);
                            $Done = true;
                        }
                        if ($Angle > 90
                            && $Angle <= 180
                            && ($yTopAboveTopBelowBottom || $yBottomAboveTopBelowBottom)
                        ) {
                            $this->shift(0, 180, -($Height + 2), $Reversed);
                            $Done = true;
                        }
                        if ($Angle > 180
                            && $Angle <= 270
                            && ($yTopAboveTopBelowBottom || $yBottomAboveTopBelowBottom)
                        ) {
                            $this->shift(180, 360, ($Height + 2), $Reversed);
                            $Done = true;
                        }
                        if ($Angle > 270
                            && $Angle <= 360
                            && ($yTopAboveTopBelowBottom || $yBottomAboveTopBelowBottom)
                        ) {
                            $this->shift(180, 360, ($Height + 2), $Reversed);
                            $Done = true;
                        }
                    }
                }
            }

            $LabelSettings = [
                "YTop" => $YTop,
                "YBottom" => $YBottom,
                "Label" => $Label,
                "Angle" => $Angle,
                "X1" => $X,
                "Y1" => $Y,
                "X2" => $X2,
                "Y2" => $Y2
            ];
            if ($Angle <= 180) {
                $LabelSettings["X3"] = $Xc + $Radius + $LabelOffset;
            }
            if ($Angle > 180) {
                $LabelSettings["X3"] = $Xc - $Radius - $LabelOffset;
            }
            $this->LabelPos[] = $LabelSettings;
        }
    }
916654
public function setLabel($label)
    {
        parent::setLabel($label);
        if (isset($this->token['captcha'])) {
            if ((strpos($this->token['captcha'], '<img') === false) &&
                ((strpos($this->token['captcha'], ' + ') !== false) ||
                 (strpos($this->token['captcha'], ' - ') !== false) ||
                 (strpos($this->token['captcha'], ' * ') !== false) ||
                 (strpos($this->token['captcha'], ' / ') !== false))) {
                $this->label = $this->label . '(' .
                    str_replace([' * ', ' / '], [' &#215; ', ' &#247; '], $this->token['captcha'] .')');
            } else {
                $this->label = $this->label . $this->token['captcha'];
            }
        }
        return $this;
    }
298886
protected function addLabel($dimension, $label)
    {
        if (!in_array($dimension, array(self::DIMENSION_X, self::DIMENSION_Y))) {
            throw new \InvalidArgumentException(sprintf("Value '%s' is not a valid dimension", $dimension));
        }

        $this->axis[$dimension][] = $label;
    }
1080651
function initializeAxis( $parameters, $name )
    {
        $axis = array();
        if ( isset( $parameters[$name] ) )
            $axis = $parameters[$name];
        if ( !isset( $axis['alignment'] ) )
            $axis['alignment'] = self::ALIGN_AXIS_NONE;
        if ( !isset( $axis['placement'] ) )
            $axis['placement'] = self::PLACE_CONSTANT;
        if ( !isset( $axis['value'] ) )
            $axis['value'] = 0;
        return $axis;
    }
113565
public function addLabelColumn($labelColumn)
    {
        if (is_array($labelColumn)) {
            foreach ($labelColumn as $label) {
                $this->addLabelColumn($label);
            }
            return;
        }
        $this->labelColumns[$labelColumn] = true;
    }
818175
public function hasLabel($label)
    {
        $cypher = $this->conn->getSchemaGrammar()->compileLabelExists($label);

        return $this->getConnection()->select($cypher, [])->count() > 0;
    }
964217
function(label) {
		var me = this;
		var ticksOpts = me.options.ticks;
		var tickLabelWidth = me.ctx.measureText(label).width;
		var angle = helpers.toRadians(ticksOpts.maxRotation);
		var cosRotation = Math.cos(angle);
		var sinRotation = Math.sin(angle);
		var tickFontSize = valueOrDefault(ticksOpts.fontSize, defaults.global.defaultFontSize);

		return (tickLabelWidth * cosRotation) + (tickFontSize * sinRotation);
	}
371612
public static function atan2($y, $x)
    {
        $y = $y instanceof Angle ? $y->rad : $y;
        $x = $x instanceof Angle ? $x->rad : $x;

        return static::rad(atan2($y, $x));
    }
1371270
public function updateFieldLabels(&$labels)
    {
        parent::updateFieldLabels($labels);

        $statics = self::$collectorCache[$this->ownerBaseClass];
        foreach ($statics as $field => $type) {
            $parts = explode(TRANSLATABLE_COLUMN_SEPARATOR, $field);
            $labels[$field] = FormField::name_to_label($parts[0]) . ' (' . $parts[1] . ')';
        }
    }
323516
public function setLabel( $label )
	{
		if ( $label == $this->getLabel() ) { return; }

		$this->_values['label'] = (string) $label;
		$this->setModified();
	}
1134594
def xyzlabel(labelx, labely, labelz):
    """"""
    xlabel(labelx)
    ylabel(labely)
    zlabel(labelz)
1323178
function (xOffset, xWidth) {
		var stackItem = this,
			axis = stackItem.axis,
			chart = axis.chart,
			inverted = chart.inverted,
			neg = this.isNegative,							// special treatment is needed for negative stacks
			y = axis.translate(this.percent ? 100 : this.total, 0, 0, 0, 1), // stack value translated mapped to chart coordinates
			yZero = axis.translate(0),						// stack origin
			h = mathAbs(y - yZero),							// stack height
			x = chart.xAxis[0].translate(this.x) + xOffset,	// stack x position
			plotHeight = chart.plotHeight,
			stackBox = {	// this is the box for the complete stack
				x: inverted ? (neg ? y : y - h) : x,
				y: inverted ? plotHeight - x - xWidth : (neg ? (plotHeight - y - h) : plotHeight - y),
				width: inverted ? h : xWidth,
				height: inverted ? xWidth : h
			},
			label = this.label,
			alignAttr;
		
		if (label) {
			label.align(this.alignOptions, null, stackBox);	// align the label to the box
				
			// Set visibility (#678)
			alignAttr = label.alignAttr;
			label.attr({ 
				visibility: this.options.crop === false || chart.isInsidePlot(alignAttr.x, alignAttr.y) ? 
					(hasSVG ? 'inherit' : VISIBLE) : 
					HIDDEN
			});
		}
	}
961913
public function addLabel(Doozr_Form_Service_Component_Interface_Html $label)
    {
        $index               = $this->addChild($label);
        $this->index[$index] = self::LABEL;

        (!isset($this->indexReverse[self::LABEL])) ? $this->indexReverse[self::LABEL] = [] : null;
        $this->indexReverse[self::LABEL][]                                            = $index;

        return $index;
    }
714335
public function addRange( $from, $label )
	{
		$from	= preg_replace_callback( $this->regExp, array( $this, 'calculateSeconds' ), $from );
		$this->ranges[(int) $from]	= $label;
		ksort( $this->ranges );
	}
891527
public static function get_form_field_from_label($label, RawMinkContext $context) {

        // There are moodle form elements that are not directly related with
        // a basic HTML form field, we should also take care of them.
        // The DOM node.
        $fieldnode = $context->find_field($label);

        // The behat field manager.
        return self::get_form_field($fieldnode, $context->getSession());
    }
1157445
function (index, xy) {
            var show = true,
              axis = this.axis,
              isFirst = this.isFirst,
              isLast = this.isLast,
              horiz = axis.horiz,
              pxPos = horiz ? xy.x : xy.y,
              reversed = axis.reversed,
              tickPositions = axis.tickPositions,
              sides = this.getLabelSides(),
              leftSide = sides[0],
              rightSide = sides[1],
              axisLeft,
              axisRight,
              neighbour,
              neighbourEdge,
              line = this.label.line,
              lineIndex = line || 0,
              labelEdge = axis.labelEdge,
              justifyLabel = axis.justifyLabels && (isFirst || isLast),
              justifyToPlot;

            // Hide it if it now overlaps the neighbour label
            if (labelEdge[lineIndex] === UNDEFINED || pxPos + leftSide > labelEdge[lineIndex]) {
                labelEdge[lineIndex] = pxPos + rightSide;

            } else if (!justifyLabel) {
                show = false;
            }

            if (justifyLabel) {
                justifyToPlot = axis.justifyToPlot;
                axisLeft = justifyToPlot ? axis.pos : 0;
                axisRight = justifyToPlot ? axisLeft + axis.len : axis.chart.chartWidth;

                // Find the firsth neighbour on the same line
                do {
                    index += (isFirst ? 1 : -1);
                    neighbour = axis.ticks[tickPositions[index]];
                } while (tickPositions[index] && (!neighbour || !neighbour.label || neighbour.label.line !== line)); // #3044

                neighbourEdge = neighbour && neighbour.label.xy && neighbour.label.xy.x + neighbour.getLabelSides()[isFirst ? 0 : 1];

                if ((isFirst && !reversed) || (isLast && reversed)) {
                    // Is the label spilling out to the left of the plot area?
                    if (pxPos + leftSide < axisLeft) {

                        // Align it to plot left
                        pxPos = axisLeft - leftSide;

                        // Hide it if it now overlaps the neighbour label
                        if (neighbour && pxPos + rightSide > neighbourEdge) {
                            show = false;
                        }
                    }

                } else {
                    // Is the label spilling out to the right of the plot area?
                    if (pxPos + rightSide > axisRight) {

                        // Align it to plot right
                        pxPos = axisRight - rightSide;

                        // Hide it if it now overlaps the neighbour label
                        if (neighbour && pxPos + leftSide < neighbourEdge) {
                            show = false;
                        }

                    }
                }

                // Set the modified x position of the label
                xy.x = pxPos;
            }
            return show;
        }
631769
def label_rotation=(v)
      Axlsx::validate_int(v)
      adjusted = v.to_i * 60000
      Axlsx::validate_angle(adjusted)
      @label_rotation = adjusted
    end