gnm.h

/******************************************************************************
 *
 * Project:  GDAL/OGR Geography Network support (Geographic Network Model)
 * Purpose:  GNM general public declarations.
 * Authors:  Mikhail Gusev (gusevmihs at gmail dot com)
 *           Dmitry Baryshnikov, polimax@mail.ru
 *
 ******************************************************************************
 * Copyright (c) 2014, Mikhail Gusev
 * Copyright (c) 2014-2015, NextGIS <info@nextgis.com>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included
 * in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 * DEALINGS IN THE SOFTWARE.
 ****************************************************************************/
 
#ifndef GNM
#define GNM
 
#if defined(__cplusplus) && !defined(CPL_SUPRESS_CPLUSPLUS)
#include "ogrsf_frmts.h"
#endif
#include "gnmgraph.h"
 
// Direction of an edge.
typedef int GNMDirection;  // We use int values in order to save them to the
                           // network data.
 
// Network's metadata parameters names.
#define GNM_MD_NAME "net_name"
#define GNM_MD_DESCR "net_description"
#define GNM_MD_SRS "net_srs"
#define GNM_MD_VERSION "net_version"
#define GNM_MD_RULE "net_rule"
#define GNM_MD_FORMAT "FORMAT"
#define GNM_MD_FETCHEDGES "fetch_edge"
#define GNM_MD_FETCHVERTEX "fetch_vertex"
#define GNM_MD_NUM_PATHS "num_paths"
#define GNM_MD_EMITTER "emitter"
 
// TODO: Constants for capabilities.
// #define GNMCanChangeConnections "CanChangeConnections"
 
typedef enum
{ GATDijkstraShortestPath = 1, GATKShortestPath, GATConnectedComponents
} GNMGraphAlgorithmType;
 
#if defined(__cplusplus) && !defined(CPL_SUPRESS_CPLUSPLUS)

 
class CPL_DLL GNMNetwork : public GDALDataset
{
  public:
    GNMNetwork();
    ~GNMNetwork() override;
 
    // GDALDataset Interface
    const OGRSpatialReference *GetSpatialRef() const override;
    char **GetFileList(void) override;
 
    // GNMNetwork Interface

    virtual CPLErr Create(const char *pszFilename, char **papszOptions) = 0;

    virtual CPLErr Open(GDALOpenInfo *poOpenInfo) = 0;

    virtual CPLErr Delete() = 0;

    virtual const char *GetName() const;

    virtual int GetVersion() const
    {
        return 0;
    }

    virtual CPLErr DisconnectAll() = 0;

    virtual OGRFeature *GetFeatureByGlobalFID(GNMGFID nGFID) = 0;

    virtual OGRLayer *GetPath(GNMGFID nStartFID, GNMGFID nEndFID,
                              GNMGraphAlgorithmType eAlgorithm,
                              char **papszOptions) = 0;

    static inline GNMNetwork *FromHandle(GNMGenericNetworkH hNet)
    {
        return static_cast<GNMNetwork *>(hNet);
    }

    static inline GNMGenericNetworkH ToHandle(GNMNetwork *poNetwork)
    {
        return static_cast<GNMGenericNetworkH>(poNetwork);
    }
 
  protected:
    virtual int CheckNetworkExist(const char *pszFilename,
                                  char **papszOptions) = 0;
 
  protected:
    CPLString m_soName{};
    OGRSpatialReference m_oSRS{};
};
 
class GNMRule;
class OGRGNMWrappedResultLayer;

 
class CPL_DLL GNMGenericNetwork : public GNMNetwork
{
  public:
    GNMGenericNetwork();
    ~GNMGenericNetwork() override;
 
    // GDALDataset Interface
 
    int GetLayerCount() const override;
    OGRLayer *GetLayer(int) const override;
    OGRErr DeleteLayer(int) override;
 
    int TestCapability(const char *) const override;
 
    virtual OGRLayer *CopyLayer(OGRLayer *poSrcLayer, const char *pszNewName,
                                char **papszOptions = nullptr) override;
 
    int CloseDependentDatasets() override;
    CPLErr FlushCache(bool bAtClosing) override;
 
    // GNMNetwork Interface
 
    virtual CPLErr Create(const char *pszFilename,
                          char **papszOptions) override = 0;
    CPLErr Delete() override;
 
    int GetVersion() const override;
    virtual GNMGFID GetNewGlobalFID();

    virtual CPLString GetAlgorithmName(GNMDirection eAlgorithm,
                                       bool bShortName);

    virtual CPLErr AddFeatureGlobalFID(GNMGFID nFID, const char *pszLayerName);

    virtual CPLErr ConnectFeatures(GNMGFID nSrcFID, GNMGFID nTgtFID,
                                   GNMGFID nConFID = -1, double dfCost = 1,
                                   double dfInvCost = 1,
                                   GNMDirection eDir = GNM_EDGE_DIR_BOTH);

    virtual CPLErr DisconnectFeatures(GNMGFID nSrcFID, GNMGFID nTgtFID,
                                      GNMGFID nConFID);

    virtual CPLErr DisconnectFeaturesWithId(GNMGFID nFID);

    virtual CPLErr ReconnectFeatures(GNMGFID nSrcFID, GNMGFID nTgtFID,
                                     GNMGFID nConFID, double dfCost = 1,
                                     double dfInvCost = 1,
                                     GNMDirection eDir = GNM_EDGE_DIR_BOTH);
 
    CPLErr DisconnectAll() override;
 
    OGRFeature *GetFeatureByGlobalFID(GNMGFID nFID) override;

    virtual CPLErr CreateRule(const char *pszRuleStr);

    virtual CPLErr DeleteAllRules();

    virtual CPLErr DeleteRule(const char *pszRuleStr);

    virtual char **GetRules() const;

    virtual CPLErr ConnectPointsByLines(char **papszLayerList,
                                        double dfTolerance, double dfCost,
                                        double dfInvCost, GNMDirection eDir);

    virtual CPLErr ChangeBlockState(GNMGFID nFID, bool bIsBlock);

    virtual CPLErr ChangeAllBlockState(bool bIsBlock = false);
 
    virtual OGRLayer *GetPath(GNMGFID nStartFID, GNMGFID nEndFID,
                              GNMGraphAlgorithmType eAlgorithm,
                              char **papszOptions) override;

    static inline GNMGenericNetwork *FromHandle(GNMGenericNetworkH hNet)
    {
        return static_cast<GNMGenericNetwork *>(hNet);
    }

    static inline GNMGenericNetworkH ToHandle(GNMGenericNetwork *poNetwork)
    {
        return static_cast<GNMGenericNetworkH>(poNetwork);
    }
 
  protected:
    virtual CPLErr CheckLayerDriver(const char *pszDefaultDriverName,
                                    char **papszOptions);
    virtual bool CheckStorageDriverSupport(const char *pszDriverName) = 0;
 
  protected:
    virtual CPLErr CreateMetadataLayer(GDALDataset *const pDS, int nVersion,
                                       size_t nFieldSize = 1024);
    virtual CPLErr StoreNetworkSrs();
    virtual CPLErr LoadNetworkSrs();
    virtual CPLErr CreateGraphLayer(GDALDataset *const pDS);
    virtual CPLErr CreateFeaturesLayer(GDALDataset *const pDS);
    virtual CPLErr LoadMetadataLayer(GDALDataset *const pDS);
    virtual CPLErr LoadGraphLayer(GDALDataset *const pDS);
    virtual CPLErr LoadGraph();
    virtual CPLErr LoadFeaturesLayer(GDALDataset *const pDS);
    virtual CPLErr DeleteMetadataLayer() = 0;
    virtual CPLErr DeleteGraphLayer() = 0;
    virtual CPLErr DeleteFeaturesLayer() = 0;
    virtual CPLErr LoadNetworkLayer(const char *pszLayername) = 0;
    virtual CPLErr DeleteNetworkLayers() = 0;
    virtual void ConnectPointsByMultiline(
        GIntBig nFID, const OGRMultiLineString *poMultiLineString,
        const std::vector<OGRLayer *> &paPointLayers, double dfTolerance,
        double dfCost, double dfInvCost, GNMDirection eDir);
    virtual void
    ConnectPointsByLine(GIntBig nFID, const OGRLineString *poLineString,
                        const std::vector<OGRLayer *> &paPointLayers,
                        double dfTolerance, double dfCost, double dfInvCost,
                        GNMDirection eDir);
    virtual GNMGFID
    FindNearestPoint(const OGRPoint *poPoint,
                     const std::vector<OGRLayer *> &paPointLayers,
                     double dfTolerance);
    virtual OGRFeature *FindConnection(GNMGFID nSrcFID, GNMGFID nTgtFID,
                                       GNMGFID nConFID);
    virtual bool SaveRules();
    virtual GNMGFID GetNewVirtualFID();
    virtual void FillResultLayer(OGRGNMWrappedResultLayer *poResLayer,
                                 const GNMPATH &path, int nNoOfPath,
                                 bool bReturnVertices, bool bReturnEdges);
  protected:
    int m_nVersion = 0;
    GNMGFID m_nGID = 0;
    GNMGFID m_nVirtualConnectionGID = -1;
    OGRLayer *m_poMetadataLayer = nullptr;
    OGRLayer *m_poGraphLayer = nullptr;
    OGRLayer *m_poFeaturesLayer = nullptr;
 
    GDALDriver *m_poLayerDriver = nullptr;
 
    std::map<GNMGFID, CPLString> m_moFeatureFIDMap{};
    std::vector<OGRLayer *> m_apoLayers{};
    std::vector<GNMRule> m_asRules;
    bool m_bIsRulesChanged = false;
 
    GNMGraph m_oGraph{};
    bool m_bIsGraphLoaded = false;
  private:
    CPL_DISALLOW_COPY_ASSIGN(GNMGenericNetwork)
};

 
class GNMGenericLayer final : public OGRLayer
{
  public:
    GNMGenericLayer(OGRLayer *poLayer, GNMGenericNetwork *poNetwork);
    ~GNMGenericLayer() override;
 
    // OGRLayer Interface
 
    OGRGeometry *GetSpatialFilter() override;
 
    virtual OGRErr ISetSpatialFilter(int iGeomField,
                                     const OGRGeometry *) override;
 
    OGRErr SetAttributeFilter(const char *) override;
 
    void ResetReading() override;
    OGRFeature *GetNextFeature() override;
    OGRErr SetNextByIndex(GIntBig nIndex) override;
 
    OGRErr DeleteFeature(GIntBig nFID) override;
 
    const char *GetName() const override;
    OGRwkbGeometryType GetGeomType() const override;
    const OGRFeatureDefn *GetLayerDefn() const override;
    virtual int FindFieldIndex(const char *pszFieldName,
                               int bExactMatch) override;
 
    const OGRSpatialReference *GetSpatialRef() const override;
 
    GIntBig GetFeatureCount(int bForce = TRUE) override;
 
    virtual OGRErr IGetExtent(int iGeomField, OGREnvelope *psExtent,
                              bool bForce = true) override;
 
    int TestCapability(const char *) const override;
 
    virtual OGRErr CreateField(const OGRFieldDefn *poField,
                               int bApproxOK = TRUE) override;
    OGRErr DeleteField(int iField) override;
    OGRErr ReorderFields(int *panMap) override;
    virtual OGRErr AlterFieldDefn(int iField, OGRFieldDefn *poNewFieldDefn,
                                  int nFlagsIn) override;
 
    virtual OGRErr CreateGeomField(const OGRGeomFieldDefn *poField,
                                   int bApproxOK = TRUE) override;
 
    OGRErr SyncToDisk() override;
 
    OGRStyleTable *GetStyleTable() override;
    void SetStyleTableDirectly(OGRStyleTable *poStyleTable) override;
 
    void SetStyleTable(OGRStyleTable *poStyleTable) override;
 
    OGRErr StartTransaction() override;
    OGRErr CommitTransaction() override;
    OGRErr RollbackTransaction() override;
 
    const char *GetFIDColumn() const override;
    const char *GetGeometryColumn() const override;
 
    OGRErr SetIgnoredFields(CSLConstList papszFields) override;

    OGRErr Intersection(OGRLayer *pLayerMethod, OGRLayer *pLayerResult,
                        char **papszOptions = nullptr,
                        GDALProgressFunc pfnProgress = nullptr,
                        void *pProgressArg = nullptr);
    OGRErr Union(OGRLayer *pLayerMethod, OGRLayer *pLayerResult,
                 char **papszOptions = nullptr,
                 GDALProgressFunc pfnProgress = nullptr,
                 void *pProgressArg = nullptr);
    OGRErr SymDifference(OGRLayer *pLayerMethod, OGRLayer *pLayerResult,
                         char **papszOptions, GDALProgressFunc pfnProgress,
                         void *pProgressArg);
    OGRErr Identity(OGRLayer *pLayerMethod, OGRLayer *pLayerResult,
                    char **papszOptions = nullptr,
                    GDALProgressFunc pfnProgress = nullptr,
                    void *pProgressArg = nullptr);
    OGRErr Update(OGRLayer *pLayerMethod, OGRLayer *pLayerResult,
                  char **papszOptions = nullptr,
                  GDALProgressFunc pfnProgress = nullptr,
                  void *pProgressArg = nullptr);
    OGRErr Clip(OGRLayer *pLayerMethod, OGRLayer *pLayerResult,
                char **papszOptions = nullptr,
                GDALProgressFunc pfnProgress = nullptr,
                void *pProgressArg = nullptr);
    OGRErr Erase(OGRLayer *pLayerMethod, OGRLayer *pLayerResult,
                 char **papszOptions = nullptr,
                 GDALProgressFunc pfnProgress = nullptr,
                 void *pProgressArg = nullptr);

    GIntBig GetFeaturesRead();

    int AttributeFilterEvaluationNeedsGeometry();

    /* consider these private */
    OGRErr InitializeIndexSupport(const char *);
    OGRLayerAttrIndex *GetIndex();
 
  protected:
    OGRErr ISetFeature(OGRFeature *poFeature) override;
    OGRErr ICreateFeature(OGRFeature *poFeature) override;
 
  protected:
    CPLString m_soLayerName{};
    OGRLayer *m_poLayer = nullptr;
    GNMGenericNetwork *m_poNetwork = nullptr;
    std::map<GNMGFID, GIntBig> m_mnFIDMap{};
 
  private:
    CPL_DISALLOW_COPY_ASSIGN(GNMGenericLayer)
};
 
typedef enum
{ GRTConnection = 0
} GNMRuleType;

 
class CPL_DLL GNMRule /* non final */
{
  public:
    GNMRule();
    explicit GNMRule(const std::string &oRule);
    explicit GNMRule(const char *pszRule);

    GNMRule(const GNMRule &) = default;

    GNMRule(GNMRule &&) = default;

    GNMRule &operator=(const GNMRule &) = default;

    GNMRule &operator=(GNMRule &&) = default;

    virtual ~GNMRule();

    virtual bool IsValid() const;
    virtual bool IsAcceptAny() const;
    virtual GNMRuleType GetType() const;
    virtual bool CanConnect(const CPLString &soSrcLayerName,
                            const CPLString &soTgtLayerName,
                            const CPLString &soConnLayerName = "");
    virtual CPLString GetSourceLayerName() const;
    virtual CPLString GetTargetLayerName() const;
    virtual CPLString GetConnectorLayerName() const;
    const char *c_str() const;
    operator const char *(void) const;
 
  protected:
    virtual bool ParseRuleString();
 
  protected:
    CPLString m_soSrcLayerName{};
    CPLString m_soTgtLayerName{};
    CPLString m_soConnLayerName{};
    bool m_bAllow = false;
    bool m_bValid = false;
    bool m_bAny = false;
    CPLString m_soRuleString{};
};

 
class OGRGNMWrappedResultLayer final : public OGRLayer
{
  public:
    OGRGNMWrappedResultLayer(GDALDataset *poDS, OGRLayer *poLayer);
    ~OGRGNMWrappedResultLayer() override;
 
    // OGRLayer
    void ResetReading() override;
    OGRFeature *GetNextFeature() override;
    OGRErr SetNextByIndex(GIntBig nIndex) override;
    OGRFeature *GetFeature(GIntBig nFID) override;
    const OGRFeatureDefn *GetLayerDefn() const override;
    GIntBig GetFeatureCount(int bForce = TRUE) override;
    int TestCapability(const char *pszCap) const override;
    virtual OGRErr CreateField(const OGRFieldDefn *poField,
                               int bApproxOK = TRUE) override;
    virtual OGRErr CreateGeomField(const OGRGeomFieldDefn *poField,
                                   int bApproxOK = TRUE) override;
    const char *GetFIDColumn() const override;
    const char *GetGeometryColumn() const override;
    const OGRSpatialReference *GetSpatialRef() const override;
 
    // OGRGNMWrappedResultLayer
    OGRErr InsertFeature(OGRFeature *poFeature, const CPLString &soLayerName,
                         int nPathNo, bool bIsEdge);
 
  protected:
    OGRErr ISetFeature(OGRFeature *poFeature) override;
    OGRErr ICreateFeature(OGRFeature *poFeature) override;
 
  protected:
    GDALDataset *poDS = nullptr;
    OGRLayer *poLayer = nullptr;
 
  private:
    CPL_DISALLOW_COPY_ASSIGN(OGRGNMWrappedResultLayer)
};
 
#endif  // __cplusplus
 
#endif  // GNM