@Test
public void testSave() throws BadRequestException {
folderResourceMap.save();
Model model = ModelFactory.createDefaultModel();
model.read(folderResourceMap.getGraphAsInputStream(RDFFormat.RDFXML), null);
Resource r = model.getResource(folderResourceMap.getUri().toString());
Assert.assertTrue(r.hasProperty(ORE.describes, model.getResource(folder.getUri().toString())));
Assert.assertTrue(r.hasProperty(RDF.type, ORE.ResourceMap));
}
/**
* Builds a model from a turtle representation in a file
*
* @param path
*/
protected Model readModel(String path) {
Model model = null;
if (path != null) {
model = ModelFactory.createDefaultModel();
InputStream inputStream = getClass().getClassLoader().getResourceAsStream(path);
String fakeUri = "http://w3c.github.io/ldp-testsuite/fakesubject";
// Even though null relative URIs are used in the resource representation file,
// the resulting model doesn't keep them intact. They are changed to "file://..." if
// an empty string is passed as base to this method.
model.read(inputStream, fakeUri, "TURTLE");
// At this point, the model should contain a resource named
// "http://w3c.github.io/ldp-testsuite/fakesubject" if
// there was a null relative URI in the resource representation
// file.
Resource subject = model.getResource(fakeUri);
if (subject != null) {
ResourceUtils.renameResource(subject, "");
}
try {
inputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
return model;
}
public Spec(final String spec_filename, final String spec_uri) {
if (null == spec_filename) {
throw new RuntimeException("Can't create spec and filename was null");
}
Logger log = Logger.getLogger(Spec.class.getName());
try {
log.log(Level.INFO, "Attempting to create Spec from {0}", spec_filename);
Path pt = new Path(spec_filename);
FileSystem fs = FileSystem.get(new Configuration());
log.log(Level.INFO, "Opening {0}", spec_filename);
FSDataInputStream stream = fs.open(pt);
_model = ModelFactory.createDefaultModel();
// _model.setNsPrefixes(getPrefixes());
RDFReader reader = this._model.getReader("TURTLE");
log.log(Level.INFO, "Reading {0}", spec_filename);
reader.read(this._model, stream, "http://put.a.base.in.your.spec/");
log.log(Level.INFO, "Successfully created Spec from {0}", spec_filename);
_specResource = _model.getResource(spec_uri);
if (!_model.containsResource(_specResource)) {
log.log(
Level.WARNING,
"Spec file {0} does not contain spec {1}",
new Object[] {spec_filename, spec_uri});
throw new RuntimeException(
"Spec file " + spec_filename + " does not contain spec " + spec_uri);
}
} catch (IOException ex) {
log.log(Level.SEVERE, "Caught IOException, converting to RuntimeException", ex);
throw new RuntimeException(ex);
}
}
/**
* If the {@link ConfigurationProperties} has a name for the initial admin user, create the user
* and add it to the model.
*/
protected void createInitialAdminUser(Model model) {
String initialAdminUsername = ConfigurationProperties.getProperty("initialAdminUser");
if (initialAdminUsername == null) {
return;
}
// A hard-coded MD5 encryption of "defaultAdmin"
String initialAdminPassword = "******";
String vitroDefaultNs = DEFAULT_DEFAULT_NAMESPACE;
Resource user = model.createResource(vitroDefaultNs + "defaultAdminUser");
model.add(
model.createStatement(
user,
model.createProperty(VitroVocabulary.RDF_TYPE),
model.getResource(VitroVocabulary.USER)));
model.add(
model.createStatement(
user,
model.createProperty(VitroVocabulary.USER_USERNAME),
model.createTypedLiteral(initialAdminUsername)));
model.add(
model.createStatement(
user,
model.createProperty(VitroVocabulary.USER_MD5PASSWORD),
model.createTypedLiteral(initialAdminPassword)));
model.add(
model.createStatement(
user,
model.createProperty(VitroVocabulary.USER_ROLE),
model.createTypedLiteral("role:/50")));
}
@Test
public void testUpdate() throws Exception {
Resource rhmRes = model.getResource(FakeRDFModel.rhm);
Property name = model.getProperty(foaf + "name");
Statement nameSt = rhmRes.listProperties(name).nextStatement();
String originalName = nameSt.getLiteral().getString();
// assume update is always first remove and then add
model.remove(nameSt);
model.add(rhmRes, name, "TESTNAME");
assert changes.size() == 2;
assert rhmRes.listProperties(name).toList().size() == 1;
assert rhmRes.listProperties(name).nextStatement().getLiteral().getString().equals("TESTNAME");
changes.undo();
assert changes.size() == 2;
assert rhmRes.listProperties(name).toList().size() == 1;
assert rhmRes
.listProperties(name)
.nextStatement()
.getLiteral()
.getString()
.equals(originalName);
changes.redo();
assert changes.size() == 2;
assert rhmRes.listProperties(name).toList().size() == 1;
assert rhmRes.listProperties(name).nextStatement().getLiteral().getString().equals("TESTNAME");
}
@Test
public void testDelete() throws Exception {
Resource rhmRes = model.getResource(FakeRDFModel.rhm);
Model toRemove = ModelFactory.createDefaultModel();
toRemove.add(model.listStatements(rhmRes, null, (RDFNode) null));
toRemove.add(model.listStatements(null, null, rhmRes));
model.remove(toRemove);
Model foo = changes.get(0).getChange();
assert changes.size() == 1;
assert !model.containsResource(rhmRes);
changes.undo();
assert changes.size() == 1;
assert model.containsResource(rhmRes);
assert model.containsAll(foo);
changes.redo();
assert changes.size() == 1;
assert !model.containsResource(rhmRes);
}
public static void main(String[] args) {
Store store = HBaseRdfFactory.connectStore("Store/hbaserdf-simple.ttl");
store.getTableFormatter().format();
Model model = HBaseRdfFactory.connectDefaultModel(store);
model.add(
model.createResource("http://example.org/person#John"),
VCARD.FN,
model.asRDFNode(Node.createLiteral("John Smith")));
model.add(
model.createResource("http://example.org/person#John"),
VCARD.EMAIL,
model.asRDFNode(Node.createLiteral("*****@*****.**")));
model.add(
model.createResource("http://example.org/person#Jim"),
VCARD.FN,
model.asRDFNode(Node.createLiteral("Jim Mason")));
model.add(
model.createResource("http://example.org/person#Jim"),
VCARD.EMAIL,
model.asRDFNode(Node.createLiteral("*****@*****.**")));
model.add(
model.createResource("http://example.org/person#Bob"),
VCARD.FN,
model.asRDFNode(Node.createLiteral("Bob Brown")));
model.add(
model.createResource("http://example.org/person#Bob"),
VCARD.EMAIL,
model.asRDFNode(Node.createLiteral("*****@*****.**")));
StmtIterator iter = model.listStatements();
while (iter.hasNext()) {
System.out.println(iter.next().toString());
}
iter = model.getResource("http://example.org/person#John").listProperties();
while (iter.hasNext()) {
System.out.println(iter.next().toString());
}
ResIterator resIter = model.listSubjects();
while (resIter.hasNext()) {
System.out.println(resIter.next().toString());
}
String query =
" PREFIX vcard: <http://www.w3.org/2001/vcard-rdf/3.0#> "
+ " SELECT ?x "
+ " WHERE "
+ " { "
+ " <http://example.org/person#John> vcard:FN ?x "
+ " } ";
QueryExecution qe = QueryExecutionFactory.create(query, model);
ResultSet rs = qe.execSelect();
ResultSetFormatter.out(rs);
}
public static EConcept getEConcept(QuerySolution qs, Model model) {
EConcept con = new EConcept();
String uri = qs.get("?concept").toString().trim();
String id = model.getResource(uri).getLocalName();
String name = qs.get("?c_name").toString().trim();
con.setCid(id);
con.setName(StringExchanger.getCommonString(name));
return con;
}
/** @param model */
public PreSummaryStatistics(Model model) {
super(model);
for (String out : nonStrProcessorOutputs) {
if (WfDescRdfUtils.isTopLevelVisible(model.getResource(out), model)) {
topLevelVisibleOutputPorts.add(out);
}
if (WfDescRdfUtils.isBookmarked(model.getResource(out), model)) {
bookmarkedIntermediaryProcessorOutputPorts.add(out);
}
}
groundTruthImportant.addAll(topLevelVisibleOutputPorts);
groundTruthImportant.addAll(bookmarkedIntermediaryProcessorOutputPorts);
groundTruthUnimportant.addAll(nonStrProcessorOutputs);
groundTruthUnimportant.removeAll(groundTruthImportant);
}
public boolean doGet(
MappedResource resource,
Property property,
boolean isInverse,
HttpServletRequest request,
HttpServletResponse response,
Configuration config)
throws IOException {
Model descriptions = getAnonymousPropertyValues(resource, property, isInverse);
if (descriptions.size() == 0) {
return false;
}
Resource r = descriptions.getResource(resource.getWebURI());
List resourceDescriptions = new ArrayList();
StmtIterator it =
isInverse ? descriptions.listStatements(null, property, r) : r.listProperties(property);
while (it.hasNext()) {
Statement stmt = it.nextStatement();
RDFNode value = isInverse ? stmt.getSubject() : stmt.getObject();
if (!value.isAnon()) {
continue;
}
resourceDescriptions.add(
new ResourceDescription((Resource) value.as(Resource.class), descriptions, config));
}
Model description = getResourceDescription(resource);
ResourceDescription resourceDescription =
new ResourceDescription(resource, description, config);
String title =
resourceDescription.getLabel()
+ (isInverse ? " ? " : " ? ")
+ config.getPrefixes().getNsURIPrefix(property.getNameSpace())
+ ":"
+ property.getLocalName();
VelocityHelper template = new VelocityHelper(getServletContext(), response);
Context context = template.getVelocityContext();
context.put("project_name", config.getProjectName());
context.put("project_link", config.getProjectLink());
context.put("title", title);
context.put("server_base", config.getWebApplicationBaseURI());
context.put("sparql_endpoint", resource.getDataset().getDataSource().getEndpointURL());
context.put("back_uri", resource.getWebURI());
context.put("back_label", resourceDescription.getLabel());
context.put(
"rdf_link",
isInverse ? resource.getInversePathDataURL(property) : resource.getPathDataURL(property));
context.put("resources", resourceDescriptions);
template.renderXHTML("pathpage.vm");
return true;
}
@Test
public void testSaveFolderEntryData() throws BadRequestException {
InputStream is =
getClass().getClassLoader().getResourceAsStream(FolderBuilder.DEFAULT_FOLDER_PATH);
researchObject.aggregate("new-resource", is, "text/plain");
is =
getClass()
.getClassLoader()
.getResourceAsStream("model/ro/folder_resource_map/folder_entry.rdf");
FolderEntry fe = folder.createFolderEntry(is);
folderResourceMap.saveFolderEntryData(fe);
Model model = ModelFactory.createDefaultModel();
model.read(folderResourceMap.getGraphAsInputStream(RDFFormat.RDFXML), null);
Resource r = model.getResource(fe.getUri().toString());
Assert.assertTrue(r.hasProperty(RDF.type, RO.FolderEntry));
r = model.getResource(fe.getProxyFor().getUri().toString());
Assert.assertTrue(
r.hasProperty(ORE.isAggregatedBy, model.getResource(fe.getProxyIn().getUri().toString())));
r = model.getResource(fe.getProxyIn().getUri().toString());
Assert.assertTrue(
r.hasProperty(ORE.aggregates, model.getResource(fe.getProxyFor().getUri().toString())));
}
public static ISCB_Resource getEResource(QuerySolution qs, Model model) {
ISCB_Resource res = new ISCB_Resource();
String uri = qs.get("?resource").toString().trim();
String id = model.getResource(uri).getLocalName();
String name = qs.get("?r_name").toString().trim();
String difficulty = qs.get("?r_difficulty").toString().trim();
String fileLocation = qs.get("?r_fileLocation").toString().trim();
res.setRid(id);
res.setName(StringExchanger.getCommonString(name));
res.setDifficulty(StringExchanger.getCommonString(difficulty));
res.setFileLocation(StringExchanger.getCommonString(fileLocation));
return res;
}
private void unifyRDFSVersion(String ns) {
for (Iterator it = Jena.cloneIt(model.listStatements()); it.hasNext(); ) {
Statement s = (Statement) it.next();
Resource newSubject = s.getSubject();
Property newPredicate = s.getPredicate();
RDFNode newObject = s.getObject();
boolean changed = false;
if (ns.equals(newSubject.getNameSpace())) {
changed = true;
newSubject = model.getResource(RDFS.getURI() + newSubject.getLocalName());
}
if (ns.equals(newPredicate.getNameSpace())) {
changed = true;
newPredicate = model.getProperty(RDFS.getURI() + newPredicate.getLocalName());
}
if (newObject.canAs(Resource.class)) {
Resource oldResource = (Resource) newObject.as(Resource.class);
if (ns.equals(oldResource.getNameSpace())) {
changed = true;
newObject = model.getResource(RDFS.getURI() + oldResource.getLocalName());
}
}
if (changed) {
model.add(newSubject, newPredicate, newObject);
if (log.isLoggable(Level.FINE)) {
log.fine(
"Replaced deprecated triple "
+ s
+ " with "
+ newSubject
+ ", "
+ newPredicate
+ ", "
+ newObject);
}
it.remove();
}
}
}
public static ELearner getELearner(QuerySolution qs, Model model) {
ELearner el = new ELearner();
String uri = qs.get("?elearner").toString().trim();
String id = model.getResource(uri).getLocalName();
String name = qs.get("?el_name").toString().trim();
String grade = qs.get("?el_grade").toString().trim();
String email = qs.get("?el_email").toString().trim();
String address = qs.get("?el_address").toString().trim();
el.setId(id);
el.setName(StringExchanger.getCommonString(name));
el.setGrade(StringExchanger.getCommonString(grade));
el.setEmail(StringExchanger.getCommonString(email));
el.setAddress(StringExchanger.getCommonString(address));
return el;
}
public Collection<URI> getSupportedFacets(URI needUri) throws NoSuchNeedException {
List<URI> ret = new LinkedList<URI>();
Need need = DataAccessUtils.loadNeed(needRepository, needUri);
Model content = rdfStorageService.loadContent(need);
if (content == null) return ret;
Resource baseRes = content.getResource(content.getNsPrefixURI(""));
StmtIterator stmtIterator = baseRes.listProperties(WON.HAS_FACET);
while (stmtIterator.hasNext()) {
RDFNode object = stmtIterator.nextStatement().getObject();
if (object.isURIResource()) {
ret.add(URI.create(object.toString()));
}
}
return ret;
}
/**
* Gets Jena statement selector corresponding to the NXRelations statement.
*
* @param graph the jena graph
* @param nuxStatement NXRelations statement
* @return jena statement selector
*/
private static SimpleSelector getJenaSelector(Model graph, Statement nuxStatement) {
com.hp.hpl.jena.rdf.model.Resource subjResource = null;
com.hp.hpl.jena.graph.Node subject = getJenaNode(nuxStatement.getSubject());
if (subject != null && subject.isURI()) {
subjResource = graph.getResource(subject.getURI());
}
Property predProp = null;
com.hp.hpl.jena.graph.Node predicate = getJenaNode(nuxStatement.getPredicate());
if (predicate != null && predicate.isURI()) {
predProp = graph.getProperty(predicate.getURI());
}
com.hp.hpl.jena.graph.Node object = getJenaNode(nuxStatement.getObject());
RDFNode objRDF = null;
if (object != null) {
objRDF = graph.asRDFNode(object);
}
return new SimpleSelector(subjResource, predProp, objRDF);
}
private void registerResources() {
try {
String personURI = "http://example.org/JohnSmith";
Model model = ModelFactory.createDefaultModel();
model.createResource(personURI).addProperty(VCARD.FN, "John Smith");
// TODO mein Test
model
.getResource(personURI)
.addProperty(
VCARD.N,
model
.createResource()
.addProperty(VCARD.Given, "John")
.addProperty(VCARD.Family, "Smith"));
// Ende TODO
resources.put(prefix + "JohnSmith", model);
URI resourceTargetUri =
new URI(
"http://"
+ EntityManager.SSP_DNS_NAME
// + ":" + EntityManager.SSP_HTTP_SERVER_PORT
+ prefix
+ "JohnSmith");
EntityManager.getInstance().entityCreated(resourceTargetUri, this);
if (log.isDebugEnabled()) {
log.debug("[SimpleBackend] Successfully added new resource at " + resourceTargetUri);
}
} catch (URISyntaxException e) {
log.fatal("[SimpleBackend] This should never happen.", e);
}
}
/**
* @see org.caboto.jena.db.Database#updateProperty(java.lang.String, java.lang.String,
* com.hp.hpl.jena.rdf.model.Property, com.hp.hpl.jena.rdf.model.RDFNode)
*/
public boolean updateProperty(String uri, String resourceUri, Property property, RDFNode value) {
try {
log.info("Updting property in model: " + uri + " " + reasoner);
Data data = getData();
Model m = data.getModel(uri);
if (!m.containsResource(ResourceFactory.createResource(resourceUri))) {
m.close();
data.close();
return false;
}
Resource resource = m.getResource(resourceUri);
if (resource.hasProperty(property)) {
resource.getProperty(property).changeObject(value);
} else {
resource.addProperty(property, value);
}
m.close();
data.close();
return true;
} catch (DataException e) {
e.printStackTrace();
return false;
}
}
/**
* ************************************************************************** THE ID of the
* ontology is the same as its URI This method is used to exchange the standard uri to the id.
*
* @param qs
* @param model
* @param column eg:"?elearner"
* @return id
*/
public static String getIdByURI(QuerySolution qs, Model model, String column) {
String uri = qs.get(column).toString();
String id = model.getResource(uri).getLocalName();
return id;
}
/* (non-Javadoc)
* @see org.dllearner.algorithms.qtl.impl.QueryTreeFactory#getQueryTree(java.lang.String, com.hp.hpl.jena.rdf.model.Model, int)
*/
@Override
public RDFResourceTree getQueryTree(String example, Model model, int maxDepth) {
return createTree(model.getResource(example), model, maxDepth);
}
public Resource lookUp(String pLookUpText, String[] pRangeTypes) {
Model model = null;
Resource resultResc = null;
String line = null;
String result = "";
BufferedReader reader = null;
HttpURLConnection lConnection = null;
URL lUrl = null;
// KeywordSearch?QueryString=string&QueryClass=string&MaxHits=string";
// logger.debug(this.urlService+"?QueryString=" + pLookUpText +
// "&MaxHits="+this.MaxHits+"&QueryClass=");
try {
lUrl =
new URL(
this.urlService
+ "?QueryString="
+ URLEncoder.encode(pLookUpText, "UTF-8")
+ "&MaxHits="
+ this.MaxHits
+ "&QueryClass=");
// set up out communications stuff
lConnection = null;
// Set up the initial connection
lConnection = (HttpURLConnection) lUrl.openConnection();
lConnection.setRequestMethod("GET");
lConnection.setDoOutput(true);
lConnection.setReadTimeout(30000);
lConnection.connect();
// logger.info("Encoding:" + lConnection.getContentEncoding());
reader = new BufferedReader(new InputStreamReader(lConnection.getInputStream()));
while ((line = reader.readLine()) != null) {
result += line;
}
} catch (MalformedURLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
if (result != "") {
String patternStr = "<ArrayOfResult(.*?)</ArrayOfResult>";
Pattern pattern = Pattern.compile(patternStr);
Matcher matcher = pattern.matcher(result);
if (matcher.find()) {
String groupStr = matcher.group(0);
// logger.debug(" matcher.groupCount() "+ matcher.groupCount());
StringReader xml = new StringReader(groupStr);
DbpediaDigester digester = new DbpediaDigester();
ArrayOfResult arrayRes = digester.digestArrayOfResult(xml);
List<Result> results = arrayRes.getResults();
// logger.debug(" results.size() "+ results.size());
if (results.size() > 0) {
Iterator<Result> it;
// compare results with types provided in the parameters
if (pRangeTypes != null) {
it = results.iterator();
while (it.hasNext() && resultResc == null) {
Result r = it.next();
// compare if the classes are the same type as requested in the parameters
Iterator<SemanticClass> itClass = r.getSemanticClasses().iterator();
boolean found = false;
while (itClass.hasNext()) {
SemanticClass mclass = itClass.next();
for (int i = 0; i < pRangeTypes.length; i++) {
// compare that the type set is contained in the type got (lower case comperison)
// logger.debug(" Compare "+ mclass.getMlabel().toLowerCase() + " with "
// +pRangeTypes[i].toLowerCase());
if (mclass.getMlabel().toLowerCase().contains(pRangeTypes[i].toLowerCase())) {
logger.debug(
" LOOKUP found type "
+ pLookUpText
+ " "
+ pRangeTypes[i]
+ " CLASS "
+ mclass.getMlabel());
if (doubleCheckSimilarity) {
logger.debug(" DOUBLE CHECK ");
if (similartityAlgorithm.getSimilarity(pLookUpText, r.getMlabel())
>= similarityMinScore) {
logger.debug(" OK");
model = DBPediaResult.createModelFromLookUp(r);
resultResc = model.getResource(r.getUri());
found = true;
}
} else {
model = DBPediaResult.createModelFromLookUp(r);
resultResc = model.getResource(r.getUri());
found = true;
}
}
}
if (found) break;
}
}
// logger.debug(" result = "+ result);
}
// else{
if (model == null && obligatoryClass == false) {
// compare similarity
Result res = null;
double maxScore = 0.0;
it = results.iterator();
// gets the result that is more similar
while (it.hasNext()) {
Result r = it.next();
double s =
similartityAlgorithm.getSimilarity(
pLookUpText.toLowerCase(), r.getMlabel().toLowerCase());
if (s > maxScore) {
res = r;
maxScore = s;
}
}
if (maxScore >= similarityMinScore) {
logger.debug(
" LOOKUP found similarity "
+ pLookUpText
+ " "
+ res.getUri()
+ " SCORE "
+ maxScore);
model = DBPediaResult.createModelFromLookUp(res);
resultResc = model.getResource(res.getUri());
}
//
}
} else logger.debug(" LOOKUP result 0");
} else logger.debug(" LOOKUP matcher empty");
} else logger.debug(" LOOKUP result empty");
return resultResc;
}
private String doRename(String oldNamespace, String newNamespace) {
String uri = null;
String result = null;
Integer counter = 0;
Boolean namespacePresent = false;
RDFService rdfService = ModelAccess.on(getServletContext()).getRDFService();
try {
Model baseOntModel =
RDFServiceGraph.createRDFServiceModel(new RDFServiceGraph(rdfService, ABOX_ASSERTIONS));
OntModel ontModel = ModelAccess.on(getServletContext()).getOntModel();
List<String> urisToChange = new LinkedList<String>();
ontModel.enterCriticalSection(Lock.READ);
try {
Iterator<Individual> indIter = ontModel.listIndividuals();
while (indIter.hasNext()) {
Individual ind = indIter.next();
String namespace = ind.getNameSpace();
if (namespace != null) {
if (oldNamespace.equals(namespace)) {
uri = ind.getURI();
urisToChange.add(uri);
namespacePresent = true;
}
}
}
} finally {
ontModel.leaveCriticalSection();
}
if (!namespacePresent) {
result = "no resources renamed";
return result;
}
for (String oldURIStr : urisToChange) {
long time1 = System.currentTimeMillis();
Resource res = baseOntModel.getResource(oldURIStr);
long time2 = System.currentTimeMillis();
String newURIStr = null;
Pattern p = Pattern.compile(oldNamespace);
String candidateString = res.getURI();
Matcher matcher = p.matcher(candidateString);
newURIStr = matcher.replaceFirst(newNamespace);
long time3 = System.currentTimeMillis();
log.debug("time to get new uri: " + Long.toString(time3 - time2));
log.debug("Renaming " + oldURIStr + " to " + newURIStr);
String whereClause =
"} WHERE { \n"
+ " GRAPH <"
+ ABOX_ASSERTIONS
+ "> { \n"
+ " { <"
+ oldURIStr
+ "> ?p <"
+ oldURIStr
+ "> } \n "
+ " UNION \n"
+ " { <"
+ oldURIStr
+ "> ?q ?o } \n "
+ " UNION \n"
+ " { ?s ?r <"
+ oldURIStr
+ "> } \n"
+ " } \n"
+ "}";
String removeQuery =
"CONSTRUCT { \n"
+ " <"
+ oldURIStr
+ "> ?p <"
+ oldURIStr
+ "> . \n "
+ " <"
+ oldURIStr
+ "> ?q ?o . \n "
+ " ?s ?r <"
+ oldURIStr
+ "> \n"
+ whereClause;
String addQuery =
"CONSTRUCT { \n"
+ " <"
+ newURIStr
+ "> ?p <"
+ newURIStr
+ "> . \n "
+ " <"
+ newURIStr
+ "> ?q ?o . \n "
+ " ?s ?r <"
+ newURIStr
+ "> \n"
+ whereClause;
try {
ChangeSet cs = rdfService.manufactureChangeSet();
cs.addAddition(
rdfService.sparqlConstructQuery(addQuery, RDFService.ModelSerializationFormat.N3),
RDFService.ModelSerializationFormat.N3,
ABOX_ASSERTIONS);
cs.addRemoval(
rdfService.sparqlConstructQuery(removeQuery, RDFService.ModelSerializationFormat.N3),
RDFService.ModelSerializationFormat.N3,
ABOX_ASSERTIONS);
rdfService.changeSetUpdate(cs);
} catch (RDFServiceException e) {
throw new RuntimeException(e);
}
long time4 = System.currentTimeMillis();
log.debug(" time to rename : " + Long.toString(time4 - time3));
log.debug(" time for one resource: " + Long.toString(time4 - time1));
counter++;
}
result = counter.toString() + " resources renamed";
return result;
} finally {
if (rdfService != null) {
rdfService.close();
}
}
}
/**
* @param args
* @throws IOException
*/
public static void main(String[] args) throws IOException {
// TODO Auto-generated method stub
Model m = ModelFactory.createDefaultModel();
CSVReader reader = new CSVReader(new FileReader("Book2.csv"));
String[] nextLine;
String[] properties = reader.readNext();
String ns = "http://aksw.org/Saleh/resource/";
// for each property
for (String property : properties)
// create property
m.createProperty(property);
int i = 1;
HashMap<String, String> created = new HashMap<>();
while ((nextLine = reader.readNext()) != null) {
Resource cl;
if (!created.containsKey(nextLine[0])) {
created.put(nextLine[0], ns + "Class" + i);
// create classes
cl =
m.createResource(
ns + "Class" + i, m.getResource("http://www.w3.org/2000/01/rdf-schema#Class"));
m.add(cl, m.getProperty("http://www.w3.org/2000/01/rdf-schema#label"), nextLine[0]);
} else {
cl = m.getResource(created.get(nextLine[0]));
}
// create instance
Resource r = m.createResource(ns + "Drug" + i, cl);
// for each column
for (int j = 1; j < nextLine.length; j++)
// create the triple
m.add(r, m.getProperty(properties[j]), nextLine[j]);
i++;
}
// print turtle file
m.write(System.out, "TURTLE");
// uncomment these to print all statements
// Iterator<Statement> it = m.listStatements();
// while (it.hasNext())
// System.out.println(it.next());
reader.close();
// save to file
try {
FileOutputStream fout = new FileOutputStream("output.ttl");
m.write(fout, "TURTLE");
} catch (IOException e) {
System.out.println("Exception caught" + e.getMessage());
e.printStackTrace();
}
}
public Resource CreateResource(String resourceName) {
if (hbaseModel.containsResource(hbaseModel.createResource(NS + resourceName))) {
return hbaseModel.getResource(resourceName);
}
return hbaseModel.createResource(NS + resourceName);
}
/**
* @param predicates: list of targeted predicates to enrich the model It calls
* getTriplesWithObjectsAreURI() method retrieving list of triples in model having URI-typed
* objects. For each object of them, it is checked if it is in DBpedia (can be extended later)
* then calls getURIInfo() method to dereference the URI-typed object in HashMap and retrieve
* the targeted predicates values "if exist", it iterates over the HashMap and add them to the
* resources in the model.
*/
private static void addAdditionalPropertiesUsingBlankNode(Map<String, String> predicates) {
// Map <predicate,value> save each interesting predicate of the URI object
Map<Property, List<RDFNode>> resourceInterestingInfoExtension =
new HashMap<Property, List<RDFNode>>();
// Map<object,objectResourceData> to save each object with its related data resource and be
// retrieved whenever a URI object data needed to be added for extension
Map<RDFNode, Resource> objectFilledResource = new HashMap<RDFNode, Resource>();
// Get list of unique URI objects in the data source as http://dbpedia.org/resource/XXXX
List<RDFNode> urisObjects = getURIObjects();
// Get information for each single distinct objectURI according to interesting predicates
logger.info("Number of unique URI object to find extension: " + urisObjects.size());
if (urisObjects.size() > 0) {
// The object resource that will have each URI object extended data
Resource object = null;
int count = 1;
// For each URI object a resource is created, filled with information,add the object with its
// data resource into map
for (RDFNode uriObject : urisObjects) {
logger.info("Predicate " + count++ + " of " + urisObjects.size() + ":" + uriObject);
// Create a resource with empty node
object = localModel.createResource();
// Retrieve all interesting <predicate,object> info. for such URI object
resourceInterestingInfoExtension = DereferencingModule.getURIInfo(uriObject);
// Add information to the resource
for (Property key : resourceInterestingInfoExtension.keySet()) {
// add the new properties to the new triple
List<RDFNode> subjects = resourceInterestingInfoExtension.get(key);
for (RDFNode subject : subjects) {
if (subject.isLiteral()) {
object.addProperty(key, subject.asLiteral().toString());
} else {
object.addProperty(key, subject);
}
}
}
// Add to list of object's resource that is filled with information
objectFilledResource.put(uriObject, object);
}
} else { // Otherwise no URI objects to be extended
return;
}
List<Statement> triplesWithURIsObjects = getTriplesWithURIObjects();
logger.info("Starting model enriching");
if (triplesWithURIsObjects.size() > 0) {
Resource object = null;
// iterate over each triple to dereference each URI object and add its information to its
// resource subject
for (Statement triple : triplesWithURIsObjects) {
// create new triple with empty node as its subject where this subject will be an object of
// the targeted resource to be extended
if (!objectFilledResource.containsKey(triple.getSubject())) {
object = objectFilledResource.get(triple.getObject());
objectsDerefModelAdded.put(triple.getObject(), object);
// Attach the object's resource to this subject
Resource resource = localModel.getResource(triple.getSubject().getURI());
resource.addProperty(defaultOutputProperty, object);
resourceInterestingInfoExtension = null;
}
}
}
}
/**
* @param uri : the URI to be dereferenced
* @param predicates : targeted predicates to be added to enrich the model
* @return This method retrieves list of values for targeted predicates for a URI-typed object for
* each URI-typed object, through content negotiation an open connection is done retrieving
* its predicates/values. An iteration is made over targeted predicates. For each predicate
* list of statements with the targeted predicate is retrieved and extracting its value in
* order to be added to hashmap<predicate,Value>
*/
@SuppressWarnings("unchecked")
private static HashMap<Property, List<RDFNode>> getURIInfo(RDFNode p) {
String uri = p.asResource().getURI();
// to store each predicate and its value
HashMap<Property, List<RDFNode>> resourceFocusedInfo = new HashMap<Property, List<RDFNode>>();
if (demo) { // Deserialize the results if exists (For Demo purpose)
if (useCache) {
try {
HashMap<String, List<String>> ser = new HashMap<String, List<String>>();
File file = new File("resourceFocusedInfo.ser");
if (file.exists()) {
ObjectInputStream in = new ObjectInputStream(new FileInputStream(file));
ser = (HashMap<String, List<String>>) in.readObject();
in.close();
// convert every object back from string
for (String prop : ser.keySet()) {
List<String> l = ser.get(prop);
List<RDFNode> nodes = new ArrayList<RDFNode>();
for (String n : l) {
nodes.add(ResourceFactory.createResource(n));
}
resourceFocusedInfo.put(ResourceFactory.createProperty(prop), nodes);
}
return resourceFocusedInfo;
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
// define local model to have the data of the URI and extract focused info through built sparql
// query
List<RDFNode> values = new ArrayList<RDFNode>();
try {
URLConnection conn = new URL(uri).openConnection();
conn.setRequestProperty("Accept", "application/rdf+xml");
conn.setRequestProperty("Accept-Language", "en");
Model model = ModelFactory.createDefaultModel();
InputStream in = conn.getInputStream();
model.read(in, null);
for (Property inputProperty : inputProperties) {
for (Statement st :
model.listStatements(model.getResource(uri), inputProperty, (RDFNode) null).toList()) {
RDFNode value = st.getObject();
if (value.isLiteral()) {
if (value.asLiteral().getLanguage().toLowerCase().equals("en")
|| value.asLiteral().getLanguage().toLowerCase().equals("")) {
values.add(value);
}
} else {
values.add(value);
}
}
resourceFocusedInfo.put(inputProperty, values);
values = new ArrayList<RDFNode>(); // create new list for new predicate
}
} catch (Exception e) {
e.printStackTrace();
}
if (demo) { // serialize the output (for Demo purpose)
try {
HashMap<String, List<String>> ser = new HashMap<String, List<String>>();
FileOutputStream fileOut = new FileOutputStream("resourceFocusedInfo.ser");
ObjectOutputStream out = new ObjectOutputStream(fileOut);
// convert to Serializabe Strings
for (Property prop : resourceFocusedInfo.keySet()) {
List<String> l = new ArrayList<String>();
for (RDFNode n : resourceFocusedInfo.get(prop)) {
l.add(n.toString());
}
ser.put(prop.toString(), l);
}
out.writeObject(ser);
out.close();
} catch (Exception e2) {
e2.printStackTrace();
}
}
return resourceFocusedInfo;
}
/** Vocabulary definitions from file:vocabularies/owl.owl */
public class OWL {
/** The RDF model that holds the vocabulary terms */
private static Model m_model = ModelFactory.createDefaultModel();
/** The namespace of the vocabulary as a string ({@value}) */
public static final String NS = "http://www.w3.org/2002/07/owl#";
/**
* The namespace of the vocabulary as a string
*
* @see #NS
*/
public static String getURI() {
return NS;
}
/** The namespace of the vocabulary as a resource */
public static final Resource NAMESPACE = m_model.createResource(NS);
/** A resource that denotes the OWL-full sublanguage of OWL */
public static final Resource FULL_LANG = m_model.getResource(getURI());
/** A resource, not officially sanctioned by WebOnt, that denotes the OWL-DL sublanguage of OWL */
public static final Resource DL_LANG =
m_model.getResource("http://www.w3.org/TR/owl-features/#term_OWLDL");
/**
* A resource, not officially sanctioned by WebOnt, that denotes the OWL-Lite sublanguage of OWL
*/
public static final Resource LITE_LANG =
m_model.getResource("http://www.w3.org/TR/owl-features/#term_OWLLite");
// Vocabulary properties
///////////////////////////
public static final Property maxCardinality =
m_model.createProperty("http://www.w3.org/2002/07/owl#maxCardinality");
public static final Property versionInfo =
m_model.createProperty("http://www.w3.org/2002/07/owl#versionInfo");
public static final Property equivalentClass =
m_model.createProperty("http://www.w3.org/2002/07/owl#equivalentClass");
public static final Property distinctMembers =
m_model.createProperty("http://www.w3.org/2002/07/owl#distinctMembers");
public static final Property oneOf =
m_model.createProperty("http://www.w3.org/2002/07/owl#oneOf");
public static final Property sameAs =
m_model.createProperty("http://www.w3.org/2002/07/owl#sameAs");
public static final Property incompatibleWith =
m_model.createProperty("http://www.w3.org/2002/07/owl#incompatibleWith");
public static final Property minCardinality =
m_model.createProperty("http://www.w3.org/2002/07/owl#minCardinality");
public static final Property complementOf =
m_model.createProperty("http://www.w3.org/2002/07/owl#complementOf");
public static final Property onProperty =
m_model.createProperty("http://www.w3.org/2002/07/owl#onProperty");
public static final Property equivalentProperty =
m_model.createProperty("http://www.w3.org/2002/07/owl#equivalentProperty");
public static final Property inverseOf =
m_model.createProperty("http://www.w3.org/2002/07/owl#inverseOf");
public static final Property backwardCompatibleWith =
m_model.createProperty("http://www.w3.org/2002/07/owl#backwardCompatibleWith");
public static final Property differentFrom =
m_model.createProperty("http://www.w3.org/2002/07/owl#differentFrom");
public static final Property priorVersion =
m_model.createProperty("http://www.w3.org/2002/07/owl#priorVersion");
public static final Property imports =
m_model.createProperty("http://www.w3.org/2002/07/owl#imports");
public static final Property allValuesFrom =
m_model.createProperty("http://www.w3.org/2002/07/owl#allValuesFrom");
public static final Property unionOf =
m_model.createProperty("http://www.w3.org/2002/07/owl#unionOf");
public static final Property hasValue =
m_model.createProperty("http://www.w3.org/2002/07/owl#hasValue");
public static final Property someValuesFrom =
m_model.createProperty("http://www.w3.org/2002/07/owl#someValuesFrom");
public static final Property disjointWith =
m_model.createProperty("http://www.w3.org/2002/07/owl#disjointWith");
public static final Property cardinality =
m_model.createProperty("http://www.w3.org/2002/07/owl#cardinality");
public static final Property intersectionOf =
m_model.createProperty("http://www.w3.org/2002/07/owl#intersectionOf");
// Vocabulary classes
///////////////////////////
public static final Resource Thing =
m_model.createResource("http://www.w3.org/2002/07/owl#Thing");
public static final Resource DataRange =
m_model.createResource("http://www.w3.org/2002/07/owl#DataRange");
public static final Resource Ontology =
m_model.createResource("http://www.w3.org/2002/07/owl#Ontology");
public static final Resource DeprecatedClass =
m_model.createResource("http://www.w3.org/2002/07/owl#DeprecatedClass");
public static final Resource AllDifferent =
m_model.createResource("http://www.w3.org/2002/07/owl#AllDifferent");
public static final Resource DatatypeProperty =
m_model.createResource("http://www.w3.org/2002/07/owl#DatatypeProperty");
public static final Resource SymmetricProperty =
m_model.createResource("http://www.w3.org/2002/07/owl#SymmetricProperty");
public static final Resource TransitiveProperty =
m_model.createResource("http://www.w3.org/2002/07/owl#TransitiveProperty");
public static final Resource DeprecatedProperty =
m_model.createResource("http://www.w3.org/2002/07/owl#DeprecatedProperty");
public static final Resource AnnotationProperty =
m_model.createResource("http://www.w3.org/2002/07/owl#AnnotationProperty");
public static final Resource Restriction =
m_model.createResource("http://www.w3.org/2002/07/owl#Restriction");
public static final Resource Class =
m_model.createResource("http://www.w3.org/2002/07/owl#Class");
public static final Resource OntologyProperty =
m_model.createResource("http://www.w3.org/2002/07/owl#OntologyProperty");
public static final Resource ObjectProperty =
m_model.createResource("http://www.w3.org/2002/07/owl#ObjectProperty");
public static final Resource FunctionalProperty =
m_model.createResource("http://www.w3.org/2002/07/owl#FunctionalProperty");
public static final Resource InverseFunctionalProperty =
m_model.createResource("http://www.w3.org/2002/07/owl#InverseFunctionalProperty");
public static final Resource Nothing =
m_model.createResource("http://www.w3.org/2002/07/owl#Nothing");
// Vocabulary individuals
///////////////////////////
}
public static String[] generateConcepts(DocumentAnalyzer analyzer, String id) {
if (analyzer.Doci.concepts != null && analyzer.Doci.concepts.size() > 0) {
List<Concept> MainConcepts =
analyzer.Doci.concepts.subList(
0, Math.min(analyzer.Doci.concepts.size(), analyzer.MaxNumOfConcepts));
String out = "";
String outForConceptPh = ""; // by concept
String outForMainPh = ""; // for main senatance
ArrayList<String> phs = analyzer.Doci.sentences;
System.out.println(
"Start generating features for "
+ id
+ " with n of sentences: "
+ phs.size()
+ " and main concepts: "
+ MainConcepts.size());
if (phs != null)
for (int i = 0; i < phs.size(); i++) {
try {
String oneOutForMainPh = ""; // for one ph for main senatance
String ph = phs.get(i);
String[] phTerms = ph.toLowerCase().split(" ");
String stemedPh = "";
for (String term : phTerms) {
stemedPh += " " + analyzer.Doci.SBStemmer.stem(term);
}
ArrayList<EnsenDBpediaResource> ress = analyzer.Doci.resourcesInSentenses.get(i);
// build csv for main sentence
// id
oneOutForMainPh += id + "ph" + i;
// QT
int qtScore = 0;
for (String term1 : analyzer.Doci.q.Text.split(" ")) {
if (term1.length() > 3 && ph.toLowerCase().contains(" " + term1.toLowerCase() + " "))
qtScore += ph.toLowerCase().split(term1.toLowerCase()).length - 1;
}
oneOutForMainPh += "," + qtScore;
// QR / QMR
int qrScore = 0;
int qmrScore = 0;
int ptScore = 0;
double csScore = 0.0;
int cns = 0;
double asScore = 0.0;
for (EnsenDBpediaResource res : ress) {
// cs sum of scores
int rank = getRank(analyzer.Doci.concepts, res.getFullUri());
if (rank > -1) csScore += (1 / (1.0 * rank));
asScore += res.similarityScore;
// q's resources
if (DBpediaSpotlightClient.EnsenDBpediaResourceListContains(
analyzer.Doci.q.Resources, res.getFullUri())
> -1) {
qrScore++;
for (int ccIndex = 0; ccIndex < MainConcepts.size(); ccIndex++) {
if (MainConcepts.get(ccIndex).URI.contains(res.getFullUri())) {
qmrScore++;
}
}
}
// groups
for (Group g : analyzer.groups) {
for (Entry<String, Double> pred : g.predicates.entrySet()) {
String[] predicatWords =
pred.getKey().replace("_", " ").split("(?=\\p{Upper})|/| ");
for (int j = 0; j < predicatWords.length; j++) {
if (predicatWords[j].length() > 3
&& ph.toLowerCase().contains(predicatWords[j].toLowerCase())) {
ptScore++;
}
}
}
}
// couble of concepts
Model graph = analyzer.Doci.fullGraph;
StmtIterator stms =
graph.listStatements(
new SimpleSelector(
graph.getResource(res.getFullUri()), null, (RDFNode) null));
while (stms.hasNext()) {
Statement next = stms.next();
if (next.getObject().isResource()) {
if (DBpediaSpotlightClient.EnsenDBpediaResourceListContains(
ress, next.getObject().asResource().getURI())
> -1) cns++;
}
}
}
oneOutForMainPh += "," + qrScore;
oneOutForMainPh += "," + qmrScore;
// mr
int MRScore = 0;
for (int ccIndex = 0; ccIndex < MainConcepts.size(); ccIndex++) {
if (DBpediaSpotlightClient.EnsenDBpediaResourceListContains(
ress, MainConcepts.get(ccIndex).URI)
> -1) {
MRScore++;
}
}
oneOutForMainPh += "," + MRScore;
// ar
oneOutForMainPh += "," + ress.size();
// cns
oneOutForMainPh += "," + cns;
int arlScore = 0;
int mrlScore = 0;
for (int k = 0; k < analyzer.Doci.concepts.size(); k++) {
Concept c = analyzer.Doci.concepts.get(k);
String[] terms = c.name.toLowerCase().split(" ");
for (String term : terms) {
term = analyzer.Doci.SBStemmer.stem(term);
if (stemedPh.contains(" " + term)) {
arlScore++;
if (k < MainConcepts.size()) // main concept
mrlScore++;
}
}
}
// arl
oneOutForMainPh += "," + arlScore;
// mrl
oneOutForMainPh += "," + mrlScore;
// pt
oneOutForMainPh += "," + ptScore;
ptScore = 0;
// as
if (ress.size() > 0) oneOutForMainPh += "," + (asScore / ress.size() * 1.0);
else oneOutForMainPh += ",0";
// len
oneOutForMainPh += "," + ph.length();
// tt
int ttscore = 0;
String[] Tterms = analyzer.Doci.content.getTitle().toLowerCase().split(" ");
for (String term : Tterms) {
term = analyzer.Doci.SBStemmer.stem(term);
if (stemedPh.contains(" " + term)) ttscore++;
}
oneOutForMainPh += "," + ttscore;
// se
oneOutForMainPh += "," + ph.trim().charAt(ph.trim().length() - 1);
// ss
char c = ph.trim().charAt(0);
if (c >= '0' && c <= '9') oneOutForMainPh += ",n";
else if (c >= 'a' && c <= 'z') oneOutForMainPh += ",c";
else if (c >= 'A' && c <= 'A') oneOutForMainPh += ",c";
else oneOutForMainPh += ",o";
// hl
int https = ph.split("http").length - 1;
https += ph.split("www.").length - 1;
https += ph.split(".html").length - 1;
if (https > 0) oneOutForMainPh += ",true";
else oneOutForMainPh += ",false";
// sss
int smallSentence = 0;
for (String s : ph.split(",")) {
if (s.split(" ").length < 3) {
smallSentence++;
}
}
oneOutForMainPh += "," + smallSentence;
// CS
if (ress.size() > 0) oneOutForMainPh += "," + csScore / ress.size();
else oneOutForMainPh += ",0.0";
// nch
double nch = 0;
Pattern p = Pattern.compile("[^A-Za-z ]");
Matcher matcher = p.matcher(ph);
int nchi = 0;
while (matcher.find()) {
matcher.group();
nchi++;
}
nch = nchi * 100.0 / ph.length();
oneOutForMainPh += "," + nch;
// d
boolean d = false;
String DATE_PATTERN =
"([0-9][0-9][0-9][0-9])|([0-9]{2})/([0-9]{2})/([0-9]{4})|([0-9]{2})-([0-9]{2})-([0-9]{4})|([0-9]{4})-([0-9]{2})-([0-9]{2})|([0-9]{4})/([0-9]{2})/([0-9]{2})";
Pattern pattern = Pattern.compile(DATE_PATTERN);
matcher = pattern.matcher(ph);
if (matcher.find()) {
d = true;
}
oneOutForMainPh += "," + d;
// php
double php = i * 100 / phs.size();
oneOutForMainPh += "," + php;
// fph
boolean fph = (i == 0);
oneOutForMainPh += "," + fph;
// lph
boolean lph = (i == phs.size() - 1);
oneOutForMainPh += "," + lph;
// newline
oneOutForMainPh += ",\n";
// build csv for concept-sentence & html files
if (ress != null) {
boolean firstTime = true;
for (int cIndex = 0;
cIndex < Math.min(analyzer.Doci.concepts.size(), analyzer.MaxNumOfConcepts);
cIndex++) {
Concept con = analyzer.Doci.concepts.get(cIndex);
if (DBpediaSpotlightClient.EnsenDBpediaResourceListContains(ress, con.URI) > -1) {
// For HTML
if (firstTime) {
out +=
"<fieldset> <legend>"
+ i
+ "- select for the Snippet: yes <input type='radio' name='Q"
+ analyzer.Doci.q.id
+ "D"
+ analyzer.Doci.Rank
+ "ph"
+ i
+ "' value='Q"
+ analyzer.Doci.q.id
+ "D"
+ analyzer.Doci.Rank
+ "ph"
+ i
+ "'>, no<input type='radio' name='Q"
+ analyzer.Doci.q.id
+ "D"
+ analyzer.Doci.Rank
+ "ph"
+ i
+ "' value='' checked> </legend><p>"
+ ph
+ "</p></hr>";
}
out +=
"<input type='checkbox' value='Q"
+ analyzer.Doci.q.id
+ "D"
+ analyzer.Doci.Rank
+ "C"
+ cIndex
+ "ph"
+ i
+ "'><span><a target='blank' href='"
+ con.URI
+ "'>"
+ con.name
+ "</a></span> ";
firstTime = false;
// for csv
// id
con.phsFeatures +=
"Q" + analyzer.Doci.q.id + "D" + analyzer.Doci.Rank + "C" + cIndex + "ph" + i;
// tct
int tempScore = 0;
int position = -1;
double sim = 0.0; // spotlight similarity
double count = 0.0; // this concept in this paragraph instances counter
for (String term1 : con.name.split(" ")) {
if (term1.length() > 3)
if (ph.toLowerCase().contains(" " + term1.toLowerCase() + " ")) {
if (position == -1) position = ph.indexOf(" " + term1.toLowerCase() + " ");
tempScore += 1;
}
}
con.phsFeatures += "," + tempScore;
// cb
int cbScore = 0;
int cnScore = 0;
Set<String> brothers = new HashSet<String>();
Set<String> neighbors = new HashSet<String>();
if (ress != null)
for (EnsenDBpediaResource res : ress) {
// get position & spotlight similarity
if (res.getFullUri().equals(con.URI)) {
position = ph.indexOf(res.originalText);
sim += res.similarityScore;
count++;
}
// groups
for (Group g : con.groups) {
if (g.auths != null && g.auths.keySet().contains(res.getFullUri()))
brothers.add(res.getFullUri());
// g.auths.keySet().toArray().toString().
if (g.hubs != null && g.hubs.keySet().contains(res.getFullUri()))
brothers.add(res.getFullUri());
for (Entry<String, Double> pred : g.predicates.entrySet()) {
String[] predicatWords =
pred.getKey().replace("_", " ").split("(?=\\p{Upper})|/| ");
for (int j = 0; j < predicatWords.length; j++) {
if (predicatWords[j].length() > 3
&& ph.toLowerCase().contains(predicatWords[j].toLowerCase())) {
ptScore++;
}
}
}
}
// graph
Model g = analyzer.Doci.fullGraph;
StmtIterator res1 =
g.listStatements(
new SimpleSelector(
g.getResource(res.getFullUri()), null, g.getResource(con.URI)));
StmtIterator res2 =
g.listStatements(
new SimpleSelector(
g.getResource(con.URI), null, g.getResource(res.getFullUri())));
while (res1.hasNext()) {
Statement next = res1.next();
neighbors.add(next.getSubject().getURI());
}
while (res2.hasNext()) {
Statement next = res2.next();
neighbors.add(next.getObject().asResource().getURI());
}
}
brothers.remove(con.URI);
cbScore = brothers.size();
con.phsFeatures += "," + cbScore;
// cn
neighbors.remove(con.URI);
cnScore = neighbors.size();
con.phsFeatures += "," + cnScore;
// cbl
int cblScore = 0;
Model m = RDFManager.createRDFModel();
for (String oneBrother : brothers) {
Resource R = m.createResource(oneBrother);
String[] terms = R.getLocalName().toLowerCase().split(" ");
for (String term : terms) {
term = analyzer.Doci.SBStemmer.stem(term);
if (stemedPh.contains(" " + term)) cblScore++;
}
}
con.phsFeatures += "," + cblScore;
// cnl
int cnlScore = 0;
for (String oneNeighbor : neighbors) {
Resource R = m.createResource(oneNeighbor);
String[] terms = R.getLocalName().toLowerCase().split(" ");
for (String term : terms) {
term = analyzer.Doci.SBStemmer.stem(term);
if (stemedPh.contains(" " + term)) cnlScore++;
}
}
con.phsFeatures += "," + cnlScore;
// ca
String stemedAbstract = "";
for (String term : con.abstractTxt.split(" ")) {
term = analyzer.Doci.SBStemmer.stem(term);
stemedAbstract += term + " ";
}
double caScore = jaccardSimilarity(stemedAbstract, stemedPh);
con.phsFeatures += "," + caScore;
// cp
double cpScore = 0;
if (position > -1) cpScore = (ph.length() - position) * 1.0 / ph.length();
if (cpScore > 1) cpScore = 1.0;
con.phsFeatures += "," + cpScore;
// qt
con.phsFeatures += "," + qtScore;
// qr
con.phsFeatures += "," + qrScore;
// mr
con.phsFeatures += "," + MRScore;
// ar
con.phsFeatures += "," + ress.size();
// arl
con.phsFeatures += "," + arlScore;
// mrl
con.phsFeatures += "," + mrlScore;
// pt
con.phsFeatures += "," + ptScore;
// cas
con.phsFeatures += "," + sim / count * 1.0;
// as
if (ress.size() > 0) con.phsFeatures += "," + (asScore / ress.size() * 1.0);
else con.phsFeatures += ",0";
// len
con.phsFeatures += "," + ph.length();
// tt
con.phsFeatures += "," + ttscore;
// se
con.phsFeatures += "," + ph.trim().charAt(ph.trim().length() - 1);
// ss
c = ph.trim().charAt(0);
if (c >= '0' && c <= '9') con.phsFeatures += ",n";
else if (c >= 'a' && c <= 'z') con.phsFeatures += ",c";
else if (c >= 'A' && c <= 'A') con.phsFeatures += ",c";
else con.phsFeatures += ",o";
// hl
if (https > 0) con.phsFeatures += ",true";
else con.phsFeatures += ",false";
// sss
con.phsFeatures += "," + smallSentence;
// csc
double cscScore = 0.0;
int rank = getRank(analyzer.Doci.concepts, con.URI);
if (rank > -1) cscScore = (1 / (1.0 * rank));
con.phsFeatures += "," + cscScore;
// cs
if (ress.size() > 0) con.phsFeatures += "," + csScore / ress.size();
else con.phsFeatures += ",0.0";
con.phsFeatures += "," + nch;
// d
con.phsFeatures += "," + d;
// php
con.phsFeatures += "," + php;
// fph
con.phsFeatures += "," + fph;
// lph
con.phsFeatures += "," + lph;
// newline
con.phsFeatures += ",\n";
}
if (MRScore == 0) oneOutForMainPh = "";
outForMainPh += oneOutForMainPh;
oneOutForMainPh = "";
}
}
out += " </fieldset>";
// Printer.printToFile("ML/Q" + analyzer.Doci.q.id + "D" + analyzer.Doci.Rank + ".csv",
// out2);
} catch (Exception e) {
}
}
for (Concept c : analyzer.Doci.concepts) {
outForConceptPh += c.phsFeatures;
}
outForConceptPh =
outForConceptPh.replace("\"", "”").replace(",,,", ",\",\",").replace("'", "`");
outForMainPh = outForMainPh.replace("\"", "”").replace(",,,", ",\",\",").replace("'", "`");
String[] results = {"", "", ""};
results[0] = out;
results[1] = outForConceptPh;
results[2] = outForMainPh;
System.out.println("finish generating features for " + id);
return results;
}
return null;
}
@Override
public Vertex getVertex(final Object id) {
final Resource resource = model.getResource(id.toString());
return new JenaVertex(model, resource);
}
