private boolean isDiseaseObject(Renderable r, Set<Long> diseaseIds) { if (r instanceof FlowLine) { FlowLine fl = (FlowLine) r; return isFlowLineRelatedToSet(fl, diseaseIds); } // Assume normal objects only: this is a very strong assumption if (r.getReactomeId() == null) return false; // A PE may be represented multiple times in a pathway diagram. Some of them // are linked to normal reactions, and some linked to disease reactions. // Have to check these cases. if (r instanceof HyperEdge) return diseaseIds.contains(r.getReactomeId()); if (r instanceof Node) { Node node = (Node) r; List<HyperEdge> edges = node.getConnectedReactions(); boolean isDisease = false; for (HyperEdge edge : edges) { if (edge instanceof FlowLine) { isDisease = isFlowLineRelatedToSet((FlowLine) edge, diseaseIds); } else if (edge.getReactomeId() != null && diseaseIds.contains(edge.getReactomeId())) { isDisease = true; } if (isDisease) return true; } } return false; }
private boolean isNormalObject(Renderable r, Set<Long> normalIds) { if (r instanceof HyperEdge) { if (r instanceof FlowLine) return isFlowLineRelatedToSet((FlowLine) r, normalIds); // Most likely the following statements should not be reached. But place // here just in case. if (r.getReactomeId() == null) return true; if (normalIds.contains(r.getReactomeId())) return true; } else if (r instanceof Node) { if (r instanceof ProcessNode) return true; // Should be used only for normal pathway. if (r.getReactomeId() == null) return true; // Check if it is linked to another disease entities Node node = (Node) r; List<HyperEdge> edges = node.getConnectedReactions(); boolean isNormal = false; for (HyperEdge edge : edges) { if (edge instanceof FlowLine) isNormal = isFlowLineRelatedToSet((FlowLine) edge, normalIds); if (isNormal) return true; if (edge.getReactomeId() != null && normalIds.contains(edge.getReactomeId())) return true; // Some special cases that use links if (!(edge instanceof EntitySetAndEntitySetLink) && !(edge instanceof EntitySetAndMemberLink) && edge.getReactomeId() == null) return true; } } return false; }
/** * Some of disease reactions may not be drawn in the pathway diagram (e.g. LoF or GoF reactions). * These reactions should be overlaid onto their normalReaction counterparts, which are encoded by * their normalReaction attributes. * * @param diseaseIds */ private void overlayDiseaseReactions(Set<Long> diseaseIds) { // Get the list of all drawing objects for checking Map<Long, Renderable> idToObject = new HashMap<Long, Renderable>(); List<Renderable> components = displayedObject.getComponents(); if (components == null || components.size() == 0) return; for (Renderable r : components) { if (r.getReactomeId() == null) continue; idToObject.put(r.getReactomeId(), r); } try { normalToDiseaseNode = new HashMap<Node, Node>(); for (Long diseaseId : diseaseIds) { if (idToObject.containsKey(diseaseId)) continue; // Have to copy the normal reactions to draw GKInstance inst = adaptor.fetchInstance(diseaseId); if (inst.getSchemClass().isa(ReactomeJavaConstants.ReactionlikeEvent)) { List<GKInstance> normalReactions = inst.getAttributeValuesList(ReactomeJavaConstants.normalReaction); if (normalReactions != null && normalReactions.size() > 0) { for (GKInstance normalRxt : normalReactions) { Renderable r = idToObject.get(normalRxt.getDBID()); if (r instanceof HyperEdge) overlayDiseaseReaction((HyperEdge) r, inst); } } } } return; } catch (Exception e) { e.printStackTrace(); } }
private void checkLossOfFunctionNodes() { try { lofNodes = new ArrayList<Node>(); List<Renderable> components = displayedObject.getComponents(); if (components == null || components.size() == 0) return; for (Renderable r : components) { if (r instanceof Node || r.getReactomeId() == null) continue; if (!diseaseIds.contains(r.getReactomeId())) continue; GKInstance inst = adaptor.fetchInstance(r.getReactomeId()); if (!inst.getSchemClass().isa(ReactomeJavaConstants.ReactionlikeEvent) || !inst.getSchemClass().isValidAttribute(ReactomeJavaConstants.entityFunctionalStatus)) continue; List<GKInstance> efs = inst.getAttributeValuesList(ReactomeJavaConstants.entityFunctionalStatus); Set<GKInstance> lofPEs = new HashSet<GKInstance>(); for (GKInstance ef : efs) { GKInstance pe = (GKInstance) ef.getAttributeValue(ReactomeJavaConstants.physicalEntity); if (isLOFEntity(ef)) lofPEs.add(pe); } List<Node> nodes = ((HyperEdge) r).getConnectedNodes(); for (Node node : nodes) { if (node.getReactomeId() == null) continue; GKInstance nodeInst = adaptor.fetchInstance(node.getReactomeId()); Set<GKInstance> nodeRefEntities = getReferenceEntity(nodeInst); for (GKInstance lofPE : lofPEs) { Set<GKInstance> lofRefEntities = getReferenceEntity(lofPE); lofRefEntities.retainAll(nodeRefEntities); if (lofRefEntities.size() > 0) { // A LOF node lofNodes.add(node); break; } } } } } catch (Exception e) { e.printStackTrace(); } }
private Node replaceNormalNode( Node normalNode, GKInstance diseaseEntity, Boolean needDashedBorder) { Node diseaseNode = normalToDiseaseNode.get(normalNode); if (diseaseNode != null) return diseaseNode; try { // If a node exists already, it should use for (Renderable r : diseaseComps) { if (diseaseEntity.getDBID().equals(r.getReactomeId()) && r instanceof Node) { // This is rather arbitrary: if two nodes are very close, // use the existing one. int dx = Math.abs(r.getPosition().x - normalNode.getPosition().x); int dy = Math.abs(r.getPosition().y - normalNode.getPosition().y); if (dx < 10 && dy < 10) { // We don't need to create a new Node if it exists already normalToDiseaseNode.put(normalNode, (Node) r); overlaidObjects.add(r); // Add it to overlaid object to cover edges return (Node) r; } } } diseaseNode = normalNode.getClass().newInstance(); RenderUtility.copyRenderInfo(normalNode, diseaseNode); // The following should NOT be called since NodeAttachment is // related to disease entity only. // TODO: Need to support this. Currently it is not supported!!! See example // in PI3/AKT cancer pathway. // diseaseNode.setNodeAttachmentsLocally(node.getNodeAttachments()); diseaseNode.setDisplayName(diseaseEntity.getDisplayName()); diseaseNode.setReactomeId(diseaseEntity.getDBID()); diseaseNode.invalidateBounds(); diseaseNode.setRenderer(normalNode.getRenderer()); diseaseNode.setLineColor(DefaultRenderConstants.DEFAULT_DISEASE_BACKGROUND); diseaseNode.setNeedDashedBorder(needDashedBorder); RenderUtility.hideCompartmentInNodeName(diseaseNode); overlaidObjects.add(diseaseNode); displayedObject.addComponent(diseaseNode); normalToDiseaseNode.put(normalNode, diseaseNode); return diseaseNode; } catch (Exception e) { e.printStackTrace(); } return null; }