Return the rotation angle of the movie.

@return int
547421
public function getRotation()
    {
        if ($this->rotation === null) {
            $match = array();
            preg_match(self::$REGEX_ROTATION, $this->output, $match);
            $this->rotation = (array_key_exists(1, $match)) ? intval(trim($match[1])) : 0;
        }
        return $this->rotation;
    }
697483
public function getRatingValue()
    {
        if ($this->_dRatingValue === null) {
            $this->_dRatingValue = (double) 0;
            $dValue = $this->getViewParameter("dRatingValue");
            if ($dValue) {
                $this->_dRatingValue = round($dValue, 1);
            }
        }

        return (double) $this->_dRatingValue;
    }
315055
public function getFullWidth() : int {
        $first = $this->getFullStart();
        $last = $this->getEndPosition();

        return $last - $first;
    }
34458
public function getDeterminant()
    {
        if ($this->determinant !== null) {
            return $this->determinant;
        }

        if (!$this->isSquare()) {
            throw new MatrixException('Matrix is not square matrix');
        }

        $lu = new LUDecomposition($this);

        return $this->determinant = $lu->det();
    }
468394
public function getOffset()
    {
        $this->assertSeekable();
        $ret = ftell($this->stream);
        if (false === $ret) {
            throw new RuntimeException('Cannot get offset of stream');
        }
        
        return $ret;
    }
834974
public double[] getRollPitchYaw() {
		double[] ret = new double[3];
		
		// roll (x-axis rotation)
		double sinr = +2.0 * (w * x + y * z);
		double cosr = +1.0 - 2.0 * (x * x + y * y);
		ret[0] = Math.atan2(sinr, cosr);

		// pitch (y-axis rotation)
		double sinp = +2.0 * (w * y - z * x);
		// use 90 degrees if out of range
		if (Math.abs(sinp) >= 1) ret[1] = Math.copySign(Math.PI / 2.0, sinp);
		else ret[1] = Math.asin(sinp);

		// yaw (z-axis rotation)
		double siny = +2.0 * (w * z + x * y);
		double cosy = +1.0 - 2.0 * (y * y + z * z);  
		ret[2] = Math.atan2(siny, cosy);
		
		return ret;
	}
108093
private function getValidRotationAmount($rotationAmount)
    {
        $rotationAmount = (int) $rotationAmount;

        $alphabetSize = $this->getAlphabetSize();

        if ($rotationAmount < 0) {
            $rotationAmount += (int) ceil(-1 * $rotationAmount / $alphabetSize) * $alphabetSize;
        }

        return $rotationAmount;
    }
70391
public function getWidth() : int {
        $first = $this->getStart();
        $last = $this->getEndPosition();

        return $last - $first;
    }
309220
public function getRelativeCenterY()
    {
        $pos = 50;
        if ($this->FaceCentreY > 0 && $this->OriginalHeight > 0) {
            $pos = $this->FaceCentreY / $this->OriginalHeight * 100;
            $pos = ($pos > 100 || $pos < 0) ? 50 : $pos;
        }

        return $pos;
    }
997783
public function getOffset(){
		if(!empty($this->offset)){
			return $this->offset;
			}
		if($this->type==PTYPE_GET){
			$this->offset=$this->getPage()*$this->getLimit();	
			}
		return $this->offset;
		}
576805
public function getOrientation()
    {
        if ($this->orientation === 'AUTO') {
            if ($this->width > $this->height) {
                $this->orientation = 'LANDSCAPE';
            } elseif ($this->width < $this->height) {
                $this->orientation = 'PORTRAIT';
            } elseif ($this->width == $this->height) {
                $this->orientation = 'SQUARE';
            }
        }

        return $this->orientation;
    }
1235954
public function getTaxTotal(): int
    {
        $taxTotal = 0;

        foreach ($this->getAdjustments(AdjustmentInterface::TAX_ADJUSTMENT) as $taxAdjustment) {
            $taxTotal += $taxAdjustment->getAmount();
        }

        foreach ($this->units as $unit) {
            $taxTotal += $unit->getTaxTotal();
        }

        return $taxTotal;
    }
579818
public function det()
    {
        if ($this->m == $this->n) {
            $d = $this->pivsign;
            for ($j = 0; $j < $this->n; $j++) {
                $d *= $this->LU[$j][$j];
            }
            return $d;
        } else {
            trigger_error(MatrixDimensionException, ERROR);
        }
    }
84572
public function getOrientation()
    {
        $aspectRatio = $this->getAspectRatio(true);
        if ($aspectRatio > 1) {
            return ImageInterface::ORIENTATION_LANDSCAPE;
        } elseif ($aspectRatio < 1) {
            return ImageInterface::ORIENTATION_PORTRAIT;
        } else {
            return ImageInterface::ORIENTATION_SQUARE;
        }
    }
1252371
public function bl()
    {
        $q = new self(self::BOTTOM_LEFT, $this->bool_rotate_way);
        $q->units($this->arr_units);

        return $q;
    }
401898
public function getAngle($X1, $Y1, $X2, $Y2)
    {
        $Opposite = $Y2 - $Y1;
        $Adjacent = $X2 - $X1;
        $Angle = rad2deg(atan2($Opposite, $Adjacent));

        return $Angle > 0 ? $Angle : 360 - abs($Angle);
    }
627315
function (rotation) {
		var ret, 
			angle = (pick(rotation, 0) - (this.side * 90) + 720) % 360;

		if (angle > 15 && angle < 165) {
			ret = 'right';
		} else if (angle > 195 && angle < 345) {
			ret = 'left';
		} else {
			ret = 'center';
		}
		return ret;
	}