Пример #1
0
  private IRenderingElement generateMixtureSgroup(Sgroup sgroup) {
    // draw the brackets
    // TODO - mixtures normally have attached Sgroup data
    // TODO - e.g. COMPONENT_FRACTION, ACTIVITY_TYPE, WEIGHT_PERCENT
    List<SgroupBracket> brackets = sgroup.getValue(SgroupKey.CtabBracket);
    if (brackets != null) {

      SgroupType type = sgroup.getType();
      String subscript = "?";
      switch (type) {
        case CtabComponent:
          Integer compNum = sgroup.getValue(SgroupKey.CtabComponentNumber);
          if (compNum != null) subscript = "c" + Integer.toString(compNum);
          else subscript = "c";
          break;
        case CtabMixture:
          subscript = "mix";
          break;
        case CtabFormulation:
          subscript = "f";
          break;
      }

      return generateSgroupBrackets(sgroup, brackets, subscript, null);
    } else {
      return new ElementGroup();
    }
  }
Пример #2
0
  /**
   * Hide the atoms and bonds of a contracted abbreviation. If the abbreviations is attached we
   * remap the attachment symbol to display the name. If there are no attachments the symbol we be
   * added later ({@see #generateSgroups}).
   *
   * @param container molecule
   * @param sgroup abbreviation group display shortcut
   */
  private static void contractAbbreviation(
      IAtomContainer container, Map<IAtom, String> symbolRemap, Sgroup sgroup) {

    final Set<IBond> crossing = sgroup.getBonds();
    final Set<IAtom> atoms = sgroup.getAtoms();

    // only do 0,1 attachments for now
    if (crossing.size() > 1) return;

    for (IAtom atom : atoms) {
      StandardGenerator.hide(atom);
    }
    for (IBond bond : container.bonds()) {
      if (atoms.contains(bond.getAtom(0)) || atoms.contains(bond.getAtom(1)))
        StandardGenerator.hide(bond);
    }
    for (IBond bond : crossing) {
      StandardGenerator.unhide(bond);
      IAtom a1 = bond.getAtom(0);
      IAtom a2 = bond.getAtom(1);
      StandardGenerator.unhide(a1);
      if (atoms.contains(a1)) symbolRemap.put(a1, sgroup.getSubscript());
      StandardGenerator.unhide(a2);
      if (atoms.contains(a2)) symbolRemap.put(a2, sgroup.getSubscript());
    }
  }
Пример #3
0
 private IRenderingElement generateMultipleSgroup(Sgroup sgroup) {
   // just draw the brackets - multiplied group parts have already been hidden in prep phase
   List<SgroupBracket> brackets = sgroup.getValue(SgroupKey.CtabBracket);
   if (brackets != null) {
     return generateSgroupBrackets(
         sgroup, brackets, (String) sgroup.getValue(SgroupKey.CtabSubScript), null);
   } else {
     return new ElementGroup();
   }
 }
Пример #4
0
  /**
   * Generates polymer Sgroup elements.
   *
   * @param sgroup the Sgroup
   * @return the rendered elements (empty if no brackets defined)
   */
  private IRenderingElement generatePolymerSgroup(Sgroup sgroup) {
    // draw the brackets
    List<SgroupBracket> brackets = sgroup.getValue(SgroupKey.CtabBracket);
    if (brackets != null) {

      SgroupType type = sgroup.getType();

      String subscript = sgroup.getValue(SgroupKey.CtabSubScript);
      String connectivity = sgroup.getValue(SgroupKey.CtabConnectivity);

      switch (type) {
        case CtabCopolymer:
          subscript = "co";
          String subtype = sgroup.getValue(SgroupKey.CtabSubType);
          if ("RAN".equals(subtype)) subscript = "ran";
          else if ("BLK".equals(subtype)) subscript = "blk";
          else if ("ALT".equals(subtype)) subscript = "alt";
          break;
        case CtabCrossLink:
          subscript = "xl";
          break;
        case CtabAnyPolymer:
          subscript = "any";
          break;
        case CtabGraft:
          subscript = "grf";
          break;
        case CtabMer:
          subscript = "mer";
          break;
        case CtabMonomer:
          subscript = "mon";
          break;
        case CtabModified:
          subscript = "mod";
          break;
        case CtabStructureRepeatUnit:
          if (subscript == null) subscript = "n";
          if (connectivity == null) connectivity = "eu";
          break;
      }

      return generateSgroupBrackets(sgroup, brackets, subscript, connectivity);
    } else {
      return new ElementGroup();
    }
  }
Пример #5
0
 private IRenderingElement generateAbbreviationSgroup(Sgroup sgroup) {
   String label = sgroup.getSubscript();
   // already handled by symbol remapping
   if (sgroup.getBonds().size() > 0 || label == null || label.isEmpty()) {
     return new ElementGroup();
   }
   // we're showing a label where there were no atoms before, we put it in the
   // middle of all of those which were hidden
   final Point2d labelCoords = GeometryUtil.get2DCenter(sgroup.getAtoms());
   ElementGroup group = new ElementGroup();
   for (Shape outline :
       atomGenerator
           .generatePseudoSymbol(label, HydrogenPosition.Right)
           .resize(1 / scale, 1 / -scale)
           .getOutlines()) group.add(GeneralPath.shapeOf(outline, foreground));
   return MarkedElement.markupAtom(group, null);
 }
Пример #6
0
  /**
   * Hide the repeated atoms and bonds of a multiple group. We hide al atoms that belong to the
   * group unless they are defined in the parent atom list. Any bond to those atoms that is not a
   * crossing bond or one connecting atoms in the parent list is hidden.
   *
   * @param container molecule
   * @param sgroup multiple group display shortcut
   */
  private static void hideMultipleParts(IAtomContainer container, Sgroup sgroup) {

    final Set<IBond> crossing = sgroup.getBonds();
    final Set<IAtom> atoms = sgroup.getAtoms();
    final Set<IAtom> parentAtoms = sgroup.getValue(SgroupKey.CtabParentAtomList);

    for (IBond bond : container.bonds()) {
      if (parentAtoms.contains(bond.getAtom(0)) && parentAtoms.contains(bond.getAtom(1))) continue;
      if (atoms.contains(bond.getAtom(0)) || atoms.contains(bond.getAtom(1)))
        StandardGenerator.hide(bond);
    }
    for (IAtom atom : atoms) {
      if (!parentAtoms.contains(atom)) StandardGenerator.hide(atom);
    }
    for (IBond bond : crossing) {
      StandardGenerator.unhide(bond);
    }
  }
Пример #7
0
  /**
   * Generate the Sgroup elements for the provided atom contains.
   *
   * @param container molecule
   * @return Sgroup rendering elements
   */
  IRenderingElement generateSgroups(IAtomContainer container) {

    ElementGroup result = new ElementGroup();
    List<Sgroup> sgroups = container.getProperty(CDKConstants.CTAB_SGROUPS);

    if (sgroups == null || sgroups.isEmpty()) return result;

    for (Sgroup sgroup : sgroups) {

      switch (sgroup.getType()) {
        case CtabAbbreviation:
          result.add(generateAbbreviationSgroup(sgroup));
          break;
        case CtabMultipleGroup:
          result.add(generateMultipleSgroup(sgroup));
          break;
        case CtabAnyPolymer:
        case CtabMonomer:
        case CtabCrossLink:
        case CtabCopolymer:
        case CtabStructureRepeatUnit:
        case CtabMer:
        case CtabGraft:
        case CtabModified:
          result.add(generatePolymerSgroup(sgroup));
          break;
        case CtabComponent:
        case CtabMixture:
        case CtabFormulation:
          result.add(generateMixtureSgroup(sgroup));
          break;
        case CtabGeneric:
          // not strictly a polymer but okay to draw as one
          result.add(generatePolymerSgroup(sgroup));
          break;
      }
    }

    return result;
  }
Пример #8
0
  /**
   * If the molecule has display shortcuts (abbreviations or multiple group sgroups) certain parts
   * of the structure are hidden from display. This method marks the parts to hide and in the case
   * of abbreviations, remaps atom symbols. Appart from additional property flags, the molecule is
   * unchanged by this method.
   *
   * @param container molecule input
   * @param symbolRemap a map that will hold symbol remapping
   */
  static void prepareDisplayShortcuts(IAtomContainer container, Map<IAtom, String> symbolRemap) {

    List<Sgroup> sgroups = container.getProperty(CDKConstants.CTAB_SGROUPS);
    if (sgroups == null || sgroups.isEmpty()) return;

    // select abbreviations that should be contracted
    for (Sgroup sgroup : sgroups) {
      if (sgroup.getType() == SgroupType.CtabAbbreviation) {
        Boolean expansion = sgroup.getValue(SgroupKey.CtabExpansion);
        // abbreviation is displayed as expanded
        if (expansion != null && expansion == Boolean.TRUE) continue;
        // no or empty label, skip it
        if (sgroup.getSubscript() == null || sgroup.getSubscript().isEmpty()) continue;
        contractAbbreviation(container, symbolRemap, sgroup);
      } else if (sgroup.getType() == SgroupType.CtabMultipleGroup) {
        hideMultipleParts(container, sgroup);
      }
    }
  }
Пример #9
0
  private IRenderingElement generateSgroupBrackets(
      Sgroup sgroup,
      List<SgroupBracket> brackets,
      String subscriptSuffix,
      String superscriptSuffix) {

    // brackets are square by default (style:0)
    Integer style = sgroup.getValue(SgroupKey.CtabBracketStyle);
    boolean round = style != null && style == 1;
    ElementGroup result = new ElementGroup();

    Set<IAtom> atoms = sgroup.getAtoms();
    Set<IBond> crossingBonds = sgroup.getBonds();

    // easy to depict in correct orientation, we just
    // point each bracket at the atom of a crossing
    // bond that is 'in' the group - this scales
    // to more than two brackets

    // first we need to pair the brackets with the bonds
    Map<SgroupBracket, IBond> pairs =
        crossingBonds.size() == brackets.size()
            ? bracketBondPairs(brackets, crossingBonds)
            : Collections.<SgroupBracket, IBond>emptyMap();

    if (!pairs.isEmpty()) {

      SgroupBracket suffixBracket = null;
      Vector2d suffixBracketPerp = null;

      for (Map.Entry<SgroupBracket, IBond> e : pairs.entrySet()) {

        final SgroupBracket bracket = e.getKey();
        final IBond bond = e.getValue();
        final IAtom inGroupAtom =
            atoms.contains(bond.getAtom(0)) ? bond.getAtom(0) : bond.getAtom(1);

        final Point2d p1 = bracket.getFirstPoint();
        final Point2d p2 = bracket.getSecondPoint();

        final Vector2d perp = VecmathUtil.newPerpendicularVector(VecmathUtil.newUnitVector(p1, p2));

        // point the vector at the atom group
        Point2d midpoint = VecmathUtil.midpoint(p1, p2);
        if (perp.dot(VecmathUtil.newUnitVector(midpoint, inGroupAtom.getPoint2d())) < 0) {
          perp.negate();
        }

        perp.scale(bracketDepth);

        Path2D path = new Path2D.Double();
        if (round) {
          // bracket 1 (cp: control point)
          path.moveTo(p1.x + perp.x, p1.y + perp.y);
          Point2d cpb1 = new Point2d(midpoint);
          cpb1.add(VecmathUtil.negate(perp));
          path.quadTo(cpb1.x, cpb1.y, p2.x + perp.x, p2.y + p2.y);
        } else {
          path.moveTo(p1.x + perp.x, p1.y + perp.y);
          path.lineTo(p1.x, p1.y);
          path.lineTo(p2.x, p2.y);
          path.lineTo(p2.x + perp.x, p2.y + perp.y);
        }
        result.add(GeneralPath.outlineOf(path, stroke, foreground));

        if (suffixBracket == null) {
          suffixBracket = bracket;
          suffixBracketPerp = perp;
        } else {
          // is this bracket better as a suffix?
          Point2d sp1 = suffixBracket.getFirstPoint();
          Point2d sp2 = suffixBracket.getSecondPoint();
          double bestMaxX = Math.max(sp1.x, sp2.x);
          double thisMaxX = Math.max(p1.x, p2.x);
          double bestMaxY = Math.max(sp1.y, sp2.y);
          double thisMaxY = Math.max(p1.y, p2.y);

          // choose the most eastern or.. the most southern
          double xDiff = thisMaxX - bestMaxX;
          double yDiff = thisMaxY - bestMaxY;
          if (xDiff > EQUIV_THRESHOLD || (xDiff > -EQUIV_THRESHOLD && yDiff < -EQUIV_THRESHOLD)) {
            suffixBracket = bracket;
            suffixBracketPerp = perp;
          }
        }
      }

      // write the labels
      if (suffixBracket != null) {

        Point2d subSufPnt = suffixBracket.getFirstPoint();
        Point2d supSufPnt = suffixBracket.getSecondPoint();

        // try to put the subscript on the bottom
        double xDiff = subSufPnt.x - supSufPnt.x;
        double yDiff = subSufPnt.y - supSufPnt.y;
        if (yDiff > EQUIV_THRESHOLD || (yDiff > -EQUIV_THRESHOLD && xDiff > EQUIV_THRESHOLD)) {
          Point2d tmpP = subSufPnt;
          subSufPnt = supSufPnt;
          supSufPnt = tmpP;
        }

        // subscript/superscript suffix annotation
        if (subscriptSuffix != null && !subscriptSuffix.isEmpty()) {
          TextOutline subscriptOutline =
              leftAlign(
                  makeText(
                      subscriptSuffix.toLowerCase(Locale.ROOT),
                      subSufPnt,
                      suffixBracketPerp,
                      labelScale));
          result.add(GeneralPath.shapeOf(subscriptOutline.getOutline(), foreground));
        }
        if (superscriptSuffix != null && !superscriptSuffix.isEmpty()) {
          TextOutline superscriptOutline =
              leftAlign(
                  makeText(
                      superscriptSuffix.toLowerCase(Locale.ROOT),
                      supSufPnt,
                      suffixBracketPerp,
                      labelScale));
          result.add(GeneralPath.shapeOf(superscriptOutline.getOutline(), foreground));
        }
      }
    } else if (brackets.size() == 2) {

      final Point2d b1p1 = brackets.get(0).getFirstPoint();
      final Point2d b1p2 = brackets.get(0).getSecondPoint();
      final Point2d b2p1 = brackets.get(1).getFirstPoint();
      final Point2d b2p2 = brackets.get(1).getSecondPoint();

      final Vector2d b1vec = VecmathUtil.newUnitVector(b1p1, b1p2);
      final Vector2d b2vec = VecmathUtil.newUnitVector(b2p1, b2p2);

      final Vector2d b1pvec = VecmathUtil.newPerpendicularVector(b1vec);
      final Vector2d b2pvec = VecmathUtil.newPerpendicularVector(b2vec);

      // Point the vectors at each other
      if (b1pvec.dot(VecmathUtil.newUnitVector(b1p1, b2p1)) < 0) b1pvec.negate();
      if (b2pvec.dot(VecmathUtil.newUnitVector(b2p1, b1p1)) < 0) b2pvec.negate();

      // scale perpendicular vectors by how deep the brackets need to be
      b1pvec.scale(bracketDepth);
      b2pvec.scale(bracketDepth);

      // bad brackets
      if (Double.isNaN(b1pvec.x)
          || Double.isNaN(b1pvec.y)
          || Double.isNaN(b2pvec.x)
          || Double.isNaN(b2pvec.y)) return result;

      Path2D path = new Path2D.Double();

      if (round) {
        // bracket 1 (cp: control point)
        path.moveTo(b1p1.x + b1pvec.x, b1p1.y + b1pvec.y);
        Point2d cpb1 = VecmathUtil.midpoint(b1p1, b1p2);
        cpb1.add(VecmathUtil.negate(b1pvec));
        path.quadTo(cpb1.x, cpb1.y, b1p2.x + b1pvec.x, b1p2.y + b1pvec.y);

        // bracket 2 (cp: control point)
        path.moveTo(b2p1.x + b2pvec.x, b2p1.y + b2pvec.y);
        Point2d cpb2 = VecmathUtil.midpoint(b2p1, b2p2);
        cpb2.add(VecmathUtil.negate(b2pvec));
        path.quadTo(cpb2.x, cpb2.y, b2p2.x + b2pvec.x, b2p2.y + b2pvec.y);
      } else {
        // bracket 1
        path.moveTo(b1p1.x + b1pvec.x, b1p1.y + b1pvec.y);
        path.lineTo(b1p1.x, b1p1.y);
        path.lineTo(b1p2.x, b1p2.y);
        path.lineTo(b1p2.x + b1pvec.x, b1p2.y + b1pvec.y);

        // bracket 2
        path.moveTo(b2p1.x + b2pvec.x, b2p1.y + b2pvec.y);
        path.lineTo(b2p1.x, b2p1.y);
        path.lineTo(b2p2.x, b2p2.y);
        path.lineTo(b2p2.x + b2pvec.x, b2p2.y + b2pvec.y);
      }

      result.add(GeneralPath.outlineOf(path, stroke, foreground));

      // work out where to put the suffix labels (e.g. ht/hh/eu) superscript
      // and (e.g. n, xl, c, mix) subscript
      // TODO: could be improved
      double b1MaxX = Math.max(b1p1.x, b1p2.x);
      double b2MaxX = Math.max(b2p1.x, b2p2.x);
      double b1MaxY = Math.max(b1p1.y, b1p2.y);
      double b2MaxY = Math.max(b2p1.y, b2p2.y);

      Point2d subSufPnt = b2p2;
      Point2d supSufPnt = b2p1;
      Vector2d subpvec = b2pvec;

      double bXDiff = b1MaxX - b2MaxX;
      double bYDiff = b1MaxY - b2MaxY;

      if (bXDiff > EQUIV_THRESHOLD || (bXDiff > -EQUIV_THRESHOLD && bYDiff < -EQUIV_THRESHOLD)) {
        subSufPnt = b1p2;
        supSufPnt = b1p1;
        subpvec = b1pvec;
      }

      double xDiff = subSufPnt.x - supSufPnt.x;
      double yDiff = subSufPnt.y - supSufPnt.y;

      if (yDiff > EQUIV_THRESHOLD || (yDiff > -EQUIV_THRESHOLD && xDiff > EQUIV_THRESHOLD)) {
        Point2d tmpP = subSufPnt;
        subSufPnt = supSufPnt;
        supSufPnt = tmpP;
      }

      // subscript/superscript suffix annotation
      if (subscriptSuffix != null && !subscriptSuffix.isEmpty()) {
        TextOutline subscriptOutline =
            leftAlign(
                makeText(subscriptSuffix.toLowerCase(Locale.ROOT), subSufPnt, subpvec, labelScale));
        result.add(GeneralPath.shapeOf(subscriptOutline.getOutline(), foreground));
      }
      if (superscriptSuffix != null && !superscriptSuffix.isEmpty()) {
        TextOutline superscriptOutline =
            leftAlign(
                makeText(
                    superscriptSuffix.toLowerCase(Locale.ROOT), supSufPnt, subpvec, labelScale));
        result.add(GeneralPath.shapeOf(superscriptOutline.getOutline(), foreground));
      }
    }
    return result;
  }