(x y)

@param WKTParser        $parser
@param CoordinateSystem $cs

@return Point
342096
private function readPointText(WKTParser $parser, CoordinateSystem $cs) : Point
    {
        $parser->matchOpener();
        $point = $this->readPoint($parser, $cs);
        $parser->matchCloser();

        return $point;
    }
1215898
private function readCurvePolygon(WKBBuffer $buffer, CoordinateSystem $cs) : CurvePolygon
    {
        $numRings = $buffer->readUnsignedLong();

        $rings = [];

        for ($i = 0; $i < $numRings; $i++) {
            $rings[] = $this->readGeometry($buffer, $cs->SRID());
        }

        return new CurvePolygon($cs, ...$rings);
    }
1160127
static public function parsePosition($data, $yval=null)
    {
        $x = $y = null;
        if (is_numeric($data)) {
            $data = intval($data);
            if ($data > 0 && $data < 10) {
                if ($data == 1) {
                    $x = static::LEFT;
                    $y = static::TOP;
                } elseif ($data == 2) {
                    $x = static::CENTER;
                    $y = static::TOP;
                } elseif ($data == 3) {
                    $x = static::RIGHT;
                    $y = static::TOP;
                } elseif ($data == 4) {
                    $x = static::LEFT;
                    $y = static::CENTER;
                } elseif ($data == 5) {
                    $x = static::CENTER;
                    $y = static::CENTER;
                } elseif ($data == 6) {
                    $x = static::RIGHT;
                    $y = static::CENTER;
                } elseif ($data == 7) {
                    $x = static::LEFT;
                    $y = static::BOTTOM;
                } elseif ($data == 8) {
                    $x = static::CENTER;
                    $y = static::BOTTOM;
                } else { // 9
                    $x = static::RIGHT;
                    $y = static::BOTTOM;
                }
            } else {
                $x = $data;
            }
        } elseif (is_string($data)) {
            $data = DataHelper::explode('\,\|', $data);
            $x = $data[0];
            if (isset($data[1])) {
                $y = $data[1];
            }
        } elseif (is_array($data)) {
            if (isset($data[0])) {
                $x = $data[0];
            }
            if (isset($data['x'])) {
                $x = $data['x'];
            }
            if (isset($data[1])) {
                $y = $data[1];
            }
            if (isset($data['y'])) {
                $y = $data['y'];
            }
        }
        if (!is_null($yval) && !is_null($y)) {
            $y = $yval;
        }
        
        $x = str_replace(['px', '%'], '', $x);
        $y = str_replace(['px', '%'], '', $y);
        
        if ($x == 'middle') {
            $x = static::CENTER;
        }
        if ($y == 'middle') {
            $y = static::CENTER;
        }
        
        return [$x, $y];
    }
967049
public function setParser($parser) {
        switch ($parser) {
            case self::PARSER_XML:
            case self::PARSER_XMLDTD:
            case self::PARSER_HTML:
            case self::PARSER_HTML5:
            case self::PARSER_HTML4:
            case self::PARSER_HTML4TR:
                $this->parser = $parser;
                return $this;
            default:
                throw new UnknownParserException('Unknown parser "' . $parser . '"');
        }
    }
496066
@Pure
	public static GeodesicPosition L1_WSG84(double x, double y) {
		final Point2d ntfLambdaPhi = NTFLambert_NTFLambdaPhi(x, y,
				LAMBERT_1_N,
				LAMBERT_1_C,
				LAMBERT_1_XS,
				LAMBERT_1_YS);
		return NTFLambdaPhi_WSG84(ntfLambdaPhi.getX(), ntfLambdaPhi.getY());
	}
119026
public function add(TextParser $parser)
    {
        $objectHash = $this->objectHash($parser);

        if (isset($this->parserIds[$objectHash])) {
            return $this;
        }

        $this->parsers[] = $parser;

        $this->parserIds[$objectHash] = true;

        return $this;
    }
635488
public function point($int_x, $int_y)
    {
        if (count($this->arr_points) >= 3) {
            throw new \RuntimeException('Triangle has only three points!');
        }

        return parent::point($int_x, $int_y);
    }
830529
@Pure
	public static GeodesicPosition L93_WSG84(double x, double y) {
		final Point2d ntfLambdaPhi = NTFLambert_NTFLambdaPhi(x, y,
				LAMBERT_93_N,
				LAMBERT_93_C,
				LAMBERT_93_XS,
				LAMBERT_93_YS);
		return NTFLambdaPhi_WSG84(ntfLambdaPhi.getX(), ntfLambdaPhi.getY());
	}
1166217
private function readCurvePolygonText(WKTParser $parser, CoordinateSystem $cs) : CurvePolygon
    {
        $parser->matchOpener();
        $curves = [];

        do {
            if ($parser->isNextOpenerOrWord()) {
                $curves[] = $this->readLineStringText($parser, $cs);
            } else {
                $curves[] = $this->readGeometry($parser, $cs->SRID());
            }

            $nextToken = $parser->getNextCloserOrComma();
        } while ($nextToken === ',');

        return new CurvePolygon($cs, ...$curves);
    }
1223461
public static Point layerToParent(Layer layer, Layer parent, float x, float y) {
    Point into = new Point(x, y);
    return layerToParent(layer, parent, into, into);
  }
715795
private static CSSParser createParser(Object source, NetworkProcessor network, String encoding, SourceType type,
                                          URL base) throws IOException, CSSException {

        CSSInputStream input = getInput(source, network, encoding, type);
        input.setBase(base);
        return createParserForInput(input);
    }
1258808
public function addPoint($X, $Y, $Value, $Force = true)
    {
        if ($X < 0 || $X > $this->GridSizeX) {
            return 0;
        }
        if ($Y < 0 || $Y > $this->GridSizeY) {
            return 0;
        }

        if ($this->Points[$X][$Y] == UNKNOWN || $Force) {
            $this->Points[$X][$Y] = $Value;
        } elseif ($this->Points[$X][$Y] == UNKNOWN) {
            $this->Points[$X][$Y] = $Value;
        } else {
            $this->Points[$X][$Y] = ($this->Points[$X][$Y] + $Value) / 2;
        }
    }
914741
public static function xy(float $x, float $y, int $srid = 0) : Point
    {
        return new Point(CoordinateSystem::xy($srid), $x, $y);
    }
331577
public static function ParserFirstCallInit(&$parser){
    $parser->setFunctionHook('movetoskin', 'Skinny::moveToSkinPF');
    $parser->setFunctionHook('setskin', 'Skinny::setSkinPF');
    $parser->setFunctionHook('layout', 'Skinny::setLayoutPF');
    $parser->setFunctionHook('skinsert', 'Skinny::insertTemplatePF');
    $parser->setFunctionHook('imageurl', 'Skinny::getImageURLPF');

    return true;
  }
17060
public int pointToPosition(int x, int y) {
        Rect frame = mTouchFrame;
        if (frame == null) {
            mTouchFrame = new Rect();
            frame = mTouchFrame;
        }

        final int count = getChildCount();
        for (int i = count - 1; i >= 0; i--) {
            View child = getChildAt(i);
            if (child.getVisibility() == View.VISIBLE) {
                child.getHitRect(frame);
                if (frame.contains(x, y)) {
                    return mFirstPosition + i;
                }
            }
        }
        return INVALID_POSITION;
    }
1285486
private function readMultiLineString(WKTParser $parser, CoordinateSystem $cs) : array
    {
        $parser->matchOpener();
        $lineStrings = [];

        do {
            $lineStrings[] = $this->readLineStringText($parser, $cs);
            $nextToken = $parser->getNextCloserOrComma();
        } while ($nextToken === ',');

        return $lineStrings;
    }
965201
public function parse(Parser $parser)
    {
        $parser->match(Lexer::T_IDENTIFIER);
        $parser->match(Lexer::T_OPEN_PARENTHESIS);
        $this->first = $parser->ArithmeticPrimary();
        $parser->match(Lexer::T_AS);
        $parser->match(Lexer::T_IDENTIFIER);
        $this->second = $parser->getLexer()->token['value'];
        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
    }