import org.biojava.nbio.alignment.SimpleGapPenalty; //导入依赖的package包/类
/**
 * Filter the {@link SegmentDataRDD} based on minimum sequence similarity to a reference sequence.
 * @param inputSequence the reference sequence to compare
 * @param minSimilarity the minimum similarity (as a double between 0.00 and 1.00)
 * @return the {@link SegmentDataRDD} after being filtered 
 * @throws CompoundNotFoundException if Biojava cannot accurately convert the String sequence to a {@link ProteinSequence}
 */
public static SegmentDataRDD filterSequenceSimilar(SegmentDataRDD segmentDataRDD, String inputSequence, double minSimilarity) throws CompoundNotFoundException {
	ProteinSequence proteinSequence = new ProteinSequence(inputSequence);
	// First set up the environment
	int gop = 8;
	int extend = 1;
	GapPenalty penalty = new SimpleGapPenalty();
	penalty.setOpenPenalty(gop);
	penalty.setExtensionPenalty(extend);
	SubstitutionMatrix<AminoAcidCompound> matrix = SubstitutionMatrixHelper.getBlosum65();
	return new SegmentDataRDD(segmentDataRDD.getSegmentRDD().filter(t -> {
		ProteinSequence otherSequence = new ProteinSequence(t._2.getSequence());
		PairwiseSequenceAligner<ProteinSequence, AminoAcidCompound> smithWaterman =
				Alignments.getPairwiseAligner(proteinSequence, otherSequence, PairwiseSequenceAlignerType.LOCAL, penalty, matrix);
		if(smithWaterman.getSimilarity()<minSimilarity){
			return false;
		}
		return true;
	}));
}
 

import org.biojava.nbio.alignment.SimpleGapPenalty; //导入依赖的package包/类
private void  swAlignment() throws CompoundNotFoundException {

        ProteinSequence s1 = new ProteinSequence(query);
        s1.setAccession(new AccessionID("Query"));

        ProteinSequence s2 = new ProteinSequence(subject);
        s2.setAccession(new AccessionID("Subject"));

        SubstitutionMatrix<AminoAcidCompound> matrix
                = SimpleSubstitutionMatrix.getBlosum62();


        alignment =  Alignments.getPairwiseAlignment(s1, s2,
                        Alignments.PairwiseSequenceAlignerType.LOCAL,
                        new SimpleGapPenalty(), matrix);

        FractionalSimilarityScorer<ProteinSequence, AminoAcidCompound> scorer =
                new FractionalSimilarityScorer<>(alignment);
        score = scorer.getScore();
    }
 

import org.biojava.nbio.alignment.SimpleGapPenalty; //导入依赖的package包/类
@BeforeClass
public static void setUpBefore() throws URISyntaxException {
	sf_matrix = new SimpleSubstitutionMatrix<>(AmbiguityDNACompoundSet.getDNACompoundSet(), (short)sf_m, (short)-sf_m);
	sf_gapPenalty = new SimpleGapPenalty(5, 3); // and sf_m==2, so they're all coprime
	sf_gop = sf_gapPenalty.getOpenPenalty();
	sf_gep = sf_gapPenalty.getExtensionPenalty();
}
 

import org.biojava.nbio.alignment.SimpleGapPenalty; //导入依赖的package包/类
@Test // TODO Biojava is even more wrong
public void testAdjacentGaps() throws Exception {
	DNASequence a = new DNASequence("AAATTT  CCCATTT".replaceAll(" ", ""));
	DNASequence b = new DNASequence("AAA  GGGCCCATTT".replaceAll(" ", ""));
	GapPenalty gapPenalty = new SimpleGapPenalty(0, 0);
	@SuppressWarnings("unchecked")
	SequenceAligner<DNASequence, NucleotideCompound> aligner = new SequenceAligner.Builder<>(sf_matrix, Alignments.PairwiseSequenceAlignerType.GLOBAL, DNASequence::new).setGapPenalty(gapPenalty).build();
	int scoreA = aligner.align(a, b).getScore();
	assertEquals(sf_m * "AAA".length() + sf_m * "CCCATTT".length() + 2 * sf_gop - 5 * sf_gep, scoreA);
	int score = aligner.alignFast(a, b);
	assertEquals(sf_m * "AAA".length() + sf_m * "CCCATTT".length() + 2 * sf_gop - 5 * sf_gep, score);
}
 

import org.biojava.nbio.alignment.SimpleGapPenalty; //导入依赖的package包/类
@Override
public double[] call() throws Exception
{
    List<ProteinSequence> sequences = Lists.newArrayList(new ProteinSequence(pair_.getQuery().getValue()), 
                                                         new ProteinSequence(pair_.getTarget().getValue()));
    
    return Alignments.getAllPairsScores(sequences, PairwiseSequenceScorerType.LOCAL, new SimpleGapPenalty(), getBlosum65());
}
 

import org.biojava.nbio.alignment.SimpleGapPenalty; //导入依赖的package包/类
private static void alignPairLocal(String id1, String id2) throws Exception {
    ProteinSequence s1 = new ProteinSequence("METSSSLPLSPISIEPEQPSHRDYDITTRRGVGTTGNPIELCTNHFNVSVRQPDVVFYQY" +
            "TVSITTENGDAVDGTGISRKLMDQLFKTYSSDLDGKRLAYDGEKTLYTVGPLPQNEFDFL" +
            "VIVEGSFSKRDCGVSDGGSSSGTCKRSKRSFLPRSYKVQIHYAAEIPLKTVLGTQRGAYT" +
            "PDKSAQDALRVLDIVLRQQAAERGCLLVRQAFFHSDGHPMKVGGGVIGIRGLHSSFRPTH" +
            "GGLSLNIDVSTTMILEPGPVIEFLKANQSVETPRQIDWIKAAKMLKHMRVKATHRNMEFK" +
            "IIGLSSKPCNQQLFSMKIKDGEREVPIREITVYDYFKQTYTEPISSAYFPCLDVGKPDRP" +
            "NYLPLEFCNLVSLQRYTKPLSGRQRVLLVESSRQKPLERIKTLNDAMHTYCYDKDPFLAG" +
            "CGISIEKEMTQVEGRVLKPPMLKFGKNEDFQPCNGRWNFNNKMLLEPRAIKSWAIVNFSF" +
            "PCDSSHISRELISCGMRKGIEIDRPFALVEEDPQYKKAGPVERVEKMIATMKLKFPDPPH" +
            "FILCILPERKTSDIYGPWKKICLTEEGIHTQCICPIKISDQYLTNVLLKINSKLGGINSL" +
            "LGIEYSYNIPLINKIPTLILGMDVSHGPPGRADVPSVAAVVGSKCWPLISRYRAAVRTQS" +
            "PRLEMIDSLFQPIENTEKGDNGIMNELFVEFYRTSRARKPKQIIIFRDGVSESQFEQVLK" +
            "IEVDQIIKAYQRLGESDVPKFTVIVAQKNHHTKLFQAKGPENVPAGTVVDTKIVHPTNYD" +
            "FYMCAHAGKIGTSRPAHYHVLLDEIGFSPDDLQNLIHSLSYVNQRSTTATSIVAPVRYAH" +
            "LAAAQVAQFTKFEGISEDGKVPELPRLHENVEGNMFFC");
    ProteinSequence s2 = new ProteinSequence("MDLLDKVMGEMGSKPGSTAKKPATSASSTPRTNVWGTAKKPSSQQQPPKPLFTTPGSQQG" +
            "SLGGRIPKREHTDRTGPDPKRKPLGGLSVPDSFNNFGTFRVQMNAWNLDISKMDERISRI" +
            "MFRATLVHTDGRRFELSLGVSAFSGDVNRQQRRQAQCLLFRAWFKRNPELFKGMTDPAIA" +
            "AYDAAETIYVGCSFFDVELTEHVCHLTEADFSPQEWKIVSLISRRSGSTFEIRIKTNPPI" +
            "YTRGPNALTLENRSELTRIIEAITDQCLHNEKFLLYSSGTFPTKGGDIASPDEVTLIKSG" +
            "FVKTTKIVDRDGVPDAIMTVDTTKSPFYKDTSLLKFFTAKMDQLTNSGGGPRGHNGGRER" +
            "RDGGGNSRKYDDRRSPRDGEIDYDERTVSHYQRQFQDERISDGMLNTLKQSLKGLDCQPI" +
            "HLKDSKANRSIMIDEIHTGTADSVTFEQKLPDGEMKLTSITEYYLQRYNYRLKFPHLPLV" +
            "TSKRAKCYDFYPMELMSILPGQRIKQSHMTVDIQSYMTGKMSSLPDQHIKQSKLVLTEYL" +
            "KLGDQPANRQMDAFRVSLKSIQPIVTNAHWLSPPDMKFANNQLYSLNPTRGVRFQTNGKF" +
            "VMPARVKSVTIINYDKEFNRNVDMFAEGLAKHCSEQGMKFDSRPNSWKKVNLGSSDRRGT" +
            "KVEIEEAIRNGVTIVFGIIAEKRPDMHDILKYFEEKLGQQTIQISSETADKFMRDHGGKQ" +
            "TIDNVIRKLNPKCGGTNFLIDVPESVGHRVVCNNSAEMRAKLYAKTQFIGFEMSHTGART" +
            "RFDIQKVMFDGDPTVVGVAYSLKHSAQLGGFSYFQESRLHKLTNLQEKMQICLNAYEQSS" +
            "SYLPETVVVYRVGSGEGDYPQIVNEVNEMKLAARKKKHGYNPKFLVICTQRNSHIRVFPE" +
            "HINERGKSMEQNVKSGTCVDVPGASHGYEEFILCCQTPLIGTVKPTKYTIIVNDCRWSKN" +
            "EIMNVTYHLAFAHQVSYAPPAIPNVSYAAQNLAKRGHNNYKTHTKLVDMNDYSYRIKEKH" +
            "EEIISSEEVDDILMRDFIETVSNDLNAMTINGRNFWA");
    SubstitutionMatrix<AminoAcidCompound> matrix = SimpleSubstitutionMatrix.getBlosum62();
    SequencePair<ProteinSequence, AminoAcidCompound> pair = Alignments.getPairwiseAlignment(s1, s2,
            Alignments.PairwiseSequenceAlignerType.LOCAL, new SimpleGapPenalty(), matrix);
    System.out.printf("%n%s vs %s%n%s", pair.getQuery().getAccession(), pair.getTarget().getAccession(), pair);
}
 

import org.biojava.nbio.alignment.SimpleGapPenalty; //导入依赖的package包/类
@Before
public void setup() throws CompoundNotFoundException {
	query = new ProteinSequence("ARND");
	target = new ProteinSequence("RDG");
	gaps = new SimpleGapPenalty(10, 1);
	blosum62 = SubstitutionMatrixHelper.getBlosum62();
	alignment = new GuanUberbacher<ProteinSequence, AminoAcidCompound>(query, target, gaps, blosum62);
	self = new GuanUberbacher<ProteinSequence, AminoAcidCompound>(query, query, gaps, blosum62);
}
 

import org.biojava.nbio.alignment.SimpleGapPenalty; //导入依赖的package包/类
/**
 * @author Daniel Cameron
 */
@Test
public void should_align_shorter_query() throws CompoundNotFoundException {
	DNASequence query = new DNASequence("A", AmbiguityDNACompoundSet.getDNACompoundSet());
	DNASequence target = new DNASequence("AT", AmbiguityDNACompoundSet.getDNACompoundSet());
	GuanUberbacher<DNASequence, NucleotideCompound> aligner = new GuanUberbacher<DNASequence, NucleotideCompound>(query, target, new SimpleGapPenalty((short)5, (short)2), SubstitutionMatrixHelper.getNuc4_4());
	assertEquals(String.format("A-%nAT%n"), aligner.getPair().toString());
}
 

import org.biojava.nbio.alignment.SimpleGapPenalty; //导入依赖的package包/类
/**
 * @author Daniel Cameron
 */
@Test
public void should_align_shorter_target() throws CompoundNotFoundException {
	DNASequence query = new DNASequence("AT", AmbiguityDNACompoundSet.getDNACompoundSet());
	DNASequence target = new DNASequence("A", AmbiguityDNACompoundSet.getDNACompoundSet());
	GuanUberbacher<DNASequence, NucleotideCompound> aligner = new GuanUberbacher<DNASequence, NucleotideCompound>(query, target, new SimpleGapPenalty((short)5, (short)2), SubstitutionMatrixHelper.getNuc4_4());
	assertEquals(String.format("AT%nA-%n"), aligner.getPair().toString());
}
 

import org.biojava.nbio.alignment.SimpleGapPenalty; //导入依赖的package包/类
/**
 * @author Daniel Cameron
 */
@Test
public void should_align_multiple_cuts() throws CompoundNotFoundException {
	DNASequence query = new DNASequence("AAT", AmbiguityDNACompoundSet.getDNACompoundSet());
	DNASequence target = new DNASequence("AATG", AmbiguityDNACompoundSet.getDNACompoundSet());
	GuanUberbacher<DNASequence, NucleotideCompound> aligner = new GuanUberbacher<DNASequence, NucleotideCompound>(query, target, new SimpleGapPenalty((short)0, (short)2), SubstitutionMatrixHelper.getNuc4_4());
	aligner.setCutsPerSection(2); // 3 bases with 2 cuts
	assertEquals(String.format("AAT-%nAATG%n"), aligner.getPair().toString());
}
 

import org.biojava.nbio.alignment.SimpleGapPenalty; //导入依赖的package包/类
@Before
public void setup() throws CompoundNotFoundException {
	protein1 = new ProteinSequence("ARND");
	protein2 = new ProteinSequence("ARND");
	protein3 = new ProteinSequence("HILK");
	protein4 = new ProteinSequence("ANDR");
	gaps = new SimpleGapPenalty((short) 2, (short) 1);
	blosum62 = SubstitutionMatrixHelper.getBlosum62();
	pair1 = new NeedlemanWunsch<ProteinSequence, AminoAcidCompound>(protein1, protein2, gaps, blosum62).getPair();
	pair2 = new NeedlemanWunsch<ProteinSequence, AminoAcidCompound>(protein3, protein4, gaps, blosum62).getPair();
}
 

import org.biojava.nbio.alignment.SimpleGapPenalty; //导入依赖的package包/类
@GET
    @Produces(MediaType.APPLICATION_JSON)
    @Path("/verse/algin/sw/{chapterNo}/{verseNo}/{threshold}")
    public Response smithWaterman(@PathParam("chapterNo") int chapterNo, @PathParam("verseNo") int verseNo, @PathParam("threshold") int threshold) {


        int MATCH_SCORE = 3;
        ResultList<Verse, Double> scores = new ResultList<>();

        Verse verse = managersSet.getVerseManager().get(chapterNo, verseNo);

        List<Root> mainRootList = VerseUtils.getRootList(verse);
        Verse nextVerse = verse.getSuccessor();

        while (nextVerse != null) {
            List<Root> secondRootList = VerseUtils.getRootList(nextVerse);

            RootCompoundSet cs = new RootCompoundSet(mainRootList, secondRootList);

            SmithWaterman sw = new SmithWaterman();
            sw.setQuery(new ArrayListSequenceReader(cs.getCompounds(0), cs));
            sw.setTarget(new ArrayListSequenceReader(cs.getCompounds(1), cs));

            GapPenalty penalty = new SimpleGapPenalty(2, 1);
            sw.setGapPenalty(penalty);

            RootSubstitutionMatrix matrix = new RootSubstitutionMatrix(cs, (short) MATCH_SCORE, (short) -4);
            sw.setSubstitutionMatrix(matrix);

            Double score = sw.getScore();
            if (score >= (MATCH_SCORE * threshold)) {
                scores.add(new ResultItem<Verse, Double>(nextVerse, score));
//                System.out.println(nextVerse.getAddress() + "***" + score);
            }

            nextVerse = nextVerse.getNextInQuran();
        }

        scores.descendSort();
        String json = getJson("verses", scores);
        return getOkResponse(json);
    }
 

import org.biojava.nbio.alignment.SimpleGapPenalty; //导入依赖的package包/类
public static void main(String[] args) throws Exception {

		String query = "AGGATGAACGCTGGCGGCGTGCTTAACACATGCAAGTCGAACGGTGAAGCCCAGCTTGCTGGGTGGATCA" +
		"GTGGCGAACGGGTGAGTAACACGTGAGCAACCTGCCCCTGACTCTGGGATAAGCGCTGGAAACGGTGTCT" +
		"AATACTGGATATGAGCTACCACCGCATGGTGAGTGGTTGGAAAGATTTTTCGGTTGGGGATGGGCTCGCG" +
		"GCCTATCAGCTTGTTGGTGAGGTAATGGCTCACCAAGGCGTCGACGGGTAGCCGGCCTGAGAGGGTGACC" +
		"GGCCACACTGGGACTGAGACACGGCCCAGACTCTACGGGAGGCAGCAGTGGGGAATATTGCACAATGGGC" +
		"GGAAGCCTGATGCAGCAACGCCGCGTGAGGGACGACGGCTTCGGGTTGTAAACCTCTTTTAGCAGGGAAG" +
		"AAGCGAGAGTGACGGTACCTGCAGAAAAAGCGCCGGCTAACTACGTGCCAGCAGCCGCGGTAATACGTAG" +
		"GGCGCAAGCGTTATCCGGAATTATTGGGCGTAAAGAGCTCGTAGGCGGTTTGTCGCGTCTGCTGTGAAAA" +
		"CCCGAGGCTCAACCTNNGGGCTGCAGTGGGTACGGGCAGACTAGAGTGCGGTAGGGGAGATTGGAATTCC" +
		"TGGTGTAGCGGTGGAATGCGCAGATATCAGGAGGAACACCGATGGCGAAGGCAGATCTCTGGGCCGTAAC" +
		"TGACGCTGAGGAGCGAAAGGGTGGGGAGCAAACAGGCTTAGATACCCTGGTAGTCCACCCCGTAAACGTT" +
		"GGGAACTAGTTGTGGGGTCCTTTCCACGGATTCCGTGACGCACGTAACGCATTAAGTTCCCCGCCTGGGG" +
		"AGTACGGCCGCAAGGCTAAAACTCAAAGGAATTGACGGGGACCCGCACAAGCGGCGGAGCATGCGGATTA" +
		"AATCGATGCAACGCGAAGAACCTTACCAAGGCTTGACATACACGAGAACGCTGCAGAAATGTAGAACTCT" +
		"TTGGACACTCGTGAACAGGTGGTGCATGGTTGTCGTCAGCTCGTGTCGTGAGATGTTGGGTTAAGTCCCG" +
		"CAACGAGCGCAACCCTCGTTCTATGTTGCCAGCACGTAATGGTGGGAACTCATGGGATACTGCCGGGGTC" +
		"AACTCGGAGGAAGGTGGGGATGACGTCAAATCATCATGCCCCTTATGTCTTGGGCTTCACGCATGCTACA" +
		"ATGGCCGGTACAAAGGGCTGCAATACCGTGAGGTGGAGCGAATCCCAAAAAGCCGGTCCCAGTTCGGATT" +
		"GAGGTCTGCAACTCGACCTCATGAAGTCGGAGTCGCTAGTAATCGCAGATCAGCAACGCTGCGGTGAATA" +
		"CGTTCCCGGGTCTTGTACACACCGCCCGTCAAGTCATGAAAGTCGGTAACACCTGAAGCCGGTGGCCTAA" +
		"CCCTTGTGGAGGGAGCCGGTAATTAAA";

		String target = "CTGGCCGCCTGCTTAACACATCCAAGTCGAACGGTGAAGCCCCANCTTACTGGGTGGATCAGTGCCGAAC" +
		"GGGTGAGTAACACGTGAGCAACCTCCCCCTGACTCTGGGATAAGCGCTGGAANCGGTGTCTAATACTGGA" +
		"TATGAGCTACCACCGCATGGTGAGTGGTTGGAAAGATTTTTCGGTTGGGGATGGGCTCGCGCCCTATGAG" +
		"CTTGTTGGTGAGGTAATGGCTCACCAAGCCGTCGACGGGTAGCCGGCCTGAGAGGGTGACCGNCCACACT" +
		"GGGACTGAGACACGGCCCAGACTCCTACGGGAGGCAGCAGTGGGGAATATTGCACAATGGGCGGAAGCCT" +
		"GATTCANCAACCCCGCGTGAGGGACGACGGCCTTCGGGTTGTAAACCTCTTTTAGCAGGGAAGAAGCGAG" +
		"AGTGACGGTACCTGCAGAAAAAGCCCCGGCTAACTACGTGCCAGCAGCCGCGGTAATACGTAGGGCGCAA" +
		"GCGTTATCCGGAATTATTGGGCGTAAAGAGCTCGTAGGCGGTTTGTCGCGTCTGCTGTGAAAACCCGAGG" +
		"CTCAACCTCGGGCCTGCAGTGGGTACGGGCAGACTAGAGTGCGGTAGGGGAGATTGGAATTCCTGGTGTA" +
		"GCGGTGGAATGCGCAGATATCAGGAGGAACACCGATGGCGAAGGCAGATCTCTGGGCCGTAACTGACGCT" +
		"GAGGAGCGAAAGGGTGGGGAGCAAACAGGCTTAGATACCCTGGTAGTCCACCCCGTAAACGTTGGGAACT" +
		"AGTTGTGGGGTCCTTTCCACGGATTCCGTGACGCAGCTAACGCATTAAGTTCCCCGCCTGGGGAGTACGG" +
		"CCGCAAGGCTAAAACTCAAAGGAATTGACGGGGACCCGCACAAGCGGCGGAGCATGCGGATTAATTCGAT" +
		"GCAACGCGAAGAACCTTACCAAGGCTTGACATACACGAGAACGCTGCAGAAATGTAGAACTCTTTGGACA" +
		"CTCGTGAACAGGTGGTGCATGGTTGTCGTCAGCTCGTGTCGTGAGATGTTGGGTTAAGTCCCGCAACGAG" +
		"CGCAACCCTCGTTCTATGTTGCCAGCACGTAATGGTGGGAACTCATGGGATACTGCCGGGGTCAACTCGG" +
		"AGGAAGGTGGGGATGACGTCAAATCATCATGCCCCTTATGTCTTGGGCTTCACGCATGCTACAATGGCCG" +
		"GTACAAAGGGCTGCAATACCGTGAGGTGGAGCGAATCCCAAAAAGCCGGTCCCAGTTCGGATTGAGGTCT" +
		"GCAACTCGACCTCATGAAGTCGGAGTCGCTAGTAATCGCAGATCAGCAACGCTGCGGTGAATACGTTCCC" +
		"GGGTCTTGTACACACCGCCCGTCAAGTCATGAAAGTCGGTAACACCTGAAGCCGGTGGCCCAACCCTTGT" +
		"GGAGGGAGCCGTCGAAGGTGGGATCGGTAATTAGGACTAAGTCGTAACAAGGTAGCCGTACC";

		GapPenalty penalty = new SimpleGapPenalty(-14, -4);
		PairwiseSequenceAligner<DNASequence, NucleotideCompound> aligner = Alignments.getPairwiseAligner(
				new DNASequence(query, AmbiguityDNACompoundSet.getDNACompoundSet()),
				new DNASequence(target, AmbiguityDNACompoundSet.getDNACompoundSet()),
				PairwiseSequenceAlignerType.GLOBAL,
				penalty, SubstitutionMatrixHelper.getNuc4_4());
		SequencePair<DNASequence, NucleotideCompound>
		alignment = aligner.getPair();

		System.out.println("Alignment: "+ alignment);

		int identical = alignment.getNumIdenticals();
		System.out.println("Number of identical residues: "+ identical);
		System.out.println("% identical query: "+ identical / (float) query.length());
		System.out.println("% identical target: "+ identical / (float) target.length());
	}
 

import org.biojava.nbio.alignment.SimpleGapPenalty; //导入依赖的package包/类
/**
 * Merges the other SubunitCluster into this one if their representatives
 * sequences are similar (according to the criteria in params).
 * <p>
 * The sequence alignment is performed using linear {@link SimpleGapPenalty} and
 * BLOSUM62 as scoring matrix.
 * 
 * @param other
 *            SubunitCluster
 * @param params
 *            SubunitClustererParameters, with information whether to use local
 *            or global alignment, sequence identity and coverage thresholds.
 *            Threshold values lower than 0.7 are not recommended.
 *            Use {@link #mergeStructure} for lower values.
 * @return true if the SubunitClusters were merged, false otherwise
 * @throws CompoundNotFoundException
 */

public boolean mergeSequence(SubunitCluster other, SubunitClustererParameters params) throws CompoundNotFoundException {
	PairwiseSequenceAlignerType alignerType = PairwiseSequenceAlignerType.LOCAL;
	if (params.isUseGlobalMetrics()) {
		alignerType = PairwiseSequenceAlignerType.GLOBAL;
	}
	return mergeSequence(other, params,alignerType
			, new SimpleGapPenalty(),
			SubstitutionMatrixHelper.getBlosum62());
}
 

import org.biojava.nbio.alignment.SimpleGapPenalty; //导入依赖的package包/类
private static SequencePair<ProteinSequence, AminoAcidCompound> alignProtein(ProteinSequence s1, ProteinSequence s2) {
	SubstitutionMatrix<AminoAcidCompound> matrix = SubstitutionMatrixHelper.getIdentity();

	GapPenalty penalty = new SimpleGapPenalty(8, 1);

	PairwiseSequenceAligner<ProteinSequence, AminoAcidCompound> nw =
			Alignments.getPairwiseAligner(s1, s2, PairwiseSequenceAlignerType.GLOBAL, penalty, matrix);

	return nw.getPair();
}
 

import org.biojava.nbio.alignment.SimpleGapPenalty; //导入依赖的package包/类
private static SequencePair<DNASequence, NucleotideCompound> alignDNA(DNASequence s1, DNASequence s2) {
	SubstitutionMatrix<NucleotideCompound> matrix = SubstitutionMatrixHelper.getNuc4_4();

	GapPenalty penalty = new SimpleGapPenalty(8, 1);

	PairwiseSequenceAligner<DNASequence, NucleotideCompound> nw =
			Alignments.getPairwiseAligner(s1, s2, PairwiseSequenceAlignerType.GLOBAL, penalty, matrix);

	return nw.getPair();
}
 

import org.biojava.nbio.alignment.SimpleGapPenalty; //导入依赖的package包/类
private static SequencePair<RNASequence, NucleotideCompound> alignRNA(RNASequence s1, RNASequence s2) {
	SubstitutionMatrix<NucleotideCompound> matrix = SubstitutionMatrixHelper.getNuc4_4();

	GapPenalty penalty = new SimpleGapPenalty(8, 1);

	PairwiseSequenceAligner<RNASequence, NucleotideCompound> nw =
			Alignments.getPairwiseAligner(s1, s2, PairwiseSequenceAlignerType.GLOBAL, penalty, matrix);

	return nw.getPair();
}
 

import org.biojava.nbio.alignment.SimpleGapPenalty; //导入依赖的package包/类
public static void main(String[] args) throws Exception {

		String uniprotID1 = "P69905";
		String uniprotID2 = "P68871";

		ProteinSequence s1 = getSequenceForId(uniprotID1);
		ProteinSequence s2 = getSequenceForId(uniprotID2);

		SubstitutionMatrix<AminoAcidCompound> matrix = SubstitutionMatrixHelper.getBlosum65();

		GapPenalty penalty = new SimpleGapPenalty();

		int gop = 8;
		int extend = 1;
		penalty.setOpenPenalty(gop);
		penalty.setExtensionPenalty(extend);


		PairwiseSequenceAligner<ProteinSequence, AminoAcidCompound> smithWaterman =
				Alignments.getPairwiseAligner(s1, s2, PairwiseSequenceAlignerType.LOCAL, penalty, matrix);

		SequencePair<ProteinSequence, AminoAcidCompound> pair = smithWaterman.getPair();


		System.out.println(pair.toString(60));


	}
 

import org.biojava.nbio.alignment.SimpleGapPenalty; //导入依赖的package包/类
@Override
public Tuple5<String,String,Float,Float,Float> call(Tuple2<Tuple2<String,String>,Tuple2<String,String>> tuple) throws Exception {

    Tuple2<String,String> p1 = tuple._1();
    Tuple2<String,String> p2 = tuple._2();

    SubstitutionMatrix matrix = SubstitutionMatrixHelper.getBlosum65();
    GapPenalty penalty = new SimpleGapPenalty();
    penalty.setOpenPenalty(8);
    penalty.setExtensionPenalty(1);

    ProteinSequence prot1 = new ProteinSequence(p1._2());
    ProteinSequence prot2 = new ProteinSequence(p2._2());

    try {
        PairwiseSequenceAligner<ProteinSequence, AminoAcidCompound> smithWaterman =
                Alignments.getPairwiseAligner(
                        prot1,
                        prot2,
                        Alignments.PairwiseSequenceAlignerType.LOCAL,
                        penalty,
                        matrix);

        SequencePair<ProteinSequence, AminoAcidCompound> alignment = smithWaterman.getPair();

        if ( debug )
         System.out.println(alignment.toString(60));



        int numIdenticals = alignment.getNumIdenticals();

        int aligLength = alignment.getLength();

        float percentIdenticals = (numIdenticals / (float) aligLength);


        // test overlaps

        int l1 = prot1.getLength();
        int l2 = prot2.getLength();

        int size = alignment.getLength();

        AlignedSequence alignedSequence1 = alignment.getAlignedSequence(1);
        AlignedSequence alignedSequence2 = alignment.getAlignedSequence(2);

        String alignedSeq1 = alignedSequence1.getSequenceAsString().replaceAll("-","");
        String alignedSeq2 = alignedSequence2.getSequenceAsString().replaceAll("-","");

        int size1 = alignedSeq1.length();
        int size2 = alignedSeq2.length();

        float overlap1 = size1 / (float) l1;
        float overlap2 = size2 / (float) l2;

        if ( debug )
            System.out.println(p1._1() + " " + p2._1() + " size:" + size + " l1: " + l1 + " l2: " + l2 + " overlap1 " + overlap1 + " overlap2 " + overlap2 + " %id: " + percentIdenticals);

        return new Tuple5<String, String, Float,Float,Float>(p1._1(),p2._1(),overlap1,overlap2,percentIdenticals);
    } catch (Exception e) {
        System.err.println("Could not align " + p1._1() + " vs." + p2._1());
    }


    return new  Tuple5<String, String, Float,Float,Float>(p1._1(),p2._1(),0f,0f,0f);
}
 

import org.biojava.nbio.alignment.SimpleGapPenalty; //导入依赖的package包/类
@Override
public Tuple5<String,String,Float,Float,Float> call(Tuple2<Tuple2<String,String>,Tuple2<String,String>> tuple) throws Exception {

	Tuple2<String,String> p1 = tuple._1();
	Tuple2<String,String> p2 = tuple._2();

	SubstitutionMatrix<AminoAcidCompound> matrix = SubstitutionMatrixHelper.getBlosum65();
	GapPenalty penalty = new SimpleGapPenalty();
	penalty.setOpenPenalty(8);
	penalty.setExtensionPenalty(1);

	ProteinSequence prot1 = new ProteinSequence(p1._2());
	ProteinSequence prot2 = new ProteinSequence(p2._2());

	try {
		PairwiseSequenceAligner<ProteinSequence, AminoAcidCompound> smithWaterman = Alignments.getPairwiseAligner(prot1,
				prot2,
				Alignments.PairwiseSequenceAlignerType.LOCAL, penalty, matrix);

		SequencePair<ProteinSequence, AminoAcidCompound> alignment = smithWaterman.getPair();

		if ( debug )
			System.out.println(alignment.toString(60));



		int numIdenticals = alignment.getNumIdenticals();

		int aligLength = alignment.getLength();

		float percentIdenticals = (numIdenticals / (float) aligLength);


		// test overlaps

		int l1 = prot1.getLength();
		int l2 = prot2.getLength();

		int size = alignment.getLength();

		float overlap1 = l1 / (float) size;
		float overlap2 = l2 / (float) size;

		if ( debug )
			System.out.println(p1._1() + " " + p2._1() + " size:" + size + " l1: " + l1 + " l2: " + l2 + " overlap1 " + overlap1 + " overlap2 " + overlap2 + " %id: " + percentIdenticals);


		return new Tuple5<String, String, Float,Float,Float>(p1._1(),p2._1(),overlap1,overlap2,percentIdenticals);
	} catch (Exception e) {
		e.printStackTrace();
	}


	return new  Tuple5<String, String, Float,Float,Float>(p1._1(),p2._1(),0f,0f,0f);
}