FileIO::SHPInterface Class Reference

Detailed Description

Manages the import of ESRI shape files into GeoLib.

Definition at line 40 of file SHPInterface.h.

#include <SHPInterface.h>

Collaboration diagram for FileIO::SHPInterface:

Public Types
enum class	OGSType {   UNDEFINED = 0 , POINT = 1 , STATION = 2 , POLYLINE = 3 ,   POLYGON = 4 }
	Connection between ESRI type system for shape files and OGS GeoLib. More...

Public Member Functions
	SHPInterface (GeoLib::GEOObjects &geoObjects)
	Constructor.
void	readSHPFile (const std::string &filename, OGSType choice, const std::string &listName, std::string const &gmsh_path)
	Reads data from the shape file.

Static Public Member Functions
static bool	readSHPInfo (const std::string &filename, int &shapeType, int &numberOfEntities)
	Reads the header of the shape file.
static bool	write2dMeshToSHP (const std::string &file_name, const MeshLib::Mesh &mesh)

Private Member Functions
void	readPoints (const SHPHandle &hSHP, int numberOfElements, std::string listName)
	Reads points into a vector of Point objects.
void	readStations (const SHPHandle &hSHP, int numberOfElements, std::string listName)
	Reads points into a vector of Point objects and marks them as Station.
void	readPolylines (const SHPHandle &hSHP, int numberOfElements, std::string listName)
	Reads lines into a vector of Polyline objects.
void	readPolygons (const SHPHandle &hSHP, int numberOfElements, const std::string &listName, std::string const &gmsh_path)
	Reads lines into a vector of Polyline and Surface objects.

Static Private Member Functions
static SHPObject *	createShapeObject (MeshLib::Element const &e, std::size_t const shp_record)
	Creates a shape object polygon out of a 2D mesh element.

Private Attributes
GeoLib::GEOObjects &	_geoObjects

Member Enumeration Documentation

OGSType

enum class FileIO::SHPInterface::OGSType

strong

Connection between ESRI type system for shape files and OGS GeoLib.

Enumerator
UNDEFINED
POINT
STATION
POLYLINE
POLYGON

Definition at line 44 of file SHPInterface.h.

    {
        UNDEFINED   = 0,
        POINT       = 1,
        STATION     = 2,
        POLYLINE    = 3,
        POLYGON     = 4
    };

Constructor & Destructor Documentation

SHPInterface()

FileIO::SHPInterface::SHPInterface ( GeoLib::GEOObjects & geoObjects )

inlineexplicit

Constructor.

Definition at line 54 of file SHPInterface.h.

        : _geoObjects(geoObjects)
    {
    }

References _geoObjects.

Member Function Documentation

createShapeObject()

SHPObject * FileIO::SHPInterface::createShapeObject ( MeshLib::Element const & e, std::size_t const shp_record )

staticprivate

Creates a shape object polygon out of a 2D mesh element.

Definition at line 327 of file SHPInterface.cpp.

{
    unsigned const nNodes(e.getNumberOfBaseNodes());
    double* padfX = new double[nNodes + 1];
    double* padfY = new double[nNodes + 1];
    double* padfZ = new double[nNodes + 1];
    for (unsigned j = 0; j < nNodes; ++j)
    {
        padfX[j] = (*e.getNode(j))[0];
        padfY[j] = (*e.getNode(j))[1];
        padfZ[j] = (*e.getNode(j))[2];
    }
    // Last node == first node to close the polygon
    padfX[nNodes] = (*e.getNode(0))[0];
    padfY[nNodes] = (*e.getNode(0))[1];
    padfZ[nNodes] = (*e.getNode(0))[2];
 
    // the generated shape object now handles the memory for padfX/Y/Z
    return SHPCreateObject(SHPT_POLYGON, shp_record, 0, nullptr, nullptr,
                           nNodes + 1, padfX, padfY, padfZ, nullptr);
}

References MeshLib::Element::getNode(), and MeshLib::Element::getNumberOfBaseNodes().

Referenced by write2dMeshToSHP().

readPoints()

void FileIO::SHPInterface::readPoints ( const SHPHandle & hSHP, int numberOfElements, std::string listName )

private

Reads points into a vector of Point objects.

Definition at line 85 of file SHPInterface.cpp.

{
    if (numberOfElements > 0)
    {
        std::vector<GeoLib::Point*> points;
        SHPObject* hSHPObject;
 
        for (int i = 0; i < numberOfElements; i++)
        {
            hSHPObject = SHPReadObject(hSHP, i);
 
            auto* pnt =
                new GeoLib::Point(*(hSHPObject->padfX), *(hSHPObject->padfY),
                                  *(hSHPObject->padfZ));
            points.push_back(pnt);
        }
 
        _geoObjects.addPointVec(std::move(points), listName,
                                GeoLib::PointVec::NameIdMap{});
        SHPDestroyObject(hSHPObject);  // de-allocate SHPObject
    }
}

References _geoObjects.

Referenced by readSHPFile().

readPolygons()

void FileIO::SHPInterface::readPolygons ( const SHPHandle & hSHP, int numberOfElements, const std::string & listName, std::string const & gmsh_path )

private

Reads lines into a vector of Polyline and Surface objects.

Definition at line 216 of file SHPInterface.cpp.

{
    readPolylines(hSHP, numberOfElements, listName);
 
    auto const polylines = _geoObjects.getPolylineVec(listName);
 
    for (auto const* polyline : *polylines)
    {
        INFO("Creating a surface by triangulation of the polyline ...");
        if (FileIO::createSurface(*polyline, _geoObjects, listName, gmsh_path))
        {
            INFO("\t done");
        }
        else
        {
            WARN(
                "\t Creating a surface by triangulation of the polyline "
                "failed.");
        }
    }
}

References _geoObjects, FileIO::createSurface(), INFO(), readPolylines(), and WARN().

Referenced by readSHPFile().

readPolylines()

void FileIO::SHPInterface::readPolylines ( const SHPHandle & hSHP, int numberOfElements, std::string listName )

private

Reads lines into a vector of Polyline objects.

Definition at line 134 of file SHPInterface.cpp.

{
    if (numberOfElements <= 0)
    {
        return;
    }
    std::vector<GeoLib::Point*> pnts;
    std::vector<GeoLib::Polyline*> lines;
 
    std::size_t pnt_id(0);
    // for each polyline
    for (int i = 0; i < numberOfElements; ++i)
    {
        SHPObject* hSHPObject = SHPReadObject(hSHP, i);
        int const noOfPoints = hSHPObject->nVertices;
        int const noOfParts = hSHPObject->nParts;
 
        for (int p = 0; p < noOfParts; ++p)
        {
            int const firstPnt = *(hSHPObject->panPartStart + p);
            int const lastPnt = (p < (noOfParts - 1))
                                    ? *(hSHPObject->panPartStart + p + 1)
                                    : noOfPoints;
 
            // for each point in that polyline
            for (int j = firstPnt; j < lastPnt; ++j)
            {
                pnts.push_back(new GeoLib::Point(
                    *(hSHPObject->padfX + j), *(hSHPObject->padfY + j),
                    *(hSHPObject->padfZ + j), pnt_id));
                pnt_id++;
            }
        }
        SHPDestroyObject(hSHPObject);  // de-allocate SHPObject
    }
 
    _geoObjects.addPointVec(std::move(pnts), listName,
                            GeoLib::PointVec::NameIdMap{});
    GeoLib::PointVec const& points(*(_geoObjects.getPointVecObj(listName)));
    std::vector<std::size_t> const& pnt_id_map(points.getIDMap());
 
    pnt_id = 0;
    for (int i = 0; i < numberOfElements; ++i)
    {
        SHPObject* hSHPObject = SHPReadObject(hSHP, i);
        int const noOfPoints = hSHPObject->nVertices;
        int const noOfParts = hSHPObject->nParts;
 
        for (int p = 0; p < noOfParts; ++p)
        {
            // output for the first part of multipart polyline
            if (noOfParts > 1 && p == 0)
            {
                INFO(
                    "Polygon {:d} consists of {:d} parts (PolylineIDs "
                    "{:d}-{:d}).",
                    i, noOfParts, lines.size(), lines.size() + noOfParts - 1);
            }
 
            int const firstPnt = *(hSHPObject->panPartStart + p);
            int const lastPnt = (p < (noOfParts - 1))
                                    ? *(hSHPObject->panPartStart + p + 1)
                                    : noOfPoints;
 
            auto* line = new GeoLib::Polyline(points.getVector());
 
            // create polyline
            for (int j = firstPnt; j < lastPnt; ++j)
            {
                line->addPoint(pnt_id_map[pnt_id]);
                pnt_id++;
            }
            // add polyline to polyline vector
            lines.push_back(line);
        }
        SHPDestroyObject(hSHPObject);  // de-allocate SHPObject
    }
    _geoObjects.addPolylineVec(std::move(lines), listName,
                               GeoLib::PolylineVec::NameIdMap{});
}

References _geoObjects, GeoLib::PointVec::getIDMap(), GeoLib::TemplateVec< T >::getVector(), and INFO().

Referenced by readPolygons(), and readSHPFile().

readSHPFile()

void FileIO::SHPInterface::readSHPFile	(	const std::string &	filename,
		OGSType	choice,
		const std::string &	listName,
		std::string const &	gmsh_path )

Reads data from the shape file.

Definition at line 52 of file SHPInterface.cpp.

{
    int shapeType;
    int numberOfElements;
    double padfMinBound[4];
    double padfMaxBound[4];
 
    SHPHandle hSHP = SHPOpen(filename.c_str(), "rb");
    SHPGetInfo(hSHP, &numberOfElements, &shapeType, padfMinBound, padfMaxBound);
 
    if (((shapeType - 1) % 10 == 0) && (choice == SHPInterface::OGSType::POINT))
    {
        readPoints(hSHP, numberOfElements, listName);
    }
    if (((shapeType - 1) % 10 == 0) &&
        (choice == SHPInterface::OGSType::STATION))
    {
        readStations(hSHP, numberOfElements, listName);
    }
    if (((shapeType - 3) % 10 == 0 || (shapeType - 5) % 10 == 0) &&
        (choice == SHPInterface::OGSType::POLYLINE))
    {
        readPolylines(hSHP, numberOfElements, listName);
    }
    if (((shapeType - 3) % 10 == 0 || (shapeType - 5) % 10 == 0) &&
        (choice == SHPInterface::OGSType::POLYGON))
    {
        readPolygons(hSHP, numberOfElements, listName, gmsh_path);
    }
}

References POINT, POLYGON, POLYLINE, readPoints(), readPolygons(), readPolylines(), readStations(), and STATION.

readSHPInfo()

bool FileIO::SHPInterface::readSHPInfo ( const std::string & filename, int & shapeType, int & numberOfEntities )

static

Reads the header of the shape file.

Definition at line 31 of file SHPInterface.cpp.

{
    SHPHandle hSHP = SHPOpen(filename.c_str(), "rb");
    if (!hSHP)
    {
        return false;
    }
 
    double padfMinBound[4];
    double padfMaxBound[4];
 
    // The SHPGetInfo() function retrieves various information about shapefile
    // as a whole. The bounds are read from the file header, and may be
    // inaccurate if the file was improperly generated.
    SHPGetInfo(hSHP, &numberOfEntities, &shapeType, padfMinBound, padfMaxBound);
 
    SHPClose(hSHP);
    return true;
}

readStations()

void FileIO::SHPInterface::readStations ( const SHPHandle & hSHP, int numberOfElements, std::string listName )

private

Reads points into a vector of Point objects and marks them as Station.

Definition at line 109 of file SHPInterface.cpp.

{
    if (numberOfElements > 0)
    {
        std::vector<GeoLib::Point*> stations;
        stations.reserve(numberOfElements);
        SHPObject* hSHPObject;
 
        for (int i = 0; i < numberOfElements; i++)
        {
            hSHPObject = SHPReadObject(hSHP, i);
            GeoLib::Station* stn =
                GeoLib::Station::createStation(std::to_string(i),
                                               *(hSHPObject->padfX),
                                               *(hSHPObject->padfY),
                                               *(hSHPObject->padfZ));
            stations.push_back(stn);
        }
 
        _geoObjects.addStationVec(std::move(stations), listName);
        SHPDestroyObject(hSHPObject);  // de-allocate SHPObject
    }
}

References _geoObjects, and GeoLib::Station::createStation().

Referenced by readSHPFile().

write2dMeshToSHP()

bool FileIO::SHPInterface::write2dMeshToSHP ( const std::string & file_name, const MeshLib::Mesh & mesh )

static

Writes a 2D mesh into a shapefile using one polygon for every element (based on request by AS, open for discussion)

Definition at line 240 of file SHPInterface.cpp.

{
    if (mesh.getDimension() != 2)
    {
        ERR("SHPInterface::write2dMeshToSHP(): Mesh to Shape conversion is "
            "only working for 2D Meshes.");
        return false;
    }
 
    std::size_t const n_elements = mesh.getNumberOfElements();
    if (n_elements < 1)
    {
        ERR("SHPInterface::write2dMeshToSHP(): Mesh contains no elements.");
        return false;
    }
 
    // DBF-export requires a limit of records because of the limits to the
    // integer values. The exponent controls maximum number of elements and
    // the maximum number of digits written in the DBF file.
    std::size_t const max_exp = 8;
    if (n_elements >= std::pow(10, max_exp))
    {
        ERR("SHPInterface::write2dMeshToSHP(): Mesh contains too many elements "
            "for currently implemented DBF-boundaries.");
        return false;
    }
 
    SHPHandle hSHP = SHPCreate(file_name.c_str(), SHPT_POLYGON);
    DBFHandle hDBF = DBFCreate(file_name.c_str());
    int const elem_id_field =
        DBFAddField(hDBF, "Elem_ID", FTInteger, max_exp, 0);
 
    // Writing mesh elements to shape file
    std::size_t shp_record(0);
    std::vector<MeshLib::Element*> const& elems = mesh.getElements();
    for (MeshLib::Element const* const e : elems)
    {
        // ignore all elements except triangles and quads
        if ((e->getGeomType() == MeshLib::MeshElemType::TRIANGLE) ||
            (e->getGeomType() == MeshLib::MeshElemType::QUAD))
        {
            SHPObject* object = createShapeObject(*e, shp_record);
            SHPWriteObject(hSHP, -1, object);
            SHPDestroyObject(object);
 
            // write element ID to DBF-file
            DBFWriteIntegerAttribute(hDBF, shp_record, elem_id_field,
                                     e->getID());
            shp_record++;
        }
    }
    SHPClose(hSHP);
 
    // Write scalar arrays to database file
    int const n_recs = DBFGetRecordCount(hDBF);
    for (auto [name, property] : mesh.getProperties())
    {
        if (auto p = dynamic_cast<MeshLib::PropertyVector<int>*>(property))
        {
            int const field =
                DBFAddField(hDBF, std::string(name).c_str(), FTInteger, 16, 0);
            for (int i = 0; i < n_recs; ++i)
            {
                std::size_t const elem_idx =
                    DBFReadIntegerAttribute(hDBF, i, elem_id_field);
                DBFWriteIntegerAttribute(hDBF, i, field, (*p)[elem_idx]);
            }
        }
        else if (auto p =
                     dynamic_cast<MeshLib::PropertyVector<double>*>(property))
        {
            int const field =
                DBFAddField(hDBF, std::string(name).c_str(), FTDouble, 33, 16);
            for (int i = 0; i < n_recs; ++i)
            {
                std::size_t const elem_idx =
                    DBFReadIntegerAttribute(hDBF, i, elem_id_field);
                DBFWriteDoubleAttribute(hDBF, i, field, (*p)[elem_idx]);
            }
        }
    }
    DBFClose(hDBF);
    INFO("Shape export of 2D mesh '{:s}' finished.", mesh.getName());
    return true;
}

References createShapeObject(), ERR(), MeshLib::Mesh::getDimension(), MeshLib::Mesh::getElements(), MeshLib::Mesh::getName(), MeshLib::Mesh::getNumberOfElements(), MeshLib::Mesh::getProperties(), INFO(), MeshLib::QUAD, and MeshLib::TRIANGLE.

Referenced by MeshView::exportToShapefile(), and main().

Member Data Documentation

_geoObjects

GeoLib::GEOObjects& FileIO::SHPInterface::_geoObjects

private

Definition at line 90 of file SHPInterface.h.

Referenced by SHPInterface(), readPoints(), readPolygons(), readPolylines(), and readStations().

---

The documentation for this class was generated from the following files:

• Applications/FileIO/SHPInterface.h
• Applications/FileIO/SHPInterface.cpp