API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Dec 12th, 2019
104
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 29.74 KB | None | 0 0
raw download clone embed print report
  1. using System;
  2. using System.Collections.Generic;
  3. using System.ComponentModel;
  4. using System.Data;
  5. using System.Drawing;
  6. using System.Linq;
  7. using System.Text;
  8. using System.Threading.Tasks;
  9. using System.Windows.Forms;
  10. using VDS.RDF;
  11. using VDS.RDF.Parsing;
  12. using System.IO;
  13. using VDS.RDF.Writing;
  14. using System.Text.RegularExpressions;
  15. using VDS.RDF.Query;
  16. using System.Collections;
  17. using VDS.RDF.Query.Datasets;
  18.  
  19. using VDS.RDF.Writing.Formatting;
  20. using System.Windows;
  21. using System.Windows.Documents;
  22.  
  23. namespace Lab6
  24. {
  25. public partial class Form1 : Form
  26. {
  27. private const string QueryText1 = "SELECT ?s ?o WHERE { ?s owl:oneOf ?o .}";
  28. private const string QueryText2 = "SELECT ?s ?p ?o WHERE { ?s ?p ?o . filter (contains(str(?p), \"disjointWith\"))}";
  29.  
  30. private SparqlQuery sparqlQuery(String queryText)
  31. {
  32. SparqlParameterizedString query_string = new SparqlParameterizedString();
  33. query_string.Namespaces.AddNamespace("ind", new Uri("ind:"));
  34. query_string.Namespaces.AddNamespace("class", new Uri("class:"));
  35. query_string.Namespaces.AddNamespace("owl", new Uri("http://www.w3.org/2002/07/owl#>"));
  36. //rdfs: <http://www.w3.org/2000/01/rdf-schema#>
  37. query_string.Namespaces.AddNamespace("rdfs", new Uri("http://www.w3.org/2000/01/rdf-schema#"));
  38. query_string.Namespaces.AddNamespace("rdf", new Uri("http://www.w3.org/1999/02/22-rdf-syntax-ns#"));
  39. query_string.Namespaces.AddNamespace("pr", new Uri("lab: property:"));
  40. query_string.CommandText = queryText;
  41. SparqlQueryParser parser = new SparqlQueryParser();
  42. SparqlQuery query = parser.ParseFromString(query_string);
  43. return query;
  44. }
  45.  
  46. public Form1()
  47. {
  48. InitializeComponent();
  49. }
  50.  
  51. private void button1_Click(object sender, EventArgs e)
  52. {
  53. var g = new Graph();
  54. FileLoader.Load(g, "CmapInTurtle.n3");
  55. listBox1.Items.AddRange(File.ReadAllLines("CmapInTurtle.n3"));
  56. }
  57.  
  58. private void button2_Click(object sender, EventArgs e)
  59. {
  60. var g = new Graph();
  61. FileLoader.Load(g, "Rules.n3");
  62. listBox2.Items.AddRange(File.ReadAllLines("Rules.n3"));
  63. }
  64.  
  65.  
  66.  
  67. private void button4_Click(object sender, EventArgs e) ////////////////////////////////////////////// ВЫВОД НОВЫХ ЗНАНИЙ ///////////////////////////////////////////
  68. {
  69. Graph g = new Graph();
  70. Notation3Parser np = new Notation3Parser();
  71. np.Load(g, "Rules.n3");
  72.  
  73. Graph g_KB = new Graph();
  74. Notation3Parser np_KB = new Notation3Parser();
  75. np_KB.Load(g_KB, "CmapInTurtle.n3");
  76.  
  77. Graph rez_graph = new Graph();
  78.  
  79. g_KB.NamespaceMap.AddNamespace("pr", new Uri("lab:property:"));
  80.  
  81. rez_graph.NamespaceMap.AddNamespace("pr", new Uri("lab:property:"));
  82.  
  83. ///////////////////////////////////////////////////////// П Р О В Е Р К А SymmetricProperty ///////////////////////////////////////////////////////////////////////////////
  84.  
  85. var Add_Triple_List = new List<Triple>();
  86. var Triple_List_Sym = new List<Triple>();
  87.  
  88. var new_rules = g.Triples;
  89. foreach (var item in new_rules)
  90. {
  91. Add_Triple_List.Add(item);
  92. //listBox3.Items.Add(item);
  93. }
  94. //for (int i = 0; i < Add_Triple_List.Count(); i++)
  95. //{
  96. // Triple rule = Add_Triple_List[i];
  97. // if (rule.ToString().Contains("SymmetricProperty"))
  98. // {
  99. // INode subj_sym = rule.Subject;
  100. // INode pred_sym = g_KB.GetUriNode("pr:neighbouringWith");
  101.  
  102. // INode pred_for_new_graph = Tools.CopyNode(pred_sym, rez_graph);
  103. // INode subj_for_new_graph = Tools.CopyNode(subj_sym, rez_graph);
  104.  
  105. // Triple_List_Sym = g_KB.GetTriplesWithSubjectPredicate(subj_sym, pred_sym).ToList();
  106.  
  107. // if (Triple_List_Sym.Count() > 0)
  108. // {
  109. // INode obj_sym = rule.Object;
  110. // INode obj_for_new_graph = Tools.CopyNode(obj_sym, rez_graph);
  111.  
  112. // Triple ts = new Triple(obj_for_new_graph, pred_for_new_graph, subj_for_new_graph);
  113. // g_KB.Assert(ts);
  114. // listBox3.Items.Add("SYMMETRIC PROPERTY \n");
  115. // listBox3.Items.Add(ts.ToString());
  116. // var tw_sym = new TurtleWriter();
  117. // // tw_sym.Save(g_KB, "CmapInTurtle.n3");
  118. // break;
  119. // }
  120.  
  121. // }
  122. //}
  123.  
  124. //var Triple_List_Trans = new List<Triple>();
  125. //var Triple_for_graph_trans = new List<Triple>();
  126. //var Triple_trans_to_remember = new List<Triple>();
  127. //int trans_count = 0;
  128. //for (int i = 0; i < Add_Triple_List.Count(); i++)
  129. //{
  130. // Triple rule = Add_Triple_List[i];
  131. // if (rule.ToString().Contains("TransitiveProperty"))
  132. // {
  133. // Triple_List_Trans.Add(rule);
  134.  
  135. // INode subj_trans = Triple_List_Trans[trans_count].Subject;
  136. // INode obj_trans = Triple_List_Trans[trans_count].Object;
  137.  
  138. // Triple_for_graph_trans = g_KB.GetTriplesWithSubjectObject(subj_trans, obj_trans).ToList();
  139.  
  140.  
  141. // if (trans_count == 1)
  142. // {
  143. // INode pred_1 = Triple_for_graph_trans[trans_count - 1].Predicate;
  144. // INode pred_trans_1 = Tools.CopyNode(pred_1, g);
  145.  
  146. // Triple ts_trans_1 = new Triple(subj_trans, pred_trans_1, obj_trans);
  147.  
  148. // Triple_trans_to_remember.Add(ts_trans_1);
  149. // }
  150.  
  151. // else
  152. // {
  153.  
  154. // INode pred_tr = Triple_for_graph_trans[trans_count].Predicate;
  155. // INode pred_trans = Tools.CopyNode(pred_tr, g);
  156.  
  157. // Triple ts_trans = new Triple(subj_trans, pred_trans, obj_trans);
  158.  
  159. // Triple_trans_to_remember.Add(ts_trans);
  160. // }
  161.  
  162. // trans_count++;
  163. // }
  164. //}
  165. //for (int i = 0; i < Triple_trans_to_remember.Count(); i++)
  166. //{
  167. // if (Triple_trans_to_remember[i].Object.Equals(Triple_trans_to_remember[i + 1].Subject))
  168. // {
  169. // Triple ts_to_add = new Triple(Triple_trans_to_remember[i].Subject, Triple_trans_to_remember[i].Predicate, Triple_trans_to_remember[i + 1].Object);
  170. // g_KB.Assert(ts_to_add);
  171. // listBox3.Items.Add("TRANSITIVE PROPERTY \n");
  172. // listBox3.Items.Add(ts_to_add.ToString());
  173. // var tw_trans = new TurtleWriter();
  174. // // tw_trans.Save(g_KB, "CmapInTurtle.n3");
  175. // break;
  176. // }
  177. //}
  178. //var Triple_List_Inv = new List<Triple>();
  179. //var Triple_for_graph_inv_subj = new List<Triple>();
  180. //var Triple_for_graph_inv_obj = new List<Triple>();
  181. //var Triple_inv_to_remember = new List<Triple>();
  182. //int count_inv;
  183. //var tw_inv = new TurtleWriter();
  184. //for (int i = 0; i < Add_Triple_List.Count(); i++)
  185. //{
  186. // Triple rule = Add_Triple_List[i];
  187. // if (rule.ToString().Contains("inverseOf"))
  188. // {
  189. // Triple_List_Inv.Add(rule);
  190. // INode pred_1_inv = rule.Subject;
  191. // Triple_for_graph_inv_subj = g_KB.GetTriplesWithPredicate(pred_1_inv).ToList();
  192.  
  193. // INode pred_2_inv = rule.Object;
  194. // Triple_for_graph_inv_obj = g_KB.GetTriplesWithPredicate(pred_2_inv).ToList();
  195.  
  196. // if (Triple_for_graph_inv_subj.Count() > 0)
  197. // {
  198. // count_inv = Triple_for_graph_inv_subj.Count();
  199. // for (int j = 0; j < count_inv; j++)
  200. // {
  201. // INode subj_inv = Triple_for_graph_inv_subj[j].Subject;
  202. // INode obj_inv = Triple_for_graph_inv_subj[j].Object;
  203. // INode pred_inv_general = Tools.CopyNode(pred_2_inv, g_KB);
  204.  
  205. // Triple ts_inv_1 = new Triple(obj_inv, pred_inv_general, subj_inv);
  206. // g_KB.Assert(ts_inv_1);
  207. // listBox3.Items.Add("INVERSE OF \n");
  208. // listBox3.Items.Add(ts_inv_1.ToString());
  209. // //tw_inv.Save(g_KB, "CmapInTurtle.n3");
  210. // break;
  211. // }
  212. // }
  213. // else if (Triple_for_graph_inv_obj.Count > 0)
  214. // {
  215. // count_inv = Triple_for_graph_inv_obj.Count();
  216. // for (int j = 0; j < count_inv; j++)
  217. // {
  218. // INode subj_inv = Triple_for_graph_inv_obj[j].Subject;
  219. // INode obj_inv = Triple_for_graph_inv_obj[j].Object;
  220. // INode pred_inv_general = Tools.CopyNode(pred_1_inv, g_KB);
  221.  
  222. // Triple ts_inv_1 = new Triple(obj_inv, pred_inv_general, subj_inv);
  223. // g_KB.Assert(ts_inv_1);
  224. // listBox3.Items.Add("INVERSE OF \n");
  225. // listBox3.Items.Add(ts_inv_1.ToString());
  226. // //tw_inv.Save(g_KB, "CmapInTurtle.n3");
  227. // break;
  228. // }
  229. // }
  230. // break;
  231. // }
  232. //}
  233.  
  234. var Triple_List_Uni = new List<Triple>();
  235. var Triple_for_graph_uni_subj = new List<Triple>();
  236. var Triple_for_graph_uni_obj = new List<Triple>();
  237. var Triple_uni_to_remember = new List<Triple>();
  238.  
  239. var Triple_for_graph_inter = new List<Triple>();
  240. var Triple_inter_to_remember = new List<Triple>();
  241.  
  242. Regex regex = new Regex("auto");
  243.  
  244. string q1 = @"
  245. prefix owl:<http://www.w3.org/2002/07/owl#>
  246. prefix rdf:<http://www.w3.org/1999/02/22-rdf-syntax-ns#>
  247. prefix pr:<lab:property:>
  248. prefix ot:<lab:other:>
  249. prefix class:<lab:classes:>
  250. prefix ind: <lab:individuals:>
  251. SELECT DISTINCT ?item (count(?mid)-1 as ?position)
  252. WHERE
  253. {
  254. [] owl:unionOf/rdf:rest* ?mid . ?mid rdf:rest* ?node .
  255. ?node rdf:first ?item .
  256. }
  257. group by ?node ?item
  258. ";
  259. string q2 = @"
  260. prefix owl:<http://www.w3.org/2002/07/owl#>
  261. prefix rdf:<http://www.w3.org/1999/02/22-rdf-syntax-ns#>
  262. prefix pr:<lab:property:>
  263. prefix ot:<lab:other:>
  264. prefix class:<lab:classes:>
  265. prefix ind: <lab:individuals:>
  266. SELECT DISTINCT ?item (count(?mid)-1 as ?position)
  267. WHERE
  268. {
  269. [] owl:intersectionOf/rdf:rest* ?mid . ?mid rdf:rest* ?node .
  270. ?node rdf:first ?item .
  271. }
  272. group by ?node ?item
  273. ";
  274.  
  275.  
  276. SparqlResultSet rez_set_uni = (SparqlResultSet)g.ExecuteQuery(q1);
  277. SparqlResultSet rez_set_inter = (SparqlResultSet)g.ExecuteQuery(q2);
  278.  
  279. var listNode = new List<INode>();
  280. var listNode_first = new List<INode>();
  281. var listNode_second = new List<INode>();
  282.  
  283.  
  284. var listNode_inter = new List<INode>();
  285.  
  286. for (int i = 0; i < rez_set_uni.Count(); i++)
  287. {
  288. INode item = rez_set_uni[i]["item"];
  289. listNode.Add(item); //там лежат элементы из скобочек
  290. }
  291.  
  292. for (int i = 0; i < rez_set_inter.Count(); i++)
  293. {
  294. INode item = rez_set_inter[i]["item"];
  295. listNode_inter.Add(item);
  296. }
  297.  
  298. for (int i = 0; i < Add_Triple_List.Count(); i++)
  299. {
  300.  
  301. Triple rule = Add_Triple_List[i];
  302. string str = Add_Triple_List[i].ToString();
  303. MatchCollection matches = regex.Matches(str);
  304. if (matches.Count == 1 && !(Add_Triple_List[i].ToString().Contains("nil")))
  305. {
  306. Triple_List_Uni.Add(rule);
  307. if (rule.ToString().Contains("unionOf"))
  308. {
  309. Triple_for_graph_uni_subj.Add(rule); //здесь лежит класс, который стал объединением элементов из скобочек
  310. }
  311. if (rule.ToString().Contains("intersectionOf"))
  312. {
  313. Triple_for_graph_inter.Add(rule); //здесь класс-пересечение
  314. }
  315. }
  316. }
  317. INode pred = g_KB.GetUriNode("rdf:type");
  318. INode pred_to_add = Tools.CopyNode(pred, g_KB);
  319. var tw = new TurtleWriter();
  320.  
  321. //for (int j = 0; j < listNode.Count; j++)
  322. //{
  323. // Triple_uni_to_remember.AddRange(g_KB.GetTriplesWithPredicateObject(pred, listNode[j]).ToList());
  324. //}
  325. //for (int k = 0; k < Triple_for_graph_uni_subj.Count(); k++)
  326. //{
  327. // INode obj_to_add = Tools.CopyNode(Triple_for_graph_uni_subj[k].Subject, g_KB);
  328. // for (int j = 0; j < Triple_uni_to_remember.Count(); j++)
  329. // {
  330. // Triple ts_uni = new Triple(Triple_uni_to_remember[j].Subject, pred_to_add, obj_to_add);
  331. // listBox3.Items.Add("UNION OF \n");
  332. // listBox3.Items.Add(ts_uni.ToString());
  333. // //g_KB.Assert(ts_uni);
  334. // //tw.Save(g_KB, "CmapInTurtle.n3");
  335. // }
  336. // }
  337.  
  338. for (int i = 0; i < listNode_inter.Count(); i++)
  339. {
  340. Triple_inter_to_remember.AddRange(g_KB.GetTriplesWithPredicateObject(pred, listNode_inter[i]).ToList());
  341. }
  342. INode obj_to_add_inter = Tools.CopyNode(Triple_for_graph_inter[0].Subject, g_KB);
  343. for (int k = 0; k < Triple_inter_to_remember.Count(); k++) //ЭТО ДЛЯ ПЕРЕСЕЧЕНИЯ - ИНДИВИД ПРИНАДЛЕЖИТ ДВУМ КЛАССАМ ОДНОВРЕМЕННО
  344. {
  345. for (int j = k + 1; j < Triple_inter_to_remember.Count(); j++)
  346. {
  347. if (Triple_inter_to_remember[k].Subject == Triple_inter_to_remember[j].Subject)
  348. {
  349. INode equal_subj = Triple_inter_to_remember[k].Subject;
  350. Triple ts_inter = new Triple(equal_subj, pred_to_add, obj_to_add_inter);
  351. listBox3.Items.Add("INTERSECTION OF \n");
  352. listBox3.Items.Add(ts_inter.ToString());
  353. //g_KB.Assert(ts_inter);
  354. //tw.Save(g_KB, "CmapInTurtle.n3");
  355. }
  356. }
  357. }
  358.  
  359. //var list_eq_class = new List<Triple>();
  360. //var list_of_nodes_first = new List<INode>();
  361. //var list_of_nodes_second = new List<INode>();
  362. //var list_of_triplets = new List<Triple>();
  363.  
  364. //TurtleWriter tw_1 = new TurtleWriter();
  365.  
  366. ////Graph new_graph_first = new Graph();
  367. ////Graph new_graph_second = new Graph();
  368. //INode pred_eq = g_KB.GetUriNode("rdf:type");
  369.  
  370. //for (int i = 0; i < Add_Triple_List.Count(); i++)
  371. //{
  372. // Triple rule = Add_Triple_List[i];
  373. // if (rule.ToString().Contains("equivalentClass"))
  374. // {
  375. // list_eq_class.Add(rule);
  376. // list_of_triplets = (g_KB.GetTriplesWithPredicateObject(pred_eq, list_eq_class[0].Subject).ToList());
  377. // }
  378. //}
  379. //INode obj_to_add_eq = Tools.CopyNode(list_eq_class[0].Object, g_KB);
  380. //for (int j = 0; j < list_of_triplets.Count(); j++)
  381. //{
  382. // Triple ts_eq = new Triple(list_of_triplets[j].Subject, pred_eq, obj_to_add_eq);
  383. // listBox3.Items.Add("EQUIVALENT CLASS \n");
  384. // listBox3.Items.Add(ts_eq.ToString());
  385. // //g_KB.Assert(ts_eq);
  386. // //tw_1.Save(g_KB, "CmapInTurtle.n3");
  387.  
  388. //}
  389.  
  390.  
  391.  
  392. }
  393.  
  394. // [Obsolete]
  395. private void button3_Click(object sender, EventArgs e)
  396. { }
  397. // {
  398.  
  399. // Regex regex = new Regex("auto");
  400.  
  401. // var g1 = new Graph();
  402. // FileLoader.Load(g1, "CmapInTurtle.n3");
  403.  
  404.  
  405. // Graph g2 = new Graph();
  406. // Notation3Parser np = new Notation3Parser();
  407. // np.Load(g2, "Rules.n3");
  408.  
  409. // Graph rez_graph = new Graph();
  410.  
  411. // //g1.NamespaceMap.AddNamespace("ind", new Uri("ind:"));
  412. // //g1.NamespaceMap.AddNamespace("class", new Uri("class:"));
  413.  
  414.  
  415. // //g2.NamespaceMap.AddNamespace("ind", new Uri("ind:"));
  416. // //g2.NamespaceMap.AddNamespace("class", new Uri("class:"));
  417. // //g2.NamespaceMap.AddNamespace("owl", new Uri("owl:"));
  418.  
  419. // rez_graph.NamespaceMap.AddNamespace("ind", new Uri("ind:"));
  420. // rez_graph.NamespaceMap.AddNamespace("class", new Uri("class:"));
  421.  
  422.  
  423. // // ISparqlDataset ds = new InMemoryDataset(g2);
  424. // // LeviathanQueryProcessor processor = new LeviathanQueryProcessor(ds);
  425. // // sparqlQuery("SELECT ?s owl:oneOf ?o WHERE { ?s owl:oneOf ?o . }");
  426. // //string query = "prefix owl:<http://www.w3.org/2002/07/owl#> prefix pr:<lab:property:> prefix class:<lab:classes:> prefix ind:<lab:individuals:> SELECT ?s owl:oneOf ?o WHERE { ?s owl:oneOf ?o . } ";
  427.  
  428.  
  429. // string q1 = @"
  430. //prefix owl:<http://www.w3.org/2002/07/owl#>
  431. //prefix rdf:<http://www.w3.org/1999/02/22-rdf-syntax-ns#>
  432. //SELECT DISTINCT ?s ?o
  433. //WHERE
  434. //{
  435. //?s owl:oneOf ?o.
  436. //?o rdf:rest*/rdf:rest?item
  437. //}";
  438. // string q2 = @"
  439. //prefix owl:<http://www.w3.org/2002/07/owl#>
  440. //prefix rdf:<http://www.w3.org/1999/02/22-rdf-syntax-ns#>
  441. //prefix pr:<lab:property:>
  442. //prefix ot:<lab:other:>
  443. //prefix class:<lab:classes:>
  444. //prefix ind: <lab:individuals:>
  445. //SELECT DISTINCT ?s ?o
  446. //WHERE
  447. //{
  448. //?s owl:disjointWith ?o.
  449. //}
  450. //";
  451.  
  452. // string q3 = @"
  453. //prefix owl:<http://www.w3.org/2002/07/owl#>
  454. //prefix rdf:<http://www.w3.org/1999/02/22-rdf-syntax-ns#>
  455. //prefix pr:<lab:property:>
  456. //prefix ot:<lab:other:>
  457. //prefix class:<lab:classes:>
  458. //prefix ind: <lab:individuals:>
  459. //SELECT DISTINCT ?s ?o
  460. //WHERE
  461. //{
  462. //?s owl:propertyDisjointWith ?o.
  463. //}
  464. //";
  465.  
  466. // ///////////////////////////////////////////////////////// ПРОВЕРКА OneOF ////////////////////////////////////////////////////////////////////////////////
  467.  
  468. // SparqlResultSet rez_set1 = (SparqlResultSet)g2.ExecuteQuery(q1);
  469. // INode obj1 = rez_set1[0][0]; //достал префикс
  470. // var listNode = new List<INode>();
  471. // var listTriple = new List<Triple>();
  472. // var generalList = new List<INode>();
  473. // var generalTRIPLETS = new List<Triple>();
  474. // var generalError = new List<Triple>();
  475. // string pattern_for_ind = @"lab:individuals:";
  476. // Regex regex_ind = new Regex(pattern_for_ind);
  477. // string pattern_for_class = @"lab:classes:";
  478. // Regex regex_clas = new Regex(pattern_for_class);
  479. // int count_ind = 0;
  480.  
  481. // var rules = g2.Triples;
  482.  
  483. // for (int i = 0; i < rez_set1.Count(); i++)
  484. // {
  485. // INode item = rez_set1[i]["s"];
  486. // listNode.Add(item);
  487. // }
  488.  
  489. // foreach (var item in rules)
  490. // {
  491. // listTriple.Add(item);
  492. // listBox3.Items.Add(item);
  493. // }
  494. // for (int i = 0; i < listTriple.Count(); i++)
  495. // {
  496. // Triple rule = listTriple[i];
  497. // string str = listTriple[i].ToString();
  498. // MatchCollection matches = regex.Matches(str);
  499. // if ((matches.Count == 1) && !(listTriple[i].ToString().Contains("nil")))
  500. // {
  501. // if (listTriple[i].ToString().Contains("individuals:"))
  502. // {
  503. // generalList.Add(rule.Object);
  504. // listBox4.Items.Add(rule.Object);
  505.  
  506. // }
  507. // else if (listTriple[i].ToString().Contains("classes:") && !(listTriple[i].ToString().Contains("nil")))
  508. // {
  509. // generalList.Add(rule.Subject);
  510. // listBox4.Items.Add(rule.Subject);
  511. // }
  512. // }
  513. // }
  514. // foreach (var item in generalList)
  515. // {
  516. // if (item.ToString().Contains("individuals"))
  517. // {
  518. // INode subj = item;
  519. // INode pred = g1.GetUriNode("rdf:type");
  520. // generalTRIPLETS = g1.GetTriplesWithSubjectPredicate(subj, pred).ToList();
  521. // count_ind++;
  522. // if (generalTRIPLETS.Count > 0)
  523. // {
  524. // listBox5.Items.Add("Everything is OK");
  525. // continue;
  526. // }
  527. // else
  528. // {
  529. // listBox5.Items.Add("oneOf RULE! There is NO individual like " + generalList[count_ind - 1] + " in class " + generalList[count_ind]);
  530. // }
  531. // }
  532. // }
  533.  
  534. // ///////////////////////////////////////////////////////// ПРОВЕРКА disjointWITH ////////////////////////////////////////////////////////////////////////////////
  535.  
  536. // SparqlResultSet rez_set2 = (SparqlResultSet)g2.ExecuteQuery(q2);
  537. // var listNodeObjDW = new List<INode>();
  538. // var listNodeSUBJDW = new List<INode>();
  539. // var generalListDW = new List<INode>();
  540. // var generalTRIPLETSDW1 = new List<Triple>();
  541. // var generalTRIPLETSDW2 = new List<Triple>();
  542. // var generalErrorDW = new List<Triple>();
  543. // var existingTriple = new List<Triple>();
  544. // int count = 0;
  545. // for (int i = 0; i < rez_set2.Count(); i++)
  546. // {
  547. // INode itemOBJ = rez_set2[i]["s"];
  548. // listNodeObjDW.Add(itemOBJ); //выбрали правую часть запроса
  549. // INode itemSUBJ = rez_set2[i]["o"];
  550. // listNodeSUBJDW.Add(itemSUBJ);
  551. // count++;
  552. // }
  553. // for (int k = 0; k < listTriple.Count(); k++)
  554. // {
  555. // Triple rule = listTriple[k];
  556. // string str = listTriple[k].ToString();
  557. // if (!(listTriple[k].ToString().Contains("auto")) && !(listTriple[k].ToString().Contains("property")) && (listTriple[k].ToString().Contains("disjointWith")))
  558. // {
  559. // generalListDW.Add(rule.Subject);
  560. // listBox4.Items.Add(rule.Subject);
  561. // generalListDW.Add(rule.Object);
  562. // listBox4.Items.Add(rule.Object);
  563. // }
  564. // }
  565. // for (int s = 0; s < (generalListDW.Count) / 2; s++)
  566. // {
  567. // INode obj11 = generalListDW[s];
  568. // INode obj12 = generalListDW[s + 1];
  569. // INode predicate = g1.GetUriNode("rdf:type");
  570. // generalTRIPLETSDW1 = g1.GetTriplesWithPredicateObject(predicate, obj11).ToList();
  571. // generalTRIPLETSDW2 = g1.GetTriplesWithPredicateObject(predicate, obj12).ToList();
  572. // if ((generalTRIPLETSDW1.Count() > 0) && (generalTRIPLETSDW2.Count() > 0) && (((generalTRIPLETSDW1.Count() < generalTRIPLETSDW2.Count()) || ((generalTRIPLETSDW1.Count() == generalTRIPLETSDW2.Count())))))
  573. // {
  574. // foreach (var item in generalTRIPLETSDW2)
  575. // {
  576. // INode subj = item.Subject;
  577. // Triple ts1 = new Triple(subj, predicate, item.Object);
  578. // existingTriple = g1.GetTriplesWithSubjectObject(subj, obj11).ToList();
  579. // if (existingTriple.Count > 0)
  580. // {
  581. // listBox5.Items.Add("disjointWith rule! Individual " + subj + " cannot be both member of " + item.Object + " and " + obj11);
  582. // break;
  583. // }
  584. // else
  585. // {
  586. // listBox5.Items.Add("Everything is OK");
  587. // continue;
  588. // }
  589. // }
  590. // }
  591. // else if ((generalTRIPLETSDW1.Count() > 0) && (generalTRIPLETSDW2.Count() > 0) && (generalTRIPLETSDW1.Count() > generalTRIPLETSDW2.Count()))
  592. // {
  593. // foreach (var item in generalTRIPLETSDW1)
  594. // {
  595. // INode subj = item.Subject;
  596. // Triple ts1 = new Triple(subj, predicate, item.Object);
  597. // existingTriple = g1.GetTriplesWithSubjectObject(subj, obj12).ToList();
  598. // if (existingTriple.Count > 0)
  599. // {
  600. // listBox5.Items.Add("disjointWith rule! Individual " + subj + " cannot be both member of " + item.Object + " and " + obj12);
  601. // break;
  602. // }
  603. // else
  604. // {
  605. // listBox5.Items.Add("Everything is OK");
  606. // continue;
  607. // }
  608. // }
  609. // }
  610.  
  611. // }
  612.  
  613. // ///////////////////////////////////////////////////////// ПРОВЕРКА PropertyDisjointWITH ////////////////////////////////////////////////////////////////////////////////
  614.  
  615. // SparqlResultSet rez_set3 = (SparqlResultSet)g2.ExecuteQuery(q3);
  616. // var listNodeObjDWP = new List<INode>();
  617. // var listNodeSUBJDWP = new List<INode>();
  618. // var generalListDWP = new List<INode>();
  619. // var generalTRIPLETSDWP1 = new List<Triple>();
  620. // var generalTRIPLETSDWP2 = new List<Triple>();
  621. // var generalErrorDWP = new List<Triple>();
  622. // var existingTripleP = new List<Triple>();
  623. // int count2 = 0;
  624.  
  625. // for (int i = 0; i < rez_set3.Count(); i++)
  626. // {
  627. // INode itemOBJ = rez_set3[i]["o"];
  628. // listNodeObjDWP.Add(itemOBJ); //выбрали правую часть запроса
  629. // INode itemSUBJ = rez_set3[i]["s"];
  630. // listNodeSUBJDWP.Add(itemSUBJ);
  631. // count2++;
  632. // }
  633.  
  634. // for (int v = 0; v < listTriple.Count(); v++)
  635. // {
  636. // Triple rule = listTriple[v];
  637. // string str = listTriple[v].ToString();
  638. // if (!(listTriple[v].ToString().Contains("auto")) && (listTriple[v].ToString().Contains("propertyDisjointWith")))
  639. // {
  640. // generalListDWP.Add(rule.Subject);
  641. // listBox4.Items.Add(rule.Subject);
  642. // generalListDWP.Add(rule.Object);
  643. // listBox4.Items.Add(rule.Object);
  644. // }
  645. // }
  646. // for ( int g=0; g<generalListDWP.Count(); g++)
  647. // {
  648. // INode pred1 = generalListDWP[g];
  649. // generalTRIPLETSDWP1 = g1.GetTriplesWithPredicate(pred1).ToList();
  650. // INode pred2 = generalListDWP[g + 1];
  651. // generalTRIPLETSDWP2 = g1.GetTriplesWithPredicate(pred2).ToList();
  652. // if (generalTRIPLETSDWP2.Count() > 0 && generalTRIPLETSDWP2.Count() > 0)
  653. // {
  654. // foreach (var item in generalTRIPLETSDWP2)
  655. // {
  656. // INode subj1 = item.Subject;
  657. // INode subj2 = generalTRIPLETSDWP1[g].Subject;
  658. // INode obj111 = item.Object;
  659. // INode obj222 = generalTRIPLETSDWP1[g].Object;
  660. // if (subj1 == subj2)
  661. // {
  662. // listBox5.Items.Add("propertyDisjointWith rule! " + subj1.ToString() + " cannot both " + pred1 + " " + obj111 + " and " + obj222);
  663. // break;
  664. // }
  665. // }
  666. // }
  667. // else if (generalTRIPLETSDWP1.Count() > 0 || generalTRIPLETSDWP2.Count() > 0)
  668. // {
  669. // listBox5.Items.Add("Everything is OK");
  670. // }
  671. // g++;
  672. // }
  673.  
  674. // }
  675. }
  676. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!