/**
* 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;
}
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;
}
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>
function TranslateLayer($hSrcDS, $hSrcLayer, $hDstDS)
{
/* -------------------------------------------------------------------- */
/* 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;
}
/* -------------------------------------------------------------------- */
/* Add fields. */
/* -------------------------------------------------------------------- */
for ($iField = 0; $iField < OGR_FD_GetFieldCount($hFDefn); $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));
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 add_layer_to_db($dst_layer_name)
{
OGRRegisterAll();
$success = false;
// create layer record so that all
// these geometries can be linked to
// one layer
$layer_id = $this->create_layer_record($this->submission_id, $dst_layer_name);
if ($layer_id != -1) {
// loop through source layer, copy
// each feature to the destination
// layer
OGR_L_ResetReading($this->ogr_src_layer);
$dst_feature_defn = OGR_L_GetLayerDefn($this->ogr_dst_layer);
while (($src_feature = OGR_L_GetNextFeature($this->ogr_src_layer)) != NULL) {
// create a blank feature
// based on the destination
// feature definition
$dst_feature = OGR_F_Create($dst_feature_defn);
// now copy the feature object
// from the source to the destination.
// the last value, bForgiving must be set to
// true because our source and destination
// schemas dont match. if bForgiving is
// false, OGR_F_SetFrom quits when it
// finds a feature that doesnt match both
// schemas.
if (OGR_F_SetFrom($dst_feature, $src_feature, TRUE) != OGRERR_NONE) {
echo "could not set destination feature from source feature";
return false;
}
// set the layer_id (fk) of the feature
// to the layer id created earlier in
// this method
$layerid_f_index = OGR_F_GetFieldIndex($dst_feature, "layer_id");
OGR_F_SetFieldInteger($dst_feature, $layerid_f_index, $layer_id);
// ------------------------------------------
// begin locked section
// ------------------------------------------
// since the feature creation does not automatically
// query the ID of the feature from the db, we
// need to query it ourselves. to prevent any
// interleaving of threads that are executing this
// method, we add a semaphore lock before the
// feature is created and release the lock once
// the ID of the feature has been queried.
// see php docs for sem_get(), sem_acquire()
// and sem_release
// note the second arg to sem_get must be "1"
// so that only one process at a time can
// acquire the semaphore
$sem_num = sem_get(5001, 1);
// block until semaphore is available
sem_acquire($sem_num);
// destination feature successfully set.
// now "create" the dst feature within the
// destination layer.
if (OGR_L_CreateFeature($this->ogr_dst_layer, $dst_feature) != OGRERR_NONE) {
echo "could not create feature in destination layer ";
return false;
}
// now that the feature has been
// created within the db, we need to
// get its ID so that we can use it
// as a FK when inserting the attributes
// of the feature.
$pk_col_name = "";
/* unused. see comments in get_max_id() */
$feature_id = $this->get_max_id($this->dst_layer_name, $pk_col_name);
// release the semaphore
sem_release($sem_num);
// ------------------------------------------
// end locked section
// ------------------------------------------
if ($feature_id == -1) {
echo "could not obtain new ID for feature ";
return false;
}
// if the value of the ID was successfully
// obtained, attempt to create
// records for the attributes in the attribute
// table
if (!$this->add_attributes_to_db($src_feature, $feature_id, $this->pk_col_name)) {
echo "could not insert attributes for feature ID " . $feature_id;
return false;
}
OGR_F_Destroy($src_feature);
OGR_F_Destroy($dst_feature);
}
}
return true;
}
function TranslateLayer($hSrcDS, $hSrcLayer, $hDstDS)
{
/* -------------------------------------------------------------------- */
/* 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);
$hDstLayer = OGR_DS_CreateLayer($hDstDS, OGR_FD_GetName($hFDefn), OGR_L_GetSpatialRef($hSrcLayer), OGR_FD_GetGeomType($hFDefn), NULL);
if ($hDstLayer == NULL) {
return FALSE;
}
/* -------------------------------------------------------------------- */
/* Add fields. */
/* -------------------------------------------------------------------- */
for ($iField = 0; $iField < OGR_FD_GetFieldCount($hFDefn); $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));
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;
}
/**
*
* processas as camadas do arquivo importado
*
* @param string $hSrcDS
* @param array $hSrcLayer
* @param string $hDstDS
*/
public function translateLayer($hSrcDS, $hSrcLayer, $hDstDS)
{
// cria layer
if (!OGR_DS_TestCapability($hDstDS, ODsCCreateLayer)) {
printf(STATIC::GEO_UNABLE_CREATE_LAYER, OGR_DS_GetName($hDstDS));
return OGRERR_FAILURE;
}
$hFDefn = OGR_L_GetLayerDefn($hSrcLayer);
$hDstLayer = OGR_DS_CreateLayer($hDstDS, OGR_FD_GetName($hFDefn), OGR_L_GetSpatialRef($hSrcLayer), OGR_FD_GetGeomType($hFDefn), NULL);
if ($hDstLayer == NULL) {
return FALSE;
}
// adiciona campos
for ($iField = 0; $iField < OGR_FD_GetFieldCount($hFDefn); $iField++) {
if (OGR_L_CreateField($hDstLayer, OGR_FD_GetFieldDefn($hFDefn, $iField), 0) != OGRERR_NONE) {
return FALSE;
}
}
// processa os features do layer
OGR_L_ResetReading($hSrcLayer);
while (($hFeature = OGR_L_GetNextFeature($hSrcLayer)) != NULL) {
$hDstFeature = OGR_F_Create(OGR_L_GetLayerDefn($hDstLayer));
if (OGR_F_SetFrom($hDstFeature, $hFeature, FALSE) != OGRERR_NONE) {
OGR_F_Destroy($hFeature);
printf(static::GEO_UNABLE_TRANSLATE_FEATURE_LAYER, 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 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;
}
$dst_layer_name = pg_fetch_result($result, 0, 0);
$dst_attr_table_name = pg_fetch_result($result, 0, 1);
$dbconn->disconnect();
}
/* end find geometry type */
/*---------------------------------------------------------------------------------------*/
/* get the handle for the destination layer */
$dst_layer = OGR_DS_GetLayerByName($dst_ds, $dst_layer_name);
if ($dst_layer == NULL) {
echo "could not create a handle for " . $dst_layer_name;
exit;
}
echo "<br> dst layer : " . $dst_layer_name . "<br>";
OGR_L_ResetReading($src_layer);
//for( $i = 0; $i < OGR_FD_GetFieldCount($feature_defn); $i++ )
while (($feature = OGR_L_GetNextFeature($src_layer)) != NULL) {
// create a blank feature in the
// destination layer.
$dst_feature_defn = OGR_L_GetLayerDefn($dst_layer);
$dst_feature = OGR_F_Create($dst_feature_defn);
// now copy the feature from the source
// layer to the dest. layer
// the last value, bForgiving must be set to
// true because our source and destination
// schemas dont match
if (OGR_F_SetFrom($dst_feature, $feature, TRUE) != OGRERR_NONE) {
echo "could not set destination feature from source feature";
exit;
}
// otherwise the feature was set
// from the source feature.