guilhem_lavaux/gl-website-deployer
0
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Update website

Browse source
This commit is contained in:
Guilhem Lavaux 2024-11-23 20:45:29 +01:00
parent 41ce1aa076
commit ea0eb1c6e0
4222 changed files with 721797 additions and 14 deletions
Download patch file Download diff file Expand all files Collapse all files

696
admin/phpMyAdmin/vendor/phpmyadmin/shapefile/src/ShapeFile.php vendored Normal file
View file

@ -0,0 +1,696 @@
<?php
declare(strict_types=1);
/**
* phpMyAdmin ShapeFile library
* <https://github.com/phpmyadmin/shapefile/>.
*
* Copyright 2006-2007 Ovidio <ovidio AT users.sourceforge.net>
* Copyright 2016 - 2017 Michal Čihař <michal@cihar.com>
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, you can download one from
* https://www.gnu.org/copyleft/gpl.html.
*/
namespace PhpMyAdmin\ShapeFile;
use function array_push;
use function chr;
use function count;
use function extension_loaded;
use function fclose;
use function feof;
use function file_exists;
use function fopen;
use function fread;
use function fwrite;
use function in_array;
use function is_array;
use function is_readable;
use function ord;
use function pack;
use function sprintf;
use function str_replace;
use function strpos;
use function strtoupper;
use function substr;
use function trim;
use function unlink;
/**
* ShapeFile class.
*/
class ShapeFile
{
public const MAGIC = 0x270a;
/** @var string|null */
public $fileName;
/** @var resource|null */
private $shpFile = null;
/** @var resource|null */
private $shxFile = null;
/** @var resource|null */
private $dbfFile = null;
/** @var array|null */
private $dbfHeader;
/** @var string */
public $lastError = '';
/** @var array */
public $boundingBox = [
'xmin' => 0.0,
'ymin' => 0.0,
'xmax' => 0.0,
'ymax' => 0.0,
];
/** @var int */
private $fileLength = 0;
/** @var int|false */
public $shapeType = 0;
/** @var array */
public $records = [];
/**
* Checks whether dbase manipulations are supported.
*/
public static function supportsDbase(): bool
{
return extension_loaded('dbase');
}
/**
* @param int $shapeType File shape type, should be same as all records
* @param array $boundingBox File bounding box
* @param string|null $fileName File name
*/
public function __construct(
int $shapeType,
array $boundingBox = [
'xmin' => 0.0,
'ymin' => 0.0,
'xmax' => 0.0,
'ymax' => 0.0,
],
?string $fileName = null
) {
$this->shapeType = $shapeType;
$this->boundingBox = $boundingBox;
$this->fileName = $fileName;
/**
* The value for file length is the total length of the file in 16-bit words
* (including the fifty 16-bit words that make up the header).
*/
$this->fileLength = 50;
}
/**
* Loads shapefile and dbase (if supported).
*
* @param string $fileName File mask to load (eg. example.*)
*/
public function loadFromFile(string $fileName): bool
{
if (! empty($fileName)) {
$this->fileName = $fileName;
$result = $this->openSHPFile();
} else {
/* We operate on buffer emulated by readSHP / eofSHP */
$result = true;
}
if ($result && ($this->openDBFFile())) {
if (! $this->loadHeaders()) {
$this->closeSHPFile();
$this->closeDBFFile();
return false;
}
if (! $this->loadRecords()) {
$this->closeSHPFile();
$this->closeDBFFile();
return false;
}
$this->closeSHPFile();
$this->closeDBFFile();
return true;
}
return false;
}
/**
* Saves shapefile.
*
* @param string|null $fileName Name of file, otherwise existing is used
*/
public function saveToFile(?string $fileName = null): bool
{
if ($fileName !== null) {
$this->fileName = $fileName;
}
if (! $this->openSHPFile(true) || (! $this->openSHXFile(true)) || (! $this->createDBFFile())) {
return false;
}
$this->saveHeaders();
$this->saveRecords();
$this->closeSHPFile();
$this->closeSHXFile();
$this->closeDBFFile();
return true;
}
/**
* Generates filename with given extension.
*
* @param string $extension Extension to use (including dot)
*/
private function getFilename(string $extension): string
{
return str_replace('.*', $extension, (string) $this->fileName);
}
/**
* Updates bounding box based on shpData.
*
* @param string $type Type of box
* @param array $data ShapeRecord shpData
*/
private function updateBBox(string $type, array $data): void
{
$min = $type . 'min';
$max = $type . 'max';
if (! isset($this->boundingBox[$min])
|| $this->boundingBox[$min] == 0.0
|| ($this->boundingBox[$min] > $data[$min])
) {
$this->boundingBox[$min] = $data[$min];
}
if (isset($this->boundingBox[$max])
&& $this->boundingBox[$max] != 0.0
&& ($this->boundingBox[$max] >= $data[$max])
) {
return;
}
$this->boundingBox[$max] = $data[$max];
}
/**
* Adds record to shape file.
*
* @return int Number of added record
*/
public function addRecord(ShapeRecord $record): int
{
if (isset($this->dbfHeader) && (is_array($this->dbfHeader))) {
$record->updateDBFInfo($this->dbfHeader);
}
$this->fileLength += $record->getContentLength() + 4;
$this->records[] = $record;
$this->records[count($this->records) - 1]->recordNumber = count($this->records);
$this->updateBBox('x', $record->shpData);
$this->updateBBox('y', $record->shpData);
if (in_array($this->shapeType, [11, 13, 15, 18, 21, 23, 25, 28])) {
$this->updateBBox('m', $record->shpData);
}
if (in_array($this->shapeType, [11, 13, 15, 18])) {
$this->updateBBox('z', $record->shpData);
}
return count($this->records) - 1;
}
/**
* Deletes record from shapefile.
*/
public function deleteRecord(int $index): void
{
if (! isset($this->records[$index])) {
return;
}
$this->fileLength -= $this->records[$index]->getContentLength() + 4;
$count = count($this->records) - 1;
for ($i = $index; $i < $count; ++$i) {
$this->records[$i] = $this->records[$i + 1];
}
unset($this->records[count($this->records) - 1]);
$this->deleteRecordFromDBF($index);
}
/**
* Returns array defining fields in DBF file.
*
* @return array|null see setDBFHeader for more information
*/
public function getDBFHeader(): ?array
{
return $this->dbfHeader;
}
/**
* Changes array defining fields in DBF file, used in dbase_create call.
*
* @param array $header An array of arrays, each array describing the
* format of one field of the database. Each
* field consists of a name, a character indicating
* the field type, and optionally, a length,
* a precision and a nullable flag.
*/
public function setDBFHeader(array $header): void
{
$this->dbfHeader = $header;
$count = count($this->records);
for ($i = 0; $i < $count; ++$i) {
$this->records[$i]->updateDBFInfo($header);
}
}
/**
* Lookups value in the DBF file and returns index.
*
* @param string $field Field to match
* @param mixed $value Value to match
*/
public function getIndexFromDBFData(string $field, $value): int
{
foreach ($this->records as $index => $record) {
if (isset($record->dbfData[$field]) &&
(trim(strtoupper($record->dbfData[$field])) === strtoupper($value))
) {
return $index;
}
}
return -1;
}
/**
* Loads DBF metadata.
*/
private function loadDBFHeader(): array
{
$DBFFile = fopen($this->getFilename('.dbf'), 'r');
$result = [];
$i = 1;
$inHeader = true;
while ($inHeader) {
if (! feof($DBFFile)) {
$buff32 = fread($DBFFile, 32);
if ($i > 1) {
if (substr($buff32, 0, 1) === chr(13)) {
$inHeader = false;
} else {
$pos = strpos(substr($buff32, 0, 10), chr(0));
$pos = ($pos === false ? 10 : $pos);
$fieldName = substr($buff32, 0, $pos);
$fieldType = substr($buff32, 11, 1);
$fieldLen = ord(substr($buff32, 16, 1));
$fieldDec = ord(substr($buff32, 17, 1));
array_push($result, [$fieldName, $fieldType, $fieldLen, $fieldDec]);
}
}
++$i;
} else {
$inHeader = false;
}
}
fclose($DBFFile);
return $result;
}
/**
* Deletes record from the DBF file.
*/
private function deleteRecordFromDBF(int $index): void
{
if ($this->dbfFile === null || ! @dbase_delete_record($this->dbfFile, $index)) {
return;
}
dbase_pack($this->dbfFile);
}
/**
* Loads SHP file metadata.
*/
private function loadHeaders(): bool
{
if (Util::loadData('N', $this->readSHP(4)) !== self::MAGIC) {
$this->setError('Not a SHP file (file code mismatch)');
return false;
}
/* Skip 20 unused bytes */
$this->readSHP(20);
$this->fileLength = Util::loadData('N', $this->readSHP(4));
/* We currently ignore version */
$this->readSHP(4);
$this->shapeType = Util::loadData('V', $this->readSHP(4));
$this->boundingBox = [];
$this->boundingBox['xmin'] = Util::loadData('d', $this->readSHP(8));
$this->boundingBox['ymin'] = Util::loadData('d', $this->readSHP(8));
$this->boundingBox['xmax'] = Util::loadData('d', $this->readSHP(8));
$this->boundingBox['ymax'] = Util::loadData('d', $this->readSHP(8));
$this->boundingBox['zmin'] = Util::loadData('d', $this->readSHP(8));
$this->boundingBox['zmax'] = Util::loadData('d', $this->readSHP(8));
$this->boundingBox['mmin'] = Util::loadData('d', $this->readSHP(8));
$this->boundingBox['mmax'] = Util::loadData('d', $this->readSHP(8));
if (self::supportsDbase()) {
$this->dbfHeader = $this->loadDBFHeader();
}
return true;
}
/**
* Saves bounding box record, possibly using 0 instead of not set values.
*
* @param resource $file File object
* @param string $type Bounding box dimension (eg. xmax, mmin...)
*/
private function saveBBoxRecord($file, string $type): void
{
fwrite($file, Util::packDouble(
$this->boundingBox[$type] ?? 0
));
}
/**
* Saves bounding box to a file.
*
* @param resource $file File object
*/
private function saveBBox($file): void
{
$this->saveBBoxRecord($file, 'xmin');
$this->saveBBoxRecord($file, 'ymin');
$this->saveBBoxRecord($file, 'xmax');
$this->saveBBoxRecord($file, 'ymax');
$this->saveBBoxRecord($file, 'zmin');
$this->saveBBoxRecord($file, 'zmax');
$this->saveBBoxRecord($file, 'mmin');
$this->saveBBoxRecord($file, 'mmax');
}
/**
* Saves SHP and SHX file metadata.
*/
private function saveHeaders(): void
{
fwrite($this->shpFile, pack('NNNNNN', self::MAGIC, 0, 0, 0, 0, 0));
fwrite($this->shpFile, pack('N', $this->fileLength));
fwrite($this->shpFile, pack('V', 1000));
fwrite($this->shpFile, pack('V', $this->shapeType));
$this->saveBBox($this->shpFile);
fwrite($this->shxFile, pack('NNNNNN', self::MAGIC, 0, 0, 0, 0, 0));
fwrite($this->shxFile, pack('N', 50 + 4 * count($this->records)));
fwrite($this->shxFile, pack('V', 1000));
fwrite($this->shxFile, pack('V', $this->shapeType));
$this->saveBBox($this->shxFile);
}
/**
* Loads records from SHP file (and DBF).
*/
private function loadRecords(): bool
{
/* Need to start at offset 100 */
while (! $this->eofSHP()) {
$record = new ShapeRecord(-1);
$record->loadFromFile($this, $this->shpFile, $this->dbfFile);
if ($record->lastError !== '') {
$this->setError($record->lastError);
return false;
}
if (($record->shapeType === false || $record->shapeType === '') && $this->eofSHP()) {
break;
}
$this->records[] = $record;
}
return true;
}
/**
* Saves records to SHP and SHX files.
*/
private function saveRecords(): void
{
$offset = 50;
if (! is_array($this->records) || (count($this->records) <= 0)) {
return;
}
foreach ($this->records as $index => $record) {
//Save the record to the .shp file
$record->saveToFile($this->shpFile, $this->dbfFile, $index + 1);
//Save the record to the .shx file
fwrite($this->shxFile, pack('N', $offset));
fwrite($this->shxFile, pack('N', $record->getContentLength()));
$offset += 4 + $record->getContentLength();
}
}
/**
* Generic interface to open files.
*
* @param bool $toWrite Whether file should be opened for writing
* @param string $extension File extension
* @param string $name Verbose file name to report errors
*
* @return resource|false File handle
*/
private function openFile(bool $toWrite, string $extension, string $name)
{
$shpName = $this->getFilename($extension);
$result = @fopen($shpName, ($toWrite ? 'wb+' : 'rb'));
if (! $result) {
$this->setError(sprintf('It wasn\'t possible to open the %s file "%s"', $name, $shpName));
return false;
}
return $result;
}
/**
* Opens SHP file.
*
* @param bool $toWrite Whether file should be opened for writing
*/
private function openSHPFile(bool $toWrite = false): bool
{
$this->shpFile = $this->openFile($toWrite, '.shp', 'Shape');
return (bool) $this->shpFile;
}
/**
* Closes SHP file.
*/
private function closeSHPFile(): void
{
if (! $this->shpFile) {
return;
}
fclose($this->shpFile);
$this->shpFile = null;
}
/**
* Opens SHX file.
*
* @param bool $toWrite Whether file should be opened for writing
*/
private function openSHXFile(bool $toWrite = false): bool
{
$this->shxFile = $this->openFile($toWrite, '.shx', 'Index');
return (bool) $this->shxFile;
}
/**
* Closes SHX file.
*/
private function closeSHXFile(): void
{
if (! $this->shxFile) {
return;
}
fclose($this->shxFile);
$this->shxFile = null;
}
/**
* Creates DBF file.
*/
private function createDBFFile(): bool
{
if (! self::supportsDbase() || ! is_array($this->dbfHeader) || count($this->dbfHeader) === 0) {
$this->dbfFile = null;
return true;
}
$dbfName = $this->getFilename('.dbf');
/* Unlink existing file */
if (file_exists($dbfName)) {
unlink($dbfName);
}
/* Create new file */
$this->dbfFile = @dbase_create($dbfName, $this->dbfHeader);
if ($this->dbfFile === false) {
$this->setError(sprintf('It wasn\'t possible to create the DBase file "%s"', $dbfName));
return false;
}
return true;
}
/**
* Loads DBF file if supported.
*/
private function openDBFFile(): bool
{
if (! self::supportsDbase()) {
$this->dbfFile = null;
return true;
}
$dbfName = $this->getFilename('.dbf');
if (! is_readable($dbfName)) {
$this->setError(sprintf('It wasn\'t possible to find the DBase file "%s"', $dbfName));
return false;
}
$this->dbfFile = @dbase_open($dbfName, 0);
if (! $this->dbfFile) {
$this->setError(sprintf('It wasn\'t possible to open the DBase file "%s"', $dbfName));
return false;
}
return true;
}
/**
* Closes DBF file.
*/
private function closeDBFFile(): void
{
if (! $this->dbfFile) {
return;
}
dbase_close($this->dbfFile);
$this->dbfFile = null;
}
/**
* Sets error message.
*/
public function setError(string $error): void
{
$this->lastError = $error;
}
/**
* Reads given number of bytes from SHP file.
*
* @return string|false
*/
public function readSHP(int $bytes)
{
if ($this->shpFile === null) {
return false;
}
return fread($this->shpFile, $bytes);
}
/**
* Checks whether file is at EOF.
*/
public function eofSHP(): bool
{
return feof($this->shpFile);
}
/**
* Returns shape name.
*/
public function getShapeName(): string
{
return Util::nameShape($this->shapeType);
}
/**
* Check whether file contains measure data.
*
* For some reason this is distinguished by zero bounding box in the
* specification.
*/
public function hasMeasure(): bool
{
return $this->boundingBox['mmin'] != 0 || $this->boundingBox['mmax'] != 0;
}
}

900
admin/phpMyAdmin/vendor/phpmyadmin/shapefile/src/ShapeRecord.php vendored Normal file
View file

@ -0,0 +1,900 @@
<?php
declare(strict_types=1);
/**
* phpMyAdmin ShapeFile library
* <https://github.com/phpmyadmin/shapefile/>.
*
* Copyright 2006-2007 Ovidio <ovidio AT users.sourceforge.net>
* Copyright 2016 - 2017 Michal Čihař <michal@cihar.com>
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, you can download one from
* https://www.gnu.org/copyleft/gpl.html.
*/
namespace PhpMyAdmin\ShapeFile;
use function array_values;
use function count;
use function fwrite;
use function in_array;
use function is_array;
use function pack;
use function sprintf;
use function strlen;
/**
* ShapeFile record class.
*/
class ShapeRecord
{
/** @var resource */
private $shpFile = null;
/** @var resource */
private $dbfFile = null;
/** @var ShapeFile */
private $shapeFile = null;
/** @var int */
private $size = 0;
/** @var int */
private $read = 0;
/** @var int|null */
public $recordNumber = null;
/** @var int */
public $shapeType = null;
/** @var string */
public $lastError = '';
/** @var array */
public $shpData = [];
/** @var array */
public $dbfData = [];
public function __construct(int $shapeType)
{
$this->shapeType = $shapeType;
}
/**
* Loads record from files.
*
* @param ShapeFile $shapeFile The ShapeFile object
* @param resource $shpFile Opened SHP file (by reference)
* @param resource $dbfFile Opened DBF file (by reference)
*/
public function loadFromFile(ShapeFile &$shapeFile, &$shpFile, &$dbfFile): void
{
$this->shapeFile = $shapeFile;
$this->shpFile = $shpFile;
$this->dbfFile = $dbfFile;
$this->loadHeaders();
/* No header read */
if ($this->read === 0) {
return;
}
switch ($this->shapeType) {
case 0:
$this->loadNullRecord();
break;
case 1:
$this->loadPointRecord();
break;
case 21:
$this->loadPointMRecord();
break;
case 11:
$this->loadPointZRecord();
break;
case 3:
$this->loadPolyLineRecord();
break;
case 23:
$this->loadPolyLineMRecord();
break;
case 13:
$this->loadPolyLineZRecord();
break;
case 5:
$this->loadPolygonRecord();
break;
case 25:
$this->loadPolygonMRecord();
break;
case 15:
$this->loadPolygonZRecord();
break;
case 8:
$this->loadMultiPointRecord();
break;
case 28:
$this->loadMultiPointMRecord();
break;
case 18:
$this->loadMultiPointZRecord();
break;
default:
$this->setError(sprintf('The Shape Type "%s" is not supported.', $this->shapeType));
break;
}
/* We need to skip rest of the record */
while ($this->read < $this->size) {
$this->loadData('V', 4);
}
/* Check if we didn't read too much */
if ($this->read !== $this->size) {
$this->setError(sprintf('Failed to parse record, read=%d, size=%d', $this->read, $this->size));
}
if (! ShapeFile::supportsDbase() || ! isset($this->dbfFile)) {
return;
}
$this->loadDBFData();
}
/**
* Saves record to files.
*
* @param resource $shpFile Opened SHP file
* @param resource $dbfFile Opened DBF file
* @param int $recordNumber Record number
*/
public function saveToFile(&$shpFile, &$dbfFile, int $recordNumber): void
{
$this->shpFile = $shpFile;
$this->dbfFile = $dbfFile;
$this->recordNumber = $recordNumber;
$this->saveHeaders();
switch ($this->shapeType) {
case 0:
// Nothing to save
break;
case 1:
$this->savePointRecord();
break;
case 21:
$this->savePointMRecord();
break;
case 11:
$this->savePointZRecord();
break;
case 3:
$this->savePolyLineRecord();
break;
case 23:
$this->savePolyLineMRecord();
break;
case 13:
$this->savePolyLineZRecord();
break;
case 5:
$this->savePolygonRecord();
break;
case 25:
$this->savePolygonMRecord();
break;
case 15:
$this->savePolygonZRecord();
break;
case 8:
$this->saveMultiPointRecord();
break;
case 28:
$this->saveMultiPointMRecord();
break;
case 18:
$this->saveMultiPointZRecord();
break;
default:
$this->setError(sprintf('The Shape Type "%s" is not supported.', $this->shapeType));
break;
}
if (! ShapeFile::supportsDbase() || $this->dbfFile === null) {
return;
}
$this->saveDBFData();
}
/**
* Updates DBF data to match header.
*
* @param array $header DBF structure header
*/
public function updateDBFInfo(array $header): void
{
$tmp = $this->dbfData;
unset($this->dbfData);
$this->dbfData = [];
foreach ($header as $value) {
$this->dbfData[$value[0]] = $tmp[$value[0]] ?? '';
}
}
/**
* Reads data.
*
* @param string $type type for unpack()
* @param int $count number of bytes
*
* @return mixed
*/
private function loadData(string $type, int $count)
{
$data = $this->shapeFile->readSHP($count);
if ($data === false) {
return false;
}
$this->read += strlen($data);
return Util::loadData($type, $data);
}
/**
* Loads metadata header from a file.
*/
private function loadHeaders(): void
{
$this->shapeType = false;
$this->recordNumber = $this->loadData('N', 4);
if ($this->recordNumber === false) {
return;
}
// We read the length of the record
$this->size = $this->loadData('N', 4);
if ($this->size === false) {
return;
}
$this->size = ($this->size * 2) + 8;
$this->shapeType = $this->loadData('V', 4);
}
/**
* Saves metadata header to a file.
*/
private function saveHeaders(): void
{
fwrite($this->shpFile, pack('N', $this->recordNumber));
fwrite($this->shpFile, pack('N', $this->getContentLength()));
fwrite($this->shpFile, pack('V', $this->shapeType));
}
private function loadPoint(): array
{
$data = [];
$data['x'] = $this->loadData('d', 8);
$data['y'] = $this->loadData('d', 8);
return $data;
}
private function loadPointM(): array
{
$data = $this->loadPoint();
$data['m'] = $this->loadData('d', 8);
return $data;
}
private function loadPointZ(): array
{
$data = $this->loadPoint();
$data['z'] = $this->loadData('d', 8);
$data['m'] = $this->loadData('d', 8);
return $data;
}
private function savePoint(array $data): void
{
fwrite($this->shpFile, Util::packDouble($data['x']));
fwrite($this->shpFile, Util::packDouble($data['y']));
}
private function savePointM(array $data): void
{
fwrite($this->shpFile, Util::packDouble($data['x']));
fwrite($this->shpFile, Util::packDouble($data['y']));
fwrite($this->shpFile, Util::packDouble($data['m']));
}
private function savePointZ(array $data): void
{
fwrite($this->shpFile, Util::packDouble($data['x']));
fwrite($this->shpFile, Util::packDouble($data['y']));
fwrite($this->shpFile, Util::packDouble($data['z']));
fwrite($this->shpFile, Util::packDouble($data['m']));
}
private function loadNullRecord(): void
{
$this->shpData = [];
}
private function loadPointRecord(): void
{
$this->shpData = $this->loadPoint();
}
private function loadPointMRecord(): void
{
$this->shpData = $this->loadPointM();
}
private function loadPointZRecord(): void
{
$this->shpData = $this->loadPointZ();
}
private function savePointRecord(): void
{
$this->savePoint($this->shpData);
}
private function savePointMRecord(): void
{
$this->savePointM($this->shpData);
}
private function savePointZRecord(): void
{
$this->savePointZ($this->shpData);
}
private function loadBBox(): void
{
$this->shpData['xmin'] = $this->loadData('d', 8);
$this->shpData['ymin'] = $this->loadData('d', 8);
$this->shpData['xmax'] = $this->loadData('d', 8);
$this->shpData['ymax'] = $this->loadData('d', 8);
}
private function loadMultiPointRecord(): void
{
$this->shpData = [];
$this->loadBBox();
$this->shpData['numpoints'] = $this->loadData('V', 4);
for ($i = 0; $i < $this->shpData['numpoints']; ++$i) {
$this->shpData['points'][] = $this->loadPoint();
}
}
private function loadMultiPointMZRecord(string $type): void
{
/* The m dimension is optional, depends on bounding box data */
if ($type === 'm' && ! $this->shapeFile->hasMeasure()) {
return;
}
$this->shpData[$type . 'min'] = $this->loadData('d', 8);
$this->shpData[$type . 'max'] = $this->loadData('d', 8);
for ($i = 0; $i < $this->shpData['numpoints']; ++$i) {
$this->shpData['points'][$i][$type] = $this->loadData('d', 8);
}
}
private function loadMultiPointMRecord(): void
{
$this->loadMultiPointRecord();
$this->loadMultiPointMZRecord('m');
}
private function loadMultiPointZRecord(): void
{
$this->loadMultiPointRecord();
$this->loadMultiPointMZRecord('z');
$this->loadMultiPointMZRecord('m');
}
private function saveMultiPointRecord(): void
{
fwrite($this->shpFile, pack(
'dddd',
$this->shpData['xmin'],
$this->shpData['ymin'],
$this->shpData['xmax'],
$this->shpData['ymax']
));
fwrite($this->shpFile, pack('V', $this->shpData['numpoints']));
for ($i = 0; $i < $this->shpData['numpoints']; ++$i) {
$this->savePoint($this->shpData['points'][$i]);
}
}
private function saveMultiPointMZRecord(string $type): void
{
fwrite($this->shpFile, pack('dd', $this->shpData[$type . 'min'], $this->shpData[$type . 'max']));
for ($i = 0; $i < $this->shpData['numpoints']; ++$i) {
fwrite($this->shpFile, Util::packDouble($this->shpData['points'][$i][$type]));
}
}
private function saveMultiPointMRecord(): void
{
$this->saveMultiPointRecord();
$this->saveMultiPointMZRecord('m');
}
private function saveMultiPointZRecord(): void
{
$this->saveMultiPointRecord();
$this->saveMultiPointMZRecord('z');
$this->saveMultiPointMZRecord('m');
}
private function loadPolyLineRecord(): void
{
$this->shpData = [];
$this->loadBBox();
$this->shpData['numparts'] = $this->loadData('V', 4);
$this->shpData['numpoints'] = $this->loadData('V', 4);
$numparts = $this->shpData['numparts'];
$numpoints = $this->shpData['numpoints'];
for ($i = 0; $i < $numparts; ++$i) {
$this->shpData['parts'][$i] = $this->loadData('V', 4);
}
$part = 0;
for ($i = 0; $i < $numpoints; ++$i) {
if ($part + 1 < $numparts && $i === $this->shpData['parts'][$part + 1]) {
++$part;
}
if (! isset($this->shpData['parts'][$part]['points'])
|| ! is_array($this->shpData['parts'][$part]['points'])
) {
$this->shpData['parts'][$part] = ['points' => []];
}
$this->shpData['parts'][$part]['points'][] = $this->loadPoint();
}
}
private function loadPolyLineMZRecord(string $type): void
{
/* The m dimension is optional, depends on bounding box data */
if ($type === 'm' && ! $this->shapeFile->hasMeasure()) {
return;
}
$this->shpData[$type . 'min'] = $this->loadData('d', 8);
$this->shpData[$type . 'max'] = $this->loadData('d', 8);
$numparts = $this->shpData['numparts'];
$numpoints = $this->shpData['numpoints'];
$part = 0;
for ($i = 0; $i < $numpoints; ++$i) {
if ($part + 1 < $numparts && $i === $this->shpData['parts'][$part + 1]) {
++$part;
}
$this->shpData['parts'][$part]['points'][$i][$type] = $this->loadData('d', 8);
}
}
private function loadPolyLineMRecord(): void
{
$this->loadPolyLineRecord();
$this->loadPolyLineMZRecord('m');
}
private function loadPolyLineZRecord(): void
{
$this->loadPolyLineRecord();
$this->loadPolyLineMZRecord('z');
$this->loadPolyLineMZRecord('m');
}
private function savePolyLineRecord(): void
{
fwrite($this->shpFile, pack(
'dddd',
$this->shpData['xmin'],
$this->shpData['ymin'],
$this->shpData['xmax'],
$this->shpData['ymax']
));
fwrite($this->shpFile, pack('VV', $this->shpData['numparts'], $this->shpData['numpoints']));
$partIndex = 0;
for ($i = 0; $i < $this->shpData['numparts']; ++$i) {
fwrite($this->shpFile, pack('V', $partIndex));
$partIndex += count($this->shpData['parts'][$i]['points']);
}
foreach ($this->shpData['parts'] as $partData) {
foreach ($partData['points'] as $pointData) {
$this->savePoint($pointData);
}
}
}
private function savePolyLineMZRecord(string $type): void
{
fwrite($this->shpFile, pack('dd', $this->shpData[$type . 'min'], $this->shpData[$type . 'max']));
foreach ($this->shpData['parts'] as $partData) {
foreach ($partData['points'] as $pointData) {
fwrite($this->shpFile, Util::packDouble($pointData[$type]));
}
}
}
private function savePolyLineMRecord(): void
{
$this->savePolyLineRecord();
$this->savePolyLineMZRecord('m');
}
private function savePolyLineZRecord(): void
{
$this->savePolyLineRecord();
$this->savePolyLineMZRecord('z');
$this->savePolyLineMZRecord('m');
}
private function loadPolygonRecord(): void
{
$this->loadPolyLineRecord();
}
private function loadPolygonMRecord(): void
{
$this->loadPolyLineMRecord();
}
private function loadPolygonZRecord(): void
{
$this->loadPolyLineZRecord();
}
private function savePolygonRecord(): void
{
$this->savePolyLineRecord();
}
private function savePolygonMRecord(): void
{
$this->savePolyLineMRecord();
}
private function savePolygonZRecord(): void
{
$this->savePolyLineZRecord();
}
private function adjustBBox(array $point): void
{
// Adjusts bounding box based on point
$directions = [
'x',
'y',
'z',
'm',
];
foreach ($directions as $direction) {
if (! isset($point[$direction])) {
continue;
}
$min = $direction . 'min';
$max = $direction . 'max';
if (! isset($this->shpData[$min]) || ($this->shpData[$min] > $point[$direction])) {
$this->shpData[$min] = $point[$direction];
}
if (isset($this->shpData[$max]) && ($this->shpData[$max] >= $point[$direction])) {
continue;
}
$this->shpData[$max] = $point[$direction];
}
}
/**
* Sets dimension to 0 if not set.
*
* @param array $point Point to check
* @param string $dimension Dimension to check
*
* @return array
*/
private function fixPoint(array $point, string $dimension): array
{
if (! isset($point[$dimension])) {
$point[$dimension] = 0.0; // no_value
}
return $point;
}
/**
* Adjust point and bounding box when adding point.
*
* @param array $point Point data
*
* @return array Fixed point data
*/
private function adjustPoint(array $point): array
{
$type = $this->shapeType / 10;
if ($type >= 2) {
$point = $this->fixPoint($point, 'm');
} elseif ($type >= 1) {
$point = $this->fixPoint($point, 'z');
$point = $this->fixPoint($point, 'm');
}
return $point;
}
/**
* Adds point to a record.
*
* @param array $point Point data
* @param int $partIndex Part index
*/
public function addPoint(array $point, int $partIndex = 0): void
{
$point = $this->adjustPoint($point);
switch ($this->shapeType) {
case 0:
//Don't add anything
return;
case 1:
case 11:
case 21:
//Substitutes the value of the current point
$this->shpData = $point;
break;
case 3:
case 5:
case 13:
case 15:
case 23:
case 25:
//Adds a new point to the selected part
$this->shpData['parts'][$partIndex]['points'][] = $point;
$this->shpData['numparts'] = count($this->shpData['parts']);
$this->shpData['numpoints'] = 1 + ($this->shpData['numpoints'] ?? 0);
break;
case 8:
case 18:
case 28:
//Adds a new point
$this->shpData['points'][] = $point;
$this->shpData['numpoints'] = 1 + ($this->shpData['numpoints'] ?? 0);
break;
default:
$this->setError(sprintf('The Shape Type "%s" is not supported.', $this->shapeType));
return;
}
$this->adjustBBox($point);
}
/**
* Deletes point from a record.
*
* @param int $pointIndex Point index
* @param int $partIndex Part index
*/
public function deletePoint(int $pointIndex = 0, int $partIndex = 0): void
{
switch ($this->shapeType) {
case 0:
//Don't delete anything
break;
case 1:
case 11:
case 21:
//Sets the value of the point to zero
$this->shpData['x'] = 0.0;
$this->shpData['y'] = 0.0;
if (in_array($this->shapeType, [11, 21])) {
$this->shpData['m'] = 0.0;
}
if (in_array($this->shapeType, [11])) {
$this->shpData['z'] = 0.0;
}
break;
case 3:
case 5:
case 13:
case 15:
case 23:
case 25:
//Deletes the point from the selected part, if exists
if (isset($this->shpData['parts'][$partIndex])
&& isset($this->shpData['parts'][$partIndex]['points'][$pointIndex])
) {
$count = count($this->shpData['parts'][$partIndex]['points']) - 1;
for ($i = $pointIndex; $i < $count; ++$i) {
$point = $this->shpData['parts'][$partIndex]['points'][$i + 1];
$this->shpData['parts'][$partIndex]['points'][$i] = $point;
}
$count = count($this->shpData['parts'][$partIndex]['points']) - 1;
unset($this->shpData['parts'][$partIndex]['points'][$count]);
$this->shpData['numparts'] = count($this->shpData['parts']);
--$this->shpData['numpoints'];
}
break;
case 8:
case 18:
case 28:
//Deletes the point, if exists
if (isset($this->shpData['points'][$pointIndex])) {
$count = count($this->shpData['points']) - 1;
for ($i = $pointIndex; $i < $count; ++$i) {
$this->shpData['points'][$i] = $this->shpData['points'][$i + 1];
}
unset($this->shpData['points'][count($this->shpData['points']) - 1]);
--$this->shpData['numpoints'];
}
break;
default:
$this->setError(sprintf('The Shape Type "%s" is not supported.', $this->shapeType));
break;
}
}
/**
* Returns length of content.
*/
public function getContentLength(): ?int
{
// The content length for a record is the length of the record contents section measured in 16-bit words.
// one coordinate makes 4 16-bit words (64 bit double)
switch ($this->shapeType) {
case 0:
$result = 0;
break;
case 1:
$result = 10;
break;
case 21:
$result = 10 + 4;
break;
case 11:
$result = 10 + 8;
break;
case 3:
case 5:
$count = count($this->shpData['parts']);
$result = 22 + 2 * $count;
for ($i = 0; $i < $count; ++$i) {
$result += 8 * count($this->shpData['parts'][$i]['points']);
}
break;
case 23:
case 25:
$count = count($this->shpData['parts']);
$result = 22 + (2 * 4) + 2 * $count;
for ($i = 0; $i < $count; ++$i) {
$result += (8 + 4) * count($this->shpData['parts'][$i]['points']);
}
break;
case 13:
case 15:
$count = count($this->shpData['parts']);
$result = 22 + (4 * 4) + 2 * $count;
for ($i = 0; $i < $count; ++$i) {
$result += (8 + 8) * count($this->shpData['parts'][$i]['points']);
}
break;
case 8:
$result = 20 + 8 * count($this->shpData['points']);
break;
case 28:
$result = 20 + (2 * 4) + (8 + 4) * count($this->shpData['points']);
break;
case 18:
$result = 20 + (4 * 4) + (8 + 8) * count($this->shpData['points']);
break;
default:
$result = null;
$this->setError(sprintf('The Shape Type "%s" is not supported.', $this->shapeType));
break;
}
return $result;
}
private function loadDBFData(): void
{
$this->dbfData = @dbase_get_record_with_names($this->dbfFile, $this->recordNumber);
unset($this->dbfData['deleted']);
}
private function saveDBFData(): void
{
if (count($this->dbfData) === 0) {
return;
}
unset($this->dbfData['deleted']);
if ($this->recordNumber <= dbase_numrecords($this->dbfFile)) {
if (! dbase_replace_record($this->dbfFile, array_values($this->dbfData), $this->recordNumber)) {
$this->setError('I wasn\'t possible to update the information in the DBF file.');
}
} else {
if (! dbase_add_record($this->dbfFile, array_values($this->dbfData))) {
$this->setError('I wasn\'t possible to add the information to the DBF file.');
}
}
}
/**
* Sets error message.
*/
public function setError(string $error): void
{
$this->lastError = $error;
}
/**
* Returns shape name.
*/
public function getShapeName(): string
{
return Util::nameShape($this->shapeType);
}
}

126
admin/phpMyAdmin/vendor/phpmyadmin/shapefile/src/Util.php vendored Normal file
View file

@ -0,0 +1,126 @@
<?php
declare(strict_types=1);
/**
* phpMyAdmin ShapeFile library
* <https://github.com/phpmyadmin/shapefile/>.
*
* Copyright 2006-2007 Ovidio <ovidio AT users.sourceforge.net>
* Copyright 2016 - 2017 Michal Čihař <michal@cihar.com>
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, you can download one from
* https://www.gnu.org/copyleft/gpl.html.
*/
namespace PhpMyAdmin\ShapeFile;
use function current;
use function pack;
use function sprintf;
use function strlen;
use function unpack;
class Util
{
/** @var bool|null */
private static $littleEndian = null;
/** @var array */
private static $shapeNames = [
0 => 'Null Shape',
1 => 'Point',
3 => 'PolyLine',
5 => 'Polygon',
8 => 'MultiPoint',
11 => 'PointZ',
13 => 'PolyLineZ',
15 => 'PolygonZ',
18 => 'MultiPointZ',
21 => 'PointM',
23 => 'PolyLineM',
25 => 'PolygonM',
28 => 'MultiPointM',
31 => 'MultiPatch',
];
/**
* Reads data.
*
* @param string $type type for unpack()
* @param string|false $data Data to process
*
* @return mixed|false
*/
public static function loadData(string $type, $data)
{
if ($data === false) {
return false;
}
if (strlen($data) === 0) {
return false;
}
$tmp = unpack($type, $data);
return $tmp === false ? $tmp : current($tmp);
}
/**
* Changes endianity.
*
* @param string $binValue Binary value
*/
public static function swap(string $binValue): string
{
$result = $binValue[strlen($binValue) - 1];
for ($i = strlen($binValue) - 2; $i >= 0; --$i) {
$result .= $binValue[$i];
}
return $result;
}
/**
* Encodes double value to correct endianity.
*
* @param float $value Value to pack
*/
public static function packDouble(float $value): string
{
$bin = pack('d', (float) $value);
if (self::$littleEndian === null) {
self::$littleEndian = (pack('L', 1) === pack('V', 1));
}
if (self::$littleEndian) {
return $bin;
}
return self::swap($bin);
}
/**
* Returns shape name.
*/
public static function nameShape(int $type): string
{
if (isset(self::$shapeNames[$type])) {
return self::$shapeNames[$type];
}
return sprintf('Shape %d', $type);
}
}