/** * Get a set of the represented path classes, i.e. those with at least 1 manually-labelled object. * * @return */ public static Set<PathClass> getRepresentedPathClasses(final PathObjectHierarchy hierarchy, final Class<? extends PathObject> cls) { Set<PathClass> pathClassSet = new LinkedHashSet<>(); for (PathObject pathObject : hierarchy.getObjects(null, cls)) { if (pathObject.getPathClass() != null) pathClassSet.add(pathObject.getPathClass()); } return pathClassSet; }
/** * Get the first ancestor class of pathObject.getPathClass() that is not an intensity class (i.e. not negative, positive, 1+, 2+ or 3+). * * This will return null if pathClass is null, or if no non-intensity classes are found. * * @param pathObject * @return */ public static PathClass getNonIntensityAncestorPathClass(final PathObject pathObject) { return PathClassFactory.getNonIntensityAncestorClass(pathObject.getPathClass()); }
public static boolean includesIntensityClasses(final Collection<PathObject> pathObjects) { for (PathObject pathObject : pathObjects) { PathClass pathClass = pathObject.getPathClass(); if (pathClass != null && PathClassFactory.isDefaultIntensityClass(pathClass)) return true; } return false; }
public static List<PathObject> getAnnotationsForClass(PathObjectHierarchy hierarchy, PathClass pathClass) { List<PathObject> annotations = new ArrayList<>(); for (PathObject pathObject : getAnnotations(hierarchy)) { if (pathClass.equals(pathObject.getPathClass())) annotations.add(pathObject); } return annotations; }
/** * Count the number of PathObjects in a collection with a specified class or base class. * * @param pathObjects * @param pathClass * @param useBaseClass * @return */ public static int countObjectsWithClass(final Collection<? extends PathObject> pathObjects, final PathClass pathClass, final boolean useBaseClass) { int count = 0; for (PathObject pathObject : pathObjects) { PathClass currentClass = pathObject.getPathClass(); if (useBaseClass) currentClass = currentClass == null ? null : currentClass.getBaseClass(); if ((pathClass == null && currentClass == null) || (pathClass != null && pathClass.equals(currentClass))) count++; } return count; }
public static List<PathObject> getLabelledObjectsForClass(final PathObjectHierarchy hierarchy, final PathClass pathClass) { List<PathObject> pathObjects = new ArrayList<>(); for (PathObject pathObject : getAnnotations(hierarchy)) { if (pathClass.equals(pathObject.getPathClass())) hierarchy.getDescendantObjects(pathObject, pathObjects, PathDetectionObject.class); } return pathObjects; }
/** * Remove all the classifications for a particular class. * * @param pathClass */ public static void resetClassifications(final PathObjectHierarchy hierarchy, final PathClass pathClass) { List<PathObject> changedList = new ArrayList<>(); for (PathObject pathObject : getAnnotations(hierarchy)) { if (pathClass.equals(pathObject.getPathClass())) { pathObject.setPathClass(null); changedList.add(pathObject); } } if (!changedList.isEmpty()) hierarchy.fireObjectClassificationsChangedEvent(null, changedList); }
static Integer getDisplayedColor(final PathObject pathObject, final Integer defaultColor) { // Check if any color has been set - if so, return it Integer color = pathObject.getColorRGB(); if (color != null) return color; // Check if any class has been set, if so then use its color PathClass pathClass = pathObject.getPathClass(); if (pathClass != null) color = pathClass.getColor(); if (color != null) return color; return defaultColor; }
public static void classifyDetection(final Predicate<PathObject> p, final String className) { PathObjectHierarchy hierarchy = getCurrentHierarchy(); if (hierarchy == null) return; List<PathObject> reclassified = new ArrayList<>(); PathClass pathClass = PathClassFactory.getPathClass(className); for (PathObject pathObject : hierarchy.getObjects(null, PathDetectionObject.class)) { if (p.test(pathObject) && pathObject.getPathClass() != pathClass) { pathObject.setPathClass(pathClass); reclassified.add(pathObject); } } if (!reclassified.isEmpty()) hierarchy.fireObjectClassificationsChangedEvent(QP.class, reclassified); }
@Override public String toString() { String postfix; if (getPathClass() == null) postfix = objectCountPostfix(); else postfix = " (" + getPathClass().getName() + ")"; if (getName() != null) return getName() + postfix; if (getROI() != null) return getROI().toString() + postfix; return "Unassigned" + postfix; // Entire image }
/** * Count the descendants of a PathObject recursively, limited to a specific PathClass. * * @param pathObject * @return */ public static int countChildren(final PathObject pathObject, final PathClass pathClass, final boolean allDescendents) { int count = 0; for (PathObject childObject : pathObject.getChildObjects()) { if (pathClass.equals(childObject.getPathClass())) count++; if (childObject.hasChildren() && allDescendents) count += countChildren(childObject, pathClass, allDescendents); } return count; }
/** * Reset the PathClass for all objects of the specified type in the specified hierarchy. * * @param hierarchy * @param cls */ public static void resetClassifications(final PathObjectHierarchy hierarchy, final Class<? extends PathObject> cls) { if (hierarchy == null) return; List<PathObject> objects = hierarchy.getObjects(null, cls); if (objects.isEmpty()) { logger.warn("No objects to reset classifications!"); return; } for (PathObject pathObject : objects) { if (pathObject.getPathClass() != null) pathObject.setPathClass(null); } hierarchy.fireObjectClassificationsChangedEvent(QP.class, objects); }
public String getDisplayedName() { String nameDisplayed = name; if (nameDisplayed == null) { PathClass pathClass = getPathClass(); if (pathClass != null) nameDisplayed = pathClass.getName(); else nameDisplayed = getClass().getSimpleName(); } if (getParent() != null && getParent().isTMACore()) nameDisplayed = getParent().getDisplayedName() + " - " + nameDisplayed; return nameDisplayed; }
/** * Get a base class - which is either a valid PathClass which is *not* an intensity class, or else null. * * This will be null if pathObject.getPathClass() == null. * * Otherwise, it will be pathObject.getPathClass().getBaseClass() assuming the result isn't an intensity class - or null otherwise. * * @param pathObject * @return */ public static PathClass getBasePathClass(final PathObject pathObject) { PathClass baseClass = pathObject.getPathClass(); if (baseClass != null) { baseClass = baseClass.getBaseClass(); // Check our base isn't an intensity class if (PathClassFactory.isPositiveOrPositiveIntensityClass(baseClass) || PathClassFactory.isNegativeClass(baseClass)) baseClass = null; } return baseClass; }
/** * Reset the intensity classifications for all specified objects. * * This means setting the classification to the result of <code>getNonIntensityAncestorPathClass(pathObject)</code> * * @param hierarchy */ public static void resetIntensityClassifications(final Collection<PathObject> pathObjects) { for (PathObject pathObject : pathObjects) { PathClass currentClass = pathObject.getPathClass(); if (PathClassFactory.isPositiveOrPositiveIntensityClass(currentClass) || PathClassFactory.isNegativeClass(currentClass)) pathObject.setPathClass(getNonIntensityAncestorPathClass(pathObject)); } }
PathClass pc1 = o1.getPathClass(); PathClass pc2 = o2.getPathClass(); if (pc1 != null) return pc1.compareTo(pc2);
areaTemp.subtract(areaNew); PathShape shapeNew = PathROIToolsAwt.getShapeROI(areaTemp, shapeMask.getC(), shapeMask.getZ(), shapeMask.getT()); annotationNew = new PathAnnotationObject(shapeNew, temp.getPathClass()); } else if (op == PathROIToolsAwt.CombineOp.INTERSECT) { areaTemp.intersect(areaNew); PathShape shapeNew = PathROIToolsAwt.getShapeROI(areaTemp, shapeMask.getC(), shapeMask.getZ(), shapeMask.getT()); annotationNew = new PathAnnotationObject(shapeNew, temp.getPathClass()); } else { PathROIToolsAwt.combineAreas(areaNew, areaTemp, op); objectsToAdd.add(new PathAnnotationObject(shapeNew, pathObject.getPathClass()));
if (classSelected == null || pathObjectTemp.getPathClass() == null || !(pathObjectTemp.getPathClass().isDerivedFrom(classSelected) || pathObjectTemp.getPathClass().getName().equals(classSelected.getName())))
pathObject.setPathClass(PathClassFactory.getOnePlus(baseClass, null)); return pathObject.getPathClass();
PathAnnotationObject annotation2 = new PathAnnotationObject(roi2, pathObject.getPathClass()); annotation2.setName(pathObject.getName()); annotation2.setColorRGB(pathObject.getColorRGB());