/** * Display atom-atom mapping numbers on a reaction. Each atom map index is loaded from the * property {@link CDKConstants#ATOM_ATOM_MAPPING}. * * <p>Note: A depiction can not have both atom numbers and atom maps visible (but this can be * achieved by manually setting the annotation). * * @return new generator for method chaining * @see #withAtomNumbers() * @see CDKConstants#ATOM_ATOM_MAPPING * @see StandardGenerator#ANNOTATION_LABEL */ public DepictionGenerator withAtomMapNumbers() { if (annotateAtomNum) throw new IllegalArgumentException( "Can not annotated atom maps, atom numbers or values are already annotated"); DepictionGenerator copy = new DepictionGenerator(this); copy.annotateAtomMap = true; return copy; }
/** * Specify a desired size of depiction. The units depend on the output format with raster images * using pixels and vector graphics using millimeters. By default depictions are only ever made * smaller if you would also like to make depictions fill all available space use the {@link * #withFillToFit()} option. * * <p> * * <p>Currently the size must either both be precisely specified (e.g. 256x256) or automatic (e.g. * {@link #AUTOMATIC}x{@link #AUTOMATIC}) you cannot for example specify a fixed height and * automatic width. * * @param w max width * @param h max height * @return new generator for method chaining * @see #withFillToFit() */ public DepictionGenerator withSize(double w, double h) { if (w < 0 && h >= 0 || h < 0 && w >= 0) throw new IllegalArgumentException( "Width and height must either both be automatic or both specified"); DepictionGenerator copy = new DepictionGenerator(this); copy.dimensions = w == AUTOMATIC ? Dimensions.AUTOMATIC : new Dimensions(w, h); return copy; }
/** * Depict a set of molecules, they will be depicted in a grid with the specified number of rows * and columns. Rows are filled first and then columns. * * @param mols molecules * @param nrow number of rows * @param ncol number of columns * @return depiction * @throws CDKException a depiction could not be generated */ public Depiction depict(Iterable<IAtomContainer> mols, int nrow, int ncol) throws CDKException { int molId = 0; for (IAtomContainer mol : mols) { setIfMissing(mol, MarkedElement.ID_KEY, "mol" + ++molId); } // ensure we have coordinates, generate them if not // we also rescale the molecules such that all bond // lengths are the same. List<Double> scaleFactors = prepareCoords(mols); // highlight parts for (Map.Entry<IChemObject, Color> e : highlight.entrySet()) e.getKey().setProperty(StandardGenerator.HIGHLIGHT_COLOR, e.getValue()); // setup the model scale List<IAtomContainer> molList = FluentIterable.from(mols).toList(); DepictionGenerator copy = this.withParam(BasicSceneGenerator.Scale.class, caclModelScale(molList)); // generate bound rendering elements final RendererModel model = copy.getModel(); final List<Bounds> molElems = copy.generate(molList, model, 1); // reset molecule coordinates resetCoords(mols, scaleFactors); // generate titles (if enabled) final List<Bounds> titles = new ArrayList<>(); if (copy.getParameterValue(BasicSceneGenerator.ShowMoleculeTitle.class)) { for (IAtomContainer mol : mols) titles.add(copy.generateTitle(mol, model.get(BasicSceneGenerator.Scale.class))); } // remove current highlight buffer for (IChemObject obj : this.highlight.keySet()) obj.removeProperty(StandardGenerator.HIGHLIGHT_COLOR); this.highlight.clear(); return new MolGridDepiction(model, molElems, titles, dimensions, nrow, ncol); }
/** * Specifies that reactions with atom-atom mappings should have their reactants/product * coordinates aligned. Default: true. * * @param val setting value * @return new generator for method chaining */ public DepictionGenerator withMappedRxnAlign(boolean val) { DepictionGenerator copy = new DepictionGenerator(this); copy.alignMappedReactions = val; return copy; }
/** * Adds to the highlight the coloring of reaction atom-maps. The optional color array is used as * the pallet with which to highlight. If none is provided a set of high-contrast colors will be * used. * * @param colors array of colors * @return new generator for method chaining * @see #withAtomMapNumbers() * @see #withAtomMapHighlight() */ public DepictionGenerator withAtomMapHighlight(Color[] colors) { DepictionGenerator copy = new DepictionGenerator(this); copy.highlightAtomMap = true; copy.atomMapColors = Arrays.copyOf(colors, colors.length); return copy; }
/** * Depict a reaction. * * @param rxn reaction instance * @return depiction * @throws CDKException a depiction could not be generated */ public Depiction depict(IReaction rxn) throws CDKException { ensure2dLayout(rxn); // can reorder components! final Color fgcol = getParameterValue(StandardGenerator.AtomColor.class) .getAtomColor(rxn.getBuilder().newInstance(IAtom.class, "C")); final List<IAtomContainer> reactants = toList(rxn.getReactants()); final List<IAtomContainer> products = toList(rxn.getProducts()); final List<IAtomContainer> agents = toList(rxn.getAgents()); // set ids for tagging elements int molId = 0; for (IAtomContainer mol : reactants) { setIfMissing(mol, MarkedElement.ID_KEY, "mol" + ++molId); setIfMissing(mol, MarkedElement.CLASS_KEY, "reactant"); } for (IAtomContainer mol : products) { setIfMissing(mol, MarkedElement.ID_KEY, "mol" + ++molId); setIfMissing(mol, MarkedElement.CLASS_KEY, "product"); } for (IAtomContainer mol : agents) { setIfMissing(mol, MarkedElement.ID_KEY, "mol" + ++molId); setIfMissing(mol, MarkedElement.CLASS_KEY, "agent"); } final Map<IChemObject, Color> myHighlight = new HashMap<>(); if (highlightAtomMap) { myHighlight.putAll(makeHighlightAtomMap(reactants, products)); } // user highlight buffer pushes out the atom-map highlight if provided myHighlight.putAll(highlight); highlight.clear(); final List<Double> reactantScales = prepareCoords(reactants); final List<Double> productScales = prepareCoords(products); final List<Double> agentScales = prepareCoords(agents); // highlight parts for (Map.Entry<IChemObject, Color> e : myHighlight.entrySet()) e.getKey().setProperty(StandardGenerator.HIGHLIGHT_COLOR, e.getValue()); // setup the model scale based on bond length final double scale = this.caclModelScale(rxn); final DepictionGenerator copy = this.withParam(BasicSceneGenerator.Scale.class, scale); final RendererModel model = copy.getModel(); // reactant/product/agent element generation, we number the reactants, then products then agents List<Bounds> reactantBounds = copy.generate(reactants, model, 1); List<Bounds> productBounds = copy.generate(toList(rxn.getProducts()), model, rxn.getReactantCount()); List<Bounds> agentBounds = copy.generate( toList(rxn.getAgents()), model, rxn.getReactantCount() + rxn.getProductCount()); // remove current highlight buffer for (IChemObject obj : myHighlight.keySet()) obj.removeProperty(StandardGenerator.HIGHLIGHT_COLOR); // generate a 'plus' element Bounds plus = copy.generatePlusSymbol(scale, fgcol); // reset the coordinates to how they were before we invoked depict resetCoords(reactants, reactantScales); resetCoords(products, productScales); resetCoords(agents, agentScales); final Bounds emptyBounds = new Bounds(); final Bounds title = copy.getParameterValue(BasicSceneGenerator.ShowReactionTitle.class) ? copy.generateTitle(rxn, scale) : emptyBounds; final List<Bounds> reactantTitles = new ArrayList<>(); final List<Bounds> productTitles = new ArrayList<>(); if (copy.getParameterValue(BasicSceneGenerator.ShowMoleculeTitle.class)) { for (IAtomContainer reactant : reactants) reactantTitles.add(copy.generateTitle(reactant, scale)); for (IAtomContainer product : products) productTitles.add(copy.generateTitle(product, scale)); } final Bounds conditions = generateReactionConditions(rxn, fgcol, model.get(BasicSceneGenerator.Scale.class)); return new ReactionDepiction( model, reactantBounds, productBounds, agentBounds, plus, rxn.getDirection(), dimensions, reactantTitles, productTitles, title, conditions, fgcol); }
/** * Low-level option method to set a rendering model parameter. * * @param key option key * @param value option value * @param <T> option key type * @param <U> option value type * @return new generator for method chaining */ public <T extends IGeneratorParameter<S>, S, U extends S> DepictionGenerator withParam( Class<T> key, U value) { DepictionGenerator copy = new DepictionGenerator(this); copy.setParam(key, value); return copy; }