motion-spec/count.py at main · secorolab/motion-spec · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
# SPDX-License-Identifier: MPL-2.0
import sys
import os
import json
import numpy as np
import rdflib
from namespace import APP

class Table:
    def __init__(self):
        self.data = {}
        self.rows = set()
        self.columns = set()

    def _extend_rows(self, row):
        if row in self.rows:
            return

        self.data[row] = {}
        for column in self.columns:
            self.data[row][column] = None

        self.rows.add(row)

    def _extend_columns(self, column):
        if column in self.columns:
            return

        for row in self.rows:
            self.data[row][column] = None

        self.columns.add(column)

    def insert(self, row, column, entry):
        self._extend_rows(row)
        self._extend_columns(column)
        self.data[row][column] = entry

    def to_list(self):
        rows = list(self.rows)
        rows.sort()
        columns = list(self.columns)
        columns.sort()

        r = []
        for row in rows:
            c = []
            for column in columns:
                c.append(self.data[row][column])
            r.append(c)

        return r

    def row_names(self):
        rows = list(self.rows)
        rows.sort()
        return rows

    def column_names(self):
        columns = list(self.columns)
        columns.sort()
        return columns

    def __repr__(self):
        rows = list(self.rows)
        rows.sort()
        columns = list(self.columns)
        columns.sort()
        sep = "\t"
        lf = "\n"

        s = sep
        for column in columns:
            s += str(column) + sep
        s += lf

        for row in rows:
            s += str(row) + sep
            for column in columns:
                s += str(self.data[row][column]) + sep
            s += lf

        return s

def replace_by(arr, find, replace):
    arr[arr == find] = replace
    return arr


if __name__ == "__main__":
    if len(sys.argv) < 2:
        sys.exit(0)

    app_model = sys.argv[1]

    # Load top-level, application model
    g = rdflib.ConjunctiveGraph()
    g.parse(app_model, format="json-ld")

    # Handle the referenced models
    entities = Table()
    lines = Table()

    models = list(g.objects(predicate=APP["import"]))
    for model_path in models:
        split = model_path.split("/")
        folder = split[-2]
        file = split[-1]
        filename, _ = os.path.splitext(file)

        with open(os.path.join("models", folder, file)) as f:
            # Count the number of entities
            obj = json.load(f)["@graph"]
            num_entities = len(obj)

            # Count the number of lines
            serialized = json.dumps(obj, indent=4)
            num_lines = len(serialized.split("\n"))

        entities.insert(folder, filename, num_entities)
        lines.insert(folder, filename, num_lines)

    #                world-model
    #                |  constraints
    #                |  |  controllers
    #                |  |  |  maps
    #                |  |  |  |  solver-specification
    #                |  |  |  |  |
    acc = np.array([[0, 0, 0, 0, 0],    # 00-misc
                    [1, 0, 0, 0, 0],    # 01-world-model
                    [0, 0, 0, 1, 0],    # 02-map
                    [0, 1, 0, 0, 0],    # 03-constraints
                    [0, 1, 0, 0, 0],    # 04-motion-specification
                    [0, 0, 1, 0, 0],    # 05-constraint-handler
                    [0, 0, 0, 0, 1],    # 06-solver-specification
                    [0, 0, 0, 0, 1]])   # 07-scenario

    ent_name = entities.column_names()
    ent_np = replace_by(np.array(entities.to_list()), None, 0)
    ent_np = ent_np @ acc

    lin_name = lines.column_names()
    lin_np = replace_by(np.array(lines.to_list()), None, 0)
    lin_np = lin_np @ acc

    print("world-model, constraints, controllers, map, solver-specification")
    print("entities:", np.sum(ent_np, axis=0))
    print(ent_np)
    print("lines:", np.sum(lin_np, axis=0))
    print(lin_np)