def genDivideRelation(session, segment, operation, _result): el1 = math2sc.variables_sc[operation[0]] #divident el2 = math2sc.variables_sc[operation[1]] #divisor res = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE, "")[1] #difference result node sc_utils.createPair(session,core.Kernel.segment(), _result, res, sc.SC_CONST) setNode = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE, "")[1] sc_utils.createPair(session,core.Kernel.segment(), _result, setNode, sc.SC_CONST) #gen input sum parameters arc1 = sc_utils.createPair(session,core.Kernel.segment(), setNode, res, sc.SC_CONST) arc2 = sc_utils.createPair(session,core.Kernel.segment(), setNode, el2, sc.SC_CONST) sc_utils.createPair(session,core.Kernel.segment(), _result, arc1, sc.SC_CONST) sc_utils.createPair(session,core.Kernel.segment(), _result, arc2, sc.SC_CONST) relation = sc_utils.createPair(session,core.Kernel.segment(), setNode, el1, sc.SC_CONST) sc_utils.createPair(session,core.Kernel.segment(), _result, relation, sc.SC_CONST) idtf = "произведение*" idtf = sc_utils.utf8ToCp1251(str(idtf)) sumNode = sc_utils.getElementByIdtf(idtf, segment) if sumNode == None: sumNode = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE, idtf)[1] for param in [keynodes.info.stype_bin_orient_norole_rel]: sc_utils.createPairPosPerm(session, core.Kernel.segment(), param, sumNode, sc.SC_CONST) sc_utils.createPair(session,core.Kernel.segment(), _result, sumNode, sc.SC_CONST) relarc = sc_utils.createPair(session,core.Kernel.segment(), sumNode, relation, sc.SC_CONST) sc_utils.createPair(session,core.Kernel.segment(), _result, relarc, sc.SC_CONST) return res
def run_command(_params, _segment): # trying to find command node session = core.Kernel.session() segment = core.Kernel.segment() # getting answer sheaf node command_sheaf = session.search_one_shot(session.sc_constraint_new(sc_core.constants.CONSTR_5_f_a_a_a_f, keynodes.ui.init_user_cmd, sc_core.pm.SC_A_CONST, sc_core.pm.SC_N_CONST, sc_core.pm.SC_A_CONST, _params), True, 5) if command_sheaf is None: return # do nothing cmd = command_sheaf[2] # check if it's command to play commands sequence command = session.search_one_shot(session.sc_constraint_new(sc_core.constants.CONSTR_3_f_a_f, key_cmd_user_play, sc_core.pm.SC_A_CONST, cmd), True, 3) if command is None: return # do nothing command = session.search_one_shot(session.sc_constraint_new(sc_core.constants.CONSTR_3_f_a_a, cmd, sc_core.pm.SC_A_CONST, sc_core.pm.SC_N_CONST), True, 3) if command is None: return # do nothing cmd = command[2] import suit.core.sc_utils as sc_utils sc_utils.createPairPosPerm(session, segment, keynodes.ui.init_base_user_cmd, cmd, sc_core.pm.SC_CONST)
def translate_value(session, _segment, _value_node, _value): """Setup value \p _value to \p _value_node @return: Return list of creates sc-elements """ v_node = sc_utils.createNodeElement(session, _segment, sc.SC_CONST) bin_pair = sc_utils.createPairBinaryOrientFull(session, _segment, v_node, _value_node, sc.SC_CONST) a = sc_utils.createPairPosPerm(session, _segment, keynodes.common.nrel_value, bin_pair[0], sc.SC_CONST) res = [v_node, a, keynodes.common.nrel_value] res.extend(bin_pair) vu_node = sc_utils.createNodeElement(session, _segment, sc.SC_CONST) a = sc_utils.createPairPosPerm(session, _segment, v_node, vu_node, sc.SC_CONST) res.extend([vu_node, a]) # make identification idtf_node = sc_utils.createNodeSheaf(session, _segment, sc.SC_CONST) bin_pair = sc_utils.createPairBinaryOrientFull(session, _segment, idtf_node, vu_node, sc.SC_CONST) a = sc_utils.createPairPosPerm(session, _segment, keynodes.common.nrel_identification, bin_pair[0], sc.SC_CONST) res.extend([idtf_node, a, keynodes.common.nrel_identification]) res.extend(bin_pair) # set value val = sc_utils.createNodeElement(session, _segment, sc.SC_CONST) sc_utils.setContentReal(session, _segment, val, _value) a = sc_utils.createPairPosPerm(session, _segment, idtf_node, val, sc.SC_CONST) a1 = sc_utils.createPairPosPerm(session, _segment, keynodes.common.rrel_dec_number, a, sc.SC_CONST) res.extend([val, a, a1, keynodes.common.rrel_dec_number]) return res
def translate_value(_segment, _value_node, _value): session = core.Kernel.session() v_node = sc_utils.createNodeElement(session, _segment, sc.SC_CONST) sheaf = sc_utils.createPairBinaryOrient(session, _segment, v_node, _value_node, sc.SC_CONST) sc_utils.createPairPosPerm(session, _segment, keynodes.common.nrel_value, sheaf, sc.SC_CONST) vu_node = sc_utils.createNodeElement(session, _segment, sc.SC_CONST) a = sc_utils.createPairPosPerm(session, _segment, v_node, vu_node, sc.SC_CONST) sc_utils.createPairPosPerm(session, _segment, geom_keynodes.Relation.rrel_cm2, a, sc.SC_CONST) # make identification idtf_node = sc_utils.createNodeSheaf(session, _segment, sc.SC_CONST) sheaf = sc_utils.createPairBinaryOrient(session, _segment, idtf_node, vu_node, sc.SC_CONST) sc_utils.createPairPosPerm(session, _segment, keynodes.common.nrel_identification, sheaf, sc.SC_CONST) # set value val = sc_utils.createNodeElement(session, _segment, sc.SC_CONST) sc_utils.setContentReal(session, _segment, val, _value) a = sc_utils.createPairPosPerm(session, _segment, idtf_node, val, sc.SC_CONST) sc_utils.createPairPosPerm(session, _segment, keynodes.common.rrel_dec_number, a, sc.SC_CONST)
def translate_quadrangle(_segment, _object, _params): """Translates circle object to sc-memory """ _addr = _object._getScAddr() # include sc-element to points session = core.Kernel.session() addToSets(session, _segment, _addr, [ geom_keynodes.Objects.plane_quadrangle, keynodes.info.stype_ext_obj_abstract ]) sides = _object.getSides() for obj in sides: sheaf = sc_utils.createPairBinaryOrient(session, _segment, _addr, obj._getScAddr(), sc.SC_CONST) sc_utils.createPairPosPerm(session, _segment, geom_keynodes.Relation.nrel_side, sheaf, sc.SC_CONST) # build square relation #sq_node = sc_utils.createNodeElement(session, _segment, sc.SC_CONST) #sheaf = sc_utils.createPairBinaryOrient(session, _segment, _addr, sq_node, sc.SC_CONST) #sc_utils.createPairPosPerm(session, _segment, geom_keynodes.Relation.nrel_square, sheaf, sc.SC_CONST) return True
def genEqualityRelation(session, segment, operation, _result): el1 = math2sc.variables_sc[operation[0]] el2 = math2sc.variables_sc[operation[1]] setNode = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE, "")[1] sc_utils.createPair(session, core.Kernel.segment(), _result, setNode, sc.SC_CONST) arc1 = sc_utils.createPair(session, core.Kernel.segment(), setNode, el1, sc.SC_CONST) arc2 = sc_utils.createPair(session, core.Kernel.segment(), setNode, el2, sc.SC_CONST) sc_utils.createPair(session, core.Kernel.segment(), _result, arc1, sc.SC_CONST) sc_utils.createPair(session, core.Kernel.segment(), _result, arc2, sc.SC_CONST) idtf = "равенство*" idtf = sc_utils.utf8ToCp1251(str(idtf)) eqNode = sc_utils.getElementByIdtf(idtf, segment) if eqNode == None: eqNode = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE, idtf)[1] for param in [keynodes.info.stype_bin_orient_norole_rel]: sc_utils.createPairPosPerm(session, core.Kernel.segment(), param, eqNode, sc.SC_CONST) sc_utils.createPair(session, core.Kernel.segment(), _result, eqNode, sc.SC_CONST) relarc = sc_utils.createPair(session, core.Kernel.segment(), eqNode, setNode, sc.SC_CONST) sc_utils.createPair(session, core.Kernel.segment(), _result, relarc, sc.SC_CONST) return el1
def translate_circle(_segment, _object, _params): """Translates circle object to sc-memory """ _addr = _object._getScAddr() # include sc-element to points session = core.Kernel.session() addToSets(session, _segment, _addr, [geom_keynodes.Objects.circle, keynodes.info.stype_ext_obj_abstract]) # add relation to center point addr_begin = _object.center_point._getScAddr() if not sc_utils.checkOutBinaryPairAttr(session, _addr, geom_keynodes.Relation.nrel_center, sc.SC_CONST): a1 = sc_utils.createPairBinaryOrient(session, _segment, _addr, addr_begin, sc.SC_CONST) sc_utils.createPairPosPerm(session, _segment, geom_keynodes.Relation.nrel_center, a1, sc.SC_CONST) if not sc_utils.checkOutBinaryPairAttr(session, _addr, geom_keynodes.Relation.nrel_radius, sc.SC_CONST): radius_obj = _object.getRadiusObject() if radius_obj is not None: a1 = sc_utils.createPairBinaryOrient(session, _segment, _addr, radius_obj._getScAddr(), sc.SC_CONST) sc_utils.createPairPosPerm(session, _segment, geom_keynodes.Relation.nrel_radius, a1, sc.SC_CONST) # translate child points translateChildPoints(session, _segment, _object) # translate radius if it exist return True
def createWindowFromNode(_node, _format, _is_edit): """Creates sc.g-window from sc.g-node @param _node: node to create window from @type _node: ScgNode @param _format: sc-element that designate format for node content @type _format: sc_global_addr @param _is_edit: flag to create editor @type _is_edit: boolean @return: window object @rtype: objects.ObjectSheet """ assert type(_node) is scg_objects.SCgNode session = core.Kernel.session() segment = core.Kernel.segment() parent = _node.parent # creating sc-element that designate window el = _node._getScAddr() if el is not None: # FIXME: changing type for variable session.change_type(el, sc.SC_N_CONST) # else: # el = sc_utils.createNodeElement(session, segment, sc.SC_CONST) sheet = objects.ObjectSheet() if el is not None: sheet._setScAddr(el) sheet.hideContent() logic = None if _is_edit: logic = core.Kernel.getSingleton().createEditor(_format) else: logic = core.Kernel.getSingleton().createViewer(_format) # including window to formats set sc_utils.createPairPosPerm(session, segment, _format, el, sc.SC_CONST) sheet.setLogic(logic) parent.addChild(sheet) sheet.setPosition(_node.getPosition()) # FIXME: removing for old window types _node._relinkToObject(sheet) parent._deleteObject(_node) # need to remove if _format.this == keynodes.ui.format_scgx.this: import suit.core.layout.LayoutGroupForceDirected as layout sheet.setLayoutGroup(layout.LayoutGroupForceSimple()) # linking by relation with parent # sheaf = sc_utils.createPairBinaryOrient(session, segment, parent._getScAddr(), el, sc.SC_CONST) # sc_utils.createPairPosPerm(session, segment, keynodes.ui.nrel_child_window, sheaf, sc.SC_CONST) return sheet
def calculate_graph_prop(_params, _segment): kernel = core.Kernel.getSingleton() session = kernel.session() segment = kernel.segment() # check type question = session.search_one_shot(session.sc_constraint_new(sc_constants.CONSTR_5_f_a_a_a_f, keynodes.questions.initiated, sc.SC_A_CONST, sc.SC_N_CONST, sc.SC_A_CONST, _params), True, 5) assert question is not None question = question[2] global graph_prop_calculators for question_type, calculator, relation in graph_prop_calculators: # check command type if sc_utils.checkIncToSets(session, question, [question_type], sc.SC_CONST): graph = session.search_one_shot(session.sc_constraint_new(sc_constants.CONSTR_3_f_a_a, question, sc.SC_A_CONST, sc.SC_N_CONST), True, 3) if graph is None: return graph = graph[2] if not sc_utils.checkIncToSets(session, graph, [graph_keynodes.Common.graph], sc.SC_CONST): return g = Graph(segment, graph) g.makeNxGraph() result = calculator(g.graphNx) if result is None: raise RuntimeWarning("Calculator can't calculate value") value = sc_utils.createNodeElement(session, segment, sc.SC_CONST) bin_rel = sc_utils.createPairBinaryOrientFull(session, segment, graph, value, sc.SC_CONST) a = sc_utils.createPairPosPerm(session, segment, relation, bin_rel[0], sc.SC_CONST) elements = translate_value(session, segment, value, result) elements.extend([value, graph, a, relation]) elements.extend(bin_rel) answer = sc_utils.createNodeElement(session, segment, sc.SC_CONST) for el in elements: sc_utils.createPairPosPerm(session, segment, answer, el, sc.SC_CONST) sc_utils.makeAnswer(session, segment, question, answer)
def translate_line_sec(_segment, _object, _params): """Translates line section to sc-memory """ _addr = _object._getScAddr() session = core.Kernel.session() if not _addr: _addr = sc_utils.createNodeStruct(session, _segment, sc.SC_CONST) _object._setScAddr(_addr) addToSets(session, _segment, _addr, [geom_keynodes.Objects.line_sector, keynodes.info.stype_struct]) # end begin points addr_begin = _object.getBegin()._getScAddr() addr_end = _object.getEnd()._getScAddr() assert addr_begin and addr_end a1 = sc_utils.createPairBinaryOrient(session, _segment, _addr, addr_begin, sc.SC_CONST) sc_utils.createPairPosPerm(session, _segment, geom_keynodes.Relation.nrel_border_point, a1, sc.SC_CONST) a2 = sc_utils.createPairBinaryOrient(session, _segment, _addr, addr_end, sc.SC_CONST) sc_utils.createPairPosPerm(session, _segment, geom_keynodes.Relation.nrel_border_point, a2, sc.SC_CONST) # check if line have length and build it value # set value if it exists # if _object.getLength() is not None: # len_node = sc_utils.createNodeElement(session, _segment, sc.SC_CONST) # sheaf = sc_utils.createPairBinaryOrient(session, _segment, _addr, len_node, sc.SC_CONST) # sc_utils.createPairPosPerm(session, _segment, geom_keynodes.Relation.nrel_length, sheaf, sc.SC_CONST) # # len_val_node = sc_utils.createNodeElement(session, _segment, sc.SC_CONST) # sheaf = sc_utils.createPairBinaryOrient(session, _segment, len_val_node, len_node, sc.SC_CONST) # sc_utils.createPairPosPerm(session, _segment, keynodes.common.nrel_value, sheaf, sc.SC_CONST) # # len_val_cm_node = sc_utils.createNodeElement(session, _segment, sc.SC_CONST) # a = sc_utils.createPairPosPerm(session, _segment, len_val_node, len_val_cm_node, sc.SC_CONST) # sc_utils.createPairPosPerm(session, _segment, geom_keynodes.Relation.rrel_cm, a, sc.SC_CONST) # # idtf_node = sc_utils.createNodeSheaf(session, _segment, sc.SC_CONST) # sheaf = sc_utils.createPairBinaryOrient(session, _segment, idtf_node, len_val_cm_node, sc.SC_CONST) # sc_utils.createPairPosPerm(session, _segment, keynodes.common.nrel_identification, sheaf, sc.SC_CONST) # # dec_val_node = sc_utils.createNodeElement(session, _segment, sc.SC_CONST) # session.set_content_real(dec_val_node, _object.getLength()) # a = sc_utils.createPairPosPerm(session, _segment, idtf_node, dec_val_node, sc.SC_CONST) # sc_utils.createPairPosPerm(session, _segment, keynodes.common.rrel_dec_number, a, sc.SC_CONST) # translate child points translateChildPoints(session, _segment, _object) return True
def addToSets(_session, _segment, _addr, _sets): """Create positive pair between each element of \p _sets list and \p _addr """ for _set in _sets: if not sc_utils.checkIncToSets( _session, _addr, [_set], sc.SC_A_CONST | sc.SC_POS | sc.SC_PERMANENT): sc_utils.createPairPosPerm(_session, _segment, _set, _addr, sc.SC_CONST)
def genSumRelation(session, segment, operation, _result): """ @param session: session @param segment: list of segments to search objects in @param operation: sum operation and list of operands @param _result: a node which the result of translation @return: a node that represents the result of summ """ el1 = math2sc.variables_sc[operation[0]] el2 = math2sc.variables_sc[operation[1]] #gen set of sum components setNode = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE, "")[1] sc_utils.createPair(session, core.Kernel.segment(), _result, setNode, sc.SC_CONST) arc1 = sc_utils.createPair(session, core.Kernel.segment(), setNode, el1, sc.SC_CONST) arc2 = sc_utils.createPair(session, core.Kernel.segment(), setNode, el2, sc.SC_CONST) sc_utils.createPair(session, core.Kernel.segment(), _result, arc1, sc.SC_CONST) sc_utils.createPair(session, core.Kernel.segment(), _result, arc2, sc.SC_CONST) #gen sum relations res = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE, "")[1] #add result node sc_utils.createPair(session, core.Kernel.segment(), _result, res, sc.SC_CONST) relation = sc_utils.createPair(session, core.Kernel.segment(), setNode, res, sc.SC_CONST) sc_utils.createPair(session, core.Kernel.segment(), _result, relation, sc.SC_CONST) idtf = "сумма*" idtf = sc_utils.utf8ToCp1251(str(idtf)) sumNode = sc_utils.getElementByIdtf(idtf, segment) if sumNode == None: sumNode = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE, idtf)[1] for param in [keynodes.info.stype_bin_orient_norole_rel]: sc_utils.createPairPosPerm(session, core.Kernel.segment(), param, sumNode, sc.SC_CONST) sc_utils.createPair(session, core.Kernel.segment(), _result, sumNode, sc.SC_CONST) relarc = sc_utils.createPair(session, core.Kernel.segment(), sumNode, relation, sc.SC_CONST) sc_utils.createPair(session, core.Kernel.segment(), _result, relarc, sc.SC_CONST) return res
def buildUserAtomQuestion(sc_qustions, sc_q_objects): # узел вопроса q_node = sc_utils.createNodeElement(session, segment, sc.SC_CONST) # добавляем во множество вопрос session.gen3_f_a_f(segment, sc_key.questions.question, q_node, sc.SC_A_CONST | sc.SC_POS) # добавляем во множество атомарный вопрос session.gen3_f_a_f(segment, sc_key.questions.atom, q_node, sc.SC_A_CONST | sc.SC_POS) # добавляем типы вопросов for sc_q in sc_qustions: session.gen3_f_a_f(segment, sc_q, q_node, sc.SC_A_CONST | sc.SC_POS) # добавляем объекты вопроса for sc_o in sc_q_objects: session.gen3_f_a_f(segment, q_node, sc_o, sc.SC_A_CONST | sc.SC_POS) # добавляем автора (пользователь) authors_node = sc_utils.createNodeElement(session, segment, sc.SC_CONST) sc_utils.createPairPosPerm(session, segment, authors_node, sc_core.Kernel.getSingleton().getUserAddr(), sc.SC_CONST) authors_pair_sheaf = sc_utils.createPairBinaryOrient( session, segment, q_node, authors_node, sc.SC_CONST) sc_utils.createPairPosPerm(session, segment, sc_key.common.nrel_authors, authors_pair_sheaf, sc.SC_CONST) # добавляем окна для вывода output_node = sc_utils.createNodeElement(session, segment, sc.SC_CONST) output_count = 0 it = session.create_iterator( session.sc_constraint_new(sc_constants.CONSTR_3_f_a_a, sc_key.ui.set_output_windows, sc.SC_ARC, 0), True) while not it.is_over(): sc_utils.createPair(session, segment, output_node, it.value(2), session.get_type(it.value(1))) output_count += 1 it.next() if output_count == 0: sc_utils.createPairPosPerm(session, segment, output_node, kernel.getMainWindow()._getScAddr(), sc.SC_CONST) #sc_utils.copySet(session, sc_key.ui.set_output_windows, output_node, segment) # link output windows set to question output_sheaf = sc_utils.createPairBinaryOrient(session, segment, output_node, q_node, sc.SC_CONST) sc_utils.createPairPosPerm(session, segment, sc_key.ui.nrel_set_of_output_windows, output_sheaf, sc.SC_CONST) # initiate question sc_utils.createPairPosPerm(session, segment, sc_key.questions.initiated, q_node, sc.SC_CONST) return q_node
def translateChildPoints(_session, _segment, _object): """Translate points, that lies on \p _object """ assert isinstance(_object, geom_objects.GeometryAbstractObject) obj_addr = _object._getScAddr() assert obj_addr is not None for _point, _pos in _object.getPoints(): pt_addr = _point._getScAddr() assert pt_addr is not None if not sc_utils.checkIncToSets(_session, pt_addr, [obj_addr], sc.SC_A_CONST | sc.SC_POS | sc.SC_PERMANENT): sc_utils.createPairPosPerm(_session, _segment, obj_addr, pt_addr, sc.SC_CONST)
def gen_function(name, params, session, segment, _result): """ @param name: function name @param params: list of function params @param _result: an output node of the translator @return: """ #gen function node idtf = name + "*" idtf = sc_utils.utf8ToCp1251(str(idtf)) funcNode = sc_utils.getElementByIdtf(idtf, segment) if funcNode == None: funcNode = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE, idtf)[1] for param in [keynodes.info.stype_bin_orient_norole_rel]: sc_utils.createPairPosPerm(session, core.Kernel.segment(), param, funcNode, sc.SC_CONST) sc_utils.createPair(session, core.Kernel.segment(), _result, funcNode, sc.SC_CONST) #gen args set argsSet = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE, "")[1] sc_utils.createPair(session, core.Kernel.segment(), _result, argsSet, sc.SC_CONST) for x in params: param = math2sc.variables_sc[x] arc = sc_utils.createPair(session, core.Kernel.segment(), argsSet, param, sc.SC_CONST) sc_utils.createPair(session, core.Kernel.segment(), _result, param, sc.SC_CONST) sc_utils.createPair(session, core.Kernel.segment(), _result, arc, sc.SC_CONST) pass #gen relation arc result = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE, "")[1] relation = sc_utils.createPair(session, core.Kernel.segment(), argsSet, result, sc.SC_CONST) sc_utils.createPair(session, core.Kernel.segment(), _result, relation, sc.SC_CONST) arc = sc_utils.createPair(session, core.Kernel.segment(), funcNode, relation, sc.SC_CONST) sc_utils.createPair(session, core.Kernel.segment(), _result, arc, sc.SC_CONST) return result
def makeScGraph(self): """Construct sc representation of netwokX graph @return: Return sc_addr of structure, that include all elements of generated sc-graph construction """ assert self.graphSc is None assert self.graphNx is not None _session = core.Kernel.session() result = sc_utils.createNode(_session, self.segment, sc.SC_CONST, "element") self.graphSc = sc_utils.createNode(_session, self.segment, sc.SC_CONST, "struct") a = sc_utils.createPairPosPerm(_session, self.segment, graph_keynodes.Common.graph, self.graphSc, sc.SC_CONST) res_list = [self.graphSc, a] nx2sc = {} # create all nodes for node in self.graphNx.nodes(): sc_node = sc_utils.createNode(_session, self.segment, sc.SC_CONST, "element") nx2sc[node] = sc_node # append into graph with vertex attribute a = sc_utils.createPairPosPerm(_session, self.segment, self.graphSc, sc_node, sc.SC_CONST) a1 = sc_utils.createPairPosPerm(_session, self.segment, graph_keynodes.Common.rrel_vertex, a, sc.SC_CONST) res_list.extend([sc_node, a, a1]) # create edges for edge in self.graphNx.edges(): sc_edge = sc_utils.createNodeSheaf(_session, self.segment, sc.SC_CONST) # append into graph with edge attribute a = sc_utils.createPairPosPerm(_session, self.segment, self.graphSc, sc_edge, sc.SC_CONST) a1 = sc_utils.createPairPosPerm(_session, self.segment, graph_keynodes.Common.rrel_edge, a, sc.SC_CONST) # setup begin and end objects beg, end = edge a2 = sc_utils.createPairPosPerm(_session, self.segment, sc_edge, nx2sc[beg], sc.SC_CONST) a3 = sc_utils.createPairPosPerm(_session, self.segment, sc_edge, nx2sc[end], sc.SC_CONST) res_list.extend([sc_edge, a, a1, a2, a3]) res_list.extend([graph_keynodes.Common.rrel_edge, graph_keynodes.Common.rrel_vertex, graph_keynodes.Common.graph ]) # create result set for r in res_list: sc_utils.createPairPosPerm(_session, self.segment, result, r, sc.SC_CONST) return result
def translate_length(_segment, _object): session = core.Kernel.session() _value = _object.getPropertyValue(geom_objects.GeometryAbstractObject.PropLength) _addr = _object._getScAddr() # build square relation if not sc_utils.checkOutBinaryPairAttr(session, _addr, geom_keynodes.Relation.nrel_length, sc.SC_CONST): p_node = sc_utils.createNodeElement(session, _segment, sc.SC_CONST) sheaf = sc_utils.createPairBinaryOrient(session, _segment, _addr, p_node, sc.SC_CONST) sc_utils.createPairPosPerm(session, _segment, geom_keynodes.Relation.nrel_length, sheaf, sc.SC_CONST) translate_value(_segment, p_node, _value) else: pass
def buildUserAtomQuestion(sc_qustions, sc_q_objects): # узел вопроса q_node = sc_utils.createNodeElement(session, segment, sc.SC_CONST) # добавляем во множество вопрос session.gen3_f_a_f(segment, sc_key.questions.question, q_node, sc.SC_A_CONST | sc.SC_POS) # добавляем во множество атомарный вопрос session.gen3_f_a_f(segment, sc_key.questions.atom, q_node, sc.SC_A_CONST | sc.SC_POS) # добавляем типы вопросов for sc_q in sc_qustions: session.gen3_f_a_f(segment, sc_q, q_node, sc.SC_A_CONST | sc.SC_POS) # добавляем объекты вопроса for sc_o in sc_q_objects: session.gen3_f_a_f(segment, q_node, sc_o, sc.SC_A_CONST | sc.SC_POS) # добавляем автора (пользователь) authors_node = sc_utils.createNodeElement(session, segment, sc.SC_CONST) sc_utils.createPairPosPerm(session, segment, authors_node, sc_core.Kernel.getSingleton().getUserAddr(), sc.SC_CONST) authors_pair_sheaf = sc_utils.createPairBinaryOrient(session, segment, q_node, authors_node, sc.SC_CONST) sc_utils.createPairPosPerm(session, segment, sc_key.common.nrel_authors, authors_pair_sheaf, sc.SC_CONST) # добавляем окна для вывода output_node = sc_utils.createNodeElement(session, segment, sc.SC_CONST) output_count = 0 it = session.create_iterator(session.sc_constraint_new(sc_constants.CONSTR_3_f_a_a, sc_key.ui.set_output_windows, sc.SC_ARC, 0), True) while not it.is_over(): sc_utils.createPair(session, segment, output_node, it.value(2), session.get_type(it.value(1))) output_count += 1 it.next() if output_count == 0: sc_utils.createPairPosPerm(session, segment, output_node, kernel.getMainWindow()._getScAddr(), sc.SC_CONST ) #sc_utils.copySet(session, sc_key.ui.set_output_windows, output_node, segment) # link output windows set to question output_sheaf = sc_utils.createPairBinaryOrient(session, segment, output_node, q_node, sc.SC_CONST) sc_utils.createPairPosPerm(session, segment, sc_key.ui.nrel_set_of_output_windows, output_sheaf, sc.SC_CONST) # initiate question sc_utils.createPairPosPerm(session, segment, sc_key.questions.initiated, q_node, sc.SC_CONST) return q_node
def genMultiplyRelation(session, segment, operation, _result): el1 = math2sc.variables_sc[operation[0]] el2 = math2sc.variables_sc[operation[1]] #gen set of sum components setNode = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE, "")[1] sc_utils.createPair(session, core.Kernel.segment(), _result, setNode, sc.SC_CONST) arc1 = sc_utils.createPair(session, core.Kernel.segment(), setNode, el1, sc.SC_CONST) arc2 = sc_utils.createPair(session, core.Kernel.segment(), setNode, el2, sc.SC_CONST) sc_utils.createPair(session, core.Kernel.segment(), _result, arc1, sc.SC_CONST) sc_utils.createPair(session, core.Kernel.segment(), _result, arc2, sc.SC_CONST) #gen sum relations res = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE, "")[1] #add result node sc_utils.createPair(session, core.Kernel.segment(), _result, res, sc.SC_CONST) relation = sc_utils.createPair(session, core.Kernel.segment(), setNode, res, sc.SC_CONST) sc_utils.createPair(session, core.Kernel.segment(), _result, relation, sc.SC_CONST) idtf = "произведение*" idtf = sc_utils.utf8ToCp1251(str(idtf)) sumNode = sc_utils.getElementByIdtf(idtf, segment) if sumNode == None: sumNode = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE, idtf)[1] for param in [keynodes.info.stype_bin_orient_norole_rel]: sc_utils.createPairPosPerm(session, core.Kernel.segment(), param, sumNode, sc.SC_CONST) sc_utils.createPair(session, core.Kernel.segment(), _result, sumNode, sc.SC_CONST) relarc = sc_utils.createPair(session, core.Kernel.segment(), sumNode, relation, sc.SC_CONST) sc_utils.createPair(session, core.Kernel.segment(), _result, relarc, sc.SC_CONST) return res
def translate_impl(self, _input, _output): """Translator implementation """ # translating objects objs = objects.ScObject._sc2Objects(_input) assert len(objs) > 0 sheet = objs[0] assert type(sheet) is objects.ObjectSheet segment = sheet.getTmpSegment() errors = [] session = core.Kernel.session() # getting objects, that need to be translated trans_obj = [] for obj in sheet.getChilds(): _addr = obj._getScAddr() if _addr is None: trans_obj.append(obj) # remove old translation data else: if _addr.seg == segment: obj._setScAddr(None) session.erase_el(_addr) # resolve sc_addrs for obj in trans_obj: _resolve_sc_addr(segment, obj) # make translation for obj in trans_obj: errors = [] char_stream = antlr3.ANTLRStringStream(obj) lexer = Lexer(char_stream) parser = Parser(antlr3.CommonTokenStream(lexer)) parser.formula() kernel = core.Kernel.getSingleton() session = kernel.session() segment = kernel.segment() for node in parser.nodeList: sc_utils.createPairPosPerm(session, segment,_output,node , sc.SC_CONST) return errors
def translateChildPoints(_session, _segment, _object): """Translate points, that lies on \p _object """ assert isinstance(_object, geom_objects.GeometryAbstractObject) obj_addr = _object._getScAddr() assert obj_addr is not None for _point, _pos in _object.getPoints(): pt_addr = _point._getScAddr() assert pt_addr is not None if not sc_utils.checkIncToSets( _session, pt_addr, [obj_addr], sc.SC_A_CONST | sc.SC_POS | sc.SC_PERMANENT): sc_utils.createPairPosPerm(_session, _segment, obj_addr, pt_addr, sc.SC_CONST)
def translete_congr(_segment, _obj1, _obj2): # check if it have relation session = core.Kernel.session() res = sc_utils.searchPairsBinaryNoOrient(session, _obj1._getScAddr(), _obj2._getScAddr(), sc.SC_CONST) if res is not None: for result in res: if sc_utils.checkIncToSets(session, result[2], [geom_keynodes.Relation.nrel_congr], sc.SC_A_CONST | sc.SC_POS | sc.SC_PERMANENT): return # create new relation a = sc_utils.createPairBinaryNoOrient(session, _segment, _obj1._getScAddr(), _obj2._getScAddr(), sc.SC_CONST) sc_utils.createPairPosPerm(session, _segment, geom_keynodes.Relation.nrel_congr, a, sc.SC_CONST) return
def translate_impl(self, _input, _output): """Translator implementation """ # translating objects objs = objects.ScObject._sc2Objects(_input) assert len(objs) > 0 sheet = objs[0] assert type(sheet) is objects.ObjectSheet segment = sheet.getTmpSegment() errors = [] session = core.Kernel.session() # getting objects, that need to be translated trans_obj = [] for obj in sheet.getChilds(): _addr = obj._getScAddr() if _addr is None: trans_obj.append(obj) # remove old translation data else: if _addr.seg == segment: obj._setScAddr(None) session.erase_el(_addr) # resolve sc_addrs for obj in trans_obj: _resolve_sc_addr(segment, obj) # make translation for obj in trans_obj: errors = [] char_stream = antlr3.ANTLRStringStream(obj) lexer = Lexer(char_stream) parser = Parser(antlr3.CommonTokenStream(lexer)) parser.formula() kernel = core.Kernel.getSingleton() session = kernel.session() segment = kernel.segment() for node in parser.nodeList: sc_utils.createPairPosPerm(session, segment, _output, node, sc.SC_CONST) return errors
def genDifferenceRelation(session, segment, operation, _result): el1 = math2sc.variables_sc[operation[0]] #minuend el2 = math2sc.variables_sc[operation[1]] #subtrahend res = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE, "")[1] #difference result node sc_utils.createPair(session, core.Kernel.segment(), _result, res, sc.SC_CONST) setNode = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE, "")[1] sc_utils.createPair(session, core.Kernel.segment(), _result, setNode, sc.SC_CONST) #gen input sum parameters arc1 = sc_utils.createPair(session, core.Kernel.segment(), setNode, res, sc.SC_CONST) arc2 = sc_utils.createPair(session, core.Kernel.segment(), setNode, el2, sc.SC_CONST) sc_utils.createPair(session, core.Kernel.segment(), _result, arc1, sc.SC_CONST) sc_utils.createPair(session, core.Kernel.segment(), _result, arc2, sc.SC_CONST) relation = sc_utils.createPair(session, core.Kernel.segment(), setNode, el1, sc.SC_CONST) sc_utils.createPair(session, core.Kernel.segment(), _result, relation, sc.SC_CONST) idtf = "сумма*" idtf = sc_utils.utf8ToCp1251(str(idtf)) sumNode = sc_utils.getElementByIdtf(idtf, segment) if sumNode == None: sumNode = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE, idtf)[1] for param in [keynodes.info.stype_bin_orient_norole_rel]: sc_utils.createPairPosPerm(session, core.Kernel.segment(), param, sumNode, sc.SC_CONST) sc_utils.createPair(session, core.Kernel.segment(), _result, sumNode, sc.SC_CONST) relarc = sc_utils.createPair(session, core.Kernel.segment(), sumNode, relation, sc.SC_CONST) sc_utils.createPair(session, core.Kernel.segment(), _result, relarc, sc.SC_CONST) return res
def translate_quadrangle(_segment, _object, _params): """Translates circle object to sc-memory """ _addr = _object._getScAddr() # include sc-element to points session = core.Kernel.session() addToSets(session, _segment, _addr, [geom_keynodes.Objects.plane_quadrangle, keynodes.info.stype_ext_obj_abstract]) sides = _object.getSides() for obj in sides: sheaf = sc_utils.createPairBinaryOrient(session, _segment, _addr, obj._getScAddr(), sc.SC_CONST) sc_utils.createPairPosPerm(session, _segment, geom_keynodes.Relation.nrel_side, sheaf, sc.SC_CONST) # build square relation #sq_node = sc_utils.createNodeElement(session, _segment, sc.SC_CONST) #sheaf = sc_utils.createPairBinaryOrient(session, _segment, _addr, sq_node, sc.SC_CONST) #sc_utils.createPairPosPerm(session, _segment, geom_keynodes.Relation.nrel_square, sheaf, sc.SC_CONST) return True
def translate_length(_segment, _object): session = core.Kernel.session() _value = _object.getPropertyValue( geom_objects.GeometryAbstractObject.PropLength) _addr = _object._getScAddr() # build square relation if not sc_utils.checkOutBinaryPairAttr( session, _addr, geom_keynodes.Relation.nrel_length, sc.SC_CONST): p_node = sc_utils.createNodeElement(session, _segment, sc.SC_CONST) sheaf = sc_utils.createPairBinaryOrient(session, _segment, _addr, p_node, sc.SC_CONST) sc_utils.createPairPosPerm(session, _segment, geom_keynodes.Relation.nrel_length, sheaf, sc.SC_CONST) translate_value(_segment, p_node, _value) else: pass
def genSumRelation(session, segment, operation, _result): """ @param session: session @param segment: list of segments to search objects in @param operation: sum operation and list of operands @param _result: a node which the result of translation @return: a node that represents the result of summ """ el1 = math2sc.variables_sc[operation[0]] el2 = math2sc.variables_sc[operation[1]] #gen set of sum components setNode = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE, "")[1] sc_utils.createPair(session,core.Kernel.segment(), _result, setNode, sc.SC_CONST) arc1 = sc_utils.createPair(session,core.Kernel.segment(), setNode, el1, sc.SC_CONST) arc2 = sc_utils.createPair(session,core.Kernel.segment(), setNode, el2, sc.SC_CONST) sc_utils.createPair(session,core.Kernel.segment(), _result, arc1, sc.SC_CONST) sc_utils.createPair(session,core.Kernel.segment(), _result, arc2, sc.SC_CONST) #gen sum relations res = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE, "")[1] #add result node sc_utils.createPair(session,core.Kernel.segment(), _result, res, sc.SC_CONST) relation = sc_utils.createPair(session,core.Kernel.segment(), setNode, res, sc.SC_CONST) sc_utils.createPair(session,core.Kernel.segment(), _result, relation, sc.SC_CONST) idtf = "сумма*" idtf = sc_utils.utf8ToCp1251(str(idtf)) sumNode = sc_utils.getElementByIdtf(idtf, segment) if sumNode == None: sumNode = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE, idtf)[1] for param in [keynodes.info.stype_bin_orient_norole_rel]: sc_utils.createPairPosPerm(session, core.Kernel.segment(), param, sumNode, sc.SC_CONST) sc_utils.createPair(session,core.Kernel.segment(), _result, sumNode, sc.SC_CONST) relarc = sc_utils.createPair(session,core.Kernel.segment(), sumNode, relation, sc.SC_CONST) sc_utils.createPair(session,core.Kernel.segment(), _result, relarc, sc.SC_CONST) return res
def gen_function(name, params, session, segment, _result): """ @param name: function name @param params: list of function params @param _result: an output node of the translator @return: """ #gen function node idtf = name+"*" idtf = sc_utils.utf8ToCp1251(str(idtf)) funcNode = sc_utils.getElementByIdtf(idtf, segment) if funcNode == None: funcNode = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE, idtf)[1] for param in [keynodes.info.stype_bin_orient_norole_rel]: sc_utils.createPairPosPerm(session, core.Kernel.segment(), param, funcNode, sc.SC_CONST) sc_utils.createPair(session,core.Kernel.segment(), _result, funcNode, sc.SC_CONST) #gen args set argsSet = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE, "")[1] sc_utils.createPair(session,core.Kernel.segment(), _result, argsSet, sc.SC_CONST) for x in params: param = math2sc.variables_sc[x] arc = sc_utils.createPair(session, core.Kernel.segment(), argsSet, param, sc.SC_CONST) sc_utils.createPair(session,core.Kernel.segment(), _result, param, sc.SC_CONST) sc_utils.createPair(session,core.Kernel.segment(), _result, arc, sc.SC_CONST) pass #gen relation arc result = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE, "")[1] relation = sc_utils.createPair(session, core.Kernel.segment(), argsSet, result, sc.SC_CONST) sc_utils.createPair(session,core.Kernel.segment(), _result, relation, sc.SC_CONST) arc = sc_utils.createPair(session,core.Kernel.segment(), funcNode, relation, sc.SC_CONST) sc_utils.createPair(session,core.Kernel.segment(), _result, arc, sc.SC_CONST) return result
def translate_circle(_segment, _object, _params): """Translates circle object to sc-memory """ _addr = _object._getScAddr() # include sc-element to points session = core.Kernel.session() addToSets( session, _segment, _addr, [geom_keynodes.Objects.circle, keynodes.info.stype_ext_obj_abstract]) # add relation to center point addr_begin = _object.center_point._getScAddr() if not sc_utils.checkOutBinaryPairAttr( session, _addr, geom_keynodes.Relation.nrel_center, sc.SC_CONST): a1 = sc_utils.createPairBinaryOrient(session, _segment, _addr, addr_begin, sc.SC_CONST) sc_utils.createPairPosPerm(session, _segment, geom_keynodes.Relation.nrel_center, a1, sc.SC_CONST) if not sc_utils.checkOutBinaryPairAttr( session, _addr, geom_keynodes.Relation.nrel_radius, sc.SC_CONST): radius_obj = _object.getRadiusObject() if radius_obj is not None: a1 = sc_utils.createPairBinaryOrient(session, _segment, _addr, radius_obj._getScAddr(), sc.SC_CONST) sc_utils.createPairPosPerm(session, _segment, geom_keynodes.Relation.nrel_radius, a1, sc.SC_CONST) # translate child points translateChildPoints(session, _segment, _object) # translate radius if it exist return True
def negation(self, ): node = None atom2 = None try: try: # logic_gram.g:47:2: ( '!' atom ) # logic_gram.g:47:3: '!' atom pass self.match(self.input, 13, self.FOLLOW_13_in_negation121) self._state.following.append(self.FOLLOW_atom_in_negation123) atom2 = self.atom() self._state.following.pop() #action start node= self.session.create_el(self.segment, sc.SC_CONST) atomNode=atom2 self.nodeList.append(sc_utils.createPairPosPerm(self.session, self.segment, logic_keynodes.Relation.nrel_negation, node, sc.SC_CONST)) self.nodeList.append(sc_utils.createPairPosPerm(self.session, self.segment, node, atomNode, sc.SC_CONST)) self.nodeList.append(node) #action end except RecognitionException, re: self.reportError(re) self.recover(self.input, re) finally: pass return node
def genEqualityRelation(session, segment, operation, _result): el1 = math2sc.variables_sc[operation[0]] el2 = math2sc.variables_sc[operation[1]] setNode = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE, "")[1] sc_utils.createPair(session,core.Kernel.segment(), _result, setNode, sc.SC_CONST) arc1 = sc_utils.createPair(session,core.Kernel.segment(), setNode, el1, sc.SC_CONST) arc2 = sc_utils.createPair(session,core.Kernel.segment(), setNode, el2, sc.SC_CONST) sc_utils.createPair(session,core.Kernel.segment(), _result, arc1, sc.SC_CONST) sc_utils.createPair(session,core.Kernel.segment(), _result, arc2, sc.SC_CONST) idtf = "равенство*" idtf = sc_utils.utf8ToCp1251(str(idtf)) eqNode = sc_utils.getElementByIdtf(idtf, segment) if eqNode == None: eqNode = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE, idtf)[1] for param in [keynodes.info.stype_bin_orient_norole_rel]: sc_utils.createPairPosPerm(session, core.Kernel.segment(), param, eqNode, sc.SC_CONST) sc_utils.createPair(session,core.Kernel.segment(), _result, eqNode, sc.SC_CONST) relarc = sc_utils.createPair(session,core.Kernel.segment(), eqNode, setNode, sc.SC_CONST) sc_utils.createPair(session,core.Kernel.segment(), _result, relarc, sc.SC_CONST) return el1
def translete_congr(_segment, _obj1, _obj2): # check if it have relation session = core.Kernel.session() res = sc_utils.searchPairsBinaryNoOrient(session, _obj1._getScAddr(), _obj2._getScAddr(), sc.SC_CONST) if res is not None: for result in res: if sc_utils.checkIncToSets( session, result[2], [geom_keynodes.Relation.nrel_congr], sc.SC_A_CONST | sc.SC_POS | sc.SC_PERMANENT): return # create new relation a = sc_utils.createPairBinaryNoOrient(session, _segment, _obj1._getScAddr(), _obj2._getScAddr(), sc.SC_CONST) sc_utils.createPairPosPerm(session, _segment, geom_keynodes.Relation.nrel_congr, a, sc.SC_CONST) return
def translate_object(_segment, _object, _params): """Translates specified geometry object to SC-code. @param _segment: segment to translate object in @type _segment: sc_segment @param _object: geometry object to translate @type _object: SCgObject or SCgPair @param _params: additional parameters to translate object. It contains list of sc-elements, that designates semantic types for specified object. sc-element, that designate translated object will be included to sets from _params @type _params: list @return: if object translated successfully, then return True, else - False @rtype: bool """ import suit.core.sc_utils as sc_utils session = core.Kernel.session() if isinstance(_object, chem_objects.ChemistryAtom): _addr = session.create_el(_segment, sc.SC_N_CONST) sc_utils.createPairPosPerm(session, _segment, getattr(chem_keynodes, "atom_%s" % _object._name), _addr, sc.SC_CONST) _object._setScAddr(_addr) elif isinstance(_object, chem_objects.ChemistryLink): _addr = session.create_el(_segment, sc.SC_N_CONST) sc_utils.createPairPosPerm(session, _segment, chem_keynodes.link, _addr, sc.SC_CONST) addr_begin = _object.getBegin()._getScAddr() addr_end = _object.getEnd()._getScAddr() assert addr_begin and addr_end a1 = sc_utils.createPairBinaryOrient(session, _segment, _addr, addr_begin, sc.SC_CONST) sc_utils.createPairPosPerm(session, _segment, chem_keynodes.linked_atom, a1, sc.SC_CONST) a2 = sc_utils.createPairBinaryOrient(session, _segment, _addr, addr_end, sc.SC_CONST) sc_utils.createPairPosPerm(session, _segment, chem_keynodes.linked_atom, a2, sc.SC_CONST) _object._setScAddr(_addr) return True
def buildUserAtomQuestion(sc_qustions, sc_q_objects): # узел вопроса q_node = sc_utils.createNodeElement(session, segment, sc.SC_CONST) # добавляем во множество вопрос session.gen3_f_a_f(segment, sc_key.questions.question, q_node, sc.SC_A_CONST | sc.SC_POS) # добавляем во множество атомарный вопрос session.gen3_f_a_f(segment, sc_key.questions.atom, q_node, sc.SC_A_CONST | sc.SC_POS) # добавляем типы вопросов for sc_q in sc_qustions: session.gen3_f_a_f(segment, sc_q, q_node, sc.SC_A_CONST | sc.SC_POS) # добавляем объекты вопроса for sc_o in sc_q_objects: session.gen3_f_a_f(segment, q_node, sc_o, sc.SC_A_CONST | sc.SC_POS) # добавляем автора (пользователь) authors_node = sc_utils.createNodeElement(session, segment, sc.SC_CONST) sc_utils.createPairPosPerm(session, segment, authors_node, sc_core.Kernel.getSingleton().getUserAddr(), sc.SC_CONST) authors_pair_sheaf = sc_utils.createPairBinaryOrient( session, segment, q_node, authors_node, sc.SC_CONST) sc_utils.createPairPosPerm(session, segment, sc_key.common.nrel_authors, authors_pair_sheaf, sc.SC_CONST) # добавляем окна для вывода output_node = sc_utils.createNodeElement(session, segment, sc.SC_CONST) sc_utils.copySet(session, sc_key.ui.set_output_windows, output_node, segment) # link output windows set to question output_sheaf = sc_utils.createPairBinaryOrient(session, segment, output_node, q_node, sc.SC_CONST) sc_utils.createPairPosPerm(session, segment, sc_key.ui.nrel_set_of_output_windows, output_sheaf, sc.SC_CONST) # initiate question sc_utils.createPairPosPerm(session, segment, sc_key.questions.initiated, q_node, sc.SC_CONST) return q_node
def get_arguments_set(_session, _seg): """Builds set of command aguments @param _session: session to work with sc-memory @type _session: sc_session @param _seg: segment to create set in @type _seg: sc_segment @return: tuple (sc_addr of arguments set, list of elements that need to be added to question) @rtype: tuple """ args_set = sc_utils.createNodeElement(_session, _seg, sc.SC_CONST) elements = [] # appending arguments to set kernel = core.Kernel.getSingleton() arg_objs = kernel.getArguments() for obj in arg_objs: _addr = obj._getScAddr() elements.append(sc_utils.createPairPosPerm(_session, _seg, args_set, _addr, sc.SC_CONST)) elements.append(_addr) return args_set, elements
def get_sel_elements_set(_session, _seg): """ Builds set of selected elements in active window @param _session: session to work with memory @type _session: sc_session @param _seg: segment to create set in @type _seg: sc_segment @return: tuple (sc_addr of selected elements set, list of elements that need to be added to question) @rtype: tuple """ sel_set = sc_utils.createNodeElement(_session, _seg, sc.SC_CONST) elements = [] # appending selected elements to set kernel = core.Kernel.getSingleton() sel_objs = kernel.rootSheet.getSelected() for obj in sel_objs: _addr = obj._getScAddr() elements.append(sc_utils.createPairPosPerm(_session, _seg, sel_set, _addr, sc.SC_CONST)) elements.append(_addr) return sel_set, elements
def generate_exppressions(_xmlnode, tag, session, segment): """ Process math tag. Generate relations between variables and numbers """ global parse_result while len(stack) > 0: parse_result.append(stack.pop(-1)) #generate unary expressions for var in variables: varname = var[0] while len(var[1]) > 0: op = var[1].pop(0) expr = op + var[0] key = var[0] var[0] = expr for operation in operations: for arg in operation[1]: if arg == key: operation[1][operation[1].index(key)] = expr for elem in parse_result: if elem == key: parse_result[parse_result.index(key)] = expr if op == "-": #generate unary minus relation #find unary minus relation node, if not find create idtf = "обратное число*" idtf = sc_utils.utf8ToCp1251(str(idtf)) unMinusNode = sc_utils.getElementByIdtf(idtf, segment) if unMinusNode == None: unMinusNode = session.create_el_idtf( core.Kernel.segment(), sc.SC_NODE, idtf)[1] for param in [keynodes.info.stype_bin_orient_norole_rel]: sc_utils.createPairPosPerm(session, core.Kernel.segment(), param, unMinusNode, sc.SC_CONST) sc_utils.createPair(session, core.Kernel.segment(), el, unMinusNode, sc.SC_CONST) #gen node for result varSC = variables_sc[key] res = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE, "")[1] #node for result pair = sc_utils.createPair( session, core.Kernel.segment(), varSC, res, sc.SC_CONST) #arc between processed node and result relBelong = sc_utils.createPair(session, core.Kernel.segment(), unMinusNode, pair, sc.SC_CONST) sc_utils.createPair(session, core.Kernel.segment(), el, res, sc.SC_CONST) sc_utils.createPair(session, core.Kernel.segment(), el, pair, sc.SC_CONST) sc_utils.createPair(session, core.Kernel.segment(), el, relBelong, sc.SC_CONST) variables_sc[expr] = res #generate operations expr = "" for elem in parse_result: if (not elem in operation_priority.keys() and not elem in functions.keys()): stack.append(elem) else: op = elem if (op not in functions.keys()): operand1 = stack.pop(-1) operand2 = stack.pop(-1) expr = operand2 + op + operand1 stack.append(expr) if op in binary_expression_gen.keys(): gen_operation = binary_expression_gen[op] res = gen_operation(session, segment, [operand2, operand1], el) variables_sc[expr] = res else: translation_errors.append("Unsupported operation") else: operands = [] expr = op + "(" for i in range(0, functions[op], 1): operands.append(stack.pop(-1)) expr += operands[-1] expr += "," expr += ")" stack.append(expr) res = f_generator.gen_function(op, operands, session, segment, el) variables_sc[expr] = res return
def translate_impl(self, _input, _output): """Translator implementation """ errors = [] objs = objects.ScObject._sc2Objects(_input) assert len(objs) > 0 sheet = objs[0] assert isinstance(sheet, objects.ObjectSheet) seg = sheet.getTmpSegment() import suit.core.sc_utils as sc_utils errors = [] session = core.Kernel.session() # getting data and translate to sc field = sheet.getLogic().field print field # remove old objects for layer in field.layers: for item in layer.items: _addr = item._getScAddr() if _addr is not None: if _addr.seg.this == seg.this: item._setScAddr(None) session.erase_el(_addr) classifier = field.classifier _segs = [seg.get_full_uri()] _segs.extend(env.search_segments) for layer in field.layers: for item in layer.items: # if (not item.type in classifier.TYPES_TOWN): # continue # creating node in sc-memory _addr = sc_utils.createNodeElement(session, seg, sc.SC_CONST) item._setScAddr(_addr) if (item.type in classifier.TYPES_TOWN): sc_utils.createPairPosPerm(session, seg, map_keynodes.ObjectType.town, _addr, sc.SC_CONST) elif (item.type in classifier.TYPES_RAILWAY): sc_utils.createPairPosPerm(session, seg, map_keynodes.ObjectType.railway, _addr, sc.SC_CONST) elif item.type == classifier.TYPE_DISTRICT: sc_utils.createPairPosPerm( session, seg, map_keynodes.ObjectType.district, _addr, sc.SC_CONST) elif item.type == classifier.TYPE_AREA: sc_utils.createPairPosPerm(session, seg, map_keynodes.ObjectType.area, _addr, sc.SC_CONST) elif item.type in classifier.TYPES_ROAD: sc_utils.createPairPosPerm(session, seg, map_keynodes.ObjectType.road, _addr, sc.SC_CONST) for atribute in item.attributes: if ((atribute in classifier.atributes) and (item.attributes[atribute] != "")): _atr = sc_utils.getElementByIdtf( classifier.atributes[atribute], _segs) if _atr is None: _atr = sc_utils.createNodeRoleRelation( session, seg, sc.SC_CONST) session.set_idtf(_atr, classifier.atributes[atribute]) _val = sc_utils.getElementByIdtf( item.attributes[atribute], _segs) if _val is None: _val = sc_utils.createNodeElement( session, seg, sc.SC_CONST) session.set_idtf(_val, item.attributes[atribute]) #print classifier.atributes[atribute], item.attributes[atribute] pair = sc_utils.createPairPosPerm( session, seg, _addr, _val, sc.SC_CONST) sc_utils.createPairPosPerm(session, seg, _atr, pair, sc.SC_CONST) return errors
def generate_output_windows_set(_session, _segment, _parent_window): """Generates output windows set @param _session: session to work with sc-memory @type _session: MThreadSession @param _segment: segment in sc-memory to work in @type _segment: sc_segment @param _parent_window: parent window object @type _parent_window: ObjectSheet @return: output windows set @rtype: sc_global_addr """ import srs_engine.sc_utils as sc_utils # preparing for sc-machine working (translating it to SC-code) output_windows_set = sc_utils.createNodeElement(_session, _segment, sc.SC_CONST) kernel = core.Kernel.getSingleton() output_windows = kernel.getOutputWindows() import srs_engine.objects as objects for _addr, _exists, _edit in output_windows: window_node = _addr if not _exists: # creating new window window = objects.ObjectSheet() window.hideContent() if _edit: try: window.setLogic(kernel.createEditor(_addr)) except: print "There are no editor for addr %s" % (str(_addr)) window.setLogic(kernel.createViewer(_addr)) else: window.setLogic(kernel.createViewer(_addr)) kernel.mainWindow.addChild(window) sc_utils.createPairPosPerm(_session, _segment, _addr, window._getScAddr(), sc.SC_CONST) window_node = window._getScAddr() # test if _addr.this == keynodes.ui.format_scgx.this: import srs_engine.layout.LayoutGroupForceDirected as layout window.setLayoutGroup(layout.LayoutGroupForceSimple()) else: # test fmt = sc_utils.getContentFormat(_session, _addr) if fmt and fmt.this == keynodes.ui.format_scgx.this: import srs_engine.layout.LayoutGroupForceDirected as layout # FIXME: thinking about multiply objects for sc_addr windows = objects.ScObject._sc2Objects(_addr) assert len(windows) > 0 window = windows[0] if window.getLayoutGroup() is None: window.setLayoutGroup(layout.LayoutGroupForceSimple()) sc_utils.createPairPosPerm(_session, _segment, output_windows_set, window_node, sc.SC_CONST) # # test # import srs_engine.objects as objects # sheet = objects.ObjectSheet() # sheet.hideContent() # # sheet.setLogic(kernel.createEditor(keynodes.ui.format_scgx)) # kernel.rootSheet.addChild(sheet) # sc_utils.createPair(_session, kernel.segment(), keynodes.ui.format_scgx, sheet._getScAddr(), sc.SC_A_CONST | sc.SC_POS) # kernel.setRootSheet(sheet) # # import srs_engine.layout.LayoutGroupForceDirected as layout # sheet.setLayoutGroup(layout.LayoutGroupForceSimple()) # # test # # sc_utils.createPairPosPerm(_session, _segment, output_windows_set, sheet._getScAddr(), sc.SC_CONST) return output_windows_set
def translate_impl(self, _input, _output): """Translator implementation """ # translating objects objs = objects.ScObject._sc2Objects(_input) assert len(objs) > 0 sheet = objs[0] assert type(sheet) is objects.ObjectSheet segment = sheet.getTmpSegment() errors = [] session = core.Kernel.session() # getting objects, that need to be translated trans_obj = [] for obj in sheet.getChilds(): _addr = obj._getScAddr() if _addr is None: trans_obj.append(obj) # remove old translation data else: if _addr.seg == segment: obj._setScAddr(None) #session.erase_el(_addr) trans_obj.append(obj) # sort objects to nodes and edges verticies = [] edges = [] for obj in trans_obj: if isinstance(obj, graph_objects.GraphVertex): verticies.append(obj) elif isinstance(obj, graph_objects.GraphLink): edges.append(obj) graph = sc_utils.createNode(session, segment, sc.SC_CONST, "struct") sc_utils.createPairPosPerm(session, segment, graph_keynodes.Common.graph, graph, sc.SC_CONST) # create all nodes for node in verticies: sc_node = sc_utils.createNode(session, segment, sc.SC_CONST, "element") node._setScAddr(sc_node) # append into graph with vertex attribute a = sc_utils.createPairPosPerm(session, segment, graph, sc_node, sc.SC_CONST) a1 = sc_utils.createPairPosPerm(session, segment, graph_keynodes.Common.rrel_vertex, a, sc.SC_CONST) # create edges for edge in edges: sc_edge = sc_utils.createNodeSheaf(session, segment, sc.SC_CONST) # append into graph with edge attribute a = sc_utils.createPairPosPerm(session, segment, graph, sc_edge, sc.SC_CONST) a1 = sc_utils.createPairPosPerm(session, segment, graph_keynodes.Common.rrel_edge, a, sc.SC_CONST) # setup begin and end objects beg = edge.getBegin()._getScAddr() end = edge.getEnd()._getScAddr() a2 = sc_utils.createPairPosPerm(session, segment, sc_edge, beg, sc.SC_CONST) a3 = sc_utils.createPairPosPerm(session, segment, sc_edge, end, sc.SC_CONST) edge._setScAddr(sc_edge) print "Translation errors:" for obj, error in errors: print error return errors
def calculate_graph_element_prop(_params, _segment): kernel = core.Kernel.getSingleton() session = kernel.session() segment = kernel.segment() # check type question = session.search_one_shot( session.sc_constraint_new(sc_constants.CONSTR_5_f_a_a_a_f, keynodes.questions.initiated, sc.SC_A_CONST, sc.SC_N_CONST, sc.SC_A_CONST, _params), True, 5) assert question is not None question = question[2] global graph_prop_calculators for question_type, calculator, relation in graph_element_prop_calculators: # check command type if sc_utils.checkIncToSets(session, question, [question_type], sc.SC_CONST): element = session.search_one_shot( session.sc_constraint_new(sc_constants.CONSTR_3_f_a_a, question, sc.SC_A_CONST, sc.SC_N_CONST), True, 3) if element is None: return element = element[2] graph = None arc = None it = session.create_iterator( session.sc_constraint_new(sc_constants.CONSTR_3_a_a_f, sc.SC_NODE, sc.SC_A_CONST | sc.SC_POS, element), True) while not it.is_over(): if sc_utils.checkIncToSets(session, it.value(0), [graph_keynodes.Common.graph], sc.SC_CONST): graph = it.value(0) arc = it.value(1) break it.next() if graph is None: continue # make graph and calculate property value g = Graph(segment, graph) sc2obj = g.makeNxGraph() result = calculator(g.graphNx, sc2obj[str(element.this)]) # if result is None: raise RuntimeWarning("Calculator can't calculate value") value = sc_utils.createNodeElement(session, segment, sc.SC_CONST) bin_rel = sc_utils.createPairBinaryOrientFull( session, segment, arc, value, sc.SC_CONST) a = sc_utils.createPairPosPerm(session, segment, relation, bin_rel[0], sc.SC_CONST) elements = translate_value(session, segment, value, result) elements.extend([value, graph, a, relation]) elements.extend(bin_rel) answer = sc_utils.createNodeElement(session, segment, sc.SC_CONST) for el in elements: sc_utils.createPairPosPerm(session, segment, answer, el, sc.SC_CONST) sc_utils.makeAnswer(session, segment, question, answer)
def calculate_graph_prop(_params, _segment): kernel = core.Kernel.getSingleton() session = kernel.session() segment = kernel.segment() # check type question = session.search_one_shot( session.sc_constraint_new(sc_constants.CONSTR_5_f_a_a_a_f, keynodes.questions.initiated, sc.SC_A_CONST, sc.SC_N_CONST, sc.SC_A_CONST, _params), True, 5) assert question is not None question = question[2] global graph_prop_calculators for question_type, calculator, relation in graph_prop_calculators: # check command type if sc_utils.checkIncToSets(session, question, [question_type], sc.SC_CONST): graph = session.search_one_shot( session.sc_constraint_new(sc_constants.CONSTR_3_f_a_a, question, sc.SC_A_CONST, sc.SC_N_CONST), True, 3) if graph is None: return graph = graph[2] if not sc_utils.checkIncToSets(session, graph, [graph_keynodes.Common.graph], sc.SC_CONST): return g = Graph(segment, graph) g.makeNxGraph() result = calculator(g.graphNx) if result is None: raise RuntimeWarning("Calculator can't calculate value") value = sc_utils.createNodeElement(session, segment, sc.SC_CONST) bin_rel = sc_utils.createPairBinaryOrientFull( session, segment, graph, value, sc.SC_CONST) a = sc_utils.createPairPosPerm(session, segment, relation, bin_rel[0], sc.SC_CONST) elements = translate_value(session, segment, value, result) elements.extend([value, graph, a, relation]) elements.extend(bin_rel) answer = sc_utils.createNodeElement(session, segment, sc.SC_CONST) for el in elements: sc_utils.createPairPosPerm(session, segment, answer, el, sc.SC_CONST) sc_utils.makeAnswer(session, segment, question, answer)
def genPowerRelation(session, segment, operation, _result): el1 = math2sc.variables_sc[operation[0]] el2 = math2sc.variables_sc[operation[1]] #gen set of sum components setNode = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE, "")[1] sc_utils.createPair(session, core.Kernel.segment(), _result, setNode, sc.SC_CONST) arc1 = sc_utils.createPair(session, core.Kernel.segment(), setNode, el1, sc.SC_CONST) arc2 = sc_utils.createPair(session, core.Kernel.segment(), setNode, el2, sc.SC_CONST) sc_utils.createPair(session, core.Kernel.segment(), _result, arc1, sc.SC_CONST) sc_utils.createPair(session, core.Kernel.segment(), _result, arc2, sc.SC_CONST) #gen sum relations res = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE, "")[1] #add result node sc_utils.createPair(session, core.Kernel.segment(), _result, res, sc.SC_CONST) relation = sc_utils.createPair(session, core.Kernel.segment(), setNode, res, sc.SC_CONST) sc_utils.createPair(session, core.Kernel.segment(), _result, relation, sc.SC_CONST) idtf = "возведение в степень*" idtf = sc_utils.utf8ToCp1251(str(idtf)) powNode = sc_utils.getElementByIdtf(idtf, segment) if powNode == None: powNode = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE, idtf)[1] for param in [keynodes.info.stype_bin_orient_norole_rel]: sc_utils.createPairPosPerm(session, core.Kernel.segment(), param, powNode, sc.SC_CONST) sc_utils.createPair(session, core.Kernel.segment(), _result, powNode, sc.SC_CONST) relarc = sc_utils.createPair(session, core.Kernel.segment(), powNode, setNode, sc.SC_CONST) baseIdtf = "основание_" baseIdtf = sc_utils.utf8ToCp1251(str(baseIdtf)) baseNode = sc_utils.getElementByIdtf(baseIdtf, segment) if baseNode == None: baseNode = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE, baseIdtf)[1] sc_utils.createPair(session, core.Kernel.segment(), _result, baseNode, sc.SC_CONST) a = sc_utils.createPair(session, core.Kernel.segment(), baseNode, arc1, sc.SC_CONST) sc_utils.createPair(session, core.Kernel.segment(), _result, a, sc.SC_CONST) expIdtf = "показатель_" expIdtf = sc_utils.utf8ToCp1251(str(expIdtf)) expNode = sc_utils.getElementByIdtf(expIdtf, segment) if expNode == None: expNode = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE, expIdtf)[1] sc_utils.createPair(session, core.Kernel.segment(), _result, expNode, sc.SC_CONST) a = sc_utils.createPair(session, core.Kernel.segment(), expNode, arc2, sc.SC_CONST) sc_utils.createPair(session, core.Kernel.segment(), _result, a, sc.SC_CONST) powerIdtf = "результат_" powerIdtf = sc_utils.utf8ToCp1251(str(powerIdtf)) powerNode = sc_utils.getElementByIdtf(powerIdtf, segment) if powerNode == None: powerNode = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE, powerIdtf)[1] sc_utils.createPair(session, core.Kernel.segment(), _result, powerNode, sc.SC_CONST) a = sc_utils.createPair(session, core.Kernel.segment(), powerNode, relation, sc.SC_CONST) sc_utils.createPair(session, core.Kernel.segment(), _result, a, sc.SC_CONST) sc_utils.createPair(session, core.Kernel.segment(), _result, relarc, sc.SC_CONST) return res
def translate_impl(self, _input, _output): """Translator implementation """ # FIXME: append type changing. Element type will be changing, if it is temporary segment # or is in semantic equivalent construction set # FIXME: think about multiply windows for one sc-element objs = objects.ScObject._sc2Objects(_input) assert len(objs) > 0 sheet = objs[0] assert isinstance(sheet, objects.ObjectSheet) seg = sheet.getTmpSegment() errors = [] session = core.Kernel.session() import suit.core.sc_utils as sc_utils # removing old objects # for obj in sheet.getChilds(): # _addr = obj._getScAddr() # if _addr is not None: # if _addr.seg.this == seg.this or isinstance(obj, scg_objects.SCgPair): # obj._setScAddr(None) # session.erase_el(_addr) # getting objects, that need to be translated trans_obj = [] for obj in sheet.getChilds(): if obj._getScAddr() is None: trans_obj.append(obj) if not isinstance(obj, objects.ObjectSheet): # translating objects obj_type = obj.getType() if obj_type == "sheet": continue if not translate_rules.has_key(obj_type): errors.append((obj, "There are no any rules for type %s" % obj_type)) else: #try: func, obj_type, params = translate_rules[obj_type] func(seg, obj, obj_type, params) #except: # import sys # errors.append((obj, "Error: %s" % str(sys.exc_info()[0]))) else: # sheet translation translate_object(seg, obj, sc.SC_NODE, []) content_type, content_data, content_format = obj.getContent() assert content_type is not objects.ObjectSheet.CT_Unknown addr = obj._getScAddr() assert addr is not None if content_type == objects.ObjectSheet.CT_String: session.set_content_str(addr, content_data) elif content_type == objects.ObjectSheet.CT_Real: session.set_content_real(addr, content_data) elif content_type == objects.ObjectSheet.CT_Int: session.set_content_int(addr, content_data) elif content_type == objects.ObjectSheet.CT_Binary: pass # FIXME: add binary content sc_utils.createPairPosPerm(session, seg, content_format, addr, sc.SC_CONST) # linking objects noorient_pairs = ['pair/-/-/-/const', 'pair/-/-/-/var', 'pair/-/-/-/meta'] orient_pairs = ['pair/-/-/orient/const', 'pair/-/-/orient/var', 'pair/-/-/orient/meta'] for obj in trans_obj: obj_type = obj.getType() # check if object is orient pair isPair = obj_type.startswith("pair") isOrient = False isNoorient = False # skipping no pair objects if not isPair: continue if obj_type in noorient_pairs: isNoorient = True if obj_type in orient_pairs: isOrient = True el = obj._getScAddr() if isOrient or isNoorient: _const = sc.SC_CONST if obj_type.find('var') != -1: _const = sc.SC_VAR elif obj_type.find('meta') != -1: _const = sc.SC_METAVAR # generating arguments a1 = sc_utils.createPairPosPerm(session, seg, el, obj.getBegin()._getScAddr(), _const) a2 = sc_utils.createPairPosPerm(session, seg, el, obj.getEnd()._getScAddr(), _const) obj.additionalScAddrs = [a1, a2] if isOrient: p1 = sc_utils.createPairPosPerm(session, seg, keynodes.n_1, a1, _const) p2 = sc_utils.createPairPosPerm(session, seg, keynodes.n_2, a2, _const) obj.additionalScAddrs.extend([p1, p2]) else: # set begin and end objects for pair session.set_beg(el, obj.getBegin()._getScAddr()) session.set_end(el, obj.getEnd()._getScAddr()) return errors
def init_cmd(session, segment, sheet, _menu_item_addr, _general_formul, _cmd_class_set, _init_set): """Initialize question/command from template @param session: Session to work with sc-memory @param segment: Segment to create sc-constructions @param sheet: Current root sheet (command initiated from it) @param _menu_item_addr: sc-element that designate command (question) menu item @type _menu_item_addr: sc_addr @param _general_formul: sc-element that designate general formulation relation (different for questions and commands) @type _general_formul: sc_addr @param _cmd_class_set: sc-element that designate class of commands (used to search command node in template) @type _cmd_class_set: sc_addr @param _init_set: sc-element that designate initiated commands set (different for commands and questions) @type _init_set: sc_addr """ kernel = core.Kernel.getSingleton() # getting question template q_templ = sc_utils.searchOneShotBinPairAttrToNode(session, _menu_item_addr, _general_formul, sc.SC_CONST) if not q_templ: raise RuntimeWarning("Question '%s' haven't template" % _caption) return # getting question node it = session.create_iterator(session.sc_constraint_new(sc_constants.CONSTR_5_f_a_a_a_f, _cmd_class_set, sc.SC_ARC, sc.SC_NODE, sc.SC_ARC, q_templ), True) question_node = None while not it.is_over(): if sc_utils.checkIncToSets(session, it.value(2), [q_templ], 0): question_node = it.value(2) break it.next() if question_node is None: raise RuntimeError("Can't get command (question) node for a '%s' command" % str(_menu_item_addr)) # creating question using template: # * iterate through elements of template set # * making values of parameters cmd_desc_..., add that values to addit_elements map # * replace var elements to const elements # * replace meta elements to var elements # * link replaced arcs params = {} addit_elements = {} # additional elements we need to add into question after params setup elements = [] pairs = [] it = session.create_iterator(session.sc_constraint_new(sc_constants.CONSTR_3_f_a_a, q_templ, sc.SC_A_CONST | sc.SC_POS,# | sc.SC_PERMANENT, 0), True) while not it.is_over(): _el = it.value(2) elements.append(_el) # selected elements if _el.this == keynodes.ui.arg_set.this: params[str(_el.this)], elms = get_arguments_set(session, segment) addit_elements[str(_el.this)] = elms elif _el.this == keynodes.ui.arg_set_only.this: # place just set node into question node params[str(_el.this)], elms = get_arguments_set(session, segment) elif _el.this == keynodes.ui.arg_all_el.this: params[str(_el.this)], elms = get_all_elements_set(session, segment) elif _el.this == keynodes.ui.arg_cur_window.this: params[str(_el.this)] = sheet elif _el.this == keynodes.ui.arg_1.this: arguments = core.Kernel.getSingleton().getArguments() if len(arguments) > 0: params[str(_el.this)] = arguments[0]._getScAddr() elif _el.this == keynodes.ui.arg_2.this: arguments = core.Kernel.getSingleton().getArguments() if len(arguments) > 1: params[str(_el.this)] = arguments[1]._getScAddr() elif _el.this == keynodes.ui.arg_3.this: arguments = core.Kernel.getSingleton().getArguments() if len(arguments) > 1: params[str(_el.this)] = arguments[2]._getScAddr() # elif _el.this == keynodes.ui.cmd_desc_curr_window.this: # params[str(_el.this)] = kernel.rootSheet._getScAddr() else: el_type = session.get_type(_el) idtf = session.get_idtf(_el) if not sc_utils.isSystemId(idtf) or (el_type & sc.SC_CONST): params[str(_el.this)] = _el else: # recreate var and meta elements using rules: # * var -> const # * meta -> var post_type = 0 if el_type & sc.SC_VAR: post_type = sc.SC_CONST elif el_type & sc.SC_META: post_type = sc.SC_VAR else: raise RuntimeWarning("Unknown const type for element '%s'" % str(_el)) if el_type & sc.SC_ARC: pairs.append(_el) params[str(_el.this)] = session.create_el(segment, sc.SC_ARC | post_type) elif el_type & sc.SC_NODE: params[str(_el.this)] = session.create_el(segment, sc.SC_NODE | post_type) # TODO: copy structure types for elements it.next() # add selected set to question set q_node_new = params[str(question_node.this)] if sc_utils.checkIncToSets(session, keynodes.ui.arg_set, [question_node], sc.SC_POS | sc.SC_VAR) and sc_utils.checkIncToSets(session, keynodes.ui.arg_set, [q_templ], sc.SC_POS | sc.SC_CONST): # make pairs to additional elements for el in addit_elements[str(keynodes.ui.arg_set.this)]: assert sc_utils.createPairPosPerm(session, segment, q_node_new, el, sc.SC_CONST) # linking arcs for pair in pairs: # get begin and end elements _beg = session.get_beg(pair) _end = session.get_end(pair) if params.has_key(str(_beg.this)): _beg = params[str(_beg.this)] if params.has_key(str(_end.this)): _end = params[str(_end.this)] pair_new = params[str(pair.this)] session.set_beg(pair_new, _beg) session.set_end(pair_new, _end) # make authors set authors_node = sc_utils.createNodeElement(session, segment, sc.SC_CONST) sc_utils.createPairPosPerm(session, segment, authors_node, core.Kernel.getSingleton().getUserAddr(), sc.SC_CONST) assert authors_node is not None authors_pair_sheaf = sc_utils.createPairBinaryOrient(session, segment, params[str(question_node.this)], authors_node, sc.SC_CONST) assert authors_pair_sheaf is not None assert sc_utils.createPairPosPerm(session, segment, keynodes.common.nrel_authors, authors_pair_sheaf, sc.SC_CONST) # make output windows set output_node = sc_utils.createNodeElement(session, segment, sc.SC_CONST) assert output_node is not None # sc_utils.copySet(session, keynodes.ui.set_output_windows, output_node, segment) output_count = 0 it = session.create_iterator(session.sc_constraint_new(sc_constants.CONSTR_3_f_a_a, keynodes.ui.set_output_windows, sc.SC_ARC, 0), True) while not it.is_over(): sc_utils.createPair(session, segment, output_node, it.value(2), session.get_type(it.value(1))) output_count += 1 it.next() if output_count == 0: sc_utils.createPairPosPerm(session, segment, output_node, kernel.getMainWindow()._getScAddr(), sc.SC_CONST ) # link output windows set to question output_sheaf = sc_utils.createPairBinaryOrient(session, segment, output_node, params[str(question_node.this)], sc.SC_CONST) assert output_sheaf is not None sc_utils.createPairPosPerm(session, segment, keynodes.ui.nrel_set_of_output_windows, output_sheaf, sc.SC_CONST) # initiate question assert sc_utils.createPairPosPerm(session, segment, _init_set, params[str(question_node.this)], sc.SC_CONST) is not None
def translate_object(_segment, _object, _type, _params): """Translates specified scg-object to SC-code. @param _segment: segment to translate object in @type _segment: sc_segment @param _object: scg-object to translate @type _object: SCgObject or SCgPair @param _type: object type @type _type: sc_type @param _params: additional parameters to translate object. It contains list of sc-elements, that designates semantic types for specified object. sc-element, that designate translated object will be included to sets from _params @type _params: list @return: if object translated successfully, then return True, else - False @rtype: bool """ import suit.core.sc_utils as sc_utils session = core.Kernel.session() # getting node idtf idtf = _object.getText() sc_object = None el = None isUri = False created = False # if idtf empty, then creating new element if idtf is None: el = session.create_el(_segment, _type) created = True else: # encode idtf to cp1251 idtf = sc_utils.utf8ToCp1251(str(idtf)) # check if idtf if full uri isUri = idtf.startswith('/') # trying to find object by idtf, if it doesn't exists, then creating it try: if el is None: if isUri: el = session.find_el_full_uri(idtf) if el is None: el = session.create_el_full_uri(idtf, _type)[1] created = True else: _segs = [_segment.get_full_uri()] _segs.extend(env.search_segments) # trying to find element el = sc_utils.getElementByIdtf(idtf, _segs) if el is None: el = session.create_el_idtf(_segment, _type, idtf)[1] created = True except: import sys, traceback print sys.exc_info()[0] traceback.print_exc(file=sys.stdout) return False assert el is not None _object._setScAddr(el) _object.setMerged(not created) # including to sets for structure type for param in _params: sc_utils.createPairPosPerm(session, _segment, param, el, sc.SC_CONST) return True
def expression(self, ): node = None a = None b = None try: try: # logic_gram.g:23:2: (a= atom ( '^' | '&' | ( '->' | '<-' ) | '<->' ) b= atom ) # logic_gram.g:23:3: a= atom ( '^' | '&' | ( '->' | '<-' ) | '<->' ) b= atom pass #action start revers=None relation=None #action end self._state.following.append(self.FOLLOW_atom_in_expression49) a = self.atom() self._state.following.pop() # logic_gram.g:26:10: ( '^' | '&' | ( '->' | '<-' ) | '<->' ) alt2 = 4 LA2 = self.input.LA(1) if LA2 == 6: alt2 = 1 elif LA2 == 7: alt2 = 2 elif LA2 == 8 or LA2 == 9: alt2 = 3 elif LA2 == 10: alt2 = 4 else: nvae = NoViableAltException("", 2, 0, self.input) raise nvae if alt2 == 1: # logic_gram.g:26:11: '^' pass self.match(self.input, 6, self.FOLLOW_6_in_expression52) #action start relation=logic_keynodes.Relation.nrel_disjunction #action end elif alt2 == 2: # logic_gram.g:27:3: '&' pass self.match(self.input, 7, self.FOLLOW_7_in_expression57) #action start relation=logic_keynodes.Relation.nrel_conjunction #action end elif alt2 == 3: # logic_gram.g:28:3: ( '->' | '<-' ) pass # logic_gram.g:28:3: ( '->' | '<-' ) alt1 = 2 LA1_0 = self.input.LA(1) if (LA1_0 == 8) : alt1 = 1 elif (LA1_0 == 9) : alt1 = 2 else: nvae = NoViableAltException("", 1, 0, self.input) raise nvae if alt1 == 1: # logic_gram.g:28:4: '->' pass self.match(self.input, 8, self.FOLLOW_8_in_expression64) elif alt1 == 2: # logic_gram.g:28:9: '<-' pass self.match(self.input, 9, self.FOLLOW_9_in_expression66) #action start revers=True #action end #action start relation=logic_keynodes.Relation.nrel_implication #action end elif alt2 == 4: # logic_gram.g:29:3: '<->' pass self.match(self.input, 10, self.FOLLOW_10_in_expression75) #action start relation=logic_keynodes.Relation.nrel_equivalence #action end self._state.following.append(self.FOLLOW_atom_in_expression84) b = self.atom() self._state.following.pop() #action start if relation==logic_keynodes.Relation.nrel_implication: if revers: a,b=b,a node=sc_utils.createPairBinaryOrient(self.session, self.segment, a ,b, sc.SC_CONST) else: node=sc_utils.createPairBinaryNoOrient(self.session, self.segment, a ,b, sc.SC_CONST) self.nodeList.append(node) self.nodeList.append(sc_utils.createPairPosPerm(self.session, self.segment,relation, node, sc.SC_CONST)) #action end except RecognitionException, re: self.reportError(re) self.recover(self.input, re) finally: pass return node
def calculate_graph_element_prop(_params, _segment): kernel = core.Kernel.getSingleton() session = kernel.session() segment = kernel.segment() # check type question = session.search_one_shot(session.sc_constraint_new(sc_constants.CONSTR_5_f_a_a_a_f, keynodes.questions.initiated, sc.SC_A_CONST, sc.SC_N_CONST, sc.SC_A_CONST, _params), True, 5) assert question is not None question = question[2] global graph_prop_calculators for question_type, calculator, relation in graph_element_prop_calculators: # check command type if sc_utils.checkIncToSets(session, question, [question_type], sc.SC_CONST): element = session.search_one_shot(session.sc_constraint_new(sc_constants.CONSTR_3_f_a_a, question, sc.SC_A_CONST, sc.SC_N_CONST), True, 3) if element is None: return element = element[2] graph = None arc = None it = session.create_iterator(session.sc_constraint_new(sc_constants.CONSTR_3_a_a_f, sc.SC_NODE, sc.SC_A_CONST | sc.SC_POS, element), True) while not it.is_over(): if sc_utils.checkIncToSets(session, it.value(0), [graph_keynodes.Common.graph], sc.SC_CONST): graph = it.value(0) arc = it.value(1) break it.next() if graph is None: continue # make graph and calculate property value g = Graph(segment, graph) sc2obj = g.makeNxGraph() result = calculator(g.graphNx, sc2obj[str(element.this)]) # if result is None: raise RuntimeWarning("Calculator can't calculate value") value = sc_utils.createNodeElement(session, segment, sc.SC_CONST) bin_rel = sc_utils.createPairBinaryOrientFull(session, segment, arc, value, sc.SC_CONST) a = sc_utils.createPairPosPerm(session, segment, relation, bin_rel[0], sc.SC_CONST) elements = translate_value(session, segment, value, result) elements.extend([value, graph, a, relation]) elements.extend(bin_rel) answer = sc_utils.createNodeElement(session, segment, sc.SC_CONST) for el in elements: sc_utils.createPairPosPerm(session, segment, answer, el, sc.SC_CONST) sc_utils.makeAnswer(session, segment, question, answer)
def genPowerRelation(session, segment, operation, _result): el1 = math2sc.variables_sc[operation[0]] el2 = math2sc.variables_sc[operation[1]] #gen set of sum components setNode = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE, "")[1] sc_utils.createPair(session,core.Kernel.segment(), _result, setNode, sc.SC_CONST) arc1 = sc_utils.createPair(session,core.Kernel.segment(), setNode, el1, sc.SC_CONST) arc2 = sc_utils.createPair(session,core.Kernel.segment(), setNode, el2, sc.SC_CONST) sc_utils.createPair(session,core.Kernel.segment(), _result, arc1, sc.SC_CONST) sc_utils.createPair(session,core.Kernel.segment(), _result, arc2, sc.SC_CONST) #gen sum relations res = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE, "")[1] #add result node sc_utils.createPair(session,core.Kernel.segment(), _result, res, sc.SC_CONST) relation = sc_utils.createPair(session,core.Kernel.segment(), setNode, res, sc.SC_CONST) sc_utils.createPair(session,core.Kernel.segment(), _result, relation, sc.SC_CONST) idtf = "возведение в степень*" idtf = sc_utils.utf8ToCp1251(str(idtf)) powNode = sc_utils.getElementByIdtf(idtf, segment) if powNode == None: powNode = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE, idtf)[1] for param in [keynodes.info.stype_bin_orient_norole_rel]: sc_utils.createPairPosPerm(session, core.Kernel.segment(), param, powNode, sc.SC_CONST) sc_utils.createPair(session,core.Kernel.segment(), _result, powNode, sc.SC_CONST) relarc = sc_utils.createPair(session,core.Kernel.segment(), powNode, setNode, sc.SC_CONST) baseIdtf = "основание_" baseIdtf = sc_utils.utf8ToCp1251(str(baseIdtf)) baseNode = sc_utils.getElementByIdtf(baseIdtf, segment) if baseNode == None: baseNode = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE, baseIdtf)[1] sc_utils.createPair(session,core.Kernel.segment(), _result, baseNode, sc.SC_CONST) a = sc_utils.createPair(session,core.Kernel.segment(), baseNode, arc1, sc.SC_CONST) sc_utils.createPair(session,core.Kernel.segment(), _result, a, sc.SC_CONST) expIdtf = "показатель_" expIdtf = sc_utils.utf8ToCp1251(str(expIdtf)) expNode = sc_utils.getElementByIdtf(expIdtf, segment) if expNode == None: expNode = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE, expIdtf)[1] sc_utils.createPair(session,core.Kernel.segment(), _result, expNode, sc.SC_CONST) a = sc_utils.createPair(session,core.Kernel.segment(), expNode, arc2, sc.SC_CONST) sc_utils.createPair(session,core.Kernel.segment(), _result, a, sc.SC_CONST) powerIdtf = "результат_" powerIdtf = sc_utils.utf8ToCp1251(str(powerIdtf)) powerNode = sc_utils.getElementByIdtf(powerIdtf, segment) if powerNode == None: powerNode = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE, powerIdtf)[1] sc_utils.createPair(session,core.Kernel.segment(), _result, powerNode, sc.SC_CONST) a = sc_utils.createPair(session,core.Kernel.segment(), powerNode, relation, sc.SC_CONST) sc_utils.createPair(session,core.Kernel.segment(), _result, a, sc.SC_CONST) sc_utils.createPair(session,core.Kernel.segment(), _result, relarc, sc.SC_CONST) return res
def translate_impl(self, _input, _output): """Translator implementation """ # FIXME: append type changing. Element type will be changing, if it is temporary segment # or is in semantic equivalent construction set # FIXME: think about multiply windows for one sc-element objs = objects.ScObject._sc2Objects(_input) assert len(objs) > 0 sheet = objs[0] assert isinstance(sheet, objects.ObjectSheet) seg = sheet.getTmpSegment() errors = [] session = core.Kernel.session() import suit.core.sc_utils as sc_utils # removing old objects # for obj in sheet.getChilds(): # _addr = obj._getScAddr() # if _addr is not None: # if _addr.seg.this == seg.this or isinstance(obj, scg_objects.SCgPair): # obj._setScAddr(None) # session.erase_el(_addr) # getting objects, that need to be translated trans_obj = [] for obj in sheet.getChilds(): if obj._getScAddr() is None: trans_obj.append(obj) if not isinstance(obj, objects.ObjectSheet): # translating objects obj_type = obj.getType() if obj_type == "sheet": continue if not translate_rules.has_key(obj_type): errors.append( (obj, "There are no any rules for type %s" % obj_type)) else: #try: func, obj_type, params = translate_rules[obj_type] func(seg, obj, obj_type, params) #except: # import sys # errors.append((obj, "Error: %s" % str(sys.exc_info()[0]))) else: # sheet translation translate_object(seg, obj, sc.SC_NODE, []) content_type, content_data, content_format = obj.getContent( ) assert content_type is not objects.ObjectSheet.CT_Unknown addr = obj._getScAddr() assert addr is not None if content_type == objects.ObjectSheet.CT_String: session.set_content_str(addr, content_data) elif content_type == objects.ObjectSheet.CT_Real: session.set_content_real(addr, content_data) elif content_type == objects.ObjectSheet.CT_Int: session.set_content_int(addr, content_data) elif content_type == objects.ObjectSheet.CT_Binary: pass # FIXME: add binary content sc_utils.createPairPosPerm(session, seg, content_format, addr, sc.SC_CONST) # linking objects noorient_pairs = [ 'pair/-/-/-/const', 'pair/-/-/-/var', 'pair/-/-/-/meta' ] orient_pairs = [ 'pair/-/-/orient/const', 'pair/-/-/orient/var', 'pair/-/-/orient/meta' ] for obj in trans_obj: obj_type = obj.getType() # check if object is orient pair isPair = obj_type.startswith("pair") isOrient = False isNoorient = False # skipping no pair objects if not isPair: continue if obj_type in noorient_pairs: isNoorient = True if obj_type in orient_pairs: isOrient = True el = obj._getScAddr() if isOrient or isNoorient: _const = sc.SC_CONST if obj_type.find('var') != -1: _const = sc.SC_VAR elif obj_type.find('meta') != -1: _const = sc.SC_METAVAR # generating arguments a1 = sc_utils.createPairPosPerm(session, seg, el, obj.getBegin()._getScAddr(), _const) a2 = sc_utils.createPairPosPerm(session, seg, el, obj.getEnd()._getScAddr(), _const) obj.additionalScAddrs = [a1, a2] if isOrient: p1 = sc_utils.createPairPosPerm(session, seg, keynodes.n_1, a1, _const) p2 = sc_utils.createPairPosPerm(session, seg, keynodes.n_2, a2, _const) obj.additionalScAddrs.extend([p1, p2]) else: # set begin and end objects for pair session.set_beg(el, obj.getBegin()._getScAddr()) session.set_end(el, obj.getEnd()._getScAddr()) return errors