From 9e79d4249b8d45a44d3fc643057fda9026c0b5e9 Mon Sep 17 00:00:00 2001 From: linlin Date: Mon, 5 Oct 2020 16:35:23 +0200 Subject: [PATCH] New translations GedLibBind.hpp (French) --- lang/fr/gklearn/gedlib/src/GedLibBind.hpp | 529 ++++++++++++++++++++++++++++++ 1 file changed, 529 insertions(+) create mode 100644 lang/fr/gklearn/gedlib/src/GedLibBind.hpp diff --git a/lang/fr/gklearn/gedlib/src/GedLibBind.hpp b/lang/fr/gklearn/gedlib/src/GedLibBind.hpp new file mode 100644 index 0000000..63e0db3 --- /dev/null +++ b/lang/fr/gklearn/gedlib/src/GedLibBind.hpp @@ -0,0 +1,529 @@ +/**************************************************************************** + * * + * Copyright (C) 2019-2020 by Natacha Lambert, David B. Blumenthal and * + * Linlin Jia * + * * + * This file should be used by Python. * + * Please call the Python module if you want to use GedLib with this code.* + * * + * Otherwise, you can directly use GedLib for C++. * + * * + ***************************************************************************/ + +/*! + * @file GedLibBind.hpp + * @brief Classe and function declarations to call easly GebLib in Python without Gedlib's types + */ +#ifndef GEDLIBBIND_HPP +#define GEDLIBBIND_HPP + +//Include standard libraries. +#include +#include +#include +#include +#include +#include "../include/gedlib-master/src/env/ged_env.hpp" +#include "../include/gedlib-master/src/env/node_map.hpp" + + +/*! + * @namespace pyged + * @brief Global namespace for gedlibpy. + */ +namespace pyged { + +/*! +* @brief Get list of available edit cost functions readable by Python. +*/ +std::vector getEditCostStringOptions(); + +/*! +* @brief Get list of available computation methods readable by Python. +*/ +std::vector getMethodStringOptions(); + +/*! +* @brief Get list of available initilaization options readable by Python. +*/ +std::vector getInitStringOptions(); + +/*! +* @brief Returns a dummy node. +* @return ID of dummy node. +*/ +static std::size_t getDummyNode(); + + +/*! +* @brief Provides the API of GEDLIB for Python. +*/ +class PyGEDEnv { + +public: + + /*! + * @brief Constructor. + */ + PyGEDEnv(); + + // PyGEDEnv(); + + /*! + * @brief Destructor. + */ + ~PyGEDEnv(); + + /*! + * @brief Tests if the environment is initialized or not. + * @return Boolean @p true if the environment is initialized and @p false otherwise. + */ + bool isInitialized(); + + /*! + * @brief Restart the environment (recall a new empty environment). + */ + void restartEnv(); + + /*! + * @brief Loads graph given in the [GXL file format](http://www.gupro.de/GXL/). + * @param[in] pathFolder The path to the directory containing the graphs. + * @param[in] pathXML The path to a XML file thats lists the graphs contained in @p pathFolder that should be loaded. + * @param[in] node_type Select if nodes are labeled or unlabeled. + * @param[in] edge_type Select if edges are labeled or unlabeled. + */ + void loadGXLGraph(const std::string & pathFolder, const std::string & pathXML, bool node_type, bool edge_type); + + /*! + * @brief Provides access to the IDs of the graphs contained in the environment. + * @return Pair (ID of first graphs, ID of last graph + 1) of graph IDs. + * If both entries equal 0, the environment does not contain any graphs. + */ + std::pair getGraphIds() const; + + /*! + * @brief Returns the list of graphs IDs which are loaded in the environment. + * @return A vector which contains all the graphs Ids. + */ + std::vector getAllGraphIds(); + + /*! + * @brief Returns the graph class. + * @param[in] id ID of an input graph that has been added to the environment. + * @return Class of the input graph. + */ + const std::string getGraphClass(std::size_t id) const; + + /*! + * @brief Returns the graph name. + * @param[in] id ID of an input graph that has been added to the environment. + * @return Name of the input graph. + */ + const std::string getGraphName(std::size_t id) const; + + /*! + * @brief Adds a new uninitialized graph to the environment. Call initEnv() after calling this method. + * @param[in] name The name of the added graph. Empty if not specified. + * @param[in] class The class of the added graph. Empty if not specified. + * @return The ID of the newly added graph. + */ + std::size_t addGraph(const std::string & graph_name, const std::string & graph_class); + + /*! + * @brief Adds a labeled node. + * @param[in] graphId ID of graph that has been added to the environment. + * @param[in] nodeId The user-specific ID of the vertex that has to be added. + * @param[in] nodeLabel The label of the vertex that has to be added. + */ + void addNode(std::size_t graphId, const std::string & nodeId, const std::map & nodeLabel); + + /*! + * @brief Adds a labeled edge. + * @param[in] graphId ID of graph that has been added to the environment. + * @param[in] tail The user-specific ID of the tail of the edge that has to be added. + * @param[in] head The user-specific ID of the head of the edge that has to be added. + * @param[in] edgeLabel The label of the vertex that has to be added. + * @param[in] ignoreDuplicates If @p true, duplicate edges are ignores. Otherwise, an exception is thrown if an existing edge is added to the graph. + */ + void addEdge(std::size_t graphId, const std::string & tail, const std::string & head, const std::map & edgeLabel, bool ignoreDuplicates = true); + + /*! + * @brief Clears and de-initializes a graph that has previously been added to the environment. Call initEnv() after calling this method. + * @param[in] graphId ID of graph that has to be cleared. + */ + void clearGraph(std::size_t graphId); + + /*! + * @brief Returns ged::ExchangeGraph representation. + * @param graphId ID of the selected graph. + * @return ged::ExchangeGraph representation of the selected graph. + */ + ged::ExchangeGraph getGraph(std::size_t graphId) const; + + /*! + * @brief Returns the internal Id of a graph, selected by its ID. + * @param[in] graphId ID of an input graph that has been added to the environment. + * @return The internal ID of the selected graph + */ + std::size_t getGraphInternalId(std::size_t graphId); + + /*! + * @brief Returns all the number of nodes on a graph, selected by its ID. + * @param[in] graphId ID of an input graph that has been added to the environment. + * @return The number of nodes on the selected graph + */ + std::size_t getGraphNumNodes(std::size_t graphId); + + /*! + * @brief Returns all the number of edges on a graph, selected by its ID. + * @param[in] graphId ID of an input graph that has been added to the environment. + * @return The number of edges on the selected graph + */ + std::size_t getGraphNumEdges(std::size_t graphId); + + /*! + * @brief Returns all th Ids of nodes on a graph, selected by its ID. + * @param[in] graphId ID of an input graph that has been added to the environment. + * @return The list of IDs's nodes on the selected graph + */ + std::vector getGraphOriginalNodeIds(std::size_t graphId); + + /*! + * @brief Returns all the labels of nodes on a graph, selected by its ID. + * @param[in] graphId ID of an input graph that has been added to the environment. + * @return The list of labels's nodes on the selected graph + */ + std::vector> getGraphNodeLabels(std::size_t graphId); + + /*! + * @brief Returns all the edges on a graph, selected by its ID. + * @param[in] graphId ID of an input graph that has been added to the environment. + * @return The list of edges on the selected graph + */ + std::map, std::map> getGraphEdges(std::size_t graphId); + + /*! + * @brief Returns the adjacence list of a graph, selected by its ID. + * @param[in] graphId ID of an input graph that has been added to the environment. + * @return The adjacence list of the selected graph + */ + std::vector> getGraphAdjacenceMatrix(std::size_t graphId); + + /*! + * @brief Sets the edit costs to one of the predefined edit costs. + * @param[in] editCost Select one of the predefined edit costs. + * @param[in] editCostConstants Parameters for the edit cost, empty by default. + */ + void setEditCost(std::string editCost, std::vector editCostConstants = {}); + + /*! + * @brief Sets the edit costs to a personal Edit Cost Class. + * @param[in] editCostConstants Parameters for the edit cost, empty by default. + * @note You have to add your class, which should inherit from EditCost class, in the function. After that, you can compile and use it in Python + */ + void setPersonalEditCost(std::vector editCostConstants = {}); + + /*! + * @brief Initializes the environment. + * @param[in] initOption Select initialization options. + * @param[in] print_to_stdout If set to @p true, the progress of the initialization is printed to std::out. + */ + void initEnv(std::string initOption = "EAGER_WITH_SHUFFLED_COPIES", bool print_to_stdout = false); + + /*! + * @brief Sets the GEDMethod to be used by run_method(). + * @param[in] method Select the method that is to be used. + * @param[in] options An options string of the form @"[--@ @] [...]@" passed to the selected method. + */ + void setMethod(std::string method, const std::string & options); + + /*! + * @brief Initializes the method specified by call to set_method(). + */ + void initMethod(); + + /*! + * @brief Returns initialization time. + * @return Runtime of the last call to init_method(). + */ + double getInitime() const; + + /*! + * @brief Runs the GED method specified by call to set_method() between the graphs with IDs @p g and @p h. + * @param[in] g ID of an input graph that has been added to the environment. + * @param[in] h ID of an input graph that has been added to the environment. + */ + void runMethod(std::size_t g, std::size_t h); + + /*! + * @brief Returns upper bound for edit distance between the input graphs. + * @param[in] g ID of an input graph that has been added to the environment. + * @param[in] h ID of an input graph that has been added to the environment. + * @return Upper bound computed by the last call to run_method() with arguments @p g and @p h. + */ + double getUpperBound(std::size_t g, std::size_t h) const; + + /*! + * @brief Returns lower bound for edit distance between the input graphs. + * @param[in] g ID of an input graph that has been added to the environment. + * @param[in] h ID of an input graph that has been added to the environment. + * @return Lower bound computed by the last call to run_method() with arguments @p g and @p h. + */ + double getLowerBound(std::size_t g,std::size_t h) const; + + /*! + * @brief Returns the forward map between nodes of the two indicated graphs. + * @param[in] g ID of an input graph that has been added to the environment. + * @param[in] h ID of an input graph that has been added to the environment. + * @return The forward map to the adjacence matrix computed by the last call to run_method() with arguments @p g and @p h. + */ + std::vector getForwardMap(std::size_t g, std::size_t h) const; + + /*! + * @brief Returns the backward map between nodes of the two indicated graphs. + * @param[in] g ID of an input graph that has been added to the environment. + * @param[in] h ID of an input graph that has been added to the environment. + * @return The backward map to the adjacence matrix computed by the last call to run_method() with arguments @p g and @p h. + */ + std::vector getBackwardMap(std::size_t g, std::size_t h) const; + + /*! + * @brief Returns image of a node. + * @param[in] g ID of an input graph that has been added to the environment. + * @param[in] h ID of an input graph that has been added to the environment. + * @param[in] nodeId Node whose image is to be returned. + * @return Node to which node @p node is assigned. + */ + std::size_t getNodeImage(std::size_t g, std::size_t h, std::size_t nodeId) const; + + /*! + * @brief Returns pre-image of a node. + * @param[in] g ID of an input graph that has been added to the environment. + * @param[in] h ID of an input graph that has been added to the environment. + * @param[in] nodeId Node whose pre-image is to be returned. + * @return Node to which node @p node is assigned. + */ + std::size_t getNodePreImage(std::size_t g, std::size_t h, std::size_t nodeId) const; + + /*! + * @brief Returns the induced cost between the two indicated graphs. + * @param[in] g ID of an input graph that has been added to the environment. + * @param[in] h ID of an input graph that has been added to the environment. + * @return The induced cost between the two indicated graphs. + */ + double getInducedCost(std::size_t g, std::size_t h) const; + + + /*! + * @brief Returns node map between the input graphs. This function duplicates datas. + * @param[in] g ID of an input graph that has been added to the environment. + * @param[in] h ID of an input graph that has been added to the environment. + * @return Node map computed by the last call to run_method() with arguments @p g and @p h. + */ + std::vector> getNodeMap(std::size_t g, std::size_t h); + + /*! + * @brief Returns assignment matrix between the input graphs. This function duplicates datas. + * @param[in] g ID of an input graph that has been added to the environment. + * @param[in] h ID of an input graph that has been added to the environment. + * @return Assignment matrix computed by the last call to run_method() with arguments @p g and @p h. + */ + std::vector> getAssignmentMatrix(std::size_t g, std::size_t h); + + /*! + * @brief Returns a vector which contains the forward and the backward maps between nodes of the two indicated graphs. + * @param[in] g ID of an input graph that has been added to the environment. + * @param[in] h ID of an input graph that has been added to the environment. + * @return The forward and backward maps to the adjacence matrix computed by the last call to run_method() with arguments @p g and @p h. + */ + std::vector> getAllMap(std::size_t g, std::size_t h); + + /*! + * @brief Returns runtime. + * @param[in] g ID of an input graph that has been added to the environment. + * @param[in] h ID of an input graph that has been added to the environment. + * @return Runtime of last call to run_method() with arguments @p g and @p h. + */ + double getRuntime(std::size_t g, std::size_t h) const; + + /*! + * @brief Checks if the edit costs are quasimetric. + * @return Boolean @p true if the edit costs are quasimetric and @p false, otherwise. + */ + bool quasimetricCosts() const; + + /*! + * @brief Applies the hungarian algorithm (LSAP) to a matrix cost. + * @param[in] matrixCost The matrix cost. + * @return the values of rho, varrho, u and v, in this order. + */ + std::vector> hungarianLSAP(std::vector> matrixCost); + + /*! + * @brief Applies the hungarian algorithm (LSAPE) to a matrix cost. + * @param[in] matrixCost The matrix cost. + * @return the values of rho, varrho, u and v, in this order. + */ + std::vector> hungarianLSAPE(std::vector> matrixCost); + + /*! + * @brief Returns the number of node labels. + * @return Number of pairwise different node labels contained in the environment. + * @note If @p 1 is returned, the nodes are unlabeled. + */ + std::size_t getNumNodeLabels() const; + + /*! + * @brief Returns node label. + * @param[in] label_id ID of node label that should be returned. Must be between 1 and num_node_labels(). + * @return Node label for selected label ID. + */ + std::map getNodeLabel(std::size_t label_id) const; + + /*! + * @brief Returns the number of edge labels. + * @return Number of pairwise different edge labels contained in the environment. + * @note If @p 1 is returned, the edges are unlabeled. + */ + std::size_t getNumEdgeLabels() const; + + /*! + * @brief Returns edge label. + * @param[in] label_id ID of edge label that should be returned. Must be between 1 and num_node_labels(). + * @return Edge label for selected label ID. + */ + std::map getEdgeLabel(std::size_t label_id) const; + + // /*! + // * @brief Returns the number of nodes. + // * @param[in] graph_id ID of an input graph that has been added to the environment. + // * @return Number of nodes in the graph. + // */ + // std::size_t getNumNodes(std::size_t graph_id) const; + + /*! + * @brief Returns average number of nodes. + * @return Average number of nodes of the graphs contained in the environment. + */ + double getAvgNumNodes() const; + + /*! + * @brief Returns node relabeling cost. + * @param[in] node_label_1 First node label. + * @param[in] node_label_2 Second node label. + * @return Node relabeling cost for the given node labels. + */ + double getNodeRelCost(const std::map & node_label_1, const std::map & node_label_2) const; + + /*! + * @brief Returns node deletion cost. + * @param[in] node_label Node label. + * @return Cost of deleting node with given label. + */ + double getNodeDelCost(const std::map & node_label) const; + + /*! + * @brief Returns node insertion cost. + * @param[in] node_label Node label. + * @return Cost of inserting node with given label. + */ + double getNodeInsCost(const std::map & node_label) const; + + /*! + * @brief Computes median node label. + * @param[in] node_labels The node labels whose median should be computed. + * @return Median of the given node labels. + */ + std::map getMedianNodeLabel(const std::vector> & node_labels) const; + + /*! + * @brief Returns edge relabeling cost. + * @param[in] edge_label_1 First edge label. + * @param[in] edge_label_2 Second edge label. + * @return Edge relabeling cost for the given edge labels. + */ + double getEdgeRelCost(const std::map & edge_label_1, const std::map & edge_label_2) const; + + /*! + * @brief Returns edge deletion cost. + * @param[in] edge_label Edge label. + * @return Cost of deleting edge with given label. + */ + double getEdgeDelCost(const std::map & edge_label) const; + + /*! + * @brief Returns edge insertion cost. + * @param[in] edge_label Edge label. + * @return Cost of inserting edge with given label. + */ + double getEdgeInsCost(const std::map & edge_label) const; + + /*! + * @brief Computes median edge label. + * @param[in] edge_labels The edge labels whose median should be computed. + * @return Median of the given edge labels. + */ + std::map getMedianEdgeLabel(const std::vector> & edge_labels) const; + + /*! + * @brief Returns the initialization type of the last initialization. + * @return Initialization type in string. + */ + std::string getInitType() const; + + /*! + * @brief Computes the edit cost between two graphs induced by a node map. + * @param[in] g_id ID of input graph. + * @param[in] h_id ID of input graph. + * @return Computed induced cost. + */ + double computeInducedCost(std::size_t g_id, std::size_t h_id, std::vector> relation) const; + + // /*! + // * @brief Returns node relabeling, insertion, or deletion cost. + // * @param[in] label1 First node label. + // * @param[in] label2 Second node label. + // * @return Node relabeling cost if @p label1 and @p label2 are both different from ged::dummy_label(), + // * node insertion cost if @p label1 equals ged::dummy_label and @p label2 does not, + // * node deletion cost if @p label1 does not equal ged::dummy_label and @p label2 does, + // * and 0 otherwise. + // */ + // double getNodeCost(std::size_t label1, std::size_t label2) const; + + +private: + + ged::GEDEnv * env_; // environment variable + + bool initialized; // initialization boolean (because env has one but not accessible) + +}; + +} + +#include "GedLibBind.ipp" + +#endif /* SRC_GEDLIB_BIND_HPP */ + + + + + + + + + + + +// namespace shapes { +// class Rectangle { +// public: +// int x0, y0, x1, y1; +// Rectangle(); +// Rectangle(int x0, int y0, int x1, int y1); +// ~Rectangle(); +// int getArea(); +// void getSize(int* width, int* height); +// void move(int dx, int dy); +// }; +// } \ No newline at end of file