protected function createNewLayer($map, $driver, $layerName, $geoType, $bSearchSpatialRef)
{
// if layer contains point objects
if ($geoType == wkbPoint) {
// before creating layer "entities" we create layer "blocks"
$layerBlocks = OGR_DS_CreateLayer($driver, 'blocks', NULL, wkbMultiLineString, NULL);
// in this layer we export representaion of all point objects (it's a square)
$wktLine = 'MULTILINESTRING((-0.5 -0.5, 0.5 -0.5, 0.5 0.5, -0.5 0.5, -0.5 -0.5))';
$geoOGR = ogr_g_createfromwkt($wktLine, NULL, NULL);
$dfnLayerBlocks = OGR_L_GetLayerDefn($layerBlocks);
$dataLine = OGR_F_Create($dfnLayerBlocks);
OGR_F_SetGeometry($dataLine, $geoOGR);
for ($i = 0; $i < OGR_FD_GetFieldCount($dfnLayerBlocks); $i++) {
$fieldDfn = OGR_FD_GetFieldDefn($dfnLayerBlocks, $i);
if (OGR_Fld_GetNameRef($fieldDfn) == 'BlockName') {
OGR_F_SetFieldString($dataLine, $i, 'SQUARE');
}
}
OGR_L_CreateFeature($layerBlocks, $dataLine);
OGR_F_Destroy($dataLine);
OGR_G_DestroyGeometry($geoOGR);
}
return parent::createNewLayer($map, $driver, 'entities', $geoType, false);
}
function __construct($driverName, $exportExt, $json, $map, $bExportAtt = false, $optDataSourceCreation = NULL, $bSearchSpatialRef = false)
{
$bOk = false;
$msVersion = null;
// MapServer version
$groups = null;
// Layers list that will be exported
parent::__construct($json);
OGRRegisterAll();
// looking for destination driver
for ($iDriver = 0; $iDriver < OGRGetDriverCount() && !$bOk; $iDriver++) {
if (!strcasecmp(OGR_DR_GetName(OGRGetDriver($iDriver)), $driverName)) {
$this->driverOGRDest = OGRGetDriver($iDriver);
$bOk = true;
break;
}
}
if ($bOk) {
// is it possible to create new data source with current driver
if (!OGR_Dr_TestCapability($this->driverOGRDest, ODrCCreateDataSource)) {
$this->driverOGRDest = null;
$bOk = false;
return;
}
}
if ($bOk) {
$msVersion = $_SESSION['MS_VERSION'];
$groups = (array) $this->jsonList[0];
// Create the destination directory
@mkdir($this->tempFilePath, 0700);
// for each layers that will be exported
foreach ($groups as $grp) {
$baseDest = null;
$layerList = array();
$attNameList = $grp->header;
$ObjList = $grp->values;
if (!$ObjList[0][0]->shplink) {
continue;
}
// if we need to export attributs
if ($bExportAtt) {
include_once '../common/pluginsMapUtils.inc.php';
for ($iAtt = 0; $iAtt < count($attNameList); $iAtt++) {
if ($attNameList[$iAtt] == '@') {
array_splice($attNameList, $iAtt, 1);
$iAtt--;
continue;
}
// remove accents and spaces:
$newAttName = PluginsMapUtils::decodeMapFileVal($map, $attNameList[$iAtt], 'UTF-8');
$newAttName = str_replace($this->bad, $this->good, $attNameList[$iAtt]);
if (is_numeric($newAttName[0])) {
$newAttName = 'z' . $newAttName;
}
$attNameList[$iAtt] = $newAttName;
}
}
// for each objects that we want to export
foreach ($ObjList as $Obj) {
$layerSrc = null;
// Source layer
$layerDest = null;
// Destination layer
$baseDest = null;
// Destination DataBase
$geoType = 0;
$shpLink = $Obj[0]->shplink;
$layerName = $shpLink[0];
$IdObj = $shpLink[1];
// if it's the first time we found current layer
if (!isset($layerList[$layerName])) {
// getting mapserver layer
$layerSrc = $map->getLayerByName($layerName);
// use layers with complex queries that are too long to select results
$newdata = $layerSrc->getMetaData('PM_RESULT_DATASUBSTITION');
if ($newdata != '') {
$layerSrc->set('data', $newdata);
}
// create destination data base
$output = $this->tempFilePath . "\\{$layerName}.{$exportExt}";
$output = str_replace('/', '\\', $output);
$baseDest = OGR_Dr_CreateDataSource($this->driverOGRDest, $output, $optDataSourceCreation);
if (!$baseDest) {
continue;
}
// is it possible to create new layers in current data source ?
if (!OGR_DS_TestCapability($baseDest, ODsCCreateLayer)) {
if ($baseDest) {
OGR_DS_Destroy($baseDest);
}
continue;
}
// create new layer in the destination data base
$geoType = $this->typeList[$layerSrc->type];
$layerDest = $this->createNewLayer($map, $baseDest, $layerName, $geoType, $bSearchSpatialRef);
// add new attribut in destination layer
if ($bExportAtt) {
$idAtt = 0;
foreach ($attNameList as $attName) {
$att = OGR_Fld_Create($attName, OFTString);
OGR_L_CreateField($layerDest, $att, $idAtt);
$idAtt++;
}
}
// saving all in layerList
$layerList[$layerName] = array();
$layerList[$layerName][] = $layerSrc;
$layerList[$layerName][] = $baseDest;
$layerList[$layerName][] = $layerDest;
$layerList[$layerName][] = $geoType;
// add file to files list will be exorted
$this->addFileToFileList($output);
} else {
$layerSrc = $layerList[$layerName][0];
$baseDest = $layerList[$layerName][1];
$layerDest = $layerList[$layerName][2];
$geoType = $layerList[$layerName][3];
}
// gettint shape object
$srcShp = PMCommon::resultGetShape($msVersion, $layerSrc, null, $IdObj, -1);
// export geometry of the object in WKT
$geoWKT = $srcShp->toWkt();
// create new geometry OGR object from WKT geometry
$geoOGR = $this->createNewOGRGeometry($geoWKT);
// create new data line on destination layer
$layerDestDefn = OGR_L_GetLayerDefn($layerDest);
$Data = OGR_F_Create($layerDestDefn);
// add geometry in data line
OGR_F_SetGeometry($Data, $geoOGR);
// if we need to export attributs
if ($bExportAtt) {
// add attributs values in data line
for ($iAtt = 1; $iAtt < count($Obj); $iAtt++) {
$newAttVal = PluginsMapUtils::decodeLayerVal($map, $layerName, $Obj[$iAtt], 'UTF-8');
OGR_F_SetFieldString($Data, $iAtt - 1 + $this->nbFieldBase, $newAttVal);
}
}
$this->insertSpecialFields($geoType, $layerDestDefn, $Data);
// add data line in destination layer
OGR_L_CreateFeature($layerDest, $Data);
OGR_F_Destroy($Data);
OGR_G_DestroyGeometry($geoOGR);
}
foreach ($layerList as $l) {
if (isset($l[1]) && $l[1]) {
OGR_DS_Destroy($l[1]);
}
}
}
// files compression
$this->zipFiles();
// remove directory
rmdir($this->tempFilePath);
}
}
function TranslateLayer($hSrcDS, $hSrcLayer, $hDstDS, $amAttributeIn)
{
/* -------------------------------------------------------------------- */
/* Create the layer. */
/* -------------------------------------------------------------------- */
if (!OGR_DS_TestCapability($hDstDS, ODsCCreateLayer)) {
printf("%s data source does not support layer creation.\n", OGR_DS_GetName($hDstDS));
return OGRERR_FAILURE;
}
$hFDefn = OGR_L_GetLayerDefn($hSrcLayer);
/* MapInfo data sources are created with one empty layer corresponding
to the $strFname that was passed to the OGR_Dr_CreateDataSource() call.
Fetch this layer handle now. */
$hDstLayer = OGR_DS_GetLayer($hDstDS, 0);
if ($hDstLayer == NULL) {
return FALSE;
}
$iFieldCount = OGR_FD_GetFieldCount($hFDefn);
printf("field count =%d\n", $iFieldCount);
/* -------------------------------------------------------------------- */
/* Add fields. */
/* -------------------------------------------------------------------- */
for ($iField = 0; $iField < $iFieldCount; $iField++) {
if (OGR_L_CreateField($hDstLayer, OGR_FD_GetFieldDefn($hFDefn, $iField), 0) != OGRERR_NONE) {
return FALSE;
}
}
/* -------------------------------------------------------------------- */
/* Transfer features. */
/* -------------------------------------------------------------------- */
OGR_L_ResetReading($hSrcLayer);
while (($hFeature = OGR_L_GetNextFeature($hSrcLayer)) != NULL) {
$hDstFeature = OGR_F_Create(OGR_L_GetLayerDefn($hDstLayer));
/* Verify if the current feature is corresponding to the feature
to update the attribute to. If yes, the value corresponding to
the attribute name selected is substituted. All other attributes
and geometry are copied as is. If not, the source feature
is copied to the destination feature as is.*/
if ($amAttributeIn && OGR_F_GetFID($hFeature) == $amAttributeIn[0]) {
for ($i = 0; $i < $iFieldCount; $i++) {
$hCurrentFieldDefn = OGR_F_GetFieldDefnRef($hFeature, $i);
$strCurrentFieldName = OGR_FLD_GetNameRef($hCurrentFieldDefn);
if ($strCurrentFieldName == $amAttributeIn[1]) {
$value = $amAttributeIn[2];
} else {
$value = OGR_F_GetFieldAsString($hFeature, $i);
}
OGR_F_SetFieldString($hDstFeature, $i, $value);
}
$hGeometry = OGR_F_GetGeometryRef($hFeature);
OGR_F_SetGeometry($hDstFeature, $hGeometry);
} else {
if (OGR_F_SetFrom($hDstFeature, $hFeature, FALSE) != OGRERR_NONE) {
OGR_F_Destroy($hFeature);
printf("Unable to translate feature %d from layer %s.\n", OGR_F_GetFID($hFeature), OGR_FD_GetName($hFDefn));
return FALSE;
}
}
OGR_F_Destroy($hFeature);
if (OGR_L_CreateFeature($hDstLayer, $hDstFeature) != OGRERR_NONE) {
OGR_F_Destroy($hDstFeature);
return FALSE;
}
OGR_F_Destroy($hDstFeature);
}
return TRUE;
}
function OGRCCreate($strFname)
{
/* Register all OGR drivers */
OGRRegisterAll();
/* Fetch MITAB driver - we want to create a TAB file */
$numDrivers = OGRGetDriverCount();
printf("nombre drivers = %d\n", $numDrivers);
for ($i = 0; $i < $numDrivers; $i++) {
$hdriver = OGRGetDriver($i);
if (OGR_Dr_GetName($hdriver) == "MapInfo File") {
printf("Driver name = %s driver number = %d\n", OGR_Dr_GetName($hdriver), $i);
break;
/* Found it! */
}
$hdriver = NULL;
}
if (!$hdriver) {
printf("Driver not found!\n");
return -1;
}
/* Create new file using this driver */
/*Uncomment and add options here. */
/* $aoptions[0] = 'option1';
$aoptions[1] = 'option2';
$hdatasource = OGR_Dr_CreateDataSource($hdriver, $strFname, $aoptions);
*/
/* Or use no option.*/
$hdatasource = OGR_Dr_CreateDataSource($hdriver, $strFname, NULL);
if ($hdatasource == NULL) {
printf("Unable to create %s\n", $strFname);
return -1;
}
/* MapInfo data sources are created with one empty layer corresponding
to the $strFname that was passed to the OGR_Dr_CreateDataSource() call.
Fetch this layer handle now. */
$hlayer = OGR_DS_GetLayer($hdatasource, 0);
if ($hlayer == NULL) {
printf("Unable to create new layer in %s\n", $strFname);
return -1;
}
/* Add a few fields to the layer defn */
$hfieldDefn = OGR_Fld_Create("id", OFTInteger);
$eErr = OGR_L_CreateField($hlayer, $hfieldDefn, 0);
if ($eErr != OGRERR_NONE) {
return $eErr;
}
$hfieldDefn = OGR_Fld_Create("area", OFTReal);
$eErr = OGR_L_CreateField($hlayer, $hfieldDefn, 0);
if ($eErr != OGRERR_NONE) {
return $eErr;
}
$hfieldDefn = OGR_Fld_Create("name", OFTString);
$eErr = OGR_L_CreateField($hlayer, $hfieldDefn, 0);
if ($eErr != OGRERR_NONE) {
return $eErr;
}
/* We'll need the layerDefn handle to create new features in this layer */
$hlayerDefn = OGR_L_GetLayerDefn($hlayer);
/* Create a new point */
$hfeature = OGR_F_Create($hlayerDefn);
OGR_F_SetFieldInteger($hfeature, 0, 1);
OGR_F_SetFieldDouble($hfeature, 1, 123.45);
OGR_F_SetFieldString($hfeature, 2, "Feature #1");
$hgeometry = OGR_G_CreateGeometry(wkbPoint);
OGR_G_SetPoint($hgeometry, 0, 123.45, 456.78, 0);
$eErr = OGR_F_SetGeometry($hfeature, $hgeometry);
if ($eErr != OGRERR_NONE) {
return $eErr;
}
$eErr = OGR_L_CreateFeature($hlayer, $hfeature);
if ($eErr != OGRERR_NONE) {
printf("Error trapped");
return $eErr;
}
/* Create a new line */
$hfeature = OGR_F_Create($hlayerDefn);
OGR_F_SetFieldInteger($hfeature, 0, 2);
OGR_F_SetFieldDouble($hfeature, 1, 42.45);
OGR_F_SetFieldString($hfeature, 2, "Feature #2");
$hgeometry = OGR_G_CreateGeometry(wkbLineString);
OGR_G_AddPoint($hgeometry, 123.45, 456.78, 0);
OGR_G_AddPoint($hgeometry, 12.34, 45.67, 0);
$eErr = OGR_F_SetGeometry($hfeature, $hgeometry);
if ($eErr != OGRERR_NONE) {
return $eErr;
}
$eErr = OGR_L_CreateFeature($hlayer, $hfeature);
if ($eErr != OGRERR_NONE) {
return $eErr;
}
/* Create a new polygon (square) */
$hfeature = OGR_F_Create($hlayerDefn);
OGR_F_SetFieldInteger($hfeature, 0, 3);
OGR_F_SetFieldDouble($hfeature, 1, 49.71);
OGR_F_SetFieldString($hfeature, 2, "Feature #3");
$hgeometry = OGR_G_CreateGeometry(wkbPolygon);
$hring = OGR_G_CreateGeometry(wkbLinearRing);
OGR_G_AddPoint($hring, 123.45, 456.78, 0);
OGR_G_AddPoint($hring, 12.34, 456.78, 0);
OGR_G_AddPoint($hring, 12.34, 45.67, 0);
OGR_G_AddPoint($hring, 123.45, 45.67, 0);
OGR_G_AddPoint($hring, 123.45, 456.78, 0);
$eErr = OGR_G_AddGeometry($hgeometry, $hring);
if ($eErr != OGRERR_NONE) {
return $eErr;
}
$eErr = OGR_F_SetGeometry($hfeature, $hgeometry);
if ($eErr != OGRERR_NONE) {
return $eErr;
}
$eErr = OGR_L_CreateFeature($hlayer, $hfeature);
if ($eErr != OGRERR_NONE) {
return $eErr;
}
/* Close data source */
OGR_DS_Destroy($hdatasource);
return OGRERR_NONE;
}
