pd-code-to-diagram 0.0.1__tar.gz

pd_code_to_diagram-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 TopologicalKnotIndexer
+
+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.

pd_code_to_diagram-0.0.1/PKG-INFO

@@ -0,0 +1,49 @@
+Metadata-Version: 2.4
+Name: pd-code-to-diagram
+Version: 0.0.1
+Summary: calculate 2d-diagram from pd_code.
+License: MIT
+License-File: LICENSE
+Author: GGN_2015
+Author-email: neko@jlulug.org
+Requires-Python: >=3.10
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Dist: cpp-simple-interface
+Requires-Dist: pd-code-sanity
+Description-Content-Type: text/markdown
+
+## pd_code_to_diagram
+given a pd_code for a topological link or knot, output a possible 2d-diagram.
+
+## Install
+
+```bash
+pip install pd-code-to-diagram
+```
+
+## Usage
+```python
+import pd_code_to_diagram
+
+# pd_code is a list of list of int
+pd_code = [[6, 1, 7, 2], [14, 7, 15, 8], [4, 15, 1, 16], [10, 6, 11, 5], [8, 4, 9, 3], [18, 11, 19, 12], [20, 17, 5, 18], [12, 19, 13, 20], [16, 10, 17, 9], [2, 14, 3, 13]]
+
+# last_socket should be int or None
+#   the program will ensure in the components contains last_socket
+#   there will be at least one arc on the border of 
+last_socket = 1
+
+# diagram_2d will be a matrix of int
+#   its type will be list of list of int
+#   get_diagram_from_pd_code will raise an RuntimeError if such diagram not exists
+diagram_2d = pd_code_to_diagram.get_diagram_from_pd_code(pd_code, last_socket)
+for line in diagram_2d:
+    print(line)
+```
+

pd_code_to_diagram-0.0.1/README.md

@@ -0,0 +1,28 @@
+## pd_code_to_diagram
+given a pd_code for a topological link or knot, output a possible 2d-diagram.
+
+## Install
+
+```bash
+pip install pd-code-to-diagram
+```
+
+## Usage
+```python
+import pd_code_to_diagram
+
+# pd_code is a list of list of int
+pd_code = [[6, 1, 7, 2], [14, 7, 15, 8], [4, 15, 1, 16], [10, 6, 11, 5], [8, 4, 9, 3], [18, 11, 19, 12], [20, 17, 5, 18], [12, 19, 13, 20], [16, 10, 17, 9], [2, 14, 3, 13]]
+
+# last_socket should be int or None
+#   the program will ensure in the components contains last_socket
+#   there will be at least one arc on the border of 
+last_socket = 1
+
+# diagram_2d will be a matrix of int
+#   its type will be list of list of int
+#   get_diagram_from_pd_code will raise an RuntimeError if such diagram not exists
+diagram_2d = pd_code_to_diagram.get_diagram_from_pd_code(pd_code, last_socket)
+for line in diagram_2d:
+    print(line)
+```

pd_code_to_diagram-0.0.1/pd_code_to_diagram/__init__.py

@@ -0,0 +1,5 @@
+from .main import get_diagram_from_pd_code
+
+__all__ = [
+    "get_diagram_from_pd_code"
+]

pd_code_to_diagram-0.0.1/pd_code_to_diagram/cpp_src/BorderDetect/BFS/BfsAlgo.h

@@ -0,0 +1,74 @@
+#pragma once
+
+#ifndef DEBUG_BFS
+    #define DEBUG_BFS (0)
+#else
+    #undef DEBUG_BFS
+    #define DEBUG_BFS (1)
+#endif
+
+#include <queue>
+
+#include "../IntMatrix2/ZeroOneMatrix.h"
+#include "../IntMatrix2/BorderWrap.h"
+
+#include "../../Utils/MyAssert.h"
+#include "../../Utils/Debug.h"
+
+class BfsAlgo {
+public:
+
+    // 给定一个起始点，返回一个 0, 1 矩阵描述哪些位置可以走到
+    ZeroOneMatrix search(const ZeroOneMatrix& graph, int xpos, int ypos) const {
+        ASSERT(0 <= xpos && xpos < graph.getRcnt());
+        ASSERT(0 <= ypos && ypos < graph.getCcnt());
+
+        // 用一个 vis 数组记录每一个位置是否被访问过
+        auto vis = ZeroOneMatrix(graph.getRcnt(), graph.getCcnt());
+
+        // 1 表示障碍物，0 表示不是障碍物
+        // 在外围填充 1
+        auto new_graph = BorderWrap(1, 
+            std::make_shared<ZeroOneMatrix>(graph)); // 拷贝构造一个
+        ASSERT(graph.getPos(xpos, ypos) == 0); // 初始位置不能是障碍物
+
+        // BFS 队列
+        std::queue<std::tuple<int, int>> q;
+        q.push(std::make_tuple(xpos, ypos));
+        vis.setPos(xpos, ypos, 1);
+
+        const int dx[] = {1, -1, 0,  0};
+        const int dy[] = {0,  0, 1, -1};
+
+        while(!q.empty()) {
+            auto [x, y] = q.front(); q.pop();
+            SHOW_CERTAIN_DEBUG_MESSAGE(DEBUG_BFS, 
+                std::string("  - Checking Position (") 
+                    + std::to_string(x) + ", " + std::to_string(y) + ")");
+
+            for(int d = 0; d < 4; d += 1) {
+                int nx = x + dx[d];
+                int ny = y + dy[d];
+
+                // 在调试模式下输出访问到的位置
+                SHOW_CERTAIN_DEBUG_MESSAGE(DEBUG_BFS, 
+                    std::string("  - Checking Adj Position (") 
+                        + std::to_string(nx) + ", " + std::to_string(ny) + ")");
+
+                // 不需要访问已经访问过或者是障碍物的节点
+                // 这里必须先判断 new_graph.getPos(nx, ny) 因为 vis.getPos(nx, ny) 没有边界安全
+                if(new_graph.getPos(nx, ny) || vis.getPos(nx, ny)) {
+                    continue;
+                }
+
+                // 既不是障碍物，也没访问过，那就走过去
+                vis.setPos(nx, ny, 1);
+                q.push(std::make_tuple(nx, ny));
+            }
+        }
+
+        // 返回哪些位置能访问
+        SHOW_CERTAIN_DEBUG_MESSAGE(DEBUG_BFS, "BFS Finished");
+        return vis;
+    }
+};

pd_code_to_diagram-0.0.1/pd_code_to_diagram/cpp_src/BorderDetect/BorderDetect.h

@@ -0,0 +1,130 @@
+#pragma once
+
+#ifndef DEBUG_BORDER_DETECT
+    #define DEBUG_BORDER_DETECT (0)
+#else
+    #undef DEBUG_BORDER_DETECT
+    #define DEBUG_BORDER_DETECT (1)
+#endif
+
+#include <set>
+
+#include "BFS/BfsAlgo.h"
+#include "DataInput/FileDataInput.h"
+#include "Graph/ConnectedComponents.h"
+#include "Graph/DiagramGraph.h"
+#include "IntMatrix2/BorderMask.h"
+#include "IntMatrix2/ZeroOneMatrix.h"
+
+#include "../Utils/MyAssert.h"
+#include "../Utils/Debug.h"
+
+class BorderDetect {
+private:
+    // 计算两个集合的交集
+    std::set<int> intersect(std::set<int> a, std::set<int> b) const {
+        std::set<int> ans;
+        for(auto item: a) {
+            if(b.find(item) != b.end()) {
+                ans.insert(item);
+            }
+        }
+        return ans;
+    }
+
+public:
+
+    // 获取所有联通分支
+    virtual std::vector<std::set<int>> getAllCc(const IntMatrix2& imx) const {
+        auto dg = DiagramGraph(imx);
+        auto cc_alg = ConnectedComponents(dg);
+        auto all_cc = cc_alg.getConnectedComponents();
+        return all_cc;
+    }
+
+    // 输出所有连通分支到一个 json 字符串
+    virtual std::string jsonifyAllCc(const std::vector<std::set<int>>& all_cc) const {
+        std::string json_string;
+
+        bool first_line = true;
+        json_string += "[\n";
+        for(const auto& cc: all_cc) {
+            if(first_line) {
+                first_line = false;
+            }else {
+                json_string += ",\n";
+            }
+            bool first = true;
+            for(const auto& item: cc) {
+                if(first) {
+                    first = false;
+                    json_string += "    [";
+                }else {
+                    json_string += ", ";
+                }
+                json_string += std::to_string(item);
+            }
+            json_string += "]";
+        }
+        json_string += "\n]\n";
+        return json_string;
+    }
+
+    // 检查最大编号所在的连通分支是否在边界上
+    // 这里的 IntMatrix 是一个二维的 int 矩阵
+    // 你需要保证最外围的一圈元素都是零（空地）
+    // last_socket_id = -1 则要求最大编号 socket 所在连通分支在最外圈
+    // last_socket_id > 0 则要求 last_socket_id 所在连通分支在最外圈
+    virtual bool checkBorderMaxCC(int last_socket_id, const IntMatrix2& imx) const {
+
+        // 获取整个矩阵中的最大元素
+        auto mxv = imx.getMax(); 
+        ASSERT(mxv > 0);
+
+        int lastv = mxv;
+        if(last_socket_id > 0) {
+            lastv = last_socket_id;
+        }
+
+        // 将所有非零位置设置为 1
+        auto mmx = ZeroOneMatrix(imx);
+
+        // 从左上角位置出发，遍历所有能走的空白位置
+        // 1 是障碍物，0 是可通行位置
+        SHOW_CERTAIN_DEBUG_MESSAGE(DEBUG_BORDER_DETECT, "Solving BFS");
+        BfsAlgo bfs_algo;
+        auto vis_mx = bfs_algo.search(mmx, 0, 0);
+
+        // 检索 0 区域的边界位置
+        SHOW_CERTAIN_DEBUG_MESSAGE(DEBUG_BORDER_DETECT, "Solving Border");
+        auto border_pos_raw = BorderMask(std::make_shared<ZeroOneMatrix>(vis_mx), 0);
+        auto border_pos     = ZeroOneMatrix(border_pos_raw);
+
+        // 在原始数据矩阵中进行筛选
+        // 筛选出所有在边界上的节点
+        auto set_int = border_pos.select(imx);
+
+        // 计算原图中的所有联通分支
+        // all_cc 包含了所有的 connected component 对应的 std::set<int>
+        SHOW_CERTAIN_DEBUG_MESSAGE(DEBUG_BORDER_DETECT, "Solving Connected Component");
+        auto dg = DiagramGraph(imx);
+        auto cc_alg = ConnectedComponents(dg);
+        auto all_cc = cc_alg.getConnectedComponents();
+
+        // 找到最后编号对应的连通分量
+        auto lastv_cc = std::set<int>();
+        for(const auto& cc: all_cc) {
+            if(cc.find(lastv) != cc.end()) {
+                lastv_cc = cc;
+            }
+        }
+
+        // 检查最大联通分支是否是独立在外的
+        // 如果最大联通分支是独立在外的，那么我们的算法
+        // 能够保证一个连通分支在最外侧，因此大概率说明不改变 pdcode 也可以做联通和
+        // 但是这一点需要进一步进行验证
+        // 具体做法就是对所有 link 考虑将其所有联通分支 swap 成最大编号联通分支并生成扭结
+        SHOW_CERTAIN_DEBUG_MESSAGE(DEBUG_BORDER_DETECT, "Checking Cover");
+        return intersect(lastv_cc, set_int).size() != 0;
+    }
+};

pd_code_to_diagram-0.0.1/pd_code_to_diagram/cpp_src/BorderDetect/DataInput/AbstractDataInput.h

@@ -0,0 +1,10 @@
+#pragma once
+
+#include <iostream>
+#include "../IntMatrix2/IntMatrix2.h"
+
+class AbstractDataInput {
+public:
+    virtual ~AbstractDataInput(){}
+    virtual IntMatrix2 loadMatrix(std::istream& in) const = 0;
+};

pd_code_to_diagram-0.0.1/pd_code_to_diagram/cpp_src/BorderDetect/DataInput/FileDataInput.h

@@ -0,0 +1,104 @@
+#pragma once
+
+#include <algorithm> // 用于std::remove_if
+#include <cctype>    // 用于std::isspace
+#include <fstream>
+#include <iostream>
+#include <sstream>
+#include <string>
+#include <utility>  // 用于std::pair
+#include <vector>
+
+#include "AbstractDataInput.h"
+#include "../../Utils/MyAssert.h"
+
+class FileDataInput: public AbstractDataInput{
+private:
+
+    // 辅助函数：去除字符串首尾的空白字符（空格、制表符、换行等）
+    std::string trim(const std::string& str) const {
+        // 找到第一个非空白字符的位置
+        auto start = str.find_first_not_of(" \t\n\r\f\v");
+        if (start == std::string::npos) {
+            return ""; // 全是空白字符，返回空字符串
+        }
+        // 找到最后一个非空白字符的位置
+        auto end = str.find_last_not_of(" \t\n\r\f\v");
+        return str.substr(start, end - start + 1);
+    }
+
+    // 核心函数：统计非空行数量，并存储非空行到vector
+    // 返回值：pair<非空行数量, 存储非空行的vector>
+    std::pair<int, std::vector<std::string>> count_non_empty_lines(std::istream& is) const {
+        std::vector<std::string> non_empty_lines;
+        std::string line;
+        int count = 0;
+
+        // 逐行读取输入流，直到流结束
+        while (std::getline(is, line)) {
+            // 去除首尾空白后判断是否为非空行
+            std::string trimmed_line = trim(line);
+            if (!trimmed_line.empty()) {
+                non_empty_lines.push_back(line); // 存储原始行（而非去除空白后的行）
+                count++;
+            }
+        }
+
+        // 检查流是否正常结束（处理读取过程中的错误）
+        if (is.bad()) {
+            throw std::runtime_error("读取输入流时发生严重错误！");
+        }
+
+        return {count, non_empty_lines};
+    }
+
+    /**
+     * @brief 统计一行字符串中按空白字符切分的非空白段数量
+     * @param line 输入的一行字符串（std::string）
+     * @return 非空白段的数量（int）
+     * @note 空白字符包括：空格、制表符(\t)、换行(\n)、回车(\r)等，连续空白只算一个分隔
+     */
+    int count_non_blank_segments(const std::string& line) const {
+        int count = 0;          // 非空白段计数
+        bool in_segment = false; // 标记是否处于非空白段中
+
+        // 遍历字符串的每个字符
+        for (char c : line) {
+            // 判断当前字符是否为空白字符
+            if (std::isspace(static_cast<unsigned char>(c))) {
+                // 空白字符：退出非空白段
+                in_segment = false;
+            } else {
+                // 非空白字符：如果未处于段中，计数+1并标记进入段
+                if (!in_segment) {
+                    count++;
+                    in_segment = true;
+                }
+                // 已处于段中，无需处理（连续非空白字符属于同一段）
+            }
+        }
+
+        return count;
+    }
+
+public:
+    virtual ~FileDataInput() {}
+    virtual IntMatrix2 loadMatrix(std::istream& in) const override {
+        auto [row_cnt, vec] = count_non_empty_lines(in);
+        ASSERT(row_cnt > 0);
+
+        auto col_cnt = count_non_blank_segments(vec[0]);
+        auto int_matrix = IntMatrix2(row_cnt, col_cnt);
+
+        for(int i = 0; i < row_cnt; i += 1) {
+            std::stringstream ss;
+            ss << vec[i];
+            for(int j = 0; j < col_cnt; j += 1) {
+                int v; ss >> v;
+                int_matrix.setPos(i, j, v);
+            }
+        }
+
+        return int_matrix;
+    }
+};

pd_code_to_diagram-0.0.1/pd_code_to_diagram/cpp_src/BorderDetect/Graph/AbstractGraph.h

@@ -0,0 +1,20 @@
+#pragma once
+
+#include <set>
+#include <vector>
+
+// 一个只读的抽象图
+class AbstractGraph {
+public:
+    virtual ~AbstractGraph() {}
+
+    // 获取最大节点编号
+    // 节点编号大于等于 1
+    virtual int getMaxNodeId() const = 0;
+
+    // 判断某个节点编号是否存在
+    virtual bool checkHasNode(int nodeId) const = 0;
+
+    // 找到某个节点下一步能走到的所有节点
+    virtual std::vector<int> getNextNode(int nodeId) const = 0;
+};

pd_code_to_diagram-0.0.1/pd_code_to_diagram/cpp_src/BorderDetect/Graph/ConnectedComponents.h

@@ -0,0 +1,74 @@
+#pragma once
+
+#include <iostream>
+
+#include <algorithm>
+#include <cstdlib>
+#include <memory>
+#include "AbstractGraph.h"
+
+// 给定一个图计算所有联通分量
+class ConnectedComponents {
+protected:
+    int* fa; // union find set
+    int maxNodeId = 0;
+
+    int find(int x) {
+        if(x == fa[x]) return x;
+        return fa[x] = find(fa[x]);
+    }
+
+    void link(int x, int y) {
+        int rx = find(x);
+        int ry = find(y);
+        if(rx != ry) {
+            if(rand() & 1) std::swap(rx, ry);
+            fa[rx] = ry;
+        }
+    }
+
+    // 计算整个图的所有连通分支
+    void construct_all(const AbstractGraph& ag) {
+        for(int i = 1; i <= ag.getMaxNodeId(); i += 1) {
+            for(auto nxt: ag.getNextNode(i)) {
+                link(i, nxt);
+            }
+        }
+    }
+
+public:
+    virtual ~ConnectedComponents() {
+        delete[] fa;
+    }
+    ConnectedComponents(const AbstractGraph& ag): maxNodeId(ag.getMaxNodeId()) {
+        fa = new int[ag.getMaxNodeId() + 1];
+        for(int i = 1; i <= ag.getMaxNodeId(); i += 1) {
+            fa[i] = i;
+        }
+        construct_all(ag);
+    }
+
+    virtual std::vector<std::set<int>> getConnectedComponents() {
+
+        // 初始化集合
+        auto ans = std::vector<std::set<int>>();
+        while((int)ans.size() - 1 < maxNodeId) {
+            ans.push_back(std::set<int>());
+        }
+
+        // 枚举所有对象，加入对应的等价类
+        for(int i = 1; i <= maxNodeId; i += 1) {
+            int root_i = find(i);
+            ans[root_i].insert(i);
+        }
+
+        // 将所有非空对象整理出来
+        auto non_empty = std::vector<std::set<int>>();
+        for(int i = 1; i <= maxNodeId; i += 1) {
+            if(ans[i].size() > 0) {
+                non_empty.push_back(ans[i]);
+            }
+        }
+        return non_empty;
+    }
+};

pd_code_to_diagram-0.0.1/pd_code_to_diagram/cpp_src/BorderDetect/Graph/DiagramGraph.h

@@ -0,0 +1,50 @@
+#pragma once
+
+#include <memory>
+
+#include "AbstractGraph.h"
+#include "Graph.h"
+#include "../IntMatrix2/AbstractIntMatrix2.h"
+#include "../../Utils/MyAssert.h"
+
+class DiagramGraph: public AbstractGraph {
+private:
+    Graph graph;
+
+public:
+    virtual ~DiagramGraph() {}
+    DiagramGraph(const AbstractIntMatrix2& aim): graph() {
+        const int dx[] = {0, -1,  0, 1};
+        const int dy[] = {1,  0, -1, 0};
+        for(int i = 1; i < aim.getRcnt() - 1; i += 1) {
+            for(int j = 1; j < aim.getCcnt() - 1; j += 1) {
+                if(aim.getPos(i, j) < 0) {
+                    int arr[4];
+                    for(int d = 0; d < 4; d += 1) {
+                        arr[d] = aim.getPos(i + dx[d], j + dy[d]);
+                        ASSERT(arr[d] > 0);
+                        graph.setMaxNodeId(d);
+                    }
+                    graph.addEdge(arr[0], arr[2]); // 对边添加
+                    graph.addEdge(arr[1], arr[3]);
+                }
+            }
+        }
+    }
+    
+    // 获取最大节点编号
+    // 节点编号大于等于 1
+    virtual int getMaxNodeId() const override {
+        return graph.getMaxNodeId();
+    }
+
+    // 判断某个节点编号是否存在
+    virtual bool checkHasNode(int nodeId) const override {
+        return 1 <= nodeId && nodeId <= graph.getMaxNodeId();
+    }
+
+    // 找到某个节点下一步能走到的所有节点
+    virtual std::vector<int> getNextNode(int nodeId) const {
+        return graph.getNextNode(nodeId);
+    }
+};

pd_code_to_diagram-0.0.1/pd_code_to_diagram/cpp_src/BorderDetect/Graph/Graph.h

@@ -0,0 +1,56 @@
+#pragma once
+
+#include "AbstractGraph.h"
+#include "../../Utils/MyAssert.h"
+
+class Graph: public AbstractGraph {
+protected:
+    int maxNodeId;
+    std::vector<std::vector<int>> nextNode; // 邻接表
+
+public:
+    virtual ~Graph() {}
+
+    Graph(): maxNodeId(0) {
+        nextNode.push_back(std::vector<int>());
+    }
+    Graph(int _maxNodeCnt): maxNodeId(0) {
+        nextNode.push_back(std::vector<int>());
+        setMaxNodeId(_maxNodeCnt);
+    }
+    
+    // 获取最大节点编号
+    // 节点编号大于等于 1
+    virtual int getMaxNodeId() const override {
+        return maxNodeId;
+    }
+
+    // 判断某个节点编号是否存在
+    virtual bool checkHasNode(int nodeId) const override {
+        return 1 <= nodeId && nodeId <= maxNodeId;
+    }
+
+    // 提高最大节点编号
+    virtual void setMaxNodeId(int newMaxNodeId) {
+        while(maxNodeId < newMaxNodeId) {
+            maxNodeId += 1;
+            nextNode.push_back({}); // 空序列
+        }
+    }
+
+    // 新增一个双向边
+    virtual void addEdge(int f, int t) {
+        setMaxNodeId(f);
+        setMaxNodeId(t);
+        ASSERT(checkHasNode(f)); // 排除小于零的情况
+        ASSERT(checkHasNode(t));
+        nextNode[f].push_back(t); // 双向加边
+        nextNode[t].push_back(f);
+    }
+
+    // 找到某个节点下一步能走到的所有节点
+    virtual std::vector<int> getNextNode(int nodeId) const override {
+        ASSERT(checkHasNode(nodeId));
+        return nextNode[nodeId];
+    }
+};

pd_code_to_diagram-0.0.1/pd_code_to_diagram/cpp_src/BorderDetect/IntCombine/AbstractIntCombine.h

@@ -0,0 +1,7 @@
+#pragma once
+
+class AbstractIntCombine {
+public:
+    virtual ~AbstractIntCombine() {}
+    virtual int combineInt(int xpos, int ypos, int lhs_val, int rhs_val) const = 0;
+};

pd_code_to_diagram-0.0.1/pd_code_to_diagram/cpp_src/BorderDetect/IntMap/AbstractIntMap.h

@@ -0,0 +1,7 @@
+#pragma once
+
+class AbstractIntMap {
+public:
+    virtual ~AbstractIntMap() {}
+    virtual int mapInt(int xpos, int ypos, int vFrom) const = 0;
+};

pd_code_to_diagram-0.0.1/pd_code_to_diagram/cpp_src/BorderDetect/IntMap/NotIntMap.h

@@ -0,0 +1,12 @@
+#pragma once
+
+#include "AbstractIntMap.h"
+
+// 
+class NotIntMap: public AbstractIntMap {
+public:
+    virtual ~NotIntMap() {}
+    virtual int mapInt(int xpos, int ypos, int vFrom) const override {
+        return vFrom == 0;
+    }
+};