def getN(self, E):
result = set()
for (x1, x2) in E:
un = x1.extent.union(x2.extent)
toadd = Concept(self.arrowUp(un), self.arrowDown(self.arrowUp(un)))
result.add(toadd)
return result
def RSALG(self):
C = set()
D = set()
for x in self.X:
elem = Concept(self.arrowUp([x]),
self.arrowDown(self.arrowUp([x])))
C.add(elem)
D.add(elem)
print("uvodna dlzka C:", len(C))
print("uvodna dlzka D:", len(D))
print([str(c) for c in C])
i = 0
while (len(D) > 1):
i += 1
print("iteracia: ", i)
m = self.getMin(D)
print("min: ", m)
E = self.getE(D, m)
print("E: ", [(str(c), str(c2)) for (c, c2) in E])
V = self.getV(D, E)
print("V: ", [str(c) for c in V])
N = self.getN(E)
print("N: ", [str(c) for c in N])
D = D.difference(V).union(N)
print("dlzka D:", len(D))
C = C.union(N)
print("dlzka C:", len(C))
return C
def __init__(self):
"""
Initial function
Generate the ontology.
"""
"""
private members:
1. concepts ----> concept list(elements are Concept object)
2. __record ----> record list(elements are tuple)
3. Root --------> Root node of the whole tree
"""
self.concepts = []
self.__record = []
self.Root = Concept('0', None)
self.nfg, self.fg = self.__read()
self.token = 0
self.token_1 = 0
self.back_point = 0
for concept in self.nfg:
self.flag = True
self.__search_sub_concept(concept)
for concept in self.concepts:
if concept.ancestor == None:
self.__link(self.Root, concept)
self.concepts.append(self.Root)
self.__record.append(('0',None))
def __search_sub_concept_in_fg(self, length_fg, cid, concept, ancestor):
while True:
self.__correct_token(concept)
if self.token >= length_fg:
self.token = self.back_point
break
next = self.fg[self.token]
next_cid = self.__extract_code(next)
if (len(cid) == 3 and len(next_cid) == 4 and cid == next_cid[0:3]) \
or (len(cid) == 4 and len(next_cid) == 5 and cid == next_cid[0:4]):
descendant = Concept(next[0], next[1])
self.concepts.append(descendant)
self.__record.append(next)
self.__link(ancestor, descendant)
self.token += 1
elif (len(cid) == 3 and len(next_cid) == 5 and cid == next_cid[0:3]):
if self.flag == True:
self.back_point = self.token
self.flag = False
self.token += 1
continue
else:
if self.flag == False:
self.token = self.back_point
break
def match_lexicon(self,token):
concept_list = []
for concept in self.lexicon:
if token.content.lower() in concept.keywords.split(","):
tmp = Concept(concept,token)
if tmp.type==1:
for num in range(token.quant):
concept_list.append(copy.copy(tmp))
else:
concept_list.append(tmp)
return concept_list
def __correct_token(self, concept):
"""
For several cases, there exist dislocation of token.
This function is used for token correction
:param concept:
:param token:
:return token:
"""
length_fg = len(self.fg)
cid = self.__extract_code(concept)
while True:
if self.token >= length_fg:
break
next = self.fg[self.token]
next_cid = self.__extract_code(next)
if (len(cid) == 4 and len(next_cid) == 4 and cid[0:3] == next_cid[0:3]): # sibling nodes
if next_cid[0] == 'E' and len(next_cid) == 4:
a = Concept(next[0], next[1])
self.concepts.append(a)
self.__record.append(next)
self.__link(self.Root, a)
self.token += 1
elif (len(cid) == 3 and len(next_cid) == 4 and cid > next_cid[0:3]): # previous concepts
self.token += 1
elif len(next_cid) == 3: # fine-grained concept but has no parents except for root
a = Concept(next[0], next[1])
self.concepts.append(a)
self.__record.append(next)
self.__link(self.Root, a)
self.token += 1
elif next_cid[0] == 'E' and len(next_cid) == 4: # fine-grained concept begun with E but has no parents
a = Concept(next[0], next[1])
self.concepts.append(a)
self.__record.append(next)
self.__link(self.Root, a)
self.token += 1
else:
break
def __search_sub_concept_in_nfg(self, length_nfg, cid, ancestor):
while True:
self.token_1 += 1
if self.token_1 >= length_nfg:
break
next = self.nfg[self.token_1]
next_cid = self.__extract_code(next)
if cid == next_cid[0:3]:
descendant = Concept(next[0], next[1])
self.concepts.append(descendant)
self.__record.append(next)
self.__link(ancestor, descendant)
else:
break
def __duplicate_judge(self, concept):
"""
Check if the concept has been in the list of record
:param concept:
:return ancestor:
"""
if concept not in self.__record:
# if not record, then record it
ancestor = Concept(concept[0], concept[1])
self.concepts.append(ancestor)
self.__record.append(concept)
else:
# record, then return it
ancestor = [obj for obj in self.concepts if obj.cid == concept[0]]
ancestor = ancestor[0]
return ancestor
def index():
c = Concept()
return render_template("index.html", inspiration=c.conceptualize())
def concept_route(subject, descriptor, setting):
print subject, descriptor, setting
c = Concept([subject, descriptor, setting])
return render_template("index.html", inspiration=c.conceptualize())
def index():
c = Concept()
return render_template("index.html", inspiration=c.conceptualize())
def concept_route(subject, descriptor, setting):
print subject, descriptor, setting
c = Concept([subject, descriptor, setting])
return render_template("index.html", inspiration=c.conceptualize())
