@Override public IBitFingerprint getBitFingerprint(IAtomContainer container) throws CDKException { BitSet fp = new BitSet(pathToBit.size()); List<String> paths = new ArrayList<>(); calculate(paths, container); for (String path : paths) fp.set(pathToBit.get(path)); return new BitSetFingerprint(fp); }
/** * Convert a mapping of features and their counts to a binary fingerprint. Each feature * can set 1-n hashes, the amount is modified by the {@code bits} operand. * * @param features features to include * @param len fingerprint length * @param bits number of bits to set for each pattern * @return the continuous fingerprint */ public static IBitFingerprint makeBitFingerprint(final Map<String,Integer> features, int len, int bits) { final BitSetFingerprint fingerprint = new BitSetFingerprint(len); final Random rand = new Random(); for (String feature : features.keySet()) { int hash = feature.hashCode(); fingerprint.set(Math.abs(hash % len)); for (int i = 1; i < bits; i++) { rand.setSeed(hash); fingerprint.set(hash = rand.nextInt(len)); } } return fingerprint; }
@Test public void testFingerprint() throws Exception { /* * We are going to test hexane. Hexane is a good test b/c it has 10 carbons. * Since the max distance for this fingerprint is 10, the final C-C fingerprint slot * at distance 10 should return false, while all the other C-C fingerprint slots * should return true. */ IFingerprinter printer = new AtomPairs2DFingerprinter(); IAtomContainer mol1 = parser.parseSmiles("cccccccccc"); BitSetFingerprint bsfp = (BitSetFingerprint) printer.getBitFingerprint(mol1); Assert.assertEquals(9, bsfp.cardinality()); Assert.assertEquals(true, bsfp.get(0)); //Distance 1 Assert.assertEquals(true, bsfp.get(78)); //Distance 2 Assert.assertEquals(true, bsfp.get(156)); //Distance 3 Assert.assertEquals(true, bsfp.get(234)); //Distance 4 Assert.assertEquals(true, bsfp.get(312)); //Distance 5 Assert.assertEquals(true, bsfp.get(390)); //Distance 6 Assert.assertEquals(true, bsfp.get(468)); //Distance 7 Assert.assertEquals(true, bsfp.get(546)); //Distance 8 Assert.assertEquals(true, bsfp.get(624)); //Distance 9 Assert.assertEquals(false, bsfp.get(702)); //Distance 10 }
/** * Calculates the circular fingerprint for the given {@link IAtomContainer}, and <b>folds</b> the result into a single bitset * (see getSize()). * * @param mol IAtomContainer for which the fingerprint should be calculated. * @return the fingerprint */ @Override public IBitFingerprint getBitFingerprint(IAtomContainer mol) throws CDKException { calculate(mol); final BitSet bits = new BitSet(length); for (int n = 0; n < fplist.size(); n++) { int i = fplist.get(n).hashCode; long b = i >= 0 ? i : ((i & 0x7FFFFFFF) | (1L << 31)); bits.set((int) (b % length)); } return new BitSetFingerprint(bits); }
@Override public IBitFingerprint getBitFingerprint(IAtomContainer container) throws CDKException { final BitSetFingerprint bitset = new BitSetFingerprint(getSize()); for (int r : radius) { final List<Sphere> spheres = generateAllSpheresFrom(container, r); final HashSet<Sphere> sphereHashSet = new HashSet<>(spheres); for (int k=0; k < this.spheres.length; ++k) { if (this.spheres[k].radius == r && sphereHashSet.contains(this.spheres[k])) bitset.set(k); } } return bitset; }
/** {@inheritDoc} */ @Override public IBitFingerprint getBitFingerprint(IAtomContainer atomContainer) throws CDKException { int bitsetLength = PATTERNS.length; BitSet fingerPrint = new BitSet(bitsetLength); SmartsPattern.prepare(atomContainer); for (int i = 0; i < PATTERNS.length; i++) { if (PATTERNS[i].matches(atomContainer)) fingerPrint.set(i, true); } return new BitSetFingerprint(fingerPrint); }
@Override public IBitFingerprint getBitFingerprint(IAtomContainer atomContainer) throws CDKException { BitSetFingerprint bitSetFingerprint = new BitSetFingerprint(getSize()); ShortestPathWalker walker = new ShortestPathWalker(atomContainer); for (String path : walker.paths) { final Integer i = bits.get(path); if (i != null) bitSetFingerprint.set(i); } return bitSetFingerprint; }
/** {@inheritDoc} */ @Override public IBitFingerprint getBitFingerprint(IAtomContainer atomContainer) throws CDKException { if (keys.isEmpty()) { throw new CDKException("No substructures were defined"); } SmartsPattern.prepare(atomContainer); BitSet fingerPrint = new BitSet(keys.size()); for (int i = 0; i < keys.size(); i++) { if (keys.get(i).pattern.matches(atomContainer)) fingerPrint.set(i, true); } return new BitSetFingerprint(fingerPrint); }
@Override public IBitFingerprint getBitFingerprint(IAtomContainer container) throws CDKException { final BitSetFingerprint bf = new BitSetFingerprint(getSize()); final ICountFingerprint icfp = circularFingerprinter.getCountFingerprint(container); for (int k=0, n = icfp.numOfPopulatedbins(); k < n; ++k) { final int index = HASH_SET.get(icfp.getHash(k)); if (index >= 0) { if (icfp.getCount(k)>0) bf.set(index, true); } } return bf; }
/** * Calculate 881 bit Pubchem fingerprint for a molecule. * * See * <a href="ftp://ftp.ncbi.nlm.nih.gov/pubchem/specifications/pubchem_fingerprints.txt">here</a> * for a description of each bit position. * * @param atomContainer the molecule to consider * @return the fingerprint * @throws CDKException if there is an error during substructure * searching or atom typing * @see #getFingerprintAsBytes() */ @Override public IBitFingerprint getBitFingerprint(IAtomContainer atomContainer) throws CDKException { generateFp(atomContainer); BitSet fp = new BitSet(FP_SIZE); for (int i = 0; i < FP_SIZE; i++) { if (isBitOn(i)) fp.set(i); } return new BitSetFingerprint(fp); }
@Override public IBitFingerprint getBitFingerprint(IAtomContainer atomContainer) throws CDKException { int bitsetLength = queries.length; BitSet fingerPrint = new BitSet(bitsetLength); { SmartsMatchers.prepare(atomContainer, true); AtomContainerManipulator.percieveAtomTypesAndConfigureAtoms(atomContainer); Aromaticity aroma = new Aromaticity(ElectronDonation.cdk(), Cycles.cdkAromaticSet()); aroma.apply(atomContainer); } for (int i = 0; i < queries.length; i++) { boolean status = queries[i].matches(atomContainer); if (status) fingerPrint.set(i, true); } return new BitSetFingerprint(fingerPrint); }
return new BitSetFingerprint(fp);
IBitFingerprint allOnesFingerprint = new BitSetFingerprint(fingerPrinter.getSize()); for (int i = 0; i < fingerPrinter.getSize(); i++) { allOnesFingerprint.set(i, true);
/** * Evaluates Tanimoto coefficient for two <code>IBitFingerprint</code>. * <p> * @param fingerprint1 fingerprint for the first molecule * @param fingerprint2 fingerprint for the second molecule * @return The Tanimoto coefficient * @throws IllegalArgumentException if bitsets are not of the same length */ public static double calculate(IBitFingerprint fingerprint1, IBitFingerprint fingerprint2) { if (fingerprint1.size() != fingerprint2.size()) { throw new IllegalArgumentException("Fingerprints must have the same size"); } int cardinality1 = fingerprint1.cardinality(); int cardinality2 = fingerprint2.cardinality(); // If the fingerprint is an IntArrayFingeprint that could mean a big // fingerprint so let's take the safe way out and create a // new IntArrayfingerprint IBitFingerprint one_and_two = fingerprint1 instanceof IntArrayFingerprint ? new IntArrayFingerprint( fingerprint1) : new BitSetFingerprint(fingerprint1); one_and_two.and(fingerprint2); double cardinalityCommon = one_and_two.cardinality(); return cardinalityCommon / (cardinality1 + cardinality2 - cardinalityCommon); }
/** * Generates a fingerprint of the default size for the given AtomContainer. * * @param container The AtomContainer for which a Fingerprint is generated * @param ringFinder An instance of * {@link org.openscience.cdk.ringsearch.AllRingsFinder} * @exception CDKException if there is a timeout in ring or aromaticity * perception * @return A {@link BitSet} representing the fingerprint */ public IBitFingerprint getBitFingerprint(IAtomContainer container, AllRingsFinder ringFinder) throws CDKException { logger.debug("Entering Fingerprinter"); logger.debug("Starting Aromaticity Detection"); long before = System.currentTimeMillis(); if (!hasPseudoAtom(container.atoms())) { AtomContainerManipulator.percieveAtomTypesAndConfigureAtoms(container); Aromaticity.cdkLegacy().apply(container); } long after = System.currentTimeMillis(); logger.debug("time for aromaticity calculation: " + (after - before) + " milliseconds"); logger.debug("Finished Aromaticity Detection"); BitSet bitSet = new BitSet(size); encodePaths(container, searchDepth, bitSet, size); return new BitSetFingerprint(bitSet); }
return new BitSetFingerprint(fp);
/** * Generates a shortest path based BitSet fingerprint for the given AtomContainer. * * @param ac The AtomContainer for which a fingerprint is generated * @exception CDKException if there error in aromaticity perception or other CDK functions * @return A {@link BitSet} representing the fingerprint */ @Override public IBitFingerprint getBitFingerprint(IAtomContainer ac) throws CDKException { IAtomContainer atomContainer = null; try { atomContainer = (IAtomContainer) ac.clone(); } catch (CloneNotSupportedException ex) { logger.error("Failed to clone the molecule:", ex); } Aromaticity.cdkLegacy().apply(atomContainer); BitSet bitSet = new BitSet(fingerprintLength); if (!ConnectivityChecker.isConnected(atomContainer)) { IAtomContainerSet partitionedMolecules = ConnectivityChecker.partitionIntoMolecules(atomContainer); for (IAtomContainer container : partitionedMolecules.atomContainers()) { addUniquePath(container, bitSet); } } else { addUniquePath(atomContainer, bitSet); } return new BitSetFingerprint(bitSet); }
@Test public void testCompareBitSetandBitFingerprintTanimoto() throws Exception { IAtomContainer mol1 = TestMoleculeFactory.make123Triazole(); IAtomContainer mol2 = TestMoleculeFactory.makeImidazole(); Fingerprinter fingerprinter = new Fingerprinter(1024, 8); BitSet bs1 = fingerprinter.getBitFingerprint(mol1).asBitSet(); BitSet bs2 = fingerprinter.getBitFingerprint(mol2).asBitSet(); float tanimoto = Tanimoto.calculate(bs1, bs2); BitSetFingerprint fp1 = new BitSetFingerprint(bs1); BitSetFingerprint fp2 = new BitSetFingerprint(bs2); double tanimoto2 = Tanimoto.calculate(fp1, fp2); Assert.assertEquals(tanimoto, tanimoto2, 0.01); IntArrayFingerprint ifp1 = new IntArrayFingerprint(fp1); IntArrayFingerprint ifp2 = new IntArrayFingerprint(fp2); tanimoto2 = Tanimoto.calculate(ifp1, ifp2); Assert.assertEquals(tanimoto, tanimoto2, 0.01); }