X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=forester%2Fjava%2Fsrc%2Forg%2Fforester%2Futil%2FForesterUtil.java;h=6c14975fcbb2c74839120dcc85c3898a35f0ee22;hb=0d0b9cde030d50b153eb6d1ff7ce13bc273edc17;hp=2cf0572986c50cd8bba7812ed24dd38b23b26251;hpb=2ce45e07bb8338407af90016e576244ce2103de9;p=jalview.git diff --git a/forester/java/src/org/forester/util/ForesterUtil.java b/forester/java/src/org/forester/util/ForesterUtil.java index 2cf0572..6c14975 100644 --- a/forester/java/src/org/forester/util/ForesterUtil.java +++ b/forester/java/src/org/forester/util/ForesterUtil.java @@ -34,6 +34,7 @@ import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.FileReader; import java.io.FileWriter; +import java.io.FilenameFilter; import java.io.IOException; import java.io.InputStream; import java.io.InputStreamReader; @@ -41,6 +42,9 @@ import java.io.StringReader; import java.io.Writer; import java.math.BigDecimal; import java.net.URL; +import java.net.URLConnection; +import java.security.KeyManagementException; +import java.security.NoSuchAlgorithmException; import java.text.DateFormat; import java.text.DecimalFormat; import java.text.DecimalFormatSymbols; @@ -50,7 +54,6 @@ import java.text.SimpleDateFormat; import java.util.ArrayList; import java.util.Collection; import java.util.Date; -import java.util.Iterator; import java.util.List; import java.util.Map; import java.util.Map.Entry; @@ -62,36 +65,42 @@ import java.util.TreeSet; import java.util.regex.Matcher; import java.util.regex.Pattern; -import org.forester.archaeopteryx.Constants; +import org.forester.archaeopteryx.AptxConstants; +import org.forester.io.parsers.PhylogenyParser; +import org.forester.phylogeny.Phylogeny; import org.forester.phylogeny.PhylogenyNode; import org.forester.phylogeny.data.Distribution; import org.forester.phylogeny.data.Sequence; import org.forester.phylogeny.data.Taxonomy; +import org.forester.phylogeny.factories.ParserBasedPhylogenyFactory; import org.forester.protein.BasicProtein; import org.forester.protein.Domain; import org.forester.protein.Protein; +import org.forester.sequence.MolecularSequence; +import org.forester.sequence.MolecularSequence.TYPE; import org.forester.surfacing.SurfacingUtil; public final class ForesterUtil { public final static String FILE_SEPARATOR = System.getProperty( "file.separator" ); - public final static String LINE_SEPARATOR = System.getProperty( "line.separator" ); + public static final NumberFormat FORMATTER_06; + public static final NumberFormat FORMATTER_3; + public static final NumberFormat FORMATTER_6; + public static final NumberFormat FORMATTER_9; public final static String JAVA_VENDOR = System.getProperty( "java.vendor" ); public final static String JAVA_VERSION = System.getProperty( "java.version" ); + public final static String LINE_SEPARATOR = System.getProperty( "line.separator" ); + public static final String NCBI_GI = "http://www.ncbi.nlm.nih.gov/protein/gi:"; + public static final String NCBI_NUCCORE = "http://www.ncbi.nlm.nih.gov/nuccore/"; + public static final String NCBI_PROTEIN = "http://www.ncbi.nlm.nih.gov/protein/"; + public static final BigDecimal NULL_BD = new BigDecimal( 0 ); public final static String OS_ARCH = System.getProperty( "os.arch" ); public final static String OS_NAME = System.getProperty( "os.name" ); public final static String OS_VERSION = System.getProperty( "os.version" ); - public final static Pattern PARANTHESESABLE_NH_CHARS_PATTERN = Pattern.compile( "[(),;\\s]" ); - public final static double ZERO_DIFF = 1.0E-9; - public static final BigDecimal NULL_BD = new BigDecimal( 0 ); - public static final NumberFormat FORMATTER_9; - public static final NumberFormat FORMATTER_6; - public static final NumberFormat FORMATTER_06; - public static final NumberFormat FORMATTER_3; - public static final String NCBI_PROTEIN = "http://www.ncbi.nlm.nih.gov/protein/"; - public static final String NCBI_NUCCORE = "http://www.ncbi.nlm.nih.gov/nuccore/"; + public static final String PDB = "http://www.pdb.org/pdb/explore/explore.do?pdbId="; public final static String UNIPROT_KB = "http://www.uniprot.org/uniprot/"; - public static final String NCBI_GI = "http://www.ncbi.nlm.nih.gov/protein/gi:"; + public final static double ZERO_DIFF = 1.0E-12; + private static final Pattern PARANTHESESABLE_NH_CHARS_PATTERN = Pattern.compile( "[(),;\\s:\\[\\]]" ); static { final DecimalFormatSymbols dfs = new DecimalFormatSymbols(); dfs.setDecimalSeparator( '.' ); @@ -102,102 +111,30 @@ public final class ForesterUtil { FORMATTER_3 = new DecimalFormat( "#.###", dfs ); } - private ForesterUtil() { - } - - public static int calculateOverlap( final Domain domain, final List covered_positions ) { - int overlap_count = 0; - for( int i = domain.getFrom(); i <= domain.getTo(); ++i ) { - if ( ( i < covered_positions.size() ) && ( covered_positions.get( i ) == true ) ) { - ++overlap_count; - } - } - return overlap_count; - } - final public static void appendSeparatorIfNotEmpty( final StringBuffer sb, final char separator ) { if ( sb.length() > 0 ) { sb.append( separator ); } } - /** - * - * Example regarding engulfment: ------------0.1 ----------0.2 --0.3 => - * domain with 0.3 is ignored - * - * -----------0.1 ----------0.2 --0.3 => domain with 0.3 is ignored - * - * - * ------------0.1 ----------0.3 --0.2 => domains with 0.3 and 0.2 are _not_ - * ignored - * - * @param max_allowed_overlap - * maximal allowed overlap (inclusive) to be still considered not - * overlapping (zero or negative value to allow any overlap) - * @param remove_engulfed_domains - * to remove domains which are completely engulfed by coverage of - * domains with better support - * @param protein - * @return - */ - public static Protein removeOverlappingDomains( final int max_allowed_overlap, - final boolean remove_engulfed_domains, - final Protein protein ) { - final Protein pruned_protein = new BasicProtein( protein.getProteinId().getId(), protein.getSpecies() - .getSpeciesId(), protein.getLength() ); - final List sorted = SurfacingUtil.sortDomainsWithAscendingConfidenceValues( protein ); - final List covered_positions = new ArrayList(); - for( final Domain domain : sorted ) { - if ( ( ( max_allowed_overlap < 0 ) || ( ForesterUtil.calculateOverlap( domain, covered_positions ) <= max_allowed_overlap ) ) - && ( !remove_engulfed_domains || !isEngulfed( domain, covered_positions ) ) ) { - final int covered_positions_size = covered_positions.size(); - for( int i = covered_positions_size; i < domain.getFrom(); ++i ) { - covered_positions.add( false ); - } - final int new_covered_positions_size = covered_positions.size(); - for( int i = domain.getFrom(); i <= domain.getTo(); ++i ) { - if ( i < new_covered_positions_size ) { - covered_positions.set( i, true ); - } - else { - covered_positions.add( true ); - } - } - pruned_protein.addProteinDomain( domain ); - } + final public static String removeFileExtension( final String file_name ) { + if ( file_name.indexOf( "." ) > 0 ) { + return file_name.substring( 0, file_name.lastIndexOf( "." ) ); } - return pruned_protein; - } - - /** - * Returns true is Domain domain falls in an uninterrupted stretch of - * covered positions. - * - * @param domain - * @param covered_positions - * @return - */ - public static boolean isEngulfed( final Domain domain, final List covered_positions ) { - for( int i = domain.getFrom(); i <= domain.getTo(); ++i ) { - if ( ( i >= covered_positions.size() ) || ( covered_positions.get( i ) != true ) ) { - return false; - } - } - return true; + return file_name; } /** * This calculates a color. If value is equal to min the returned color is * minColor, if value is equal to max the returned color is maxColor, * otherwise a color 'proportional' to value is returned. - * + * * @param value - * the value + * the value * @param min - * the smallest value + * the smallest value * @param max - * the largest value + * the largest value * @param minColor * the color for min * @param maxColor @@ -228,15 +165,15 @@ public final class ForesterUtil { * value is equal to mean the returned color is meanColor, otherwise a color * 'proportional' to value is returned -- either between min-mean or * mean-max - * + * * @param value * the value * @param min * the smallest value * @param max - * the largest value + * the largest value * @param mean - * the mean/median value + * the mean/median value * @param minColor * the color for min * @param maxColor @@ -277,6 +214,50 @@ public final class ForesterUtil { } } + /** + * Helper method for calcColor methods. + * + * @param smallercolor_component_x + * color component the smaller color + * @param largercolor_component_x + * color component the larger color + * @param x + * factor + * @return an int representing a color component + */ + final private static int calculateColorComponent( final double smallercolor_component_x, + final double largercolor_component_x, + final double x ) { + return ( int ) ( smallercolor_component_x + + ( ( x * ( largercolor_component_x - smallercolor_component_x ) ) / 255.0 ) ); + } + + /** + * Helper method for calcColor methods. + * + * + * @param value + * the value + * @param larger + * the largest value + * @param smaller + * the smallest value + * @return a normalized value between larger and smaller + */ + final private static double calculateColorFactor( final double value, final double larger, final double smaller ) { + return ( 255.0 * ( value - smaller ) ) / ( larger - smaller ); + } + + public static int calculateOverlap( final Domain domain, final List covered_positions ) { + int overlap_count = 0; + for( int i = domain.getFrom(); i <= domain.getTo(); ++i ) { + if ( ( i < covered_positions.size() ) && ( covered_positions.get( i ) == true ) ) { + ++overlap_count; + } + } + return overlap_count; + } + final public static String collapseWhiteSpace( final String s ) { return s.replaceAll( "[\\s]+", " " ); } @@ -425,18 +406,8 @@ public final class ForesterUtil { } } - public static String[] file2array( final File file ) throws IOException { - final List list = file2list( file ); - final String[] ary = new String[ list.size() ]; - int i = 0; - for( final String s : list ) { - ary[ i++ ] = s; - } - return ary; - } - public static String[][] file22dArray( final File file ) throws IOException { - final List list = new ArrayList(); + final List list = new ArrayList<>(); final BufferedReader in = new BufferedReader( new FileReader( file ) ); String str; while ( ( str = in.readLine() ) != null ) { @@ -463,8 +434,18 @@ public final class ForesterUtil { return ary; } + public static String[] file2array( final File file ) throws IOException { + final List list = file2list( file ); + final String[] ary = new String[ list.size() ]; + int i = 0; + for( final String s : list ) { + ary[ i++ ] = s; + } + return ary; + } + final public static List file2list( final File file ) throws IOException { - final List list = new ArrayList(); + final List list = new ArrayList<>(); final BufferedReader in = new BufferedReader( new FileReader( file ) ); String str; while ( ( str = in.readLine() ) != null ) { @@ -480,7 +461,7 @@ public final class ForesterUtil { } final public static SortedSet file2set( final File file ) throws IOException { - final SortedSet set = new TreeSet(); + final SortedSet set = new TreeSet<>(); final BufferedReader in = new BufferedReader( new FileReader( file ) ); String str; while ( ( str = in.readLine() ) != null ) { @@ -529,7 +510,9 @@ public final class ForesterUtil { reader = new BufferedReader( new StringReader( source.toString() ) ); } else if ( source instanceof URL ) { - reader = new BufferedReader( new InputStreamReader( ( ( URL ) source ).openStream() ) ); + final URLConnection url_connection = ( ( URL ) source ).openConnection(); + url_connection.setDefaultUseCaches( false ); + reader = new BufferedReader( new InputStreamReader( url_connection.getInputStream() ) ); } else { throw new IllegalArgumentException( "dont know how to read [" + source.getClass() + "]" ); @@ -558,6 +541,23 @@ public final class ForesterUtil { return ForesterUtil.LINE_SEPARATOR; } + final public static MolecularSequence.TYPE guessMolecularSequenceType( final String mol_seq ) { + final String s = mol_seq.toUpperCase(); + if ( s.contains( "L" ) || s.contains( "I" ) || s.contains( "E" ) || s.contains( "H" ) || s.contains( "D" ) + || s.contains( "Q" ) ) { + return TYPE.AA; + } + else { + if ( s.contains( "T" ) ) { + return TYPE.DNA; + } + else if ( s.contains( "U" ) ) { + return TYPE.RNA; + } + } + return null; + } + final public static void increaseCountingMap( final Map counting_map, final String item_name ) { if ( !counting_map.containsKey( item_name ) ) { counting_map.put( item_name, 1 ); @@ -567,10 +567,6 @@ public final class ForesterUtil { } } - final public static boolean isContainsParanthesesableNhCharacter( final String nh ) { - return PARANTHESESABLE_NH_CHARS_PATTERN.matcher( nh ).find(); - } - final public static boolean isEmpty( final List l ) { if ( ( l == null ) || l.isEmpty() ) { return true; @@ -599,10 +595,38 @@ public final class ForesterUtil { return ( ( s == null ) || ( s.length() < 1 ) ); } + final public static boolean isEmptyTrimmed( final String s ) { + if ( s == null ) { + return true; + } + return ( ( s.trim().length() < 1 ) ); + } + + /** + * Returns true is Domain domain falls in an uninterrupted stretch of + * covered positions. + * + * @param domain + * @param covered_positions + * @return + */ + public static boolean isEngulfed( final Domain domain, final List covered_positions ) { + for( int i = domain.getFrom(); i <= domain.getTo(); ++i ) { + if ( ( i >= covered_positions.size() ) || ( covered_positions.get( i ) != true ) ) { + return false; + } + } + return true; + } + final public static boolean isEqual( final double a, final double b ) { return ( ( Math.abs( a - b ) ) < ZERO_DIFF ); } + final public static boolean isEqual( final double a, final double b, final double tolerance ) { + return ( ( Math.abs( a - b ) ) < tolerance ); + } + final public static boolean isEven( final int n ) { return ( n % 2 ) == 0; } @@ -611,7 +635,7 @@ public final class ForesterUtil { * This determines whether String[] a and String[] b have at least one * String in common (intersect). Returns false if at least one String[] is * null or empty. - * + * * @param a * a String[] b a String[] * @return true if both a and b or not empty or null and contain at least @@ -643,6 +667,16 @@ public final class ForesterUtil { } } + public final static boolean isMac() { + try { + return OS_NAME.toLowerCase().startsWith( "mac" ); + } + catch ( final Exception e ) { + ForesterUtil.printWarningMessage( AptxConstants.PRG_NAME, "minor error: " + e ); + return false; + } + } + final public static boolean isNull( final BigDecimal s ) { return ( ( s == null ) || ( s.compareTo( NULL_BD ) == 0 ) ); } @@ -675,17 +709,7 @@ public final class ForesterUtil { return OS_NAME.toLowerCase().indexOf( "win" ) > -1; } catch ( final Exception e ) { - ForesterUtil.printWarningMessage( Constants.PRG_NAME, "minor error: " + e ); - return false; - } - } - - public final static boolean isMac() { - try { - return OS_NAME.toLowerCase().startsWith( "mac" ); - } - catch ( final Exception e ) { - ForesterUtil.printWarningMessage( Constants.PRG_NAME, "minor error: " + e ); + ForesterUtil.printWarningMessage( AptxConstants.PRG_NAME, "minor error: " + e ); return false; } } @@ -700,6 +724,10 @@ public final class ForesterUtil { return null; } + final public static String isWritableFile( final String s ) { + return isWritableFile( new File( s ) ); + } + /** * Helper for method "stringToColor". *

@@ -716,7 +744,7 @@ public final class ForesterUtil { } final public static SortedMap listToSortedCountsMap( final List list ) { - final SortedMap map = new TreeMap(); + final SortedMap map = new TreeMap<>(); for( final Object key : list ) { if ( !map.containsKey( key ) ) { map.put( key, 1 ); @@ -731,7 +759,8 @@ public final class ForesterUtil { final public static void map2file( final File file, final Map data, final String entry_separator, - final String data_separator ) throws IOException { + final String data_separator ) + throws IOException { final Writer writer = new BufferedWriter( new FileWriter( file ) ); map2writer( writer, data, entry_separator, data_separator ); writer.close(); @@ -740,7 +769,8 @@ public final class ForesterUtil { final public static void map2writer( final Writer writer, final Map data, final String entry_separator, - final String data_separator ) throws IOException { + final String data_separator ) + throws IOException { boolean first = true; for( final Entry entry : data.entrySet() ) { if ( !first ) { @@ -755,10 +785,10 @@ public final class ForesterUtil { } } - final public static StringBuffer mapToStringBuffer( final Map map, final String key_value_separator ) { + final public static StringBuffer mapToStringBuffer( final Map map, + final String key_value_separator ) { final StringBuffer sb = new StringBuffer(); - for( final Iterator iter = map.keySet().iterator(); iter.hasNext(); ) { - final Object key = iter.next(); + for( final Object key : map.keySet() ) { sb.append( key.toString() ); sb.append( key_value_separator ); sb.append( map.get( key ).toString() ); @@ -788,6 +818,194 @@ public final class ForesterUtil { } } + public final static Color obtainColorDependingOnTaxonomyGroup( final String tax_group ) { + if ( !ForesterUtil.isEmpty( tax_group ) ) { + if ( tax_group.equals( TaxonomyGroups.DEUTEROSTOMIA ) ) { + return TaxonomyColors.DEUTEROSTOMIA_COLOR; + } + else if ( tax_group.equals( TaxonomyGroups.PROTOSTOMIA ) ) { + return TaxonomyColors.PROTOSTOMIA_COLOR; + } + else if ( tax_group.equals( TaxonomyGroups.CNIDARIA ) ) { + return TaxonomyColors.CNIDARIA_COLOR; + } + else if ( tax_group.equals( TaxonomyGroups.PLACOZOA ) ) { + return TaxonomyColors.PLACOZOA_COLOR; + } + else if ( tax_group.equals( TaxonomyGroups.CTENOPHORA ) ) { + return TaxonomyColors.CTENOPHORA_COLOR; + } + else if ( tax_group.equals( TaxonomyGroups.PORIFERA ) ) { + return TaxonomyColors.PORIFERA_COLOR; + } + else if ( tax_group.equals( TaxonomyGroups.CHOANOFLAGELLIDA ) ) { + return TaxonomyColors.CHOANOFLAGELLIDA; + } + else if ( tax_group.equals( TaxonomyGroups.ICHTHYOPHONIDA_FILASTEREA ) ) { + return TaxonomyColors.ICHTHYOSPOREA_AND_FILASTEREA; + } + else if ( tax_group.equals( TaxonomyGroups.DIKARYA ) ) { + return TaxonomyColors.DIKARYA_COLOR; + } + else if ( tax_group.equalsIgnoreCase( TaxonomyGroups.FUNGI ) + || tax_group.equalsIgnoreCase( TaxonomyGroups.OTHER_FUNGI ) ) { + return TaxonomyColors.OTHER_FUNGI_COLOR; + } + else if ( tax_group.equals( TaxonomyGroups.NUCLEARIIDAE_AND_FONTICULA_GROUP ) ) { + return TaxonomyColors.NUCLEARIIDAE_AND_FONTICULA_GROUP_COLOR; + } + else if ( tax_group.equals( TaxonomyGroups.AMOEBOZOA ) ) { + return TaxonomyColors.AMOEBOZOA_COLOR; + } + else if ( tax_group.equals( TaxonomyGroups.EMBRYOPHYTA ) ) { + return TaxonomyColors.EMBRYOPHYTA_COLOR; + } + else if ( tax_group.equals( TaxonomyGroups.CHLOROPHYTA ) ) { + return TaxonomyColors.CHLOROPHYTA_COLOR; + } + else if ( tax_group.equals( TaxonomyGroups.RHODOPHYTA ) ) { + return TaxonomyColors.RHODOPHYTA_COLOR; + } + else if ( tax_group.equals( TaxonomyGroups.HACROBIA ) ) { + return TaxonomyColors.HACROBIA_COLOR; + } + else if ( tax_group.equals( TaxonomyGroups.GLAUCOCYSTOPHYCEAE ) ) { + return TaxonomyColors.GLAUCOPHYTA_COLOR; + } + else if ( tax_group.equals( TaxonomyGroups.STRAMENOPILES ) ) { + return TaxonomyColors.STRAMENOPILES_COLOR; + } + else if ( tax_group.equals( TaxonomyGroups.ALVEOLATA ) ) { + return TaxonomyColors.ALVEOLATA_COLOR; + } + else if ( tax_group.equals( TaxonomyGroups.RHIZARIA ) ) { + return TaxonomyColors.RHIZARIA_COLOR; + } + else if ( tax_group.equals( TaxonomyGroups.EXCAVATA ) ) { + return TaxonomyColors.EXCAVATA_COLOR; + } + else if ( tax_group.equals( TaxonomyGroups.APUSOZOA ) ) { + return TaxonomyColors.APUSOZOA_COLOR; + } + else if ( tax_group.equals( TaxonomyGroups.ARCHAEA ) ) { + return TaxonomyColors.ARCHAEA_COLOR; + } + else if ( tax_group.equals( TaxonomyGroups.BACTERIA ) ) { + return TaxonomyColors.BACTERIA_COLOR; + } + else if ( tax_group.equals( TaxonomyGroups.VIRUSES ) ) { + return TaxonomyColors.VIRUSES_COLOR; + } + else if ( tax_group.equals( TaxonomyGroups.ALPHAHERPESVIRINAE ) ) { + return TaxonomyColors.ALPHAHERPESVIRINAE_COLOR; + } + else if ( tax_group.equals( TaxonomyGroups.BETAHERPESVIRINAE ) ) { + return TaxonomyColors.BETAHERPESVIRINAE_COLOR; + } + else if ( tax_group.equals( TaxonomyGroups.GAMMAHERPESVIRINAE ) ) { + return TaxonomyColors.GAMMAHERPESVIRINAE_COLOR; + } + else if ( tax_group.equals( TaxonomyGroups.OTHER ) ) { + return TaxonomyColors.OTHER_COLOR; + } + } + return null; + } + + public final static String obtainNormalizedTaxonomyGroup( final String tax ) { + if ( tax.equalsIgnoreCase( TaxonomyGroups.DEUTEROSTOMIA ) ) { + return TaxonomyGroups.DEUTEROSTOMIA; + } + else if ( tax.equalsIgnoreCase( TaxonomyGroups.PROTOSTOMIA ) ) { + return TaxonomyGroups.PROTOSTOMIA; + } + else if ( tax.equalsIgnoreCase( TaxonomyGroups.CNIDARIA ) ) { + return TaxonomyGroups.CNIDARIA; + } + else if ( tax.toLowerCase().startsWith( "trichoplax" ) || tax.equalsIgnoreCase( TaxonomyGroups.PLACOZOA ) ) { + return TaxonomyGroups.PLACOZOA; + } + else if ( tax.toLowerCase().startsWith( "mnemiopsis" ) || tax.equalsIgnoreCase( TaxonomyGroups.CTENOPHORA ) ) { + return TaxonomyGroups.CTENOPHORA; + } + else if ( tax.toLowerCase().startsWith( "amphimedon" ) || tax.equalsIgnoreCase( TaxonomyGroups.PORIFERA ) ) { + return TaxonomyGroups.PORIFERA; + } + else if ( tax.equalsIgnoreCase( "codonosigidae" ) || tax.equalsIgnoreCase( TaxonomyGroups.CHOANOFLAGELLIDA ) ) { + return TaxonomyGroups.CHOANOFLAGELLIDA; + } + else if ( tax.toLowerCase().startsWith( TaxonomyGroups.ICHTHYOPHONIDA_FILASTEREA ) + || tax.toLowerCase().startsWith( "ichthyophonida and filasterea" ) + || tax.toLowerCase().startsWith( "ichthyosporea & filasterea" ) + || tax.toLowerCase().startsWith( "ichthyosporea and filasterea" ) ) { + return TaxonomyGroups.ICHTHYOPHONIDA_FILASTEREA; + } + else if ( tax.equalsIgnoreCase( TaxonomyGroups.DIKARYA ) ) { + return TaxonomyGroups.DIKARYA; + } + else if ( tax.equalsIgnoreCase( TaxonomyGroups.FUNGI ) || tax.equalsIgnoreCase( TaxonomyGroups.OTHER_FUNGI ) ) { + return TaxonomyGroups.OTHER_FUNGI; + } + else if ( tax.toLowerCase().startsWith( "nucleariidae and fonticula" ) ) { + return TaxonomyGroups.NUCLEARIIDAE_AND_FONTICULA_GROUP; + } + else if ( tax.equalsIgnoreCase( TaxonomyGroups.AMOEBOZOA ) ) { + return TaxonomyGroups.AMOEBOZOA; + } + else if ( tax.equalsIgnoreCase( TaxonomyGroups.EMBRYOPHYTA ) ) { + return TaxonomyGroups.EMBRYOPHYTA; + } + else if ( tax.equalsIgnoreCase( TaxonomyGroups.CHLOROPHYTA ) ) { + return TaxonomyGroups.CHLOROPHYTA; + } + else if ( tax.equalsIgnoreCase( TaxonomyGroups.RHODOPHYTA ) ) { + return TaxonomyGroups.RHODOPHYTA; + } + else if ( tax.toLowerCase().startsWith( TaxonomyGroups.HACROBIA ) ) { + return TaxonomyGroups.HACROBIA; + } + else if ( tax.equalsIgnoreCase( TaxonomyGroups.GLAUCOCYSTOPHYCEAE ) || tax.equalsIgnoreCase( "glaucophyta" ) ) { + return TaxonomyGroups.GLAUCOCYSTOPHYCEAE; + } + else if ( tax.equalsIgnoreCase( TaxonomyGroups.STRAMENOPILES ) ) { + return TaxonomyGroups.STRAMENOPILES; + } + else if ( tax.equalsIgnoreCase( TaxonomyGroups.ALVEOLATA ) ) { + return TaxonomyGroups.ALVEOLATA; + } + else if ( tax.equalsIgnoreCase( TaxonomyGroups.RHIZARIA ) ) { + return TaxonomyGroups.RHIZARIA; + } + else if ( tax.equalsIgnoreCase( TaxonomyGroups.EXCAVATA ) ) { + return TaxonomyGroups.EXCAVATA; + } + else if ( tax.equalsIgnoreCase( TaxonomyGroups.APUSOZOA ) ) { + return TaxonomyGroups.APUSOZOA; + } + else if ( tax.equalsIgnoreCase( TaxonomyGroups.ARCHAEA ) ) { + return TaxonomyGroups.ARCHAEA; + } + else if ( tax.equalsIgnoreCase( TaxonomyGroups.BACTERIA ) ) { + return TaxonomyGroups.BACTERIA; + } + else if ( tax.equalsIgnoreCase( TaxonomyGroups.BACTERIA ) ) { + return TaxonomyGroups.BACTERIA; + } + else if ( tax.equalsIgnoreCase( TaxonomyGroups.VIRUSES ) ) { + return TaxonomyGroups.VIRUSES; + } + else if ( tax.equalsIgnoreCase( TaxonomyGroups.ALPHAHERPESVIRINAE ) ) { + return TaxonomyGroups.ALPHAHERPESVIRINAE; + } + else if ( tax.equalsIgnoreCase( TaxonomyGroups.BETAHERPESVIRINAE ) ) { + return TaxonomyGroups.BETAHERPESVIRINAE; + } + else if ( tax.equalsIgnoreCase( TaxonomyGroups.GAMMAHERPESVIRINAE ) ) { + return TaxonomyGroups.GAMMAHERPESVIRINAE; + } + return null; + } + final public static BufferedReader obtainReader( final Object source ) throws IOException, FileNotFoundException { BufferedReader reader = null; if ( source instanceof File ) { @@ -819,11 +1037,26 @@ public final class ForesterUtil { return reader; } - final public static StringBuffer pad( final double number, final int size, final char pad, final boolean left_pad ) { + public final static void outOfMemoryError( final OutOfMemoryError e ) { + System.err.println(); + System.err.println( "Java memory allocation might be too small, try \"-Xmx2048m\" java command line option" ); + System.err.println(); + e.printStackTrace( System.err ); + System.err.println(); + System.exit( -1 ); + } + + final public static StringBuffer pad( final double number, + final int size, + final char pad, + final boolean left_pad ) { return pad( new StringBuffer( number + "" ), size, pad, left_pad ); } - final public static StringBuffer pad( final String string, final int size, final char pad, final boolean left_pad ) { + final public static StringBuffer pad( final String string, + final int size, + final char pad, + final boolean left_pad ) { return pad( new StringBuffer( string ), size, pad, left_pad ); } @@ -877,7 +1110,9 @@ public final class ForesterUtil { System.err.println( "[" + prg_name + "] > error: " + message ); } - final public static void printProgramInformation( final String prg_name, final String prg_version, final String date ) { + final public static void printProgramInformation( final String prg_name, + final String prg_version, + final String date ) { final int l = prg_name.length() + prg_version.length() + date.length() + 4; System.out.println(); System.out.println( prg_name + " " + prg_version + " (" + date + ")" ); @@ -921,7 +1156,8 @@ public final class ForesterUtil { } if ( !ForesterUtil.isEmpty( ForesterUtil.JAVA_VERSION ) && !ForesterUtil.isEmpty( ForesterUtil.JAVA_VENDOR ) ) { System.out.println(); - System.out.println( "[running on Java " + ForesterUtil.JAVA_VERSION + " " + ForesterUtil.JAVA_VENDOR + "]" ); + System.out + .println( "[running on Java " + ForesterUtil.JAVA_VERSION + " " + ForesterUtil.JAVA_VENDOR + "]" ); } System.out.println(); } @@ -934,6 +1170,71 @@ public final class ForesterUtil { System.out.println( "[" + prg_name + "] > " + message ); } + public static List readUrl( final String url_str ) throws IOException { + final URL url = new URL( url_str ); + final URLConnection urlc = url.openConnection(); + //urlc.setRequestProperty( "User-Agent", "" ); + final BufferedReader in = new BufferedReader( new InputStreamReader( urlc.getInputStream() ) ); + String line; + final List result = new ArrayList<>(); + while ( ( line = in.readLine() ) != null ) { + result.add( line ); + } + in.close(); + return result; + } + + /** + * + * Example regarding engulfment: ------------0.1 ----------0.2 --0.3 => + * domain with 0.3 is ignored + * + * -----------0.1 ----------0.2 --0.3 => domain with 0.3 is ignored + * + * + * ------------0.1 ----------0.3 --0.2 => domains with 0.3 and 0.2 are _not_ + * ignored + * + * @param max_allowed_overlap + * maximal allowed overlap (inclusive) to be still considered not + * overlapping (zero or negative value to allow any overlap) + * @param remove_engulfed_domains + * to remove domains which are completely engulfed by coverage of + * domains with better support + * @param protein + * @return + */ + public static Protein removeOverlappingDomains( final int max_allowed_overlap, + final boolean remove_engulfed_domains, + final Protein protein ) { + final Protein pruned_protein = new BasicProtein( protein.getProteinId().getId(), + protein.getSpecies().getSpeciesId(), + protein.getLength() ); + final List sorted = SurfacingUtil.sortDomainsWithAscendingConfidenceValues( protein ); + final List covered_positions = new ArrayList<>(); + for( final Domain domain : sorted ) { + if ( ( ( max_allowed_overlap < 0 ) + || ( ForesterUtil.calculateOverlap( domain, covered_positions ) <= max_allowed_overlap ) ) + && ( !remove_engulfed_domains || !isEngulfed( domain, covered_positions ) ) ) { + final int covered_positions_size = covered_positions.size(); + for( int i = covered_positions_size; i < domain.getFrom(); ++i ) { + covered_positions.add( false ); + } + final int new_covered_positions_size = covered_positions.size(); + for( int i = domain.getFrom(); i <= domain.getTo(); ++i ) { + if ( i < new_covered_positions_size ) { + covered_positions.set( i, true ); + } + else { + covered_positions.add( true ); + } + } + pruned_protein.addProteinDomain( domain ); + } + } + return pruned_protein; + } + final public static String removeSuffix( final String file_name ) { final int i = file_name.lastIndexOf( '.' ); if ( i > 1 ) { @@ -944,7 +1245,7 @@ public final class ForesterUtil { /** * Removes all white space from String s. - * + * * @return String s with white space removed */ final public static String removeWhiteSpace( String s ) { @@ -959,18 +1260,11 @@ public final class ForesterUtil { return s; } - final public static String replaceIllegalNhCharacters( final String nh ) { - if ( nh == null ) { - return ""; - } - return nh.trim().replaceAll( "[\\[\\]:]+", "_" ); - } - final public static String replaceIllegalNhxCharacters( final String nhx ) { if ( nhx == null ) { return ""; } - return nhx.trim().replaceAll( "[\\[\\](),:;\\s]+", "_" ); + return nhx.trim().replaceAll( "[\\[\\]']+", "_" ); } final public static double round( final double value, final int decimal_place ) { @@ -1003,6 +1297,35 @@ public final class ForesterUtil { } } + public final static StringBuilder santitizeStringForNH( String data ) { + data = data.replaceAll( "\\s+", " " ).trim(); + final StringBuilder sb = new StringBuilder(); + if ( data.length() > 0 ) { + final boolean single_pars = data.indexOf( '\'' ) > -1; + final boolean double_pars = data.indexOf( '"' ) > -1; + if ( single_pars && double_pars ) { + data = data.replace( '\'', '`' ); + sb.append( '\'' ); + sb.append( data ); + sb.append( '\'' ); + } + else if ( single_pars ) { + sb.append( '"' ); + sb.append( data ); + sb.append( '"' ); + } + else if ( PARANTHESESABLE_NH_CHARS_PATTERN.matcher( data ).find() ) { + sb.append( '\'' ); + sb.append( data ); + sb.append( '\'' ); + } + else { + sb.append( data ); + } + } + return sb; + } + public static boolean seqIsLikelyToBeAa( final String s ) { final String seq = s.toLowerCase(); if ( ( seq.indexOf( 'r' ) > -1 ) || ( seq.indexOf( 'd' ) > -1 ) || ( seq.indexOf( 'e' ) > -1 ) @@ -1014,6 +1337,11 @@ public final class ForesterUtil { return false; } + final private static String[] splitString( final String str ) { + final String regex = "[\\s;,]+"; + return str.split( regex ); + } + final public static String stringArrayToString( final String[] a ) { return stringArrayToString( a, ", " ); } @@ -1061,17 +1389,17 @@ public final class ForesterUtil { return str_array; } - final public static void unexpectedFatalError( final Exception e ) { + final public static void unexpectedFatalError( final Error e ) { System.err.println(); - System.err.println( "unexpected exception: should not have occured! Please contact program author(s)." ); + System.err.println( "unexpected error: should not have occured! Please contact program author(s)." ); e.printStackTrace( System.err ); System.err.println(); System.exit( -1 ); } - final public static void unexpectedFatalError( final Error e ) { + final public static void unexpectedFatalError( final Exception e ) { System.err.println(); - System.err.println( "unexpected error: should not have occured! Please contact program author(s)." ); + System.err.println( "unexpected exception: should not have occured! Please contact program author(s)." ); e.printStackTrace( System.err ); System.err.println(); System.exit( -1 ); @@ -1159,154 +1487,224 @@ public final class ForesterUtil { return sb.toString(); } - /** - * Helper method for calcColor methods. - * - * @param smallercolor_component_x - * color component the smaller color - * @param largercolor_component_x - * color component the larger color - * @param x - * factor - * @return an int representing a color component - */ - final private static int calculateColorComponent( final double smallercolor_component_x, - final double largercolor_component_x, - final double x ) { - return ( int ) ( smallercolor_component_x + ( ( x * ( largercolor_component_x - smallercolor_component_x ) ) / 255.0 ) ); - } - - /** - * Helper method for calcColor methods. - * - * - * @param value - * the value - * @param larger - * the largest value - * @param smaller - * the smallest value - * @return a normalized value between larger and smaller - */ - final private static double calculateColorFactor( final double value, final double larger, final double smaller ) { - return ( 255.0 * ( value - smaller ) ) / ( larger - smaller ); - } - - final private static String[] splitString( final String str ) { - final String regex = "[\\s;,]+"; - return str.split( regex ); - } - - public final static void outOfMemoryError( final OutOfMemoryError e ) { - System.err.println(); - System.err.println( "Java memory allocation might be too small, try \"-Xmx2048m\" java command line option" ); - System.err.println(); - e.printStackTrace( System.err ); - System.err.println(); - System.exit( -1 ); - } - - public final static Color obtainColorDependingOnTaxonomyGroup( final String tax, final String tax_code ) { - if ( tax.equalsIgnoreCase( "deuterostomia" ) ) { - printRel( tax_code, "deuterostomia" ); - return TaxonomyColors.DEUTEROSTOMIA_COLOR; + public final static Phylogeny[] readPhylogeniesFromUrl( final URL url, final PhylogenyParser parser ) + throws NoSuchAlgorithmException, IOException, KeyManagementException { + if ( url == null ) { + throw new IllegalArgumentException( "URL to read from must not be null" ); } - else if ( tax.equalsIgnoreCase( "protostomia" ) ) { - printRel( tax_code, "protostomia" ); - return TaxonomyColors.PROTOSTOMIA_COLOR; + else if ( parser == null ) { + throw new IllegalArgumentException( "parser to use to read from URL must not be null" ); } - else if ( tax.equalsIgnoreCase( "cnidaria" ) ) { - printRel( tax_code, "cnidaria" ); - return TaxonomyColors.CNIDARIA_COLOR; + final URLConnection con; + if ( url.toString().startsWith( "https:" ) ) { + con = TrustManager.makeHttpsURLConnection( url ); } - else if ( tax.toLowerCase().startsWith( "trichoplax" ) || tax.equalsIgnoreCase( "placozoa" ) ) { - printRel( tax_code, "placozoa" ); - return TaxonomyColors.PLACOZOA_COLOR; + else if ( url.toString().startsWith( "http:" ) ) { + con = url.openConnection(); } - else if ( tax.toLowerCase().startsWith( "mnemiopsis" ) || tax.equalsIgnoreCase( "ctenophora" ) ) { - printRel( tax_code, "ctenophora" ); - return TaxonomyColors.CTENOPHORA_COLOR; + else { + throw new IllegalArgumentException( "Cannot deal with URL: " + url ); } - else if ( tax.toLowerCase().startsWith( "amphimedon" ) || tax.equalsIgnoreCase( "porifera" ) ) { - printRel( tax_code, "porifera" ); - return TaxonomyColors.PORIFERA_COLOR; + if ( con == null ) { + throw new IOException( "could not create connection from " + url ); } - else if ( tax.equalsIgnoreCase( "codonosigidae" ) || tax.equalsIgnoreCase( "choanoflagellida" ) ) { - printRel( tax_code, "choanoflagellida" ); - return TaxonomyColors.CHOANOFLAGELLIDA; + con.setDefaultUseCaches( false ); + final InputStream is = con.getInputStream(); + if ( is == null ) { + throw new IOException( "could not create input stream from " + url ); } - else if ( tax.toLowerCase().startsWith( "ichthyophonida & filasterea" ) - || tax.toLowerCase().startsWith( "ichthyophonida and filasterea" ) - || tax.toLowerCase().startsWith( "ichthyosporea & filasterea" ) - || tax.toLowerCase().startsWith( "ichthyosporea and filasterea" ) ) { - printRel( tax_code, "ichthyophonida & filasterea" ); - return TaxonomyColors.ICHTHYOSPOREA_AND_FILASTEREA; + final Phylogeny[] trees = ParserBasedPhylogenyFactory.getInstance().create( is, parser ); + try { + is.close(); } - else if ( tax.equalsIgnoreCase( "fungi" ) ) { - printRel( tax_code, "fungi" ); - return TaxonomyColors.FUNGI_COLOR; + catch ( final Exception e ) { + // ignore } - else if ( tax.toLowerCase().startsWith( "nucleariidae and fonticula" ) ) { - printRel( tax_code, "nucleariidae and fonticula group" ); - return TaxonomyColors.NUCLEARIIDAE_AND_FONTICULA_GROUP_COLOR; + return trees; + } + + public final static File getMatchingFile( final File dir, final String prefix, final String suffix ) + throws IOException { + if ( !dir.exists() ) { + throw new IOException( "[" + dir + "] does not exist" ); } - else if ( tax.equalsIgnoreCase( "amoebozoa" ) ) { - printRel( tax_code, "amoebozoa" ); - return TaxonomyColors.AMOEBOZOA_COLOR; + if ( !dir.isDirectory() ) { + throw new IOException( "[" + dir + "] is not a directory" ); } - else if ( tax.equalsIgnoreCase( "embryophyta" ) ) { - printRel( tax_code, "embryophyta" ); - return TaxonomyColors.EMBRYOPHYTA_COLOR; + if ( dir.listFiles().length == 0 ) { + throw new IOException( "[" + dir + "] is empty" ); } - else if ( tax.equalsIgnoreCase( "chlorophyta" ) ) { - printRel( tax_code, "chlorophyta" ); - return TaxonomyColors.CHLOROPHYTA_COLOR; + final File files[] = dir.listFiles( new FilenameFilter() { + + @Override + public boolean accept( final File dir, final String name ) { + return ( name.endsWith( suffix ) ); + } + } ); + if ( files.length == 0 ) { + throw new IOException( "no files ending with \"" + suffix + "\" found in [" + dir + "]" ); + } + String my_prefix = prefix; + boolean done = false; + boolean more_than_one = false; + File the_one = null; + do { + int matches = 0; + for( final File file : files ) { + if ( file.getName().startsWith( my_prefix ) ) { + matches++; + if ( matches > 1 ) { + the_one = null; + break; + } + the_one = file; + } + } + if ( matches > 1 ) { + more_than_one = true; + done = true; + } + if ( matches == 1 ) { + done = true; + } + else { + if ( my_prefix.length() <= 1 ) { + throw new IOException( "no file matching \"" + removeFileExtension( prefix ) + + "\" and ending with \"" + suffix + "\" found in [" + dir + "]" ); + } + my_prefix = my_prefix.substring( 0, my_prefix.length() - 1 ); + } + } while ( !done ); + if ( more_than_one ) { + throw new IOException( "multiple files matching \"" + removeFileExtension( prefix ) + + "\" and ending with \"" + suffix + "\" found in [" + dir + "]" ); + } + else if ( the_one != null ) { + } + else { + throw new IOException( "no file matching \"" + removeFileExtension( prefix ) + "\" and ending with \"" + + suffix + "\" found in [" + dir + "]" ); + } + return the_one; + } + + public final static String greatestCommonPrefix( final String a, final String b ) { + final int min_length = Math.min( a.length(), b.length() ); + for( int i = 0; i < min_length; ++i ) { + if ( a.charAt( i ) != b.charAt( i ) ) { + return a.substring( 0, i ); + } + } + return a.substring( 0, min_length ); + } + + public final static boolean isContainsPrefix( final String word, final String prefix, final String separator ) { + if ( ForesterUtil.isEmpty( separator ) ) { + throw new IllegalArgumentException( "separator must not be null or empty" ); + } + final String[] word_ary = word.split( Pattern.quote( separator ) ); + final String[] prefix_ary = prefix.split( Pattern.quote( separator ) ); + if ( word_ary.length < prefix_ary.length ) { + return false; + } + final int prefix_ary_length = prefix_ary.length; + for( int i = 0; i < prefix_ary_length; ++i ) { + if ( !( word_ary[ i ].equals( prefix_ary[ i ] ) ) ) { + return false; + } } - else if ( tax.equalsIgnoreCase( "rhodophyta" ) ) { - printRel( tax_code, "rhodophyta" ); - return TaxonomyColors.RHODOPHYTA_COLOR; + return true; + } + + public final static String greatestCommonPrefix( final String a, final String b, final String separator ) { + if ( ForesterUtil.isEmpty( separator ) ) { + throw new IllegalArgumentException( "separator must not be null or empty" ); + } + final String[] as = a.split( Pattern.quote( separator ) ); + final String[] bs = b.split( Pattern.quote( separator ) ); + final int min_length = Math.min( as.length, bs.length ); + for( int i = 0; i < min_length; ++i ) { + if ( !( as[ i ].equals( bs[ i ] ) ) ) { + final StringBuilder sb = new StringBuilder(); + boolean first = true; + for( int j = 0; j < i; ++j ) { + if ( first ) { + first = false; + } + else { + sb.append( separator ); + } + sb.append( as[ j ] ); + } + return sb.toString(); + } } - else if ( tax.toLowerCase().startsWith( "hacrobia" ) ) { - printRel( tax_code, "hacrobia" ); - return TaxonomyColors.HACROBIA_COLOR; + final StringBuilder sb = new StringBuilder(); + boolean first = true; + for( int j = 0; j < min_length; ++j ) { + if ( first ) { + first = false; + } + else { + sb.append( separator ); + } + sb.append( as[ j ] ); } - else if ( tax.equalsIgnoreCase( "glaucocystophyceae" ) || tax.equalsIgnoreCase( "glaucophyta" ) ) { - printRel( tax_code, "glaucocystophyceae" ); - return TaxonomyColors.GLAUCOPHYTA_COLOR; + return sb.toString(); + } + + public final static String greatestCommonPrefix( final List strings ) { + if ( strings == null ) { + throw new IllegalArgumentException( "list of strings is null" ); } - else if ( tax.equalsIgnoreCase( "stramenopiles" ) ) { - printRel( tax_code, "stramenopiles" ); - return TaxonomyColors.STRAMENOPILES_COLOR; + if ( strings.isEmpty() ) { + throw new IllegalArgumentException( "list of strings is empty" ); } - else if ( tax.equalsIgnoreCase( "alveolata" ) ) { - printRel( tax_code, "alveolata" ); - return TaxonomyColors.ALVEOLATA_COLOR; + String common = strings.get( 0 ); + for( int i = 1; i < strings.size(); ++i ) { + common = greatestCommonPrefix( common, strings.get( i ) ); } - else if ( tax.equalsIgnoreCase( "rhizaria" ) ) { - printRel( tax_code, "rhizaria" ); - return TaxonomyColors.RHIZARIA_COLOR; + return common; + } + + public final static String greatestCommonPrefix( final List strings, final String separator ) { + if ( ForesterUtil.isEmpty( separator ) ) { + return greatestCommonPrefix( strings ); } - else if ( tax.equalsIgnoreCase( "excavata" ) ) { - printRel( tax_code, "excavata" ); - return TaxonomyColors.EXCAVATA_COLOR; + if ( strings == null ) { + throw new IllegalArgumentException( "list of strings is null" ); } - else if ( tax.equalsIgnoreCase( "apusozoa" ) ) { - printRel( tax_code, "apusozoa" ); - return TaxonomyColors.APUSOZOA_COLOR; + if ( strings.isEmpty() ) { + throw new IllegalArgumentException( "list of strings is empty" ); } - else if ( tax.equalsIgnoreCase( "archaea" ) ) { - printRel( tax_code, "archaea" ); - return TaxonomyColors.ARCHAEA_COLOR; + String common = strings.get( 0 ); + for( int i = 1; i < strings.size(); ++i ) { + common = greatestCommonPrefix( common, strings.get( i ), separator ); } - else if ( tax.equalsIgnoreCase( "bacteria" ) ) { - printRel( tax_code, "bacteria" ); - return TaxonomyColors.BACTERIA_COLOR; + return common; + } + + public static List spliIntoPrefixes( final String prefix, final String separator ) { + final String[] a = prefix.split( Pattern.quote( separator ) ); + final List l = new ArrayList<>(); + for( int i = 0; i < a.length; ++i ) { + final StringBuilder sb = new StringBuilder(); + for( int j = 0; j <= i; ++j ) { + sb.append( a[ j ] ); + if ( j < i ) { + sb.append( separator ); + } + } + l.add( sb.toString() ); } - return null; + return l; } - private final static void printRel( String tax_code, String group ) { - //System.out.println( tax_code + "->" + group ); - System.out.println( "_default_taxcode_taxgroup_map.put( \"" + tax_code + "\", \"" + group + "\" );" ); + public static boolean isLooksLikeFasta( final File file ) throws IOException { + final String first_line = ForesterUtil.getFirstLine( file ).trim().toLowerCase(); + return ( ( !isEmptyTrimmed( first_line ) && first_line.trim().startsWith( ">" ) ) ); + } + + private ForesterUtil() { } }