OpenI
/
graphkit-learn
Not watched
1
0
Fork 0
Code
Releases 2 Wiki Activity
Issues 0 Pull Requests 0 Datasets Model Cloudbrain
You can not select more than 25 topics Topics must start with a chinese character,a letter or number, can include dashes ('-') and can be up to 35 characters long.
Tree: 7e94ecaf31
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '7e94ecaf31'
${ noResults }
graphkit-learn/gklearn/gedlib/src/GedLibBind.hpp

529 lines
21 kB
Raw Blame History 

  1. /****************************************************************************

  2.  *                                                                          *

  3.  *   Copyright (C) 2019-2020 by Natacha Lambert, David B. Blumenthal and    *

  4.  *   Linlin Jia                                                             *

  5.  *                                                                          *

  6.  *   This file should be used by Python.                                    *

  7.  * 	 Please call the Python module if you want to use GedLib with this code.* 

  8.  *                                                                          *

  9.  * 	 Otherwise, you can directly use GedLib for C++.                        *

  10.  *                                                                          *

  11.  ***************************************************************************/

  12.  

  13. /*!

  14.  * @file GedLibBind.hpp

  15.  * @brief Classe and function declarations to call easly GebLib in Python without Gedlib's types

  16.  */

  17. #ifndef GEDLIBBIND_HPP

  18. #define GEDLIBBIND_HPP

  19.  

  20. //Include standard libraries.

  21. #include <string>

  22. #include <vector>

  23. #include <map>

  24. #include <list>

  25. #include <iostream>

  26. #include "../include/gedlib-master/src/env/ged_env.hpp"

  27. #include "../include/gedlib-master/src/env/node_map.hpp"

  28. 

  29. 

  30. /*!

  31.  * @namespace pyged

  32.  * @brief Global namespace for gedlibpy.

  33.  */

  34. namespace pyged {

  35. 

  36. /*!

  37. * @brief Get list of available edit cost functions readable by Python.

  38. */

  39. std::vector<std::string> getEditCostStringOptions(); 

  40. 

  41. /*!

  42. * @brief Get list of available computation methods readable by Python.

  43. */

  44. std::vector<std::string> getMethodStringOptions();

  45. 

  46. /*!

  47. * @brief Get list of available initilaization options readable by Python.

  48. */

  49. std::vector<std::string> getInitStringOptions();

  50. 

  51. /*!

  52. * @brief Returns a dummy node.

  53. * @return ID of dummy node.

  54. */

  55. static std::size_t getDummyNode();

  56. 

  57. 

  58. /*!

  59. * @brief Provides the API of GEDLIB for Python.

  60. */

  61. class PyGEDEnv {

  62. 

  63. public:

  64. 

  65. 	/*!

  66. 	 * @brief Constructor.

  67. 	 */

  68.     PyGEDEnv();

  69. 

  70.     // PyGEDEnv();

  71. 

  72. 	/*!

  73. 	 * @brief Destructor.

  74. 	 */

  75.     ~PyGEDEnv();

  76. 

  77.     /*!

  78.     * @brief Tests if the environment is initialized or not. 

  79.     * @return Boolean @p true if the environment is initialized and @p false otherwise.

  80.     */

  81.     bool isInitialized();

  82. 

  83.     /*!

  84.     * @brief Restart the environment (recall a new empty environment).

  85.     */

  86.     void restartEnv();

  87. 

  88.     /*!

  89.     * @brief Loads graph given in the [GXL file format](http://www.gupro.de/GXL/).

  90.     * @param[in] pathFolder The path to the directory containing the graphs.

  91.     * @param[in] pathXML The path to a XML file thats lists the graphs contained in @p pathFolder that should be loaded.

  92.     * @param[in] node_type Select if nodes are labeled or unlabeled.

  93.     * @param[in] edge_type Select if edges are labeled or unlabeled.

  94.     */

  95.     void loadGXLGraph(const std::string & pathFolder, const std::string & pathXML, bool node_type, bool edge_type);

  96. 

  97.     /*!

  98.     * @brief Provides access to the IDs of the graphs contained in the environment.

  99.     * @return Pair <tt>(ID of first graphs, ID of last graph + 1)</tt> of graph IDs.

  100.     * If both entries equal 0, the environment does not contain any graphs.

  101.     */

  102.     std::pair<std::size_t,std::size_t> getGraphIds() const;

  103. 

  104.     /*!

  105.     * @brief Returns the list of graphs IDs which are loaded in the environment. 

  106.     * @return A vector which contains all the graphs Ids. 

  107.     */

  108.     std::vector<std::size_t> getAllGraphIds();

  109. 

  110.     /*!

  111.     * @brief Returns the graph class.

  112.     * @param[in] id ID of an input graph that has been added to the environment.

  113.     * @return Class of the input graph.

  114.     */

  115.     const std::string getGraphClass(std::size_t id) const;

  116. 

  117.     /*!

  118.     * @brief Returns the graph name.

  119.     * @param[in] id ID of an input graph that has been added to the environment.

  120.     * @return Name of the input graph.

  121.     */

  122.     const std::string getGraphName(std::size_t id) const;

  123. 

  124.     /*!

  125.     * @brief Adds a new uninitialized graph to the environment. Call initEnv() after calling this method.

  126.     * @param[in] name The name of the added graph. Empty if not specified.

  127.     * @param[in] class The class of the added graph. Empty if not specified.

  128.     * @return The ID of the newly added graph.

  129.     */

  130.     std::size_t addGraph(const std::string & graph_name, const std::string & graph_class);

  131. 

  132.     /*!

  133.     * @brief Adds a labeled node.

  134.     * @param[in] graphId ID of graph that has been added to the environment.

  135.     * @param[in] nodeId The user-specific ID of the vertex that has to be added.

  136.     * @param[in] nodeLabel The label of the vertex that has to be added.

  137.     */

  138.     void addNode(std::size_t graphId, const std::string & nodeId, const std::map<std::string, std::string> & nodeLabel);

  139. 

  140.     /*!

  141.     * @brief Adds a labeled edge.

  142.     * @param[in] graphId ID of graph that has been added to the environment.

  143.     * @param[in] tail The user-specific ID of the tail of the edge that has to be added.

  144.     * @param[in] head The user-specific ID of the head of the edge that has to be added.

  145.     * @param[in] edgeLabel The label of the vertex that has to be added. 

  146.     * @param[in] ignoreDuplicates If @p true, duplicate edges are ignores. Otherwise, an exception is thrown if an existing edge is added to the graph.

  147.     */

  148.     void addEdge(std::size_t graphId, const std::string & tail, const std::string & head, const std::map<std::string, std::string> & edgeLabel, bool ignoreDuplicates = true);

  149. 

  150.     /*!

  151.     * @brief Clears and de-initializes a graph that has previously been added to the environment. Call initEnv() after calling this method.

  152.     * @param[in] graphId ID of graph that has to be cleared.

  153.     */

  154.     void clearGraph(std::size_t graphId);

  155. 

  156.     /*!

  157.     * @brief Returns ged::ExchangeGraph representation.

  158.     * @param graphId ID of the selected graph.

  159.     * @return ged::ExchangeGraph representation of the selected graph.

  160.     */

  161.     ged::ExchangeGraph<ged::GXLNodeID, ged::GXLLabel, ged::GXLLabel> getGraph(std::size_t graphId) const;

  162. 

  163.     /*!

  164.     * @brief Returns the internal Id of a graph, selected by its ID.

  165.     * @param[in] graphId ID of an input graph that has been added to the environment.

  166.     * @return The internal ID of the selected graph

  167.     */

  168.     std::size_t getGraphInternalId(std::size_t graphId);

  169. 

  170.     /*!

  171.     * @brief Returns all the number of nodes on a graph, selected by its ID.

  172.     * @param[in] graphId ID of an input graph that has been added to the environment.

  173.     * @return The number of nodes on the selected graph

  174.     */

  175.     std::size_t getGraphNumNodes(std::size_t graphId);

  176. 

  177.     /*!

  178.     * @brief Returns all the number of edges on a graph, selected by its ID.

  179.     * @param[in] graphId ID of an input graph that has been added to the environment.

  180.     * @return The number of edges on the selected graph

  181.     */

  182.     std::size_t getGraphNumEdges(std::size_t graphId);

  183. 

  184.     /*!

  185.     * @brief Returns all th Ids of nodes on a graph, selected by its ID.

  186.     * @param[in] graphId ID of an input graph that has been added to the environment.

  187.     * @return The list of IDs's nodes on the selected graph

  188.     */

  189.     std::vector<std::string> getGraphOriginalNodeIds(std::size_t graphId);

  190. 

  191.     /*!

  192.     * @brief Returns all the labels of nodes on a graph, selected by its ID.

  193.     * @param[in] graphId ID of an input graph that has been added to the environment.

  194.     * @return The list of labels's nodes on the selected graph

  195.     */

  196.     std::vector<std::map<std::string, std::string>> getGraphNodeLabels(std::size_t graphId);

  197. 

  198.     /*!

  199.     * @brief Returns all the edges on a graph, selected by its ID.

  200.     * @param[in] graphId ID of an input graph that has been added to the environment.

  201.     * @return The list of edges on the selected graph

  202.     */

  203.     std::map<std::pair<std::size_t, std::size_t>, std::map<std::string, std::string>> getGraphEdges(std::size_t graphId);

  204. 

  205.     /*!

  206.     * @brief Returns the adjacence list of a graph, selected by its ID.

  207.     * @param[in] graphId ID of an input graph that has been added to the environment.

  208.     * @return The adjacence list of the selected graph

  209.     */

  210.     std::vector<std::vector<std::size_t>> getGraphAdjacenceMatrix(std::size_t graphId);

  211. 

  212.     /*!

  213.     * @brief Sets the edit costs to one of the predefined edit costs.

  214.     * @param[in] editCost Select one of the predefined edit costs.

  215.     * @param[in] editCostConstants Parameters for the edit cost, empty by default.

  216.     */

  217.     void setEditCost(std::string editCost, std::vector<double> editCostConstants = {});

  218. 

  219.     /*!

  220.     * @brief Sets the edit costs to a personal Edit Cost Class.

  221.     * @param[in] editCostConstants Parameters for the edit cost, empty by default.

  222.     * @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

  223.     */

  224.     void setPersonalEditCost(std::vector<double> editCostConstants = {});

  225. 

  226.     /*!

  227.     * @brief Initializes the environment.

  228.     * @param[in] initOption Select initialization options.

  229. 	* @param[in] print_to_stdout If set to @p true, the progress of the initialization is printed to std::out.

  230.     */

  231.     void initEnv(std::string initOption = "EAGER_WITH_SHUFFLED_COPIES", bool print_to_stdout = false);

  232. 

  233.     /*!

  234.     * @brief Sets the GEDMethod to be used by run_method().

  235.     * @param[in] method Select the method that is to be used.

  236.     * @param[in] options An options string of the form @"[--@<option@> @<arg@>] [...]@" passed to the selected method.

  237.     */

  238.     void setMethod(std::string method, const std::string & options);

  239. 

  240.     /*!

  241.     * @brief Initializes the method specified by call to set_method().

  242.     */

  243.     void initMethod();

  244. 

  245.     /*!

  246.     * @brief Returns initialization time.

  247.     * @return Runtime of the last call to init_method().

  248.     */

  249.     double getInitime() const;

  250. 

  251.     /*!

  252.     * @brief Runs the GED method specified by call to set_method() between the graphs with IDs @p g and @p h.

  253.     * @param[in] g ID of an input graph that has been added to the environment.

  254.     * @param[in] h ID of an input graph that has been added to the environment.

  255.     */

  256.     void runMethod(std::size_t g, std::size_t h);

  257. 

  258.     /*!

  259.     * @brief Returns upper bound for edit distance between the input graphs.

  260.     * @param[in] g ID of an input graph that has been added to the environment.

  261.     * @param[in] h ID of an input graph that has been added to the environment.

  262.     * @return Upper bound computed by the last call to run_method() with arguments @p g and @p h.

  263.     */

  264.     double getUpperBound(std::size_t g, std::size_t h) const;

  265. 

  266.     /*!

  267.     * @brief Returns lower bound for edit distance between the input graphs.

  268.     * @param[in] g ID of an input graph that has been added to the environment.

  269.     * @param[in] h ID of an input graph that has been added to the environment.

  270.     * @return Lower bound computed by the last call to run_method() with arguments @p g and @p h.

  271.     */

  272.     double getLowerBound(std::size_t g,std::size_t h) const;

  273. 

  274.     /*!

  275.     * @brief  Returns the forward map between nodes of the two indicated graphs. 

  276.     * @param[in] g ID of an input graph that has been added to the environment.

  277.     * @param[in] h ID of an input graph that has been added to the environment.

  278.     * @return The forward map to the adjacence matrix computed by the last call to run_method() with arguments @p g and @p h.

  279.     */

  280.     std::vector<long unsigned int> getForwardMap(std::size_t g, std::size_t h) const;

  281. 

  282.     /*!

  283.     * @brief  Returns the backward map between nodes of the two indicated graphs. 

  284.     * @param[in] g ID of an input graph that has been added to the environment.

  285.     * @param[in] h ID of an input graph that has been added to the environment.

  286.     * @return The backward map to the adjacence matrix computed by the last call to run_method() with arguments @p g and @p h.

  287.     */

  288.     std::vector<long unsigned int> getBackwardMap(std::size_t g, std::size_t h) const;

  289. 

  290.     /*!

  291.     * @brief Returns image of a node.

  292.     * @param[in] g ID of an input graph that has been added to the environment.

  293.     * @param[in] h ID of an input graph that has been added to the environment.

  294.     * @param[in] nodeId Node whose image is to be returned.

  295.     * @return Node to which node @p node is assigned.

  296.     */

  297.     std::size_t getNodeImage(std::size_t g, std::size_t h, std::size_t nodeId) const;

  298. 

  299.     /*!

  300.     * @brief Returns pre-image of a node.

  301.     * @param[in] g ID of an input graph that has been added to the environment.

  302.     * @param[in] h ID of an input graph that has been added to the environment.

  303.     * @param[in] nodeId Node whose pre-image is to be returned.

  304.     * @return Node to which node @p node is assigned.

  305.     */

  306.     std::size_t getNodePreImage(std::size_t g, std::size_t h, std::size_t nodeId) const;

  307. 

  308.     /*!

  309.     * @brief Returns the induced cost between the two indicated graphs.

  310.     * @param[in] g ID of an input graph that has been added to the environment.

  311.     * @param[in] h ID of an input graph that has been added to the environment.

  312.     * @return The induced cost between the two indicated graphs.

  313.     */

  314.     double getInducedCost(std::size_t g, std::size_t h) const;

  315.     

  316. 

  317.     /*!

  318.     * @brief Returns node map between the input graphs. This function duplicates datas. 

  319.     * @param[in] g ID of an input graph that has been added to the environment.

  320.     * @param[in] h ID of an input graph that has been added to the environment.

  321.     * @return Node map computed by the last call to run_method() with arguments @p g and @p h.

  322.     */

  323.     std::vector<std::pair<std::size_t, std::size_t>> getNodeMap(std::size_t g, std::size_t h);

  324. 

  325.     /*!

  326.     * @brief Returns assignment matrix between the input graphs. This function duplicates datas. 

  327.     * @param[in] g ID of an input graph that has been added to the environment.

  328.     * @param[in] h ID of an input graph that has been added to the environment.

  329.     * @return Assignment matrix computed by the last call to run_method() with arguments @p g and @p h.

  330.     */

  331.     std::vector<std::vector<int>> getAssignmentMatrix(std::size_t g, std::size_t h);

  332. 

  333.     /*!

  334.     * @brief  Returns a vector which contains the forward and the backward maps between nodes of the two indicated graphs. 

  335.     * @param[in] g ID of an input graph that has been added to the environment.

  336.     * @param[in] h ID of an input graph that has been added to the environment.

  337.     * @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.

  338.     */

  339.     std::vector<std::vector<unsigned long int>> getAllMap(std::size_t g, std::size_t h);

  340. 

  341.     /*!

  342.     * @brief Returns runtime.

  343.     * @param[in] g ID of an input graph that has been added to the environment.

  344.     * @param[in] h ID of an input graph that has been added to the environment.

  345.     * @return Runtime of last call to run_method() with arguments @p g and @p h.

  346.     */

  347.     double getRuntime(std::size_t g, std::size_t h) const;

  348. 

  349.     /*!

  350.     * @brief Checks if the edit costs are quasimetric.

  351.     * @return Boolean @p true if the edit costs are quasimetric and @p false, otherwise.

  352.     */

  353.     bool quasimetricCosts() const;

  354. 

  355.     /*!

  356.     * @brief Applies the hungarian algorithm (LSAP) to a matrix cost.

  357.     * @param[in] matrixCost The matrix cost.

  358.     * @return the values of rho, varrho, u and v, in this order.

  359.     */

  360.     std::vector<std::vector<size_t>> hungarianLSAP(std::vector<std::vector<std::size_t>> matrixCost);

  361. 

  362.     /*!

  363.     * @brief Applies the hungarian algorithm (LSAPE) to a matrix cost.

  364.     * @param[in] matrixCost The matrix cost.

  365.     * @return the values of rho, varrho, u and v, in this order.

  366.     */

  367.     std::vector<std::vector<double>> hungarianLSAPE(std::vector<std::vector<double>> matrixCost);

  368. 

  369.     /*!

  370. 	 * @brief Returns the number of node labels.

  371. 	 * @return Number of pairwise different node labels contained in the environment.

  372. 	 * @note If @p 1 is returned, the nodes are unlabeled.

  373. 	 */

  374. 	std::size_t getNumNodeLabels() const;

  375. 

  376.     /*!

  377. 	 * @brief Returns node label.

  378. 	 * @param[in] label_id ID of node label that should be returned. Must be between 1 and num_node_labels().

  379. 	 * @return Node label for selected label ID.

  380. 	 */

  381. 	std::map<std::string, std::string> getNodeLabel(std::size_t label_id) const;

  382. 

  383.     /*!

  384. 	 * @brief Returns the number of edge labels.

  385. 	 * @return Number of pairwise different edge labels contained in the environment.

  386. 	 * @note If @p 1 is returned, the edges are unlabeled.

  387. 	 */

  388. 	std::size_t getNumEdgeLabels() const;

  389. 

  390. 	/*!

  391. 	 * @brief Returns edge label.

  392. 	 * @param[in] label_id ID of edge label that should be returned. Must be between 1 and num_node_labels().

  393. 	 * @return Edge label for selected label ID.

  394. 	 */

  395. 	std::map<std::string, std::string> getEdgeLabel(std::size_t label_id) const;

  396. 

  397. 	// /*!

  398. 	//  * @brief Returns the number of nodes.

  399. 	//  * @param[in] graph_id ID of an input graph that has been added to the environment.

  400. 	//  * @return Number of nodes in the graph.

  401. 	//  */

  402. 	// std::size_t getNumNodes(std::size_t graph_id) const;

  403. 

  404. 	/*!

  405. 	 * @brief Returns average number of nodes.

  406. 	 * @return Average number of nodes of the graphs contained in the environment.

  407. 	 */

  408. 	double getAvgNumNodes() const;

  409. 

  410.     /*!

  411. 	 * @brief Returns node relabeling cost.

  412. 	 * @param[in] node_label_1 First node label.

  413. 	 * @param[in] node_label_2 Second node label.

  414. 	 * @return Node relabeling cost for the given node labels.

  415. 	 */

  416. 	double getNodeRelCost(const std::map<std::string, std::string> & node_label_1, const std::map<std::string, std::string> & node_label_2) const;

  417. 

  418. 	/*!

  419. 	 * @brief Returns node deletion cost.

  420. 	 * @param[in] node_label Node label.

  421. 	 * @return Cost of deleting node with given label.

  422. 	 */

  423. 	double getNodeDelCost(const std::map<std::string, std::string> & node_label) const;

  424. 

  425. 	/*!

  426. 	 * @brief Returns node insertion cost.

  427. 	 * @param[in] node_label Node label.

  428. 	 * @return Cost of inserting node with given label.

  429. 	 */

  430. 	double getNodeInsCost(const std::map<std::string, std::string> & node_label) const;

  431. 

  432. 	/*!

  433. 	 * @brief Computes median node label.

  434. 	 * @param[in] node_labels The node labels whose median should be computed.

  435. 	 * @return Median of the given node labels.

  436. 	 */

  437. 	std::map<std::string, std::string> getMedianNodeLabel(const std::vector<std::map<std::string, std::string>> & node_labels) const;

  438. 

  439. 	/*!

  440. 	 * @brief Returns edge relabeling cost.

  441. 	 * @param[in] edge_label_1 First edge label.

  442. 	 * @param[in] edge_label_2 Second edge label.

  443. 	 * @return Edge relabeling cost for the given edge labels.

  444. 	 */

  445. 	double getEdgeRelCost(const std::map<std::string, std::string> & edge_label_1, const std::map<std::string, std::string> & edge_label_2) const;

  446. 

  447. 	/*!

  448. 	 * @brief Returns edge deletion cost.

  449. 	 * @param[in] edge_label Edge label.

  450. 	 * @return Cost of deleting edge with given label.

  451. 	 */

  452. 	double getEdgeDelCost(const std::map<std::string, std::string> & edge_label) const;

  453. 

  454. 	/*!

  455. 	 * @brief Returns edge insertion cost.

  456. 	 * @param[in] edge_label Edge label.

  457. 	 * @return Cost of inserting edge with given label.

  458. 	 */

  459. 	double getEdgeInsCost(const std::map<std::string, std::string> & edge_label) const;

  460. 

  461. 	/*!

  462. 	 * @brief Computes median edge label.

  463. 	 * @param[in] edge_labels The edge labels whose median should be computed.

  464. 	 * @return Median of the given edge labels.

  465. 	 */

  466. 	std::map<std::string, std::string> getMedianEdgeLabel(const std::vector<std::map<std::string, std::string>> & edge_labels) const;

  467. 

  468.     /*!

  469. 	 * @brief Returns the initialization type of the last initialization.

  470. 	 * @return Initialization type in string.

  471. 	 */

  472. 	std::string getInitType() const;

  473. 

  474.     /*!

  475. 	 * @brief Computes the edit cost between two graphs induced by a node map.

  476. 	 * @param[in] g_id ID of input graph.

  477. 	 * @param[in] h_id ID of input graph.

  478.      * @return Computed induced cost.

  479. 	 */

  480. 	double computeInducedCost(std::size_t g_id, std::size_t h_id, std::vector<pair<std::size_t, std::size_t>> relation) const;

  481. 

  482.     // /*!

  483. 	//  * @brief Returns node relabeling, insertion, or deletion cost.

  484. 	//  * @param[in] label1 First node label.

  485. 	//  * @param[in] label2 Second node label.

  486. 	//  * @return Node relabeling cost if @p label1 and @p label2 are both different from ged::dummy_label(),

  487. 	//  * node insertion cost if @p label1 equals ged::dummy_label and @p label2 does not,

  488. 	//  * node deletion cost if @p label1 does not equal ged::dummy_label and @p label2 does,

  489. 	//  * and 0 otherwise.

  490. 	//  */

  491. 	// double getNodeCost(std::size_t label1, std::size_t label2) const;

  492. 

  493. 

  494. private:

  495. 

  496.     ged::GEDEnv<ged::GXLNodeID, ged::GXLLabel, ged::GXLLabel> * env_; // environment variable

  497. 

  498.     bool initialized; // initialization boolean (because env has one but not accessible)

  499. 

  500. };

  501. 

  502. }

  503. 

  504. #include "GedLibBind.ipp"

  505. 

  506. #endif /* SRC_GEDLIB_BIND_HPP */

  507. 

  508. 

  509. 

  510. 

  511. 

  512. 

  513. 

  514. 

  515. 

  516. 

  517. 

  518. // namespace shapes {

  519. //     class Rectangle {

  520. //         public:

  521. //             int x0, y0, x1, y1;

  522. //             Rectangle();

  523. //             Rectangle(int x0, int y0, int x1, int y1);

  524. //             ~Rectangle();

  525. //             int getArea();

  526. //             void getSize(int* width, int* height);

  527. //             void move(int dx, int dy);

  528. //     };

  529. // }