/** * Scan through the layers once to remember which layers attach to which layers. */ private static List<AnnotationLayer> getAttachingLayers(AnnotationLayer aTarget, List<AnnotationLayer> aLayers, AnnotationSchemaService aAnnotationService) { List<AnnotationLayer> attachingLayers = new ArrayList<>(); // Chains always attach to themselves if (CHAIN_TYPE.equals(aTarget.getType())) { attachingLayers.add(aTarget); } // FIXME This is a hack! Actually we should check the type of the attachFeature when // determine which layers attach to with other layers. Currently we only use attachType, // but do not follow attachFeature if it is set. if (aTarget.isBuiltIn() && aTarget.getName().equals(POS.class.getName())) { attachingLayers.add(aAnnotationService.getLayer(Dependency.class.getName(), aTarget.getProject())); } // Custom layers for (AnnotationLayer l : aLayers) { if (aTarget.equals(l.getAttachType())) { attachingLayers.add(l); } } return attachingLayers; }
private AnnotationLayer createTokenLayer(Project aProject) throws IOException { AnnotationLayer tokenLayer = new AnnotationLayer(Token.class.getName(), "Token", SPAN_TYPE, aProject, true, AnchoringMode.SINGLE_TOKEN); annotationSchemaService.createLayer(tokenLayer); return tokenLayer; } }
/** * A field that takes the name of the annotation to attach to, e.g. * "de.tudarmstadt...type.Token" (Token.class.getName()) */ @Override public String getAttachTypeName() { return layer.getAttachType() == null ? null : layer.getAttachType().getName(); }
@Override public boolean accepts(AnnotationLayer aLayer, AnnotationFeature aFeature) { if (aLayer == null || aFeature == null) { return false; } return asList(AnchoringMode.SINGLE_TOKEN, AnchoringMode.TOKENS).contains( aLayer.getAnchoringMode()) && WebAnnoConst.SPAN_TYPE.equals(aLayer.getType()); }
private List<AnnotationLayer> getLayersToRender() { AnnotatorState state = getModelObject(); List<AnnotationLayer> layersToRender = new ArrayList<>(); for (AnnotationLayer layer : state.getAnnotationLayers()) { boolean isSegmentationLayer = layer.getName().equals(Token.class.getName()) || layer.getName().equals(Sentence.class.getName()); boolean isUnsupportedLayer = layer.getType().equals(CHAIN_TYPE) && (state.getMode().equals(Mode.AUTOMATION) || state.getMode().equals(Mode.CORRECTION) || state.getMode().equals(Mode.CURATION)); if (layer.isEnabled() && !isSegmentationLayer && !isUnsupportedLayer) { layersToRender.add(layer); } } return layersToRender; }
exLayer.setAllowStacking(aLayer.isAllowStacking()); exLayer.setBuiltIn(aLayer.isBuiltIn()); exLayer.setReadonly(aLayer.isReadonly()); exLayer.setCrossSentence(aLayer.isCrossSentence()); exLayer.setDescription(aLayer.getDescription()); exLayer.setEnabled(aLayer.isEnabled()); exLayer.setLockToTokenOffset(AnchoringMode.SINGLE_TOKEN.equals(aLayer.getAnchoringMode())); exLayer.setMultipleTokens(AnchoringMode.TOKENS.equals(aLayer.getAnchoringMode())); exLayer.setAnchoringMode(aLayer.getAnchoringMode()); exLayer.setLinkedListBehavior(aLayer.isLinkedListBehavior()); exLayer.setName(aLayer.getName()); exLayer.setProjectName(aLayer.getProject().getName()); exLayer.setType(aLayer.getType()); exLayer.setUiName(aLayer.getUiName());
@Override public boolean accepts(AnnotationLayer aLayer, AnnotationFeature aFeature) { if (aLayer == null || aFeature == null) { return false; } return asList(SINGLE_TOKEN, TOKENS).contains(aLayer.getAnchoringMode()) && !aLayer.isCrossSentence() && SPAN_TYPE.equals(aLayer.getType()) && aFeature.getType().startsWith(PREFIX); }
private Set<AnnotationFS> getAttachedSpans(AnnotationFS aFs, AnnotationLayer aLayer) { CAS cas = aFs.getCAS(); Set<AnnotationFS> attachedSpans = new HashSet<>(); TypeAdapter adapter = annotationService.getAdapter(aLayer); if (adapter instanceof SpanAdapter && aLayer.getAttachType() != null) { Type spanType = CasUtil.getType(cas, aLayer.getAttachType().getName()); Feature attachFeature = spanType.getFeatureByBaseName(aLayer.getAttachFeature() .getName()); for (AnnotationFS attachedFs : selectAt(cas, spanType, aFs.getBegin(), aFs.getEnd())) { if (isSame(attachedFs.getFeatureValue(attachFeature), aFs)) { attachedSpans.add(attachedFs); } } } return attachedSpans; }
@Override @Transactional public List<AnnotationFeature> listAttachedLinkFeatures(AnnotationLayer aLayer) { return entityManager .createQuery( "FROM AnnotationFeature WHERE linkMode in (:modes) AND project = :project AND " + "type in (:attachType) ORDER BY uiName", AnnotationFeature.class) .setParameter("modes", asList(LinkMode.SIMPLE, LinkMode.WITH_ROLE)) .setParameter("attachType", asList(aLayer.getName(), CAS.TYPE_NAME_ANNOTATION)) // Checking for project is necessary because type match is string-based .setParameter("project", aLayer.getProject()).getResultList(); }
private Metadata buildMetadata(CAS aCas) throws RecommendationException { CASMetadata casMetadata = getCasMetadata(aCas); AnnotationLayer layer = recommender.getLayer(); return new Metadata( layer.getName(), recommender.getFeature().getName(), casMetadata.getProjectId(), layer.getAnchoringMode().getId(), layer.isCrossSentence() ); }
private void initLayerAndFeatureCache() { // Initialize and populate the hash maps for the layers and features layers = new HashMap<String, AnnotationLayer>(); layerFeatures = new HashMap<String, List<AnnotationFeature>>(); for (AnnotationLayer layer : annotationSchemaService.listAnnotationLayer(project)) { if (layer.isEnabled()) { layers.put(layer.getName(), layer); List<AnnotationFeature> features = new ArrayList<AnnotationFeature>(); for (AnnotationFeature feature : annotationSchemaService .listAnnotationFeature(layer)) { features.add(feature); } layerFeatures.put(layer.getName(), features); } } }
@Override public boolean accepts(AnnotationLayer aLayer) { return RELATION_TYPE.equals(aLayer.getType()); }
private void fix(Project aProject, Class<? extends TOP> aLayer, String aLayerType, AnnotationLayer aTokenLayer, String aFeature) { if (annotationSchemaService.existsLayer(aLayer.getName(), aLayerType, aProject)) { AnnotationLayer layer = annotationSchemaService.getLayer(aLayer.getName(), aProject); if (layer.getAttachFeature() == null) { layer.setAttachFeature(annotationSchemaService.getFeature(aFeature, aTokenLayer)); log.info("DATABASE UPGRADE PERFORMED: Fixed attach-feature of layer " + "[{}] ({}) in project [{}] ({})", layer.getUiName(), layer.getId(), aProject.getName(), aProject.getId()); } } } }
@Override public long getTypeId() { return layer.getId(); }
private void createNeLayer(Project aProject, TagSet aTagSet) throws IOException { AnnotationLayer neLayer = new AnnotationLayer(NamedEntity.class.getName(), "Named entity", SPAN_TYPE, aProject, true, AnchoringMode.TOKENS); neLayer.setAllowStacking(true); annotationSchemaService.createLayer(neLayer); annotationSchemaService.createFeature(new AnnotationFeature(aProject, neLayer, "value", "value", CAS.TYPE_NAME_STRING, "Named entity type", aTagSet)); }
@Override protected void onConfigure() { super.onConfigure(); AnnotationLayer layer = LayerDetailForm.this.getModelObject(); // Makes no sense for relation layers or layers that attach to tokens setVisible(!isBlank(layer.getType()) && !RELATION_TYPE.equals(layer.getType()) && !CHAIN_TYPE.equals(layer.getType()) && layer.getAttachFeature() == null); } });