function OGRSetGetString($hFeatureIn, $iField, $value)
{
    /*Assigning a string value to the field to the field "0".*/
    OGR_F_SetFieldString($hFeatureIn, $iField, $value);
    /*Retrieving the field value. */
    $value = OGR_F_GetFieldAsString($hFeatureIn, $iField);
    printf("String value = %s\n", $value);
    return OGRERR_NONE;
}
Beispiel #2
0
 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;
}
Beispiel #5
0
 protected function insertSpecialFields($geoType, $dfnLayerDest, $dataLine)
 {
     // if "dataLine" contains point object
     if ($geoType == wkbPoint) {
         // we inform the name of representation
         for ($i = 0; $i < OGR_FD_GetFieldCount($dfnLayerDest); $i++) {
             $fieldDfn = OGR_FD_GetFieldDefn($dfnLayerDest, $i);
             if (OGR_Fld_GetNameRef($fieldDfn) == 'BlockName') {
                 OGR_F_SetFieldString($dataLine, $i, 'SQUARE');
             }
         }
     }
     return true;
 }