|
Alignment API and Server 3.6 | |||||||||
PREV NEXT | FRAMES NO FRAMES |
Uses of AlignmentException in fr.inrialpes.exmo.align.impl |
---|
Methods in fr.inrialpes.exmo.align.impl that throw AlignmentException | |
---|---|
void |
BasicAlignment.accept(AlignmentVisitor visitor)
|
void |
BasicCell.accept(AlignmentVisitor visitor)
|
void |
BasicRelation.accept(AlignmentVisitor visitor)
|
void |
OWLAPICell.accept(AlignmentVisitor visitor)
Deprecated. |
void |
URICell.accept(AlignmentVisitor visitor)
|
Cell |
BasicAlignment.addAlignCell(Object ob1,
Object ob2)
|
Cell |
OWLAPIAlignment.addAlignCell(Object ob1,
Object ob2)
Deprecated. |
Cell |
URIAlignment.addAlignCell(Object ob1,
Object ob2)
|
Cell |
BasicAlignment.addAlignCell(Object ob1,
Object ob2,
String relation,
double measure)
|
Cell |
OWLAPIAlignment.addAlignCell(Object ob1,
Object ob2,
String relation,
double measure)
Deprecated. |
Cell |
URIAlignment.addAlignCell(Object ob1,
Object ob2,
String relation,
double measure)
|
Cell |
BasicAlignment.addAlignCell(String id,
Object ob1,
Object ob2,
Relation relation,
double measure)
|
Cell |
OWLAPIAlignment.addAlignCell(String id,
Object ob1,
Object ob2,
Relation relation,
double measure)
Deprecated. |
Cell |
URIAlignment.addAlignCell(String id,
Object ob1,
Object ob2,
Relation relation,
double measure)
Cell methods |
Cell |
BasicAlignment.addAlignCell(String id,
Object ob1,
Object ob2,
Relation relation,
double measure,
Parameters extensions)
Cell methods |
Cell |
OWLAPIAlignment.addAlignCell(String id,
Object ob1,
Object ob2,
Relation relation,
double measure,
Parameters extensions)
Deprecated. Cell methods |
void |
DistanceAlignment.addAlignDistanceCell(Object ob1,
Object ob2,
String relation,
double measure)
|
void |
BasicOntologyNetwork.addAlignment(Alignment al)
|
protected void |
BasicAlignment.addCell(Cell c)
|
void |
DistanceAlignment.align(Alignment alignment,
Parameters params)
Process matching - create distance data structures, - compute distance or similarity - extract alignment |
Alignment |
BasicAlignment.compose(Alignment align)
The second alignment is composed with the first one meaning that for any pair (o, o', n, r) in O and (o',o", n', r') in O' the resulting alignment will contain: ( o, o", join(n,n'), compose(r, r')) iff compose(r,r') exists. |
Cell |
BasicCell.compose(Cell c)
|
Cell |
ObjectCell.compose(Cell c)
|
Cell |
BasicAlignment.createCell(String id,
Object ob1,
Object ob2,
Relation relation,
double measure)
|
Cell |
OWLAPIAlignment.createCell(String id,
Object ob1,
Object ob2,
Relation relation,
double measure)
Deprecated. |
Cell |
ObjectAlignment.createCell(String id,
Object ob1,
Object ob2,
Relation relation,
double measure)
|
Cell |
URIAlignment.createCell(String id,
Object ob1,
Object ob2,
Relation relation,
double measure)
|
BasicAlignment |
BasicAlignment.createNewAlignment(Object onto1,
Object onto2)
Algebraic part This is to be improved by (TODO): - improving cell equivalence (maybe not dependent on the confidence... |
OWLAPIAlignment |
OWLAPIAlignment.createNewAlignment(Object onto1,
Object onto2)
Deprecated. |
ObjectAlignment |
ObjectAlignment.createNewAlignment(Object onto1,
Object onto2)
Generate a copy of this alignment object |
URIAlignment |
URIAlignment.createNewAlignment(Object onto1,
Object onto2)
|
void |
BasicAlignment.cut(double threshold)
Default cut implementation For compatibility with API until version 1.1 |
void |
BasicAlignment.cut(String method,
double threshold)
Cut refinement : - getting those cells with strength above n (hard) - getting the n best cells (best) - getting those cells with strength at worse n under the best (span) - getting the n% best cells (perc) - getting those cells with strength at worse n% of the best (prop) - getting all cells until a gap of n (hardgap) - getting all cells until a gap of n% of the last (propgap) Rule: threshold is betweew 1 and 0 |
void |
BasicAlignment.cut2(double threshold)
The cut function suppresses from an alignment all the cell over a particulat threshold |
Alignment |
BasicAlignment.diff(Alignment align)
The second alignment is suppresed from the first one meaning that for any pair (o, o', n, r) in O and (o, o', n', r) in O' the resulting alignment will contain: ( o, o', diff(n,n'), r) any pair which is only in the first alignment is preserved. |
Alignment |
DistanceAlignment.extract(String type,
Parameters params)
Extract the alignment form the Similarity There are theoretically 16 types of extractors composing the characteristics [q]estion mark = ?, one or zero relation [s]tar = *, one, zero or many relations [1] = 1, exactly one relation [p]lus = +, one or many relations for each place of the relation. |
Cell |
BasicAlignment.getAlignCell1(Object ob)
|
Cell |
OWLAPIAlignment.getAlignCell1(Object ob)
Deprecated. implemented as the one retrieving the highest strength correspondence |
Cell |
URIAlignment.getAlignCell1(Object ob)
|
Cell |
BasicAlignment.getAlignCell2(Object ob)
|
Cell |
OWLAPIAlignment.getAlignCell2(Object ob)
Deprecated. implemented as the one retrieving the highest strength correspondence |
Cell |
URIAlignment.getAlignCell2(Object ob)
|
Set<Cell> |
BasicAlignment.getAlignCells1(Object ob)
|
Set<Cell> |
OWLAPIAlignment.getAlignCells1(Object ob)
Deprecated. |
Set<Cell> |
URIAlignment.getAlignCells1(Object ob)
|
Set<Cell> |
BasicAlignment.getAlignCells2(Object ob)
|
Set<Cell> |
OWLAPIAlignment.getAlignCells2(Object ob)
Deprecated. |
Set<Cell> |
URIAlignment.getAlignCells2(Object ob)
|
double |
DistanceAlignment.getAlignedDistance1(Object ob)
|
double |
DistanceAlignment.getAlignedDistance2(Object ob)
|
Object |
BasicAlignment.getAlignedObject1(Object ob)
|
Object |
BasicAlignment.getAlignedObject2(Object ob)
|
Relation |
BasicAlignment.getAlignedRelation1(Object ob)
|
Relation |
BasicAlignment.getAlignedRelation2(Object ob)
|
double |
BasicAlignment.getAlignedStrength1(Object ob)
|
double |
BasicAlignment.getAlignedStrength2(Object ob)
|
URI |
BasicCell.getObject1AsURI()
Since version 3.3, the interpretation of objects (and thus finding their URI) depends on the Ontology API which is used. |
URI |
BasicCell.getObject1AsURI(Alignment al)
|
URI |
OWLAPICell.getObject1AsURI(Alignment al)
Deprecated. |
URI |
ObjectCell.getObject1AsURI(Alignment al)
Used to order the cells in an alignment: -- this > c iff this.getStrength() < c.getStrength() -- public int compareTo( Cell c ){ //if ( ! (c instanceof Cell) ) return 1; if ( c.getStrength() > getStrength() ) return 1; if ( getStrength() > c.getStrength() ) return -1; return 0; } |
URI |
URICell.getObject1AsURI(Alignment al)
|
URI |
BasicCell.getObject2AsURI()
Since version 3.3, the interpretation of objects (and thus finding their URI) depends on the Ontology API which is used. |
URI |
BasicCell.getObject2AsURI(Alignment al)
|
URI |
OWLAPICell.getObject2AsURI(Alignment al)
Deprecated. |
URI |
ObjectCell.getObject2AsURI(Alignment al)
|
URI |
URICell.getObject2AsURI(Alignment al)
|
void |
BasicAlignment.harden(double threshold)
The harden function acts like threshold but put all weights to 1. |
void |
BasicAlignment.ingest(Alignment alignment)
Incorporate the cells of the alignment into its own alignment. |
void |
BasicAlignment.init(Object onto1,
Object onto2)
|
void |
OWLAPIAlignment.init(Object onto1,
Object onto2)
Deprecated. |
void |
ObjectAlignment.init(Object onto1,
Object onto2)
|
void |
URIAlignment.init(Object o1,
Object o2)
|
void |
BasicAlignment.init(Object onto1,
Object onto2,
Object cache)
Initialises the Alignment object with two ontologies. |
Alignment |
BasicAlignment.inverse()
A new alignment is created such that for any pair (o, o', n, r) in O the resulting alignment will contain: ( o', o, n, inverse(r)) iff compose(r) exists. |
Cell |
BasicCell.inverse()
|
Cell |
OWLAPICell.inverse()
Deprecated. |
Cell |
ObjectCell.inverse()
|
Cell |
URICell.inverse()
|
Alignment |
BasicAlignment.join(Alignment align)
The second alignment is join with the first one meaning that for any pair (o, o', n, r) in O and (o, o', n', r) in O' the resulting alignment will contain: ( o, o", join(n,n'), r) any pair which is in only one alignment is discarded. |
void |
OWLAPIAlignment.loadInit(Alignment al)
Deprecated. |
void |
ObjectAlignment.loadInit(Alignment al)
|
(package private) static LoadedOntology |
ObjectAlignment.loadOntology(URI ref)
|
Alignment |
BasicAlignment.meet(Alignment align)
The second alignment is meet with the first one meaning that for any pair (o, o', n, r) in O and (o, o', n', r) in O' the resulting alignment will contain: ( o, o', meet(n,n'), r) any pair which is in only one alignment is preserved. |
void |
BasicOntologyNetwork.remAlignment(Alignment al)
|
void |
BasicOntologyNetwork.remOntology(URI onto)
|
void |
BasicAlignment.removeAlignCell(Cell c)
|
void |
BasicAlignment.render(AlignmentVisitor renderer)
This should be rewritten in order to generate the axiom ontology instead of printing it! And then use ontology serialization for getting it printed. |
void |
BasicCell.setObject1(Object ob)
|
void |
BasicCell.setObject2(Object ob)
|
void |
BasicAlignment.setOntology1(Object ontology)
|
void |
URIAlignment.setOntology1(Object ontology)
|
void |
BasicAlignment.setOntology2(Object ontology)
|
void |
URIAlignment.setOntology2(Object ontology)
|
static ObjectAlignment |
ObjectAlignment.toObjectAlignment(URIAlignment al)
|
static OWLAPIAlignment |
OWLAPIAlignment.toOWLAPIAlignment(URIAlignment al)
Deprecated. |
URIAlignment |
BasicAlignment.toURIAlignment()
Returns default exception for conversion to URIAlignments |
URIAlignment |
OWLAPIAlignment.toURIAlignment()
Deprecated. This is a clone with the URI instead of OWLAPI objects |
URIAlignment |
ObjectAlignment.toURIAlignment()
This is a clone with the URI instead of Object objects |
URIAlignment |
URIAlignment.toURIAlignment()
Returns default exception for conversion to URIAlignments |
Constructors in fr.inrialpes.exmo.align.impl that throw AlignmentException | |
---|---|
BasicCell(String id,
Object ob1,
Object ob2,
Relation rel,
double m)
Creation |
|
ObjectCell(String id,
Object ob1,
Object ob2,
Relation rel,
double m)
Creation |
|
OWLAPICell(String id,
org.semanticweb.owl.model.OWLEntity ob1,
org.semanticweb.owl.model.OWLEntity ob2,
Relation rel,
double m)
Deprecated. |
|
URICell(String id,
URI ob1,
URI ob2,
Relation rel,
double m)
Creation |
Uses of AlignmentException in fr.inrialpes.exmo.align.impl.eval |
---|
Methods in fr.inrialpes.exmo.align.impl.eval that throw AlignmentException | |
---|---|
double |
ExtPREvaluator.eval(Parameters params)
This is a partial implementation of [Ehrig & Euzenat 2005] because the relations are not taken into account (they are supposed to be always =) |
double |
PRGraphEvaluator.eval(Parameters params)
Compute precision and recall graphs. |
double |
PRecEvaluator.eval(Parameters params)
The formulas are standard: given a reference alignment A given an obtained alignment B which are sets of cells (linking one entity of ontology O to another of ontolohy O'). |
double |
SymMeanEvaluator.eval(Parameters params)
|
double |
ExtPREvaluator.eval(Parameters params,
Object cache)
|
double |
PRGraphEvaluator.eval(Parameters params,
Object cache)
|
double |
PRecEvaluator.eval(Parameters params,
Object cache)
|
double |
SymMeanEvaluator.eval(Parameters params,
Object cache)
|
int |
ExtPREvaluator.isSuperClass(Object class1,
Object class2,
HeavyLoadedOntology<Object> ontology)
This is a strange method which returns an integer representing how directly a class is superclass of another or not. |
boolean |
ExtPREvaluator.isSuperProperty(Object prop1,
Object prop2,
HeavyLoadedOntology<Object> ontology)
|
protected int |
ExtPREvaluator.relativePosition(Object o1,
Object o2,
HeavyLoadedOntology<Object> onto)
|
int |
ExtPREvaluator.superClassPosition(Object class1,
Object class2,
HeavyLoadedOntology<Object> onto)
|
Constructors in fr.inrialpes.exmo.align.impl.eval that throw AlignmentException | |
---|---|
PRecEvaluator(Alignment align1,
Alignment align2)
Creation Initiate Evaluator for precision and recall |
|
SymMeanEvaluator(Alignment align1,
Alignment align2)
Creation |
Uses of AlignmentException in fr.inrialpes.exmo.align.impl.method |
---|
Methods in fr.inrialpes.exmo.align.impl.method that throw AlignmentException | |
---|---|
void |
ClassStructAlignment.align(Alignment alignment,
Parameters params)
Processing |
void |
NameAndPropertyAlignment.align(Alignment alignment,
Parameters params)
Processing |
void |
StringDistAlignment.align(Alignment alignment,
Parameters params)
|
void |
StrucSubsDistAlignment.align(Alignment alignment,
Parameters params)
Processing |
void |
ClassStructAlignment.init(Object o1,
Object o2,
Object ontologies)
Initialisation The class requires HeavyLoadedOntologies |
void |
NameAndPropertyAlignment.init(Object o1,
Object o2,
Object ontologies)
Initialisation The class requires HeavyLoadedOntologies |
void |
StrucSubsDistAlignment.init(Object o1,
Object o2,
Object ontologies)
Initialisation The class requires HeavyLoadedOntologies |
Uses of AlignmentException in fr.inrialpes.exmo.align.impl.rel |
---|
Methods in fr.inrialpes.exmo.align.impl.rel that throw AlignmentException | |
---|---|
void |
EquivRelation.accept(AlignmentVisitor visitor)
|
void |
IncompatRelation.accept(AlignmentVisitor visitor)
|
void |
NonTransitiveImplicationRelation.accept(AlignmentVisitor visitor)
|
void |
SubsumeRelation.accept(AlignmentVisitor visitor)
|
void |
SubsumedRelation.accept(AlignmentVisitor visitor)
|
Uses of AlignmentException in fr.inrialpes.exmo.align.impl.renderer |
---|
Methods in fr.inrialpes.exmo.align.impl.renderer that throw AlignmentException | |
---|---|
private void |
XSLTRendererVisitor.collectURIs(Cell cell)
|
URI |
SKOSRendererVisitor.getURI2()
|
void |
COWLMappingRendererVisitor.printObject(Object ob,
LoadedOntology onto)
|
void |
COWLMappingRendererVisitor.visit(Alignment align)
|
void |
HTMLMetadataRendererVisitor.visit(Alignment align)
|
void |
HTMLRendererVisitor.visit(Alignment align)
|
void |
OWLAxiomsRendererVisitor.visit(Alignment align)
|
void |
RDFRendererVisitor.visit(Alignment align)
|
void |
SEKTMappingRendererVisitor.visit(Alignment align)
|
void |
SKOSRendererVisitor.visit(Alignment align)
|
void |
SWRLRendererVisitor.visit(Alignment align)
|
void |
XMLMetadataRendererVisitor.visit(Alignment align)
|
void |
XSLTRendererVisitor.visit(Alignment align)
|
void |
COWLMappingRendererVisitor.visit(Cell cell)
|
void |
HTMLRendererVisitor.visit(Cell cell)
|
void |
OWLAxiomsRendererVisitor.visit(Cell cell)
|
void |
RDFRendererVisitor.visit(Cell cell)
|
void |
SEKTMappingRendererVisitor.visit(Cell cell)
|
void |
SKOSRendererVisitor.visit(Cell cell)
|
void |
SWRLRendererVisitor.visit(Cell cell)
|
void |
XSLTRendererVisitor.visit(Cell cell)
|
void |
COWLMappingRendererVisitor.visit(EquivRelation rel)
|
void |
OWLAxiomsRendererVisitor.visit(EquivRelation rel)
|
void |
SEKTMappingRendererVisitor.visit(EquivRelation rel)
|
void |
SKOSRendererVisitor.visit(EquivRelation rel)
|
void |
SWRLRendererVisitor.visit(EquivRelation rel)
|
void |
XSLTRendererVisitor.visit(EquivRelation rel)
|
void |
COWLMappingRendererVisitor.visit(IncompatRelation rel)
|
void |
OWLAxiomsRendererVisitor.visit(IncompatRelation rel)
|
void |
SEKTMappingRendererVisitor.visit(IncompatRelation rel)
|
void |
SKOSRendererVisitor.visit(IncompatRelation rel)
|
void |
COWLMappingRendererVisitor.visit(Relation rel)
|
void |
OWLAxiomsRendererVisitor.visit(Relation rel)
|
void |
SEKTMappingRendererVisitor.visit(Relation rel)
|
void |
SKOSRendererVisitor.visit(Relation rel)
|
void |
SWRLRendererVisitor.visit(Relation rel)
|
void |
XSLTRendererVisitor.visit(Relation rel)
|
void |
COWLMappingRendererVisitor.visit(SubsumedRelation rel)
|
void |
OWLAxiomsRendererVisitor.visit(SubsumedRelation rel)
|
void |
SEKTMappingRendererVisitor.visit(SubsumedRelation rel)
|
void |
SKOSRendererVisitor.visit(SubsumedRelation rel)
|
void |
COWLMappingRendererVisitor.visit(SubsumeRelation rel)
|
void |
OWLAxiomsRendererVisitor.visit(SubsumeRelation rel)
|
void |
SEKTMappingRendererVisitor.visit(SubsumeRelation rel)
|
void |
SKOSRendererVisitor.visit(SubsumeRelation rel)
|
Uses of AlignmentException in fr.inrialpes.exmo.align.ling |
---|
Methods in fr.inrialpes.exmo.align.ling that throw AlignmentException | |
---|---|
void |
JWNLAlignment.align(Alignment alignment,
Parameters params)
Processing |
double |
JWNLDistances.basicGlossOverlap(String s1,
String s2)
NOT FINISHED Compute the overlap between all glosses of two strings |
double |
JWNLDistances.basicSynonymySimilarity(String s1,
String s2)
Evaluate if two terms can be synonym |
double |
JWNLDistances.cosynonymySimilarity(String s1,
String s2)
Compute the proportion of common synset between two words |
(package private) Set<net.didion.jwnl.data.Synset> |
JWNLDistances.getAllSenses(String term)
Retrieve all WordNet sense of a term |
void |
JWNLAlignment.WordNetMatrixMeasure.init()
|
void |
JWNLAlignment.WordNetMatrixMeasure.init(String wndict)
|
void |
JWNLAlignment.WordNetMatrixMeasure.init(String wndict,
String wnvers)
|
void |
JWNLAlignment.WordNetMatrixMeasure.init(String wndict,
String wnvers,
int simFunction)
|
void |
JWNLDistances.Initialize()
Initialize the JWNL API. |
void |
JWNLDistances.Initialize(String wordnetdir,
String wordnetversion)
|
double |
JWNLDistances.wuPalmerSimilarity(String s1,
String s2)
Compute the Wu-Palmer similarity defined by score = 2*depth(lcs(s1,s2)) / (depth(s1) + depth(s2)) |
Uses of AlignmentException in fr.inrialpes.exmo.align.onto |
---|
Methods in fr.inrialpes.exmo.align.onto that throw AlignmentException | |
---|---|
Object |
LoadedOntology.getEntity(URI u)
|
Set<String> |
LoadedOntology.getEntityAnnotations(Object o)
|
Set<String> |
LoadedOntology.getEntityComments(Object o)
|
Set<String> |
LoadedOntology.getEntityComments(Object o,
String lang)
|
String |
LoadedOntology.getEntityName(Object o)
|
Set<String> |
LoadedOntology.getEntityNames(Object o)
|
Set<String> |
LoadedOntology.getEntityNames(Object o,
String lang)
|
URI |
LoadedOntology.getEntityURI(Object o)
|
abstract LoadedOntology |
OntologyFactory.loadOntology(URI uri)
Load an ontology, cache enabled These methods should rather be in a LoadableOntologyFactory |
abstract LoadedOntology |
OntologyFactory.newOntology(Object onto)
Encapsulate an ontology already in the environment These methods should rather be in a LoadableOntologyFactory |
Uses of AlignmentException in fr.inrialpes.exmo.align.onto.jena25 |
---|
Methods in fr.inrialpes.exmo.align.onto.jena25 that throw AlignmentException | |
---|---|
Object |
JENAOntology.getEntity(URI u)
|
Set<String> |
JENAOntology.getEntityAnnotations(Object o)
|
void |
JENAOntology.getEntityAnnotations(Object o,
Set<String> annots)
|
Set<String> |
JENAOntology.getEntityComments(Object o)
|
Set<String> |
JENAOntology.getEntityComments(Object o,
String lang)
|
String |
JENAOntology.getEntityName(Object o)
|
Set<String> |
JENAOntology.getEntityNames(Object o)
|
Set<String> |
JENAOntology.getEntityNames(Object o,
String lang)
|
URI |
JENAOntology.getEntityURI(Object o)
|
JENAOntology |
JENAOntologyFactory.loadOntology(URI uri)
|
JENAOntology |
JENAOntologyFactory.newOntology(Object ontology)
|
Uses of AlignmentException in fr.inrialpes.exmo.align.onto.owlapi10 |
---|
Methods in fr.inrialpes.exmo.align.onto.owlapi10 that throw AlignmentException | |
---|---|
Object |
OWLAPIOntology.getEntity(URI uri)
|
Set<String> |
OWLAPIOntology.getEntityAnnotations(Object o)
|
Set<String> |
OWLAPIOntology.getEntityComments(Object o)
|
Set<String> |
OWLAPIOntology.getEntityComments(Object o,
String lang)
|
String |
OWLAPIOntology.getEntityName(Object o)
|
Set<String> |
OWLAPIOntology.getEntityNames(Object o)
|
Set<String> |
OWLAPIOntology.getEntityNames(Object o,
String lang)
|
URI |
OWLAPIOntology.getEntityURI(Object o)
|
OWLAPIOntology |
OWLAPIOntologyFactory.loadOntology(URI uri)
|
OWLAPIOntology |
OWLAPIOntologyFactory.newOntology(Object ontology)
|
Uses of AlignmentException in fr.inrialpes.exmo.align.service |
---|
Methods in fr.inrialpes.exmo.align.service that throw AlignmentException | |
---|---|
void |
WSAlignment.align(Alignment alignment,
Parameters params)
Process matching This does not work with regular AServ web service because it returns an URL |
Alignment |
CacheImpl.getAlignment(String id)
retrieve full alignment from id (and cache it) |
Alignment |
CacheImpl.getMetadata(String id)
retrieve alignment metadata from id This is more difficult because we return the alignment we have disreagarding if it is complete o only metadata |
void |
AServProtocolManager.init(DBService connection,
Parameters p)
|
void |
CacheImpl.init(Parameters p)
loads the alignment descriptions from the database and put them in the alignmentTable hashtable |
String |
CacheImpl.recordNewAlignment(String id,
Alignment al,
boolean force)
records alignment identified by id |
void |
CacheImpl.resetDatabase(boolean force)
|
protected Alignment |
CacheImpl.retrieveAlignment(String id,
Alignment alignment)
loads the full alignments from the database and put them in the alignmentTable hastable should be invoked when: ( result.getExtension(CACHED) == "" && result.getExtension(STORED) != "") { |
String |
QueryMediator.rewriteQuery(String aQuery)
|
static String |
QueryMediator.rewriteSPARQLQuery(String aQuery,
Alignment align)
|
void |
CacheImpl.storeAlignment(String id)
|
void |
CacheImpl.unstoreAlignment(String id)
Non publicised class |
void |
CacheImpl.updateDatabase()
|
Uses of AlignmentException in fr.inrialpes.exmo.align.util |
---|
Methods in fr.inrialpes.exmo.align.util that throw AlignmentException | |
---|---|
Evaluator |
GroupOutput.eval(String alignName1,
String alignName2)
|
Uses of AlignmentException in org.semanticweb.owl.align |
---|
Methods in org.semanticweb.owl.align that throw AlignmentException | |
---|---|
void |
Alignment.accept(AlignmentVisitor visitor)
Alignment methods |
void |
Cell.accept(AlignmentVisitor visitor)
|
void |
Relation.accept(AlignmentVisitor visitor)
Creation |
Cell |
Alignment.addAlignCell(Object ob1,
Object ob2)
|
Cell |
Alignment.addAlignCell(Object ob1,
Object ob,
String relation,
double measure)
Cells are created and indexed at once |
void |
OntologyNetwork.addAlignment(Alignment al)
|
void |
AlignmentProcess.align(Alignment alignment,
Parameters param)
The align method computes the alignment from the ontologies. |
Alignment |
Alignment.compose(Alignment align)
|
Cell |
Cell.compose(Cell c)
|
void |
Alignment.cut(double threshold)
|
void |
Alignment.cut(String method,
double threshold)
|
Alignment |
Alignment.diff(Alignment align)
|
double |
Evaluator.eval(Parameters param)
Run the evaluation between the two ontologies. |
double |
Evaluator.eval(Parameters param,
Object cache)
Run the evaluation between the two ontologies. |
Cell |
Alignment.getAlignCell1(Object ob)
Cells are retrieved These primitives are deprecated. |
Cell |
Alignment.getAlignCell2(Object ob)
//@deprecated There is more than one cell about one object |
Set<Cell> |
Alignment.getAlignCells1(Object ob)
Cells are retrieved These primitives are deprecated. |
Set<Cell> |
Alignment.getAlignCells2(Object ob)
|
Object |
Alignment.getAlignedObject1(Object ob)
Each part of the cell can be queried independently. |
Object |
Alignment.getAlignedObject2(Object ob)
|
Relation |
Alignment.getAlignedRelation1(Object ob)
|
Relation |
Alignment.getAlignedRelation2(Object ob)
|
double |
Alignment.getAlignedStrength1(Object ob)
|
double |
Alignment.getAlignedStrength2(Object ob)
|
URI |
Cell.getObject1AsURI()
//@deprecated use getObject1AsURI( null ) instead |
URI |
Cell.getObject1AsURI(Alignment al)
|
URI |
Cell.getObject2AsURI()
//@deprecated use getObject2AsURI( null ) instead |
URI |
Cell.getObject2AsURI(Alignment al)
|
URI |
Alignment.getOntology1URI()
|
URI |
Alignment.getOntology2URI()
|
void |
Alignment.harden(double threshold)
|
void |
Alignment.init(Object onto1,
Object onto2)
Initialize the alignement before using it |
void |
Alignment.init(Object onto1,
Object onto2,
Object cache)
Initialize the alignement before using it, with some ontology caching trick //@deprecated The OntologyCache is now internal, use init( onto1, onto2 ) instead |
Alignment |
Alignment.inverse()
Algebra of alignment manipulation operations: compose, join, meet. |
Cell |
Cell.inverse()
|
Alignment |
Alignment.join(Alignment align)
|
Alignment |
Alignment.meet(Alignment align)
|
void |
OntologyNetwork.remAlignment(Alignment al)
|
void |
OntologyNetwork.remOntology(URI onto)
|
void |
Alignment.render(AlignmentVisitor renderer)
Exporting The alignments are exported for other purposes. |
void |
Cell.setObject1(Object ob)
|
void |
Cell.setObject2(Object ob)
|
void |
Alignment.setOntology1(Object ontology)
|
void |
Alignment.setOntology2(Object ontology)
|
void |
AlignmentVisitor.visit(Alignment a)
|
void |
AlignmentVisitor.visit(Cell c)
|
void |
AlignmentVisitor.visit(Relation r)
|
|
Alignment API and Server 3.6 | |||||||||
PREV NEXT | FRAMES NO FRAMES |