Exemplo n.º 1
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 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;
}
function OGR2Tab_Update_main()
{
    $strFormat = "MapInfo File";
    $strDataSource = NULL;
    $strDestDataSource = NULL;
    $amAttribute = NULL;
    /* -------------------------------------------------------------------- */
    /*      Register format(s).                                             */
    /* -------------------------------------------------------------------- */
    OGRRegisterAll();
    /* -------------------------------------------------------------------- */
    /*      Processing command line arguments.                              */
    /* -------------------------------------------------------------------- */
    $numArgs = count($_SERVER["argv"]);
    for ($iArg = 1; $iArg < $numArgs; $iArg++) {
        /* Get the feature id and attribute name to update to the new attribute
           value.*/
        if (!strcasecmp($_SERVER["argv"][$iArg], "-fid") && $iArg < $numArgs - 1) {
            $amAttribute[0] = $_SERVER["argv"][++$iArg];
            $amAttribute[1] = $_SERVER["argv"][++$iArg];
            $amAttribute[2] = $_SERVER["argv"][++$iArg];
            printf("FID = %d\n", $amAttribute[0]);
            printf("Attribute name  = %s\n", $amAttribute[1]);
            printf("Attribute value = %d\n", $amAttribute[2]);
        } else {
            if ($_SERVER["argv"][$iArg][0] == '-') {
                Usage();
            } else {
                if ($strDestDataSource == NULL) {
                    $strDestDataSource = $_SERVER["argv"][$iArg];
                    printf("DestDataSource = %s\n", $strDestDataSource);
                } else {
                    if ($strDataSource == NULL) {
                        $strDataSource = $_SERVER["argv"][$iArg];
                        printf("DataSource = %s\n", $strDataSource);
                    }
                }
            }
        }
    }
    if ($strDataSource == NULL) {
        Usage();
    }
    /* -------------------------------------------------------------------- */
    /*      Open data source.                                               */
    /* -------------------------------------------------------------------- */
    $hSFDriver = NULL;
    $hDS = OGROpen($strDataSource, FALSE, $hSFDriver);
    /* -------------------------------------------------------------------- */
    /*      Report failure                                                  */
    /* -------------------------------------------------------------------- */
    if ($hDS == NULL) {
        printf("FAILURE:\nUnable to open datasource `%s' with the following drivers:\n", $strDataSource);
        for ($iDriver = 0; $iDriver < OGRGetDriverCount(); $iDriver++) {
            printf("  -> %s\n", OGR_DR_GetName(OGRGetDriver($iDriver)));
        }
        return OGRERR_FAILURE;
    }
    /* -------------------------------------------------------------------- */
    /*      Find the output driver.                                         */
    /* -------------------------------------------------------------------- */
    for ($iDriver = 0; $iDriver < OGRGetDriverCount() && $hSFDriver == NULL; $iDriver++) {
        if (!strcasecmp(OGR_DR_GetName(OGRGetDriver($iDriver)), $strFormat)) {
            $hSFDriver = OGRGetDriver($iDriver);
        }
    }
    if ($hSFDriver == NULL) {
        printf("Unable to find driver `%s'.\n", $strFormat);
        printf("The following drivers are available:\n");
        for ($iDriver = 0; $iDriver < OGRGetDriverCount(); $iDriver++) {
            printf("  -> %s\n", OGR_DR_GetName(OGRGetDriver($iDriver)));
        }
        return OGRERR_FAILURE;
    }
    if (!OGR_Dr_TestCapability($hSFDriver, ODrCCreateDataSource)) {
        printf("%s driver does not support data source creation.\n", $strFormat);
        return OGRERR_FAILURE;
    }
    /* -------------------------------------------------------------------- */
    /*      Create the output data source.                                  */
    /* -------------------------------------------------------------------- */
    /*Uncomment and add options here. */
    /* $aoptions[0] = 'option1';
        $aoptions[1] = 'option2';
        $hODS = OGR_Dr_CreateDataSource( $hSFDriver, $strDestDataSource, $aoptions );
    */
    /* Or use no option.*/
    $hODS = OGR_Dr_CreateDataSource($hSFDriver, $strDestDataSource, NULL);
    if ($hODS == NULL) {
        return OGRERR_FAILURE;
    }
    /* -------------------------------------------------------------------- */
    /*      Process only first layer in source dataset                      */
    /* -------------------------------------------------------------------- */
    if (OGR_DS_GetLayerCount($hDS) > 0) {
        $hLayer = OGR_DS_GetLayer($hDS, 0);
        if ($hLayer == NULL) {
            printf("FAILURE: Couldn't fetch advertised layer 0!\n");
            return OGRERR_FAILURE;
        }
        if (!TranslateLayer($hDS, $hLayer, $hODS, $amAttribute)) {
            return OGRERR_FAILURE;
        }
    }
    /* -------------------------------------------------------------------- */
    /*      Close down.                                                     */
    /* -------------------------------------------------------------------- */
    OGR_DS_Destroy($hDS);
    OGR_DS_Destroy($hODS);
    return OGRERR_NONE;
}
function OGR2Tab_SQL_main()
{
    /*Assigning initial value.*/
    $strFormat = "MapInfo File";
    $strDataSource = NULL;
    $strDestDataSource = NULL;
    $strWhere = NULL;
    $hSpatialFilter = NULL;
    $strSQLStatement = NULL;
    $strDialect = NULL;
    /* -------------------------------------------------------------------- */
    /*      Register format(s).                                             */
    /* -------------------------------------------------------------------- */
    OGRRegisterAll();
    /* -------------------------------------------------------------------- */
    /*      Processing command line arguments.                              */
    /* -------------------------------------------------------------------- */
    $numArgs = count($_SERVER["argv"]);
    for ($iArg = 1; $iArg < $numArgs; $iArg++) {
        /* Construct a spatial filter.*/
        if ($_SERVER["argv"][$iArg] == "-spat" && $_SERVER["argv"][$iArg + 1] != NULL && $_SERVER["argv"][$iArg + 2] != NULL && $_SERVER["argv"][$iArg + 3] != NULL && $_SERVER["argv"][$iArg + 4] != NULL) {
            $hSpatialFilter = OGR_G_CreateGeometry(wkbLinearRing);
            OGR_G_AddPoint($hSpatialFilter, floatval($_SERVER["argv"][$iArg + 1]), floatval($_SERVER["argv"][$iArg + 2]), 0.0);
            OGR_G_AddPoint($hSpatialFilter, floatval($_SERVER["argv"][$iArg + 1]), floatval($_SERVER["argv"][$iArg + 4]), 0.0);
            OGR_G_AddPoint($hSpatialFilter, floatval($_SERVER["argv"][$iArg + 3]), floatval($_SERVER["argv"][$iArg + 4]), 0.0);
            OGR_G_AddPoint($hSpatialFilter, floatval($_SERVER["argv"][$iArg + 3]), floatval($_SERVER["argv"][$iArg + 2]), 0.0);
            OGR_G_AddPoint($hSpatialFilter, floatval($_SERVER["argv"][$iArg + 1]), floatval($_SERVER["argv"][$iArg + 2]), 0.0);
            printf("Xmin = %s Ymin = %s Xmax = %s Ymax = %s\n", $_SERVER["argv"][$iArg + 1], $_SERVER["argv"][$iArg + 2], $_SERVER["argv"][$iArg + 3], $_SERVER["argv"][$iArg + 4]);
            $iArg += 4;
        } else {
            if ($_SERVER["argv"][$iArg] == "-sql" && $_SERVER["argv"][$iArg + 1] != NULL) {
                $strSQLStatement = $_SERVER["argv"][++$iArg];
                printf("SQLStatement = %s\n", $strSQLStatement);
            } else {
                if ($strDestDataSource == NULL) {
                    $strDestDataSource = $_SERVER["argv"][$iArg];
                    printf("DestDataSource = %s\n", $strDestDataSource);
                } else {
                    if ($strDataSource == NULL) {
                        $strDataSource = $_SERVER["argv"][$iArg];
                        printf("DataSource = %s\n", $strDataSource);
                    } else {
                        if ($_SERVER["argv"][$iArg][0] == '-') {
                            Usage();
                        }
                    }
                }
            }
        }
    }
    if ($strDataSource == NULL) {
        Usage();
    }
    /* -------------------------------------------------------------------- */
    /*      Open data source.                                               */
    /* -------------------------------------------------------------------- */
    $hSFDriver = NULL;
    $hDS = OGROpen($strDataSource, FALSE, $hSFDriver);
    /* -------------------------------------------------------------------- */
    /*      Report failure                                                  */
    /* -------------------------------------------------------------------- */
    if ($hDS == NULL) {
        printf("FAILURE:\nUnable to open datasource `%s' with the following drivers:\n", $strDataSource);
        for ($iDriver = 0; $iDriver < OGRGetDriverCount(); $iDriver++) {
            printf("  -> %s\n", OGR_DR_GetName(OGRGetDriver($iDriver)));
        }
        return OGRERR_FAILURE;
    }
    /* -------------------------------------------------------------------- */
    /*      Find the output driver.                                         */
    /* -------------------------------------------------------------------- */
    for ($iDriver = 0; $iDriver < OGRGetDriverCount() && $hSFDriver == NULL; $iDriver++) {
        if (!strcasecmp(OGR_DR_GetName(OGRGetDriver($iDriver)), $strFormat)) {
            $hSFDriver = OGRGetDriver($iDriver);
        }
    }
    if ($hSFDriver == NULL) {
        printf("Unable to find driver `%s'.\n", $strFormat);
        printf("The following drivers are available:\n");
        for ($iDriver = 0; $iDriver < OGRGetDriverCount(); $iDriver++) {
            printf("  -> %s\n", OGR_DR_GetName(OGRGetDriver($iDriver)));
        }
        return OGRERR_FAILURE;
    }
    if (!OGR_Dr_TestCapability($hSFDriver, ODrCCreateDataSource)) {
        printf("%s driver does not support data source creation.\n", $strFormat);
        return OGRERR_FAILURE;
    }
    /* -------------------------------------------------------------------- */
    /*      Create the output data source.                                  */
    /* -------------------------------------------------------------------- */
    /*Uncomment and add options here. */
    /* $aoptions[0] = 'option1';
        $aoptions[1] = 'option2';
        $hODS = OGR_Dr_CreateDataSource( $hSFDriver, $strDestDataSource, $aoptions );
    */
    /* Or use no option.*/
    $hODS = OGR_Dr_CreateDataSource($hSFDriver, $strDestDataSource, NULL);
    if ($hODS == NULL) {
        return OGRERR_FAILURE;
    }
    /* -------------------------------------------------------------------- */
    /*      Fetch source layer using SQL statement.                         */
    /* -------------------------------------------------------------------- */
    $hLayer = OGR_DS_ExecuteSQL($hDS, $strSQLStatement, $hSpatialFilter, NULL);
    /*Copy datasource file to a new data source file*/
    if ($hLayer != NULL) {
        if (!TranslateLayer($hDS, $hLayer, $hODS)) {
            return OGRERR_FAILURE;
        }
        OGR_DS_ReleaseResultSet($hDS, $hLayer);
    }
    /* -------------------------------------------------------------------- */
    /*      Close down.                                                     */
    /* -------------------------------------------------------------------- */
    OGR_DS_Destroy($hDS);
    OGR_DS_Destroy($hODS);
    return OGRERR_NONE;
}
Exemplo n.º 5
0
 /**
  * Return layer definition string
  * reads either *.msl file with same base name as data file
  *   or default polygon/line/point.lyr file from plugin dir
  * @return string $layerString
  */
 protected function getLayerDefinition($connParams, $layerSpatialType)
 {
     $ogrDBConn = false;
     if ($connParams['type'] == "generic") {
         $ogrConnectionStr = $this->data_path_prefix . $connParams['layer'];
         //error_log($ogrConnectionStr);
         // $layerDefFile = dirname(__FILE__) . "/" . $connParams['layer'] . ".msl";   ## swap comment if layer definition file in plugin dir
         $layerDefFile = $ogrConnectionStr . ".msl";
     } else {
         $ogrConnectionStr = "PG: " . $connParams['connection'];
         $layerDefFile = dirname(__FILE__) . "/layerdefinition/" . $connParams['schema'] . "." . $connParams['layer'] . ".msl";
         //$layerDefFile = dirname(__FILE__) . "/layerdefinition/" . $connParams['layer'] . ".msl";
     }
     if ($layerSpatialType == "vector") {
         if (!file_exists($ogrConnectionStr) && $connParams['type'] == "generic") {
             error_log($ogrConnectionStr . " does not exist.");
             return null;
         }
         // Register all drivers
         OGRRegisterAll();
         // Open data source
         $hSFDriver = NULL;
         $hDatasource = OGROpen($ogrConnectionStr, 0, $hSFDriver);
         if (!$hDatasource) {
             error_log("Unable to open %s\n" . $ogrConnectionStr);
             return 0;
         }
         if ($connParams['type'] == "generic") {
             $hLayer = OGR_DS_GetLayer($hDatasource, 0);
         } else {
             $hLayer = OGR_DS_GetLayerByName($hDatasource, $connParams['schema'] . "." . $connParams['layer']);
         }
         /* Dump info about this layer */
         $hLayerDefn = OGR_L_GetLayerDefn($hLayer);
         $hFeature = OGR_L_GetNextFeature($hLayer);
         if (OGR_F_GetGeometryRef($hFeature) != NULL) {
             $hGeom = OGR_F_GetGeometryRef($hFeature);
             //$geomType = OGR_G_GetGeometryType($hGeom);
             $geomNameOGR = OGR_G_GetGeometryName($hGeom);
         }
         /* Close data source */
         OGR_DS_Destroy($hDatasource);
         /*$geomList[1] = "point";
           $geomList[2] = "line";
           $geomList[3] = "polygon";
           $geomList[6] = "polygon";*/
         $geomList["POINT"] = "point";
         $geomList["MULTIPOINT"] = "point";
         $geomList["LINESTRING"] = "line";
         $geomList["MULTILINESTRING"] = "line";
         $geomList["POLYGON"] = "polygon";
         $geomList["MULTIPOLYGON"] = "polygon";
         //            $geomName = $geomList[$geomType];
         $geomName = $geomList[$geomNameOGR];
     } else {
         $geomName = "raster";
     }
     if (is_file($layerDefFile)) {
         //if (is_file($layerDefFile = $layerFilename . ".msl")) {
         $layerString = file_get_contents($layerDefFile);
     } else {
         $layerPath = dirname(__FILE__) . "/layerdefinition/{$geomName}.lyr";
         $layerString = file_get_contents($layerPath);
     }
     //error_log("layerDefFile: $layerDefFile");
     return $layerString;
 }
printf("\nLayers count = %s\n", $numLayers);
for ($i = 0; $i < $numLayers; $i++) {
    $hLayer = OGR_DS_GetLayer($hDatasource, $i);
    /* Dump info about this layer */
    $hLayerDefn = OGR_L_GetLayerDefn($hLayer);
    $numFields = OGR_FD_GetFieldCount($hLayerDefn);
    printf("\n===================\n");
    printf("Layer %d: '%s'\n\n", i, OGR_FD_GetName($hLayerDefn));
    for ($j = 0; $j < $numFields; $j++) {
        $hFieldDefn = OGR_FD_GetFieldDefn($hLayerDefn, $j);
        printf(" Field %d: %s (%s)\n", $j, OGR_Fld_GetNameRef($hFieldDefn), OGR_GetFieldTypeName(OGR_Fld_GetType($hFieldDefn)));
    }
    printf("\n");
    printf("Feature(s) count= %d", OGR_L_GetFeatureCount($hLayer, TRUE));
    printf("\n\n");
    /* And dump each feature individually */
    while (($hFeature = OGR_L_GetNextFeature($hLayer)) != NULL) {
        OGR_F_DumpReadable($hFeature);
        OGR_F_Destroy($hFeature);
    }
    printf("\n\n----- EOF -----\n");
    /* No need to free layer handle, it belongs to the datasource */
}
/* Close data source */
OGR_DS_Destroy($hDatasource);
?>

</PRE>
</BODY>
</HTML>
Exemplo n.º 7
0
 /**
  *
  * Função que transforma o arquivo num formato qualquer para formato conhecido
  *
  * @param string $inputFile
  * @param string $outputFile
  * @param string $outputFormat
  * @param array  $options
  */
 public function ogrToOgr($inputFile, $outputFile, $outputFormat = 'KML', $options = NULL)
 {
     // pega todos os formatos disponíveis no GDAL / OGR
     OGRRegisterAll();
     $astrLayers = NULL;
     $hSFDriver = NULL;
     $hDS = OGROpen($inputFile, FALSE, $hSFDriver);
     // erro caso não consiga abrir o arquivo com os drivers disponíveis.
     if ($hDS == NULL) {
         for ($iDriver = 0; $iDriver < OGRGetDriverCount(); $iDriver++) {
             $drivers[] = OGR_DR_GetName(OGRGetDriver($iDriver));
         }
         return sprintf(static::GEO_UNABLE_OPEN_FILE_DRIVERS, $inputFile, implode(',', $drivers));
     }
     // pega o driver de saída.
     for ($iDriver = 0; $iDriver < OGRGetDriverCount() && $hSFDriver == NULL; $iDriver++) {
         if (!strcasecmp(OGR_DR_GetName(OGRGetDriver($iDriver)), $outputFormat)) {
             $hSFDriver = OGRGetDriver($iDriver);
         }
     }
     // não encontrou driver para saída.
     if ($hSFDriver == NULL) {
         for ($iDriver = 0; $iDriver < OGRGetDriverCount(); $iDriver++) {
             $drivers[] = OGR_DR_GetName(OGRGetDriver($iDriver));
         }
         return sprintf(static::GEO_FIND_DRIVERS, $outputFormat, implode(',', $drivers));
     }
     // driver de saída não suporta gerar arquivo físico.
     if (!OGR_Dr_TestCapability($hSFDriver, ODrCCreateDataSource)) {
         return sprintf(static::GEO_DRIVER_DONT_SUPORT_IMPORT, $outputFormat);
     }
     // cria o arquivo de saída
     $hODS = OGR_Dr_CreateDataSource($hSFDriver, $outputFile, $options);
     if ($hODS == NULL) {
         return OGRERR_FAILURE;
     }
     // processa cada layer do arquivo
     for ($iLayer = 0; $iLayer < OGR_DS_GetLayerCount($hDS); $iLayer++) {
         $hLayer = OGR_DS_GetLayer($hDS, $iLayer);
         if ($hLayer == NULL) {
             return sprintf(STATIC::GEO_UNABLE_PROCESS_LAYER, $ilayer);
         }
         if (count($astrLayers) == 0 || in_array(OGR_FD_GetName(OGR_L_GetLayerDefn($hLayer)), $astrLayers) != FALSE) {
             if (!$this->translateLayer($hDS, $hLayer, $hODS)) {
                 return OGRERR_FAILURE;
             }
         }
     }
     OGR_DS_Destroy($hDS);
     OGR_DS_Destroy($hODS);
     return NULL;
 }
function OGR2OGR_main()
{
    $strFormat = "ESRI Shapefile";
    $strDataSource = NULL;
    $strDestDataSource = NULL;
    $astrLayers = NULL;
    /* -------------------------------------------------------------------- */
    /*      Register format(s).                                             */
    /* -------------------------------------------------------------------- */
    OGRRegisterAll();
    /* -------------------------------------------------------------------- */
    /*      Processing command line arguments.                              */
    /* -------------------------------------------------------------------- */
    $numArgs = count($_SERVER["argv"]);
    for ($iArg = 1; $iArg < $numArgs; $iArg++) {
        if (!strcasecmp($_SERVER["argv"][$iArg], "-f") && $iArg < $numArgs - 1) {
            $strFormat = $_SERVER["argv"][++$iArg];
            printf("Format = %s\n", $strFormat);
        } else {
            if ($_SERVER["argv"][$iArg][0] == '-') {
                Usage();
            } else {
                if ($strDestDataSource == NULL) {
                    $strDestDataSource = $_SERVER["argv"][$iArg];
                    printf("DestDataSource = %s\n", $strDestDataSource);
                } else {
                    if ($strDataSource == NULL) {
                        $strDataSource = $_SERVER["argv"][$iArg];
                        printf("DataSource = %s\n", $strDataSource);
                    } else {
                        $astrLayers[] = $_SERVER["argv"][$iArg];
                    }
                }
            }
        }
    }
    $i = 0;
    while ($astrLayers[$i]) {
        printf("Layers [%d] = %s\n", $i, $astrLayers[$i]);
        $i++;
    }
    if ($strDataSource == NULL) {
        Usage();
    }
    /* -------------------------------------------------------------------- */
    /*      Open data source.                                               */
    /* -------------------------------------------------------------------- */
    $hSFDriver = NULL;
    $hDS = OGROpen($strDataSource, FALSE, $hSFDriver);
    /* -------------------------------------------------------------------- */
    /*      Report failure                                                  */
    /* -------------------------------------------------------------------- */
    if ($hDS == NULL) {
        printf("FAILURE:\nUnable to open datasource `%s' with the following drivers:\n", $strDataSource);
        for ($iDriver = 0; $iDriver < OGRGetDriverCount(); $iDriver++) {
            printf("  -> %s\n", OGR_DR_GetName(OGRGetDriver($iDriver)));
        }
        return OGRERR_FAILURE;
    }
    /* -------------------------------------------------------------------- */
    /*      Find the output driver.                                         */
    /* -------------------------------------------------------------------- */
    for ($iDriver = 0; $iDriver < OGRGetDriverCount() && $hSFDriver == NULL; $iDriver++) {
        if (!strcasecmp(OGR_DR_GetName(OGRGetDriver($iDriver)), $strFormat)) {
            $hSFDriver = OGRGetDriver($iDriver);
        }
    }
    if ($hSFDriver == NULL) {
        printf("Unable to find driver `%s'.\n", $strFormat);
        printf("The following drivers are available:\n");
        for ($iDriver = 0; $iDriver < OGRGetDriverCount(); $iDriver++) {
            printf("  -> %s\n", OGR_DR_GetName(OGRGetDriver($iDriver)));
        }
        return OGRERR_FAILURE;
    }
    if (!OGR_Dr_TestCapability($hSFDriver, ODrCCreateDataSource)) {
        printf("%s driver does not support data source creation.\n", $strFormat);
        return OGRERR_FAILURE;
    }
    /* -------------------------------------------------------------------- */
    /*      Create the output data source.                                  */
    /* -------------------------------------------------------------------- */
    /*Uncomment and add options here. */
    /* $aoptions[0] = 'option1';
        $aoptions[1] = 'option2';
        $hODS = OGR_Dr_CreateDataSource( $hSFDriver, $strDestDataSource, $aoptions );
    */
    /* Or use no option.*/
    $hODS = OGR_Dr_CreateDataSource($hSFDriver, $strDestDataSource, NULL);
    if ($hODS == NULL) {
        return OGRERR_FAILURE;
    }
    /* -------------------------------------------------------------------- */
    /*      Process each data source layer.                                 */
    /* -------------------------------------------------------------------- */
    for ($iLayer = 0; $iLayer < OGR_DS_GetLayerCount($hDS); $iLayer++) {
        $hLayer = OGR_DS_GetLayer($hDS, $iLayer);
        if ($hLayer == NULL) {
            printf("FAILURE: Couldn't fetch advertised layer %d!\n", $iLayer);
            return OGRERR_FAILURE;
        }
        if (count($astrLayers) == 0 || in_array(OGR_FD_GetName(OGR_L_GetLayerDefn($hLayer)), $astrLayers) != FALSE) {
            if (!TranslateLayer($hDS, $hLayer, $hODS)) {
                return OGRERR_FAILURE;
            }
        }
    }
    /* -------------------------------------------------------------------- */
    /*      Close down.                                                     */
    /* -------------------------------------------------------------------- */
    OGR_DS_Destroy($hDS);
    OGR_DS_Destroy($hODS);
    return OGRERR_NONE;
}
function ogr2tab_copy_srs()
{
    /*Corresponding MapInfo File driver number.*/
    $iDriver = 5;
    $strFormat = "MapInfo File";
    /*Path to existing data source to modify to fit user needs.*/
    $strSrcDataSource = "./phpunit_tests/data/tab/mpasabe200/Commune.TAB";
    /*Path to new data source to modify to fit user needs.*/
    $strDestDataSource = "../ogrtests/tmp/output";
    /*New layer name to modify to fit user needs.*/
    $strDestLayerName = "MyNewLayer";
    /*Layer selected to fetch a feature from.  If the data source name in
      $strSrcDataSource is a "tab" file, the layer number, specified by 
      $iLayer, to copy from must be set to zero.  Otherwise the layer 
      number might be any number between 0 and the layer count.*/
    //    $iLayer = 1;
    $iLayer = 0;
    /* -------------------------------------------------------------------- */
    /*      Register format(s).                                             */
    /* -------------------------------------------------------------------- */
    OGRRegisterAll();
    /* -------------------------------------------------------------------- */
    /*      Open the existing data source.                                  */
    /* -------------------------------------------------------------------- */
    $hSFDriver = NULL;
    $hSrcDS = OGROpen($strSrcDataSource, FALSE, $hSFDriver);
    /* -------------------------------------------------------------------- */
    /*      Report failure                                                  */
    /* -------------------------------------------------------------------- */
    if ($hSrcDS == NULL) {
        printf("FAILURE:\nUnable to open datasource `%s'\n", $strSrcDataSource);
        return OGRERR_FAILURE;
    }
    /* -------------------------------------------------------------------- */
    /*      Find the output driver handle.                                  */
    /* -------------------------------------------------------------------- */
    if ($hSFDriver == NULL) {
        $hSFDriver = OGRGetDriver($iDriver);
    }
    if ($hSFDriver == NULL) {
        printf("Unable to find driver `%s'.\n", $strFormat);
        return OGRERR_FAILURE;
    }
    /* -------------------------------------------------------------------- */
    /*      Create the destination data source.                             */
    /* -------------------------------------------------------------------- */
    $hDestDS = OGR_Dr_CreateDataSource($hSFDriver, $strDestDataSource, NULL);
    if ($hDestDS == NULL) {
        return OGRERR_FAILURE;
    }
    /* -------------------------------------------------------------------- */
    /*      Select an existing layer from the existing data source to get   */
    /*      the projection information from.  To modify accordingly to user */
    /*      needs.                                                          */
    /* -------------------------------------------------------------------- */
    if (OGR_DS_GetLayerCount($hSrcDS) > 0) {
        $hSrcLayer = OGR_DS_GetLayer($hSrcDS, $iLayer);
        if ($hSrcLayer == NULL) {
            printf("FAILURE: Couldn't fetch advertised layer %d!\n", $iLayer);
            return OGRERR_FAILURE;
        }
        $hSrcSRS = OGR_L_GetSpatialRef($hSrcLayer);
    }
    /* -------------------------------------------------------------------- */
    /*      Create a new layer based on the existing data source            */
    /*      information.                                                    */
    /* -------------------------------------------------------------------- */
    $hSrcFDefn = OGR_L_GetLayerDefn($hSrcLayer);
    $eType = OGR_FD_GetGeomType($hSrcFDefn);
    $hDestLayer = OGR_DS_CreateLayer($hDestDS, $strDestLayerName, $hSrcSRS, $eType, NULL);
    if ($hDestLayer == NULL) {
        return FALSE;
    }
    /* -------------------------------------------------------------------- */
    /*      Create the field definitions for the new layer based on the     */
    /*      existing field definitions of the source layer.                 */
    /* -------------------------------------------------------------------- */
    for ($iField = 0; $iField < OGR_FD_GetFieldCount($hSrcFDefn); $iField++) {
        if (OGR_L_CreateField($hDestLayer, OGR_FD_GetFieldDefn($hSrcFDefn, $iField), 0) != OGRERR_NONE) {
            return OGRERR_FAILURE;
        }
    }
    /* -------------------------------------------------------------------- */
    /*      Get only one feature on the existing layer and copy it to the   */
    /*      new layer.                                                      */
    /* -------------------------------------------------------------------- */
    OGR_L_ResetReading($hSrcLayer);
    $hSrcFeature = OGR_L_GetNextFeature($hSrcLayer);
    $hDestFeature = OGR_F_Create(OGR_L_GetLayerDefn($hDestLayer));
    if (OGR_F_SetFrom($hDestFeature, $hSrcFeature, FALSE) != OGRERR_NONE) {
        OGR_F_Destroy($hDestFeature);
        printf("Unable to copy feature %d from layer %s.\n", OGR_F_GetFID($hSrcFeature), OGR_FD_GetName($hSrcFDefn));
        return OGRERR_FAILURE;
    }
    OGR_F_Destroy($hSrcFeature);
    if (OGR_L_CreateFeature($hDestLayer, $hDestFeature) != OGRERR_NONE) {
        OGR_F_Destroy($hDestFeature);
        return OGRERR_FAILURE;
    }
    OGR_F_Destroy($hDestFeature);
    /* -------------------------------------------------------------------- */
    /*      Close down.                                                     */
    /* -------------------------------------------------------------------- */
    OGR_DS_Destroy($hSrcDS);
    OGR_DS_Destroy($hDestDS);
    return OGRERR_NONE;
}
function OGR_SpatialFilter_main()
{
    /*Assigning initial value.*/
    $strFormat = "ESRI Shapefile";
    $strDataSource = NULL;
    $strDestDataSource = NULL;
    $strWhere = NULL;
    $hSpatialFilter = NULL;
    /* -------------------------------------------------------------------- */
    /*      Register format(s).                                             */
    /* -------------------------------------------------------------------- */
    OGRRegisterAll();
    /* -------------------------------------------------------------------- */
    /*      Processing command line arguments.                              */
    /* -------------------------------------------------------------------- */
    $numArgs = count($_SERVER["argv"]);
    for ($iArg = 1; $iArg < $numArgs; $iArg++) {
        if (!strcasecmp($_SERVER["argv"][$iArg], "-f") && $iArg < $numArgs - 1) {
            $strFormat = $_SERVER["argv"][++$iArg];
            printf("Format = %s\n", $strFormat);
        } else {
            if ($_SERVER["argv"][$iArg] == "-spat" && $_SERVER["argv"][$iArg + 1] != NULL && $_SERVER["argv"][$iArg + 2] != NULL && $_SERVER["argv"][$iArg + 3] != NULL && $_SERVER["argv"][$iArg + 4] != NULL) {
                $hSpatialFilter = OGR_G_CreateGeometry(wkbLinearRing);
                OGR_G_AddPoint($hSpatialFilter, floatval($_SERVER["argv"][$iArg + 1]), floatval($_SERVER["argv"][$iArg + 2]), 0.0);
                OGR_G_AddPoint($hSpatialFilter, floatval($_SERVER["argv"][$iArg + 1]), floatval($_SERVER["argv"][$iArg + 4]), 0.0);
                OGR_G_AddPoint($hSpatialFilter, floatval($_SERVER["argv"][$iArg + 3]), floatval($_SERVER["argv"][$iArg + 4]), 0.0);
                OGR_G_AddPoint($hSpatialFilter, floatval($_SERVER["argv"][$iArg + 3]), floatval($_SERVER["argv"][$iArg + 2]), 0.0);
                OGR_G_AddPoint($hSpatialFilter, floatval($_SERVER["argv"][$iArg + 1]), floatval($_SERVER["argv"][$iArg + 2]), 0.0);
                printf("Xmin = %s Ymin = %s Xmax = %s Ymax = %s\n", $_SERVER["argv"][$iArg + 1], $_SERVER["argv"][$iArg + 2], $_SERVER["argv"][$iArg + 3], $_SERVER["argv"][$iArg + 4]);
                $iArg += 4;
            } else {
                if ($_SERVER["argv"][$iArg] == "-where" && $_SERVER["argv"][$iArg + 1] != NULL) {
                    $strWhere = $_SERVER["argv"][++$iArg];
                    printf("where = %s\n", $strWhere);
                } else {
                    if ($_SERVER["argv"][$iArg][0] == '-') {
                        Usage();
                    } else {
                        if ($strDestDataSource == NULL) {
                            $strDestDataSource = $_SERVER["argv"][$iArg];
                            printf("DestDataSource = %s\n", $strDestDataSource);
                        } else {
                            if ($strDataSource == NULL) {
                                $strDataSource = $_SERVER["argv"][$iArg];
                                printf("DataSource = %s\n", $strDataSource);
                            }
                        }
                    }
                }
            }
        }
    }
    if ($strDataSource == NULL) {
        Usage();
    }
    /* -------------------------------------------------------------------- */
    /*      Open data source.                                               */
    /* -------------------------------------------------------------------- */
    $hSFDriver = NULL;
    $hDS = OGROpen($strDataSource, FALSE, $hSFDriver);
    /* -------------------------------------------------------------------- */
    /*      Report failure                                                  */
    /* -------------------------------------------------------------------- */
    if ($hDS == NULL) {
        printf("FAILURE:\nUnable to open datasource `%s' with the following drivers:\n", $strDataSource);
        for ($iDriver = 0; $iDriver < OGRGetDriverCount(); $iDriver++) {
            printf("  -> %s\n", OGR_DR_GetName(OGRGetDriver($iDriver)));
        }
        return OGRERR_FAILURE;
    }
    /* -------------------------------------------------------------------- */
    /*      Find the output driver.                                         */
    /* -------------------------------------------------------------------- */
    for ($iDriver = 0; $iDriver < OGRGetDriverCount() && $hSFDriver == NULL; $iDriver++) {
        if (!strcasecmp(OGR_DR_GetName(OGRGetDriver($iDriver)), $strFormat)) {
            $hSFDriver = OGRGetDriver($iDriver);
        }
    }
    if ($hSFDriver == NULL) {
        printf("Unable to find driver `%s'.\n", $strFormat);
        printf("The following drivers are available:\n");
        for ($iDriver = 0; $iDriver < OGRGetDriverCount(); $iDriver++) {
            printf("  -> %s\n", OGR_DR_GetName(OGRGetDriver($iDriver)));
        }
        return OGRERR_FAILURE;
    }
    if (!OGR_Dr_TestCapability($hSFDriver, ODrCCreateDataSource)) {
        printf("%s driver does not support data source creation.\n", $strFormat);
        return OGRERR_FAILURE;
    }
    /* -------------------------------------------------------------------- */
    /*      Create the output data source.                                  */
    /* -------------------------------------------------------------------- */
    /*Uncomment and add options here. */
    /* $aoptions[0] = 'option1';
        $aoptions[1] = 'option2';
        $hODS = OGR_Dr_CreateDataSource( $hSFDriver, $strDestDataSource, $aoptions );
    */
    /* Or use no option.*/
    $hODS = OGR_Dr_CreateDataSource($hSFDriver, $strDestDataSource, NULL);
    if ($hODS == NULL) {
        return OGRERR_FAILURE;
    }
    /* -------------------------------------------------------------------- */
    /*      Process each data source layer.                                 */
    /* -------------------------------------------------------------------- */
    for ($iLayer = 0; $iLayer < OGR_DS_GetLayerCount($hDS); $iLayer++) {
        $hLayer = OGR_DS_GetLayer($hDS, $iLayer);
        if ($hLayer == NULL) {
            printf("FAILURE: Couldn't fetch advertised layer %d!\n", $iLayer);
            return OGRERR_FAILURE;
        }
        if (count($astrLayers) == 0 || in_array(OGR_FD_GetName(OGR_L_GetLayerDefn($hLayer)), $astrLayers) != FALSE) {
            /*Assign spatial filter*/
            if ($hSpatialFilter != NULL) {
                OGR_L_SetSpatialFilter($hLayer, $hSpatialFilter);
            }
            /*Assign attribute filter*/
            if ($strWhere != NULL) {
                $eErr = OGR_L_SetAttributeFilter($hLayer, $strWhere);
            }
            if ($eErr != OGRERR_NONE) {
                printf("Erreur when setting attribute filter", $eErr);
                return $eErr;
            }
            /*Copy datasource file to a new data source file*/
            if (!TranslateLayer($hDS, $hLayer, $hODS)) {
                return OGRERR_FAILURE;
            }
        }
    }
    /* -------------------------------------------------------------------- */
    /*      Close down.                                                     */
    /* -------------------------------------------------------------------- */
    OGR_DS_Destroy($hDS);
    OGR_DS_Destroy($hODS);
    return OGRERR_NONE;
}