From: Diane Trout Date: Sat, 4 Feb 2006 00:38:24 +0000 (+0000) Subject: massive code move X-Git-Url: http://woldlab.caltech.edu/gitweb/?p=mussa.git;a=commitdiff_plain;h=5adb8d9425a4662e790664faa82dce851efc577d massive code move mussa_gui_ was redundant so i moved all of those modules into gui/ Also I used the non-recursive gnu make style build system. And lastly there are some Doxygen compatible bits of doucmentation thrown in here. --- diff --git a/Doxyfile b/Doxyfile new file mode 100644 index 0000000..1022908 --- /dev/null +++ b/Doxyfile @@ -0,0 +1,1228 @@ +# Doxyfile 1.4.4 + +# This file describes the settings to be used by the documentation system +# doxygen (www.doxygen.org) for a project +# +# All text after a hash (#) is considered a comment and will be ignored +# The format is: +# TAG = value [value, ...] +# For lists items can also be appended using: +# TAG += value [value, ...] +# Values that contain spaces should be placed between quotes (" ") + +#--------------------------------------------------------------------------- +# Project related configuration options +#--------------------------------------------------------------------------- + +# The PROJECT_NAME tag is a single word (or a sequence of words surrounded +# by quotes) that should identify the project. + +PROJECT_NAME = mussa + +# The PROJECT_NUMBER tag can be used to enter a project or revision number. +# This could be handy for archiving the generated documentation or +# if some version control system is used. + +PROJECT_NUMBER = $Revision$ + +# The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute) +# base path where the generated documentation will be put. +# If a relative path is entered, it will be relative to the location +# where doxygen was started. If left blank the current directory will be used. + +OUTPUT_DIRECTORY = doc + +# If the CREATE_SUBDIRS tag is set to YES, then doxygen will create +# 4096 sub-directories (in 2 levels) under the output directory of each output +# format and will distribute the generated files over these directories. +# Enabling this option can be useful when feeding doxygen a huge amount of +# source files, where putting all generated files in the same directory would +# otherwise cause performance problems for the file system. + +CREATE_SUBDIRS = NO + +# The OUTPUT_LANGUAGE tag is used to specify the language in which all +# documentation generated by doxygen is written. Doxygen will use this +# information to generate all constant output in the proper language. +# The default language is English, other supported languages are: +# Brazilian, Catalan, Chinese, Chinese-Traditional, Croatian, Czech, Danish, +# Dutch, Finnish, French, German, Greek, Hungarian, Italian, Japanese, +# Japanese-en (Japanese with English messages), Korean, Korean-en, Norwegian, +# Polish, Portuguese, Romanian, Russian, Serbian, Slovak, Slovene, Spanish, +# Swedish, and Ukrainian. + +OUTPUT_LANGUAGE = English + +# This tag can be used to specify the encoding used in the generated output. +# The encoding is not always determined by the language that is chosen, +# but also whether or not the output is meant for Windows or non-Windows users. +# In case there is a difference, setting the USE_WINDOWS_ENCODING tag to YES +# forces the Windows encoding (this is the default for the Windows binary), +# whereas setting the tag to NO uses a Unix-style encoding (the default for +# all platforms other than Windows). + +USE_WINDOWS_ENCODING = NO + +# If the BRIEF_MEMBER_DESC tag is set to YES (the default) Doxygen will +# include brief member descriptions after the members that are listed in +# the file and class documentation (similar to JavaDoc). +# Set to NO to disable this. + +BRIEF_MEMBER_DESC = YES + +# If the REPEAT_BRIEF tag is set to YES (the default) Doxygen will prepend +# the brief description of a member or function before the detailed description. +# Note: if both HIDE_UNDOC_MEMBERS and BRIEF_MEMBER_DESC are set to NO, the +# brief descriptions will be completely suppressed. + +REPEAT_BRIEF = YES + +# This tag implements a quasi-intelligent brief description abbreviator +# that is used to form the text in various listings. Each string +# in this list, if found as the leading text of the brief description, will be +# stripped from the text and the result after processing the whole list, is +# used as the annotated text. Otherwise, the brief description is used as-is. +# If left blank, the following values are used ("$name" is automatically +# replaced with the name of the entity): "The $name class" "The $name widget" +# "The $name file" "is" "provides" "specifies" "contains" +# "represents" "a" "an" "the" + +ABBREVIATE_BRIEF = + +# If the ALWAYS_DETAILED_SEC and REPEAT_BRIEF tags are both set to YES then +# Doxygen will generate a detailed section even if there is only a brief +# description. + +ALWAYS_DETAILED_SEC = NO + +# If the INLINE_INHERITED_MEMB tag is set to YES, doxygen will show all +# inherited members of a class in the documentation of that class as if those +# members were ordinary class members. Constructors, destructors and assignment +# operators of the base classes will not be shown. + +INLINE_INHERITED_MEMB = NO + +# If the FULL_PATH_NAMES tag is set to YES then Doxygen will prepend the full +# path before files name in the file list and in the header files. If set +# to NO the shortest path that makes the file name unique will be used. + +FULL_PATH_NAMES = YES + +# If the FULL_PATH_NAMES tag is set to YES then the STRIP_FROM_PATH tag +# can be used to strip a user-defined part of the path. Stripping is +# only done if one of the specified strings matches the left-hand part of +# the path. The tag can be used to show relative paths in the file list. +# If left blank the directory from which doxygen is run is used as the +# path to strip. + +STRIP_FROM_PATH = + +# The STRIP_FROM_INC_PATH tag can be used to strip a user-defined part of +# the path mentioned in the documentation of a class, which tells +# the reader which header file to include in order to use a class. +# If left blank only the name of the header file containing the class +# definition is used. Otherwise one should specify the include paths that +# are normally passed to the compiler using the -I flag. + +STRIP_FROM_INC_PATH = + +# If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter +# (but less readable) file names. This can be useful is your file systems +# doesn't support long names like on DOS, Mac, or CD-ROM. + +SHORT_NAMES = NO + +# If the JAVADOC_AUTOBRIEF tag is set to YES then Doxygen +# will interpret the first line (until the first dot) of a JavaDoc-style +# comment as the brief description. If set to NO, the JavaDoc +# comments will behave just like the Qt-style comments (thus requiring an +# explicit @brief command for a brief description. + +JAVADOC_AUTOBRIEF = NO + +# The MULTILINE_CPP_IS_BRIEF tag can be set to YES to make Doxygen +# treat a multi-line C++ special comment block (i.e. a block of //! or /// +# comments) as a brief description. This used to be the default behaviour. +# The new default is to treat a multi-line C++ comment block as a detailed +# description. Set this tag to YES if you prefer the old behaviour instead. + +MULTILINE_CPP_IS_BRIEF = NO + +# If the DETAILS_AT_TOP tag is set to YES then Doxygen +# will output the detailed description near the top, like JavaDoc. +# If set to NO, the detailed description appears after the member +# documentation. + +DETAILS_AT_TOP = NO + +# If the INHERIT_DOCS tag is set to YES (the default) then an undocumented +# member inherits the documentation from any documented member that it +# re-implements. + +INHERIT_DOCS = YES + +# If member grouping is used in the documentation and the DISTRIBUTE_GROUP_DOC +# tag is set to YES, then doxygen will reuse the documentation of the first +# member in the group (if any) for the other members of the group. By default +# all members of a group must be documented explicitly. + +DISTRIBUTE_GROUP_DOC = NO + +# If the SEPARATE_MEMBER_PAGES tag is set to YES, then doxygen will produce +# a new page for each member. If set to NO, the documentation of a member will +# be part of the file/class/namespace that contains it. + +SEPARATE_MEMBER_PAGES = NO + +# The TAB_SIZE tag can be used to set the number of spaces in a tab. +# Doxygen uses this value to replace tabs by spaces in code fragments. + +TAB_SIZE = 8 + +# This tag can be used to specify a number of aliases that acts +# as commands in the documentation. An alias has the form "name=value". +# For example adding "sideeffect=\par Side Effects:\n" will allow you to +# put the command \sideeffect (or @sideeffect) in the documentation, which +# will result in a user-defined paragraph with heading "Side Effects:". +# You can put \n's in the value part of an alias to insert newlines. + +ALIASES = + +# Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C +# sources only. Doxygen will then generate output that is more tailored for C. +# For instance, some of the names that are used will be different. The list +# of all members will be omitted, etc. + +OPTIMIZE_OUTPUT_FOR_C = NO + +# Set the OPTIMIZE_OUTPUT_JAVA tag to YES if your project consists of Java sources +# only. Doxygen will then generate output that is more tailored for Java. +# For instance, namespaces will be presented as packages, qualified scopes +# will look different, etc. + +OPTIMIZE_OUTPUT_JAVA = NO + +# Set the SUBGROUPING tag to YES (the default) to allow class member groups of +# the same type (for instance a group of public functions) to be put as a +# subgroup of that type (e.g. under the Public Functions section). Set it to +# NO to prevent subgrouping. Alternatively, this can be done per class using +# the \nosubgrouping command. + +SUBGROUPING = YES + +#--------------------------------------------------------------------------- +# Build related configuration options +#--------------------------------------------------------------------------- + +# If the EXTRACT_ALL tag is set to YES doxygen will assume all entities in +# documentation are documented, even if no documentation was available. +# Private class members and static file members will be hidden unless +# the EXTRACT_PRIVATE and EXTRACT_STATIC tags are set to YES + +EXTRACT_ALL = YES + +# If the EXTRACT_PRIVATE tag is set to YES all private members of a class +# will be included in the documentation. + +EXTRACT_PRIVATE = YES + +# If the EXTRACT_STATIC tag is set to YES all static members of a file +# will be included in the documentation. + +EXTRACT_STATIC = YES + +# If the EXTRACT_LOCAL_CLASSES tag is set to YES classes (and structs) +# defined locally in source files will be included in the documentation. +# If set to NO only classes defined in header files are included. + +EXTRACT_LOCAL_CLASSES = YES + +# This flag is only useful for Objective-C code. When set to YES local +# methods, which are defined in the implementation section but not in +# the interface are included in the documentation. +# If set to NO (the default) only methods in the interface are included. + +EXTRACT_LOCAL_METHODS = NO + +# If the HIDE_UNDOC_MEMBERS tag is set to YES, Doxygen will hide all +# undocumented members of documented classes, files or namespaces. +# If set to NO (the default) these members will be included in the +# various overviews, but no documentation section is generated. +# This option has no effect if EXTRACT_ALL is enabled. + +HIDE_UNDOC_MEMBERS = NO + +# If the HIDE_UNDOC_CLASSES tag is set to YES, Doxygen will hide all +# undocumented classes that are normally visible in the class hierarchy. +# If set to NO (the default) these classes will be included in the various +# overviews. This option has no effect if EXTRACT_ALL is enabled. + +HIDE_UNDOC_CLASSES = NO + +# If the HIDE_FRIEND_COMPOUNDS tag is set to YES, Doxygen will hide all +# friend (class|struct|union) declarations. +# If set to NO (the default) these declarations will be included in the +# documentation. + +HIDE_FRIEND_COMPOUNDS = NO + +# If the HIDE_IN_BODY_DOCS tag is set to YES, Doxygen will hide any +# documentation blocks found inside the body of a function. +# If set to NO (the default) these blocks will be appended to the +# function's detailed documentation block. + +HIDE_IN_BODY_DOCS = NO + +# The INTERNAL_DOCS tag determines if documentation +# that is typed after a \internal command is included. If the tag is set +# to NO (the default) then the documentation will be excluded. +# Set it to YES to include the internal documentation. + +INTERNAL_DOCS = NO + +# If the CASE_SENSE_NAMES tag is set to NO then Doxygen will only generate +# file names in lower-case letters. If set to YES upper-case letters are also +# allowed. This is useful if you have classes or files whose names only differ +# in case and if your file system supports case sensitive file names. Windows +# and Mac users are advised to set this option to NO. + +CASE_SENSE_NAMES = YES + +# If the HIDE_SCOPE_NAMES tag is set to NO (the default) then Doxygen +# will show members with their full class and namespace scopes in the +# documentation. If set to YES the scope will be hidden. + +HIDE_SCOPE_NAMES = NO + +# If the SHOW_INCLUDE_FILES tag is set to YES (the default) then Doxygen +# will put a list of the files that are included by a file in the documentation +# of that file. + +SHOW_INCLUDE_FILES = YES + +# If the INLINE_INFO tag is set to YES (the default) then a tag [inline] +# is inserted in the documentation for inline members. + +INLINE_INFO = YES + +# If the SORT_MEMBER_DOCS tag is set to YES (the default) then doxygen +# will sort the (detailed) documentation of file and class members +# alphabetically by member name. If set to NO the members will appear in +# declaration order. + +SORT_MEMBER_DOCS = YES + +# If the SORT_BRIEF_DOCS tag is set to YES then doxygen will sort the +# brief documentation of file, namespace and class members alphabetically +# by member name. If set to NO (the default) the members will appear in +# declaration order. + +SORT_BRIEF_DOCS = NO + +# If the SORT_BY_SCOPE_NAME tag is set to YES, the class list will be +# sorted by fully-qualified names, including namespaces. If set to +# NO (the default), the class list will be sorted only by class name, +# not including the namespace part. +# Note: This option is not very useful if HIDE_SCOPE_NAMES is set to YES. +# Note: This option applies only to the class list, not to the +# alphabetical list. + +SORT_BY_SCOPE_NAME = NO + +# The GENERATE_TODOLIST tag can be used to enable (YES) or +# disable (NO) the todo list. This list is created by putting \todo +# commands in the documentation. + +GENERATE_TODOLIST = YES + +# The GENERATE_TESTLIST tag can be used to enable (YES) or +# disable (NO) the test list. This list is created by putting \test +# commands in the documentation. + +GENERATE_TESTLIST = YES + +# The GENERATE_BUGLIST tag can be used to enable (YES) or +# disable (NO) the bug list. This list is created by putting \bug +# commands in the documentation. + +GENERATE_BUGLIST = YES + +# The GENERATE_DEPRECATEDLIST tag can be used to enable (YES) or +# disable (NO) the deprecated list. This list is created by putting +# \deprecated commands in the documentation. + +GENERATE_DEPRECATEDLIST= YES + +# The ENABLED_SECTIONS tag can be used to enable conditional +# documentation sections, marked by \if sectionname ... \endif. + +ENABLED_SECTIONS = + +# The MAX_INITIALIZER_LINES tag determines the maximum number of lines +# the initial value of a variable or define consists of for it to appear in +# the documentation. If the initializer consists of more lines than specified +# here it will be hidden. Use a value of 0 to hide initializers completely. +# The appearance of the initializer of individual variables and defines in the +# documentation can be controlled using \showinitializer or \hideinitializer +# command in the documentation regardless of this setting. + +MAX_INITIALIZER_LINES = 30 + +# Set the SHOW_USED_FILES tag to NO to disable the list of files generated +# at the bottom of the documentation of classes and structs. If set to YES the +# list will mention the files that were used to generate the documentation. + +SHOW_USED_FILES = YES + +# If the sources in your project are distributed over multiple directories +# then setting the SHOW_DIRECTORIES tag to YES will show the directory hierarchy +# in the documentation. The default is YES. + +SHOW_DIRECTORIES = YES + +# The FILE_VERSION_FILTER tag can be used to specify a program or script that +# doxygen should invoke to get the current version for each file (typically from the +# version control system). Doxygen will invoke the program by executing (via +# popen()) the command , where is the value of +# the FILE_VERSION_FILTER tag, and is the name of an input file +# provided by doxygen. Whatever the progam writes to standard output +# is used as the file version. See the manual for examples. + +FILE_VERSION_FILTER = + +#--------------------------------------------------------------------------- +# configuration options related to warning and progress messages +#--------------------------------------------------------------------------- + +# The QUIET tag can be used to turn on/off the messages that are generated +# by doxygen. Possible values are YES and NO. If left blank NO is used. + +QUIET = NO + +# The WARNINGS tag can be used to turn on/off the warning messages that are +# generated by doxygen. Possible values are YES and NO. If left blank +# NO is used. + +WARNINGS = YES + +# If WARN_IF_UNDOCUMENTED is set to YES, then doxygen will generate warnings +# for undocumented members. If EXTRACT_ALL is set to YES then this flag will +# automatically be disabled. + +WARN_IF_UNDOCUMENTED = YES + +# If WARN_IF_DOC_ERROR is set to YES, doxygen will generate warnings for +# potential errors in the documentation, such as not documenting some +# parameters in a documented function, or documenting parameters that +# don't exist or using markup commands wrongly. + +WARN_IF_DOC_ERROR = YES + +# This WARN_NO_PARAMDOC option can be abled to get warnings for +# functions that are documented, but have no documentation for their parameters +# or return value. If set to NO (the default) doxygen will only warn about +# wrong or incomplete parameter documentation, but not about the absence of +# documentation. + +WARN_NO_PARAMDOC = NO + +# The WARN_FORMAT tag determines the format of the warning messages that +# doxygen can produce. The string should contain the $file, $line, and $text +# tags, which will be replaced by the file and line number from which the +# warning originated and the warning text. Optionally the format may contain +# $version, which will be replaced by the version of the file (if it could +# be obtained via FILE_VERSION_FILTER) + +WARN_FORMAT = "$file:$line: $text" + +# The WARN_LOGFILE tag can be used to specify a file to which warning +# and error messages should be written. If left blank the output is written +# to stderr. + +WARN_LOGFILE = + +#--------------------------------------------------------------------------- +# configuration options related to the input files +#--------------------------------------------------------------------------- + +# The INPUT tag can be used to specify the files and/or directories that contain +# documented source files. You may enter file names like "myfile.cpp" or +# directories like "/usr/src/myproject". Separate the files or directories +# with spaces. + +INPUT = + +# If the value of the INPUT tag contains directories, you can use the +# FILE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp +# and *.h) to filter out the source-files in the directories. If left +# blank the following patterns are tested: +# *.c *.cc *.cxx *.cpp *.c++ *.java *.ii *.ixx *.ipp *.i++ *.inl *.h *.hh *.hxx +# *.hpp *.h++ *.idl *.odl *.cs *.php *.php3 *.inc *.m *.mm + +FILE_PATTERNS = + +# The RECURSIVE tag can be used to turn specify whether or not subdirectories +# should be searched for input files as well. Possible values are YES and NO. +# If left blank NO is used. + +RECURSIVE = NO + +# The EXCLUDE tag can be used to specify files and/or directories that should +# excluded from the INPUT source files. This way you can easily exclude a +# subdirectory from a directory tree whose root is specified with the INPUT tag. + +EXCLUDE = + +# The EXCLUDE_SYMLINKS tag can be used select whether or not files or +# directories that are symbolic links (a Unix filesystem feature) are excluded +# from the input. + +EXCLUDE_SYMLINKS = NO + +# If the value of the INPUT tag contains directories, you can use the +# EXCLUDE_PATTERNS tag to specify one or more wildcard patterns to exclude +# certain files from those directories. Note that the wildcards are matched +# against the file with absolute path, so to exclude all test directories +# for example use the pattern */test/* + +EXCLUDE_PATTERNS = + +# The EXAMPLE_PATH tag can be used to specify one or more files or +# directories that contain example code fragments that are included (see +# the \include command). + +EXAMPLE_PATH = + +# If the value of the EXAMPLE_PATH tag contains directories, you can use the +# EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp +# and *.h) to filter out the source-files in the directories. If left +# blank all files are included. + +EXAMPLE_PATTERNS = + +# If the EXAMPLE_RECURSIVE tag is set to YES then subdirectories will be +# searched for input files to be used with the \include or \dontinclude +# commands irrespective of the value of the RECURSIVE tag. +# Possible values are YES and NO. If left blank NO is used. + +EXAMPLE_RECURSIVE = NO + +# The IMAGE_PATH tag can be used to specify one or more files or +# directories that contain image that are included in the documentation (see +# the \image command). + +IMAGE_PATH = + +# The INPUT_FILTER tag can be used to specify a program that doxygen should +# invoke to filter for each input file. Doxygen will invoke the filter program +# by executing (via popen()) the command , where +# is the value of the INPUT_FILTER tag, and is the name of an +# input file. Doxygen will then use the output that the filter program writes +# to standard output. If FILTER_PATTERNS is specified, this tag will be +# ignored. + +INPUT_FILTER = + +# The FILTER_PATTERNS tag can be used to specify filters on a per file pattern +# basis. Doxygen will compare the file name with each pattern and apply the +# filter if there is a match. The filters are a list of the form: +# pattern=filter (like *.cpp=my_cpp_filter). See INPUT_FILTER for further +# info on how filters are used. If FILTER_PATTERNS is empty, INPUT_FILTER +# is applied to all files. + +FILTER_PATTERNS = + +# If the FILTER_SOURCE_FILES tag is set to YES, the input filter (if set using +# INPUT_FILTER) will be used to filter the input files when producing source +# files to browse (i.e. when SOURCE_BROWSER is set to YES). + +FILTER_SOURCE_FILES = NO + +#--------------------------------------------------------------------------- +# configuration options related to source browsing +#--------------------------------------------------------------------------- + +# If the SOURCE_BROWSER tag is set to YES then a list of source files will +# be generated. Documented entities will be cross-referenced with these sources. +# Note: To get rid of all source code in the generated output, make sure also +# VERBATIM_HEADERS is set to NO. + +SOURCE_BROWSER = NO + +# Setting the INLINE_SOURCES tag to YES will include the body +# of functions and classes directly in the documentation. + +INLINE_SOURCES = NO + +# Setting the STRIP_CODE_COMMENTS tag to YES (the default) will instruct +# doxygen to hide any special comment blocks from generated source code +# fragments. Normal C and C++ comments will always remain visible. + +STRIP_CODE_COMMENTS = YES + +# If the REFERENCED_BY_RELATION tag is set to YES (the default) +# then for each documented function all documented +# functions referencing it will be listed. + +REFERENCED_BY_RELATION = YES + +# If the REFERENCES_RELATION tag is set to YES (the default) +# then for each documented function all documented entities +# called/used by that function will be listed. + +REFERENCES_RELATION = YES + +# If the USE_HTAGS tag is set to YES then the references to source code +# will point to the HTML generated by the htags(1) tool instead of doxygen +# built-in source browser. The htags tool is part of GNU's global source +# tagging system (see http://www.gnu.org/software/global/global.html). You +# will need version 4.8.6 or higher. + +USE_HTAGS = NO + +# If the VERBATIM_HEADERS tag is set to YES (the default) then Doxygen +# will generate a verbatim copy of the header file for each class for +# which an include is specified. Set to NO to disable this. + +VERBATIM_HEADERS = YES + +#--------------------------------------------------------------------------- +# configuration options related to the alphabetical class index +#--------------------------------------------------------------------------- + +# If the ALPHABETICAL_INDEX tag is set to YES, an alphabetical index +# of all compounds will be generated. Enable this if the project +# contains a lot of classes, structs, unions or interfaces. + +ALPHABETICAL_INDEX = NO + +# If the alphabetical index is enabled (see ALPHABETICAL_INDEX) then +# the COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns +# in which this list will be split (can be a number in the range [1..20]) + +COLS_IN_ALPHA_INDEX = 5 + +# In case all classes in a project start with a common prefix, all +# classes will be put under the same header in the alphabetical index. +# The IGNORE_PREFIX tag can be used to specify one or more prefixes that +# should be ignored while generating the index headers. + +IGNORE_PREFIX = + +#--------------------------------------------------------------------------- +# configuration options related to the HTML output +#--------------------------------------------------------------------------- + +# If the GENERATE_HTML tag is set to YES (the default) Doxygen will +# generate HTML output. + +GENERATE_HTML = YES + +# The HTML_OUTPUT tag is used to specify where the HTML docs will be put. +# If a relative path is entered the value of OUTPUT_DIRECTORY will be +# put in front of it. If left blank `html' will be used as the default path. + +HTML_OUTPUT = html + +# The HTML_FILE_EXTENSION tag can be used to specify the file extension for +# each generated HTML page (for example: .htm,.php,.asp). If it is left blank +# doxygen will generate files with .html extension. + +HTML_FILE_EXTENSION = .html + +# The HTML_HEADER tag can be used to specify a personal HTML header for +# each generated HTML page. If it is left blank doxygen will generate a +# standard header. + +HTML_HEADER = + +# The HTML_FOOTER tag can be used to specify a personal HTML footer for +# each generated HTML page. If it is left blank doxygen will generate a +# standard footer. + +HTML_FOOTER = + +# The HTML_STYLESHEET tag can be used to specify a user-defined cascading +# style sheet that is used by each HTML page. It can be used to +# fine-tune the look of the HTML output. If the tag is left blank doxygen +# will generate a default style sheet. Note that doxygen will try to copy +# the style sheet file to the HTML output directory, so don't put your own +# stylesheet in the HTML output directory as well, or it will be erased! + +HTML_STYLESHEET = + +# If the HTML_ALIGN_MEMBERS tag is set to YES, the members of classes, +# files or namespaces will be aligned in HTML using tables. If set to +# NO a bullet list will be used. + +HTML_ALIGN_MEMBERS = YES + +# If the GENERATE_HTMLHELP tag is set to YES, additional index files +# will be generated that can be used as input for tools like the +# Microsoft HTML help workshop to generate a compressed HTML help file (.chm) +# of the generated HTML documentation. + +GENERATE_HTMLHELP = NO + +# If the GENERATE_HTMLHELP tag is set to YES, the CHM_FILE tag can +# be used to specify the file name of the resulting .chm file. You +# can add a path in front of the file if the result should not be +# written to the html output directory. + +CHM_FILE = + +# If the GENERATE_HTMLHELP tag is set to YES, the HHC_LOCATION tag can +# be used to specify the location (absolute path including file name) of +# the HTML help compiler (hhc.exe). If non-empty doxygen will try to run +# the HTML help compiler on the generated index.hhp. + +HHC_LOCATION = + +# If the GENERATE_HTMLHELP tag is set to YES, the GENERATE_CHI flag +# controls if a separate .chi index file is generated (YES) or that +# it should be included in the master .chm file (NO). + +GENERATE_CHI = NO + +# If the GENERATE_HTMLHELP tag is set to YES, the BINARY_TOC flag +# controls whether a binary table of contents is generated (YES) or a +# normal table of contents (NO) in the .chm file. + +BINARY_TOC = NO + +# The TOC_EXPAND flag can be set to YES to add extra items for group members +# to the contents of the HTML help documentation and to the tree view. + +TOC_EXPAND = NO + +# The DISABLE_INDEX tag can be used to turn on/off the condensed index at +# top of each HTML page. The value NO (the default) enables the index and +# the value YES disables it. + +DISABLE_INDEX = NO + +# This tag can be used to set the number of enum values (range [1..20]) +# that doxygen will group on one line in the generated HTML documentation. + +ENUM_VALUES_PER_LINE = 4 + +# If the GENERATE_TREEVIEW tag is set to YES, a side panel will be +# generated containing a tree-like index structure (just like the one that +# is generated for HTML Help). For this to work a browser that supports +# JavaScript, DHTML, CSS and frames is required (for instance Mozilla 1.0+, +# Netscape 6.0+, Internet explorer 5.0+, or Konqueror). Windows users are +# probably better off using the HTML help feature. + +GENERATE_TREEVIEW = NO + +# If the treeview is enabled (see GENERATE_TREEVIEW) then this tag can be +# used to set the initial width (in pixels) of the frame in which the tree +# is shown. + +TREEVIEW_WIDTH = 250 + +#--------------------------------------------------------------------------- +# configuration options related to the LaTeX output +#--------------------------------------------------------------------------- + +# If the GENERATE_LATEX tag is set to YES (the default) Doxygen will +# generate Latex output. + +GENERATE_LATEX = YES + +# The LATEX_OUTPUT tag is used to specify where the LaTeX docs will be put. +# If a relative path is entered the value of OUTPUT_DIRECTORY will be +# put in front of it. If left blank `latex' will be used as the default path. + +LATEX_OUTPUT = latex + +# The LATEX_CMD_NAME tag can be used to specify the LaTeX command name to be +# invoked. If left blank `latex' will be used as the default command name. + +LATEX_CMD_NAME = latex + +# The MAKEINDEX_CMD_NAME tag can be used to specify the command name to +# generate index for LaTeX. If left blank `makeindex' will be used as the +# default command name. + +MAKEINDEX_CMD_NAME = makeindex + +# If the COMPACT_LATEX tag is set to YES Doxygen generates more compact +# LaTeX documents. This may be useful for small projects and may help to +# save some trees in general. + +COMPACT_LATEX = NO + +# The PAPER_TYPE tag can be used to set the paper type that is used +# by the printer. Possible values are: a4, a4wide, letter, legal and +# executive. If left blank a4wide will be used. + +PAPER_TYPE = a4wide + +# The EXTRA_PACKAGES tag can be to specify one or more names of LaTeX +# packages that should be included in the LaTeX output. + +EXTRA_PACKAGES = + +# The LATEX_HEADER tag can be used to specify a personal LaTeX header for +# the generated latex document. The header should contain everything until +# the first chapter. If it is left blank doxygen will generate a +# standard header. Notice: only use this tag if you know what you are doing! + +LATEX_HEADER = + +# If the PDF_HYPERLINKS tag is set to YES, the LaTeX that is generated +# is prepared for conversion to pdf (using ps2pdf). The pdf file will +# contain links (just like the HTML output) instead of page references +# This makes the output suitable for online browsing using a pdf viewer. + +PDF_HYPERLINKS = NO + +# If the USE_PDFLATEX tag is set to YES, pdflatex will be used instead of +# plain latex in the generated Makefile. Set this option to YES to get a +# higher quality PDF documentation. + +USE_PDFLATEX = NO + +# If the LATEX_BATCHMODE tag is set to YES, doxygen will add the \\batchmode. +# command to the generated LaTeX files. This will instruct LaTeX to keep +# running if errors occur, instead of asking the user for help. +# This option is also used when generating formulas in HTML. + +LATEX_BATCHMODE = NO + +# If LATEX_HIDE_INDICES is set to YES then doxygen will not +# include the index chapters (such as File Index, Compound Index, etc.) +# in the output. + +LATEX_HIDE_INDICES = NO + +#--------------------------------------------------------------------------- +# configuration options related to the RTF output +#--------------------------------------------------------------------------- + +# If the GENERATE_RTF tag is set to YES Doxygen will generate RTF output +# The RTF output is optimized for Word 97 and may not look very pretty with +# other RTF readers or editors. + +GENERATE_RTF = NO + +# The RTF_OUTPUT tag is used to specify where the RTF docs will be put. +# If a relative path is entered the value of OUTPUT_DIRECTORY will be +# put in front of it. If left blank `rtf' will be used as the default path. + +RTF_OUTPUT = rtf + +# If the COMPACT_RTF tag is set to YES Doxygen generates more compact +# RTF documents. This may be useful for small projects and may help to +# save some trees in general. + +COMPACT_RTF = NO + +# If the RTF_HYPERLINKS tag is set to YES, the RTF that is generated +# will contain hyperlink fields. The RTF file will +# contain links (just like the HTML output) instead of page references. +# This makes the output suitable for online browsing using WORD or other +# programs which support those fields. +# Note: wordpad (write) and others do not support links. + +RTF_HYPERLINKS = NO + +# Load stylesheet definitions from file. Syntax is similar to doxygen's +# config file, i.e. a series of assignments. You only have to provide +# replacements, missing definitions are set to their default value. + +RTF_STYLESHEET_FILE = + +# Set optional variables used in the generation of an rtf document. +# Syntax is similar to doxygen's config file. + +RTF_EXTENSIONS_FILE = + +#--------------------------------------------------------------------------- +# configuration options related to the man page output +#--------------------------------------------------------------------------- + +# If the GENERATE_MAN tag is set to YES (the default) Doxygen will +# generate man pages + +GENERATE_MAN = NO + +# The MAN_OUTPUT tag is used to specify where the man pages will be put. +# If a relative path is entered the value of OUTPUT_DIRECTORY will be +# put in front of it. If left blank `man' will be used as the default path. + +MAN_OUTPUT = man + +# The MAN_EXTENSION tag determines the extension that is added to +# the generated man pages (default is the subroutine's section .3) + +MAN_EXTENSION = .3 + +# If the MAN_LINKS tag is set to YES and Doxygen generates man output, +# then it will generate one additional man file for each entity +# documented in the real man page(s). These additional files +# only source the real man page, but without them the man command +# would be unable to find the correct page. The default is NO. + +MAN_LINKS = NO + +#--------------------------------------------------------------------------- +# configuration options related to the XML output +#--------------------------------------------------------------------------- + +# If the GENERATE_XML tag is set to YES Doxygen will +# generate an XML file that captures the structure of +# the code including all documentation. + +GENERATE_XML = NO + +# The XML_OUTPUT tag is used to specify where the XML pages will be put. +# If a relative path is entered the value of OUTPUT_DIRECTORY will be +# put in front of it. If left blank `xml' will be used as the default path. + +XML_OUTPUT = xml + +# The XML_SCHEMA tag can be used to specify an XML schema, +# which can be used by a validating XML parser to check the +# syntax of the XML files. + +XML_SCHEMA = + +# The XML_DTD tag can be used to specify an XML DTD, +# which can be used by a validating XML parser to check the +# syntax of the XML files. + +XML_DTD = + +# If the XML_PROGRAMLISTING tag is set to YES Doxygen will +# dump the program listings (including syntax highlighting +# and cross-referencing information) to the XML output. Note that +# enabling this will significantly increase the size of the XML output. + +XML_PROGRAMLISTING = YES + +#--------------------------------------------------------------------------- +# configuration options for the AutoGen Definitions output +#--------------------------------------------------------------------------- + +# If the GENERATE_AUTOGEN_DEF tag is set to YES Doxygen will +# generate an AutoGen Definitions (see autogen.sf.net) file +# that captures the structure of the code including all +# documentation. Note that this feature is still experimental +# and incomplete at the moment. + +GENERATE_AUTOGEN_DEF = NO + +#--------------------------------------------------------------------------- +# configuration options related to the Perl module output +#--------------------------------------------------------------------------- + +# If the GENERATE_PERLMOD tag is set to YES Doxygen will +# generate a Perl module file that captures the structure of +# the code including all documentation. Note that this +# feature is still experimental and incomplete at the +# moment. + +GENERATE_PERLMOD = NO + +# If the PERLMOD_LATEX tag is set to YES Doxygen will generate +# the necessary Makefile rules, Perl scripts and LaTeX code to be able +# to generate PDF and DVI output from the Perl module output. + +PERLMOD_LATEX = NO + +# If the PERLMOD_PRETTY tag is set to YES the Perl module output will be +# nicely formatted so it can be parsed by a human reader. This is useful +# if you want to understand what is going on. On the other hand, if this +# tag is set to NO the size of the Perl module output will be much smaller +# and Perl will parse it just the same. + +PERLMOD_PRETTY = YES + +# The names of the make variables in the generated doxyrules.make file +# are prefixed with the string contained in PERLMOD_MAKEVAR_PREFIX. +# This is useful so different doxyrules.make files included by the same +# Makefile don't overwrite each other's variables. + +PERLMOD_MAKEVAR_PREFIX = + +#--------------------------------------------------------------------------- +# Configuration options related to the preprocessor +#--------------------------------------------------------------------------- + +# If the ENABLE_PREPROCESSING tag is set to YES (the default) Doxygen will +# evaluate all C-preprocessor directives found in the sources and include +# files. + +ENABLE_PREPROCESSING = YES + +# If the MACRO_EXPANSION tag is set to YES Doxygen will expand all macro +# names in the source code. If set to NO (the default) only conditional +# compilation will be performed. Macro expansion can be done in a controlled +# way by setting EXPAND_ONLY_PREDEF to YES. + +MACRO_EXPANSION = NO + +# If the EXPAND_ONLY_PREDEF and MACRO_EXPANSION tags are both set to YES +# then the macro expansion is limited to the macros specified with the +# PREDEFINED and EXPAND_AS_PREDEFINED tags. + +EXPAND_ONLY_PREDEF = NO + +# If the SEARCH_INCLUDES tag is set to YES (the default) the includes files +# in the INCLUDE_PATH (see below) will be search if a #include is found. + +SEARCH_INCLUDES = YES + +# The INCLUDE_PATH tag can be used to specify one or more directories that +# contain include files that are not input files but should be processed by +# the preprocessor. + +INCLUDE_PATH = + +# You can use the INCLUDE_FILE_PATTERNS tag to specify one or more wildcard +# patterns (like *.h and *.hpp) to filter out the header-files in the +# directories. If left blank, the patterns specified with FILE_PATTERNS will +# be used. + +INCLUDE_FILE_PATTERNS = + +# The PREDEFINED tag can be used to specify one or more macro names that +# are defined before the preprocessor is started (similar to the -D option of +# gcc). The argument of the tag is a list of macros of the form: name +# or name=definition (no spaces). If the definition and the = are +# omitted =1 is assumed. To prevent a macro definition from being +# undefined via #undef or recursively expanded use the := operator +# instead of the = operator. + +PREDEFINED = + +# If the MACRO_EXPANSION and EXPAND_ONLY_PREDEF tags are set to YES then +# this tag can be used to specify a list of macro names that should be expanded. +# The macro definition that is found in the sources will be used. +# Use the PREDEFINED tag if you want to use a different macro definition. + +EXPAND_AS_DEFINED = + +# If the SKIP_FUNCTION_MACROS tag is set to YES (the default) then +# doxygen's preprocessor will remove all function-like macros that are alone +# on a line, have an all uppercase name, and do not end with a semicolon. Such +# function macros are typically used for boiler-plate code, and will confuse +# the parser if not removed. + +SKIP_FUNCTION_MACROS = YES + +#--------------------------------------------------------------------------- +# Configuration::additions related to external references +#--------------------------------------------------------------------------- + +# The TAGFILES option can be used to specify one or more tagfiles. +# Optionally an initial location of the external documentation +# can be added for each tagfile. The format of a tag file without +# this location is as follows: +# TAGFILES = file1 file2 ... +# Adding location for the tag files is done as follows: +# TAGFILES = file1=loc1 "file2 = loc2" ... +# where "loc1" and "loc2" can be relative or absolute paths or +# URLs. If a location is present for each tag, the installdox tool +# does not have to be run to correct the links. +# Note that each tag file must have a unique name +# (where the name does NOT include the path) +# If a tag file is not located in the directory in which doxygen +# is run, you must also specify the path to the tagfile here. + +TAGFILES = + +# When a file name is specified after GENERATE_TAGFILE, doxygen will create +# a tag file that is based on the input files it reads. + +GENERATE_TAGFILE = + +# If the ALLEXTERNALS tag is set to YES all external classes will be listed +# in the class index. If set to NO only the inherited external classes +# will be listed. + +ALLEXTERNALS = NO + +# If the EXTERNAL_GROUPS tag is set to YES all external groups will be listed +# in the modules index. If set to NO, only the current project's groups will +# be listed. + +EXTERNAL_GROUPS = YES + +# The PERL_PATH should be the absolute path and name of the perl script +# interpreter (i.e. the result of `which perl'). + +PERL_PATH = /usr/bin/perl + +#--------------------------------------------------------------------------- +# Configuration options related to the dot tool +#--------------------------------------------------------------------------- + +# If the CLASS_DIAGRAMS tag is set to YES (the default) Doxygen will +# generate a inheritance diagram (in HTML, RTF and LaTeX) for classes with base +# or super classes. Setting the tag to NO turns the diagrams off. Note that +# this option is superseded by the HAVE_DOT option below. This is only a +# fallback. It is recommended to install and use dot, since it yields more +# powerful graphs. + +CLASS_DIAGRAMS = YES + +# If set to YES, the inheritance and collaboration graphs will hide +# inheritance and usage relations if the target is undocumented +# or is not a class. + +HIDE_UNDOC_RELATIONS = YES + +# If you set the HAVE_DOT tag to YES then doxygen will assume the dot tool is +# available from the path. This tool is part of Graphviz, a graph visualization +# toolkit from AT&T and Lucent Bell Labs. The other options in this section +# have no effect if this option is set to NO (the default) + +HAVE_DOT = NO + +# If the CLASS_GRAPH and HAVE_DOT tags are set to YES then doxygen +# will generate a graph for each documented class showing the direct and +# indirect inheritance relations. Setting this tag to YES will force the +# the CLASS_DIAGRAMS tag to NO. + +CLASS_GRAPH = YES + +# If the COLLABORATION_GRAPH and HAVE_DOT tags are set to YES then doxygen +# will generate a graph for each documented class showing the direct and +# indirect implementation dependencies (inheritance, containment, and +# class references variables) of the class with other documented classes. + +COLLABORATION_GRAPH = YES + +# If the GROUP_GRAPHS and HAVE_DOT tags are set to YES then doxygen +# will generate a graph for groups, showing the direct groups dependencies + +GROUP_GRAPHS = YES + +# If the UML_LOOK tag is set to YES doxygen will generate inheritance and +# collaboration diagrams in a style similar to the OMG's Unified Modeling +# Language. + +UML_LOOK = NO + +# If set to YES, the inheritance and collaboration graphs will show the +# relations between templates and their instances. + +TEMPLATE_RELATIONS = NO + +# If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDE_GRAPH, and HAVE_DOT +# tags are set to YES then doxygen will generate a graph for each documented +# file showing the direct and indirect include dependencies of the file with +# other documented files. + +INCLUDE_GRAPH = YES + +# If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDED_BY_GRAPH, and +# HAVE_DOT tags are set to YES then doxygen will generate a graph for each +# documented header file showing the documented files that directly or +# indirectly include this file. + +INCLUDED_BY_GRAPH = YES + +# If the CALL_GRAPH and HAVE_DOT tags are set to YES then doxygen will +# generate a call dependency graph for every global function or class method. +# Note that enabling this option will significantly increase the time of a run. +# So in most cases it will be better to enable call graphs for selected +# functions only using the \callgraph command. + +CALL_GRAPH = NO + +# If the GRAPHICAL_HIERARCHY and HAVE_DOT tags are set to YES then doxygen +# will graphical hierarchy of all classes instead of a textual one. + +GRAPHICAL_HIERARCHY = YES + +# If the DIRECTORY_GRAPH, SHOW_DIRECTORIES and HAVE_DOT tags are set to YES +# then doxygen will show the dependencies a directory has on other directories +# in a graphical way. The dependency relations are determined by the #include +# relations between the files in the directories. + +DIRECTORY_GRAPH = YES + +# The DOT_IMAGE_FORMAT tag can be used to set the image format of the images +# generated by dot. Possible values are png, jpg, or gif +# If left blank png will be used. + +DOT_IMAGE_FORMAT = png + +# The tag DOT_PATH can be used to specify the path where the dot tool can be +# found. If left blank, it is assumed the dot tool can be found in the path. + +DOT_PATH = + +# The DOTFILE_DIRS tag can be used to specify one or more directories that +# contain dot files that are included in the documentation (see the +# \dotfile command). + +DOTFILE_DIRS = + +# The MAX_DOT_GRAPH_WIDTH tag can be used to set the maximum allowed width +# (in pixels) of the graphs generated by dot. If a graph becomes larger than +# this value, doxygen will try to truncate the graph, so that it fits within +# the specified constraint. Beware that most browsers cannot cope with very +# large images. + +MAX_DOT_GRAPH_WIDTH = 1024 + +# The MAX_DOT_GRAPH_HEIGHT tag can be used to set the maximum allows height +# (in pixels) of the graphs generated by dot. If a graph becomes larger than +# this value, doxygen will try to truncate the graph, so that it fits within +# the specified constraint. Beware that most browsers cannot cope with very +# large images. + +MAX_DOT_GRAPH_HEIGHT = 1024 + +# The MAX_DOT_GRAPH_DEPTH tag can be used to set the maximum depth of the +# graphs generated by dot. A depth value of 3 means that only nodes reachable +# from the root by following a path via at most 3 edges will be shown. Nodes +# that lay further from the root node will be omitted. Note that setting this +# option to 1 or 2 may greatly reduce the computation time needed for large +# code bases. Also note that a graph may be further truncated if the graph's +# image dimensions are not sufficient to fit the graph (see MAX_DOT_GRAPH_WIDTH +# and MAX_DOT_GRAPH_HEIGHT). If 0 is used for the depth value (the default), +# the graph is not depth-constrained. + +MAX_DOT_GRAPH_DEPTH = 0 + +# Set the DOT_TRANSPARENT tag to YES to generate images with a transparent +# background. This is disabled by default, which results in a white background. +# Warning: Depending on the platform used, enabling this option may lead to +# badly anti-aliased labels on the edges of a graph (i.e. they become hard to +# read). + +DOT_TRANSPARENT = NO + +# Set the DOT_MULTI_TARGETS tag to YES allow dot to generate multiple output +# files in one run (i.e. multiple -o and -T options on the command line). This +# makes dot run faster, but since only newer versions of dot (>1.8.10) +# support this, this feature is disabled by default. + +DOT_MULTI_TARGETS = NO + +# If the GENERATE_LEGEND tag is set to YES (the default) Doxygen will +# generate a legend page explaining the meaning of the various boxes and +# arrows in the dot generated graphs. + +GENERATE_LEGEND = YES + +# If the DOT_CLEANUP tag is set to YES (the default) Doxygen will +# remove the intermediate dot files that are used to generate +# the various graphs. + +DOT_CLEANUP = YES + +#--------------------------------------------------------------------------- +# Configuration::additions related to the search engine +#--------------------------------------------------------------------------- + +# The SEARCHENGINE tag specifies whether or not a search engine should be +# used. If set to NO the values of all tags below this one will be ignored. + +SEARCHENGINE = NO diff --git a/Makefile b/Makefile index 9c4282b..2315302 100644 --- a/Makefile +++ b/Makefile @@ -1,121 +1,31 @@ -# may the coders of gcc be infested with the fleas of ten thousand camels... +BASEDIR := ./ -CFLAGS=-ftemplate-depth-25 -#CFLAGS= -ftemplate-depth-25 -ggdb -#-Winline +CXXFLAGS := +LDFLAGS := -lfltk -OFLAG= -O +# each module will add to this, .os are derived from it +SRC := -# this is sufficient on debian machines -#LDFLAGS= -lfltk +include module.mk +include gui/module.mk -# this is what's needed on redhat machines -#LDFLAGS= -lfltk -L/usr/X11R6/lib -lX11 -# this is what's needed on fedora machines -#LDFLAGS= -lfltk -L/usr/X11R6/lib -lX11 -lXft +# process what the module.mks defined +OBJ := $(patsubst %.cxx,%.o, $(filter %.cxx,$(SRC))) +DEPS := $(OBJ:.o=.d) -# this is what's needed on gentoo machines -LDFLAGS= -L/usr/lib/fltk-1.1/ -lfltk -L/usr/X11R6/lib -lX11 -lXft - -# needed for apple/OS X -#LDFLAGS= -framework Carbon -framework ApplicationServices -lfltk - -# needed for cygwin/mingw32 -#CFLAGS=-ftemplate-depth-25 -mno-cygwin -#LDFLAGS= -lfltk -L/usr/lib/w32lib -lgdi32 -lws2_32 -luuid -lole32 +mussa: $(OBJ) + g++ -o $@ $(CXXFLAGS) $(LDFLAGS) $^ -# to check for memory leaks -MEMFLAG= -lefence +%.d: %.cxx + makedepend -o.d $(dirname $^) $(CFLAGS) $(CXXFILAGS) $^ -f- > $@ -all: mussa +%.o: %.cxx + g++ -c -o $@ $(CXXFLAGS) $^ -sequence.o : sequence.cc sequence.hh - $(CXX) $(CFLAGS) $(OFLAG) -c sequence.cc +include $(DEPS) -flp.o : flp.cc flp.hh - $(CXX) $(CFLAGS) $(OFLAG) -c flp.cc +clean: + -rm $(OBJ) $(DEPS) -flp_seqcomp.o : flp_seqcomp.cc flp.hh - $(CXX) $(CFLAGS) $(OFLAG) -c flp_seqcomp.cc -seqcomp : seqcomp.cc flp.o flp_seqcomp.o sequence.o - $(CXX) $(CFLAGS) $(OFLAG) -o seqcomp seqcomp.cc flp.o flp_seqcomp.o sequence.o - -mussa_nway.o : mussa_nway.cc mussa_nway.hh - $(CXX) $(CFLAGS) $(OFLAG) -c mussa_nway.cc - -mussa_nway_other.o : mussa_nway_other.cc mussa_nway.hh - $(CXX) $(CFLAGS) $(OFLAG) -c mussa_nway_other.cc - -mussa_nway_entropy.o : mussa_nway_entropy.cc mussa_nway.hh - $(CXX) $(CFLAGS) $(OFLAG) -c mussa_nway_entropy.cc - -mussa_class.o : mussa_class.cc mussa_class.hh - $(CXX) $(CFLAGS) -c mussa_class.cc - -mussan : sequence.o flp.o flp_seqcomp.o mussa_nway.o mussa_class.o \ - mussa_overlord.o mussa.cc - $(CXX) $(CFLAGS) -o mussa mussa.cc mussa_overlord.o \ - mussa_class.o mussa_nway.o flp_seqcomp.o flp.o sequence.o $(LDFLAGS) - -mussa_gui_seq_view.o : mussa_gui_seq_view.cc mussa_gui_seq_view.hh - $(CXX) $(CFLAGS) -c mussa_gui_seq_view.cc - -mussa_gui_seq.o : mussa_gui_seq.cc mussa_gui_seq.hh - $(CXX) $(CFLAGS) -c mussa_gui_seq.cc - -mussa_gui_seq_text.o : mussa_gui_seq_text.cc mussa_gui_seq_text.hh - $(CXX) $(CFLAGS) -c mussa_gui_seq_text.cc - -mussa_gui_motif_window.o : mussa_gui_motif_window.cc mussa_gui_motif_window.hh - $(CXX) $(CFLAGS) -c mussa_gui_motif_window.cc - -mussa_gui_annot_window.o : mussa_gui_annot_window.cc mussa_gui_annot_window.hh - $(CXX) $(CFLAGS) -c mussa_gui_annot_window.cc - -mussa_gui_load_window.o : mussa_gui_load_window.cc mussa_gui_load_window.hh - $(CXX) $(CFLAGS) -c mussa_gui_load_window.cc - -mussa_gui_subana.o : mussa_gui_subana.cc mussa_gui_subana.hh - $(CXX) $(CFLAGS) -c mussa_gui_subana.cc - -mussa_gui_conn_view.o : mussa_gui_conn_view.cc mussa_gui_conn_view.hh - $(CXX) $(CFLAGS) -O -c mussa_gui_conn_view.cc - -mussa_gui_conn_window.o : mussa_gui_conn_window.cc mussa_gui_conn_window.hh - $(CXX) $(CFLAGS) -c mussa_gui_conn_window.cc - -mussa : sequence.o flp.o flp_seqcomp.o \ - mussa_nway.o mussa_nway_other.o \ - mussa_nway_entropy.o mussa_class.o \ - mussa_gui_seq.o mussa_gui_seq_view.o \ - mussa_gui_motif_window.o mussa_gui_annot_window.o \ - mussa_gui_load_window.o mussa_gui_subana.o \ - mussa_gui_seq_text.o \ - mussa_gui_conn_view.o mussa_gui_conn_window.o \ - mussa.cc - $(CXX) $(CFLAGS) -o mussa mussa.cc \ - mussa_gui_conn_view.o mussa_gui_conn_window.o \ - mussa_gui_seq_text.o \ - mussa_gui_subana.o mussa_gui_load_window.o \ - mussa_gui_motif_window.o mussa_gui_annot_window.o \ - mussa_gui_seq.o mussa_gui_seq_view.o \ - mussa_class.o mussa_nway.o \ - mussa_nway_entropy.o mussa_nway_other.o \ - flp_seqcomp.o flp.o sequence.o $(LDFLAGS) - - -clean : - rm *.o - -cleaner : - rm *~ - -#mussa_overlord.o : mussa_overlord.cc mussa_overlord.hh -# $(CXX) $(CFLAGS) -c mussa_overlord.cc - - - -annot_test : sequence.o annot_test.cc - $(CXX) $(CFLAGS) -o annot_test annot_test.cc sequence.o diff --git a/flp.cc b/flp.cc deleted file mode 100644 index 73527d2..0000000 --- a/flp.cc +++ /dev/null @@ -1,235 +0,0 @@ -// This file is part of the Mussa source distribution. -// http://mussa.caltech.edu/ -// Contact author: Tristan De Buysscher, tristan@caltech.edu - -// This program and all associated source code files are Copyright (C) 2005 -// the California Institute of Technology, Pasadena, CA, 91125 USA. It is -// under the GNU Public License; please see the included LICENSE.txt -// file for more information, or contact Tristan directly. - - -// ---------------------------------------- -// ---------- flp.cc ----------- -// ---------------------------------------- - -#include "flp.hh" - -#include -#include - -using namespace std; - -FLPs::FLPs() -{ -} - -void -FLPs::setup(string type, int win_size, int hard_thres, int len1, int len2) -{ - list empty_match_list; - int i; - - window_size = win_size; - hard_threshold = hard_thres; - seq1_length = len1; - seq2_length = len2; - ana_type = type; - seq1_win_num = seq1_length - win_size + 1; - seq2_win_num = seq2_length - win_size + 1; - all_matches.reserve(seq1_win_num); - - empty_match_list.clear(); - for(i = 0; i < seq1_win_num; i++) - all_matches.push_back(empty_match_list); -} - -int -FLPs::win_num() -{ - return seq1_win_num; -} - -/* -bool -FLPs::match_less(match *match1, match *match2) -{ - if (match1->score < match2->score) - return true; - else if ( (match1->score == match2->score) && - (match1->index < match2->index) ) - return true; - else - return false; -} - -void -FLPs::sort() -{ - int i; - - for(i = 0; i < seq1_win_num; i++) - if (!all_matches[i].empty()) - all_matches[i].sort(&FLPs::match_less); -} -*/ - -list -FLPs::matches(int index) -{ - list these_matches; - list::iterator list_i, list_end; - - index = abs(index); - list_i = all_matches[index].begin(); - list_end = all_matches[index].end(); - //if (list_i == list_end) - //cout << "its fuckin empty!!!!"; - while (list_i != list_end) - { - these_matches.push_back(list_i->index); - //cout << list_i->index << " "; - ++list_i; - } - //cout << endl; - - return these_matches; -} - -list -FLPs::thres_matches(int index, int thres) -{ - list thres_matches; - list::iterator list_i, list_end; - - index = abs(index); - list_i = all_matches[index].begin(); - list_end = all_matches[index].end(); - thres_matches.clear(); - - //if (list_i == list_end) - //cout << "its fuckin empty!!!!"; - while (list_i != list_end) - { - if (list_i->score >= thres) - thres_matches.push_back(list_i->index); - //cout << list_i->index << " "; - - ++list_i; - } - //cout << endl; - - return thres_matches; -} - - -void -FLPs::file_save(string save_file_path) -{ - fstream save_file; - list::iterator match_i, match_list_end; - int i; - - save_file.open(save_file_path.c_str(), ios::out); - - save_file << "\n"; - - for(i = 0; i < seq1_win_num; i++) - { - if (!all_matches[i].empty()) - { - match_i = all_matches[i].begin(); - match_list_end = all_matches[i].end(); - while (match_i != match_list_end) - { - save_file << match_i->index << "," << match_i->score << " "; - ++match_i; - } - } - save_file << endl; - } - - save_file << "\n"; - - save_file.close(); -} - -void -FLPs::file_load(string file_path) -{ - fstream data_file; - string file_data, file_data_line, pair_data, index_data, score_data; - int type, window, hard_thres; - match a_match; - string::size_type split_index, comma_index; - bool tag_open = false; - list a_match_list; - int i; - - - - - - - data_file.open(file_path.c_str(), ios::in); - - getline(data_file,file_data_line); - // parse seqcomp open tag and parameters - // eg - // if parse successful... - tag_open = true; - - while ((!data_file.eof()) && tag_open) - { - // intialize list to empty - a_match_list.clear(); - - getline(data_file,file_data_line); - - if (file_data_line == "") - tag_open = false; - // parse line of matches - else if (file_data_line == "") - { - //cout << "empty line\n"; - all_matches.push_back(a_match_list); - } - else - { - split_index = file_data_line.find(" "); - - while (split_index != string::npos) - { - pair_data = file_data_line.substr(0,split_index); - file_data_line = file_data_line.substr(split_index+1); - //cout << "pair_data = " << pair_data << "..."; - // parse out the 2 pieces of data, index and score of pair match - comma_index = pair_data.find(","); - index_data = pair_data.substr(0, comma_index); - a_match.index = atoi(index_data.c_str() ); - score_data = pair_data.substr(comma_index+1); - a_match.score = atoi(score_data.c_str() ); - - //cout << a_match.index << "," << a_match.score << " "; - - a_match_list.push_back(a_match); - - split_index = file_data_line.find(" "); - } - //cout << "\n"; - all_matches.push_back(a_match_list); - } - } - seq1_win_num = all_matches.size(); - cout << "windows in flp = " << all_matches.size() << endl; - data_file.close(); -} - -/* - cout << "fee\n"; - cout << "fie\n"; - cout << "foe "; - cout << "fum\n"; -*/ - - diff --git a/flp.cxx b/flp.cxx new file mode 100644 index 0000000..73527d2 --- /dev/null +++ b/flp.cxx @@ -0,0 +1,235 @@ +// This file is part of the Mussa source distribution. +// http://mussa.caltech.edu/ +// Contact author: Tristan De Buysscher, tristan@caltech.edu + +// This program and all associated source code files are Copyright (C) 2005 +// the California Institute of Technology, Pasadena, CA, 91125 USA. It is +// under the GNU Public License; please see the included LICENSE.txt +// file for more information, or contact Tristan directly. + + +// ---------------------------------------- +// ---------- flp.cc ----------- +// ---------------------------------------- + +#include "flp.hh" + +#include +#include + +using namespace std; + +FLPs::FLPs() +{ +} + +void +FLPs::setup(string type, int win_size, int hard_thres, int len1, int len2) +{ + list empty_match_list; + int i; + + window_size = win_size; + hard_threshold = hard_thres; + seq1_length = len1; + seq2_length = len2; + ana_type = type; + seq1_win_num = seq1_length - win_size + 1; + seq2_win_num = seq2_length - win_size + 1; + all_matches.reserve(seq1_win_num); + + empty_match_list.clear(); + for(i = 0; i < seq1_win_num; i++) + all_matches.push_back(empty_match_list); +} + +int +FLPs::win_num() +{ + return seq1_win_num; +} + +/* +bool +FLPs::match_less(match *match1, match *match2) +{ + if (match1->score < match2->score) + return true; + else if ( (match1->score == match2->score) && + (match1->index < match2->index) ) + return true; + else + return false; +} + +void +FLPs::sort() +{ + int i; + + for(i = 0; i < seq1_win_num; i++) + if (!all_matches[i].empty()) + all_matches[i].sort(&FLPs::match_less); +} +*/ + +list +FLPs::matches(int index) +{ + list these_matches; + list::iterator list_i, list_end; + + index = abs(index); + list_i = all_matches[index].begin(); + list_end = all_matches[index].end(); + //if (list_i == list_end) + //cout << "its fuckin empty!!!!"; + while (list_i != list_end) + { + these_matches.push_back(list_i->index); + //cout << list_i->index << " "; + ++list_i; + } + //cout << endl; + + return these_matches; +} + +list +FLPs::thres_matches(int index, int thres) +{ + list thres_matches; + list::iterator list_i, list_end; + + index = abs(index); + list_i = all_matches[index].begin(); + list_end = all_matches[index].end(); + thres_matches.clear(); + + //if (list_i == list_end) + //cout << "its fuckin empty!!!!"; + while (list_i != list_end) + { + if (list_i->score >= thres) + thres_matches.push_back(list_i->index); + //cout << list_i->index << " "; + + ++list_i; + } + //cout << endl; + + return thres_matches; +} + + +void +FLPs::file_save(string save_file_path) +{ + fstream save_file; + list::iterator match_i, match_list_end; + int i; + + save_file.open(save_file_path.c_str(), ios::out); + + save_file << "\n"; + + for(i = 0; i < seq1_win_num; i++) + { + if (!all_matches[i].empty()) + { + match_i = all_matches[i].begin(); + match_list_end = all_matches[i].end(); + while (match_i != match_list_end) + { + save_file << match_i->index << "," << match_i->score << " "; + ++match_i; + } + } + save_file << endl; + } + + save_file << "\n"; + + save_file.close(); +} + +void +FLPs::file_load(string file_path) +{ + fstream data_file; + string file_data, file_data_line, pair_data, index_data, score_data; + int type, window, hard_thres; + match a_match; + string::size_type split_index, comma_index; + bool tag_open = false; + list a_match_list; + int i; + + + + + + + data_file.open(file_path.c_str(), ios::in); + + getline(data_file,file_data_line); + // parse seqcomp open tag and parameters + // eg + // if parse successful... + tag_open = true; + + while ((!data_file.eof()) && tag_open) + { + // intialize list to empty + a_match_list.clear(); + + getline(data_file,file_data_line); + + if (file_data_line == "") + tag_open = false; + // parse line of matches + else if (file_data_line == "") + { + //cout << "empty line\n"; + all_matches.push_back(a_match_list); + } + else + { + split_index = file_data_line.find(" "); + + while (split_index != string::npos) + { + pair_data = file_data_line.substr(0,split_index); + file_data_line = file_data_line.substr(split_index+1); + //cout << "pair_data = " << pair_data << "..."; + // parse out the 2 pieces of data, index and score of pair match + comma_index = pair_data.find(","); + index_data = pair_data.substr(0, comma_index); + a_match.index = atoi(index_data.c_str() ); + score_data = pair_data.substr(comma_index+1); + a_match.score = atoi(score_data.c_str() ); + + //cout << a_match.index << "," << a_match.score << " "; + + a_match_list.push_back(a_match); + + split_index = file_data_line.find(" "); + } + //cout << "\n"; + all_matches.push_back(a_match_list); + } + } + seq1_win_num = all_matches.size(); + cout << "windows in flp = " << all_matches.size() << endl; + data_file.close(); +} + +/* + cout << "fee\n"; + cout << "fie\n"; + cout << "foe "; + cout << "fum\n"; +*/ + + diff --git a/flp.hh b/flp.hh index 0929bd1..a34b51a 100644 --- a/flp.hh +++ b/flp.hh @@ -18,13 +18,16 @@ #include #include - -// FLP = Fixed Length Pairs (Data) -// vector of linked lists of the match type struct +//! FLP = Fixed Length Pairs (Data) +/*! + * vector of linked lists of the match type struct + */ class FLPs { private: + //! the number of base pairs used to compute this sliding window int window_size; + //! the minimum tnumber of base pairs need for this window to be saved. int hard_threshold; int seq1_length, seq2_length, seq1_win_num, seq2_win_num; std::string ana_type; diff --git a/flp_seqcomp.cc b/flp_seqcomp.cc deleted file mode 100644 index 43ba7c0..0000000 --- a/flp_seqcomp.cc +++ /dev/null @@ -1,152 +0,0 @@ -// This file is part of the Mussa source distribution. -// http://mussa.caltech.edu/ -// Contact author: Tristan De Buysscher, tristan@caltech.edu - -// This program and all associated source code files are Copyright (C) 2005 -// the California Institute of Technology, Pasadena, CA, 91125 USA. It is -// under the GNU Public License; please see the included LICENSE.txt -// file for more information, or contact Tristan directly. - - -// ---------------------------------------- -// ---------- flp_seqcomp.cc ----------- -// ---------------------------------------- - -#include "flp.hh" -using namespace std; - -// Note one recording RC matches. This version of 'seqcomp' records RC matches -// as index of the window start in its nonRC form. However, past versions of -// the analysis recorded it as the index of the rear of the window, as the -// following legacy comment indicates. FR still uses this method - -// Titus thinks the start of an RC window should be its "rear" in the -// normal version of the sequence. He's wrong, of course, and in the -// future my followers will annihilate his in the Final Battle, but for -// now I'll let him have his way. - -// note seq2_i is actually the index of the leaving bp, so need to +1 - -inline void -FLPs::add(int seq1_i, int seq2_i, int a_score, int i2_offset) -{ - match a_match; - - - if (a_score >= hard_threshold) - { - a_match.index = seq2_i + i2_offset; - a_match.score = a_score; - - all_matches[seq1_i].push_back(a_match); - } -} - - -void -FLPs::seqcomp(string sseq1, string sseq2, bool is_RC) -{ - int start_i, seq1_i, seq2_i, win_i; // loop variables - int matches; // number of matches in to a window - int i2_offset; - char * seq1, * seq2; - - - seq1 = (char *) sseq1.c_str(); - seq2 = (char *) sseq2.c_str(); - - - if (is_RC) - i2_offset = window_size - seq2_length; - else - i2_offset = 0; - - - // this does the "upper diagonals" of the search - - // loop thru the start positions for sequence 1 - for(start_i = 0; start_i < seq1_win_num; start_i++) - { - matches = 0; - // compare initial window - for(win_i = 0; win_i < window_size; win_i++) - if ((seq1[start_i+win_i] == seq2[win_i]) && - (seq1[start_i+win_i] != 'N')) // N's match nothing ** - matches++; - - //seq2_i is always 0 for initial win - seq2_i = 0; - - // call inlined function that adds match if it is above threshold - add(start_i, seq2_i, matches, i2_offset); - - // run through rest of seq1 and seq2 with current seq1 offset (ie start_i) - // compare the bps leaving and entering the window and modify matches count - seq1_i = start_i; - while( (seq1_i < seq1_win_num-1) && (seq2_i < seq2_win_num-1) ) - { - // copmpare the bp leaving the window - if ((seq1[seq1_i] == seq2[seq2_i]) && - (seq1[seq1_i] != 'N')) // N's match nothing - matches = matches -1; - - // compare the bp entering the window - if ((seq1[seq1_i+window_size] == seq2[seq2_i+window_size]) && - (seq1[seq1_i+window_size] != 'N')) // N's match nothing - matches = matches + 1; - - add(seq1_i + 1, seq2_i + 1, matches, i2_offset); - - seq1_i = seq1_i + 1; // increment seq1_i to next window - seq2_i = seq2_i + 1; // increment seq2_i to next window - } // end of loop thru the current offset sequence - } // end of loop thru the start positions of seq1 sequence - - - // this does the "lower diagonals" of the search - - // loop thru the start positions for sequence 1 - for(start_i = 1; start_i < seq2_win_num; start_i++) - { - matches = 0; - - // compare initial window - for(win_i = 0; win_i < window_size; win_i++) - if ((seq2[start_i+win_i] == seq1[win_i]) && - (seq2[start_i+win_i] != 'N')) // N's match nothing - matches++; - - //seq2_i is always start_i for initial window - seq2_i = start_i; - - add(0, seq2_i, matches, i2_offset); - - // run through rest of seq1 and seq2 with current seq1 offset (ie start_i) - // compare the bps leaving and entering the window and modify matches count - seq1_i = 0; - while( (seq1_i < seq1_win_num-1) && (seq2_i < seq2_win_num-1) ) - { - // copmpare the bp leaving the window - if ((seq1[seq1_i] == seq2[seq2_i]) && - (seq1[seq1_i] != 'N')) // N's match nothing - matches = matches - 1; - - // compare the bp entering the window - if ((seq1[seq1_i+window_size] == seq2[seq2_i+window_size]) && - (seq1[seq1_i+window_size] != 'N')) // N's match nothing - matches = matches + 1; - - add(seq1_i + 1, seq2_i + 1, matches, i2_offset); - - seq1_i = seq1_i + 1; // increment seq1_i to next window - seq2_i = seq2_i + 1; // increment seq2_i to next window - } // end of loop thru the current offset sequence - } // end of loop thru the start positions of seq2 sequence -} - -/* - cout << "fee\n"; - cout << "fie\n"; - cout << "foe\n"; - cout << "fum\n"; -*/ diff --git a/flp_seqcomp.cxx b/flp_seqcomp.cxx new file mode 100644 index 0000000..43ba7c0 --- /dev/null +++ b/flp_seqcomp.cxx @@ -0,0 +1,152 @@ +// This file is part of the Mussa source distribution. +// http://mussa.caltech.edu/ +// Contact author: Tristan De Buysscher, tristan@caltech.edu + +// This program and all associated source code files are Copyright (C) 2005 +// the California Institute of Technology, Pasadena, CA, 91125 USA. It is +// under the GNU Public License; please see the included LICENSE.txt +// file for more information, or contact Tristan directly. + + +// ---------------------------------------- +// ---------- flp_seqcomp.cc ----------- +// ---------------------------------------- + +#include "flp.hh" +using namespace std; + +// Note one recording RC matches. This version of 'seqcomp' records RC matches +// as index of the window start in its nonRC form. However, past versions of +// the analysis recorded it as the index of the rear of the window, as the +// following legacy comment indicates. FR still uses this method + +// Titus thinks the start of an RC window should be its "rear" in the +// normal version of the sequence. He's wrong, of course, and in the +// future my followers will annihilate his in the Final Battle, but for +// now I'll let him have his way. + +// note seq2_i is actually the index of the leaving bp, so need to +1 + +inline void +FLPs::add(int seq1_i, int seq2_i, int a_score, int i2_offset) +{ + match a_match; + + + if (a_score >= hard_threshold) + { + a_match.index = seq2_i + i2_offset; + a_match.score = a_score; + + all_matches[seq1_i].push_back(a_match); + } +} + + +void +FLPs::seqcomp(string sseq1, string sseq2, bool is_RC) +{ + int start_i, seq1_i, seq2_i, win_i; // loop variables + int matches; // number of matches in to a window + int i2_offset; + char * seq1, * seq2; + + + seq1 = (char *) sseq1.c_str(); + seq2 = (char *) sseq2.c_str(); + + + if (is_RC) + i2_offset = window_size - seq2_length; + else + i2_offset = 0; + + + // this does the "upper diagonals" of the search + + // loop thru the start positions for sequence 1 + for(start_i = 0; start_i < seq1_win_num; start_i++) + { + matches = 0; + // compare initial window + for(win_i = 0; win_i < window_size; win_i++) + if ((seq1[start_i+win_i] == seq2[win_i]) && + (seq1[start_i+win_i] != 'N')) // N's match nothing ** + matches++; + + //seq2_i is always 0 for initial win + seq2_i = 0; + + // call inlined function that adds match if it is above threshold + add(start_i, seq2_i, matches, i2_offset); + + // run through rest of seq1 and seq2 with current seq1 offset (ie start_i) + // compare the bps leaving and entering the window and modify matches count + seq1_i = start_i; + while( (seq1_i < seq1_win_num-1) && (seq2_i < seq2_win_num-1) ) + { + // copmpare the bp leaving the window + if ((seq1[seq1_i] == seq2[seq2_i]) && + (seq1[seq1_i] != 'N')) // N's match nothing + matches = matches -1; + + // compare the bp entering the window + if ((seq1[seq1_i+window_size] == seq2[seq2_i+window_size]) && + (seq1[seq1_i+window_size] != 'N')) // N's match nothing + matches = matches + 1; + + add(seq1_i + 1, seq2_i + 1, matches, i2_offset); + + seq1_i = seq1_i + 1; // increment seq1_i to next window + seq2_i = seq2_i + 1; // increment seq2_i to next window + } // end of loop thru the current offset sequence + } // end of loop thru the start positions of seq1 sequence + + + // this does the "lower diagonals" of the search + + // loop thru the start positions for sequence 1 + for(start_i = 1; start_i < seq2_win_num; start_i++) + { + matches = 0; + + // compare initial window + for(win_i = 0; win_i < window_size; win_i++) + if ((seq2[start_i+win_i] == seq1[win_i]) && + (seq2[start_i+win_i] != 'N')) // N's match nothing + matches++; + + //seq2_i is always start_i for initial window + seq2_i = start_i; + + add(0, seq2_i, matches, i2_offset); + + // run through rest of seq1 and seq2 with current seq1 offset (ie start_i) + // compare the bps leaving and entering the window and modify matches count + seq1_i = 0; + while( (seq1_i < seq1_win_num-1) && (seq2_i < seq2_win_num-1) ) + { + // copmpare the bp leaving the window + if ((seq1[seq1_i] == seq2[seq2_i]) && + (seq1[seq1_i] != 'N')) // N's match nothing + matches = matches - 1; + + // compare the bp entering the window + if ((seq1[seq1_i+window_size] == seq2[seq2_i+window_size]) && + (seq1[seq1_i+window_size] != 'N')) // N's match nothing + matches = matches + 1; + + add(seq1_i + 1, seq2_i + 1, matches, i2_offset); + + seq1_i = seq1_i + 1; // increment seq1_i to next window + seq2_i = seq2_i + 1; // increment seq2_i to next window + } // end of loop thru the current offset sequence + } // end of loop thru the start positions of seq2 sequence +} + +/* + cout << "fee\n"; + cout << "fie\n"; + cout << "foe\n"; + cout << "fum\n"; +*/ diff --git a/gui/AnnotWindow.cxx b/gui/AnnotWindow.cxx new file mode 100644 index 0000000..e82a51a --- /dev/null +++ b/gui/AnnotWindow.cxx @@ -0,0 +1,185 @@ +// This file is part of the Mussa source distribution. +// http://mussa.caltech.edu/ +// Contact author: Tristan De Buysscher, tristan@caltech.edu + +// This program and all associated source code files are Copyright (C) 2005 +// the California Institute of Technology, Pasadena, CA, 91125 USA. It is +// under the GNU Public License; please see the included LICENSE.txt +// file for more information, or contact Tristan directly. + + +#include "AnnotWindow.hh" +#include +#include + +using namespace std; + +annot_color +new_blank_annot() +{ + annot_color *a_annot; + + a_annot = new annot_color; + a_annot->type = ""; + a_annot->color = (Fl_Color) 5; + //cout << "type: " << a_annot->type << endl; + + return *a_annot; +} + + +void +cb_annot_color(Fl_Button* o, void* v) +{ + annot_instance * blah = (annot_instance *) v; + AnnotWindow* T= blah->mw_ptr; + T->cb_annot_color_i(o,blah->index); +} + +AnnotWindow::AnnotWindow(int w, int h, const char* title, + vector * some_annots):Fl_Window(w,h,title) +{ + int i, annot_num; + + the_annots = some_annots; + annot_count = 0; + + annot_color_buttons.clear(); + + begin(); + annot_input_pack = new Fl_Pack(0, 0, w, h); + annot_input_pack->spacing(4); + + // button to add new annot inputs + add_annot = new Fl_Button(0,0,100,24,"Add Annot Slot"); + add_annot->callback((Fl_Callback*)add_annot_cb, this); + annot_input_pack->add(add_annot); + // test button to make sure annot data is being stored + test = new Fl_Button(0,0,100,24,"show annots"); + test->callback((Fl_Callback*)print_cb, this); + annot_input_pack->add(test); + + // creat an initial set of annot input widgets and attach to annot vector + annot_num = some_annots->size(); + for (i = 0; i < annot_num; i++) + { + add_annot_input(i); + annot_count++; + } + + add(annot_input_pack); + + end(); + resizable(this); + show(); +} + + //tmp_input->user_data((void*) i); + +AnnotWindow::~AnnotWindow(){} + +void +AnnotWindow::add_annot_input(int index) +{ + Fl_Output * new_input; + Fl_Button *new_color_button; + annot_instance * something; + Fl_Pack * annot_hor_pack; + + + something = new annot_instance; + something->mw_ptr = this; + something->index = index; + + annot_hor_pack = new Fl_Pack(0, 0, w(), 24); + annot_hor_pack->type(Fl_Pack::HORIZONTAL); + annot_hor_pack->spacing(4); + + // setup the color display/selection button + new_color_button = new Fl_Button(0, 0, 24, 24, ""); + new_color_button->color((*the_annots)[index].color); + new_color_button->box(FL_FLAT_BOX); + new_color_button->callback((Fl_Callback*)cb_annot_color, (void*) something); + annot_color_buttons.push_back(new_color_button); + annot_hor_pack->add(new_color_button); + + + // setup the annot inputs + new_input = new Fl_Output(0, 0, 200, 24, ""); + new_input->value( ((*the_annots)[index].type).c_str() ); + //new_input->callback((Fl_Callback*)cb_annot_in, (void*) something); + annot_ins.push_back(new_input); + annot_hor_pack->add(new_input); + + annot_input_pack->add(annot_hor_pack); +} +/* + cout << "fee\n"; + cout << "fie\n"; + cout << "foe\n"; + cout << "fum\n"; +*/ + +void +AnnotWindow::cb_annot_in_i(Fl_Input* o, int i) +{ + (*the_annots)[i].type = o->value(); +} + +void +AnnotWindow::cb_annot_color_i(Fl_Button* o, int i) +{ + //Fl_Color new_color; + + (*the_annots)[i].color = fl_show_colormap((*the_annots)[i].color); + //annot_color_buttons[i]-> + o->color((*the_annots)[i].color); + redraw(); +} + +void AnnotWindow::add_annot_cb(Fl_Button* o, void* v) +{ + AnnotWindow* T=(AnnotWindow*)v; + T->add_annot_cb_real(o,v); +} + + +void AnnotWindow::add_annot_cb_real(Fl_Button* , void*) +{ + annot_color blank_annot; + + //blank_annot.name = ""; + //blank_annot.seq = ""; + blank_annot = new_blank_annot(); + (*the_annots).push_back(blank_annot); + add_annot_input(annot_count++); + redraw(); +} + + +void AnnotWindow::print_cb(Fl_Button* o, void* v) +{ + AnnotWindow* T=(AnnotWindow*)v; + T->print_cb_real(o,v); +} + + +void AnnotWindow::print_cb_real(Fl_Button* , void*) +{ + int i; + + for (i = 0; i < annot_count; i++) + cout << (*the_annots)[i].type << endl; +} + +/* +void +cb_annot_in(Fl_Input* o, void* v) +{ + annot_instance * blah = (annot_instance *) v; + AnnotWindow* T= blah->mw_ptr; + T->cb_annot_in_i(o,blah->index); +} + + +*/ diff --git a/gui/AnnotWindow.hh b/gui/AnnotWindow.hh new file mode 100644 index 0000000..0303139 --- /dev/null +++ b/gui/AnnotWindow.hh @@ -0,0 +1,72 @@ +#ifndef _MUSSA_GUI_ANNOT_WINDOW_H_ +#define _MUSSA_GUI_ANNOT_WINDOW_H_ +// This file is part of the Mussa source distribution. +// http://mussa.caltech.edu/ +// Contact author: Tristan De Buysscher, tristan@caltech.edu + +// This program and all associated source code files are Copyright (C) 2005 +// the California Institute of Technology, Pasadena, CA, 91125 USA. It is +// under the GNU Public License; please see the included LICENSE.txt +// file for more information, or contact Tristan directly. + +#include +#include +#include + +#include +#include + +#include +#include +#include + +#include "MotifWindow.hh" + +struct annot_color +{ + std::string type; + Fl_Color color; +}; + +//typedef annot_ptr *annot; + + +class AnnotWindow : public Fl_Window +{ + public: + AnnotWindow(int w, int h, const char* title, + std::vector * some_annots); + ~AnnotWindow(); + Fl_Pack * annot_input_pack; + std::list annot_ins; + std::vector annot_color_buttons; + std::list name_ins; + Fl_Button* test; + Fl_Button* add_annot; + + void cb_annot_in_i(Fl_Input*, int i); + void cb_annot_color_i(Fl_Button* o, int i); + + private: + std::vector * the_annots; + int annot_count; + + void add_annot_input(int index); + + static void add_annot_cb(Fl_Button*, void*); + inline void add_annot_cb_real(Fl_Button*, void*); + + static void print_cb(Fl_Button*, void*); + inline void print_cb_real(Fl_Button*, void*); +}; + +// crazy whacked shite Titus taught me to do to get an index value associated +// with each instance of an input associated with the callback... +struct annot_instance +{ + AnnotWindow * mw_ptr; + int index; +}; + +annot_color new_blank_annot(); +#endif diff --git a/gui/ConnView.cxx b/gui/ConnView.cxx new file mode 100644 index 0000000..15cc250 --- /dev/null +++ b/gui/ConnView.cxx @@ -0,0 +1,707 @@ +// This file is part of the Mussa source distribution. +// http://mussa.caltech.edu/ +// Contact author: Tristan De Buysscher, tristan@caltech.edu + +// This program and all associated source code files are Copyright (C) 2005 +// the California Institute of Technology, Pasadena, CA, 91125 USA. It is +// under the GNU Public License; please see the included LICENSE.txt +// file for more information, or contact Tristan directly. + + +#include "ConnView.hh" + +#include +#include + +#include +#include + +using namespace std; + +void +ConnView::setup(string name, int sq_num, int win_len, + vector *some_seqs, + Nway_Paths *some_paths) +{ + int i, i2, seq_length; + Sequence a_seq; + motif blank_motif; + annot_color new_annot; + + + ana_name = name; + seq_num = sq_num; + window = win_len; + S = some_seqs; + P = some_paths; + + cout << "num of paths = " << some_paths->refined_pathz.size() << endl; + + cout << "x()=" << x() << " y()=" << y() << " w()=" << w() << " h()=" << h(); + cout << endl; + + max_seq_len = 0; + for(i = 0; i < seq_num; ++i) + { + a_seq = (*S)[i]; + cout << a_seq.len() << endl; + seq_length = a_seq.len(); + seq_lens.push_back(seq_length); + if (seq_length > max_seq_len) + max_seq_len = seq_length; + if (seq_length < 1000) + seq_scales.push_back(1); + else if (seq_length < 1000000) + seq_scales.push_back(2); + else + seq_scales.push_back(3); + } + + name_pad = 80; + y_pad = 20; + + x_scale_factor = (float) max_seq_len / (w() - name_pad); + cout << "scale factor is " << x_scale_factor << endl; + y_seq_incre = (h()-(y_pad*2)) / (seq_num - 1); + + + drag_start = -1000; + drag_end = -1000; + ref_seq_num = 0; + + dragging = false; + selected = false; + + highlight.clear(); + show_bars = false; + show_lines = false; + bar_interval = max_seq_len / 20; + line_interval = max_seq_len / 20; + ref_seq_num = 0; + + + some_motifs.clear(); + for(i = 0; i < 5; ++i) + { + blank_motif = new_blank_motif(); + some_motifs.push_back(blank_motif); + } + + // find all unique annotation type ids + some_annots.clear(); + vector::iterator annot_type_i; + list::iterator annot_i; + + // loop thru all sequences + for(i2 = 0; i2 < seq_num; i2++) + { + cout << "ConnView: annotation loop\n"; + // loop thru all annotation entries in this sequence + for(annot_i = (*S)[i2].annots.begin(); annot_i != (*S)[i2].annots.end(); ++annot_i) + { + cout << annot_i->start << ", " << annot_i->end << " : "; + cout << annot_i->name << " " << annot_i->type << endl; + // loop thru annotation types + annot_type_i = some_annots.begin(); + bool type_unfound = true; + while ((annot_type_i != some_annots.end()) && type_unfound) + { + if (annot_i->type == annot_type_i->type) + type_unfound = false; // stop search if found + ++annot_type_i; + } + //if unfound, then add to list + if (type_unfound) + { + new_annot = new_blank_annot(); + new_annot.type = annot_i->type; + some_annots.push_back(new_annot); + } + } + } +} + + +void +ConnView::scale_paths() +{ + vector a_path; + list >::iterator pathz_i; + int i2; + + + scaled_pathz.clear(); + + for(pathz_i = P->refined_pathz.begin(); pathz_i != P->refined_pathz.end(); ++pathz_i) + { + a_path = *pathz_i; + for(i2 = 0; i2 <= seq_num; i2++) + a_path[i2] = (int) (a_path[i2] / x_scale_factor); + scaled_pathz.push_back(a_path); + } +} + +void +ConnView::toggle_bars() +{ + show_bars = !show_bars; + redraw(); +} + +void +ConnView::set_bar_interval(int new_bar_len) +{ + bar_interval = new_bar_len; + cout << "bar interval = " << bar_interval << endl; + redraw(); +} + +void +ConnView::toggle_lines() +{ + show_lines = !show_lines; + redraw(); +} + +void +ConnView::set_line_interval(int new_line_len) +{ + line_interval = new_line_len; + cout << "line interval = " << line_interval << endl; + redraw(); +} + + +void +ConnView::draw() +{ + // this is temporary - check if new motifs have been added + check_new_motifs(); + + // clear drawing area and set background to white + fl_color(FL_WHITE); + fl_rectf(x(), y(), w(), h()); + + + // draw the scale indicators if they are on + // put into own method soon... + int i, div_num, x_loc; + float div_len_scaled; + + if (show_bars) + { + div_num = max_seq_len / bar_interval; + div_len_scaled = ((float) bar_interval) / x_scale_factor; + fl_color(230,230,230); + for(i = 0; i <= div_num; i+=2) + { + x_loc = (int)(i * div_len_scaled+x()); + fl_rectf(x_loc, y(), (int) div_len_scaled, h()); + } + } + + if (show_lines) + { + div_num = max_seq_len / line_interval; + div_len_scaled = ((float) line_interval) / x_scale_factor; + fl_color(0,0,0); + fl_line_style(FL_SOLID, 1, NULL); + for(i = 0; i <= div_num; i++) + { + x_loc = (int)(i * div_len_scaled+x()); + fl_line(x_loc, y(), x_loc, h()+y()); + } + } + + + // divide up the space with some light blue lines + fl_color(150,200,255); + fl_line_style(FL_SOLID, 2, NULL); + fl_rect(x(), y(), w(), h()); + fl_line(w()+x()-name_pad, y(), w()+x()-name_pad, h()+y()); + + draw_paths(); + + // white out any overdraw from path area into name/info area + fl_color(FL_WHITE); + fl_rectf(w()+x()-name_pad, y(), w()+x(), h()); + + draw_sequence_stuff(); + + // draw selection box + /* + if (selected) + { + fl_color(FL_BLACK); + fl_line_style(FL_SOLID, 1, NULL); + fl_rect(drag_start,(ref_seq_num*y_seq_incre)+y(),drag_end-drag_start, + 16); + } + */ +} + + +void +ConnView::draw_paths() +{ + list >::iterator i; + int i2, i3, y_loc, x_loc, x_start, x_end; + vector a_path; + list::iterator highlight_i; + int window_size; + bool rc_color; + int path_start, path_end; + //Sequence a_seq; + + + // determine which paths to highlight + highlight.clear(); + for(i = scaled_pathz.begin(); i != scaled_pathz.end(); ++i) + { + a_path = *i; + // determine if path falls within the selected region and mark it for + // highlighted color + path_start = abs(a_path[ref_seq_num+1]); + path_end = path_start + a_path[0]; + if ( ( (path_start >= drag_start-x()) && (path_end <= drag_end-x()) ) || + ( (path_start < drag_start-x()) && (path_end > drag_end-x()) ) || + ( (path_start < drag_start-x()) && (path_end > drag_start-x()) ) || + ( (path_start < drag_end-x()) && (path_end > drag_end-x()) ) ) + highlight.push_back(true); + else + highlight.push_back(false); + } + + fl_line_style(FL_SOLID, 1, NULL); + // draw non-highlight paths (ie not in the selection box) + highlight_i = highlight.begin(); + for(i = scaled_pathz.begin(); i != scaled_pathz.end(); ++i) + { + a_path = *i; + y_loc = y()+y_pad; + + // get window size to determine line width + window_size = a_path[0]; + // make sure width is at least 1 - might be zero to my slack rounding + if (window_size == 0) + window_size = 1; + + if (!(*highlight_i)) + for(i2 = 1; i2 < seq_num; i2++) + { + // RC case handling + // ugh, an xor...only want blue if one of the nodes is rc + if ( ((a_path[i2] < 0) || (a_path[i2+1] < 0)) && + !((a_path[i2] < 0) && (a_path[i2+1] < 0)) ) + fl_color(200,200,255); + else + fl_color(255,200,200); + + fl_line_style(FL_SOLID, 1, NULL); + fl_polygon((int)abs(a_path[i2])+x(), y_loc + 3, + (int)abs(a_path[i2])+window_size+x(), y_loc + 3, + (int)abs(a_path[i2+1])+window_size+x(), y_loc + y_seq_incre - 3, + (int)abs(a_path[i2+1])+x(), y_loc + y_seq_incre - 3); + + y_loc += y_seq_incre; + } + ++highlight_i; + } + + // draw highlighted paths (ie in or partially in selection) + // drawing these separately and after other paths so they are on top + highlight_i = highlight.begin(); + for(i = scaled_pathz.begin(); i != scaled_pathz.end(); ++i) + { + a_path = *i; + y_loc = y()+y_pad; + + // get window size to determine line width + window_size = a_path[0]; + // make sure width is at least 1 - might be zero to my slack rounding + if (window_size == 0) + window_size = 1; + + if (*highlight_i) + for(i2 = 1; i2 < seq_num; i2++) + { + // RC case handling + // ugh, an xor...only want blue if one of the nodes is rc + if ( ((a_path[i2] < 0) || (a_path[i2+1] < 0)) && + !((a_path[i2] < 0) && (a_path[i2+1] < 0)) ) + fl_color(FL_BLUE); + else + fl_color(FL_RED); + + fl_polygon((int)abs(a_path[i2])+x(), y_loc + 3, + (int)abs(a_path[i2])+window_size+x(), y_loc + 3, + (int)abs(a_path[i2+1])+window_size+x(), y_loc + y_seq_incre - 3, + (int)abs(a_path[i2+1])+x(), y_loc + y_seq_incre - 3); + + y_loc += y_seq_incre; + } + ++highlight_i; + } +} + +/* + list >::iterator i; + int window_size; + bool rc_color; + int path_start, path_end; + Sequence a_seq; + vector a_path; +*/ + +void +ConnView::draw_sequence_stuff() +{ + int i2, i3, y_loc, y_offset, x_loc, x_start, x_end, mv_offset; + list::iterator annot_i; + string species_name, seq_length; + stringstream raw_length; + + + // draw sequence representation lines + fl_font(FL_COURIER, 14); + //fl_color(FL_BLACK); + fl_color(100,100,100); + // normally size 7, adjust for various screenshotage + fl_line_style(FL_SOLID, 11, NULL); + y_loc = y()+y_pad; + y_offset = 5; + for(i2 = 0; i2 < seq_num; i2++) + { + if (i2 == seq_num - 1) + y_offset = -10; + x_loc = (int)(seq_lens[i2] / x_scale_factor) + x(); + //report_float("seq scaled len", x_loc); + fl_line(x(),y_loc,x_loc,y_loc); + + species_name = (*S)[i2].species; + fl_draw(species_name.c_str(), x()+w()-name_pad+5, y_loc+y_offset); + + // funkiness to figure out which genomic scale to report size in + if (seq_scales[i2] == 1) + raw_length << setprecision(3) << seq_lens[i2] << " bp"; + else if (seq_scales[i2] == 2) + raw_length << setprecision(3) << seq_lens[i2] / 1000.0 << " Kb"; + else if (seq_scales[i2] == 3) + raw_length << setprecision(3) << seq_lens[i2] /1000000.0<< " Mb"; + seq_length = raw_length.str(); + fl_draw(seq_length.c_str(), x()+w()-name_pad+5, y_loc+y_offset+15); + raw_length.str(""); + + y_loc += y_seq_incre; + } + + //fl_line(x(),y()+y_pad/2,w()-name_pad,y()+y_pad/2); + //fl_line(x(),y()+h()-y_pad/2,w()-name_pad,y()+h()-y_pad/2); + + // draw annotations + vector::iterator annot_type_i; + + fl_color(FL_GREEN); + fl_line_style(FL_SOLID, 3, NULL); + y_loc = y()+y_pad; + for(i2 = 0; i2 < seq_num; i2++) + { + // loop thru all annotation entries + for(annot_i = (*S)[i2].annots.begin(); annot_i != (*S)[i2].annots.end(); ++annot_i) + { + fl_line_style(FL_SOLID, 7, NULL); + mv_offset = 0; + + // loop thru annotation types to determine color + annot_type_i = some_annots.begin(); + bool type_unfound = true; + while ((annot_type_i != some_annots.end()) && type_unfound) + { + if (annot_i->type == annot_type_i->type) + { + fl_color(annot_type_i->color); + type_unfound = false; + } + else + fl_color(FL_GREEN); + ++annot_type_i; + } + + // calculate scaled start and end, and draw + x_start = (int)(annot_i->start / x_scale_factor) + x(); + x_end = (int)(annot_i->end / x_scale_factor) + x(); + fl_line(x_start,y_loc+mv_offset,x_end,y_loc+mv_offset); + } + y_loc += y_seq_incre; + } + + + // draw motifs found + vector::iterator motif_i; + vector some_motif_locs; + vector::iterator i_locs; + int scale_len, motif_len; + + fl_color(255,0,255); + fl_line_style(FL_SOLID, 9, NULL); + motif_i = some_motifs.begin(); + while (motif_i != some_motifs.end()) + { + fl_color(motif_i->color); + motif_len = motif_i->seq.length(); + scale_len = (int) (motif_len / x_scale_factor); + if (scale_len == 0) + scale_len = 1; + y_loc = y()+y_pad; + if (!motif_i->locations.empty()) + for(i2 = 0; i2 < seq_num; i2++) + { + some_motif_locs = (*motif_i).locations[i2]; + + i_locs = some_motif_locs.begin(); + while (i_locs != some_motif_locs.end()) + { + x_start = (int)(*i_locs / x_scale_factor) + x(); + fl_line(x_start,y_loc,x_start+scale_len,y_loc); + ++i_locs; + } + y_loc += y_seq_incre; + } + ++motif_i; + } +} + + +void +ConnView::resize(int new_x, int new_y, int new_w, int new_h) +{ + + x(new_x); + y(new_y); + w(new_w); + h(new_h); + + x_scale_factor = (float) max_seq_len / (w() - name_pad); + cout << "scale factor is " << x_scale_factor << endl; + y_seq_incre = (h()-(2*y_pad)) / (seq_num - 1); + + scale_paths(); +} + + +void +ConnView::reporter(string var, int value) +{ + cout << var << " : " << value << endl; +} + + +void +ConnView::report_float(string var, float value) +{ + cout << var << " : " << value << endl; +} + +int +ConnView::handle(int e) +{ + int return_value; + float y_calc_tmp; + + // this empty string needs to be put on cout, otherwise the -O optimize + // compile option seems to throw this function away with the following: + // gcc version 3.2.2 20030222 (Red Hat Linux 3.2.2-5) + cout << ""; + + // why do I need a -O for this module? Well, originally I just used the + // same compile flags for all modules. I changed that. However, on debian + // systems I need the -O otherwise the behavior I observe on redhat machines + // with above compiler happens if I don't have that empty cout. WTF + + switch(e) + { + case FL_PUSH: + if (Fl::event_button3()) + { + spawnSeq(); + return_value = 1; + } + else if (Fl::event_button2()) + { + find_motifs(); + return_value = 1; + } + break; + case FL_DRAG: + if (!dragging) + { + drag_start = Fl::event_x(); + y_drag_start = (float) Fl::event_y(); + ref_seq_num = (int) (round ( (y_drag_start/y_seq_incre) ) ); + dragging = true; + selected = false; + return_value = 1; + } + fl_line_style(FL_SOLID, 1, NULL); + fl_overlay_rect(drag_start, (ref_seq_num*y_seq_incre)+y(), + Fl::event_x()-drag_start, 16); + + break; + case FL_RELEASE: + if (dragging) + { + drag_end = Fl::event_x(); + dragging = false; + selected = true; + redraw(); + return_value = 1; + } + break; + default: + return_value = Fl_Widget::handle(e); + } + + return return_value; +} + + + +void +ConnView::check_new_motifs() +{ + vector::iterator i; + int i2; + vector some_motif_locs; + vector::iterator i_locs; + + i = some_motifs.begin(); + while (i != some_motifs.end()) + { + if (i->dirty) + { + cout << i->seq << " is new\n"; + i->locations.clear(); + //i_locs = i->locations; + for(i2 = 0; i2 < seq_num; i2++) + { + some_motif_locs = (*S)[i2].find_motif(i->seq); + (*i).locations.push_back(some_motif_locs); + + + i_locs = some_motif_locs.begin(); + while (i_locs != some_motif_locs.end()) + { + cout << *i_locs << " "; + ++i_locs; + } + cout << endl; + + } + + i->dirty = false; + } + ++i; + } +} + + +void +ConnView::spawnSeq() +{ + list > selected_paths; + list >::iterator pathz_i; + int i2, i3, y_loc, x_loc, x_start, x_end; + vector a_path; + list::iterator highlight_i; + int y_max; + string window_name; + + + if (selected) + { + // make new list of connections that are highlighted + selected_paths.clear(); + highlight_i = highlight.begin(); + for(pathz_i = P->refined_pathz.begin(); pathz_i != P->refined_pathz.end(); ++pathz_i) + { + if (*highlight_i) + { + a_path = *pathz_i; + selected_paths.push_back(a_path); + } + ++highlight_i; + } + + // give 50 pixels of height per sequence + y_max = seq_num * 50; + window_name = "Mussa Sequence: " + ana_name; + + a_seq_win = new SeqWindow(800, y_max, (const char*) window_name.c_str(), + seq_num, + S, selected_paths, seq_lens, &some_motifs); + } +} + + +void +ConnView::find_motifs() +{ + motif_find_window = new MotifWindow(300, 300, "Motifs", &some_motifs); +} + +void +ConnView::annot_win() +{ + annot_color_window = new AnnotWindow(300, 300, "Annotations", &some_annots); +} + +// @!@! special hacked in color coding for the myf5/6 region annots + +/* + if (annot_i->type == "mvista") + { + fl_color(255,230,0); + fl_line_style(FL_SOLID, 8, NULL); + mv_offset = -4; + } + else if (annot_i->type == "reg") + { + fl_line_style(FL_SOLID, 10, NULL); + mv_offset = -8; + + if (annot_i->name == "CNS") + fl_color(255,150,0); + else if (annot_i->name == "ELA") + fl_color(0,200,120); + else if (annot_i->name == "ES") + fl_color(0,200,200); + else if (annot_i->name == "NA") + fl_color(120,120,120); + else if (annot_i->name == "EA") + { + fl_line_style(FL_SOLID, 7, NULL); + mv_offset = -13; + fl_color(0,200,120); + } + else if (annot_i->name == "VS") + { + fl_line_style(FL_SOLID, 7, NULL); + mv_offset = -6; + fl_color(255,255,0); + } + else if (annot_i->name == "SP") + { + fl_line_style(FL_SOLID, 7, NULL); + mv_offset = -13; + fl_color(255,230,150); + } + else if (annot_i->name == "L") + { + fl_line_style(FL_SOLID, 7, NULL); + mv_offset = -6; + fl_color(0,0,100); + } + else if (annot_i->name == "TCM") + fl_color(0,130,230); + } +*/ diff --git a/gui/ConnView.hh b/gui/ConnView.hh new file mode 100644 index 0000000..cf28ff7 --- /dev/null +++ b/gui/ConnView.hh @@ -0,0 +1,95 @@ +#ifndef _MUSSA_GUI_CONN_VIEW_H_ +#define _MUSSA_GUI_CONN_VIEW_H_ +// This file is part of the Mussa source distribution. +// http://mussa.caltech.edu/ +// Contact author: Tristan De Buysscher, tristan@caltech.edu + +// This program and all associated source code files are Copyright (C) 2005 +// the California Institute of Technology, Pasadena, CA, 91125 USA. It is +// under the GNU Public License; please see the included LICENSE.txt +// file for more information, or contact Tristan directly. + +#include +#include +#include +#include + +#include "sequence.hh" +#include "SeqView.hh" +#include "SeqWindow.hh" +#include "MotifWindow.hh" +#include "AnnotWindow.hh" // aparently for annot_color +#include "mussa_nway.hh" + +#include + +class Nway_Paths; +class ConnView : public Fl_Box +{ + public: + ConnView(int x_top,int y_top,int x_bot,int y_bot) : + Fl_Box(x_top,y_top,x_bot,y_bot) + {} + + void setup(std::string name, int sq_num, int win_len, + std::vector *, Nway_Paths *); + void scale_paths(); + + void spawnSeq(); + void find_motifs(); + void annot_win(); + + void toggle_bars(); + void set_bar_interval(int new_bar_len); + void toggle_lines(); + void set_line_interval(int new_line_len); + + + private: + std::string ana_name; + int seq_num, window, threshold; + bool win_append, thres_append; + + //this data is passed as pointers to the instantiated classes + std::vector *S; + Nway_Paths *P; + + int name_pad, y_pad; + float x_scale_factor; + int y_seq_incre; + int drag_start, drag_end; + float y_drag_start; + int ref_seq_num, max_seq_len; + bool dragging, selected; + std::list highlight; + + //path data scaled for current view size + std::list > scaled_pathz; + std::vector seq_lens; + std::vector seq_scales; + int bar_interval, line_interval; + bool show_bars, show_lines; + + //keeps track of all the motifs the user has inputed + std::vector some_motifs; + MotifWindow *motif_find_window; + + //keeps track of the colors assigned to each motif type + std::vector some_annots; + AnnotWindow *annot_color_window; + + SeqWindow *a_seq_win; + + void draw(); + void draw_paths(); + void draw_sequence_stuff(); + + void resize(int x, int y, int w, int h); + int handle(int e); + void check_new_motifs(); + + //for drawing function debugging + void reporter(std::string var, int value); + void report_float(std::string var, float value); +}; +#endif diff --git a/gui/ConnWindow.cxx b/gui/ConnWindow.cxx new file mode 100644 index 0000000..6a99cdc --- /dev/null +++ b/gui/ConnWindow.cxx @@ -0,0 +1,420 @@ +// This file is part of the Mussa source distribution. +// http://mussa.caltech.edu/ +// Contact author: Tristan De Buysscher, tristan@caltech.edu + +// This program and all associated source code files are Copyright (C) 2005 +// the California Institute of Technology, Pasadena, CA, 91125 USA. It is +// under the GNU Public License; please see the included LICENSE.txt +// file for more information, or contact Tristan directly. + + +#include "ConnWindow.hh" + +#include +using namespace std; + +void +load_ana_cb(Fl_Button* o, void* v) +{ + ConnWindow* T=(ConnWindow*)v; + T->real_load_ana_cb(); +} + + +void +ConnWindow::real_load_ana_cb() +{ + char *picked_file; + string a_file_path; + string err_msg; + + cout << "Load! Load! Load, ye yellow-bellied seadogs!\n"; + //picked_file = fl_file_chooser("Find an Analysis", "", "", 1); + picked_file = fl_dir_chooser("Find an Analysis", "", 1); + if (picked_file != NULL) + { + a_file_path = picked_file; + cout << "doo wah diddy diddy dum diddy doo\n"; + cout << a_file_path << endl; + + // load the analysis + an_analysis = new Mussa(); + err_msg = an_analysis->load(a_file_path); + //.substr(0,a_file_path.find(".mu"))); + + if (err_msg == "") + { + // relabel window with the analysis name + window_name = "Mussa: " + an_analysis->ana_name; + label((const char*)window_name.c_str()); + // show the user the analysis + conn_box->setup(an_analysis->ana_name, an_analysis->seq_num, + an_analysis->window, &(an_analysis->the_Seqs), + &(an_analysis->the_paths)); + conn_box->scale_paths(); + } + else + { + fl_alert(err_msg.c_str()); + cout << err_msg << endl; + } + } +} + + +void +do_ana_cb(Fl_Button* o, void* v) +{ + ConnWindow* T=(ConnWindow*)v; + T->real_do_ana_cb(); +} + + +void +ConnWindow::real_do_ana_cb() +{ + char *picked_file; + string a_file_path; + string err_msg; + + picked_file = fl_file_chooser("Analysis Config File", "", "", 1); + if (picked_file != NULL) + { + a_file_path = picked_file; + + an_analysis = new Mussa(); + err_msg = an_analysis->load_mupa_file(a_file_path); + + if (err_msg == "") + { + err_msg = an_analysis->analyze(0, 0, 't', 0.0); + } + + if (err_msg == "") + { + // relabel window with the analysis name + window_name = "Mussa: " + an_analysis->ana_name; + label((const char*)window_name.c_str()); + // show the user the analysis + conn_box->setup(an_analysis->ana_name, an_analysis->seq_num, + an_analysis->window, &(an_analysis->the_Seqs), + &(an_analysis->the_paths)); + conn_box->scale_paths(); + } + else + { + fl_alert(err_msg.c_str()); + cout << err_msg; + } + } +} + + +void +setup_ana_cb(Fl_Button* o, void* v) +{ + ConnWindow* T=(ConnWindow*)v; + T->real_setup_ana_cb(); +} + +void +ConnWindow::real_setup_ana_cb() +{ + an_analysis = new Mussa(); + setup_win = new SetupWindow(650,700,"Analysis Setup", an_analysis); + + while(setup_win->visible()) + Fl::wait(.1); + cout << "Like a warm summer day\n"; + + if (setup_win->done()) + { + // relabel window with the analysis name + window_name = "Mussa: " + an_analysis->ana_name; + label((const char*)window_name.c_str()); + // is it this easy? what if setup window encounters an error...?? + conn_box->setup(an_analysis->ana_name, an_analysis->seq_num, + an_analysis->window, &(an_analysis->the_Seqs), + &(an_analysis->the_paths)); + + conn_box->scale_paths(); + } +} + + +void +subana_cb(Fl_Button* o, void* v) +{ + ConnWindow* T=(ConnWindow*)v; + T->real_subana_cb(); +} + +void +ConnWindow::real_subana_cb() +{ + string subana_name; + + sub_analysis = new Mussa(); + subana_win = new SubAnalysisWindow(500,400,"Sub Analysis Setup", sub_analysis, + an_analysis->the_Seqs); + + while(subana_win->visible()) + Fl::wait(.1); + cout << "Like a warm summer day\n"; + + if (subana_win->done()) + { + subana_name = "SubMussa: " + sub_analysis->ana_name; + sub_conn_win = new ConnWindow(w(), h(), (const char*) subana_name.c_str()); + cout << "Like a warm day in may\n"; + sub_conn_win->add_ana(sub_analysis); + //Fl::visual(FL_DOUBLE|FL_INDEX); + //sub_conn_box->show(); + } +} + + +void +seq_show_cb(Fl_Button* o, void* v) +{ + ConnWindow* T=(ConnWindow*)v; + T->real_seq_show_cb(); +} + +void +ConnWindow::real_seq_show_cb() +{ + show_seq_win = new SeqTextWindow(500,400,"Seq Show", an_analysis->the_Seqs); +} + +void +seq_win_spawn_cb(Fl_Button* o, void* v) +{ + ConnWindow* T=(ConnWindow*)v; + T->real_seq_win_spawn_cb(); +} + +void +ConnWindow::real_seq_win_spawn_cb() +{ + conn_box->spawnSeq(); +} + +void +motif_find_cb(Fl_Button* o, void* v) +{ + ConnWindow* T=(ConnWindow*)v; + T->real_motif_find_cb(); +} + +void +ConnWindow::real_motif_find_cb() +{ + conn_box->find_motifs(); +} + +void +annot_win_cb(Fl_Button* o, void* v) +{ + ConnWindow* T=(ConnWindow*)v; + T->real_annot_win_cb(); +} + +void +ConnWindow::real_annot_win_cb() +{ + conn_box->annot_win(); +} + + +// all the crap needed for dealing with the scale bars +void +toggle_scale_bars_cb(Fl_Button* o, void* v) +{ + ConnWindow* T=(ConnWindow*)v; + T->real_toggle_bars_cb(); +} + +void +ConnWindow::real_toggle_bars_cb() +{ + conn_box->toggle_bars(); +} + +void +set_bar_len_cb(Fl_Input* o, void* v) +{ + ConnWindow* T=(ConnWindow*)v; + cout << "WAAAAAAAAA\n"; + T->real_set_bar_len_cb(o); +} + +void +ConnWindow::real_set_bar_len_cb(Fl_Input* o) +{ + int new_bar_len; + + new_bar_len = atoi(o->value()); + cout << "new bar len = " << new_bar_len << endl; + conn_box->set_bar_interval(new_bar_len); +} + + +// all the crap needed for dealing with the scale lines +void +toggle_scale_lines_cb(Fl_Button* o, void* v) +{ + ConnWindow* T=(ConnWindow*)v; + T->real_toggle_lines_cb(); +} + +void +ConnWindow::real_toggle_lines_cb() +{ + conn_box->toggle_lines(); +} + +void +set_line_len_cb(Fl_Input* o, void* v) +{ + ConnWindow* T=(ConnWindow*)v; + cout << "WAAAAAAAAA\n"; + T->real_set_line_len_cb(o); +} + +void +ConnWindow::real_set_line_len_cb(Fl_Input* o) +{ + int new_line_len; + + new_line_len = atoi(o->value()); + cout << "new line len = " << new_line_len << endl; + conn_box->set_line_interval(new_line_len); +} + + +// setting new soft threshold + +void +set_soft_thres_cb(Fl_Input* o, void* v) +{ + ConnWindow* T=(ConnWindow*)v; + cout << "WAAAAAAAAA\n"; + T->real_set_soft_thres_cb(o); +} + +void +ConnWindow::real_set_soft_thres_cb(Fl_Input* o) +{ + int new_soft_thres; + + new_soft_thres = atoi(o->value()); + cout << "new soft thres = " << new_soft_thres << endl; + + an_analysis->set_soft_thres(new_soft_thres); + an_analysis->set_ana_mode('t'); + an_analysis->nway(); + conn_box->scale_paths(); + conn_box->redraw(); + + // hacked in stuff to save muway files at different thresholds + string save_path; + ostringstream append_info; + + save_path = an_analysis->ana_name + "/" + + an_analysis->ana_name.substr(0,an_analysis->ana_name.find("_t")); + append_info.str(""); + append_info << "_t" << new_soft_thres << ".muway"; + //<< "_w" << an_analysis->window + save_path += append_info.str(); + cout << "saving as: " << save_path << endl; + an_analysis->save_muway(save_path); +} + + + + +ConnWindow::ConnWindow(int w, int h, const char* title): + Fl_Double_Window(w,h,title) +{ + int button_len = 120; + Fl_Color a_color = fl_rgb_color(150, 200, 255); + + padding = 5; + + begin(); + //fl_color(150,200,255); + color(FL_WHITE); + resizable(this); + + + // create file menu button + file_menu = new Fl_Menu_Button(padding, 2, button_len, 30, "Analysis"); + file_menu->color(FL_WHITE,a_color); + file_menu->box(FL_BORDER_BOX); + file_menu->clear(); + + // add menu items + file_menu->add("Do Analysis", 0, (Fl_Callback *) do_ana_cb, this); + file_menu->add("Load Analysis", 0, (Fl_Callback *) load_ana_cb, this); + file_menu->add("Setup Analysis", 0, (Fl_Callback *) setup_ana_cb, this); + file_menu->add("Sub Analysis", 0, (Fl_Callback *) subana_cb, this); + + + view_menu = new Fl_Menu_Button(padding+button_len,2, button_len, 30, "View"); + view_menu->color(FL_WHITE,a_color); + view_menu->box(FL_BORDER_BOX); + view_menu->clear(); + view_menu->add("Sequence Zoom", 0, (Fl_Callback*) seq_win_spawn_cb, this); + view_menu->add("Motif Finder", 0, (Fl_Callback*) motif_find_cb, this); + view_menu->add("Annotations", 0, (Fl_Callback*) annot_win_cb, this); + view_menu->add("Copy Seq", 0, (Fl_Callback*) seq_show_cb, this); + view_menu->add("Toggle Bars", 0, (Fl_Callback*) toggle_scale_bars_cb, this, + FL_MENU_TOGGLE|FL_MENU_VALUE); + view_menu->add("Toggle Lines", 0, (Fl_Callback*) toggle_scale_lines_cb, this, + FL_MENU_TOGGLE|FL_MENU_VALUE); + + bar_input = new Fl_Input(padding+3*button_len, 2, button_len, 30, "Bar Length (bp)"); + bar_input->value(""); + bar_input->when(FL_WHEN_ENTER_KEY); + bar_input->callback((Fl_Callback*)set_bar_len_cb, this); + + line_input = new Fl_Input(padding+5*button_len, 2, button_len, 30, "Line Interval (bp)"); + line_input->value(""); + line_input->when(FL_WHEN_ENTER_KEY); + line_input->callback((Fl_Callback*)set_line_len_cb, this); + + + thres_input = new Fl_Input(padding+7*button_len, 2, button_len, 30, "Threshold"); + thres_input->value(""); + thres_input->when(FL_WHEN_ENTER_KEY); + thres_input->callback((Fl_Callback*)set_soft_thres_cb, this); + + + // create the connections box + conn_box = new ConnView(padding, padding + 30, w-2*padding, h-2*padding-30); + //conn_box = new ConnView(padding, padding, w-2*padding, h-2*padding); + + end(); + show(); +} + + +ConnWindow::~ConnWindow() +{} + + +void +ConnWindow::add_ana(Mussa *the_ana) +{ + an_analysis = the_ana; + + // relabel window with the analysis name + window_name = "Mussa: " + an_analysis->ana_name; + label((const char*)window_name.c_str()); + + conn_box->setup(an_analysis->ana_name, an_analysis->seq_num, + an_analysis->window, &(an_analysis->the_Seqs), + &(an_analysis->the_paths)); + conn_box->scale_paths(); +} diff --git a/gui/ConnWindow.hh b/gui/ConnWindow.hh new file mode 100644 index 0000000..35c9e05 --- /dev/null +++ b/gui/ConnWindow.hh @@ -0,0 +1,67 @@ +#ifndef _MUSSA_GUI_CONN_WINDOW_H_ +#define _MUSSA_GUI_CONN_WINDOW_H_ + +// This file is part of the Mussa source distribution. +// http://mussa.caltech.edu/ +// Contact author: Tristan De Buysscher, tristan@caltech.edu + +// This program and all associated source code files are Copyright (C) 2005 +// the California Institute of Technology, Pasadena, CA, 91125 USA. It is +// under the GNU Public License; please see the included LICENSE.txt +// file for more information, or contact Tristan directly. + +#include + +#include +#include +#include + +#include "ConnView.hh" +#include "SetupWindow.hh" +#include "SubAnalysisWindow.hh" +#include "SeqTextWindow.hh" + +//! Window for showing the lines connecting the various sequences together +class ConnWindow : public Fl_Double_Window +{ + private: + Mussa *an_analysis, *sub_analysis; + ConnWindow *sub_conn_win; + + Fl_Menu_Button *file_menu; + Fl_Menu_Button *view_menu; + Fl_Menu_Bar *menu_bar; + Fl_Input *bar_input; + Fl_Input *line_input; + Fl_Input *thres_input; + ConnView *conn_box; + SetupWindow *setup_win; + SubAnalysisWindow *subana_win; + SeqTextWindow *show_seq_win; + int padding, name_pad; + std::string window_name; + + public: + ConnWindow(int w, int h, const char* title); + ~ConnWindow(); + void add_ana(Mussa *the_ana); + + void real_load_ana_cb(); + void real_do_ana_cb(); + void real_setup_ana_cb(); + void real_subana_cb(); + void real_resthres(); + void real_seq_show_cb(); + + void real_seq_win_spawn_cb(); + void real_motif_find_cb(); + void real_annot_win_cb(); + + void real_toggle_bars_cb(); + void real_set_bar_len_cb(Fl_Input* o); + void real_toggle_lines_cb(); + void real_set_line_len_cb(Fl_Input* o); + void real_set_soft_thres_cb(Fl_Input* o); +}; + +#endif diff --git a/gui/MotifWindow.cxx b/gui/MotifWindow.cxx new file mode 100644 index 0000000..7667ec1 --- /dev/null +++ b/gui/MotifWindow.cxx @@ -0,0 +1,191 @@ +// This file is part of the Mussa source distribution. +// http://mussa.caltech.edu/ +// Contact author: Tristan De Buysscher, tristan@caltech.edu + +// This program and all associated source code files are Copyright (C) 2005 +// the California Institute of Technology, Pasadena, CA, 91125 USA. It is +// under the GNU Public License; please see the included LICENSE.txt +// file for more information, or contact Tristan directly. + + +#include "MotifWindow.hh" + +#include + +#include + +using namespace std; + +motif +new_blank_motif() +{ + motif *a_motif; + + a_motif = new motif; + a_motif->name = ""; + a_motif->seq = ""; + a_motif->color = (Fl_Color) 5; + a_motif->locations.clear(); + a_motif->dirty = false; + + cout << "name: " << a_motif->name << " seq: " << a_motif->seq << endl; + + return *a_motif; +} + + +void +cb_motif_in(Fl_Input* o, void* v) +{ + motif_instance * blah = (motif_instance *) v; + MotifWindow* T= blah->mw_ptr; + T->cb_motif_in_i(o,blah->index); +} + + +void +cb_motif_color(Fl_Button* o, void* v) +{ + motif_instance * blah = (motif_instance *) v; + MotifWindow* T= blah->mw_ptr; + T->cb_motif_color_i(o,blah->index); +} + + +MotifWindow::MotifWindow(int w, int h, const char* title, + vector * some_motifs):Fl_Window(w,h,title) +{ + int i; + + the_motifs = some_motifs; + motif_count = 0; + + motif_color_buttons.clear(); + + begin(); + motif_input_pack = new Fl_Pack(0, 0, w, h); + motif_input_pack->spacing(4); + + // button to add new motif inputs + add_motif = new Fl_Button(0,0,100,24,"Add Motif Slot"); + add_motif->callback((Fl_Callback*)add_motif_cb, this); + motif_input_pack->add(add_motif); + // test button to make sure motif data is being stored + test = new Fl_Button(0,0,100,24,"show motifs"); + test->callback((Fl_Callback*)print_cb, this); + motif_input_pack->add(test); + // creat an initial set of motif input widgets and attach to motif vector + for (i = 0; i < 5; i++) + { + add_motif_input(i); + motif_count++; + } + + + + + add(motif_input_pack); + + end(); + resizable(this); + show(); +} + + //tmp_input->user_data((void*) i); + +MotifWindow::~MotifWindow(){} + +void +MotifWindow::add_motif_input(int index) +{ + Fl_Input * new_input; + Fl_Button *new_color_button; + motif_instance * something; + Fl_Pack * motif_hor_pack; + + + something = new motif_instance; + something->mw_ptr = this; + something->index = index; + + motif_hor_pack = new Fl_Pack(0, 0, w(), 24); + motif_hor_pack->type(Fl_Pack::HORIZONTAL); + motif_hor_pack->spacing(4); + + // setup the color display/selection button + new_color_button = new Fl_Button(0, 0, 24, 24, ""); + new_color_button->color((*the_motifs)[index].color); + new_color_button->box(FL_FLAT_BOX); + new_color_button->callback((Fl_Callback*)cb_motif_color, (void*) something); + motif_color_buttons.push_back(new_color_button); + motif_hor_pack->add(new_color_button); + + + // setup the motif inputs + new_input = new Fl_Input(0, 0, 200, 24, ""); + new_input->value( ((*the_motifs)[index].seq).c_str() ); + new_input->callback((Fl_Callback*)cb_motif_in, (void*) something); + motif_ins.push_back(new_input); + motif_hor_pack->add(new_input); + + motif_input_pack->add(motif_hor_pack); +} +/* + cout << "fee\n"; + cout << "fie\n"; + cout << "foe\n"; + cout << "fum\n"; +*/ + +void +MotifWindow::cb_motif_in_i(Fl_Input* o, int i) +{ + (*the_motifs)[i].seq = o->value(); + (*the_motifs)[i].dirty = true; +} + +void +MotifWindow::cb_motif_color_i(Fl_Button* o, int i) +{ + //Fl_Color new_color; + + (*the_motifs)[i].color = fl_show_colormap((*the_motifs)[i].color); + //motif_color_buttons[i]-> + o->color((*the_motifs)[i].color); + redraw(); +} + +void MotifWindow::add_motif_cb(Fl_Button* o, void* v) +{ + MotifWindow* T=(MotifWindow*)v; + T->add_motif_cb_real(o,v); +} + + +void MotifWindow::add_motif_cb_real(Fl_Button* , void*) +{ + motif blank_motif; + + //blank_motif.name = ""; + //blank_motif.seq = ""; + blank_motif = new_blank_motif(); + (*the_motifs).push_back(blank_motif); + add_motif_input(motif_count++); + redraw(); +} + + +void MotifWindow::print_cb(Fl_Button* o, void* v) +{ + MotifWindow* T=(MotifWindow*)v; + T->print_cb_real(o,v); +} + + +void MotifWindow::print_cb_real(Fl_Button* , void*) +{ + int i; + + for (i = 0; i < motif_count; i++) + cout << (*the_motifs)[i].seq << endl; +} diff --git a/gui/MotifWindow.hh b/gui/MotifWindow.hh new file mode 100644 index 0000000..5c16594 --- /dev/null +++ b/gui/MotifWindow.hh @@ -0,0 +1,72 @@ +#ifndef _MUSSA_GUI_MOTIF_WINDOW_H_ +#define _MUSSA_GUI_MOTIF_WINDOW_H_ +// This file is part of the Mussa source distribution. +// http://mussa.caltech.edu/ +// Contact author: Tristan De Buysscher, tristan@caltech.edu + +// This program and all associated source code files are Copyright (C) 2005 +// the California Institute of Technology, Pasadena, CA, 91125 USA. It is +// under the GNU Public License; please see the included LICENSE.txt +// file for more information, or contact Tristan directly. + +#include +#include +#include + +#include +#include + +#include +#include + +#include "mussa_class.hh" + +struct motif +{ + std::string name, seq; + Fl_Color color; + std::vector > locations; + bool dirty; +}; + +//typedef motif_ptr *motif; + + +class MotifWindow : public Fl_Window +{ + public: + MotifWindow(int w, int h, const char* title, std::vector * some_motifs); + ~MotifWindow(); + Fl_Pack * motif_input_pack; + std::list motif_ins; + std::vector motif_color_buttons; + std::list name_ins; + Fl_Button* test; + Fl_Button* add_motif; + + void cb_motif_in_i(Fl_Input*, int i); + void cb_motif_color_i(Fl_Button* o, int i); + + private: + std::vector * the_motifs; + int motif_count; + + void add_motif_input(int index); + + static void add_motif_cb(Fl_Button*, void*); + inline void add_motif_cb_real(Fl_Button*, void*); + + static void print_cb(Fl_Button*, void*); + inline void print_cb_real(Fl_Button*, void*); +}; + +// crazy whacked shite Titus taught me to do to get an index value associated +// with each instance of an input associated with the callback... +struct motif_instance +{ + MotifWindow * mw_ptr; + int index; +}; + +motif new_blank_motif(); +#endif diff --git a/gui/SeqTextWindow.cxx b/gui/SeqTextWindow.cxx new file mode 100644 index 0000000..4f1d059 --- /dev/null +++ b/gui/SeqTextWindow.cxx @@ -0,0 +1,146 @@ +// This file is part of the Mussa source distribution. +// http://mussa.caltech.edu/ +// Contact author: Tristan De Buysscher, tristan@caltech.edu + +// This program and all associated source code files are Copyright (C) 2005 +// the California Institute of Technology, Pasadena, CA, 91125 USA. It is +// under the GNU Public License; please see the included LICENSE.txt +// file for more information, or contact Tristan directly. + + +#include "SeqTextWindow.hh" + +#include +using namespace std; +void +get_seq_cb(Fl_Button* o, void* v) +{ + SeqTextWindow* T=(SeqTextWindow*)v; + T->real_get_seq_cb(); +} + +void +SeqTextWindow::real_get_seq_cb() +{ + string sub_seq_formatted; + int seq_len, i, line_len; + + + cout << "length = " << seq_end-seq_start << endl; + + // make sure inputed values within valid ranges + if ((seq_end > seq_start) && (seq_id > -1) && (seq_id < the_Seqs.size()) ) + { + sub_sequence = the_Seqs[seq_id].subseq(seq_start, seq_end-seq_start); + + sub_seq_formatted = ""; + seq_len = sub_sequence.size(); + line_len = 40; + for (i = 0; i < seq_len; i += line_len) + { + sub_seq_formatted.append(sub_sequence.substr(i,line_len)); + sub_seq_formatted.append("\n"); + } + + seq_display->value((const char *)sub_seq_formatted.c_str()); + } +} + + +// *** input seq index id + +void +set_seq_id_cb(Fl_Input* o, void* v) +{ + SeqTextWindow* T=(SeqTextWindow*)v; + T->real_set_seq_id_cb(o); +} + +void +SeqTextWindow::real_set_seq_id_cb(Fl_Input* o) +{ + seq_id = atoi(o->value()) - 1; // -1 since arrays start at 0 +} + + +// *** input seq start index + +void +set_seq_start_cb(Fl_Input* o, void* v) +{ + SeqTextWindow* T=(SeqTextWindow*)v; + T->real_set_seq_start_cb(o); +} + +void +SeqTextWindow::real_set_seq_start_cb(Fl_Input* o) +{ + seq_start = atoi(o->value()); +} + +// *** input seq end index + +void +set_seq_end_cb(Fl_Input* o, void* v) +{ + SeqTextWindow* T=(SeqTextWindow*)v; + T->real_set_seq_end_cb(o); +} + +void +SeqTextWindow::real_set_seq_end_cb(Fl_Input* o) +{ + seq_end = atoi(o->value()); +} + + +SeqTextWindow::SeqTextWindow(int w, int h, const char* title, + vector some_Seqs):Fl_Window(w,h,title) +{ + string a_name; + color(FL_WHITE); + the_Seqs = some_Seqs; + + + seq_id = -1; + seq_start = 1000000; + seq_end = -1000000; + + begin(); + + seq_id_input = new Fl_Input(80,10,30,30, "Seq num: "); + seq_id_input->value(""); + seq_id_input->callback((Fl_Callback*)set_seq_id_cb, this); + + seq_start_input = new Fl_Input(160,10,100,30, " start: "); + seq_start_input->value(""); + seq_start_input->callback((Fl_Callback*)set_seq_start_cb, this); + + seq_end_input = new Fl_Input(310,10,100,30, "end: "); + seq_end_input->value(""); + seq_end_input->callback((Fl_Callback*)set_seq_end_cb, this); + + seq_display = new Fl_Multiline_Output(10, 50, w-20, h-60, ""); + seq_display->value(""); + + //seq_display2 = new Fl_Text_Display(10,100, w-20, h-110,""); + + // button to get the sequence + get_seq_but = new Fl_Button(w-80,10,80,30,"Get Seq"); + get_seq_but->callback((Fl_Callback*)get_seq_cb, this); + + + end(); + //resizable(this); + show(); +} + + +SeqTextWindow::~SeqTextWindow(){} + +/* + cout << "fee\n"; + cout << "fie\n"; + cout << "foe\n"; + cout << "fum\n"; +*/ diff --git a/gui/SeqTextWindow.hh b/gui/SeqTextWindow.hh new file mode 100644 index 0000000..0000ec8 --- /dev/null +++ b/gui/SeqTextWindow.hh @@ -0,0 +1,51 @@ +#ifndef _MUSSA_GUI_SEQ_TEXT_H_ +#define _MUSSA_GUI_SEQ_TEXT_H_ +// This file is part of the Mussa source distribution. +// http://mussa.caltech.edu/ +// Contact author: Tristan De Buysscher, tristan@caltech.edu + +// This program and all associated source code files are Copyright (C) 2005 +// the California Institute of Technology, Pasadena, CA, 91125 USA. It is +// under the GNU Public License; please see the included LICENSE.txt +// file for more information, or contact Tristan directly. + +#include +#include + +#include +#include +#include +#include +#include +#include + +#include "sequence.hh" + +class SeqTextWindow : public Fl_Window +{ + public: + SeqTextWindow(int w, int h, const char* title, std::vector some_Seqs); + ~SeqTextWindow(); + + Fl_Button* get_seq_but; + Fl_Multiline_Output* seq_display; + Fl_Text_Buffer* seq_buffer; + Fl_Text_Display* seq_display2; + Fl_Input *seq_id_input; + Fl_Input *seq_start_input; + Fl_Input *seq_end_input; + + // callback receiver functions + + void real_get_seq_cb(); + void real_set_seq_id_cb(Fl_Input* o); + void real_set_seq_start_cb(Fl_Input* o); + void real_set_seq_end_cb(Fl_Input* o); + + private: + // sequence data + std::vector the_Seqs; + std::string sub_sequence; + int seq_id, seq_start, seq_end; +}; +#endif diff --git a/gui/SeqView.cxx b/gui/SeqView.cxx new file mode 100644 index 0000000..1d1b547 --- /dev/null +++ b/gui/SeqView.cxx @@ -0,0 +1,525 @@ +// This file is part of the Mussa source distribution. +// http://mussa.caltech.edu/ +// Contact author: Tristan De Buysscher, tristan@caltech.edu + +// This program and all associated source code files are Copyright (C) 2005 +// the California Institute of Technology, Pasadena, CA, 91125 USA. It is +// under the GNU Public License; please see the included LICENSE.txt +// file for more information, or contact Tristan directly. + + +#include "SeqView.hh" +#include +#include + +#include +#include + +using namespace std; + +void +SeqView::setup(string name, int sq_num, + vector *some_seqs, + list > some_paths, vector some_lens, + vector *some_motifs) +{ + int seq_i; + list >::iterator pathz_i; + + + ana_name = name; + seq_num = sq_num; + S = some_seqs; + P = some_paths; + seq_lens = some_lens; + the_motifs = some_motifs; + + y_seq_incre = (y_max-10-10) / (seq_num - 1); + + fl_font(FL_COURIER, 14); + cout << "font width: " << fl_width('A') << endl; + + index_pad = 6 * (int) fl_width('A') + 5; + + align_offsets(0); + + raw_sequence.clear(); + for(seq_i = 0; seq_i < seq_num; ++seq_i) + raw_sequence.push_back( (*S)[seq_i].seq() ); + + for(pathz_i = P.begin(); pathz_i != P.end(); ++pathz_i) + { + show_aligns.push_back(true); + } + + dragging = false; + scroll_offset = 0; + //scroll_pos = 0; + drag_change = 0; + + cout << "waaaaa!\n"; + cout << x() << " " << y() << " " << w() << " " << h() << endl; +} + +void +SeqView::resize(int new_x, int new_y, int new_w, int new_h) +{ + x(new_x); + y(new_y); + w(new_w); + h(new_h); + + // hmmm, why do I use these values on the the widgets inherent ones? + // I think there was a reason...once? + x_max = new_w; + y_max = new_h; + x_min = new_x; + y_min = new_y; + + // things that need to be recalculated + y_seq_incre = (y_max-10-10) / (seq_num - 1); +} + + + + +void +SeqView::draw() +{ + double ch_width; + + + // clear drawing area and set background to white + fl_color(FL_WHITE); + fl_rectf(x(), y(), w(), h()); + + + fl_font(FL_COURIER, 14); + //blatantly stolen from FR2 + ch_width = fl_width('A'); // monospaced: all characters are same width + + + if (show_bars) + { + int grey_box_num, grey_box_len; + int i; + // draw in some light grey boxes every 10bp to delineate for user + //fl_color(200,235,235); + fl_color(180,180,180); + grey_box_num = (((x_max - index_pad) / (int) ch_width) / 10) + 1; + grey_box_len = 10 * (int) ch_width; + for(i = 0; i < grey_box_num; i++) + if ((i % 2) != 0) + fl_rectf(x()+index_pad-1 + (i * grey_box_len), y(), grey_box_len, h()); + } + + if (show_motifs) + draw_motifs(ch_width); + + draw_sequence(ch_width); + + draw_match_lines(ch_width); + + draw_indices(ch_width); + + + // draw some bounding boxes to visually separate things + fl_color(150,200,255); + fl_line_style(FL_SOLID, 2, NULL); + fl_rect(x(), y(), w(), h()); + fl_rect(x()+index_pad-1, y(), w()-2*(index_pad-1), h()); +} + +void +SeqView::draw_motifs(double ch_width) +{ + vector::iterator motif_i; + vector some_motif_locs; + vector::iterator i_locs; + int scale_len, motif_len, i2; + int y_loc, x_start; + + //fl_color(255,0,255); + fl_line_style(FL_SOLID, 10, NULL); + motif_i = the_motifs->begin(); + while (motif_i != the_motifs->end()) + { + fl_color(motif_i->color); + motif_len = motif_i->seq.length(); + scale_len = (int) (motif_len * ch_width); + y_loc = y_min + 10; + if (!motif_i->locations.empty()) + for(i2 = 0; i2 < seq_num; i2++) + { + some_motif_locs = (*motif_i).locations[i2]; + + i_locs = some_motif_locs.begin(); + while (i_locs != some_motif_locs.end()) + { + x_start = (int) ((*i_locs +scroll_offset - seq_align_offsets[i2]) + * ch_width) + index_pad + x(); + + //cout << *i_locs << ":" << x_start << " "; + // don't draw highlights outside of box range, they can wraparound past some boundry + if ((x_start > 0) && (x_start < w())) + fl_line(x_start,y_loc,x_start+scale_len,y_loc); + ++i_locs; + } + //cout << endl; + y_loc += y_seq_incre; + } + ++motif_i; + } +} + +void +SeqView::draw_sequence(double ch_width) +{ + int i, seq_i, y_loc; + Sequence a_seq; + string sub_seq; + int seq_len, sub_seq_start, sub_seq_len; + + + + fl_color(FL_BLACK); + y_loc = y_min + 10 + 5; + + for(seq_i = 0; seq_i < seq_num; seq_i++) + { + seq_len = raw_sequence[seq_i].length(); + sub_seq_start = seq_align_offsets[seq_i] - scroll_offset; + sub_seq_len = (x_max - index_pad) / (int) ch_width; + //cout << x_max << " index_pad: " << index_pad << " y - ip: " << (x_max - index_pad) << endl; + + // gotta check thru boundary conditions to make sure we're producing the + // right string for the current position (otherwise gonna crash due to + // illegal indexing into substr + if (sub_seq_start < 0) + { + sub_seq_len = sub_seq_len - sub_seq_start; + if (sub_seq_len < 0) + sub_seq_len = 0; + sub_seq_start = 0; + } + else if (sub_seq_start >= seq_len) + { + sub_seq_start = seq_len; + sub_seq_len = 0; + } + else if ((sub_seq_start + sub_seq_len) >= seq_len) + sub_seq_len = seq_len - sub_seq_start; + + sub_seq = raw_sequence[seq_i].substr(sub_seq_start, sub_seq_len); + fl_draw(sub_seq.c_str(), index_pad, y_loc); + y_loc += y_seq_incre; + } +} + + +void +SeqView::draw_match_lines(double ch_width) +{ + int i, y_loc; + vector a_path; + list >::iterator pathz_i; + int i2, i3; + int x_start, y_start, x_end, y_end; + int window_length, win_i; + int rc_1 = 0; + int rc_2 = 0; + int offset1, offset2; + float center1, center2; + bool rc_color; + vector rc_list; + bool full_match; + vector matched; + int align_counter; + + + align_counter = 0; + for(pathz_i = P.begin(); pathz_i != P.end(); ++pathz_i) + { + if (show_aligns[align_counter]) + { + a_path = *pathz_i; + window_length = a_path[0]; + + // determine which parts of the path are RC relative to first species + rc_list.clear(); + for(i2 = 1; i2 <= seq_num; i2++) + { + if (a_path[i2] < 0) + rc_list.push_back(true); + else + rc_list.push_back(false); + } + + // loop over each bp in the conserved region for all sequences + for(win_i = 0; win_i < window_length; win_i++) + { + // determine which exact base pairs match between the sequences + full_match = true; + for(i2 = 1; i2 < seq_num; i2++) + { + // assume not rc as most likely, adjust below + rc_1 = 0; + rc_2 = 0; + // no matter the case, any RC node needs adjustments + if (a_path[i2] < 0) + rc_1 = window_length-1; + if (a_path[i2+1] < 0) + rc_2 = window_length-1; + + x_start = (abs(a_path[i2]-rc_1+win_i)); + x_end = (abs(a_path[i2+1]-rc_2+win_i)); + + // RC case handling + // ugh, and xor...only want rc coloring if just one of the nodes is rc + // if both nodes are rc, then they are 'normal' relative to each other + if ( ( rc_list[i2] || rc_list[i2-1] ) && + !(rc_list[i2] && rc_list[i2-1] ) ) + { //the hideous rc matching logic - not complex, but annoying + if ( !( ( (raw_sequence[i2-1][x_start] == 'A') && + (raw_sequence[i2][x_end] == 'T') ) || + ( (raw_sequence[i2-1][x_start] == 'T') && + (raw_sequence[i2][x_end] == 'A') ) || + ( (raw_sequence[i2-1][x_start] == 'G') && + (raw_sequence[i2][x_end] == 'C') ) || + ( (raw_sequence[i2-1][x_start] == 'C') && + (raw_sequence[i2][x_end] == 'G') ) ) ) + full_match = false; + } + else + { + if (!( (raw_sequence[i2-1][x_start] == raw_sequence[i2][x_end]) && + (raw_sequence[i2-1][x_start] != 'N') && + (raw_sequence[i2][x_end] != 'N') ) ) + full_match = false; + } + } + + // draw for matches stretching across all sequences + if (full_match) + { + fl_line_style(FL_SOLID, 1, NULL); + + // now can draw the line for each bp in this window that matches + // grrr, need to ask if anyone cares if I switch the seq top-bot order... + i3 = 0; + y_loc = y_min + 5; + for(i2 = 1; i2 < seq_num; i2++) + { + // assume not rc as most likely, adjust below + rc_1 = 0; + rc_2 = 0; + // this makes the lines start in the middle of the drawn char/bp + center1 = 0.5; + center2 = 0.5; + // no matter the case, any RC node needs adjustments + if (a_path[i2] < 0) + { + rc_1 = window_length; + center1 = -center1; + } + if (a_path[i2+1] < 0) + { + rc_2 = window_length; + center2 = -center2; + } + + // set offset based on current alignment for which bp to show + offset1 = seq_align_offsets[i2-1]; + offset2 = seq_align_offsets[i2]; + + if ( ( rc_list[i2] || rc_list[i2-1] ) && + !(rc_list[i2] && rc_list[i2-1] ) ) + fl_color(FL_BLUE); + else + fl_color(FL_RED); + + // maybe shouldn't recalc these, but store values from first loop + x_start = (abs((int) (a_path[i2]-rc_1+win_i))); + x_end = (abs((int) (a_path[i2+1]-rc_2+win_i))); + + fl_line( (int)((x_start+center1-offset1+scroll_offset)*ch_width) + + index_pad, y_loc + 10, + (int)((x_end+center2-offset2+scroll_offset)*ch_width) + + index_pad, y_loc+y_seq_incre ); + y_loc += y_seq_incre; + } + } + } + } + align_counter++; + } +} + +void +SeqView::draw_indices(double ch_width) +{ + int seq_i; + Sequence a_seq; + int y_loc; + ostringstream an_index; + int shown_seq_len; + + + // clear out space on sides to draw in index values + // I block out the sides rather than adding offsets to the drawing of seq + // and conservation lines since the lines need to draw off the 'edge' + fl_color(FL_WHITE); + fl_rectf(0, y_min, index_pad, h()+y_min); + fl_rectf(w()-index_pad, y_min, index_pad, h()+y_min); + + // now can draw in the indices of the start and end of the shown sequence + fl_color(FL_BLACK); + y_loc = y_min + 10 + 5; + for(seq_i = 0; seq_i < seq_num; seq_i++) + { + an_index.str(""); + an_index << (seq_align_offsets[seq_i]-scroll_offset); + fl_draw((an_index.str()).c_str(), 2, y_loc); + + shown_seq_len = (w() - 2 * index_pad) / (int) ch_width; + an_index.str(""); + an_index << (seq_align_offsets[seq_i]-scroll_offset+shown_seq_len); + fl_draw((an_index.str()).c_str(), w()-index_pad+2, y_loc); + y_loc += y_seq_incre; + } +} + + +void +SeqView::toggle_align(int align_num) +{ + //cout << align_num << endl; + //cout << show_aligns[align_num] << endl; + show_aligns[align_num] = !show_aligns[align_num]; + //cout << show_aligns[align_num] << endl; +} + + +void +SeqView::align_offsets(int align_num) +{ + list >::iterator pathz_i; + int i; + vector a_path; + int window_length; + + cout << "alignment: " << align_num << endl; + + if (P.begin() == P.end()) + cout << "crud....\n"; + else + { + pathz_i = P.begin(); + + while(pathz_i != P.end()) + ++pathz_i; + + // find the path specified + i = 0; + pathz_i = P.begin(); + while( (i < align_num) && (pathz_i != P.end()) ) + { + ++i; + ++pathz_i; + } + + // now set the alignment offsets - basically where the path starts + seq_align_offsets.clear(); + for(i = 0; i < seq_num ; i++) + { + //cout << (*pathz_i)[i+1] << endl; + seq_align_offsets.push_back( abs((*pathz_i)[i+1]) ); + // for testing purposes: to see everything in the short test sequences + //seq_align_offsets.push_back(0); + } + // reset any dragging done, otherwise might be hard to find selected align + scroll_offset = 0; + } +} + + + +int +SeqView::handle(int e) +{ + int return_value; + + // this empty string needs to be put on cout, otherwise the -O optimize + // compile option seems to throw this function away with the following: + // gcc version 3.2.2 20030222 (Red Hat Linux 3.2.2-5) + cout << ""; + + switch(e) + { + case FL_PUSH: + if (Fl::event_button3()) + { + cout << "menu menu menu!\n"; + return_value = 1; + } + break; + case FL_DRAG: + if (!dragging) + { + drag_change = Fl::event_x(); + dragging = true; + return_value = 1; + } + drag_change = Fl::event_x() - drag_change; + scroll_offset += drag_change; + drag_change = Fl::event_x(); + redraw(); + break; + case FL_RELEASE: + if (dragging) + { + //scroll_offset += Fl::event_x() - drag_start; + //scroll_dist = Fl::event_x() - drag_start; + //scroll_offset += scroll_dist; + //scroll_offset += scroll_pos; + dragging = false; + redraw(); + return_value = 1; + } + break; + default: + return_value = Fl_Widget::handle(e); + } + + return return_value; +} + +void +SeqView::toggle_bars() +{ + show_bars = !show_bars; + redraw(); +} + + +void +SeqView::toggle_motifs() +{ + show_motifs = !show_motifs; + redraw(); +} + + +void +SeqView::reporter(string id, int value) +{ + cout << id << " : " << value << endl; +} + + +/* + cout << "fee\n"; + cout << "fie\n"; + cout << "foe\n"; + cout << "fum\n"; +*/ diff --git a/gui/SeqView.hh b/gui/SeqView.hh new file mode 100644 index 0000000..a728d82 --- /dev/null +++ b/gui/SeqView.hh @@ -0,0 +1,75 @@ +#ifndef _MUSSA_GUI_SEQ_VIEW_H_ +#define _MUSSA_GUI_SEQ_VIEW_H_ +// This file is part of the Mussa source distribution. +// http://mussa.caltech.edu/ +// Contact author: Tristan De Buysscher, tristan@caltech.edu + +// This program and all associated source code files are Copyright (C) 2005 +// the California Institute of Technology, Pasadena, CA, 91125 USA. It is +// under the GNU Public License; please see the included LICENSE.txt +// file for more information, or contact Tristan directly. + +#include +#include +#include + +#include + +#include "MotifWindow.hh" +#include "SetupWindow.hh" + +class SeqView : public Fl_Box +{ + public: + SeqView(int x_top,int y_top,int x_bot,int y_bot) : + Fl_Box(x_top,y_top,x_bot,y_bot) + { + x_max = x_bot; + y_max = y_bot; + x_min = x_top; + y_min = y_top; + show_bars = true; + show_motifs = true; + } + + void setup(std::string name, int sq_num, std::vector *some_seqs, + std::list > some_paths, + std::vector some_lens, std::vector *some_motifs); + void align_offsets(int align_num); + void toggle_align(int align_num); + void toggle_bars(); + void toggle_motifs(); + + private: + std::string ana_name; + int seq_num; + int base_window_len; + + //this data is passed as pointers to the instantiated classes + std::vector *S; + //list of paths in selection box + std::list > P; + std::vector seq_lens; + //pointer to passed motif data + std::vector *the_motifs; + + int x_max, y_max, x_min, y_min; + int y_seq_incre; + int index_pad; + std::vector seq_align_offsets; + std::vector raw_sequence; + bool dragging; + int drag_change, scroll_offset; + bool show_bars, show_motifs; + std::vector show_aligns; + + void resize(int new_x, int new_y, int new_w, int new_h); + void draw(); + void draw_motifs(double ch_width); + void draw_sequence(double ch_width); + void draw_match_lines(double ch_width); + void draw_indices(double ch_width); + int handle(int e); + void reporter(std::string id, int value); +}; +#endif diff --git a/gui/SeqWindow.cxx b/gui/SeqWindow.cxx new file mode 100644 index 0000000..3e2c5bd --- /dev/null +++ b/gui/SeqWindow.cxx @@ -0,0 +1,218 @@ +// This file is part of the Mussa source distribution. +// http://mussa.caltech.edu/ +// Contact author: Tristan De Buysscher, tristan@caltech.edu + +// This program and all associated source code files are Copyright (C) 2005 +// the California Institute of Technology, Pasadena, CA, 91125 USA. It is +// under the GNU Public License; please see the included LICENSE.txt +// file for more information, or contact Tristan directly. + + +#include "SeqWindow.hh" + +#include + +#include + +using namespace std; + +void +set_align_cb(Fl_Widget* widg, void* the_data) +{ + menu_align_data_bundle * blah = (menu_align_data_bundle *) the_data; + SeqWindow* T= blah->swm_ptr; + T->real_set_align_cb(blah->which_align); +} + + +void +SeqWindow::real_set_align_cb(int which_align) +{ + vector a_path; + int window_length; + + + a_path = *P.begin(); + window_length = a_path[0]; + cout << window_length << endl; + + cout << "fum1\n"; + seq_box->align_offsets(which_align); + seq_box->redraw(); +} + + +void +show_align_cb(Fl_Widget* widg, void* the_data) +{ + menu_align_data_bundle * blah = (menu_align_data_bundle *) the_data; + SeqWindow* T= blah->swm_ptr; + T->real_show_align_cb(blah->which_align); +} + + +void +SeqWindow::real_show_align_cb(int which_align) +{ + vector a_path; + int window_length; + + + cout << "fumish\n"; + seq_box->toggle_align(which_align); + seq_box->redraw(); +} + + +void +toggle_bars_cb(Fl_Button* o, void* v) +{ + SeqWindow* T=(SeqWindow*)v; + T->real_toggle_bars_cb(); +} + + +void +SeqWindow::real_toggle_bars_cb() +{ + seq_box->toggle_bars(); +} + + +void +toggle_motifs_cb(Fl_Button* o, void* v) +{ + SeqWindow* T=(SeqWindow*)v; + T->real_toggle_motifs_cb(); +} + + +void +SeqWindow::real_toggle_motifs_cb() +{ + seq_box->toggle_motifs(); +} + + +// main code, window creation + +SeqWindow::SeqWindow(int w, int h, const char* title, int sq_num, + vector *some_seqs, + list > some_paths, + vector some_lens, + vector *some_motifs): + Fl_Double_Window(w,h,title) +{ + menu_align_data_bundle * some_menu_data; + vector a_path; + int window_length, align_number; + int i; + ostringstream align_id_ostr; + string align_id_string; + list >::iterator align_iter; + + + + // most of this stuff is here just to pass to SeqView object + // some is needed to setup the window menus + seq_num = sq_num; + S = some_seqs; + P = some_paths; + seq_lens = some_lens; + the_motifs = some_motifs; + + + begin(); + color(FL_WHITE); + resizable(this); + + // make the menu that allows alignment selection + choose_align_menu = new Fl_Menu_Button(5, 2, 180, 30, "Choose Alignment"); + choose_align_menu->color(FL_WHITE,FL_BLUE); + choose_align_menu->box(FL_BORDER_BOX); + choose_align_menu->clear(); + + // make the menu that allows alignment selection + show_align_menu = new Fl_Menu_Button(190, 2, 180, 30, "Show Alignment"); + show_align_menu->color(FL_WHITE,FL_BLUE); + show_align_menu->box(FL_BORDER_BOX); + show_align_menu->clear(); + + + // adds menu items for each path + align_iter = P.begin(); + align_number = 0; + while(align_iter != P.end()) + { + some_menu_data = new menu_align_data_bundle; + some_menu_data->swm_ptr = this; + some_menu_data->which_align = align_number; + align_id_ostr << (*align_iter)[0] << ": "; + for(i = 1; i <= seq_num; i++) + align_id_ostr << (*align_iter)[i] << ", "; + align_id_string = align_id_ostr.str(); + choose_align_menu->add((const char*)align_id_string.c_str(), 0, + (Fl_Callback *) set_align_cb, + (void*) some_menu_data); + show_align_menu->add((const char*)align_id_string.c_str(), 0, + (Fl_Callback *) show_align_cb, + (void*) some_menu_data, FL_MENU_TOGGLE|FL_MENU_VALUE); + + align_id_ostr.str(""); + ++align_number; + ++align_iter; + } + + /* + show_align_menu->add("f&ee"); + show_align_menu->add("f&ie"); + show_align_menu->add("f&oe"); + show_align_menu->add("f&um"); + */ + + Fl_Button *test_but = new Fl_Button(375, 2, 150, 30, "Toggle Motifs"); + test_but->color(FL_WHITE,FL_BLUE); + test_but->box(FL_BORDER_BOX); + test_but->callback((Fl_Callback*) toggle_motifs_cb, this); + + toggle_bars = new Fl_Button(530, 2, 150, 30, "Toggle 10bp bars"); + toggle_bars->color(FL_WHITE,FL_BLUE); + toggle_bars->box(FL_BORDER_BOX); + toggle_bars->callback((Fl_Callback*) toggle_bars_cb, this); + + + // make the view of the sequence + seq_box = new SeqView(0, 34, w, h-34); + seq_box->setup(ana_name, seq_num, S, P, seq_lens, the_motifs); + //real_set_align_cb(2); + + end(); + Fl::visual(FL_DOUBLE|FL_INDEX); + show(); +} + + + +/* + some_menu_data = new menu_align_data_bundle; + some_menu_data->swm_ptr = this; + some_menu_data->which_align = 2; + choose_align_menu->add("f&ie", FL_ALT+'i', (Fl_Callback *) set_align_cb, + (void*) some_menu_data); + + some_menu_data = new menu_align_data_bundle; + some_menu_data->swm_ptr = this; + some_menu_data->which_align = 3; + choose_align_menu->add("f&oe", FL_ALT+'o', (Fl_Callback *) set_align_cb, + (void*) some_menu_data); + + some_menu_data = new menu_align_data_bundle; + some_menu_data->swm_ptr = this; + some_menu_data->which_align = 4; + choose_align_menu->add("f&um", FL_ALT+'u', (Fl_Callback *) set_align_cb, + (void*) some_menu_data); +*/ + + + + diff --git a/gui/SeqWindow.hh b/gui/SeqWindow.hh new file mode 100644 index 0000000..9ae346a --- /dev/null +++ b/gui/SeqWindow.hh @@ -0,0 +1,68 @@ +#ifndef _MUSSA_GUI_SEQ_H_ +#define _MUSSA_GUI_SEQ_H_ +// This file is part of the Mussa source distribution. +// http://mussa.caltech.edu/ +// Contact author: Tristan De Buysscher, tristan@caltech.edu + +// This program and all associated source code files are Copyright (C) 2005 +// the California Institute of Technology, Pasadena, CA, 91125 USA. It is +// under the GNU Public License; please see the included LICENSE.txt +// file for more information, or contact Tristan directly. + +#include +#include +#include +#include + +#include "SeqView.hh" + +#include +#include +#include +#include + +class SeqWindow : public Fl_Double_Window +{ + private: + std::string ana_name; + int base_window_len; + + //this data is passed as pointers to the instantiated classes + std::vector *S; + // list of paths in selection box + std::list > P; + std::vector seq_lens; + //pointer to passed motif data + std::vector *the_motifs; + + int x_max, y_max; + Fl_Menu_Button *choose_align_menu; + Fl_Menu_Button *show_align_menu; + Fl_Button *toggle_bars; + SeqView *seq_box; + + public: + int seq_num; + + SeqWindow(int w, int h, const char* title, int sq_num, + std::vector *some_seqs, + std::list > some_paths, + std::vector some_lens, + std::vector *some_motifs); + virtual ~SeqWindow(){ std::cout << "dying\n"; } + + void make_choose_menu(); + void make_show_menu(); + void real_set_align_cb(int which_align); + void real_show_align_cb(int which_align); + void real_toggle_bars_cb(); + void real_toggle_motifs_cb(); +}; + + +struct menu_align_data_bundle +{ + SeqWindow * swm_ptr; + int which_align; +}; +#endif diff --git a/gui/SetupWindow.cxx b/gui/SetupWindow.cxx new file mode 100644 index 0000000..0487628 --- /dev/null +++ b/gui/SetupWindow.cxx @@ -0,0 +1,423 @@ +// This file is part of the Mussa source distribution. +// http://mussa.caltech.edu/ +// Contact author: Tristan De Buysscher, tristan@caltech.edu + +// This program and all associated source code files are Copyright (C) 2005 +// the California Institute of Technology, Pasadena, CA, 91125 USA. It is +// under the GNU Public License; please see the included LICENSE.txt +// file for more information, or contact Tristan directly. + + +#include "SetupWindow.hh" +#include "mussa_class.hh" +#include +#include + +using namespace std; + +bool +SetupWindow::done() +{ + return all_done; +} + + +void +do_analysis_cb(Fl_Button* o, void* v) +{ + SetupWindow* T=(SetupWindow*)v; + T->real_do_analysis(); +} + + +// passes the parameters to the mussa class object and orders it to run +void +SetupWindow::real_do_analysis() +{ + int i; + string err_msg; + + // <-- need a check here to make sure all vars have a valid value + + an_analysis->clear(); + an_analysis->set_name(ana_name); + an_analysis->set_seq_num(seq_num); + an_analysis->set_window(window); + an_analysis->set_threshold(threshold); + + for(i=0; i < seq_num; i++) + an_analysis->set_seq_info(seq_files[i], annot_files[i], fasta_indices[i], + sub_seq_starts[i], sub_seq_ends[i]); + + err_msg = an_analysis->analyze(0,0, 't', 0.0); + //cout << "Feel the tribal beat\n"; + if (!(err_msg == "")) + { + //fl_alert(err_msg.c_str()); + cout << err_msg; + } + + all_done = true; + + hide(); +} + + +void +choose_seq_file_cb(Fl_Button* o, void* v) +{ + seq_data_instance * blah = (seq_data_instance *) v; + SetupWindow* T= blah->sw_ptr; + T->real_choose_seq_file_cb(blah->index); +} + + +void +SetupWindow::real_choose_seq_file_cb(int i) +{ + char *picked_file; + string a_file_path; + + picked_file = fl_file_chooser("Find an Analysis", "", "", 1); + a_file_path = picked_file; + seq_files[i] = a_file_path; + seq_inputs[i]->value((const char *)picked_file); +} + + +void +seq_file_in_cb(Fl_Input* o, void* v) +{ + seq_data_instance * blah = (seq_data_instance *) v; + SetupWindow* T= blah->sw_ptr; + T->real_seq_file_in_cb(o,blah->index); +} + + +void +SetupWindow::real_seq_file_in_cb(Fl_Input* o, int i) +{ + seq_files[i] = o->value(); + // leaving this as a reminder that bools will need to be set to determine + // if all needed fields have been filled with some value before an analysis + // is attempted + //(*the_motifs)[i].dirty = true; +} + +//char *picked_file; +//picked_file = fl_file_chooser("Find an Analysis", "", "", 1); + +// *** Annot file selection + +void +choose_annot_file_cb(Fl_Button* o, void* v) +{ + seq_data_instance * blah = (seq_data_instance *) v; + SetupWindow* T= blah->sw_ptr; + T->real_choose_annot_file_cb(blah->index); +} + + +void +SetupWindow::real_choose_annot_file_cb(int i) +{ + char *picked_file; + string a_file_path; + + picked_file = fl_file_chooser("Find an Analysis", "", "", 1); + a_file_path = picked_file; + annot_files[i] = a_file_path; + annot_inputs[i]->value((const char *)picked_file); +} + +void +annot_file_in_cb(Fl_Input* o, void* v) +{ + seq_data_instance * blah = (seq_data_instance *) v; + SetupWindow* T= blah->sw_ptr; + T->real_annot_file_in_cb(o,blah->index); +} + +void +SetupWindow::real_annot_file_in_cb(Fl_Input* o, int i) +{ + annot_files[i] = o->value(); +} + + +// *** fasta index selection + +void +fa_index_in_cb(Fl_Input* o, void* v) +{ + seq_data_instance * blah = (seq_data_instance *) v; + SetupWindow* T= blah->sw_ptr; + T->real_fa_index_in_cb(o,blah->index); +} + +void +SetupWindow::real_fa_index_in_cb(Fl_Input* o, int i) +{ + fasta_indices[i] = atoi(o->value()); +} + +// *** subsequence start select + +void +sub_start_in_cb(Fl_Input* o, void* v) +{ + seq_data_instance * blah = (seq_data_instance *) v; + SetupWindow* T= blah->sw_ptr; + T->real_sub_start_in_cb(o,blah->index); +} + +void +SetupWindow::real_sub_start_in_cb(Fl_Input* o, int i) +{ + sub_seq_starts[i] = atoi(o->value()); +} + +// *** subsequence end select + +void +sub_end_in_cb(Fl_Input* o, void* v) +{ + seq_data_instance * blah = (seq_data_instance *) v; + SetupWindow* T= blah->sw_ptr; + T->real_sub_end_in_cb(o,blah->index); +} + +void +SetupWindow::real_sub_end_in_cb(Fl_Input* o, int i) +{ + sub_seq_ends[i] = atoi(o->value()); + +} + +// *** input analysis name + +void +set_ana_name_cb(Fl_Input* o, void* v) +{ + SetupWindow* T=(SetupWindow*)v; + T->real_set_ana_name_cb(o); +} + +void +SetupWindow::real_set_ana_name_cb(Fl_Input* o) +{ + ana_name = o->value(); +} + +// *** input window size + +void +set_win_size_cb(Fl_Input* o, void* v) +{ + SetupWindow* T=(SetupWindow*)v; + T->real_set_win_size_cb(o); +} + +void +SetupWindow::real_set_win_size_cb(Fl_Input* o) +{ + window = atoi(o->value()); +} + +// *** input threshold + +void +set_threshold_cb(Fl_Input* o, void* v) +{ + SetupWindow* T=(SetupWindow*)v; + T->real_set_threshold_cb(o); +} + +void +SetupWindow::real_set_threshold_cb(Fl_Input* o) +{ + threshold = atoi(o->value()); +} + +void +set_seq_num_cb(Fl_Input* o, void* v) +{ + SetupWindow* T=(SetupWindow*)v; + T->real_set_seq_num_cb(o); +} + +// *** input number of sequences, add appropriate inputs for each sequence + +void +SetupWindow::real_set_seq_num_cb(Fl_Input* o) +{ + int i; + + seq_num = atoi(o->value()); + seq_inputs.clear(); + annot_inputs.clear(); + + seq_scroll = new Fl_Scroll(5,80,w()-10,h()-115); + seq_scroll->color(FL_WHITE); + + for (i = 0; i < seq_num; i++) + { + seq_files.push_back(""); + annot_files.push_back(""); + fasta_indices.push_back(1); + sub_seq_starts.push_back(0); + sub_seq_ends.push_back(0); + add_seq_input(i); + } + seq_scroll->box(FL_DOWN_FRAME); + add(seq_scroll); + redraw(); +} + + +SetupWindow::SetupWindow(int w, int h, const char* title, Mussa *the_analysis):Fl_Window(w,h,title) +{ + color(FL_WHITE); + + an_analysis = the_analysis; + all_done = false; + + begin(); + + name_input = new Fl_Input(110, 10, w-120, 30, "Analysis Name "); + name_input->value(""); + //name_input->when(FL_WHEN_ENTER_KEY); + name_input->box(FL_BORDER_BOX); + name_input->callback((Fl_Callback*)set_ana_name_cb, this); + + // add in radio buttons for win_append and thres_append eventually + win_append = true; + thres_append = true; + + win_input = new Fl_Input(65,45,100,30, "Window "); + win_input->value(""); + win_input->callback((Fl_Callback*)set_win_size_cb, this); + + thres_input = new Fl_Input(250,45,100,30, "Threshold "); + thres_input->value(""); + thres_input->callback((Fl_Callback*)set_threshold_cb, this); + + seq_num_input = new Fl_Input(430,45,100, 30, "Seq Num "); + seq_num_input->value(""); + seq_num_input->callback((Fl_Callback*)set_seq_num_cb, this); + + // button to launch the analysis + test = new Fl_Button(w-100,h-30,100,30,"Do Analysis"); + test->callback((Fl_Callback*)do_analysis_cb, this); + + // test button to make sure setup data is being stored + test = new Fl_Button(w-200,h-30,100,30,"show setup"); + test->callback((Fl_Callback*)print_cb, this); + + // generic input, keeping around as template for future additions + //_input = new Fl_Input(0, , 30, ""); + //_input->value(""); + //_input->when(FL_WHEN_ENTER_KEY); + //_input->callback((Fl_Callback*)set__cb, this); + + end(); + //resizable(this); + show(); +} + + +SetupWindow::~SetupWindow(){} + + +void +SetupWindow::add_seq_input(int i) +{ + Fl_Input *fasta_input, *start_input, *end_input; + Fl_Button *seq_browse, *annot_browse; + + + // this remembers what seq index each input is associated with + seq_data_instance * something; + something = new seq_data_instance; + something->sw_ptr = this; + something->index = i; + + + // setup sequence file input for text input or file browsing + seq_inputs.push_back(new Fl_Input(55, 85+(i*105), w()-165, 30, "seq ")); + seq_inputs[i]->value(""); + seq_inputs[i]->callback((Fl_Callback*)seq_file_in_cb, (void*) something); + + seq_browse = new Fl_Button(w()-105, 85+(i*105), 80, 30, "Browse"); + seq_browse->callback((Fl_Callback*)choose_seq_file_cb, (void*) something); + + // setup annotation file input for text input or file browsing + annot_inputs.push_back(new Fl_Input(55, 120+(i*105), w()-165, 30, "annot ")); + annot_inputs[i]->value(""); + annot_inputs[i]->callback((Fl_Callback*)annot_file_in_cb,(void*)something); + + annot_browse = new Fl_Button(w()-105, 120+(i*105), 80, 30, "Browse"); + annot_browse->callback((Fl_Callback*)choose_annot_file_cb, (void*)something); + + // index of fasta seq wanted if more than 1 seq in file + fasta_input = new Fl_Input(90, 155+(i*105), 50, 30, "fasta index"); + fasta_input->value(""); + fasta_input->callback((Fl_Callback*)fa_index_in_cb, (void*) something); + + // subsequence select, index of first bp wanted + start_input = new Fl_Input(225, 155+(i*105), 50, 30, "start index"); + start_input->value(""); + start_input->callback((Fl_Callback*)sub_start_in_cb, (void*) something); + + // subsequence select, index of last bp wanted + end_input = new Fl_Input(355, 155+(i*105), 50, 30, "end index"); + end_input->value(""); + end_input->callback((Fl_Callback*)sub_end_in_cb, (void*) something); + + seq_scroll->add(seq_inputs[i]); + seq_scroll->add(seq_browse); + seq_scroll->add(annot_inputs[i]); + seq_scroll->add(annot_browse); + seq_scroll->add(fasta_input); + seq_scroll->add(start_input); + seq_scroll->add(end_input); +} + +/* + cout << "fee\n"; + cout << "fie\n"; + cout << "foe\n"; + cout << "fum\n"; +*/ + +void SetupWindow::print_cb(Fl_Button* o, void* v) +{ + SetupWindow* T=(SetupWindow*)v; + T->print_cb_real(o,v); +} + + +void SetupWindow::print_cb_real(Fl_Button* , void*) +{ + cout << "ana_name: " << ana_name << endl; + cout << "win: " << window << endl; + cout << "thres: " << threshold << endl; + cout << "seq_num: " << seq_num << endl; + //cout << "win_add: " << win_append << end; + //cout << "thres_add: " << thres_append << endl; + + int i; + + + + for (i = 0; i < seq_num; i++) + { + cout << seq_files[i] << endl; + cout << annot_files[i] << endl; + cout << "fasta: " << fasta_indices[i]; + cout << " start: " << sub_seq_starts[i]; + cout << " end: " << sub_seq_ends[i] << endl; + cout << "blargle!\n"; + } + cout << "end of inputs\n" << endl; +} diff --git a/gui/SetupWindow.hh b/gui/SetupWindow.hh new file mode 100644 index 0000000..42eccb7 --- /dev/null +++ b/gui/SetupWindow.hh @@ -0,0 +1,86 @@ +#ifndef _MUSSA_GUI_LOAD_WINDOW_H_ +#define _MUSSA_GUI_LOAD_WINDOW_H_ + +// This file is part of the Mussa source distribution. +// http://mussa.caltech.edu/ +// Contact author: Tristan De Buysscher, tristan@caltech.edu + +// This program and all associated source code files are Copyright (C) 2005 +// the California Institute of Technology, Pasadena, CA, 91125 USA. It is +// under the GNU Public License; please see the included LICENSE.txt +// file for more information, or contact Tristan directly. + +#include +#include + +#include +#include +#include +#include + +class Mussa; +#include "SetupWindow.hh" + +class SetupWindow : public Fl_Window +{ + public: + SetupWindow(int w, int h, const char* title, Mussa *an_analysis); + ~SetupWindow(); + + bool done(); + + //did I put these in public for a reason? + Fl_Button* test; + Fl_Input *name_input; + Fl_Input *win_input; + Fl_Input *thres_input; + Fl_Input *seq_num_input; + Fl_Scroll *seq_scroll; + // need to keep track of these so a browsed file search can set the input + // fields to teh selected file + std::vector seq_inputs, annot_inputs; + + + // callback receiver functions + + void real_do_analysis(); + + void real_set_ana_name_cb(Fl_Input* o); + void real_set_win_size_cb(Fl_Input* o); + void real_set_threshold_cb(Fl_Input* o); + void real_set_seq_num_cb(Fl_Input* o); + + void real_seq_file_in_cb(Fl_Input* o, int i); + void real_choose_seq_file_cb(int i); + void real_annot_file_in_cb(Fl_Input* o, int i); + void real_choose_annot_file_cb(int i); + + void real_fa_index_in_cb(Fl_Input* o, int i); + void real_sub_start_in_cb(Fl_Input* o, int i); + void real_sub_end_in_cb(Fl_Input* o, int i); + + private: + Mussa *an_analysis; + std::string ana_name; + int window, threshold, seq_num; + std::vector seq_files, annot_files; + std::vector fasta_indices, sub_seq_starts, sub_seq_ends; + bool win_append, thres_append; + + bool all_done; + static void print_cb(Fl_Button*, void*); + inline void print_cb_real(Fl_Button*, void*); + + void add_seq_input(int index); +}; + +// crazy whacked shite Titus taught me to do to get an index value associated +// with each instance of an input associated with the callback... + +struct seq_data_instance +{ + SetupWindow * sw_ptr; + int index; +}; + +#endif diff --git a/gui/SubAnalysisWindow.cxx b/gui/SubAnalysisWindow.cxx new file mode 100644 index 0000000..4831f93 --- /dev/null +++ b/gui/SubAnalysisWindow.cxx @@ -0,0 +1,288 @@ +// This file is part of the Mussa source distribution. +// http://mussa.caltech.edu/ +// Contact author: Tristan De Buysscher, tristan@caltech.edu + +// This program and all associated source code files are Copyright (C) 2005 +// the California Institute of Technology, Pasadena, CA, 91125 USA. It is +// under the GNU Public License; please see the included LICENSE.txt +// file for more information, or contact Tristan directly. + + +#include "SubAnalysisWindow.hh" + +#include +using namespace std; + +void +do_subana_cb(Fl_Button* o, void* v) +{ + SubAnalysisWindow* T=(SubAnalysisWindow*)v; + T->real_do_subana(); +} + + +// passes the parameters to the mussa class object and orders it to run +void +SubAnalysisWindow::real_do_subana() +{ + int i; + string a_sequence, err_msg; + + // <-- need a check here to make sure all vars have a valid value + + an_analysis->clear(); + an_analysis->set_name(ana_name); + an_analysis->set_seq_num(seq_num); + an_analysis->set_window(window); + an_analysis->set_threshold(threshold); + + for(i=0; i < seq_num; i++) + { + a_sequence = the_Seqs[i].seq(); + cout << a_sequence.length() << endl; + a_sequence = a_sequence.substr(sub_seq_starts[i], + sub_seq_ends[i] - sub_seq_starts[i] ); + cout << a_sequence.length() << endl; + an_analysis->add_a_seq(a_sequence); + } + + err_msg = an_analysis->analyze(0,0, 't', 0.0); + + cout << "Feel the tribal beat\n"; + if (!(err_msg == "")) + { + //fl_alert(err_msg.c_str()); + cout << err_msg; + } + + all_done = true; + + hide(); +} + + + +// *** subsequence start select + +void +sub_start_in_cb1(Fl_Input* o, void* v) +{ + sub_seq_data_instance * blah = (sub_seq_data_instance *) v; + SubAnalysisWindow* T= blah->sw_ptr; + T->real_sub_start_in_cb(o,blah->index); +} + +void +SubAnalysisWindow::real_sub_start_in_cb(Fl_Input* o, int i) +{ + sub_seq_starts[i] = atoi(o->value()); +} + +// *** subsequence end select + +void +sub_end_in_cb1(Fl_Input* o, void* v) +{ + sub_seq_data_instance * blah = (sub_seq_data_instance *) v; + SubAnalysisWindow* T= blah->sw_ptr; + T->real_sub_end_in_cb(o,blah->index); +} + +void +SubAnalysisWindow::real_sub_end_in_cb(Fl_Input* o, int i) +{ + sub_seq_ends[i] = atoi(o->value()); + +} + +// *** input analysis name + +void +set_ana_name_cb1(Fl_Input* o, void* v) +{ + SubAnalysisWindow* T=(SubAnalysisWindow*)v; + T->real_set_ana_name_cb(o); +} + +void +SubAnalysisWindow::real_set_ana_name_cb(Fl_Input* o) +{ + ana_name = o->value(); +} + +// *** input window size + +void +set_win_size_cb1(Fl_Input* o, void* v) +{ + SubAnalysisWindow* T=(SubAnalysisWindow*)v; + T->real_set_win_size_cb(o); +} + +void +SubAnalysisWindow::real_set_win_size_cb(Fl_Input* o) +{ + window = atoi(o->value()); +} + +// *** input threshold + +void +set_threshold_cb1(Fl_Input* o, void* v) +{ + SubAnalysisWindow* T=(SubAnalysisWindow*)v; + T->real_set_threshold_cb(o); +} + +void +SubAnalysisWindow::real_set_threshold_cb(Fl_Input* o) +{ + threshold = atoi(o->value()); +} + + +bool +SubAnalysisWindow::done() +{ + return all_done; +} + + +SubAnalysisWindow::SubAnalysisWindow(int w, int h, const char* title,Mussa *the_analysis, + vector some_Seqs):Fl_Window(w,h,title) +{ + string a_name; + + color(FL_WHITE); + + an_analysis = the_analysis; + the_Seqs = some_Seqs; + all_done = false; + + // initialize parameters + ana_name = ""; + window = -1; + threshold = -1; + + begin(); + + name_input = new Fl_Input(135, 10, w-140, 30, "SubAnalysis Name "); + name_input->value(""); + //name_input->when(FL_WHEN_ENTER_KEY); + name_input->box(FL_BORDER_BOX); + name_input->callback((Fl_Callback*)set_ana_name_cb1, this); + + // add in radio buttons for win_append and thres_append eventually + win_append = true; + thres_append = true; + + win_input = new Fl_Input(135,45,100,30, "Window: "); + win_input->value(""); + win_input->callback((Fl_Callback*)set_win_size_cb1, this); + + thres_input = new Fl_Input(320,45,100,30, "Threshold: "); + thres_input->value(""); + thres_input->callback((Fl_Callback*)set_threshold_cb1, this); + + // button to launch the analysis + test = new Fl_Button(w-100,h-30,100,30,"Do Analysis"); + test->callback((Fl_Callback*)do_subana_cb, this); + + // test button to make sure setup data is being stored + test = new Fl_Button(w-200,h-30,100,30,"show setup"); + test->callback((Fl_Callback*)print_cb, this); + + // add all the inputs for the sub sequence starts & ends + int i; + + seq_num = the_Seqs.size(); + + seq_scroll = new Fl_Scroll(5,80,w-10,h-115); + seq_scroll->color(FL_WHITE); + + for (i = 0; i < seq_num; i++) + { + sub_seq_starts.push_back(0); + sub_seq_ends.push_back(0); + a_name = the_Seqs[i].sp_name(); + cout << a_name << endl; + add_seq_input(i, a_name); + } + seq_scroll->box(FL_DOWN_FRAME); + //add(seq_scroll); + //redraw(); + + end(); + //resizable(this); + show(); +} + + +SubAnalysisWindow::~SubAnalysisWindow(){} + + +void +SubAnalysisWindow::add_seq_input(int i, string a_name) +{ + Fl_Input *start_input, *end_input; + + + // this remembers what seq index each input is associated with + sub_seq_data_instance * something; + something = new sub_seq_data_instance; + something->sw_ptr = this; + something->index = i; + + + // subsequence select, index of first bp wanted + start_input = new Fl_Input(150, 85+(i*35), 70, 30, "start index: "); + start_input->value(""); + start_input->callback((Fl_Callback*)sub_start_in_cb1, (void*) something); + + // subsequence select, index of last bp wanted + end_input = new Fl_Input(300, 85+(i*35), 70, 30, "end index: "); + end_input->value(""); + end_input->callback((Fl_Callback*)sub_end_in_cb1, (void*) something); + + seq_scroll->add(start_input); + seq_scroll->add(end_input); +} + +/* + cout << "fee\n"; + cout << "fie\n"; + cout << "foe\n"; + cout << "fum\n"; +*/ + +void SubAnalysisWindow::print_cb(Fl_Button* o, void* v) +{ + SubAnalysisWindow* T=(SubAnalysisWindow*)v; + T->print_cb_real(o,v); +} + + +void SubAnalysisWindow::print_cb_real(Fl_Button* , void*) +{ + cout << "ana_name: " << ana_name << endl; + cout << "win: " << window << endl; + cout << "thres: " << threshold << endl; + cout << "seq_num: " << seq_num << endl; + //cout << "win_add: " << win_append << end; + //cout << "thres_add: " << thres_append << endl; + + int i; + + + + for (i = 0; i < seq_num; i++) + { + //cout << seq_files[i] << endl; + //cout << annot_files[i] << endl; + //cout << "fasta: " << fasta_indices[i]; + cout << " start: " << sub_seq_starts[i]; + cout << " end: " << sub_seq_ends[i] << endl; + cout << "blargle!\n"; + } + cout << "end of inputs\n" << endl; +} diff --git a/gui/SubAnalysisWindow.hh b/gui/SubAnalysisWindow.hh new file mode 100644 index 0000000..e4a9e2d --- /dev/null +++ b/gui/SubAnalysisWindow.hh @@ -0,0 +1,81 @@ +#ifndef _MUSSA_GUI_SUBANA_H_ +#define _MUSSA_GUI_SUBANA_H_ +// This file is part of the Mussa source distribution. +// http://mussa.caltech.edu/ +// Contact author: Tristan De Buysscher, tristan@caltech.edu + +// This program and all associated source code files are Copyright (C) 2005 +// the California Institute of Technology, Pasadena, CA, 91125 USA. It is +// under the GNU Public License; please see the included LICENSE.txt +// file for more information, or contact Tristan directly. + +#include +#include + +#include +#include +#include +#include +#include + +#include "mussa_class.hh" +#include "SeqTextWindow.hh" + +class SubAnalysisWindow : public Fl_Window +{ + public: + SubAnalysisWindow(int w, int h, const char* title, Mussa *an_analysis, + std::vector some_Seqs); + ~SubAnalysisWindow(); + bool done(); + + + Fl_Button* test; + + Fl_Input *name_input; + Fl_Input *win_input; + Fl_Input *thres_input; + Fl_Input *seq_num_input; + Fl_Scroll *seq_scroll; + // need to keep track of these so a browsed file search can set the input + // fields to the selected file + std::vector seq_inputs, annot_inputs; + + + // callback receiver functions + + void real_do_subana(); + + void real_set_ana_name_cb(Fl_Input* o); + void real_set_win_size_cb(Fl_Input* o); + void real_set_threshold_cb(Fl_Input* o); + + void real_sub_start_in_cb(Fl_Input* o, int i); + void real_sub_end_in_cb(Fl_Input* o, int i); + + private: + // sequence data + std::vector the_Seqs; + Mussa *an_analysis; + std::string ana_name; + int window, threshold, seq_num; + std::vector sub_seq_starts, sub_seq_ends; + bool win_append, thres_append; + bool all_done; + + static void print_cb(Fl_Button*, void*); + inline void print_cb_real(Fl_Button*, void*); + + void add_seq_input(int index, std::string a_name); +}; + +// crazy whacked shite Titus taught me to do to get an index value associated +// with each instance of an input associated with the callback... + + +struct sub_seq_data_instance +{ + SubAnalysisWindow * sw_ptr; + int index; +}; +#endif diff --git a/gui/module.mk b/gui/module.mk new file mode 100644 index 0000000..31e1286 --- /dev/null +++ b/gui/module.mk @@ -0,0 +1,15 @@ +CURDIR := $(BASEDIR)gui/ + +SOURCES.cxx := AnnotWindow.cxx \ + ConnView.cxx \ + ConnWindow.cxx \ + MotifWindow.cxx \ + SeqTextWindow.cxx \ + SeqView.cxx \ + SeqWindow.cxx \ + SetupWindow.cxx \ + SubAnalysisWindow.cxx + +SRC += $(addprefix $(CURDIR), $(SOURCES.cxx)) +CXXFLAGS += -I$(CURDIR) + diff --git a/module.mk b/module.mk new file mode 100644 index 0000000..b86e711 --- /dev/null +++ b/module.mk @@ -0,0 +1,16 @@ +CURDIR := $(BASEDIR) + +SOURCES.cxx := flp.cxx \ + flp_seqcomp.cxx \ + mussa.cxx \ + mussa_class.cxx \ + mussa_nway.cxx \ + mussa_nway_entropy.cxx \ + mussa_nway_other.cxx \ + sequence.cxx + #seqcomp.cxx \ #(old seqcomp) + #mussa_nway_refine.cxx \ (broken code) + +SRC += $(addprefix $(CURDIR), $(SOURCES.cxx)) +CXXFLAGS += -I$(CURDIR) + diff --git a/mussa.cc b/mussa.cc deleted file mode 100644 index d3d48f5..0000000 --- a/mussa.cc +++ /dev/null @@ -1,196 +0,0 @@ -// This file is part of the Mussa source distribution. -// http://mussa.caltech.edu/ -// Contact author: Tristan De Buysscher, tristan@caltech.edu - -// This program and all associated source code files are Copyright (C) 2005 -// the California Institute of Technology, Pasadena, CA, 91125 USA. It is -// under the GNU Public License; please see the included LICENSE.txt -// file for more information, or contact Tristan directly. - - -#include "mussa_gui_conn_window.hh" -#include -using namespace std; - -char -parse_args(int argc, char **argv, string *a_file_path, int *window, - int *threshold, char *ana_mode, float *ent_thres); - - -int main(int argc, char **argv) -{ - Mussa an_analysis; - string a_file_path; - char * picked_file; - int window, threshold; - float ent_thres; - char run_mode, ana_mode; - int x_max=1000; - int y_max=500; - string err_msg; - - - err_msg = ""; - - // yeah, its horrible to be passing these by reference, but I just don't see - // any other way without making parse_args part of MussaClass, which just - // seems wrong (args are after all, an io type thing, and the gui only mode - // will have it own way as well... - run_mode = parse_args(argc, argv, &a_file_path, &window, &threshold, - &ana_mode, &ent_thres); - - cout << "mussa: run mode = " << run_mode; - cout << "\tfile_path = "<< a_file_path << endl; - cout << "mussa: ent_thres = " << ent_thres << endl; - - // if no error from parse args (run_mode = 'e', ie error), run in proper mode - if (run_mode != 'e') - { - if ((run_mode == 'f') || (run_mode == 'n')) - { - err_msg = an_analysis.load_mupa_file(a_file_path); - err_msg = an_analysis.analyze(window, threshold, ana_mode, ent_thres); - //an_overlord.do_analysis(); - } - - if (run_mode == 'v') - err_msg = an_analysis.load(a_file_path); - //an_overlord.get_analysis(); - - // no longer needed, but still semi-useful reality check... - if (run_mode == 'g') - { - cout << "GTV - All Gui, All the Time\n"; - } - - if (err_msg == "") - { - if ((run_mode == 'f') || (run_mode == 'v') || (run_mode == 'g')) - { - //an_overlord.spawnConnView(1000,500); - ConnWindow *a_conn_win = new ConnWindow(x_max, y_max, "Mussa"); - - // we have an analysis already if in these 2 modes - if ((run_mode == 'f') || (run_mode == 'v')) - a_conn_win->add_ana(&an_analysis); - - Fl::run(); - } - } - else - cout << err_msg << endl; - } -} - - -// minimal arg reading function, not very robust to errors -char -parse_args(int argc, char **argv, string *a_file_path, int *window, - int *threshold, char *ana_mode, float *ent_thres) -{ - int i, else_i; - string an_arg; - char run_mode; - - // initialize these to 0 as flag if they are not changed - *window = 0; - *threshold = 0; - *ent_thres = 0.0; - run_mode = 'e'; //error default if no run mode set implicitly or explicitly - *ana_mode = 't'; // default to transitivie analyses mode - - - - // no args means gui only mode - if (argc == 1) - run_mode = 'g'; - // 1 arg means its a mupa file and run in full mode - /* - else if (argc == 2) - { - } - */ - else - { - else_i = 0; - i = 1; - while (i < argc) - { - an_arg = * ++argv; - i++; - - // see what alternate mode the user wants to run in - if (an_arg == "-m") - { - an_arg = * ++argv; - i++; - if ( (an_arg == "v") || (an_arg == "n") ) //only 2 valid modes so far - run_mode = an_arg[0]; - else - { - cout << "Error: \'" << an_arg; - cout << "\' is not a valid analysis mode for -a argument" << endl; - run_mode = 'e'; - } - *a_file_path = * ++argv; - i++; - } - // alternate analyses modes - else if (an_arg == "-a") - { - an_arg = * ++argv; - i++; - // t = transitive, r = radial, e = entropy - if ( (an_arg == "t") || (an_arg == "r") || (an_arg == "e") ) - *ana_mode = an_arg[0]; - else - { - cout << "Error: \'" << an_arg; - cout << "\' is not a valid run mode for -m argument" << endl; - run_mode = 'e'; - } - - } - else if (an_arg == "-w") // alternate window size arg - { - *window = atoi(* ++argv); - i++; - } - else if (an_arg == "-t") // alternate threshold arg - { - *threshold = atoi(* ++argv); - i++; - } - else if (an_arg == "-et") // alternate entropy threshold arg - { - *ent_thres = atof(* ++argv); - i++; - } - else - { - if (else_i == 0) - { - *a_file_path = an_arg; - run_mode = 'f'; - else_i++; - } - else - { - //cout << "Error, unknown arg: \'" << an_arg << "\'" << endl; - cout << "Error, too many filenames: \'" << an_arg << "\'" << endl; - run_mode == 'e'; - } - } - } - } - - return run_mode; -} - - -/* - cout << "fee\n"; - cout << "fie\n"; - cout << "foe\n"; - cout << "fum\n"; -*/ diff --git a/mussa.cxx b/mussa.cxx new file mode 100644 index 0000000..1ee7ae6 --- /dev/null +++ b/mussa.cxx @@ -0,0 +1,196 @@ +// This file is part of the Mussa source distribution. +// http://mussa.caltech.edu/ +// Contact author: Tristan De Buysscher, tristan@caltech.edu + +// This program and all associated source code files are Copyright (C) 2005 +// the California Institute of Technology, Pasadena, CA, 91125 USA. It is +// under the GNU Public License; please see the included LICENSE.txt +// file for more information, or contact Tristan directly. + + +#include "ConnWindow.hh" +#include +using namespace std; + +char +parse_args(int argc, char **argv, string *a_file_path, int *window, + int *threshold, char *ana_mode, float *ent_thres); + + +int main(int argc, char **argv) +{ + Mussa an_analysis; + string a_file_path; + char * picked_file; + int window, threshold; + float ent_thres; + char run_mode, ana_mode; + int x_max=1000; + int y_max=500; + string err_msg; + + + err_msg = ""; + + // yeah, its horrible to be passing these by reference, but I just don't see + // any other way without making parse_args part of MussaClass, which just + // seems wrong (args are after all, an io type thing, and the gui only mode + // will have it own way as well... + run_mode = parse_args(argc, argv, &a_file_path, &window, &threshold, + &ana_mode, &ent_thres); + + cout << "mussa: run mode = " << run_mode; + cout << "\tfile_path = "<< a_file_path << endl; + cout << "mussa: ent_thres = " << ent_thres << endl; + + // if no error from parse args (run_mode = 'e', ie error), run in proper mode + if (run_mode != 'e') + { + if ((run_mode == 'f') || (run_mode == 'n')) + { + err_msg = an_analysis.load_mupa_file(a_file_path); + err_msg = an_analysis.analyze(window, threshold, ana_mode, ent_thres); + //an_overlord.do_analysis(); + } + + if (run_mode == 'v') + err_msg = an_analysis.load(a_file_path); + //an_overlord.get_analysis(); + + // no longer needed, but still semi-useful reality check... + if (run_mode == 'g') + { + cout << "GTV - All Gui, All the Time\n"; + } + + if (err_msg == "") + { + if ((run_mode == 'f') || (run_mode == 'v') || (run_mode == 'g')) + { + //an_overlord.spawnConnView(1000,500); + ConnWindow *a_conn_win = new ConnWindow(x_max, y_max, "Mussa"); + + // we have an analysis already if in these 2 modes + if ((run_mode == 'f') || (run_mode == 'v')) + a_conn_win->add_ana(&an_analysis); + + Fl::run(); + } + } + else + cout << err_msg << endl; + } +} + + +// minimal arg reading function, not very robust to errors +char +parse_args(int argc, char **argv, string *a_file_path, int *window, + int *threshold, char *ana_mode, float *ent_thres) +{ + int i, else_i; + string an_arg; + char run_mode; + + // initialize these to 0 as flag if they are not changed + *window = 0; + *threshold = 0; + *ent_thres = 0.0; + run_mode = 'e'; //error default if no run mode set implicitly or explicitly + *ana_mode = 't'; // default to transitivie analyses mode + + + + // no args means gui only mode + if (argc == 1) + run_mode = 'g'; + // 1 arg means its a mupa file and run in full mode + /* + else if (argc == 2) + { + } + */ + else + { + else_i = 0; + i = 1; + while (i < argc) + { + an_arg = * ++argv; + i++; + + // see what alternate mode the user wants to run in + if (an_arg == "-m") + { + an_arg = * ++argv; + i++; + if ( (an_arg == "v") || (an_arg == "n") ) //only 2 valid modes so far + run_mode = an_arg[0]; + else + { + cout << "Error: \'" << an_arg; + cout << "\' is not a valid analysis mode for -a argument" << endl; + run_mode = 'e'; + } + *a_file_path = * ++argv; + i++; + } + // alternate analyses modes + else if (an_arg == "-a") + { + an_arg = * ++argv; + i++; + // t = transitive, r = radial, e = entropy + if ( (an_arg == "t") || (an_arg == "r") || (an_arg == "e") ) + *ana_mode = an_arg[0]; + else + { + cout << "Error: \'" << an_arg; + cout << "\' is not a valid run mode for -m argument" << endl; + run_mode = 'e'; + } + + } + else if (an_arg == "-w") // alternate window size arg + { + *window = atoi(* ++argv); + i++; + } + else if (an_arg == "-t") // alternate threshold arg + { + *threshold = atoi(* ++argv); + i++; + } + else if (an_arg == "-et") // alternate entropy threshold arg + { + *ent_thres = atof(* ++argv); + i++; + } + else + { + if (else_i == 0) + { + *a_file_path = an_arg; + run_mode = 'f'; + else_i++; + } + else + { + //cout << "Error, unknown arg: \'" << an_arg << "\'" << endl; + cout << "Error, too many filenames: \'" << an_arg << "\'" << endl; + run_mode == 'e'; + } + } + } + } + + return run_mode; +} + + +/* + cout << "fee\n"; + cout << "fie\n"; + cout << "foe\n"; + cout << "fum\n"; +*/ diff --git a/mussa_class.cc b/mussa_class.cc deleted file mode 100644 index a6597ed..0000000 --- a/mussa_class.cc +++ /dev/null @@ -1,687 +0,0 @@ -// This file is part of the Mussa source distribution. -// http://mussa.caltech.edu/ -// Contact author: Tristan De Buysscher, tristan@caltech.edu - -// This program and all associated source code files are Copyright (C) 2005 -// the California Institute of Technology, Pasadena, CA, 91125 USA. It is -// under the GNU Public License; please see the included LICENSE.txt -// file for more information, or contact Tristan directly. - - -// ---------------------------------------- -// ---------- mussa_class.cc ----------- -// ---------------------------------------- - -#include "mussa_class.hh" - -#include -#include -#include - -using namespace std; - -Mussa::Mussa() -{ -} - -// set all parameters to null state -void -Mussa::clear() -{ - ana_name = ""; - seq_num = 0; - window = 0; - threshold = 0; - soft_thres = 0; - win_append = false; - thres_append = false; - seq_files.clear(); - fasta_indices.clear(); - annot_files.clear(); - sub_seq_starts.clear(); - sub_seq_ends.clear(); -} - -// these 5 simple methods manually set the parameters for doing an analysis -// used so that the gui can take input from user and setup the analysis -// note - still need a set_append(bool, bool) method... -void -Mussa::set_name(string a_name) -{ - ana_name = a_name; -} - -void -Mussa::set_seq_num(int a_num) -{ - seq_num = a_num; -} - -void -Mussa::set_window(int a_window) -{ - window = a_window; -} - -void -Mussa::set_threshold(int a_threshold) -{ - threshold = a_threshold; - //soft_thres = a_threshold; -} - -void -Mussa::set_soft_thres(int sft_thres) -{ - soft_thres = sft_thres; -} - -void -Mussa::set_ana_mode(char new_ana_mode) -{ - ana_mode = new_ana_mode; -} - -// takes a string and sets it as the next seq - no AGCTN checking atm -void -Mussa::add_a_seq(string a_seq) -{ - Sequence aSeq; - - aSeq.set_seq(a_seq); - the_Seqs.push_back(aSeq); -} - - -// sets info for just 1 seq at a time -void -Mussa::set_seq_info(string seq_file, string annot_file, int fa_i, int a_start, int the_end) -{ - seq_files.push_back(seq_file); - fasta_indices.push_back(fa_i); - annot_files.push_back(annot_file); - sub_seq_starts.push_back(a_start); - sub_seq_ends.push_back(the_end); -} - -string -Mussa::load_mupa_file(string para_file_path) -{ - ifstream para_file; - string file_data_line; - string param, value, annot_file; - int split_index, fasta_index; - int sub_seq_start, sub_seq_end; - bool seq_params, did_seq; - string err_msg; - int bogo; - bool parsing_path; - int new_index, dir_index; - - - // initialize values - clear(); - - para_file.open(para_file_path.c_str(), ios::in); - - // if file was opened, read the parameter values - if (para_file) - { - // need to find the path to the .mupa file - parsing_path = true; - dir_index = 0; - while (parsing_path) - { - new_index = (para_file_path.substr(dir_index)).find("/"); - //cout << "mu class: "<< new_index << endl; - if (new_index > 0) - dir_index += new_index + 1; - else - parsing_path = false; - } - - file_path_base = para_file_path.substr(0,dir_index); - cout << "mu class: mupa base path = " << file_path_base << endl; - - // setup loop by getting file's first line - getline(para_file,file_data_line); - split_index = file_data_line.find(" "); - param = file_data_line.substr(0,split_index); - value = file_data_line.substr(split_index+1); - - while (!para_file.eof()) - { - did_seq = false; - if (param == "ANA_NAME") - ana_name = value; - else if (param == "APPEND_WIN") - win_append = true; - else if (param == "APPEND_THRES") - thres_append = true; - else if (param == "SEQUENCE_NUM") - seq_num = atoi(value.c_str()); - else if (param == "WINDOW") - window = atoi(value.c_str()); - else if (param == "THRESHOLD") - threshold = atoi(value.c_str()); - else if (param == "SEQUENCE") - { - seq_files.push_back(file_path_base + value); - fasta_index = 1; - annot_file = ""; - sub_seq_start = 0; - sub_seq_end = 0; - seq_params = true; - - while ((!para_file.eof()) && seq_params) - { - getline(para_file,file_data_line); - split_index = file_data_line.find(" "); - param = file_data_line.substr(0,split_index); - value = file_data_line.substr(split_index+1); - - if (param == "FASTA_INDEX") - fasta_index = atoi(value.c_str()); - else if (param == "ANNOTATION") - annot_file = file_path_base + value; - else if (param == "SEQ_START") - sub_seq_start = atoi(value.c_str()); - else if (param == "SEQ_END") - { - cout << "hey! " << atoi(value.c_str()) << endl; - sub_seq_end = atoi(value.c_str()); - } - //ignore empty lines or that start with '#' - else if ((param == "") || (param == "#")) {} - else seq_params = false; - } - - fasta_indices.push_back(fasta_index); - annot_files.push_back(annot_file); - sub_seq_starts.push_back(sub_seq_start); - sub_seq_ends.push_back(sub_seq_end); - did_seq = true; - } - //ignore empty lines or that start with '#' - else if ((param == "") || (param == "#")) {} - else - { - cout << "Illegal/misplaced mussa parameter in file\n"; - cout << param << "\n"; - } - - if (!did_seq) - { - getline(para_file,file_data_line); - split_index = file_data_line.find(" "); - param = file_data_line.substr(0,split_index); - value = file_data_line.substr(split_index+1); - did_seq = false; - } - } - - para_file.close(); - - soft_thres = threshold; - cout << "nway mupa: ana_name = " << ana_name << " seq_num = " << seq_num; - cout << " window = " << window << " threshold = " << threshold << endl; - - return ""; - } - - // no file was loaded, signal error - else - { - err_msg = "Config File: " + para_file_path + " not found"; - return err_msg; - } -} - -// if (!((param == "") || (param == "#"))) -// cout << value << " = " << param << endl; - - -string -Mussa::analyze(int w, int t, char the_ana_mode, double new_ent_thres) -{ - string err_msg; - time_t t1, t2, begin, end; - double setuptime, seqloadtime, seqcomptime, nwaytime, savetime, totaltime; - - - cout << "nway ana: seq_num = " << seq_num << endl; - - begin = time(NULL); - - // now loading parameters from file must be done separately - //t1 = time(NULL); - //err_msg = load_mupa_file(para_file_path); - //t2 = time(NULL); - //setuptime = difftime(t2, t1); - - ana_mode = the_ana_mode; - ent_thres = new_ent_thres; - if (w > 0) - window = w; - if (t > 0) - { - threshold = t; - soft_thres = t; - } - - //if (err_msg == "") - //{ - cout << "fee\n"; - t1 = time(NULL); - err_msg = get_Seqs(); - t2 = time(NULL); - seqloadtime = difftime(t2, t1); - - - if (err_msg == "") - { - cout << "fie\n"; - t1 = time(NULL); - seqcomp(); - t2 = time(NULL); - seqcomptime = difftime(t2, t1); - - - cout << "foe\n"; - t1 = time(NULL); - cout << "nway ana: seq_num = " << seq_num << endl; - the_paths.setup(seq_num, window, threshold); - nway(); - t2 = time(NULL); - nwaytime = difftime(t2, t1); - - - cout << "fum\n"; - t1 = time(NULL); - save(); - t2 = time(NULL); - savetime = difftime(t2, t1); - - end = time(NULL); - totaltime = difftime(end, begin); - - - cout << "seqload\tseqcomp\tnway\tsave\ttotal\n"; - //setup\t - //cout << setuptime << "\t"; - cout << seqloadtime << "\t"; - cout << seqcomptime << "\t"; - cout << nwaytime << "\t"; - cout << savetime << "\t"; - cout << totaltime << "\n"; - } - else - return err_msg; - //} - //else - //return err_msg; -} - - -string -Mussa::get_Seqs() -{ - list::iterator seq_files_i, annot_files_i; - list::iterator fasta_indices_i, seq_starts_i, seq_ends_i; - Sequence aSeq; - string err_msg; - - - seq_files_i = seq_files.begin(); - fasta_indices_i = fasta_indices.begin(); - annot_files_i = annot_files.begin(); - seq_starts_i = sub_seq_starts.begin(); - seq_ends_i = sub_seq_ends.begin(); - - err_msg = ""; - - while ( (seq_files_i != seq_files.end()) && (err_msg == "") ) - /* it should be guarenteed that each of the following exist - should I bother checking, and how to deal with if not true... - && - (fasta_indices_i != fasta_indices.end()) && - (annot_files_i != annot_files.end()) && - (seq_starts_i != sub_seq_starts.end()) && - (seq_ends_i != sub_seq_ends.end()) ) - */ - { - err_msg = aSeq.load_fasta(*seq_files_i, *fasta_indices_i,*seq_starts_i, - *seq_ends_i); - if (err_msg == "") - { - if (*annot_files_i != "") - err_msg = aSeq.load_annot(*annot_files_i, *seq_starts_i, *seq_ends_i); - - if (err_msg == "") - { - the_Seqs.push_back(aSeq); - cout << aSeq.hdr() << endl; - //cout << aSeq.seq() << endl; - aSeq.clear(); - ++seq_files_i; // advance all the iterators - ++fasta_indices_i; - ++annot_files_i; - ++seq_starts_i; - ++seq_ends_i; - } - else - break; - } - else - break; - } - - return err_msg; -} - - -void -Mussa::seqcomp() -{ - int i, i2; // loop vars over sequences to analyze - vector seq_lens; - vector empty_FLP_vector; - FLPs dummy_comp; - string save_file_string; - - empty_FLP_vector.clear(); - for(i = 0; i < seq_num; i++) - { - all_comps.push_back(empty_FLP_vector); - for(i2 = 0; i2 < seq_num; i2++) - all_comps[i].push_back(dummy_comp); - } - for(i = 0; i < seq_num; i++) - seq_lens.push_back(the_Seqs[i].len()); - - for(i = 0; i < seq_num; i++) - for(i2 = i+1; i2 < seq_num; i2++) - { - cout << "seqcomping: " << i << " v. " << i2 << endl; - all_comps[i][i2].setup("m", window, threshold, seq_lens[i],seq_lens[i2]); - all_comps[i][i2].seqcomp(the_Seqs[i].seq(), the_Seqs[i2].seq(), false); - all_comps[i][i2].seqcomp(the_Seqs[i].seq(),the_Seqs[i2].rev_comp(),true); - } -} - - - -void -Mussa::nway() -{ - vector some_Seqs; - int i; - - - cout << "nway: ana mode = " << ana_mode << endl; - cout << "nway: seq_num = " << seq_num << endl; - - the_paths.set_soft_thres(soft_thres); - - if (ana_mode == 't') - the_paths.trans_path_search(all_comps); - - else if (ana_mode == 'r') - the_paths.radiate_path_search(all_comps); - - else if (ana_mode == 'e') - { - //unlike other methods, entropy needs to look at the sequence at this stage - some_Seqs.clear(); - for(i = 0; i < seq_num; i++) - some_Seqs.push_back(the_Seqs[i].seq()); - - the_paths.setup_ent(ent_thres, some_Seqs); // ent analysis extra setup - the_paths.entropy_path_search(all_comps); - } - - // old recursive transitive analysis function - else if (ana_mode == 'o') - the_paths.find_paths_r(all_comps); - - the_paths.simple_refine(); -} - -void -Mussa::save() -{ - string save_name, save_path, create_dir_cmd, flp_filepath; - fstream save_file; - ostringstream append_info; - int i, i2, dir_create_status; - - - // not sure why, but gotta close file each time since can't pass file streams - - save_name = ana_name; - - // gotta do bit with adding win & thres if to be appended - if (win_append) - { - append_info.str(""); - append_info << "_w" << window; - save_name += append_info.str(); - } - - if (thres_append) - { - append_info.str(""); - append_info << "_t" << threshold; - save_name += append_info.str(); - } - -//#include - // ******* use appropriate for os ------- 1 of 4 - // the additions for osX make it more sane where it saves the analysis - // will come up with a cleaner sol'n later... - create_dir_cmd = "mkdir " + save_name; //linux - //create_dir_cmd = "mkdir " + file_path_base + save_name; //osX - - dir_create_status = system( (const char*) create_dir_cmd.c_str()); - cout << "action: " << dir_create_status << endl; - - // save sequence and annots to a special mussa file - - // ******** use appropriate for OS ---------- 2 of 4 - save_path = save_name + "/" + save_name + ".museq"; //linux - //save_path = file_path_base + save_name + "/" + save_name + ".museq"; //osX - - save_file.open(save_path.c_str(), ios::out); - save_file << "" << endl; - //save_file.close(); - - for(i = 0; i < seq_num; i++) - the_Seqs[i].save(save_file); - - //save_file.open(save_path.c_str(), ios::app); - save_file << "" << endl; - save_file.close(); - - // save nway paths to its mussa save file - - // ******** use appropriate for OS -------- 3 of 4 - save_path = save_name + "/" + save_name + ".muway"; //linux - //save_path = file_path_base + save_name + "/" + save_name + ".muway"; //os X - the_paths.save(save_path); - - for(i = 0; i < seq_num; i++) - for(i2 = i+1; i2 < seq_num; i2++) - { - append_info.str(""); - append_info << "_sp_" << i << "v" << i2; - // ******** use appropriate for OS --------- 4 of 4 - //linux - save_path = save_name + "/" + save_name + append_info.str() + ".flp"; - //osX - //save_path = file_path_base + save_name + "/" + save_name + append_info.str() + ".flp"; - all_comps[i][i2].file_save(save_path); - } -} - -void -Mussa::save_muway(string save_path) -{ - the_paths.save(save_path); -} - -string -Mussa::load(string ana_file) -{ - int i, i2, new_index, dir_index; - string file_path_base, a_file_path, ana_path; - bool parsing_path; - Sequence tmp_seq; - string err_msg; - ostringstream append_info; - vector empty_FLP_vector; - FLPs dummy_comp; - - - ana_path = ana_file; - parsing_path = true; - dir_index = 0; - while (parsing_path) - { - new_index = (ana_path.substr(dir_index)).find("/"); - //cout << "mu class: "<< new_index << endl; - if (new_index > 0) - dir_index += new_index + 1; - else - parsing_path = false; - } - - ana_name = ana_path.substr(dir_index); - cout << "mu class: ana_name = " << ana_name << endl; - file_path_base = ana_path + "/" + ana_path.substr(dir_index); - a_file_path = file_path_base + ".muway"; - err_msg = the_paths.load(a_file_path); - cout << "there is no safe distance\n"; - - if (err_msg == "") - { - seq_num = the_paths.seq_num(); - - cout << "No BAM\n"; - - a_file_path = file_path_base + ".museq"; - - // this is a bit of a hack due to C++ not acting like it should with files - for (i = 1; i <= seq_num; i++) - { - tmp_seq.clear(); - cout << "mussa_class: loading the fucking museq frag...\n"; - tmp_seq.load_museq(a_file_path, i); - the_Seqs.push_back(tmp_seq); - } - - empty_FLP_vector.clear(); - for(i = 0; i < seq_num; i++) - { - all_comps.push_back(empty_FLP_vector); - for(i2 = 0; i2 < seq_num; i2++) - all_comps[i].push_back(dummy_comp); - } - - for(i = 0; i < seq_num; i++) - for(i2 = i+1; i2 < seq_num; i2++) - { - append_info.str(""); - append_info << "_sp_" << i << "v" << i2; - cout << append_info.str() << endl; - a_file_path = file_path_base + append_info.str() + ".flp"; - all_comps[i][i2].file_load(a_file_path); - cout << "real size = " << all_comps[i][i2].all_matches.size() << endl; - } - - - return ""; - } - else - return err_msg; -} - -/* - cout << "fee\n"; - cout << "fie\n"; - cout << "foe\n"; - cout << "fum\n"; -*/ - - - -void -Mussa::save_old() -{ - fstream save_file; - int i; - - save_file.open(ana_name.c_str(), ios::out); - - for(i = 0; i < seq_num; i++) - save_file << the_Seqs[i].seq() << endl; - - save_file << window << endl; - save_file.close(); - //note more complex eventually since ana_name may need to have - //window size, threshold and other stuff to modify it... - the_paths.save_old(ana_name); -} - - -void -Mussa::load_old(char * load_file_path, int s_num) -{ - fstream save_file; - string file_data_line; - int i, space_split_i, comma_split_i; - vector loaded_path; - string node_pair, node; - Sequence a_seq; - - seq_num = s_num; - the_paths.setup(seq_num, 0, 0); - save_file.open(load_file_path, ios::in); - - // currently loads old mussa format - - // get sequences - for(i = 0; i < seq_num; i++) - { - getline(save_file, file_data_line); - a_seq.set_seq(file_data_line); - the_Seqs.push_back(a_seq); - } - - // get window size - getline(save_file, file_data_line); - window = atoi(file_data_line.c_str()); - // get paths - - while (!save_file.eof()) - { - loaded_path.clear(); - getline(save_file, file_data_line); - if (file_data_line != "") - for(i = 0; i < seq_num; i++) - { - space_split_i = file_data_line.find(" "); - node_pair = file_data_line.substr(0,space_split_i); - //cout << "np= " << node_pair; - comma_split_i = node_pair.find(","); - node = node_pair.substr(comma_split_i+1); - //cout << "n= " << node << " "; - loaded_path.push_back(atoi (node.c_str())); - file_data_line = file_data_line.substr(space_split_i+1); - } - //cout << endl; - the_paths.add_path(loaded_path); - } - save_file.close(); - - //the_paths.save("tmp.save"); -} diff --git a/mussa_class.cxx b/mussa_class.cxx new file mode 100644 index 0000000..b571516 --- /dev/null +++ b/mussa_class.cxx @@ -0,0 +1,687 @@ +// This file is part of the Mussa source distribution. +// http://mussa.caltech.edu/ +// Contact author: Tristan De Buysscher, tristan@caltech.edu + +// This program and all associated source code files are Copyright (C) 2005 +// the California Institute of Technology, Pasadena, CA, 91125 USA. It is +// under the GNU Public License; please see the included LICENSE.txt +// file for more information, or contact Tristan directly. + + +// ---------------------------------------- +// ---------- mussa_class.cc ----------- +// ---------------------------------------- + +#include "mussa_class.hh" +#include "flp.hh" +#include +#include +#include + +using namespace std; + +Mussa::Mussa() +{ +} + +// set all parameters to null state +void +Mussa::clear() +{ + ana_name = ""; + seq_num = 0; + window = 0; + threshold = 0; + soft_thres = 0; + win_append = false; + thres_append = false; + seq_files.clear(); + fasta_indices.clear(); + annot_files.clear(); + sub_seq_starts.clear(); + sub_seq_ends.clear(); +} + +// these 5 simple methods manually set the parameters for doing an analysis +// used so that the gui can take input from user and setup the analysis +// note - still need a set_append(bool, bool) method... +void +Mussa::set_name(string a_name) +{ + ana_name = a_name; +} + +void +Mussa::set_seq_num(int a_num) +{ + seq_num = a_num; +} + +void +Mussa::set_window(int a_window) +{ + window = a_window; +} + +void +Mussa::set_threshold(int a_threshold) +{ + threshold = a_threshold; + //soft_thres = a_threshold; +} + +void +Mussa::set_soft_thres(int sft_thres) +{ + soft_thres = sft_thres; +} + +void +Mussa::set_ana_mode(char new_ana_mode) +{ + ana_mode = new_ana_mode; +} + +// takes a string and sets it as the next seq - no AGCTN checking atm +void +Mussa::add_a_seq(string a_seq) +{ + Sequence aSeq; + + aSeq.set_seq(a_seq); + the_Seqs.push_back(aSeq); +} + + +// sets info for just 1 seq at a time +void +Mussa::set_seq_info(string seq_file, string annot_file, int fa_i, int a_start, int the_end) +{ + seq_files.push_back(seq_file); + fasta_indices.push_back(fa_i); + annot_files.push_back(annot_file); + sub_seq_starts.push_back(a_start); + sub_seq_ends.push_back(the_end); +} + +string +Mussa::load_mupa_file(string para_file_path) +{ + ifstream para_file; + string file_data_line; + string param, value, annot_file; + int split_index, fasta_index; + int sub_seq_start, sub_seq_end; + bool seq_params, did_seq; + string err_msg; + int bogo; + bool parsing_path; + int new_index, dir_index; + + + // initialize values + clear(); + + para_file.open(para_file_path.c_str(), ios::in); + + // if file was opened, read the parameter values + if (para_file) + { + // need to find the path to the .mupa file + parsing_path = true; + dir_index = 0; + while (parsing_path) + { + new_index = (para_file_path.substr(dir_index)).find("/"); + //cout << "mu class: "<< new_index << endl; + if (new_index > 0) + dir_index += new_index + 1; + else + parsing_path = false; + } + + file_path_base = para_file_path.substr(0,dir_index); + cout << "mu class: mupa base path = " << file_path_base << endl; + + // setup loop by getting file's first line + getline(para_file,file_data_line); + split_index = file_data_line.find(" "); + param = file_data_line.substr(0,split_index); + value = file_data_line.substr(split_index+1); + + while (!para_file.eof()) + { + did_seq = false; + if (param == "ANA_NAME") + ana_name = value; + else if (param == "APPEND_WIN") + win_append = true; + else if (param == "APPEND_THRES") + thres_append = true; + else if (param == "SEQUENCE_NUM") + seq_num = atoi(value.c_str()); + else if (param == "WINDOW") + window = atoi(value.c_str()); + else if (param == "THRESHOLD") + threshold = atoi(value.c_str()); + else if (param == "SEQUENCE") + { + seq_files.push_back(file_path_base + value); + fasta_index = 1; + annot_file = ""; + sub_seq_start = 0; + sub_seq_end = 0; + seq_params = true; + + while ((!para_file.eof()) && seq_params) + { + getline(para_file,file_data_line); + split_index = file_data_line.find(" "); + param = file_data_line.substr(0,split_index); + value = file_data_line.substr(split_index+1); + + if (param == "FASTA_INDEX") + fasta_index = atoi(value.c_str()); + else if (param == "ANNOTATION") + annot_file = file_path_base + value; + else if (param == "SEQ_START") + sub_seq_start = atoi(value.c_str()); + else if (param == "SEQ_END") + { + cout << "hey! " << atoi(value.c_str()) << endl; + sub_seq_end = atoi(value.c_str()); + } + //ignore empty lines or that start with '#' + else if ((param == "") || (param == "#")) {} + else seq_params = false; + } + + fasta_indices.push_back(fasta_index); + annot_files.push_back(annot_file); + sub_seq_starts.push_back(sub_seq_start); + sub_seq_ends.push_back(sub_seq_end); + did_seq = true; + } + //ignore empty lines or that start with '#' + else if ((param == "") || (param == "#")) {} + else + { + cout << "Illegal/misplaced mussa parameter in file\n"; + cout << param << "\n"; + } + + if (!did_seq) + { + getline(para_file,file_data_line); + split_index = file_data_line.find(" "); + param = file_data_line.substr(0,split_index); + value = file_data_line.substr(split_index+1); + did_seq = false; + } + } + + para_file.close(); + + soft_thres = threshold; + cout << "nway mupa: ana_name = " << ana_name << " seq_num = " << seq_num; + cout << " window = " << window << " threshold = " << threshold << endl; + + return ""; + } + + // no file was loaded, signal error + else + { + err_msg = "Config File: " + para_file_path + " not found"; + return err_msg; + } +} + +// if (!((param == "") || (param == "#"))) +// cout << value << " = " << param << endl; + + +string +Mussa::analyze(int w, int t, char the_ana_mode, double new_ent_thres) +{ + string err_msg; + time_t t1, t2, begin, end; + double setuptime, seqloadtime, seqcomptime, nwaytime, savetime, totaltime; + + + cout << "nway ana: seq_num = " << seq_num << endl; + + begin = time(NULL); + + // now loading parameters from file must be done separately + //t1 = time(NULL); + //err_msg = load_mupa_file(para_file_path); + //t2 = time(NULL); + //setuptime = difftime(t2, t1); + + ana_mode = the_ana_mode; + ent_thres = new_ent_thres; + if (w > 0) + window = w; + if (t > 0) + { + threshold = t; + soft_thres = t; + } + + //if (err_msg == "") + //{ + cout << "fee\n"; + t1 = time(NULL); + err_msg = get_Seqs(); + t2 = time(NULL); + seqloadtime = difftime(t2, t1); + + + if (err_msg == "") + { + cout << "fie\n"; + t1 = time(NULL); + seqcomp(); + t2 = time(NULL); + seqcomptime = difftime(t2, t1); + + + cout << "foe\n"; + t1 = time(NULL); + cout << "nway ana: seq_num = " << seq_num << endl; + the_paths.setup(seq_num, window, threshold); + nway(); + t2 = time(NULL); + nwaytime = difftime(t2, t1); + + + cout << "fum\n"; + t1 = time(NULL); + save(); + t2 = time(NULL); + savetime = difftime(t2, t1); + + end = time(NULL); + totaltime = difftime(end, begin); + + + cout << "seqload\tseqcomp\tnway\tsave\ttotal\n"; + //setup\t + //cout << setuptime << "\t"; + cout << seqloadtime << "\t"; + cout << seqcomptime << "\t"; + cout << nwaytime << "\t"; + cout << savetime << "\t"; + cout << totaltime << "\n"; + } + else + return err_msg; + //} + //else + //return err_msg; +} + + +string +Mussa::get_Seqs() +{ + list::iterator seq_files_i, annot_files_i; + list::iterator fasta_indices_i, seq_starts_i, seq_ends_i; + Sequence aSeq; + string err_msg; + + + seq_files_i = seq_files.begin(); + fasta_indices_i = fasta_indices.begin(); + annot_files_i = annot_files.begin(); + seq_starts_i = sub_seq_starts.begin(); + seq_ends_i = sub_seq_ends.begin(); + + err_msg = ""; + + while ( (seq_files_i != seq_files.end()) && (err_msg == "") ) + /* it should be guarenteed that each of the following exist + should I bother checking, and how to deal with if not true... + && + (fasta_indices_i != fasta_indices.end()) && + (annot_files_i != annot_files.end()) && + (seq_starts_i != sub_seq_starts.end()) && + (seq_ends_i != sub_seq_ends.end()) ) + */ + { + err_msg = aSeq.load_fasta(*seq_files_i, *fasta_indices_i,*seq_starts_i, + *seq_ends_i); + if (err_msg == "") + { + if (*annot_files_i != "") + err_msg = aSeq.load_annot(*annot_files_i, *seq_starts_i, *seq_ends_i); + + if (err_msg == "") + { + the_Seqs.push_back(aSeq); + cout << aSeq.hdr() << endl; + //cout << aSeq.seq() << endl; + aSeq.clear(); + ++seq_files_i; // advance all the iterators + ++fasta_indices_i; + ++annot_files_i; + ++seq_starts_i; + ++seq_ends_i; + } + else + break; + } + else + break; + } + + return err_msg; +} + + +void +Mussa::seqcomp() +{ + int i, i2; // loop vars over sequences to analyze + vector seq_lens; + vector empty_FLP_vector; + FLPs dummy_comp; + string save_file_string; + + empty_FLP_vector.clear(); + for(i = 0; i < seq_num; i++) + { + all_comps.push_back(empty_FLP_vector); + for(i2 = 0; i2 < seq_num; i2++) + all_comps[i].push_back(dummy_comp); + } + for(i = 0; i < seq_num; i++) + seq_lens.push_back(the_Seqs[i].len()); + + for(i = 0; i < seq_num; i++) + for(i2 = i+1; i2 < seq_num; i2++) + { + cout << "seqcomping: " << i << " v. " << i2 << endl; + all_comps[i][i2].setup("m", window, threshold, seq_lens[i],seq_lens[i2]); + all_comps[i][i2].seqcomp(the_Seqs[i].seq(), the_Seqs[i2].seq(), false); + all_comps[i][i2].seqcomp(the_Seqs[i].seq(),the_Seqs[i2].rev_comp(),true); + } +} + + + +void +Mussa::nway() +{ + vector some_Seqs; + int i; + + + cout << "nway: ana mode = " << ana_mode << endl; + cout << "nway: seq_num = " << seq_num << endl; + + the_paths.set_soft_thres(soft_thres); + + if (ana_mode == 't') + the_paths.trans_path_search(all_comps); + + else if (ana_mode == 'r') + the_paths.radiate_path_search(all_comps); + + else if (ana_mode == 'e') + { + //unlike other methods, entropy needs to look at the sequence at this stage + some_Seqs.clear(); + for(i = 0; i < seq_num; i++) + some_Seqs.push_back(the_Seqs[i].seq()); + + the_paths.setup_ent(ent_thres, some_Seqs); // ent analysis extra setup + the_paths.entropy_path_search(all_comps); + } + + // old recursive transitive analysis function + else if (ana_mode == 'o') + the_paths.find_paths_r(all_comps); + + the_paths.simple_refine(); +} + +void +Mussa::save() +{ + string save_name, save_path, create_dir_cmd, flp_filepath; + fstream save_file; + ostringstream append_info; + int i, i2, dir_create_status; + + + // not sure why, but gotta close file each time since can't pass file streams + + save_name = ana_name; + + // gotta do bit with adding win & thres if to be appended + if (win_append) + { + append_info.str(""); + append_info << "_w" << window; + save_name += append_info.str(); + } + + if (thres_append) + { + append_info.str(""); + append_info << "_t" << threshold; + save_name += append_info.str(); + } + +//#include + // ******* use appropriate for os ------- 1 of 4 + // the additions for osX make it more sane where it saves the analysis + // will come up with a cleaner sol'n later... + create_dir_cmd = "mkdir " + save_name; //linux + //create_dir_cmd = "mkdir " + file_path_base + save_name; //osX + + dir_create_status = system( (const char*) create_dir_cmd.c_str()); + cout << "action: " << dir_create_status << endl; + + // save sequence and annots to a special mussa file + + // ******** use appropriate for OS ---------- 2 of 4 + save_path = save_name + "/" + save_name + ".museq"; //linux + //save_path = file_path_base + save_name + "/" + save_name + ".museq"; //osX + + save_file.open(save_path.c_str(), ios::out); + save_file << "" << endl; + //save_file.close(); + + for(i = 0; i < seq_num; i++) + the_Seqs[i].save(save_file); + + //save_file.open(save_path.c_str(), ios::app); + save_file << "" << endl; + save_file.close(); + + // save nway paths to its mussa save file + + // ******** use appropriate for OS -------- 3 of 4 + save_path = save_name + "/" + save_name + ".muway"; //linux + //save_path = file_path_base + save_name + "/" + save_name + ".muway"; //os X + the_paths.save(save_path); + + for(i = 0; i < seq_num; i++) + for(i2 = i+1; i2 < seq_num; i2++) + { + append_info.str(""); + append_info << "_sp_" << i << "v" << i2; + // ******** use appropriate for OS --------- 4 of 4 + //linux + save_path = save_name + "/" + save_name + append_info.str() + ".flp"; + //osX + //save_path = file_path_base + save_name + "/" + save_name + append_info.str() + ".flp"; + all_comps[i][i2].file_save(save_path); + } +} + +void +Mussa::save_muway(string save_path) +{ + the_paths.save(save_path); +} + +string +Mussa::load(string ana_file) +{ + int i, i2, new_index, dir_index; + string file_path_base, a_file_path, ana_path; + bool parsing_path; + Sequence tmp_seq; + string err_msg; + ostringstream append_info; + vector empty_FLP_vector; + FLPs dummy_comp; + + + ana_path = ana_file; + parsing_path = true; + dir_index = 0; + while (parsing_path) + { + new_index = (ana_path.substr(dir_index)).find("/"); + //cout << "mu class: "<< new_index << endl; + if (new_index > 0) + dir_index += new_index + 1; + else + parsing_path = false; + } + + ana_name = ana_path.substr(dir_index); + cout << "mu class: ana_name = " << ana_name << endl; + file_path_base = ana_path + "/" + ana_path.substr(dir_index); + a_file_path = file_path_base + ".muway"; + err_msg = the_paths.load(a_file_path); + cout << "there is no safe distance\n"; + + if (err_msg == "") + { + seq_num = the_paths.seq_num(); + + cout << "No BAM\n"; + + a_file_path = file_path_base + ".museq"; + + // this is a bit of a hack due to C++ not acting like it should with files + for (i = 1; i <= seq_num; i++) + { + tmp_seq.clear(); + cout << "mussa_class: loading the fucking museq frag...\n"; + tmp_seq.load_museq(a_file_path, i); + the_Seqs.push_back(tmp_seq); + } + + empty_FLP_vector.clear(); + for(i = 0; i < seq_num; i++) + { + all_comps.push_back(empty_FLP_vector); + for(i2 = 0; i2 < seq_num; i2++) + all_comps[i].push_back(dummy_comp); + } + + for(i = 0; i < seq_num; i++) + for(i2 = i+1; i2 < seq_num; i2++) + { + append_info.str(""); + append_info << "_sp_" << i << "v" << i2; + cout << append_info.str() << endl; + a_file_path = file_path_base + append_info.str() + ".flp"; + all_comps[i][i2].file_load(a_file_path); + cout << "real size = " << all_comps[i][i2].all_matches.size() << endl; + } + + + return ""; + } + else + return err_msg; +} + +/* + cout << "fee\n"; + cout << "fie\n"; + cout << "foe\n"; + cout << "fum\n"; +*/ + + + +void +Mussa::save_old() +{ + fstream save_file; + int i; + + save_file.open(ana_name.c_str(), ios::out); + + for(i = 0; i < seq_num; i++) + save_file << the_Seqs[i].seq() << endl; + + save_file << window << endl; + save_file.close(); + //note more complex eventually since ana_name may need to have + //window size, threshold and other stuff to modify it... + the_paths.save_old(ana_name); +} + + +void +Mussa::load_old(char * load_file_path, int s_num) +{ + fstream save_file; + string file_data_line; + int i, space_split_i, comma_split_i; + vector loaded_path; + string node_pair, node; + Sequence a_seq; + + seq_num = s_num; + the_paths.setup(seq_num, 0, 0); + save_file.open(load_file_path, ios::in); + + // currently loads old mussa format + + // get sequences + for(i = 0; i < seq_num; i++) + { + getline(save_file, file_data_line); + a_seq.set_seq(file_data_line); + the_Seqs.push_back(a_seq); + } + + // get window size + getline(save_file, file_data_line); + window = atoi(file_data_line.c_str()); + // get paths + + while (!save_file.eof()) + { + loaded_path.clear(); + getline(save_file, file_data_line); + if (file_data_line != "") + for(i = 0; i < seq_num; i++) + { + space_split_i = file_data_line.find(" "); + node_pair = file_data_line.substr(0,space_split_i); + //cout << "np= " << node_pair; + comma_split_i = node_pair.find(","); + node = node_pair.substr(comma_split_i+1); + //cout << "n= " << node << " "; + loaded_path.push_back(atoi (node.c_str())); + file_data_line = file_data_line.substr(space_split_i+1); + } + //cout << endl; + the_paths.add_path(loaded_path); + } + save_file.close(); + + //the_paths.save("tmp.save"); +} diff --git a/mussa_class.hh b/mussa_class.hh index efa6e91..334f10f 100644 --- a/mussa_class.hh +++ b/mussa_class.hh @@ -23,7 +23,6 @@ std::string int_to_str(int an_int); - class Mussa { friend class MussaOverlord; @@ -41,11 +40,11 @@ class Mussa bool win_override, thres_override; bool win_append, thres_append; - // sequence data + //! sequence data std::vector the_Seqs; - // the seqcomp data + //! the seqcomp data std::vector > all_comps; - // N-way data, ie the mussa results + //! N-way data, ie the mussa results Nway_Paths the_paths; diff --git a/mussa_gui_annot_window.cc b/mussa_gui_annot_window.cc deleted file mode 100644 index daa6a0f..0000000 --- a/mussa_gui_annot_window.cc +++ /dev/null @@ -1,185 +0,0 @@ -// This file is part of the Mussa source distribution. -// http://mussa.caltech.edu/ -// Contact author: Tristan De Buysscher, tristan@caltech.edu - -// This program and all associated source code files are Copyright (C) 2005 -// the California Institute of Technology, Pasadena, CA, 91125 USA. It is -// under the GNU Public License; please see the included LICENSE.txt -// file for more information, or contact Tristan directly. - - -#include "mussa_gui_annot_window.hh" -#include -#include - -using namespace std; - -annot_color -new_blank_annot() -{ - annot_color *a_annot; - - a_annot = new annot_color; - a_annot->type = ""; - a_annot->color = (Fl_Color) 5; - //cout << "type: " << a_annot->type << endl; - - return *a_annot; -} - - -void -cb_annot_color(Fl_Button* o, void* v) -{ - annot_instance * blah = (annot_instance *) v; - AnnotWindow* T= blah->mw_ptr; - T->cb_annot_color_i(o,blah->index); -} - -AnnotWindow::AnnotWindow(int w, int h, const char* title, - vector * some_annots):Fl_Window(w,h,title) -{ - int i, annot_num; - - the_annots = some_annots; - annot_count = 0; - - annot_color_buttons.clear(); - - begin(); - annot_input_pack = new Fl_Pack(0, 0, w, h); - annot_input_pack->spacing(4); - - // button to add new annot inputs - add_annot = new Fl_Button(0,0,100,24,"Add Annot Slot"); - add_annot->callback((Fl_Callback*)add_annot_cb, this); - annot_input_pack->add(add_annot); - // test button to make sure annot data is being stored - test = new Fl_Button(0,0,100,24,"show annots"); - test->callback((Fl_Callback*)print_cb, this); - annot_input_pack->add(test); - - // creat an initial set of annot input widgets and attach to annot vector - annot_num = some_annots->size(); - for (i = 0; i < annot_num; i++) - { - add_annot_input(i); - annot_count++; - } - - add(annot_input_pack); - - end(); - resizable(this); - show(); -} - - //tmp_input->user_data((void*) i); - -AnnotWindow::~AnnotWindow(){} - -void -AnnotWindow::add_annot_input(int index) -{ - Fl_Output * new_input; - Fl_Button *new_color_button; - annot_instance * something; - Fl_Pack * annot_hor_pack; - - - something = new annot_instance; - something->mw_ptr = this; - something->index = index; - - annot_hor_pack = new Fl_Pack(0, 0, w(), 24); - annot_hor_pack->type(Fl_Pack::HORIZONTAL); - annot_hor_pack->spacing(4); - - // setup the color display/selection button - new_color_button = new Fl_Button(0, 0, 24, 24, ""); - new_color_button->color((*the_annots)[index].color); - new_color_button->box(FL_FLAT_BOX); - new_color_button->callback((Fl_Callback*)cb_annot_color, (void*) something); - annot_color_buttons.push_back(new_color_button); - annot_hor_pack->add(new_color_button); - - - // setup the annot inputs - new_input = new Fl_Output(0, 0, 200, 24, ""); - new_input->value( ((*the_annots)[index].type).c_str() ); - //new_input->callback((Fl_Callback*)cb_annot_in, (void*) something); - annot_ins.push_back(new_input); - annot_hor_pack->add(new_input); - - annot_input_pack->add(annot_hor_pack); -} -/* - cout << "fee\n"; - cout << "fie\n"; - cout << "foe\n"; - cout << "fum\n"; -*/ - -void -AnnotWindow::cb_annot_in_i(Fl_Input* o, int i) -{ - (*the_annots)[i].type = o->value(); -} - -void -AnnotWindow::cb_annot_color_i(Fl_Button* o, int i) -{ - //Fl_Color new_color; - - (*the_annots)[i].color = fl_show_colormap((*the_annots)[i].color); - //annot_color_buttons[i]-> - o->color((*the_annots)[i].color); - redraw(); -} - -void AnnotWindow::add_annot_cb(Fl_Button* o, void* v) -{ - AnnotWindow* T=(AnnotWindow*)v; - T->add_annot_cb_real(o,v); -} - - -void AnnotWindow::add_annot_cb_real(Fl_Button* , void*) -{ - annot_color blank_annot; - - //blank_annot.name = ""; - //blank_annot.seq = ""; - blank_annot = new_blank_annot(); - (*the_annots).push_back(blank_annot); - add_annot_input(annot_count++); - redraw(); -} - - -void AnnotWindow::print_cb(Fl_Button* o, void* v) -{ - AnnotWindow* T=(AnnotWindow*)v; - T->print_cb_real(o,v); -} - - -void AnnotWindow::print_cb_real(Fl_Button* , void*) -{ - int i; - - for (i = 0; i < annot_count; i++) - cout << (*the_annots)[i].type << endl; -} - -/* -void -cb_annot_in(Fl_Input* o, void* v) -{ - annot_instance * blah = (annot_instance *) v; - AnnotWindow* T= blah->mw_ptr; - T->cb_annot_in_i(o,blah->index); -} - - -*/ diff --git a/mussa_gui_annot_window.hh b/mussa_gui_annot_window.hh deleted file mode 100644 index bd1a60c..0000000 --- a/mussa_gui_annot_window.hh +++ /dev/null @@ -1,72 +0,0 @@ -#ifndef _MUSSA_GUI_ANNOT_WINDOW_H_ -#define _MUSSA_GUI_ANNOT_WINDOW_H_ -// This file is part of the Mussa source distribution. -// http://mussa.caltech.edu/ -// Contact author: Tristan De Buysscher, tristan@caltech.edu - -// This program and all associated source code files are Copyright (C) 2005 -// the California Institute of Technology, Pasadena, CA, 91125 USA. It is -// under the GNU Public License; please see the included LICENSE.txt -// file for more information, or contact Tristan directly. - -#include -#include -#include - -#include -#include - -#include -#include -#include - -#include "mussa_gui_motif_window.hh" - -struct annot_color -{ - std::string type; - Fl_Color color; -}; - -//typedef annot_ptr *annot; - - -class AnnotWindow : public Fl_Window -{ - public: - AnnotWindow(int w, int h, const char* title, - std::vector * some_annots); - ~AnnotWindow(); - Fl_Pack * annot_input_pack; - std::list annot_ins; - std::vector annot_color_buttons; - std::list name_ins; - Fl_Button* test; - Fl_Button* add_annot; - - void cb_annot_in_i(Fl_Input*, int i); - void cb_annot_color_i(Fl_Button* o, int i); - - private: - std::vector * the_annots; - int annot_count; - - void add_annot_input(int index); - - static void add_annot_cb(Fl_Button*, void*); - inline void add_annot_cb_real(Fl_Button*, void*); - - static void print_cb(Fl_Button*, void*); - inline void print_cb_real(Fl_Button*, void*); -}; - -// crazy whacked shite Titus taught me to do to get an index value associated -// with each instance of an input associated with the callback... -struct annot_instance -{ - AnnotWindow * mw_ptr; - int index; -}; - -annot_color new_blank_annot(); -#endif diff --git a/mussa_gui_conn_view.cc b/mussa_gui_conn_view.cc deleted file mode 100644 index 2c91da7..0000000 --- a/mussa_gui_conn_view.cc +++ /dev/null @@ -1,703 +0,0 @@ -// This file is part of the Mussa source distribution. -// http://mussa.caltech.edu/ -// Contact author: Tristan De Buysscher, tristan@caltech.edu - -// This program and all associated source code files are Copyright (C) 2005 -// the California Institute of Technology, Pasadena, CA, 91125 USA. It is -// under the GNU Public License; please see the included LICENSE.txt -// file for more information, or contact Tristan directly. - - -#include "mussa_gui_conn_view.hh" - -#include -#include -using namespace std; - -void -ConnView::setup(string name, int sq_num, int win_len, - vector *some_seqs, - Nway_Paths *some_paths) -{ - int i, i2, seq_length; - Sequence a_seq; - motif blank_motif; - annot_color new_annot; - - - ana_name = name; - seq_num = sq_num; - window = win_len; - S = some_seqs; - P = some_paths; - - cout << "num of paths = " << some_paths->refined_pathz.size() << endl; - - cout << "x()=" << x() << " y()=" << y() << " w()=" << w() << " h()=" << h(); - cout << endl; - - max_seq_len = 0; - for(i = 0; i < seq_num; ++i) - { - a_seq = (*S)[i]; - cout << a_seq.len() << endl; - seq_length = a_seq.len(); - seq_lens.push_back(seq_length); - if (seq_length > max_seq_len) - max_seq_len = seq_length; - if (seq_length < 1000) - seq_scales.push_back(1); - else if (seq_length < 1000000) - seq_scales.push_back(2); - else - seq_scales.push_back(3); - } - - name_pad = 80; - y_pad = 20; - - x_scale_factor = (float) max_seq_len / (w() - name_pad); - cout << "scale factor is " << x_scale_factor << endl; - y_seq_incre = (h()-(y_pad*2)) / (seq_num - 1); - - - drag_start = -1000; - drag_end = -1000; - ref_seq_num = 0; - - dragging = false; - selected = false; - - highlight.clear(); - show_bars = false; - show_lines = false; - bar_interval = max_seq_len / 20; - line_interval = max_seq_len / 20; - ref_seq_num = 0; - - - some_motifs.clear(); - for(i = 0; i < 5; ++i) - { - blank_motif = new_blank_motif(); - some_motifs.push_back(blank_motif); - } - - // find all unique annotation type ids - some_annots.clear(); - vector::iterator annot_type_i; - list::iterator annot_i; - - // loop thru all sequences - for(i2 = 0; i2 < seq_num; i2++) - { - cout << "ConnView: annotation loop\n"; - // loop thru all annotation entries in this sequence - for(annot_i = (*S)[i2].annots.begin(); annot_i != (*S)[i2].annots.end(); ++annot_i) - { - cout << annot_i->start << ", " << annot_i->end << " : "; - cout << annot_i->name << " " << annot_i->type << endl; - // loop thru annotation types - annot_type_i = some_annots.begin(); - bool type_unfound = true; - while ((annot_type_i != some_annots.end()) && type_unfound) - { - if (annot_i->type == annot_type_i->type) - type_unfound = false; // stop search if found - ++annot_type_i; - } - //if unfound, then add to list - if (type_unfound) - { - new_annot = new_blank_annot(); - new_annot.type = annot_i->type; - some_annots.push_back(new_annot); - } - } - } -} - - -void -ConnView::scale_paths() -{ - vector a_path; - list >::iterator pathz_i; - int i2; - - - scaled_pathz.clear(); - - for(pathz_i = P->refined_pathz.begin(); pathz_i != P->refined_pathz.end(); ++pathz_i) - { - a_path = *pathz_i; - for(i2 = 0; i2 <= seq_num; i2++) - a_path[i2] = (int) (a_path[i2] / x_scale_factor); - scaled_pathz.push_back(a_path); - } -} - -void -ConnView::toggle_bars() -{ - show_bars = !show_bars; - redraw(); -} - -void -ConnView::set_bar_interval(int new_bar_len) -{ - bar_interval = new_bar_len; - cout << "bar interval = " << bar_interval << endl; - redraw(); -} - -void -ConnView::toggle_lines() -{ - show_lines = !show_lines; - redraw(); -} - -void -ConnView::set_line_interval(int new_line_len) -{ - line_interval = new_line_len; - cout << "line interval = " << line_interval << endl; - redraw(); -} - - -void -ConnView::draw() -{ - // this is temporary - check if new motifs have been added - check_new_motifs(); - - // clear drawing area and set background to white - fl_color(FL_WHITE); - fl_rectf(x(), y(), w(), h()); - - - // draw the scale indicators if they are on - // put into own method soon... - int i, div_num, x_loc; - float div_len_scaled; - - if (show_bars) - { - div_num = max_seq_len / bar_interval; - div_len_scaled = ((float) bar_interval) / x_scale_factor; - fl_color(230,230,230); - for(i = 0; i <= div_num; i+=2) - { - x_loc = (int)(i * div_len_scaled+x()); - fl_rectf(x_loc, y(), (int) div_len_scaled, h()); - } - } - - if (show_lines) - { - div_num = max_seq_len / line_interval; - div_len_scaled = ((float) line_interval) / x_scale_factor; - fl_color(0,0,0); - fl_line_style(FL_SOLID, 1, NULL); - for(i = 0; i <= div_num; i++) - { - x_loc = (int)(i * div_len_scaled+x()); - fl_line(x_loc, y(), x_loc, h()+y()); - } - } - - - // divide up the space with some light blue lines - fl_color(150,200,255); - fl_line_style(FL_SOLID, 2, NULL); - fl_rect(x(), y(), w(), h()); - fl_line(w()+x()-name_pad, y(), w()+x()-name_pad, h()+y()); - - draw_paths(); - - // white out any overdraw from path area into name/info area - fl_color(FL_WHITE); - fl_rectf(w()+x()-name_pad, y(), w()+x(), h()); - - draw_sequence_stuff(); - - // draw selection box - /* - if (selected) - { - fl_color(FL_BLACK); - fl_line_style(FL_SOLID, 1, NULL); - fl_rect(drag_start,(ref_seq_num*y_seq_incre)+y(),drag_end-drag_start, - 16); - } - */ -} - - -void -ConnView::draw_paths() -{ - list >::iterator i; - int i2, i3, y_loc, x_loc, x_start, x_end; - vector a_path; - list::iterator highlight_i; - int window_size; - bool rc_color; - int path_start, path_end; - //Sequence a_seq; - - - // determine which paths to highlight - highlight.clear(); - for(i = scaled_pathz.begin(); i != scaled_pathz.end(); ++i) - { - a_path = *i; - // determine if path falls within the selected region and mark it for - // highlighted color - path_start = abs(a_path[ref_seq_num+1]); - path_end = path_start + a_path[0]; - if ( ( (path_start >= drag_start-x()) && (path_end <= drag_end-x()) ) || - ( (path_start < drag_start-x()) && (path_end > drag_end-x()) ) || - ( (path_start < drag_start-x()) && (path_end > drag_start-x()) ) || - ( (path_start < drag_end-x()) && (path_end > drag_end-x()) ) ) - highlight.push_back(true); - else - highlight.push_back(false); - } - - fl_line_style(FL_SOLID, 1, NULL); - // draw non-highlight paths (ie not in the selection box) - highlight_i = highlight.begin(); - for(i = scaled_pathz.begin(); i != scaled_pathz.end(); ++i) - { - a_path = *i; - y_loc = y()+y_pad; - - // get window size to determine line width - window_size = a_path[0]; - // make sure width is at least 1 - might be zero to my slack rounding - if (window_size == 0) - window_size = 1; - - if (!(*highlight_i)) - for(i2 = 1; i2 < seq_num; i2++) - { - // RC case handling - // ugh, an xor...only want blue if one of the nodes is rc - if ( ((a_path[i2] < 0) || (a_path[i2+1] < 0)) && - !((a_path[i2] < 0) && (a_path[i2+1] < 0)) ) - fl_color(200,200,255); - else - fl_color(255,200,200); - - fl_line_style(FL_SOLID, 1, NULL); - fl_polygon((int)abs(a_path[i2])+x(), y_loc + 3, - (int)abs(a_path[i2])+window_size+x(), y_loc + 3, - (int)abs(a_path[i2+1])+window_size+x(), y_loc + y_seq_incre - 3, - (int)abs(a_path[i2+1])+x(), y_loc + y_seq_incre - 3); - - y_loc += y_seq_incre; - } - ++highlight_i; - } - - // draw highlighted paths (ie in or partially in selection) - // drawing these separately and after other paths so they are on top - highlight_i = highlight.begin(); - for(i = scaled_pathz.begin(); i != scaled_pathz.end(); ++i) - { - a_path = *i; - y_loc = y()+y_pad; - - // get window size to determine line width - window_size = a_path[0]; - // make sure width is at least 1 - might be zero to my slack rounding - if (window_size == 0) - window_size = 1; - - if (*highlight_i) - for(i2 = 1; i2 < seq_num; i2++) - { - // RC case handling - // ugh, an xor...only want blue if one of the nodes is rc - if ( ((a_path[i2] < 0) || (a_path[i2+1] < 0)) && - !((a_path[i2] < 0) && (a_path[i2+1] < 0)) ) - fl_color(FL_BLUE); - else - fl_color(FL_RED); - - fl_polygon((int)abs(a_path[i2])+x(), y_loc + 3, - (int)abs(a_path[i2])+window_size+x(), y_loc + 3, - (int)abs(a_path[i2+1])+window_size+x(), y_loc + y_seq_incre - 3, - (int)abs(a_path[i2+1])+x(), y_loc + y_seq_incre - 3); - - y_loc += y_seq_incre; - } - ++highlight_i; - } -} - -/* - list >::iterator i; - int window_size; - bool rc_color; - int path_start, path_end; - Sequence a_seq; - vector a_path; -*/ - -void -ConnView::draw_sequence_stuff() -{ - int i2, i3, y_loc, y_offset, x_loc, x_start, x_end, mv_offset; - list::iterator annot_i; - string species_name, seq_length; - stringstream raw_length; - - - // draw sequence representation lines - fl_font(FL_COURIER, 14); - //fl_color(FL_BLACK); - fl_color(100,100,100); - // normally size 7, adjust for various screenshotage - fl_line_style(FL_SOLID, 11, NULL); - y_loc = y()+y_pad; - y_offset = 5; - for(i2 = 0; i2 < seq_num; i2++) - { - if (i2 == seq_num - 1) - y_offset = -10; - x_loc = (int)(seq_lens[i2] / x_scale_factor) + x(); - //report_float("seq scaled len", x_loc); - fl_line(x(),y_loc,x_loc,y_loc); - - species_name = (*S)[i2].species; - fl_draw(species_name.c_str(), x()+w()-name_pad+5, y_loc+y_offset); - - // funkiness to figure out which genomic scale to report size in - if (seq_scales[i2] == 1) - raw_length << setprecision(3) << seq_lens[i2] << " bp"; - else if (seq_scales[i2] == 2) - raw_length << setprecision(3) << seq_lens[i2] / 1000.0 << " Kb"; - else if (seq_scales[i2] == 3) - raw_length << setprecision(3) << seq_lens[i2] /1000000.0<< " Mb"; - seq_length = raw_length.str(); - fl_draw(seq_length.c_str(), x()+w()-name_pad+5, y_loc+y_offset+15); - raw_length.str(""); - - y_loc += y_seq_incre; - } - - //fl_line(x(),y()+y_pad/2,w()-name_pad,y()+y_pad/2); - //fl_line(x(),y()+h()-y_pad/2,w()-name_pad,y()+h()-y_pad/2); - - // draw annotations - vector::iterator annot_type_i; - - fl_color(FL_GREEN); - fl_line_style(FL_SOLID, 3, NULL); - y_loc = y()+y_pad; - for(i2 = 0; i2 < seq_num; i2++) - { - // loop thru all annotation entries - for(annot_i = (*S)[i2].annots.begin(); annot_i != (*S)[i2].annots.end(); ++annot_i) - { - fl_line_style(FL_SOLID, 7, NULL); - mv_offset = 0; - - // loop thru annotation types to determine color - annot_type_i = some_annots.begin(); - bool type_unfound = true; - while ((annot_type_i != some_annots.end()) && type_unfound) - { - if (annot_i->type == annot_type_i->type) - { - fl_color(annot_type_i->color); - type_unfound = false; - } - else - fl_color(FL_GREEN); - ++annot_type_i; - } - - // calculate scaled start and end, and draw - x_start = (int)(annot_i->start / x_scale_factor) + x(); - x_end = (int)(annot_i->end / x_scale_factor) + x(); - fl_line(x_start,y_loc+mv_offset,x_end,y_loc+mv_offset); - } - y_loc += y_seq_incre; - } - - - // draw motifs found - vector::iterator motif_i; - vector some_motif_locs; - vector::iterator i_locs; - int scale_len, motif_len; - - fl_color(255,0,255); - fl_line_style(FL_SOLID, 9, NULL); - motif_i = some_motifs.begin(); - while (motif_i != some_motifs.end()) - { - fl_color(motif_i->color); - motif_len = motif_i->seq.length(); - scale_len = (int) (motif_len / x_scale_factor); - if (scale_len == 0) - scale_len = 1; - y_loc = y()+y_pad; - if (!motif_i->locations.empty()) - for(i2 = 0; i2 < seq_num; i2++) - { - some_motif_locs = (*motif_i).locations[i2]; - - i_locs = some_motif_locs.begin(); - while (i_locs != some_motif_locs.end()) - { - x_start = (int)(*i_locs / x_scale_factor) + x(); - fl_line(x_start,y_loc,x_start+scale_len,y_loc); - ++i_locs; - } - y_loc += y_seq_incre; - } - ++motif_i; - } -} - - -void -ConnView::resize(int new_x, int new_y, int new_w, int new_h) -{ - - x(new_x); - y(new_y); - w(new_w); - h(new_h); - - x_scale_factor = (float) max_seq_len / (w() - name_pad); - cout << "scale factor is " << x_scale_factor << endl; - y_seq_incre = (h()-(2*y_pad)) / (seq_num - 1); - - scale_paths(); -} - - -void -ConnView::reporter(string var, int value) -{ - cout << var << " : " << value << endl; -} - - -void -ConnView::report_float(string var, float value) -{ - cout << var << " : " << value << endl; -} - -int -ConnView::handle(int e) -{ - int return_value; - float y_calc_tmp; - - // this empty string needs to be put on cout, otherwise the -O optimize - // compile option seems to throw this function away with the following: - // gcc version 3.2.2 20030222 (Red Hat Linux 3.2.2-5) - cout << ""; - - // why do I need a -O for this module? Well, originally I just used the - // same compile flags for all modules. I changed that. However, on debian - // systems I need the -O otherwise the behavior I observe on redhat machines - // with above compiler happens if I don't have that empty cout. WTF - - switch(e) - { - case FL_PUSH: - if (Fl::event_button3()) - { - spawnSeq(); - return_value = 1; - } - else if (Fl::event_button2()) - { - find_motifs(); - return_value = 1; - } - break; - case FL_DRAG: - if (!dragging) - { - drag_start = Fl::event_x(); - y_drag_start = (float) Fl::event_y(); - ref_seq_num = (int) (round ( (y_drag_start/y_seq_incre) ) ); - dragging = true; - selected = false; - return_value = 1; - } - fl_line_style(FL_SOLID, 1, NULL); - fl_overlay_rect(drag_start, (ref_seq_num*y_seq_incre)+y(), - Fl::event_x()-drag_start, 16); - - break; - case FL_RELEASE: - if (dragging) - { - drag_end = Fl::event_x(); - dragging = false; - selected = true; - redraw(); - return_value = 1; - } - break; - default: - return_value = Fl_Widget::handle(e); - } - - return return_value; -} - - - -void -ConnView::check_new_motifs() -{ - vector::iterator i; - int i2; - vector some_motif_locs; - vector::iterator i_locs; - - i = some_motifs.begin(); - while (i != some_motifs.end()) - { - if (i->dirty) - { - cout << i->seq << " is new\n"; - i->locations.clear(); - //i_locs = i->locations; - for(i2 = 0; i2 < seq_num; i2++) - { - some_motif_locs = (*S)[i2].find_motif(i->seq); - (*i).locations.push_back(some_motif_locs); - - - i_locs = some_motif_locs.begin(); - while (i_locs != some_motif_locs.end()) - { - cout << *i_locs << " "; - ++i_locs; - } - cout << endl; - - } - - i->dirty = false; - } - ++i; - } -} - - -void -ConnView::spawnSeq() -{ - list > selected_paths; - list >::iterator pathz_i; - int i2, i3, y_loc, x_loc, x_start, x_end; - vector a_path; - list::iterator highlight_i; - int y_max; - string window_name; - - - if (selected) - { - // make new list of connections that are highlighted - selected_paths.clear(); - highlight_i = highlight.begin(); - for(pathz_i = P->refined_pathz.begin(); pathz_i != P->refined_pathz.end(); ++pathz_i) - { - if (*highlight_i) - { - a_path = *pathz_i; - selected_paths.push_back(a_path); - } - ++highlight_i; - } - - // give 50 pixels of height per sequence - y_max = seq_num * 50; - window_name = "Mussa Sequence: " + ana_name; - - a_seq_win = new SeqWindow(800, y_max, (const char*) window_name.c_str(), - seq_num, - S, selected_paths, seq_lens, &some_motifs); - } -} - - -void -ConnView::find_motifs() -{ - motif_find_window = new MotifWindow(300, 300, "Motifs", &some_motifs); -} - -void -ConnView::annot_win() -{ - annot_color_window = new AnnotWindow(300, 300, "Annotations", &some_annots); -} - -// @!@! special hacked in color coding for the myf5/6 region annots - -/* - if (annot_i->type == "mvista") - { - fl_color(255,230,0); - fl_line_style(FL_SOLID, 8, NULL); - mv_offset = -4; - } - else if (annot_i->type == "reg") - { - fl_line_style(FL_SOLID, 10, NULL); - mv_offset = -8; - - if (annot_i->name == "CNS") - fl_color(255,150,0); - else if (annot_i->name == "ELA") - fl_color(0,200,120); - else if (annot_i->name == "ES") - fl_color(0,200,200); - else if (annot_i->name == "NA") - fl_color(120,120,120); - else if (annot_i->name == "EA") - { - fl_line_style(FL_SOLID, 7, NULL); - mv_offset = -13; - fl_color(0,200,120); - } - else if (annot_i->name == "VS") - { - fl_line_style(FL_SOLID, 7, NULL); - mv_offset = -6; - fl_color(255,255,0); - } - else if (annot_i->name == "SP") - { - fl_line_style(FL_SOLID, 7, NULL); - mv_offset = -13; - fl_color(255,230,150); - } - else if (annot_i->name == "L") - { - fl_line_style(FL_SOLID, 7, NULL); - mv_offset = -6; - fl_color(0,0,100); - } - else if (annot_i->name == "TCM") - fl_color(0,130,230); - } -*/ diff --git a/mussa_gui_conn_view.hh b/mussa_gui_conn_view.hh deleted file mode 100644 index 75d5b5b..0000000 --- a/mussa_gui_conn_view.hh +++ /dev/null @@ -1,89 +0,0 @@ -#ifndef _MUSSA_GUI_CONN_VIEW_H_ -#define _MUSSA_GUI_CONN_VIEW_H_ -// This file is part of the Mussa source distribution. -// http://mussa.caltech.edu/ -// Contact author: Tristan De Buysscher, tristan@caltech.edu - -// This program and all associated source code files are Copyright (C) 2005 -// the California Institute of Technology, Pasadena, CA, 91125 USA. It is -// under the GNU Public License; please see the included LICENSE.txt -// file for more information, or contact Tristan directly. - -#include -#include -#include -#include - -#include "mussa_gui_annot_window.hh" -#include "mussa_gui_subana.hh" - - -class ConnView : public Fl_Box -{ - public: - ConnView(int x_top,int y_top,int x_bot,int y_bot) : - Fl_Box(x_top,y_top,x_bot,y_bot) - {} - - void setup(std::string name, int sq_num, int win_len, - std::vector *, Nway_Paths *); - void scale_paths(); - - void spawnSeq(); - void find_motifs(); - void annot_win(); - - void toggle_bars(); - void set_bar_interval(int new_bar_len); - void toggle_lines(); - void set_line_interval(int new_line_len); - - - private: - std::string ana_name; - int seq_num, window, threshold; - bool win_append, thres_append; - - //this data is passed as pointers to the instantiated classes - std::vector *S; - Nway_Paths *P; - - int name_pad, y_pad; - float x_scale_factor; - int y_seq_incre; - int drag_start, drag_end; - float y_drag_start; - int ref_seq_num, max_seq_len; - bool dragging, selected; - std::list highlight; - - //path data scaled for current view size - std::list > scaled_pathz; - std::vector seq_lens; - std::vector seq_scales; - int bar_interval, line_interval; - bool show_bars, show_lines; - - //keeps track of all the motifs the user has inputed - std::vector some_motifs; - MotifWindow *motif_find_window; - - //keeps track of the colors assigned to each motif type - std::vector some_annots; - AnnotWindow *annot_color_window; - - SeqWindow *a_seq_win; - - void draw(); - void draw_paths(); - void draw_sequence_stuff(); - - void resize(int x, int y, int w, int h); - int handle(int e); - void check_new_motifs(); - - //for drawing function debugging - void reporter(std::string var, int value); - void report_float(std::string var, float value); -}; -#endif diff --git a/mussa_gui_conn_window.cc b/mussa_gui_conn_window.cc deleted file mode 100644 index 4574372..0000000 --- a/mussa_gui_conn_window.cc +++ /dev/null @@ -1,420 +0,0 @@ -// This file is part of the Mussa source distribution. -// http://mussa.caltech.edu/ -// Contact author: Tristan De Buysscher, tristan@caltech.edu - -// This program and all associated source code files are Copyright (C) 2005 -// the California Institute of Technology, Pasadena, CA, 91125 USA. It is -// under the GNU Public License; please see the included LICENSE.txt -// file for more information, or contact Tristan directly. - - -#include "mussa_gui_conn_window.hh" - -#include -using namespace std; - -void -load_ana_cb(Fl_Button* o, void* v) -{ - ConnWindow* T=(ConnWindow*)v; - T->real_load_ana_cb(); -} - - -void -ConnWindow::real_load_ana_cb() -{ - char *picked_file; - string a_file_path; - string err_msg; - - cout << "Load! Load! Load, ye yellow-bellied seadogs!\n"; - //picked_file = fl_file_chooser("Find an Analysis", "", "", 1); - picked_file = fl_dir_chooser("Find an Analysis", "", 1); - if (picked_file != NULL) - { - a_file_path = picked_file; - cout << "doo wah diddy diddy dum diddy doo\n"; - cout << a_file_path << endl; - - // load the analysis - an_analysis = new Mussa(); - err_msg = an_analysis->load(a_file_path); - //.substr(0,a_file_path.find(".mu"))); - - if (err_msg == "") - { - // relabel window with the analysis name - window_name = "Mussa: " + an_analysis->ana_name; - label((const char*)window_name.c_str()); - // show the user the analysis - conn_box->setup(an_analysis->ana_name, an_analysis->seq_num, - an_analysis->window, &(an_analysis->the_Seqs), - &(an_analysis->the_paths)); - conn_box->scale_paths(); - } - else - { - fl_alert(err_msg.c_str()); - cout << err_msg << endl; - } - } -} - - -void -do_ana_cb(Fl_Button* o, void* v) -{ - ConnWindow* T=(ConnWindow*)v; - T->real_do_ana_cb(); -} - - -void -ConnWindow::real_do_ana_cb() -{ - char *picked_file; - string a_file_path; - string err_msg; - - picked_file = fl_file_chooser("Analysis Config File", "", "", 1); - if (picked_file != NULL) - { - a_file_path = picked_file; - - an_analysis = new Mussa(); - err_msg = an_analysis->load_mupa_file(a_file_path); - - if (err_msg == "") - { - err_msg = an_analysis->analyze(0, 0, 't', 0.0); - } - - if (err_msg == "") - { - // relabel window with the analysis name - window_name = "Mussa: " + an_analysis->ana_name; - label((const char*)window_name.c_str()); - // show the user the analysis - conn_box->setup(an_analysis->ana_name, an_analysis->seq_num, - an_analysis->window, &(an_analysis->the_Seqs), - &(an_analysis->the_paths)); - conn_box->scale_paths(); - } - else - { - fl_alert(err_msg.c_str()); - cout << err_msg; - } - } -} - - -void -setup_ana_cb(Fl_Button* o, void* v) -{ - ConnWindow* T=(ConnWindow*)v; - T->real_setup_ana_cb(); -} - -void -ConnWindow::real_setup_ana_cb() -{ - an_analysis = new Mussa(); - setup_win = new SetupWindow(650,700,"Analysis Setup", an_analysis); - - while(setup_win->visible()) - Fl::wait(.1); - cout << "Like a warm summer day\n"; - - if (setup_win->done()) - { - // relabel window with the analysis name - window_name = "Mussa: " + an_analysis->ana_name; - label((const char*)window_name.c_str()); - // is it this easy? what if setup window encounters an error...?? - conn_box->setup(an_analysis->ana_name, an_analysis->seq_num, - an_analysis->window, &(an_analysis->the_Seqs), - &(an_analysis->the_paths)); - - conn_box->scale_paths(); - } -} - - -void -subana_cb(Fl_Button* o, void* v) -{ - ConnWindow* T=(ConnWindow*)v; - T->real_subana_cb(); -} - -void -ConnWindow::real_subana_cb() -{ - string subana_name; - - sub_analysis = new Mussa(); - subana_win = new SubanaWindow(500,400,"Sub Analysis Setup", sub_analysis, - an_analysis->the_Seqs); - - while(subana_win->visible()) - Fl::wait(.1); - cout << "Like a warm summer day\n"; - - if (subana_win->done()) - { - subana_name = "SubMussa: " + sub_analysis->ana_name; - sub_conn_win = new ConnWindow(w(), h(), (const char*) subana_name.c_str()); - cout << "Like a warm day in may\n"; - sub_conn_win->add_ana(sub_analysis); - //Fl::visual(FL_DOUBLE|FL_INDEX); - //sub_conn_box->show(); - } -} - - -void -seq_show_cb(Fl_Button* o, void* v) -{ - ConnWindow* T=(ConnWindow*)v; - T->real_seq_show_cb(); -} - -void -ConnWindow::real_seq_show_cb() -{ - show_seq_win = new SeqTextWin(500,400,"Seq Show", an_analysis->the_Seqs); -} - -void -seq_win_spawn_cb(Fl_Button* o, void* v) -{ - ConnWindow* T=(ConnWindow*)v; - T->real_seq_win_spawn_cb(); -} - -void -ConnWindow::real_seq_win_spawn_cb() -{ - conn_box->spawnSeq(); -} - -void -motif_find_cb(Fl_Button* o, void* v) -{ - ConnWindow* T=(ConnWindow*)v; - T->real_motif_find_cb(); -} - -void -ConnWindow::real_motif_find_cb() -{ - conn_box->find_motifs(); -} - -void -annot_win_cb(Fl_Button* o, void* v) -{ - ConnWindow* T=(ConnWindow*)v; - T->real_annot_win_cb(); -} - -void -ConnWindow::real_annot_win_cb() -{ - conn_box->annot_win(); -} - - -// all the crap needed for dealing with the scale bars -void -toggle_scale_bars_cb(Fl_Button* o, void* v) -{ - ConnWindow* T=(ConnWindow*)v; - T->real_toggle_bars_cb(); -} - -void -ConnWindow::real_toggle_bars_cb() -{ - conn_box->toggle_bars(); -} - -void -set_bar_len_cb(Fl_Input* o, void* v) -{ - ConnWindow* T=(ConnWindow*)v; - cout << "WAAAAAAAAA\n"; - T->real_set_bar_len_cb(o); -} - -void -ConnWindow::real_set_bar_len_cb(Fl_Input* o) -{ - int new_bar_len; - - new_bar_len = atoi(o->value()); - cout << "new bar len = " << new_bar_len << endl; - conn_box->set_bar_interval(new_bar_len); -} - - -// all the crap needed for dealing with the scale lines -void -toggle_scale_lines_cb(Fl_Button* o, void* v) -{ - ConnWindow* T=(ConnWindow*)v; - T->real_toggle_lines_cb(); -} - -void -ConnWindow::real_toggle_lines_cb() -{ - conn_box->toggle_lines(); -} - -void -set_line_len_cb(Fl_Input* o, void* v) -{ - ConnWindow* T=(ConnWindow*)v; - cout << "WAAAAAAAAA\n"; - T->real_set_line_len_cb(o); -} - -void -ConnWindow::real_set_line_len_cb(Fl_Input* o) -{ - int new_line_len; - - new_line_len = atoi(o->value()); - cout << "new line len = " << new_line_len << endl; - conn_box->set_line_interval(new_line_len); -} - - -// setting new soft threshold - -void -set_soft_thres_cb(Fl_Input* o, void* v) -{ - ConnWindow* T=(ConnWindow*)v; - cout << "WAAAAAAAAA\n"; - T->real_set_soft_thres_cb(o); -} - -void -ConnWindow::real_set_soft_thres_cb(Fl_Input* o) -{ - int new_soft_thres; - - new_soft_thres = atoi(o->value()); - cout << "new soft thres = " << new_soft_thres << endl; - - an_analysis->set_soft_thres(new_soft_thres); - an_analysis->set_ana_mode('t'); - an_analysis->nway(); - conn_box->scale_paths(); - conn_box->redraw(); - - // hacked in stuff to save muway files at different thresholds - string save_path; - ostringstream append_info; - - save_path = an_analysis->ana_name + "/" - + an_analysis->ana_name.substr(0,an_analysis->ana_name.find("_t")); - append_info.str(""); - append_info << "_t" << new_soft_thres << ".muway"; - //<< "_w" << an_analysis->window - save_path += append_info.str(); - cout << "saving as: " << save_path << endl; - an_analysis->save_muway(save_path); -} - - - - -ConnWindow::ConnWindow(int w, int h, const char* title): - Fl_Double_Window(w,h,title) -{ - int button_len = 120; - Fl_Color a_color = fl_rgb_color(150, 200, 255); - - padding = 5; - - begin(); - //fl_color(150,200,255); - color(FL_WHITE); - resizable(this); - - - // create file menu button - file_menu = new Fl_Menu_Button(padding, 2, button_len, 30, "Analysis"); - file_menu->color(FL_WHITE,a_color); - file_menu->box(FL_BORDER_BOX); - file_menu->clear(); - - // add menu items - file_menu->add("Do Analysis", 0, (Fl_Callback *) do_ana_cb, this); - file_menu->add("Load Analysis", 0, (Fl_Callback *) load_ana_cb, this); - file_menu->add("Setup Analysis", 0, (Fl_Callback *) setup_ana_cb, this); - file_menu->add("Sub Analysis", 0, (Fl_Callback *) subana_cb, this); - - - view_menu = new Fl_Menu_Button(padding+button_len,2, button_len, 30, "View"); - view_menu->color(FL_WHITE,a_color); - view_menu->box(FL_BORDER_BOX); - view_menu->clear(); - view_menu->add("Sequence Zoom", 0, (Fl_Callback*) seq_win_spawn_cb, this); - view_menu->add("Motif Finder", 0, (Fl_Callback*) motif_find_cb, this); - view_menu->add("Annotations", 0, (Fl_Callback*) annot_win_cb, this); - view_menu->add("Copy Seq", 0, (Fl_Callback*) seq_show_cb, this); - view_menu->add("Toggle Bars", 0, (Fl_Callback*) toggle_scale_bars_cb, this, - FL_MENU_TOGGLE|FL_MENU_VALUE); - view_menu->add("Toggle Lines", 0, (Fl_Callback*) toggle_scale_lines_cb, this, - FL_MENU_TOGGLE|FL_MENU_VALUE); - - bar_input = new Fl_Input(padding+3*button_len, 2, button_len, 30, "Bar Length (bp)"); - bar_input->value(""); - bar_input->when(FL_WHEN_ENTER_KEY); - bar_input->callback((Fl_Callback*)set_bar_len_cb, this); - - line_input = new Fl_Input(padding+5*button_len, 2, button_len, 30, "Line Interval (bp)"); - line_input->value(""); - line_input->when(FL_WHEN_ENTER_KEY); - line_input->callback((Fl_Callback*)set_line_len_cb, this); - - - thres_input = new Fl_Input(padding+7*button_len, 2, button_len, 30, "Threshold"); - thres_input->value(""); - thres_input->when(FL_WHEN_ENTER_KEY); - thres_input->callback((Fl_Callback*)set_soft_thres_cb, this); - - - // create the connections box - conn_box = new ConnView(padding, padding + 30, w-2*padding, h-2*padding-30); - //conn_box = new ConnView(padding, padding, w-2*padding, h-2*padding); - - end(); - show(); -} - - -ConnWindow::~ConnWindow() -{} - - -void -ConnWindow::add_ana(Mussa *the_ana) -{ - an_analysis = the_ana; - - // relabel window with the analysis name - window_name = "Mussa: " + an_analysis->ana_name; - label((const char*)window_name.c_str()); - - conn_box->setup(an_analysis->ana_name, an_analysis->seq_num, - an_analysis->window, &(an_analysis->the_Seqs), - &(an_analysis->the_paths)); - conn_box->scale_paths(); -} diff --git a/mussa_gui_conn_window.hh b/mussa_gui_conn_window.hh deleted file mode 100644 index 5a1044f..0000000 --- a/mussa_gui_conn_window.hh +++ /dev/null @@ -1,64 +0,0 @@ -#ifndef _MUSSA_GUI_CONN_WINDOW_H_ -#define _MUSSA_GUI_CONN_WINDOW_H_ - -// This file is part of the Mussa source distribution. -// http://mussa.caltech.edu/ -// Contact author: Tristan De Buysscher, tristan@caltech.edu - -// This program and all associated source code files are Copyright (C) 2005 -// the California Institute of Technology, Pasadena, CA, 91125 USA. It is -// under the GNU Public License; please see the included LICENSE.txt -// file for more information, or contact Tristan directly. - -#include - -#include -#include - -#include "mussa_gui_conn_view.hh" -#include "mussa_gui_load_window.hh" -#include "mussa_gui_subana.hh" -#include "mussa_gui_seq_text.hh" - -class ConnWindow : public Fl_Double_Window -{ - private: - Mussa *an_analysis, *sub_analysis; - ConnWindow *sub_conn_win; - - Fl_Menu_Button *file_menu; - Fl_Menu_Button *view_menu; - Fl_Input *bar_input; - Fl_Input *line_input; - Fl_Input *thres_input; - ConnView *conn_box; - SetupWindow *setup_win; - SubanaWindow *subana_win; - SeqTextWin *show_seq_win; - int padding, name_pad; - std::string window_name; - - public: - ConnWindow(int w, int h, const char* title); - ~ConnWindow(); - void add_ana(Mussa *the_ana); - - void real_load_ana_cb(); - void real_do_ana_cb(); - void real_setup_ana_cb(); - void real_subana_cb(); - void real_resthres(); - void real_seq_show_cb(); - - void real_seq_win_spawn_cb(); - void real_motif_find_cb(); - void real_annot_win_cb(); - - void real_toggle_bars_cb(); - void real_set_bar_len_cb(Fl_Input* o); - void real_toggle_lines_cb(); - void real_set_line_len_cb(Fl_Input* o); - void real_set_soft_thres_cb(Fl_Input* o); -}; - -#endif diff --git a/mussa_gui_load_window.cc b/mussa_gui_load_window.cc deleted file mode 100644 index 9f93525..0000000 --- a/mussa_gui_load_window.cc +++ /dev/null @@ -1,423 +0,0 @@ -// This file is part of the Mussa source distribution. -// http://mussa.caltech.edu/ -// Contact author: Tristan De Buysscher, tristan@caltech.edu - -// This program and all associated source code files are Copyright (C) 2005 -// the California Institute of Technology, Pasadena, CA, 91125 USA. It is -// under the GNU Public License; please see the included LICENSE.txt -// file for more information, or contact Tristan directly. - - -#include "mussa_gui_load_window.hh" - -#include -#include - -using namespace std; - -bool -SetupWindow::done() -{ - return all_done; -} - - -void -do_analysis_cb(Fl_Button* o, void* v) -{ - SetupWindow* T=(SetupWindow*)v; - T->real_do_analysis(); -} - - -// passes the parameters to the mussa class object and orders it to run -void -SetupWindow::real_do_analysis() -{ - int i; - string err_msg; - - // <-- need a check here to make sure all vars have a valid value - - an_analysis->clear(); - an_analysis->set_name(ana_name); - an_analysis->set_seq_num(seq_num); - an_analysis->set_window(window); - an_analysis->set_threshold(threshold); - - for(i=0; i < seq_num; i++) - an_analysis->set_seq_info(seq_files[i], annot_files[i], fasta_indices[i], - sub_seq_starts[i], sub_seq_ends[i]); - - err_msg = an_analysis->analyze(0,0, 't', 0.0); - //cout << "Feel the tribal beat\n"; - if (!(err_msg == "")) - { - //fl_alert(err_msg.c_str()); - cout << err_msg; - } - - all_done = true; - - hide(); -} - - -void -choose_seq_file_cb(Fl_Button* o, void* v) -{ - seq_data_instance * blah = (seq_data_instance *) v; - SetupWindow* T= blah->sw_ptr; - T->real_choose_seq_file_cb(blah->index); -} - - -void -SetupWindow::real_choose_seq_file_cb(int i) -{ - char *picked_file; - string a_file_path; - - picked_file = fl_file_chooser("Find an Analysis", "", "", 1); - a_file_path = picked_file; - seq_files[i] = a_file_path; - seq_inputs[i]->value((const char *)picked_file); -} - - -void -seq_file_in_cb(Fl_Input* o, void* v) -{ - seq_data_instance * blah = (seq_data_instance *) v; - SetupWindow* T= blah->sw_ptr; - T->real_seq_file_in_cb(o,blah->index); -} - - -void -SetupWindow::real_seq_file_in_cb(Fl_Input* o, int i) -{ - seq_files[i] = o->value(); - // leaving this as a reminder that bools will need to be set to determine - // if all needed fields have been filled with some value before an analysis - // is attempted - //(*the_motifs)[i].dirty = true; -} - -//char *picked_file; -//picked_file = fl_file_chooser("Find an Analysis", "", "", 1); - -// *** Annot file selection - -void -choose_annot_file_cb(Fl_Button* o, void* v) -{ - seq_data_instance * blah = (seq_data_instance *) v; - SetupWindow* T= blah->sw_ptr; - T->real_choose_annot_file_cb(blah->index); -} - - -void -SetupWindow::real_choose_annot_file_cb(int i) -{ - char *picked_file; - string a_file_path; - - picked_file = fl_file_chooser("Find an Analysis", "", "", 1); - a_file_path = picked_file; - annot_files[i] = a_file_path; - annot_inputs[i]->value((const char *)picked_file); -} - -void -annot_file_in_cb(Fl_Input* o, void* v) -{ - seq_data_instance * blah = (seq_data_instance *) v; - SetupWindow* T= blah->sw_ptr; - T->real_annot_file_in_cb(o,blah->index); -} - -void -SetupWindow::real_annot_file_in_cb(Fl_Input* o, int i) -{ - annot_files[i] = o->value(); -} - - -// *** fasta index selection - -void -fa_index_in_cb(Fl_Input* o, void* v) -{ - seq_data_instance * blah = (seq_data_instance *) v; - SetupWindow* T= blah->sw_ptr; - T->real_fa_index_in_cb(o,blah->index); -} - -void -SetupWindow::real_fa_index_in_cb(Fl_Input* o, int i) -{ - fasta_indices[i] = atoi(o->value()); -} - -// *** subsequence start select - -void -sub_start_in_cb(Fl_Input* o, void* v) -{ - seq_data_instance * blah = (seq_data_instance *) v; - SetupWindow* T= blah->sw_ptr; - T->real_sub_start_in_cb(o,blah->index); -} - -void -SetupWindow::real_sub_start_in_cb(Fl_Input* o, int i) -{ - sub_seq_starts[i] = atoi(o->value()); -} - -// *** subsequence end select - -void -sub_end_in_cb(Fl_Input* o, void* v) -{ - seq_data_instance * blah = (seq_data_instance *) v; - SetupWindow* T= blah->sw_ptr; - T->real_sub_end_in_cb(o,blah->index); -} - -void -SetupWindow::real_sub_end_in_cb(Fl_Input* o, int i) -{ - sub_seq_ends[i] = atoi(o->value()); - -} - -// *** input analysis name - -void -set_ana_name_cb(Fl_Input* o, void* v) -{ - SetupWindow* T=(SetupWindow*)v; - T->real_set_ana_name_cb(o); -} - -void -SetupWindow::real_set_ana_name_cb(Fl_Input* o) -{ - ana_name = o->value(); -} - -// *** input window size - -void -set_win_size_cb(Fl_Input* o, void* v) -{ - SetupWindow* T=(SetupWindow*)v; - T->real_set_win_size_cb(o); -} - -void -SetupWindow::real_set_win_size_cb(Fl_Input* o) -{ - window = atoi(o->value()); -} - -// *** input threshold - -void -set_threshold_cb(Fl_Input* o, void* v) -{ - SetupWindow* T=(SetupWindow*)v; - T->real_set_threshold_cb(o); -} - -void -SetupWindow::real_set_threshold_cb(Fl_Input* o) -{ - threshold = atoi(o->value()); -} - -void -set_seq_num_cb(Fl_Input* o, void* v) -{ - SetupWindow* T=(SetupWindow*)v; - T->real_set_seq_num_cb(o); -} - -// *** input number of sequences, add appropriate inputs for each sequence - -void -SetupWindow::real_set_seq_num_cb(Fl_Input* o) -{ - int i; - - seq_num = atoi(o->value()); - seq_inputs.clear(); - annot_inputs.clear(); - - seq_scroll = new Fl_Scroll(5,80,w()-10,h()-115); - seq_scroll->color(FL_WHITE); - - for (i = 0; i < seq_num; i++) - { - seq_files.push_back(""); - annot_files.push_back(""); - fasta_indices.push_back(1); - sub_seq_starts.push_back(0); - sub_seq_ends.push_back(0); - add_seq_input(i); - } - seq_scroll->box(FL_DOWN_FRAME); - add(seq_scroll); - redraw(); -} - - -SetupWindow::SetupWindow(int w, int h, const char* title, Mussa *the_analysis):Fl_Window(w,h,title) -{ - color(FL_WHITE); - - an_analysis = the_analysis; - all_done = false; - - begin(); - - name_input = new Fl_Input(110, 10, w-120, 30, "Analysis Name "); - name_input->value(""); - //name_input->when(FL_WHEN_ENTER_KEY); - name_input->box(FL_BORDER_BOX); - name_input->callback((Fl_Callback*)set_ana_name_cb, this); - - // add in radio buttons for win_append and thres_append eventually - win_append = true; - thres_append = true; - - win_input = new Fl_Input(65,45,100,30, "Window "); - win_input->value(""); - win_input->callback((Fl_Callback*)set_win_size_cb, this); - - thres_input = new Fl_Input(250,45,100,30, "Threshold "); - thres_input->value(""); - thres_input->callback((Fl_Callback*)set_threshold_cb, this); - - seq_num_input = new Fl_Input(430,45,100, 30, "Seq Num "); - seq_num_input->value(""); - seq_num_input->callback((Fl_Callback*)set_seq_num_cb, this); - - // button to launch the analysis - test = new Fl_Button(w-100,h-30,100,30,"Do Analysis"); - test->callback((Fl_Callback*)do_analysis_cb, this); - - // test button to make sure setup data is being stored - test = new Fl_Button(w-200,h-30,100,30,"show setup"); - test->callback((Fl_Callback*)print_cb, this); - - // generic input, keeping around as template for future additions - //_input = new Fl_Input(0, , 30, ""); - //_input->value(""); - //_input->when(FL_WHEN_ENTER_KEY); - //_input->callback((Fl_Callback*)set__cb, this); - - end(); - //resizable(this); - show(); -} - - -SetupWindow::~SetupWindow(){} - - -void -SetupWindow::add_seq_input(int i) -{ - Fl_Input *fasta_input, *start_input, *end_input; - Fl_Button *seq_browse, *annot_browse; - - - // this remembers what seq index each input is associated with - seq_data_instance * something; - something = new seq_data_instance; - something->sw_ptr = this; - something->index = i; - - - // setup sequence file input for text input or file browsing - seq_inputs.push_back(new Fl_Input(55, 85+(i*105), w()-165, 30, "seq ")); - seq_inputs[i]->value(""); - seq_inputs[i]->callback((Fl_Callback*)seq_file_in_cb, (void*) something); - - seq_browse = new Fl_Button(w()-105, 85+(i*105), 80, 30, "Browse"); - seq_browse->callback((Fl_Callback*)choose_seq_file_cb, (void*) something); - - // setup annotation file input for text input or file browsing - annot_inputs.push_back(new Fl_Input(55, 120+(i*105), w()-165, 30, "annot ")); - annot_inputs[i]->value(""); - annot_inputs[i]->callback((Fl_Callback*)annot_file_in_cb,(void*)something); - - annot_browse = new Fl_Button(w()-105, 120+(i*105), 80, 30, "Browse"); - annot_browse->callback((Fl_Callback*)choose_annot_file_cb, (void*)something); - - // index of fasta seq wanted if more than 1 seq in file - fasta_input = new Fl_Input(90, 155+(i*105), 50, 30, "fasta index"); - fasta_input->value(""); - fasta_input->callback((Fl_Callback*)fa_index_in_cb, (void*) something); - - // subsequence select, index of first bp wanted - start_input = new Fl_Input(225, 155+(i*105), 50, 30, "start index"); - start_input->value(""); - start_input->callback((Fl_Callback*)sub_start_in_cb, (void*) something); - - // subsequence select, index of last bp wanted - end_input = new Fl_Input(355, 155+(i*105), 50, 30, "end index"); - end_input->value(""); - end_input->callback((Fl_Callback*)sub_end_in_cb, (void*) something); - - seq_scroll->add(seq_inputs[i]); - seq_scroll->add(seq_browse); - seq_scroll->add(annot_inputs[i]); - seq_scroll->add(annot_browse); - seq_scroll->add(fasta_input); - seq_scroll->add(start_input); - seq_scroll->add(end_input); -} - -/* - cout << "fee\n"; - cout << "fie\n"; - cout << "foe\n"; - cout << "fum\n"; -*/ - -void SetupWindow::print_cb(Fl_Button* o, void* v) -{ - SetupWindow* T=(SetupWindow*)v; - T->print_cb_real(o,v); -} - - -void SetupWindow::print_cb_real(Fl_Button* , void*) -{ - cout << "ana_name: " << ana_name << endl; - cout << "win: " << window << endl; - cout << "thres: " << threshold << endl; - cout << "seq_num: " << seq_num << endl; - //cout << "win_add: " << win_append << end; - //cout << "thres_add: " << thres_append << endl; - - int i; - - - - for (i = 0; i < seq_num; i++) - { - cout << seq_files[i] << endl; - cout << annot_files[i] << endl; - cout << "fasta: " << fasta_indices[i]; - cout << " start: " << sub_seq_starts[i]; - cout << " end: " << sub_seq_ends[i] << endl; - cout << "blargle!\n"; - } - cout << "end of inputs\n" << endl; -} diff --git a/mussa_gui_load_window.hh b/mussa_gui_load_window.hh deleted file mode 100644 index 02e7727..0000000 --- a/mussa_gui_load_window.hh +++ /dev/null @@ -1,83 +0,0 @@ -#ifndef _MUSSA_GUI_LOAD_WINDOW_H_ -#define _MUSSA_GUI_LOAD_WINDOW_H_ - -// This file is part of the Mussa source distribution. -// http://mussa.caltech.edu/ -// Contact author: Tristan De Buysscher, tristan@caltech.edu - -// This program and all associated source code files are Copyright (C) 2005 -// the California Institute of Technology, Pasadena, CA, 91125 USA. It is -// under the GNU Public License; please see the included LICENSE.txt -// file for more information, or contact Tristan directly. - -#include -#include -#include -#include - -#include "mussa_class.hh" -#include "mussa_gui_load_window.hh" - -class SetupWindow : public Fl_Window -{ - public: - SetupWindow(int w, int h, const char* title, Mussa *an_analysis); - ~SetupWindow(); - - bool done(); - - //did I put these in public for a reason? - Fl_Button* test; - Fl_Input *name_input; - Fl_Input *win_input; - Fl_Input *thres_input; - Fl_Input *seq_num_input; - Fl_Scroll *seq_scroll; - // need to keep track of these so a browsed file search can set the input - // fields to teh selected file - std::vector seq_inputs, annot_inputs; - - - // callback receiver functions - - void real_do_analysis(); - - void real_set_ana_name_cb(Fl_Input* o); - void real_set_win_size_cb(Fl_Input* o); - void real_set_threshold_cb(Fl_Input* o); - void real_set_seq_num_cb(Fl_Input* o); - - void real_seq_file_in_cb(Fl_Input* o, int i); - void real_choose_seq_file_cb(int i); - void real_annot_file_in_cb(Fl_Input* o, int i); - void real_choose_annot_file_cb(int i); - - void real_fa_index_in_cb(Fl_Input* o, int i); - void real_sub_start_in_cb(Fl_Input* o, int i); - void real_sub_end_in_cb(Fl_Input* o, int i); - - private: - Mussa *an_analysis; - std::string ana_name; - int window, threshold, seq_num; - std::vector seq_files, annot_files; - std::vector fasta_indices, sub_seq_starts, sub_seq_ends; - bool win_append, thres_append; - - bool all_done; - static void print_cb(Fl_Button*, void*); - inline void print_cb_real(Fl_Button*, void*); - - void add_seq_input(int index); -}; - -// crazy whacked shite Titus taught me to do to get an index value associated -// with each instance of an input associated with the callback... - -struct seq_data_instance -{ - SetupWindow * sw_ptr; - int index; -}; - -#endif diff --git a/mussa_gui_motif_window.cc b/mussa_gui_motif_window.cc deleted file mode 100644 index 302ab74..0000000 --- a/mussa_gui_motif_window.cc +++ /dev/null @@ -1,191 +0,0 @@ -// This file is part of the Mussa source distribution. -// http://mussa.caltech.edu/ -// Contact author: Tristan De Buysscher, tristan@caltech.edu - -// This program and all associated source code files are Copyright (C) 2005 -// the California Institute of Technology, Pasadena, CA, 91125 USA. It is -// under the GNU Public License; please see the included LICENSE.txt -// file for more information, or contact Tristan directly. - - -#include "mussa_gui_motif_window.hh" - -#include - -#include - -using namespace std; - -motif -new_blank_motif() -{ - motif *a_motif; - - a_motif = new motif; - a_motif->name = ""; - a_motif->seq = ""; - a_motif->color = (Fl_Color) 5; - a_motif->locations.clear(); - a_motif->dirty = false; - - cout << "name: " << a_motif->name << " seq: " << a_motif->seq << endl; - - return *a_motif; -} - - -void -cb_motif_in(Fl_Input* o, void* v) -{ - motif_instance * blah = (motif_instance *) v; - MotifWindow* T= blah->mw_ptr; - T->cb_motif_in_i(o,blah->index); -} - - -void -cb_motif_color(Fl_Button* o, void* v) -{ - motif_instance * blah = (motif_instance *) v; - MotifWindow* T= blah->mw_ptr; - T->cb_motif_color_i(o,blah->index); -} - - -MotifWindow::MotifWindow(int w, int h, const char* title, - vector * some_motifs):Fl_Window(w,h,title) -{ - int i; - - the_motifs = some_motifs; - motif_count = 0; - - motif_color_buttons.clear(); - - begin(); - motif_input_pack = new Fl_Pack(0, 0, w, h); - motif_input_pack->spacing(4); - - // button to add new motif inputs - add_motif = new Fl_Button(0,0,100,24,"Add Motif Slot"); - add_motif->callback((Fl_Callback*)add_motif_cb, this); - motif_input_pack->add(add_motif); - // test button to make sure motif data is being stored - test = new Fl_Button(0,0,100,24,"show motifs"); - test->callback((Fl_Callback*)print_cb, this); - motif_input_pack->add(test); - // creat an initial set of motif input widgets and attach to motif vector - for (i = 0; i < 5; i++) - { - add_motif_input(i); - motif_count++; - } - - - - - add(motif_input_pack); - - end(); - resizable(this); - show(); -} - - //tmp_input->user_data((void*) i); - -MotifWindow::~MotifWindow(){} - -void -MotifWindow::add_motif_input(int index) -{ - Fl_Input * new_input; - Fl_Button *new_color_button; - motif_instance * something; - Fl_Pack * motif_hor_pack; - - - something = new motif_instance; - something->mw_ptr = this; - something->index = index; - - motif_hor_pack = new Fl_Pack(0, 0, w(), 24); - motif_hor_pack->type(Fl_Pack::HORIZONTAL); - motif_hor_pack->spacing(4); - - // setup the color display/selection button - new_color_button = new Fl_Button(0, 0, 24, 24, ""); - new_color_button->color((*the_motifs)[index].color); - new_color_button->box(FL_FLAT_BOX); - new_color_button->callback((Fl_Callback*)cb_motif_color, (void*) something); - motif_color_buttons.push_back(new_color_button); - motif_hor_pack->add(new_color_button); - - - // setup the motif inputs - new_input = new Fl_Input(0, 0, 200, 24, ""); - new_input->value( ((*the_motifs)[index].seq).c_str() ); - new_input->callback((Fl_Callback*)cb_motif_in, (void*) something); - motif_ins.push_back(new_input); - motif_hor_pack->add(new_input); - - motif_input_pack->add(motif_hor_pack); -} -/* - cout << "fee\n"; - cout << "fie\n"; - cout << "foe\n"; - cout << "fum\n"; -*/ - -void -MotifWindow::cb_motif_in_i(Fl_Input* o, int i) -{ - (*the_motifs)[i].seq = o->value(); - (*the_motifs)[i].dirty = true; -} - -void -MotifWindow::cb_motif_color_i(Fl_Button* o, int i) -{ - //Fl_Color new_color; - - (*the_motifs)[i].color = fl_show_colormap((*the_motifs)[i].color); - //motif_color_buttons[i]-> - o->color((*the_motifs)[i].color); - redraw(); -} - -void MotifWindow::add_motif_cb(Fl_Button* o, void* v) -{ - MotifWindow* T=(MotifWindow*)v; - T->add_motif_cb_real(o,v); -} - - -void MotifWindow::add_motif_cb_real(Fl_Button* , void*) -{ - motif blank_motif; - - //blank_motif.name = ""; - //blank_motif.seq = ""; - blank_motif = new_blank_motif(); - (*the_motifs).push_back(blank_motif); - add_motif_input(motif_count++); - redraw(); -} - - -void MotifWindow::print_cb(Fl_Button* o, void* v) -{ - MotifWindow* T=(MotifWindow*)v; - T->print_cb_real(o,v); -} - - -void MotifWindow::print_cb_real(Fl_Button* , void*) -{ - int i; - - for (i = 0; i < motif_count; i++) - cout << (*the_motifs)[i].seq << endl; -} diff --git a/mussa_gui_motif_window.hh b/mussa_gui_motif_window.hh deleted file mode 100644 index 5c16594..0000000 --- a/mussa_gui_motif_window.hh +++ /dev/null @@ -1,72 +0,0 @@ -#ifndef _MUSSA_GUI_MOTIF_WINDOW_H_ -#define _MUSSA_GUI_MOTIF_WINDOW_H_ -// This file is part of the Mussa source distribution. -// http://mussa.caltech.edu/ -// Contact author: Tristan De Buysscher, tristan@caltech.edu - -// This program and all associated source code files are Copyright (C) 2005 -// the California Institute of Technology, Pasadena, CA, 91125 USA. It is -// under the GNU Public License; please see the included LICENSE.txt -// file for more information, or contact Tristan directly. - -#include -#include -#include - -#include -#include - -#include -#include - -#include "mussa_class.hh" - -struct motif -{ - std::string name, seq; - Fl_Color color; - std::vector > locations; - bool dirty; -}; - -//typedef motif_ptr *motif; - - -class MotifWindow : public Fl_Window -{ - public: - MotifWindow(int w, int h, const char* title, std::vector * some_motifs); - ~MotifWindow(); - Fl_Pack * motif_input_pack; - std::list motif_ins; - std::vector motif_color_buttons; - std::list name_ins; - Fl_Button* test; - Fl_Button* add_motif; - - void cb_motif_in_i(Fl_Input*, int i); - void cb_motif_color_i(Fl_Button* o, int i); - - private: - std::vector * the_motifs; - int motif_count; - - void add_motif_input(int index); - - static void add_motif_cb(Fl_Button*, void*); - inline void add_motif_cb_real(Fl_Button*, void*); - - static void print_cb(Fl_Button*, void*); - inline void print_cb_real(Fl_Button*, void*); -}; - -// crazy whacked shite Titus taught me to do to get an index value associated -// with each instance of an input associated with the callback... -struct motif_instance -{ - MotifWindow * mw_ptr; - int index; -}; - -motif new_blank_motif(); -#endif diff --git a/mussa_gui_seq.cc b/mussa_gui_seq.cc deleted file mode 100644 index a2cb19d..0000000 --- a/mussa_gui_seq.cc +++ /dev/null @@ -1,218 +0,0 @@ -// This file is part of the Mussa source distribution. -// http://mussa.caltech.edu/ -// Contact author: Tristan De Buysscher, tristan@caltech.edu - -// This program and all associated source code files are Copyright (C) 2005 -// the California Institute of Technology, Pasadena, CA, 91125 USA. It is -// under the GNU Public License; please see the included LICENSE.txt -// file for more information, or contact Tristan directly. - - -#include "mussa_gui_seq.hh" - -#include - -#include - -using namespace std; - -void -set_align_cb(Fl_Widget* widg, void* the_data) -{ - menu_align_data_bundle * blah = (menu_align_data_bundle *) the_data; - SeqWindow* T= blah->swm_ptr; - T->real_set_align_cb(blah->which_align); -} - - -void -SeqWindow::real_set_align_cb(int which_align) -{ - vector a_path; - int window_length; - - - a_path = *P.begin(); - window_length = a_path[0]; - cout << window_length << endl; - - cout << "fum1\n"; - seq_box->align_offsets(which_align); - seq_box->redraw(); -} - - -void -show_align_cb(Fl_Widget* widg, void* the_data) -{ - menu_align_data_bundle * blah = (menu_align_data_bundle *) the_data; - SeqWindow* T= blah->swm_ptr; - T->real_show_align_cb(blah->which_align); -} - - -void -SeqWindow::real_show_align_cb(int which_align) -{ - vector a_path; - int window_length; - - - cout << "fumish\n"; - seq_box->toggle_align(which_align); - seq_box->redraw(); -} - - -void -toggle_bars_cb(Fl_Button* o, void* v) -{ - SeqWindow* T=(SeqWindow*)v; - T->real_toggle_bars_cb(); -} - - -void -SeqWindow::real_toggle_bars_cb() -{ - seq_box->toggle_bars(); -} - - -void -toggle_motifs_cb(Fl_Button* o, void* v) -{ - SeqWindow* T=(SeqWindow*)v; - T->real_toggle_motifs_cb(); -} - - -void -SeqWindow::real_toggle_motifs_cb() -{ - seq_box->toggle_motifs(); -} - - -// main code, window creation - -SeqWindow::SeqWindow(int w, int h, const char* title, int sq_num, - vector *some_seqs, - list > some_paths, - vector some_lens, - vector *some_motifs): - Fl_Double_Window(w,h,title) -{ - menu_align_data_bundle * some_menu_data; - vector a_path; - int window_length, align_number; - int i; - ostringstream align_id_ostr; - string align_id_string; - list >::iterator align_iter; - - - - // most of this stuff is here just to pass to SeqView object - // some is needed to setup the window menus - seq_num = sq_num; - S = some_seqs; - P = some_paths; - seq_lens = some_lens; - the_motifs = some_motifs; - - - begin(); - color(FL_WHITE); - resizable(this); - - // make the menu that allows alignment selection - choose_align_menu = new Fl_Menu_Button(5, 2, 180, 30, "Choose Alignment"); - choose_align_menu->color(FL_WHITE,FL_BLUE); - choose_align_menu->box(FL_BORDER_BOX); - choose_align_menu->clear(); - - // make the menu that allows alignment selection - show_align_menu = new Fl_Menu_Button(190, 2, 180, 30, "Show Alignment"); - show_align_menu->color(FL_WHITE,FL_BLUE); - show_align_menu->box(FL_BORDER_BOX); - show_align_menu->clear(); - - - // adds menu items for each path - align_iter = P.begin(); - align_number = 0; - while(align_iter != P.end()) - { - some_menu_data = new menu_align_data_bundle; - some_menu_data->swm_ptr = this; - some_menu_data->which_align = align_number; - align_id_ostr << (*align_iter)[0] << ": "; - for(i = 1; i <= seq_num; i++) - align_id_ostr << (*align_iter)[i] << ", "; - align_id_string = align_id_ostr.str(); - choose_align_menu->add((const char*)align_id_string.c_str(), 0, - (Fl_Callback *) set_align_cb, - (void*) some_menu_data); - show_align_menu->add((const char*)align_id_string.c_str(), 0, - (Fl_Callback *) show_align_cb, - (void*) some_menu_data, FL_MENU_TOGGLE|FL_MENU_VALUE); - - align_id_ostr.str(""); - ++align_number; - ++align_iter; - } - - /* - show_align_menu->add("f&ee"); - show_align_menu->add("f&ie"); - show_align_menu->add("f&oe"); - show_align_menu->add("f&um"); - */ - - Fl_Button *test_but = new Fl_Button(375, 2, 150, 30, "Toggle Motifs"); - test_but->color(FL_WHITE,FL_BLUE); - test_but->box(FL_BORDER_BOX); - test_but->callback((Fl_Callback*) toggle_motifs_cb, this); - - toggle_bars = new Fl_Button(530, 2, 150, 30, "Toggle 10bp bars"); - toggle_bars->color(FL_WHITE,FL_BLUE); - toggle_bars->box(FL_BORDER_BOX); - toggle_bars->callback((Fl_Callback*) toggle_bars_cb, this); - - - // make the view of the sequence - seq_box = new SeqView(0, 34, w, h-34); - seq_box->setup(ana_name, seq_num, S, P, seq_lens, the_motifs); - //real_set_align_cb(2); - - end(); - Fl::visual(FL_DOUBLE|FL_INDEX); - show(); -} - - - -/* - some_menu_data = new menu_align_data_bundle; - some_menu_data->swm_ptr = this; - some_menu_data->which_align = 2; - choose_align_menu->add("f&ie", FL_ALT+'i', (Fl_Callback *) set_align_cb, - (void*) some_menu_data); - - some_menu_data = new menu_align_data_bundle; - some_menu_data->swm_ptr = this; - some_menu_data->which_align = 3; - choose_align_menu->add("f&oe", FL_ALT+'o', (Fl_Callback *) set_align_cb, - (void*) some_menu_data); - - some_menu_data = new menu_align_data_bundle; - some_menu_data->swm_ptr = this; - some_menu_data->which_align = 4; - choose_align_menu->add("f&um", FL_ALT+'u', (Fl_Callback *) set_align_cb, - (void*) some_menu_data); -*/ - - - - diff --git a/mussa_gui_seq.hh b/mussa_gui_seq.hh deleted file mode 100644 index eaf1cc0..0000000 --- a/mussa_gui_seq.hh +++ /dev/null @@ -1,68 +0,0 @@ -#ifndef _MUSSA_GUI_SEQ_H_ -#define _MUSSA_GUI_SEQ_H_ -// This file is part of the Mussa source distribution. -// http://mussa.caltech.edu/ -// Contact author: Tristan De Buysscher, tristan@caltech.edu - -// This program and all associated source code files are Copyright (C) 2005 -// the California Institute of Technology, Pasadena, CA, 91125 USA. It is -// under the GNU Public License; please see the included LICENSE.txt -// file for more information, or contact Tristan directly. - -#include -#include -#include -#include - -#include "mussa_gui_seq_view.hh" - -#include -#include -#include -#include - -class SeqWindow : public Fl_Double_Window -{ - private: - std::string ana_name; - int base_window_len; - - //this data is passed as pointers to the instantiated classes - std::vector *S; - // list of paths in selection box - std::list > P; - std::vector seq_lens; - //pointer to passed motif data - std::vector *the_motifs; - - int x_max, y_max; - Fl_Menu_Button *choose_align_menu; - Fl_Menu_Button *show_align_menu; - Fl_Button *toggle_bars; - SeqView *seq_box; - - public: - int seq_num; - - SeqWindow(int w, int h, const char* title, int sq_num, - std::vector *some_seqs, - std::list > some_paths, - std::vector some_lens, - std::vector *some_motifs); - virtual ~SeqWindow(){ std::cout << "dying\n"; } - - void make_choose_menu(); - void make_show_menu(); - void real_set_align_cb(int which_align); - void real_show_align_cb(int which_align); - void real_toggle_bars_cb(); - void real_toggle_motifs_cb(); -}; - - -struct menu_align_data_bundle -{ - SeqWindow * swm_ptr; - int which_align; -}; -#endif diff --git a/mussa_gui_seq_text.cc b/mussa_gui_seq_text.cc deleted file mode 100644 index 45554f6..0000000 --- a/mussa_gui_seq_text.cc +++ /dev/null @@ -1,146 +0,0 @@ -// This file is part of the Mussa source distribution. -// http://mussa.caltech.edu/ -// Contact author: Tristan De Buysscher, tristan@caltech.edu - -// This program and all associated source code files are Copyright (C) 2005 -// the California Institute of Technology, Pasadena, CA, 91125 USA. It is -// under the GNU Public License; please see the included LICENSE.txt -// file for more information, or contact Tristan directly. - - -#include "mussa_gui_seq_text.hh" - -#include -using namespace std; -void -get_seq_cb(Fl_Button* o, void* v) -{ - SeqTextWin* T=(SeqTextWin*)v; - T->real_get_seq_cb(); -} - -void -SeqTextWin::real_get_seq_cb() -{ - string sub_seq_formatted; - int seq_len, i, line_len; - - - cout << "length = " << seq_end-seq_start << endl; - - // make sure inputed values within valid ranges - if ((seq_end > seq_start) && (seq_id > -1) && (seq_id < the_Seqs.size()) ) - { - sub_sequence = the_Seqs[seq_id].subseq(seq_start, seq_end-seq_start); - - sub_seq_formatted = ""; - seq_len = sub_sequence.size(); - line_len = 40; - for (i = 0; i < seq_len; i += line_len) - { - sub_seq_formatted.append(sub_sequence.substr(i,line_len)); - sub_seq_formatted.append("\n"); - } - - seq_display->value((const char *)sub_seq_formatted.c_str()); - } -} - - -// *** input seq index id - -void -set_seq_id_cb(Fl_Input* o, void* v) -{ - SeqTextWin* T=(SeqTextWin*)v; - T->real_set_seq_id_cb(o); -} - -void -SeqTextWin::real_set_seq_id_cb(Fl_Input* o) -{ - seq_id = atoi(o->value()) - 1; // -1 since arrays start at 0 -} - - -// *** input seq start index - -void -set_seq_start_cb(Fl_Input* o, void* v) -{ - SeqTextWin* T=(SeqTextWin*)v; - T->real_set_seq_start_cb(o); -} - -void -SeqTextWin::real_set_seq_start_cb(Fl_Input* o) -{ - seq_start = atoi(o->value()); -} - -// *** input seq end index - -void -set_seq_end_cb(Fl_Input* o, void* v) -{ - SeqTextWin* T=(SeqTextWin*)v; - T->real_set_seq_end_cb(o); -} - -void -SeqTextWin::real_set_seq_end_cb(Fl_Input* o) -{ - seq_end = atoi(o->value()); -} - - -SeqTextWin::SeqTextWin(int w, int h, const char* title, - vector some_Seqs):Fl_Window(w,h,title) -{ - string a_name; - color(FL_WHITE); - the_Seqs = some_Seqs; - - - seq_id = -1; - seq_start = 1000000; - seq_end = -1000000; - - begin(); - - seq_id_input = new Fl_Input(80,10,30,30, "Seq num: "); - seq_id_input->value(""); - seq_id_input->callback((Fl_Callback*)set_seq_id_cb, this); - - seq_start_input = new Fl_Input(160,10,100,30, " start: "); - seq_start_input->value(""); - seq_start_input->callback((Fl_Callback*)set_seq_start_cb, this); - - seq_end_input = new Fl_Input(310,10,100,30, "end: "); - seq_end_input->value(""); - seq_end_input->callback((Fl_Callback*)set_seq_end_cb, this); - - seq_display = new Fl_Multiline_Output(10, 50, w-20, h-60, ""); - seq_display->value(""); - - //seq_display2 = new Fl_Text_Display(10,100, w-20, h-110,""); - - // button to get the sequence - get_seq_but = new Fl_Button(w-80,10,80,30,"Get Seq"); - get_seq_but->callback((Fl_Callback*)get_seq_cb, this); - - - end(); - //resizable(this); - show(); -} - - -SeqTextWin::~SeqTextWin(){} - -/* - cout << "fee\n"; - cout << "fie\n"; - cout << "foe\n"; - cout << "fum\n"; -*/ diff --git a/mussa_gui_seq_text.hh b/mussa_gui_seq_text.hh deleted file mode 100644 index 48b84b6..0000000 --- a/mussa_gui_seq_text.hh +++ /dev/null @@ -1,50 +0,0 @@ -#ifndef _MUSSA_GUI_SEQ_TEXT_H_ -#define _MUSSA_GUI_SEQ_TEXT_H_ -// This file is part of the Mussa source distribution. -// http://mussa.caltech.edu/ -// Contact author: Tristan De Buysscher, tristan@caltech.edu - -// This program and all associated source code files are Copyright (C) 2005 -// the California Institute of Technology, Pasadena, CA, 91125 USA. It is -// under the GNU Public License; please see the included LICENSE.txt -// file for more information, or contact Tristan directly. - -#include -#include - -#include -#include -#include -#include -#include - -#include "mussa_gui_seq.hh" - -class SeqTextWin : public Fl_Window -{ - public: - SeqTextWin(int w, int h, const char* title, std::vector some_Seqs); - ~SeqTextWin(); - - Fl_Button* get_seq_but; - Fl_Multiline_Output* seq_display; - Fl_Text_Buffer* seq_buffer; - Fl_Text_Display* seq_display2; - Fl_Input *seq_id_input; - Fl_Input *seq_start_input; - Fl_Input *seq_end_input; - - // callback receiver functions - - void real_get_seq_cb(); - void real_set_seq_id_cb(Fl_Input* o); - void real_set_seq_start_cb(Fl_Input* o); - void real_set_seq_end_cb(Fl_Input* o); - - private: - // sequence data - std::vector the_Seqs; - std::string sub_sequence; - int seq_id, seq_start, seq_end; -}; -#endif diff --git a/mussa_gui_seq_view.cc b/mussa_gui_seq_view.cc deleted file mode 100644 index f4c83f2..0000000 --- a/mussa_gui_seq_view.cc +++ /dev/null @@ -1,524 +0,0 @@ -// This file is part of the Mussa source distribution. -// http://mussa.caltech.edu/ -// Contact author: Tristan De Buysscher, tristan@caltech.edu - -// This program and all associated source code files are Copyright (C) 2005 -// the California Institute of Technology, Pasadena, CA, 91125 USA. It is -// under the GNU Public License; please see the included LICENSE.txt -// file for more information, or contact Tristan directly. - - -#include "mussa_gui_seq.hh" -#include - -#include -#include - -using namespace std; - -void -SeqView::setup(string name, int sq_num, - vector *some_seqs, - list > some_paths, vector some_lens, - vector *some_motifs) -{ - int seq_i; - list >::iterator pathz_i; - - - ana_name = name; - seq_num = sq_num; - S = some_seqs; - P = some_paths; - seq_lens = some_lens; - the_motifs = some_motifs; - - y_seq_incre = (y_max-10-10) / (seq_num - 1); - - fl_font(FL_COURIER, 14); - cout << "font width: " << fl_width('A') << endl; - - index_pad = 6 * (int) fl_width('A') + 5; - - align_offsets(0); - - raw_sequence.clear(); - for(seq_i = 0; seq_i < seq_num; ++seq_i) - raw_sequence.push_back( (*S)[seq_i].seq() ); - - for(pathz_i = P.begin(); pathz_i != P.end(); ++pathz_i) - { - show_aligns.push_back(true); - } - - dragging = false; - scroll_offset = 0; - //scroll_pos = 0; - drag_change = 0; - - cout << "waaaaa!\n"; - cout << x() << " " << y() << " " << w() << " " << h() << endl; -} - -void -SeqView::resize(int new_x, int new_y, int new_w, int new_h) -{ - x(new_x); - y(new_y); - w(new_w); - h(new_h); - - // hmmm, why do I use these values on the the widgets inherent ones? - // I think there was a reason...once? - x_max = new_w; - y_max = new_h; - x_min = new_x; - y_min = new_y; - - // things that need to be recalculated - y_seq_incre = (y_max-10-10) / (seq_num - 1); -} - - - - -void -SeqView::draw() -{ - double ch_width; - - - // clear drawing area and set background to white - fl_color(FL_WHITE); - fl_rectf(x(), y(), w(), h()); - - - fl_font(FL_COURIER, 14); - //blatantly stolen from FR2 - ch_width = fl_width('A'); // monospaced: all characters are same width - - - if (show_bars) - { - int grey_box_num, grey_box_len; - int i; - // draw in some light grey boxes every 10bp to delineate for user - //fl_color(200,235,235); - fl_color(180,180,180); - grey_box_num = (((x_max - index_pad) / (int) ch_width) / 10) + 1; - grey_box_len = 10 * (int) ch_width; - for(i = 0; i < grey_box_num; i++) - if ((i % 2) != 0) - fl_rectf(x()+index_pad-1 + (i * grey_box_len), y(), grey_box_len, h()); - } - - if (show_motifs) - draw_motifs(ch_width); - - draw_sequence(ch_width); - - draw_match_lines(ch_width); - - draw_indices(ch_width); - - - // draw some bounding boxes to visually separate things - fl_color(150,200,255); - fl_line_style(FL_SOLID, 2, NULL); - fl_rect(x(), y(), w(), h()); - fl_rect(x()+index_pad-1, y(), w()-2*(index_pad-1), h()); -} - -void -SeqView::draw_motifs(double ch_width) -{ - vector::iterator motif_i; - vector some_motif_locs; - vector::iterator i_locs; - int scale_len, motif_len, i2; - int y_loc, x_start; - - //fl_color(255,0,255); - fl_line_style(FL_SOLID, 10, NULL); - motif_i = the_motifs->begin(); - while (motif_i != the_motifs->end()) - { - fl_color(motif_i->color); - motif_len = motif_i->seq.length(); - scale_len = (int) (motif_len * ch_width); - y_loc = y_min + 10; - if (!motif_i->locations.empty()) - for(i2 = 0; i2 < seq_num; i2++) - { - some_motif_locs = (*motif_i).locations[i2]; - - i_locs = some_motif_locs.begin(); - while (i_locs != some_motif_locs.end()) - { - x_start = (int) ((*i_locs +scroll_offset - seq_align_offsets[i2]) - * ch_width) + index_pad + x(); - - //cout << *i_locs << ":" << x_start << " "; - // don't draw highlights outside of box range, they can wraparound past some boundry - if ((x_start > 0) && (x_start < w())) - fl_line(x_start,y_loc,x_start+scale_len,y_loc); - ++i_locs; - } - //cout << endl; - y_loc += y_seq_incre; - } - ++motif_i; - } -} - -void -SeqView::draw_sequence(double ch_width) -{ - int i, seq_i, y_loc; - Sequence a_seq; - string sub_seq; - int seq_len, sub_seq_start, sub_seq_len; - - - - fl_color(FL_BLACK); - y_loc = y_min + 10 + 5; - - for(seq_i = 0; seq_i < seq_num; seq_i++) - { - seq_len = raw_sequence[seq_i].length(); - sub_seq_start = seq_align_offsets[seq_i] - scroll_offset; - sub_seq_len = (x_max - index_pad) / (int) ch_width; - //cout << x_max << " index_pad: " << index_pad << " y - ip: " << (x_max - index_pad) << endl; - - // gotta check thru boundary conditions to make sure we're producing the - // right string for the current position (otherwise gonna crash due to - // illegal indexing into substr - if (sub_seq_start < 0) - { - sub_seq_len = sub_seq_len - sub_seq_start; - if (sub_seq_len < 0) - sub_seq_len = 0; - sub_seq_start = 0; - } - else if (sub_seq_start >= seq_len) - { - sub_seq_start = seq_len; - sub_seq_len = 0; - } - else if ((sub_seq_start + sub_seq_len) >= seq_len) - sub_seq_len = seq_len - sub_seq_start; - - sub_seq = raw_sequence[seq_i].substr(sub_seq_start, sub_seq_len); - fl_draw(sub_seq.c_str(), index_pad, y_loc); - y_loc += y_seq_incre; - } -} - - -void -SeqView::draw_match_lines(double ch_width) -{ - int i, y_loc; - vector a_path; - list >::iterator pathz_i; - int i2, i3; - int x_start, y_start, x_end, y_end; - int window_length, win_i; - int rc_1 = 0; - int rc_2 = 0; - int offset1, offset2; - float center1, center2; - bool rc_color; - vector rc_list; - bool full_match; - vector matched; - int align_counter; - - - align_counter = 0; - for(pathz_i = P.begin(); pathz_i != P.end(); ++pathz_i) - { - if (show_aligns[align_counter]) - { - a_path = *pathz_i; - window_length = a_path[0]; - - // determine which parts of the path are RC relative to first species - rc_list.clear(); - for(i2 = 1; i2 <= seq_num; i2++) - { - if (a_path[i2] < 0) - rc_list.push_back(true); - else - rc_list.push_back(false); - } - - // loop over each bp in the conserved region for all sequences - for(win_i = 0; win_i < window_length; win_i++) - { - // determine which exact base pairs match between the sequences - full_match = true; - for(i2 = 1; i2 < seq_num; i2++) - { - // assume not rc as most likely, adjust below - rc_1 = 0; - rc_2 = 0; - // no matter the case, any RC node needs adjustments - if (a_path[i2] < 0) - rc_1 = window_length-1; - if (a_path[i2+1] < 0) - rc_2 = window_length-1; - - x_start = (abs(a_path[i2]-rc_1+win_i)); - x_end = (abs(a_path[i2+1]-rc_2+win_i)); - - // RC case handling - // ugh, and xor...only want rc coloring if just one of the nodes is rc - // if both nodes are rc, then they are 'normal' relative to each other - if ( ( rc_list[i2] || rc_list[i2-1] ) && - !(rc_list[i2] && rc_list[i2-1] ) ) - { //the hideous rc matching logic - not complex, but annoying - if ( !( ( (raw_sequence[i2-1][x_start] == 'A') && - (raw_sequence[i2][x_end] == 'T') ) || - ( (raw_sequence[i2-1][x_start] == 'T') && - (raw_sequence[i2][x_end] == 'A') ) || - ( (raw_sequence[i2-1][x_start] == 'G') && - (raw_sequence[i2][x_end] == 'C') ) || - ( (raw_sequence[i2-1][x_start] == 'C') && - (raw_sequence[i2][x_end] == 'G') ) ) ) - full_match = false; - } - else - { - if (!( (raw_sequence[i2-1][x_start] == raw_sequence[i2][x_end]) && - (raw_sequence[i2-1][x_start] != 'N') && - (raw_sequence[i2][x_end] != 'N') ) ) - full_match = false; - } - } - - // draw for matches stretching across all sequences - if (full_match) - { - fl_line_style(FL_SOLID, 1, NULL); - - // now can draw the line for each bp in this window that matches - // grrr, need to ask if anyone cares if I switch the seq top-bot order... - i3 = 0; - y_loc = y_min + 5; - for(i2 = 1; i2 < seq_num; i2++) - { - // assume not rc as most likely, adjust below - rc_1 = 0; - rc_2 = 0; - // this makes the lines start in the middle of the drawn char/bp - center1 = 0.5; - center2 = 0.5; - // no matter the case, any RC node needs adjustments - if (a_path[i2] < 0) - { - rc_1 = window_length; - center1 = -center1; - } - if (a_path[i2+1] < 0) - { - rc_2 = window_length; - center2 = -center2; - } - - // set offset based on current alignment for which bp to show - offset1 = seq_align_offsets[i2-1]; - offset2 = seq_align_offsets[i2]; - - if ( ( rc_list[i2] || rc_list[i2-1] ) && - !(rc_list[i2] && rc_list[i2-1] ) ) - fl_color(FL_BLUE); - else - fl_color(FL_RED); - - // maybe shouldn't recalc these, but store values from first loop - x_start = (abs((int) (a_path[i2]-rc_1+win_i))); - x_end = (abs((int) (a_path[i2+1]-rc_2+win_i))); - - fl_line( (int)((x_start+center1-offset1+scroll_offset)*ch_width) - + index_pad, y_loc + 10, - (int)((x_end+center2-offset2+scroll_offset)*ch_width) - + index_pad, y_loc+y_seq_incre ); - y_loc += y_seq_incre; - } - } - } - } - align_counter++; - } -} - -void -SeqView::draw_indices(double ch_width) -{ - int seq_i; - Sequence a_seq; - int y_loc; - ostringstream an_index; - int shown_seq_len; - - - // clear out space on sides to draw in index values - // I block out the sides rather than adding offsets to the drawing of seq - // and conservation lines since the lines need to draw off the 'edge' - fl_color(FL_WHITE); - fl_rectf(0, y_min, index_pad, h()+y_min); - fl_rectf(w()-index_pad, y_min, index_pad, h()+y_min); - - // now can draw in the indices of the start and end of the shown sequence - fl_color(FL_BLACK); - y_loc = y_min + 10 + 5; - for(seq_i = 0; seq_i < seq_num; seq_i++) - { - an_index.str(""); - an_index << (seq_align_offsets[seq_i]-scroll_offset); - fl_draw((an_index.str()).c_str(), 2, y_loc); - - shown_seq_len = (w() - 2 * index_pad) / (int) ch_width; - an_index.str(""); - an_index << (seq_align_offsets[seq_i]-scroll_offset+shown_seq_len); - fl_draw((an_index.str()).c_str(), w()-index_pad+2, y_loc); - y_loc += y_seq_incre; - } -} - - -void -SeqView::toggle_align(int align_num) -{ - //cout << align_num << endl; - //cout << show_aligns[align_num] << endl; - show_aligns[align_num] = !show_aligns[align_num]; - //cout << show_aligns[align_num] << endl; -} - - -void -SeqView::align_offsets(int align_num) -{ - list >::iterator pathz_i; - int i; - vector a_path; - int window_length; - - cout << "alignment: " << align_num << endl; - - if (P.begin() == P.end()) - cout << "crud....\n"; - else - { - pathz_i = P.begin(); - - while(pathz_i != P.end()) - ++pathz_i; - - // find the path specified - i = 0; - pathz_i = P.begin(); - while( (i < align_num) && (pathz_i != P.end()) ) - { - ++i; - ++pathz_i; - } - - // now set the alignment offsets - basically where the path starts - seq_align_offsets.clear(); - for(i = 0; i < seq_num ; i++) - { - //cout << (*pathz_i)[i+1] << endl; - seq_align_offsets.push_back( abs((*pathz_i)[i+1]) ); - // for testing purposes: to see everything in the short test sequences - //seq_align_offsets.push_back(0); - } - // reset any dragging done, otherwise might be hard to find selected align - scroll_offset = 0; - } -} - - - -int -SeqView::handle(int e) -{ - int return_value; - - // this empty string needs to be put on cout, otherwise the -O optimize - // compile option seems to throw this function away with the following: - // gcc version 3.2.2 20030222 (Red Hat Linux 3.2.2-5) - cout << ""; - - switch(e) - { - case FL_PUSH: - if (Fl::event_button3()) - { - cout << "menu menu menu!\n"; - return_value = 1; - } - break; - case FL_DRAG: - if (!dragging) - { - drag_change = Fl::event_x(); - dragging = true; - return_value = 1; - } - drag_change = Fl::event_x() - drag_change; - scroll_offset += drag_change; - drag_change = Fl::event_x(); - redraw(); - break; - case FL_RELEASE: - if (dragging) - { - //scroll_offset += Fl::event_x() - drag_start; - //scroll_dist = Fl::event_x() - drag_start; - //scroll_offset += scroll_dist; - //scroll_offset += scroll_pos; - dragging = false; - redraw(); - return_value = 1; - } - break; - default: - return_value = Fl_Widget::handle(e); - } - - return return_value; -} - -void -SeqView::toggle_bars() -{ - show_bars = !show_bars; - redraw(); -} - - -void -SeqView::toggle_motifs() -{ - show_motifs = !show_motifs; - redraw(); -} - - -void -SeqView::reporter(string id, int value) -{ - cout << id << " : " << value << endl; -} - - -/* - cout << "fee\n"; - cout << "fie\n"; - cout << "foe\n"; - cout << "fum\n"; -*/ diff --git a/mussa_gui_seq_view.hh b/mussa_gui_seq_view.hh deleted file mode 100644 index c66d368..0000000 --- a/mussa_gui_seq_view.hh +++ /dev/null @@ -1,75 +0,0 @@ -#ifndef _MUSSA_GUI_SEQ_VIEW_H_ -#define _MUSSA_GUI_SEQ_VIEW_H_ -// This file is part of the Mussa source distribution. -// http://mussa.caltech.edu/ -// Contact author: Tristan De Buysscher, tristan@caltech.edu - -// This program and all associated source code files are Copyright (C) 2005 -// the California Institute of Technology, Pasadena, CA, 91125 USA. It is -// under the GNU Public License; please see the included LICENSE.txt -// file for more information, or contact Tristan directly. - -#include -#include -#include - -#include - -#include "mussa_gui_motif_window.hh" -#include "mussa_gui_load_window.hh" - -class SeqView : public Fl_Box -{ - public: - SeqView(int x_top,int y_top,int x_bot,int y_bot) : - Fl_Box(x_top,y_top,x_bot,y_bot) - { - x_max = x_bot; - y_max = y_bot; - x_min = x_top; - y_min = y_top; - show_bars = true; - show_motifs = true; - } - - void setup(std::string name, int sq_num, std::vector *some_seqs, - std::list > some_paths, - std::vector some_lens, std::vector *some_motifs); - void align_offsets(int align_num); - void toggle_align(int align_num); - void toggle_bars(); - void toggle_motifs(); - - private: - std::string ana_name; - int seq_num; - int base_window_len; - - //this data is passed as pointers to the instantiated classes - std::vector *S; - //list of paths in selection box - std::list > P; - std::vector seq_lens; - //pointer to passed motif data - std::vector *the_motifs; - - int x_max, y_max, x_min, y_min; - int y_seq_incre; - int index_pad; - std::vector seq_align_offsets; - std::vector raw_sequence; - bool dragging; - int drag_change, scroll_offset; - bool show_bars, show_motifs; - std::vector show_aligns; - - void resize(int new_x, int new_y, int new_w, int new_h); - void draw(); - void draw_motifs(double ch_width); - void draw_sequence(double ch_width); - void draw_match_lines(double ch_width); - void draw_indices(double ch_width); - int handle(int e); - void reporter(std::string id, int value); -}; -#endif diff --git a/mussa_gui_subana.cc b/mussa_gui_subana.cc deleted file mode 100644 index cd29299..0000000 --- a/mussa_gui_subana.cc +++ /dev/null @@ -1,288 +0,0 @@ -// This file is part of the Mussa source distribution. -// http://mussa.caltech.edu/ -// Contact author: Tristan De Buysscher, tristan@caltech.edu - -// This program and all associated source code files are Copyright (C) 2005 -// the California Institute of Technology, Pasadena, CA, 91125 USA. It is -// under the GNU Public License; please see the included LICENSE.txt -// file for more information, or contact Tristan directly. - - -#include "mussa_gui_subana.hh" - -#include -using namespace std; - -void -do_subana_cb(Fl_Button* o, void* v) -{ - SubanaWindow* T=(SubanaWindow*)v; - T->real_do_subana(); -} - - -// passes the parameters to the mussa class object and orders it to run -void -SubanaWindow::real_do_subana() -{ - int i; - string a_sequence, err_msg; - - // <-- need a check here to make sure all vars have a valid value - - an_analysis->clear(); - an_analysis->set_name(ana_name); - an_analysis->set_seq_num(seq_num); - an_analysis->set_window(window); - an_analysis->set_threshold(threshold); - - for(i=0; i < seq_num; i++) - { - a_sequence = the_Seqs[i].seq(); - cout << a_sequence.length() << endl; - a_sequence = a_sequence.substr(sub_seq_starts[i], - sub_seq_ends[i] - sub_seq_starts[i] ); - cout << a_sequence.length() << endl; - an_analysis->add_a_seq(a_sequence); - } - - err_msg = an_analysis->analyze(0,0, 't', 0.0); - - cout << "Feel the tribal beat\n"; - if (!(err_msg == "")) - { - //fl_alert(err_msg.c_str()); - cout << err_msg; - } - - all_done = true; - - hide(); -} - - - -// *** subsequence start select - -void -sub_start_in_cb1(Fl_Input* o, void* v) -{ - sub_seq_data_instance * blah = (sub_seq_data_instance *) v; - SubanaWindow* T= blah->sw_ptr; - T->real_sub_start_in_cb(o,blah->index); -} - -void -SubanaWindow::real_sub_start_in_cb(Fl_Input* o, int i) -{ - sub_seq_starts[i] = atoi(o->value()); -} - -// *** subsequence end select - -void -sub_end_in_cb1(Fl_Input* o, void* v) -{ - sub_seq_data_instance * blah = (sub_seq_data_instance *) v; - SubanaWindow* T= blah->sw_ptr; - T->real_sub_end_in_cb(o,blah->index); -} - -void -SubanaWindow::real_sub_end_in_cb(Fl_Input* o, int i) -{ - sub_seq_ends[i] = atoi(o->value()); - -} - -// *** input analysis name - -void -set_ana_name_cb1(Fl_Input* o, void* v) -{ - SubanaWindow* T=(SubanaWindow*)v; - T->real_set_ana_name_cb(o); -} - -void -SubanaWindow::real_set_ana_name_cb(Fl_Input* o) -{ - ana_name = o->value(); -} - -// *** input window size - -void -set_win_size_cb1(Fl_Input* o, void* v) -{ - SubanaWindow* T=(SubanaWindow*)v; - T->real_set_win_size_cb(o); -} - -void -SubanaWindow::real_set_win_size_cb(Fl_Input* o) -{ - window = atoi(o->value()); -} - -// *** input threshold - -void -set_threshold_cb1(Fl_Input* o, void* v) -{ - SubanaWindow* T=(SubanaWindow*)v; - T->real_set_threshold_cb(o); -} - -void -SubanaWindow::real_set_threshold_cb(Fl_Input* o) -{ - threshold = atoi(o->value()); -} - - -bool -SubanaWindow::done() -{ - return all_done; -} - - -SubanaWindow::SubanaWindow(int w, int h, const char* title,Mussa *the_analysis, - vector some_Seqs):Fl_Window(w,h,title) -{ - string a_name; - - color(FL_WHITE); - - an_analysis = the_analysis; - the_Seqs = some_Seqs; - all_done = false; - - // initialize parameters - ana_name = ""; - window = -1; - threshold = -1; - - begin(); - - name_input = new Fl_Input(135, 10, w-140, 30, "SubAnalysis Name "); - name_input->value(""); - //name_input->when(FL_WHEN_ENTER_KEY); - name_input->box(FL_BORDER_BOX); - name_input->callback((Fl_Callback*)set_ana_name_cb1, this); - - // add in radio buttons for win_append and thres_append eventually - win_append = true; - thres_append = true; - - win_input = new Fl_Input(135,45,100,30, "Window: "); - win_input->value(""); - win_input->callback((Fl_Callback*)set_win_size_cb1, this); - - thres_input = new Fl_Input(320,45,100,30, "Threshold: "); - thres_input->value(""); - thres_input->callback((Fl_Callback*)set_threshold_cb1, this); - - // button to launch the analysis - test = new Fl_Button(w-100,h-30,100,30,"Do Analysis"); - test->callback((Fl_Callback*)do_subana_cb, this); - - // test button to make sure setup data is being stored - test = new Fl_Button(w-200,h-30,100,30,"show setup"); - test->callback((Fl_Callback*)print_cb, this); - - // add all the inputs for the sub sequence starts & ends - int i; - - seq_num = the_Seqs.size(); - - seq_scroll = new Fl_Scroll(5,80,w-10,h-115); - seq_scroll->color(FL_WHITE); - - for (i = 0; i < seq_num; i++) - { - sub_seq_starts.push_back(0); - sub_seq_ends.push_back(0); - a_name = the_Seqs[i].sp_name(); - cout << a_name << endl; - add_seq_input(i, a_name); - } - seq_scroll->box(FL_DOWN_FRAME); - //add(seq_scroll); - //redraw(); - - end(); - //resizable(this); - show(); -} - - -SubanaWindow::~SubanaWindow(){} - - -void -SubanaWindow::add_seq_input(int i, string a_name) -{ - Fl_Input *start_input, *end_input; - - - // this remembers what seq index each input is associated with - sub_seq_data_instance * something; - something = new sub_seq_data_instance; - something->sw_ptr = this; - something->index = i; - - - // subsequence select, index of first bp wanted - start_input = new Fl_Input(150, 85+(i*35), 70, 30, "start index: "); - start_input->value(""); - start_input->callback((Fl_Callback*)sub_start_in_cb1, (void*) something); - - // subsequence select, index of last bp wanted - end_input = new Fl_Input(300, 85+(i*35), 70, 30, "end index: "); - end_input->value(""); - end_input->callback((Fl_Callback*)sub_end_in_cb1, (void*) something); - - seq_scroll->add(start_input); - seq_scroll->add(end_input); -} - -/* - cout << "fee\n"; - cout << "fie\n"; - cout << "foe\n"; - cout << "fum\n"; -*/ - -void SubanaWindow::print_cb(Fl_Button* o, void* v) -{ - SubanaWindow* T=(SubanaWindow*)v; - T->print_cb_real(o,v); -} - - -void SubanaWindow::print_cb_real(Fl_Button* , void*) -{ - cout << "ana_name: " << ana_name << endl; - cout << "win: " << window << endl; - cout << "thres: " << threshold << endl; - cout << "seq_num: " << seq_num << endl; - //cout << "win_add: " << win_append << end; - //cout << "thres_add: " << thres_append << endl; - - int i; - - - - for (i = 0; i < seq_num; i++) - { - //cout << seq_files[i] << endl; - //cout << annot_files[i] << endl; - //cout << "fasta: " << fasta_indices[i]; - cout << " start: " << sub_seq_starts[i]; - cout << " end: " << sub_seq_ends[i] << endl; - cout << "blargle!\n"; - } - cout << "end of inputs\n" << endl; -} diff --git a/mussa_gui_subana.hh b/mussa_gui_subana.hh deleted file mode 100644 index e86e777..0000000 --- a/mussa_gui_subana.hh +++ /dev/null @@ -1,81 +0,0 @@ -#ifndef _MUSSA_GUI_SUBANA_H_ -#define _MUSSA_GUI_SUBANA_H_ -// This file is part of the Mussa source distribution. -// http://mussa.caltech.edu/ -// Contact author: Tristan De Buysscher, tristan@caltech.edu - -// This program and all associated source code files are Copyright (C) 2005 -// the California Institute of Technology, Pasadena, CA, 91125 USA. It is -// under the GNU Public License; please see the included LICENSE.txt -// file for more information, or contact Tristan directly. - -#include -#include - -#include -#include -#include -#include -#include - -#include "mussa_class.hh" -#include "mussa_gui_seq_text.hh" - -class SubanaWindow : public Fl_Window -{ - public: - SubanaWindow(int w, int h, const char* title, Mussa *an_analysis, - std::vector some_Seqs); - ~SubanaWindow(); - bool done(); - - - Fl_Button* test; - - Fl_Input *name_input; - Fl_Input *win_input; - Fl_Input *thres_input; - Fl_Input *seq_num_input; - Fl_Scroll *seq_scroll; - // need to keep track of these so a browsed file search can set the input - // fields to the selected file - std::vector seq_inputs, annot_inputs; - - - // callback receiver functions - - void real_do_subana(); - - void real_set_ana_name_cb(Fl_Input* o); - void real_set_win_size_cb(Fl_Input* o); - void real_set_threshold_cb(Fl_Input* o); - - void real_sub_start_in_cb(Fl_Input* o, int i); - void real_sub_end_in_cb(Fl_Input* o, int i); - - private: - // sequence data - std::vector the_Seqs; - Mussa *an_analysis; - std::string ana_name; - int window, threshold, seq_num; - std::vector sub_seq_starts, sub_seq_ends; - bool win_append, thres_append; - bool all_done; - - static void print_cb(Fl_Button*, void*); - inline void print_cb_real(Fl_Button*, void*); - - void add_seq_input(int index, std::string a_name); -}; - -// crazy whacked shite Titus taught me to do to get an index value associated -// with each instance of an input associated with the callback... - - -struct sub_seq_data_instance -{ - SubanaWindow * sw_ptr; - int index; -}; -#endif diff --git a/mussa_nway.cc b/mussa_nway.cc deleted file mode 100644 index c9a2f09..0000000 --- a/mussa_nway.cc +++ /dev/null @@ -1,471 +0,0 @@ -// This file is part of the Mussa source distribution. -// http://mussa.caltech.edu/ -// Contact author: Tristan De Buysscher, tristan@caltech.edu - -// This program and all associated source code files are Copyright (C) 2005 -// the California Institute of Technology, Pasadena, CA, 91125 USA. It is -// under the GNU Public License; please see the included LICENSE.txt -// file for more information, or contact Tristan directly. - - -// ---------------------------------------- -// ---------- mussa_nway.cc ----------- -// ---------------------------------------- - -#include "mussa_nway.hh" -#include -#include - -using namespace std; - -Nway_Paths::Nway_Paths() -{ -} - -void -Nway_Paths::setup(int sp_num, int w, int t) -{ - species_num = sp_num; - threshold = t; - soft_thres = threshold; - win_size = w; - pathz.clear(); - - cout << "nway: species_num = " << species_num << ", thres = " << threshold - << ", softo = " << soft_thres << endl; -} - -void -Nway_Paths::set_soft_thres(int sft_thres) -{ - soft_thres = sft_thres; -} - - - - -// dumbly goes thru and combines path windows exactly adjacent (ie + 1 index) -// doesn't deal with interleaved adjacency -void -Nway_Paths::simple_refine() -{ - // ext_path remembers the first window set in an extending path - vector ext_path, cur_path, next_path, new_path; - list >::iterator pathz_i; - int i2, win_ext_len = 0; - bool extending, end = false; - int count_loop = 0; - - - refined_pathz.clear(); - - cout << "path number is: " << pathz.size() << endl; - pathz_i = pathz.begin(); - ext_path = *pathz_i; - - while(pathz_i != pathz.end()) - { - //cout << "path number is: " << pathz.size() << endl; - //++count_loop; - //cout << "glorpagh!!!!!" << count_loop << endl; - - // keep track of current path and advance to next path - cur_path = *pathz_i; - ++pathz_i; - if (pathz_i == pathz.end()) - end = true; - else - next_path = *pathz_i; - - //cout << "S\'Nork!\n"; - - if (not end) - { - // if node for each seq is equal to the next node+1 then for all - // sequences then we are extending - extending = true; - for(i2 = 0; i2 < species_num; i2++) - { - //cout << cur_path[i2] << " vs " << endl; - //cout << next_path[i2] << endl; - if (cur_path[i2] + 1 != next_path[i2]) - extending = false; - } - } - else - extending = false; - - if (extending) - { - //cout << "Raaaawwwrrr! I am extending\n"; - win_ext_len++; - } - else - { - //cout << "Larfnarg?\n"; - // add the extend window length as first element and add as refined - new_path = ext_path; - new_path.insert(new_path.begin(),win_size + win_ext_len); - for(i2 = 1; i2 <= species_num; i2++) - { - if (new_path[i2] < 0) - { - //cout << "before: " << new_path[i2]; - new_path[i2] += win_ext_len; - //cout << " after: " << new_path[i2] << endl; - } - } - refined_pathz.push_back(new_path); - // reset stuff - win_ext_len = 0; - ext_path = next_path; - } - } - cout << "r_path number is: " << refined_pathz.size() << endl; -} - - -void -Nway_Paths::add_path(vector loaded_path) -{ - pathz.push_back(loaded_path); -} - - -void -Nway_Paths::save(string save_file_path) -{ - fstream save_file; - list >::iterator path_i, paths_end; - vector a_path; - int i; - - save_file.open(save_file_path.c_str(), ios::out); - - save_file << "\n"; - - path_i = refined_pathz.begin(); - paths_end = refined_pathz.end(); - //path_i = pathz.begin(); - //paths_end = pathz.end(); - while (path_i != paths_end) - { - a_path = *path_i; - //cout << a_path.size() << endl; - //first entry is the window length of the windows in the path - save_file << a_path[0] << ":"; - for(i = 1; i <= species_num; ++i) - { - save_file << a_path[i]; - if (i != species_num) - save_file << ","; - } - save_file << endl; - ++path_i; - } - - save_file << "\n"; - save_file.close(); -} - -/* - if (path_i == paths_end) - cout << "Arrrrrrgggghhhhhh\n"; -*/ - -int -Nway_Paths::seq_num() -{ - return species_num; -} - - -string -Nway_Paths::load(string load_file_path) -{ - fstream load_file; - string file_data_line, header_data, data, path_node, path_length; - int i, space_split_i, equal_split_i, comma_split_i, colon_split_i; - vector loaded_path; - string err_msg; - - - load_file.open(load_file_path.c_str(), ios::in); - - if (!load_file) - { - err_msg = "Sequence File: " + load_file_path + " not found"; - cout << "BAM!!!!\n"; - return err_msg; - } - - else - { - // get header data - // grab mussa tag - discard for now...maybe check in future... - getline(load_file,file_data_line); - space_split_i = file_data_line.find(" "); - file_data_line = file_data_line.substr(space_split_i+1); - // grab type tag - need in future to distinguish between flp and vlp paths - space_split_i = file_data_line.find(" "); - file_data_line = file_data_line.substr(space_split_i+1); - // get species/seq number - space_split_i = file_data_line.find(" "); - header_data = file_data_line.substr(0,space_split_i); - equal_split_i = header_data.find("="); - data = file_data_line.substr(equal_split_i+1); - species_num = atoi (data.c_str()); - file_data_line = file_data_line.substr(space_split_i+1); - // get window size - space_split_i = file_data_line.find(" "); - header_data = file_data_line.substr(0,space_split_i); - equal_split_i = header_data.find("="); - data = file_data_line.substr(equal_split_i+1); - win_size = atoi (data.c_str()); - file_data_line = file_data_line.substr(space_split_i+1); - // get window size - space_split_i = file_data_line.find(" "); - header_data = file_data_line.substr(0,space_split_i); - equal_split_i = header_data.find("="); - data = file_data_line.substr(equal_split_i+1); - threshold = atoi (data.c_str()); - file_data_line = file_data_line.substr(space_split_i+1); - - cout << "seq_num=" << species_num << " win=" << win_size; - cout << " thres=" << threshold << endl; - - // clear out the current data - refined_pathz.clear(); - - int temp; - - getline(load_file,file_data_line); - while ( (!load_file.eof()) && (file_data_line != "") ) - { - if (file_data_line != "") - { - loaded_path.clear(); - colon_split_i = file_data_line.find(":"); - path_length = file_data_line.substr(0,colon_split_i); - loaded_path.push_back(atoi (path_length.c_str())); - file_data_line = file_data_line.substr(colon_split_i+1); - for(i = 0; i < species_num; i++) - { - comma_split_i = file_data_line.find(","); - path_node = file_data_line.substr(0, comma_split_i); - temp = atoi (path_node.c_str()); - loaded_path.push_back(temp); - file_data_line = file_data_line.substr(comma_split_i+1); - } - refined_pathz.push_back(loaded_path); - } - getline(load_file,file_data_line); - } - - - load_file.close(); - - return ""; - } -} - - - - -void -Nway_Paths::path_search(vector > all_comparisons, vector path, int depth) -{ - list new_nodes, trans_check_nodes; - list::iterator new_nodes_i, new_nodes_end; - int i; - bool trans_check_good; - - new_nodes = all_comparisons[depth - 1][depth].matches(path[depth-1]); - new_nodes_i = new_nodes.begin(); - new_nodes_end = new_nodes.end(); - while(new_nodes_i != new_nodes_end) - { - //cout << " * species " << depth << " node: " << *new_nodes_i << endl; - // check transitivity with previous nodes in path - trans_check_good = true; - for(i = 0; i < depth - 1; i++) - { - trans_check_nodes = all_comparisons[i][depth].matches(path[i]); - if ( (trans_check_nodes.end() == find(trans_check_nodes.begin(), - trans_check_nodes.end(), - *new_nodes_i) ) && - (trans_check_nodes.end() == find(trans_check_nodes.begin(), - trans_check_nodes.end(), - *new_nodes_i * -1) ) ) - trans_check_good = false; - } - - if (trans_check_good) - { - // this makes sure path nodes are recorded with RC status relative to - // the base species - if ( path[depth-1] >= 0) - path.push_back(*new_nodes_i); - else - path.push_back(*new_nodes_i * -1); - - if (depth < species_num - 1) - path_search(all_comparisons, path, depth + 1); - else - pathz.push_back(path); - path.pop_back(); - } - ++new_nodes_i; - } -} -// cout << " ****I have the power...\n"; - -/* use this if I ever get the friggin seqcomp match lists to sort... - if (binary_search(trans_check_nodes.begin(), trans_check_nodes.end(), - *new_nodes_i)) -*/ - -void -Nway_Paths::find_paths_r(vector > all_comparisons) -{ - vector path; - int win_i, window_num; - list new_nodes; - list::iterator new_nodes_i, new_nodes_end; - - pathz.clear(); - window_num = all_comparisons[0][1].win_num(); - cout << window_num << endl; - // loop thru all windows in first species - for (win_i = 0; win_i < window_num; win_i++) - { - path.clear(); - path.push_back(win_i); - new_nodes = all_comparisons[0][1].matches(path[0]); - new_nodes_i = new_nodes.begin(); - new_nodes_end = new_nodes.end(); - //if (new_nodes_i != new_nodes_end) - //cout << "* species 0 node: " << win_i << endl; - // cout << "foookin hell\n"; - path.push_back(0); - while(new_nodes_i != new_nodes_end) - { - //cout << " * species 1 node: " << *new_nodes_i << endl; - path[1] = *new_nodes_i; - path_search(all_comparisons, path, 2); - ++new_nodes_i; - } - } -} - - -void -Nway_Paths::save_old(string save_file_path) -{ - fstream save_file; - list >::iterator path_i, paths_end; - vector a_path; - int i; - - save_file.open(save_file_path.c_str(), ios::app); - - path_i = pathz.begin(); - paths_end = pathz.end(); - while(path_i != paths_end) - { - a_path = *path_i; - //cout << a_path.size() << endl; - for(i = 0; i < species_num; ++i) - save_file << i << "," << a_path[i] << " "; - save_file << endl; - ++path_i; - } - save_file.close(); -} - - -/* -void -Nway_Paths::find_paths(vector > all_comparisons) -{ - int win_i, sp_i; - vector > > path_src_tree; - list new_nodes; - list::iterator node_i, node_end; - > >::iterator branch_i, branch_end; - - pathz.clear(); - path_src_tree.reserve(species_num - 1); - - - // loop thru all windows in first species - for (win_i = 0; win_i < window_num; win_i++) - { - // clear the path search tree - for(i = 0; i < species_num; i++) - path_src_tree[i].clear(); - - // top level kept empty even tho implicity has one entry of the first - // species at this window - why bother, adds a little speed - - // get connection list for first species, creating a list of nodes - // of second species connected to the first species at this window - new_nodes = all_comparisons[0][1]; - path_src_tree[1].push_back(new_nodes); - - // loop thru rest of species for this window to see if any paths of matches - // go across all species - // if path search tree becomes empty, break out of loop, no reason to search further - sp_i = 1; - while ((sp_i < species_num) && (path tree not empty)) - { - branch_i = path_src_tree[1].begin(); - branch_end = path_src_tree[1].end(); - while (branch_i != branch_end) - { - node_i = branch_i->begin(); - node_end = branch_i->end(); - } - - - // loop over all current nodes - // get connection list for each node - // loop over each previous node in list - // get those nodes connection list - // intersect previous node connections with current - - ++sp_i; - } - - // insert any of the paths found into the master list of paths - - // add no paths if tmp_pathz is empty... - } -} - -void Nway_Paths::refine() -{ -} - -void Nway_Paths::print() -{ - list >::iterator pathz_i; - - cout << "printing list of lists\n"; - for (pathz_i = pathz.begin(); pathz_i != pathz.end(); ++pathz_i) - { - for (path_i = pathz_i->begin(); path_i != pathz_i->end(); ++path_i) - cout << *path_i << " "; - cout << endl; - } -} -*/ - - - - diff --git a/mussa_nway.cxx b/mussa_nway.cxx new file mode 100644 index 0000000..c9a2f09 --- /dev/null +++ b/mussa_nway.cxx @@ -0,0 +1,471 @@ +// This file is part of the Mussa source distribution. +// http://mussa.caltech.edu/ +// Contact author: Tristan De Buysscher, tristan@caltech.edu + +// This program and all associated source code files are Copyright (C) 2005 +// the California Institute of Technology, Pasadena, CA, 91125 USA. It is +// under the GNU Public License; please see the included LICENSE.txt +// file for more information, or contact Tristan directly. + + +// ---------------------------------------- +// ---------- mussa_nway.cc ----------- +// ---------------------------------------- + +#include "mussa_nway.hh" +#include +#include + +using namespace std; + +Nway_Paths::Nway_Paths() +{ +} + +void +Nway_Paths::setup(int sp_num, int w, int t) +{ + species_num = sp_num; + threshold = t; + soft_thres = threshold; + win_size = w; + pathz.clear(); + + cout << "nway: species_num = " << species_num << ", thres = " << threshold + << ", softo = " << soft_thres << endl; +} + +void +Nway_Paths::set_soft_thres(int sft_thres) +{ + soft_thres = sft_thres; +} + + + + +// dumbly goes thru and combines path windows exactly adjacent (ie + 1 index) +// doesn't deal with interleaved adjacency +void +Nway_Paths::simple_refine() +{ + // ext_path remembers the first window set in an extending path + vector ext_path, cur_path, next_path, new_path; + list >::iterator pathz_i; + int i2, win_ext_len = 0; + bool extending, end = false; + int count_loop = 0; + + + refined_pathz.clear(); + + cout << "path number is: " << pathz.size() << endl; + pathz_i = pathz.begin(); + ext_path = *pathz_i; + + while(pathz_i != pathz.end()) + { + //cout << "path number is: " << pathz.size() << endl; + //++count_loop; + //cout << "glorpagh!!!!!" << count_loop << endl; + + // keep track of current path and advance to next path + cur_path = *pathz_i; + ++pathz_i; + if (pathz_i == pathz.end()) + end = true; + else + next_path = *pathz_i; + + //cout << "S\'Nork!\n"; + + if (not end) + { + // if node for each seq is equal to the next node+1 then for all + // sequences then we are extending + extending = true; + for(i2 = 0; i2 < species_num; i2++) + { + //cout << cur_path[i2] << " vs " << endl; + //cout << next_path[i2] << endl; + if (cur_path[i2] + 1 != next_path[i2]) + extending = false; + } + } + else + extending = false; + + if (extending) + { + //cout << "Raaaawwwrrr! I am extending\n"; + win_ext_len++; + } + else + { + //cout << "Larfnarg?\n"; + // add the extend window length as first element and add as refined + new_path = ext_path; + new_path.insert(new_path.begin(),win_size + win_ext_len); + for(i2 = 1; i2 <= species_num; i2++) + { + if (new_path[i2] < 0) + { + //cout << "before: " << new_path[i2]; + new_path[i2] += win_ext_len; + //cout << " after: " << new_path[i2] << endl; + } + } + refined_pathz.push_back(new_path); + // reset stuff + win_ext_len = 0; + ext_path = next_path; + } + } + cout << "r_path number is: " << refined_pathz.size() << endl; +} + + +void +Nway_Paths::add_path(vector loaded_path) +{ + pathz.push_back(loaded_path); +} + + +void +Nway_Paths::save(string save_file_path) +{ + fstream save_file; + list >::iterator path_i, paths_end; + vector a_path; + int i; + + save_file.open(save_file_path.c_str(), ios::out); + + save_file << "\n"; + + path_i = refined_pathz.begin(); + paths_end = refined_pathz.end(); + //path_i = pathz.begin(); + //paths_end = pathz.end(); + while (path_i != paths_end) + { + a_path = *path_i; + //cout << a_path.size() << endl; + //first entry is the window length of the windows in the path + save_file << a_path[0] << ":"; + for(i = 1; i <= species_num; ++i) + { + save_file << a_path[i]; + if (i != species_num) + save_file << ","; + } + save_file << endl; + ++path_i; + } + + save_file << "\n"; + save_file.close(); +} + +/* + if (path_i == paths_end) + cout << "Arrrrrrgggghhhhhh\n"; +*/ + +int +Nway_Paths::seq_num() +{ + return species_num; +} + + +string +Nway_Paths::load(string load_file_path) +{ + fstream load_file; + string file_data_line, header_data, data, path_node, path_length; + int i, space_split_i, equal_split_i, comma_split_i, colon_split_i; + vector loaded_path; + string err_msg; + + + load_file.open(load_file_path.c_str(), ios::in); + + if (!load_file) + { + err_msg = "Sequence File: " + load_file_path + " not found"; + cout << "BAM!!!!\n"; + return err_msg; + } + + else + { + // get header data + // grab mussa tag - discard for now...maybe check in future... + getline(load_file,file_data_line); + space_split_i = file_data_line.find(" "); + file_data_line = file_data_line.substr(space_split_i+1); + // grab type tag - need in future to distinguish between flp and vlp paths + space_split_i = file_data_line.find(" "); + file_data_line = file_data_line.substr(space_split_i+1); + // get species/seq number + space_split_i = file_data_line.find(" "); + header_data = file_data_line.substr(0,space_split_i); + equal_split_i = header_data.find("="); + data = file_data_line.substr(equal_split_i+1); + species_num = atoi (data.c_str()); + file_data_line = file_data_line.substr(space_split_i+1); + // get window size + space_split_i = file_data_line.find(" "); + header_data = file_data_line.substr(0,space_split_i); + equal_split_i = header_data.find("="); + data = file_data_line.substr(equal_split_i+1); + win_size = atoi (data.c_str()); + file_data_line = file_data_line.substr(space_split_i+1); + // get window size + space_split_i = file_data_line.find(" "); + header_data = file_data_line.substr(0,space_split_i); + equal_split_i = header_data.find("="); + data = file_data_line.substr(equal_split_i+1); + threshold = atoi (data.c_str()); + file_data_line = file_data_line.substr(space_split_i+1); + + cout << "seq_num=" << species_num << " win=" << win_size; + cout << " thres=" << threshold << endl; + + // clear out the current data + refined_pathz.clear(); + + int temp; + + getline(load_file,file_data_line); + while ( (!load_file.eof()) && (file_data_line != "") ) + { + if (file_data_line != "") + { + loaded_path.clear(); + colon_split_i = file_data_line.find(":"); + path_length = file_data_line.substr(0,colon_split_i); + loaded_path.push_back(atoi (path_length.c_str())); + file_data_line = file_data_line.substr(colon_split_i+1); + for(i = 0; i < species_num; i++) + { + comma_split_i = file_data_line.find(","); + path_node = file_data_line.substr(0, comma_split_i); + temp = atoi (path_node.c_str()); + loaded_path.push_back(temp); + file_data_line = file_data_line.substr(comma_split_i+1); + } + refined_pathz.push_back(loaded_path); + } + getline(load_file,file_data_line); + } + + + load_file.close(); + + return ""; + } +} + + + + +void +Nway_Paths::path_search(vector > all_comparisons, vector path, int depth) +{ + list new_nodes, trans_check_nodes; + list::iterator new_nodes_i, new_nodes_end; + int i; + bool trans_check_good; + + new_nodes = all_comparisons[depth - 1][depth].matches(path[depth-1]); + new_nodes_i = new_nodes.begin(); + new_nodes_end = new_nodes.end(); + while(new_nodes_i != new_nodes_end) + { + //cout << " * species " << depth << " node: " << *new_nodes_i << endl; + // check transitivity with previous nodes in path + trans_check_good = true; + for(i = 0; i < depth - 1; i++) + { + trans_check_nodes = all_comparisons[i][depth].matches(path[i]); + if ( (trans_check_nodes.end() == find(trans_check_nodes.begin(), + trans_check_nodes.end(), + *new_nodes_i) ) && + (trans_check_nodes.end() == find(trans_check_nodes.begin(), + trans_check_nodes.end(), + *new_nodes_i * -1) ) ) + trans_check_good = false; + } + + if (trans_check_good) + { + // this makes sure path nodes are recorded with RC status relative to + // the base species + if ( path[depth-1] >= 0) + path.push_back(*new_nodes_i); + else + path.push_back(*new_nodes_i * -1); + + if (depth < species_num - 1) + path_search(all_comparisons, path, depth + 1); + else + pathz.push_back(path); + path.pop_back(); + } + ++new_nodes_i; + } +} +// cout << " ****I have the power...\n"; + +/* use this if I ever get the friggin seqcomp match lists to sort... + if (binary_search(trans_check_nodes.begin(), trans_check_nodes.end(), + *new_nodes_i)) +*/ + +void +Nway_Paths::find_paths_r(vector > all_comparisons) +{ + vector path; + int win_i, window_num; + list new_nodes; + list::iterator new_nodes_i, new_nodes_end; + + pathz.clear(); + window_num = all_comparisons[0][1].win_num(); + cout << window_num << endl; + // loop thru all windows in first species + for (win_i = 0; win_i < window_num; win_i++) + { + path.clear(); + path.push_back(win_i); + new_nodes = all_comparisons[0][1].matches(path[0]); + new_nodes_i = new_nodes.begin(); + new_nodes_end = new_nodes.end(); + //if (new_nodes_i != new_nodes_end) + //cout << "* species 0 node: " << win_i << endl; + // cout << "foookin hell\n"; + path.push_back(0); + while(new_nodes_i != new_nodes_end) + { + //cout << " * species 1 node: " << *new_nodes_i << endl; + path[1] = *new_nodes_i; + path_search(all_comparisons, path, 2); + ++new_nodes_i; + } + } +} + + +void +Nway_Paths::save_old(string save_file_path) +{ + fstream save_file; + list >::iterator path_i, paths_end; + vector a_path; + int i; + + save_file.open(save_file_path.c_str(), ios::app); + + path_i = pathz.begin(); + paths_end = pathz.end(); + while(path_i != paths_end) + { + a_path = *path_i; + //cout << a_path.size() << endl; + for(i = 0; i < species_num; ++i) + save_file << i << "," << a_path[i] << " "; + save_file << endl; + ++path_i; + } + save_file.close(); +} + + +/* +void +Nway_Paths::find_paths(vector > all_comparisons) +{ + int win_i, sp_i; + vector > > path_src_tree; + list new_nodes; + list::iterator node_i, node_end; + > >::iterator branch_i, branch_end; + + pathz.clear(); + path_src_tree.reserve(species_num - 1); + + + // loop thru all windows in first species + for (win_i = 0; win_i < window_num; win_i++) + { + // clear the path search tree + for(i = 0; i < species_num; i++) + path_src_tree[i].clear(); + + // top level kept empty even tho implicity has one entry of the first + // species at this window - why bother, adds a little speed + + // get connection list for first species, creating a list of nodes + // of second species connected to the first species at this window + new_nodes = all_comparisons[0][1]; + path_src_tree[1].push_back(new_nodes); + + // loop thru rest of species for this window to see if any paths of matches + // go across all species + // if path search tree becomes empty, break out of loop, no reason to search further + sp_i = 1; + while ((sp_i < species_num) && (path tree not empty)) + { + branch_i = path_src_tree[1].begin(); + branch_end = path_src_tree[1].end(); + while (branch_i != branch_end) + { + node_i = branch_i->begin(); + node_end = branch_i->end(); + } + + + // loop over all current nodes + // get connection list for each node + // loop over each previous node in list + // get those nodes connection list + // intersect previous node connections with current + + ++sp_i; + } + + // insert any of the paths found into the master list of paths + + // add no paths if tmp_pathz is empty... + } +} + +void Nway_Paths::refine() +{ +} + +void Nway_Paths::print() +{ + list >::iterator pathz_i; + + cout << "printing list of lists\n"; + for (pathz_i = pathz.begin(); pathz_i != pathz.end(); ++pathz_i) + { + for (path_i = pathz_i->begin(); path_i != pathz_i->end(); ++path_i) + cout << *path_i << " "; + cout << endl; + } +} +*/ + + + + diff --git a/mussa_nway.hh b/mussa_nway.hh index 645a069..32209c4 100644 --- a/mussa_nway.hh +++ b/mussa_nway.hh @@ -20,7 +20,6 @@ #include "flp.hh" - class Nway_Paths { friend class ConnView; @@ -37,8 +36,6 @@ class Nway_Paths std::list > pathz; std::list > refined_pathz; - - public: Nway_Paths(); void setup(int sp_num, int w, int t); diff --git a/mussa_nway_entropy.cc b/mussa_nway_entropy.cc deleted file mode 100644 index 013c312..0000000 --- a/mussa_nway_entropy.cc +++ /dev/null @@ -1,263 +0,0 @@ -// This file is part of the Mussa source distribution. -// http://mussa.caltech.edu/ -// Contact author: Tristan De Buysscher, tristan@caltech.edu - -// This program and all associated source code files are Copyright (C) 2005 -// the California Institute of Technology, Pasadena, CA, 91125 USA. It is -// under the GNU Public License; please see the included LICENSE.txt -// file for more information, or contact Tristan directly. - - - -#include "mussa_nway.hh" -#include -#include -using namespace std; - -// vars that will be availble to entropy function when in its nway class -//vector c_sequences; -//int window = 5, seq_num; - - -void -Nway_Paths::setup_ent(double new_entropy_thres, vector some_Seqs) -{ - int i; - - ent_thres = new_entropy_thres; - - c_sequences.clear(); - for (i = 0; i < species_num; i++) - c_sequences.push_back((char *)some_Seqs[i].c_str()); -} - - -double -Nway_Paths::path_entropy(vector path) -{ - int bp_occurences[5]; - double bp_prob, frac_ent, avg_entropy; - vector entropies; - int i, seq_i, i2; - int window = win_size; - int seq_num = species_num; - - - for(i = 0; i < window; i++) // loop thru all bp positions - { - for(i2 = 0; i2 < 5; i2++) // clear old occurences - bp_occurences[i2] = 0; - - for(seq_i = 0; seq_i < seq_num; seq_i++) //loop thru all sequences at pos i - if (path[seq_i] > -1) - switch (c_sequences[seq_i][i+path[seq_i]]) - { - case 'A': - ++bp_occurences[0]; - break; - case 'T': - ++bp_occurences[1]; - break; - case 'G': - ++bp_occurences[2]; - break; - case 'C': - ++bp_occurences[3]; - break; - case 'N': - ++bp_occurences[4]; - break; - default: - cout << "error, nonAGCTN on seq: " << seq_i << " at index: "; - cout << i+path[seq_i] << endl; - } - else - switch (c_sequences[seq_i][-1 * (i + path[seq_i] - window + 1) ]) - { - case 'A': - ++bp_occurences[1]; - break; - case 'T': - ++bp_occurences[0]; - break; - case 'G': - ++bp_occurences[3]; - break; - case 'C': - ++bp_occurences[2]; - break; - case 'N': - ++bp_occurences[4]; - break; - default: - cout << "error, nonAGCTN on seq: " << seq_i << " at index: "; - cout << (i + path[seq_i] - window + 1) << endl; - } - - - entropies.push_back(0.000); - for(i2 = 0; i2 < 5; i2++) //calculate entropies - { - bp_prob = (double) bp_occurences[i2] / (double) seq_num; - //cout << bp_prob << "::"; - if (bp_prob == 0.0000) - frac_ent = 0.0000; - else - frac_ent = bp_prob * ( log10(bp_prob) / log10(2.0) ); - //cout << frac_ent << " "; - entropies[i] += frac_ent; - } - //cout << endl; - } - - avg_entropy = 0; - for(i = 0; i < window; i++) - { - avg_entropy += entropies[i]; - //cout << entropies[i] << endl; - } - - avg_entropy = -1.00 * (avg_entropy / (double) window); - //cout << "average entropy: " << avg_entropy << endl; - return avg_entropy; -} - - - - - -void -Nway_Paths::entropy_path_search(vector > all_comparisons) -{ - vector path; - double avg_entropy; - int win_i, sp_i, sp_depth, window_num, i, cur_node; - bool some_matches, still_paths, not_advanced, trans_good; - list new_nodes, trans_check_nodes; - vector > all_matches; - vector::iterator> sp_nodes, sp_nodes_end; - list::iterator debug_i; - - - pathz.clear(); - window_num = all_comparisons[0][1].win_num(); - cout << window_num << endl; // just a sanity check - - sp_nodes.reserve(species_num); - sp_nodes_end.reserve(species_num); - - // loop thru all windows in first species - for (win_i = 0; win_i < window_num; win_i++) - { - // first we see if the first seq has matches to all other seqs at this win - some_matches = true; - sp_i = 1; - all_matches.clear(); - while ( (sp_i < species_num) && (some_matches) ) - { - new_nodes.clear(); - new_nodes = all_comparisons[0][sp_i].matches(win_i); - if (new_nodes.empty()) - some_matches = false; - - all_matches.push_back(new_nodes); - sp_i++; - } - //cout << "fee\n"; - - // if 1st seq does match to all others, make all possible paths - // out of all these matches - if (some_matches) - { - sp_nodes.clear(); - sp_nodes_end.clear(); - // set each species list of matches to beginning - for (sp_i = 0; sp_i < species_num-1; sp_i++) - { - sp_nodes.push_back(all_matches[sp_i].begin()); - sp_nodes_end.push_back(all_matches[sp_i].end()); - } - - still_paths = true; - //cout << "fie\n"; - while (still_paths) - { - // add path that each species iterator is pointing to - path.clear(); - path.push_back(win_i); - - //cout << win_i; - for (sp_i = 0; sp_i < species_num-1; sp_i++) - { - //cout << ", " << *(sp_nodes[sp_i]); - path.push_back(*(sp_nodes[sp_i])); - } - //cout << endl; - - // check entropy <--------------------------------------------------- - avg_entropy = path_entropy(path); - if (avg_entropy <= ent_thres) - pathz.push_back(path); - - // now advance the right iterator - not_advanced = true; - sp_depth = species_num - 2; // this roves up & down species list - while ( (not_advanced) && (sp_depth != -1) ) - { - //cout << "foe\n"; - //cout << sp_depth << ".." << *(sp_nodes[sp_depth]) << endl; - (sp_nodes[sp_depth])++; // advance iter at current depth - //cout << sp_depth << ".." << *(sp_nodes[sp_depth]) << endl; - - // if we reached the end of the list, reset iter & go up one depth - if (sp_nodes[sp_depth] == sp_nodes_end[sp_depth]) - { - //cout << "fum\n"; - sp_nodes[sp_depth] = all_matches[sp_depth].begin(); - sp_depth--; - //cout << "depth = " << sp_depth << endl; - } - else - not_advanced = false; - } - - if (sp_depth == -1) // jumped up to first species, all paths searched - still_paths = false; - else // otherwise just reset to max depth and continue - sp_depth = species_num - 2; - } - } - } -} - - -//initial coding testing -/* -int main(int argc, char **argv) -{ - vector sequences; - vector i_starts; - double avg_entropy; - int seq_i; - - sequences.clear(); - sequences.push_back("AAAAA"); - sequences.push_back("AAAAT"); - sequences.push_back("AATTG"); - sequences.push_back("ATTGC"); - - seq_num = 4; - - c_sequences.clear(); - i_starts.clear(); - for(seq_i = 0; seq_i < seq_num; seq_i++) //loop thru all sequences at pos i - { - c_sequences.push_back((char *)sequences[seq_i].c_str()); - i_starts.push_back(0); - } - - avg_entropy = Window_Entropy(i_starts); - - cout << "average entropy: " << avg_entropy << endl; -} -*/ diff --git a/mussa_nway_entropy.cxx b/mussa_nway_entropy.cxx new file mode 100644 index 0000000..013c312 --- /dev/null +++ b/mussa_nway_entropy.cxx @@ -0,0 +1,263 @@ +// This file is part of the Mussa source distribution. +// http://mussa.caltech.edu/ +// Contact author: Tristan De Buysscher, tristan@caltech.edu + +// This program and all associated source code files are Copyright (C) 2005 +// the California Institute of Technology, Pasadena, CA, 91125 USA. It is +// under the GNU Public License; please see the included LICENSE.txt +// file for more information, or contact Tristan directly. + + + +#include "mussa_nway.hh" +#include +#include +using namespace std; + +// vars that will be availble to entropy function when in its nway class +//vector c_sequences; +//int window = 5, seq_num; + + +void +Nway_Paths::setup_ent(double new_entropy_thres, vector some_Seqs) +{ + int i; + + ent_thres = new_entropy_thres; + + c_sequences.clear(); + for (i = 0; i < species_num; i++) + c_sequences.push_back((char *)some_Seqs[i].c_str()); +} + + +double +Nway_Paths::path_entropy(vector path) +{ + int bp_occurences[5]; + double bp_prob, frac_ent, avg_entropy; + vector entropies; + int i, seq_i, i2; + int window = win_size; + int seq_num = species_num; + + + for(i = 0; i < window; i++) // loop thru all bp positions + { + for(i2 = 0; i2 < 5; i2++) // clear old occurences + bp_occurences[i2] = 0; + + for(seq_i = 0; seq_i < seq_num; seq_i++) //loop thru all sequences at pos i + if (path[seq_i] > -1) + switch (c_sequences[seq_i][i+path[seq_i]]) + { + case 'A': + ++bp_occurences[0]; + break; + case 'T': + ++bp_occurences[1]; + break; + case 'G': + ++bp_occurences[2]; + break; + case 'C': + ++bp_occurences[3]; + break; + case 'N': + ++bp_occurences[4]; + break; + default: + cout << "error, nonAGCTN on seq: " << seq_i << " at index: "; + cout << i+path[seq_i] << endl; + } + else + switch (c_sequences[seq_i][-1 * (i + path[seq_i] - window + 1) ]) + { + case 'A': + ++bp_occurences[1]; + break; + case 'T': + ++bp_occurences[0]; + break; + case 'G': + ++bp_occurences[3]; + break; + case 'C': + ++bp_occurences[2]; + break; + case 'N': + ++bp_occurences[4]; + break; + default: + cout << "error, nonAGCTN on seq: " << seq_i << " at index: "; + cout << (i + path[seq_i] - window + 1) << endl; + } + + + entropies.push_back(0.000); + for(i2 = 0; i2 < 5; i2++) //calculate entropies + { + bp_prob = (double) bp_occurences[i2] / (double) seq_num; + //cout << bp_prob << "::"; + if (bp_prob == 0.0000) + frac_ent = 0.0000; + else + frac_ent = bp_prob * ( log10(bp_prob) / log10(2.0) ); + //cout << frac_ent << " "; + entropies[i] += frac_ent; + } + //cout << endl; + } + + avg_entropy = 0; + for(i = 0; i < window; i++) + { + avg_entropy += entropies[i]; + //cout << entropies[i] << endl; + } + + avg_entropy = -1.00 * (avg_entropy / (double) window); + //cout << "average entropy: " << avg_entropy << endl; + return avg_entropy; +} + + + + + +void +Nway_Paths::entropy_path_search(vector > all_comparisons) +{ + vector path; + double avg_entropy; + int win_i, sp_i, sp_depth, window_num, i, cur_node; + bool some_matches, still_paths, not_advanced, trans_good; + list new_nodes, trans_check_nodes; + vector > all_matches; + vector::iterator> sp_nodes, sp_nodes_end; + list::iterator debug_i; + + + pathz.clear(); + window_num = all_comparisons[0][1].win_num(); + cout << window_num << endl; // just a sanity check + + sp_nodes.reserve(species_num); + sp_nodes_end.reserve(species_num); + + // loop thru all windows in first species + for (win_i = 0; win_i < window_num; win_i++) + { + // first we see if the first seq has matches to all other seqs at this win + some_matches = true; + sp_i = 1; + all_matches.clear(); + while ( (sp_i < species_num) && (some_matches) ) + { + new_nodes.clear(); + new_nodes = all_comparisons[0][sp_i].matches(win_i); + if (new_nodes.empty()) + some_matches = false; + + all_matches.push_back(new_nodes); + sp_i++; + } + //cout << "fee\n"; + + // if 1st seq does match to all others, make all possible paths + // out of all these matches + if (some_matches) + { + sp_nodes.clear(); + sp_nodes_end.clear(); + // set each species list of matches to beginning + for (sp_i = 0; sp_i < species_num-1; sp_i++) + { + sp_nodes.push_back(all_matches[sp_i].begin()); + sp_nodes_end.push_back(all_matches[sp_i].end()); + } + + still_paths = true; + //cout << "fie\n"; + while (still_paths) + { + // add path that each species iterator is pointing to + path.clear(); + path.push_back(win_i); + + //cout << win_i; + for (sp_i = 0; sp_i < species_num-1; sp_i++) + { + //cout << ", " << *(sp_nodes[sp_i]); + path.push_back(*(sp_nodes[sp_i])); + } + //cout << endl; + + // check entropy <--------------------------------------------------- + avg_entropy = path_entropy(path); + if (avg_entropy <= ent_thres) + pathz.push_back(path); + + // now advance the right iterator + not_advanced = true; + sp_depth = species_num - 2; // this roves up & down species list + while ( (not_advanced) && (sp_depth != -1) ) + { + //cout << "foe\n"; + //cout << sp_depth << ".." << *(sp_nodes[sp_depth]) << endl; + (sp_nodes[sp_depth])++; // advance iter at current depth + //cout << sp_depth << ".." << *(sp_nodes[sp_depth]) << endl; + + // if we reached the end of the list, reset iter & go up one depth + if (sp_nodes[sp_depth] == sp_nodes_end[sp_depth]) + { + //cout << "fum\n"; + sp_nodes[sp_depth] = all_matches[sp_depth].begin(); + sp_depth--; + //cout << "depth = " << sp_depth << endl; + } + else + not_advanced = false; + } + + if (sp_depth == -1) // jumped up to first species, all paths searched + still_paths = false; + else // otherwise just reset to max depth and continue + sp_depth = species_num - 2; + } + } + } +} + + +//initial coding testing +/* +int main(int argc, char **argv) +{ + vector sequences; + vector i_starts; + double avg_entropy; + int seq_i; + + sequences.clear(); + sequences.push_back("AAAAA"); + sequences.push_back("AAAAT"); + sequences.push_back("AATTG"); + sequences.push_back("ATTGC"); + + seq_num = 4; + + c_sequences.clear(); + i_starts.clear(); + for(seq_i = 0; seq_i < seq_num; seq_i++) //loop thru all sequences at pos i + { + c_sequences.push_back((char *)sequences[seq_i].c_str()); + i_starts.push_back(0); + } + + avg_entropy = Window_Entropy(i_starts); + + cout << "average entropy: " << avg_entropy << endl; +} +*/ diff --git a/mussa_nway_other.cc b/mussa_nway_other.cc deleted file mode 100644 index d0b5f2c..0000000 --- a/mussa_nway_other.cc +++ /dev/null @@ -1,374 +0,0 @@ -// This file is part of the Mussa source distribution. -// http://mussa.caltech.edu/ -// Contact author: Tristan De Buysscher, tristan@caltech.edu - -// This program and all associated source code files are Copyright (C) 2005 -// the California Institute of Technology, Pasadena, CA, 91125 USA. It is -// under the GNU Public License; please see the included LICENSE.txt -// file for more information, or contact Tristan directly. - - -#include "mussa_nway.hh" -#include - -using namespace std; - -void -Nway_Paths::radiate_path_search(vector > all_comparisons) -{ - vector path; - int win_i, sp_i, sp_depth, window_num; - bool some_matches, still_paths, not_advanced; - list new_nodes; - vector > all_matches; - vector::iterator> sp_nodes, sp_nodes_end; - list::iterator debug_i; - - pathz.clear(); - window_num = all_comparisons[0][1].win_num(); - cout << window_num << endl; // just a sanity check - - sp_nodes.reserve(species_num); - sp_nodes_end.reserve(species_num); - - // loop thru all windows in first species - for (win_i = 0; win_i < window_num; win_i++) - { - // first we see if the first seq has matches to all other seqs at this win - some_matches = true; - sp_i = 1; - all_matches.clear(); - while ( (sp_i < species_num) && (some_matches) ) - { - new_nodes.clear(); - new_nodes = all_comparisons[0][sp_i].matches(win_i); - if (new_nodes.empty()) - some_matches = false; - - all_matches.push_back(new_nodes); - sp_i++; - } - //cout << "fee\n"; - /* - if (some_matches) - { - cout << win_i << " plrf" << endl; - for (sp_i = 0; sp_i < species_num-1; sp_i++) - { - debug_i = all_matches[sp_i].begin(); - while (debug_i != all_matches[sp_i].end()) - { - cout << *debug_i << " "; - debug_i++; - } - cout << "plrfff"<< endl; - } - } - */ - // if 1st seq does match to all others, make all possible paths - // out of all these matches - if (some_matches) - { - sp_nodes.clear(); - sp_nodes_end.clear(); - // set each species list of matches to beginning - for (sp_i = 0; sp_i < species_num-1; sp_i++) - { - sp_nodes.push_back(all_matches[sp_i].begin()); - sp_nodes_end.push_back(all_matches[sp_i].end()); - } - - still_paths = true; - sp_depth = species_num - 2; // this roves up & down species list - //cout << "fie\n"; - while (still_paths) - { - // add path that each species iterator is pointing to - path.clear(); - path.push_back(win_i); - - //cout << win_i; - for (sp_i = 0; sp_i < species_num-1; sp_i++) - { - //cout << ", " << *(sp_nodes[sp_i]); - path.push_back(*(sp_nodes[sp_i])); - } - //cout << endl; - - pathz.push_back(path); - - // now advance the right iterator - not_advanced = true; - while ( (not_advanced) && (sp_depth != -1) ) - { - //cout << "foe\n"; - //cout << sp_depth << ".." << *(sp_nodes[sp_depth]) << endl; - (sp_nodes[sp_depth])++; // advance iter at current depth - //cout << sp_depth << ".." << *(sp_nodes[sp_depth]) << endl; - - // if we reached the end of the list, reset iter & go up one depth - if (sp_nodes[sp_depth] == sp_nodes_end[sp_depth]) - { - //cout << "fum\n"; - sp_nodes[sp_depth] = all_matches[sp_depth].begin(); - sp_depth--; - //cout << "depth = " << sp_depth << endl; - } - else - not_advanced = false; - } - - if (sp_depth == -1) // jumped up to first species, all paths searched - still_paths = false; - else // otherwise just reset to max depth and continue - sp_depth = species_num - 2; - } - } - } -} - - - - -void -Nway_Paths::trans_path_search(vector > all_comparisons) -{ - vector path; - int win_i, sp_i, sp_depth, window_num, i, cur_node; - bool some_matches, still_paths, not_advanced, trans_good; - list new_nodes, trans_check_nodes; - vector > all_matches; - vector::iterator> sp_nodes, sp_nodes_end; - list::iterator debug_i; - - cout << "trans: softhres = " << soft_thres; - cout << ", window = " << win_size << ", "; - - pathz.clear(); - window_num = all_comparisons[0][1].win_num(); - cout << "window number = " << window_num << endl; // just a sanity check - cout << "trans: species_num = " << species_num << endl; - sp_nodes.reserve(species_num); - cout << "trans: fie\n"; - sp_nodes_end.reserve(species_num); - cout << "trans: foe\n"; - // loop thru all windows in first species - for (win_i = 0; win_i < window_num; win_i++) - { - // first we see if the first seq has matches to all other seqs at this win - some_matches = true; - sp_i = 1; - all_matches.clear(); - while ( (sp_i < species_num) && (some_matches) ) - { - new_nodes.clear(); - // --thres - //new_nodes = all_comparisons[0][sp_i].matches(win_i); - new_nodes = all_comparisons[0][sp_i].thres_matches(win_i, soft_thres); - if (new_nodes.empty()) - some_matches = false; - - all_matches.push_back(new_nodes); - sp_i++; - } - //cout << "fee\n"; - /* - if (some_matches) - { - cout << win_i << " plrf" << endl; - for (sp_i = 0; sp_i < species_num-1; sp_i++) - { - debug_i = all_matches[sp_i].begin(); - while (debug_i != all_matches[sp_i].end()) - { - cout << *debug_i << " "; - debug_i++; - } - cout << "plrfff"<< endl; - } - } - */ - // if 1st seq does match to all others, make all possible paths - // out of all these matches - if (some_matches) - { - sp_nodes.clear(); - sp_nodes_end.clear(); - // set each species list of matches to beginning - for (sp_i = 0; sp_i < species_num-1; sp_i++) - { - sp_nodes.push_back(all_matches[sp_i].begin()); - sp_nodes_end.push_back(all_matches[sp_i].end()); - } - - still_paths = true; - //cout << "fie\n"; - while (still_paths) - { - // add path that each species iterator is pointing to - path.clear(); - path.push_back(win_i); - - //cout << win_i; - for (sp_i = 0; sp_i < species_num-1; sp_i++) - { - //cout << ", " << *(sp_nodes[sp_i]); - path.push_back(*(sp_nodes[sp_i])); - } - //cout << endl; - - // check transitivity - sp_depth = 1; - trans_good = true; - while ( (sp_depth != species_num-1) && (trans_good) ) - { - cur_node = path[sp_depth]; - for(i = sp_depth+1; i < species_num; i++) - { - // --thres - //trans_check_nodes = all_comparisons[sp_depth][i].matches(cur_node); - trans_check_nodes = - all_comparisons[sp_depth][i].thres_matches(cur_node, soft_thres); - - if ( (trans_check_nodes.end() == find(trans_check_nodes.begin(), - trans_check_nodes.end(), - path[i]) ) && - (trans_check_nodes.end() == find(trans_check_nodes.begin(), - trans_check_nodes.end(), - path[i] * -1) ) ) - trans_good = false; - } - - sp_depth++; - } - - if (trans_good) - pathz.push_back(path); - - // now advance the right iterator - not_advanced = true; - sp_depth = species_num - 2; // this roves up & down species list - while ( (not_advanced) && (sp_depth != -1) ) - { - //cout << "foe\n"; - //cout << sp_depth << ".." << *(sp_nodes[sp_depth]) << endl; - (sp_nodes[sp_depth])++; // advance iter at current depth - //cout << sp_depth << ".." << *(sp_nodes[sp_depth]) << endl; - - // if we reached the end of the list, reset iter & go up one depth - if (sp_nodes[sp_depth] == sp_nodes_end[sp_depth]) - { - //cout << "fum\n"; - sp_nodes[sp_depth] = all_matches[sp_depth].begin(); - sp_depth--; - //cout << "depth = " << sp_depth << endl; - } - else - not_advanced = false; - } - - if (sp_depth == -1) // jumped up to first species, all paths searched - still_paths = false; - else // otherwise just reset to max depth and continue - sp_depth = species_num - 2; - } - } - } -} - - - - -/* - // loop thru all windows in first species - for (win_i = 0; win_i < window_num; win_i++) - { - path.clear(); - path.push_back(win_i); - cur_nodes = all_comparisons[0][1].matches(path[0]); - cur_nodes_i = cur_nodes.begin(); - cur_nodes_end = cur_nodes.end(); - path.push_back(0); - for (sp_i = 2; sp_i < species_num; sp_i++) - { - new_nodes = all_comparisons[0][sp_i].matches(path[0]); - new_nodes_i = new_nodes.begin(); - new_nodes_end = new_nodes.end(); - - while(cur_nodes_i != cur_nodes_end) - { - intersect_bad = false; - if ( (new_nodes.end() == find(new_nodes.begin(), new_nodes.end(), - *cur_nodes_i) ) && - (new_nodes.end() == find(new_nodes.begin(), new_nodes.end(), - *cur_nodes_i * -1) ) ) - intersect_bad = true; - - // if no matches to this sequence, we don't need to check this node - // against any of the remaining ones - if (intersect_bad) - cur_nodes_i = cur_nodes.erase(cur_nodes_i); // this advances the iter - else - ++cur_nodes_i; // just advance normally - - } - } - - } -*/ - - -/* - while(new_nodes_i != new_nodes_end) - - - path[1] = *new_nodes_i; - path_search(all_comparisons, path, 2); - -*/ - //if (new_nodes_i != new_nodes_end) - //cout << "* species 0 node: " << win_i << endl; - // cout << "foookin hell\n"; - - //cout << " * species 1 node: " << *new_nodes_i << endl; - - //cout << " * species " << depth << " node: " << *new_nodes_i << endl; - // check transitivity with previous nodes in path - -/* -void -Nway_Paths::path_search(vector > all_comparisons, vector path, int depth) -{ - list new_nodes, trans_check_nodes; - list::iterator new_nodes_i, new_nodes_end; - int i; - - new_nodes = all_comparisons[depth - 1][depth].matches(path[depth-1]); - new_nodes_i = new_nodes.begin(); - new_nodes_end = new_nodes.end(); - - if (trans_check_good) - { - // this makes sure path nodes are recorded with RC status relative to - // the base species - if ( path[depth-1] >= 0) - path.push_back(*new_nodes_i); - else - path.push_back(*new_nodes_i * -1); - - if (depth < species_num - 1) - path_search(all_comparisons, path, depth + 1); - else - pathz.push_back(path); - path.pop_back(); - } - ++new_nodes_i; - } -} -*/ -// cout << " ****I have the power...\n"; - -/* use this if I ever get the friggin seqcomp match lists to sort... - if (binary_search(trans_check_nodes.begin(), trans_check_nodes.end(), - *new_nodes_i)) -*/ diff --git a/mussa_nway_other.cxx b/mussa_nway_other.cxx new file mode 100644 index 0000000..d0b5f2c --- /dev/null +++ b/mussa_nway_other.cxx @@ -0,0 +1,374 @@ +// This file is part of the Mussa source distribution. +// http://mussa.caltech.edu/ +// Contact author: Tristan De Buysscher, tristan@caltech.edu + +// This program and all associated source code files are Copyright (C) 2005 +// the California Institute of Technology, Pasadena, CA, 91125 USA. It is +// under the GNU Public License; please see the included LICENSE.txt +// file for more information, or contact Tristan directly. + + +#include "mussa_nway.hh" +#include + +using namespace std; + +void +Nway_Paths::radiate_path_search(vector > all_comparisons) +{ + vector path; + int win_i, sp_i, sp_depth, window_num; + bool some_matches, still_paths, not_advanced; + list new_nodes; + vector > all_matches; + vector::iterator> sp_nodes, sp_nodes_end; + list::iterator debug_i; + + pathz.clear(); + window_num = all_comparisons[0][1].win_num(); + cout << window_num << endl; // just a sanity check + + sp_nodes.reserve(species_num); + sp_nodes_end.reserve(species_num); + + // loop thru all windows in first species + for (win_i = 0; win_i < window_num; win_i++) + { + // first we see if the first seq has matches to all other seqs at this win + some_matches = true; + sp_i = 1; + all_matches.clear(); + while ( (sp_i < species_num) && (some_matches) ) + { + new_nodes.clear(); + new_nodes = all_comparisons[0][sp_i].matches(win_i); + if (new_nodes.empty()) + some_matches = false; + + all_matches.push_back(new_nodes); + sp_i++; + } + //cout << "fee\n"; + /* + if (some_matches) + { + cout << win_i << " plrf" << endl; + for (sp_i = 0; sp_i < species_num-1; sp_i++) + { + debug_i = all_matches[sp_i].begin(); + while (debug_i != all_matches[sp_i].end()) + { + cout << *debug_i << " "; + debug_i++; + } + cout << "plrfff"<< endl; + } + } + */ + // if 1st seq does match to all others, make all possible paths + // out of all these matches + if (some_matches) + { + sp_nodes.clear(); + sp_nodes_end.clear(); + // set each species list of matches to beginning + for (sp_i = 0; sp_i < species_num-1; sp_i++) + { + sp_nodes.push_back(all_matches[sp_i].begin()); + sp_nodes_end.push_back(all_matches[sp_i].end()); + } + + still_paths = true; + sp_depth = species_num - 2; // this roves up & down species list + //cout << "fie\n"; + while (still_paths) + { + // add path that each species iterator is pointing to + path.clear(); + path.push_back(win_i); + + //cout << win_i; + for (sp_i = 0; sp_i < species_num-1; sp_i++) + { + //cout << ", " << *(sp_nodes[sp_i]); + path.push_back(*(sp_nodes[sp_i])); + } + //cout << endl; + + pathz.push_back(path); + + // now advance the right iterator + not_advanced = true; + while ( (not_advanced) && (sp_depth != -1) ) + { + //cout << "foe\n"; + //cout << sp_depth << ".." << *(sp_nodes[sp_depth]) << endl; + (sp_nodes[sp_depth])++; // advance iter at current depth + //cout << sp_depth << ".." << *(sp_nodes[sp_depth]) << endl; + + // if we reached the end of the list, reset iter & go up one depth + if (sp_nodes[sp_depth] == sp_nodes_end[sp_depth]) + { + //cout << "fum\n"; + sp_nodes[sp_depth] = all_matches[sp_depth].begin(); + sp_depth--; + //cout << "depth = " << sp_depth << endl; + } + else + not_advanced = false; + } + + if (sp_depth == -1) // jumped up to first species, all paths searched + still_paths = false; + else // otherwise just reset to max depth and continue + sp_depth = species_num - 2; + } + } + } +} + + + + +void +Nway_Paths::trans_path_search(vector > all_comparisons) +{ + vector path; + int win_i, sp_i, sp_depth, window_num, i, cur_node; + bool some_matches, still_paths, not_advanced, trans_good; + list new_nodes, trans_check_nodes; + vector > all_matches; + vector::iterator> sp_nodes, sp_nodes_end; + list::iterator debug_i; + + cout << "trans: softhres = " << soft_thres; + cout << ", window = " << win_size << ", "; + + pathz.clear(); + window_num = all_comparisons[0][1].win_num(); + cout << "window number = " << window_num << endl; // just a sanity check + cout << "trans: species_num = " << species_num << endl; + sp_nodes.reserve(species_num); + cout << "trans: fie\n"; + sp_nodes_end.reserve(species_num); + cout << "trans: foe\n"; + // loop thru all windows in first species + for (win_i = 0; win_i < window_num; win_i++) + { + // first we see if the first seq has matches to all other seqs at this win + some_matches = true; + sp_i = 1; + all_matches.clear(); + while ( (sp_i < species_num) && (some_matches) ) + { + new_nodes.clear(); + // --thres + //new_nodes = all_comparisons[0][sp_i].matches(win_i); + new_nodes = all_comparisons[0][sp_i].thres_matches(win_i, soft_thres); + if (new_nodes.empty()) + some_matches = false; + + all_matches.push_back(new_nodes); + sp_i++; + } + //cout << "fee\n"; + /* + if (some_matches) + { + cout << win_i << " plrf" << endl; + for (sp_i = 0; sp_i < species_num-1; sp_i++) + { + debug_i = all_matches[sp_i].begin(); + while (debug_i != all_matches[sp_i].end()) + { + cout << *debug_i << " "; + debug_i++; + } + cout << "plrfff"<< endl; + } + } + */ + // if 1st seq does match to all others, make all possible paths + // out of all these matches + if (some_matches) + { + sp_nodes.clear(); + sp_nodes_end.clear(); + // set each species list of matches to beginning + for (sp_i = 0; sp_i < species_num-1; sp_i++) + { + sp_nodes.push_back(all_matches[sp_i].begin()); + sp_nodes_end.push_back(all_matches[sp_i].end()); + } + + still_paths = true; + //cout << "fie\n"; + while (still_paths) + { + // add path that each species iterator is pointing to + path.clear(); + path.push_back(win_i); + + //cout << win_i; + for (sp_i = 0; sp_i < species_num-1; sp_i++) + { + //cout << ", " << *(sp_nodes[sp_i]); + path.push_back(*(sp_nodes[sp_i])); + } + //cout << endl; + + // check transitivity + sp_depth = 1; + trans_good = true; + while ( (sp_depth != species_num-1) && (trans_good) ) + { + cur_node = path[sp_depth]; + for(i = sp_depth+1; i < species_num; i++) + { + // --thres + //trans_check_nodes = all_comparisons[sp_depth][i].matches(cur_node); + trans_check_nodes = + all_comparisons[sp_depth][i].thres_matches(cur_node, soft_thres); + + if ( (trans_check_nodes.end() == find(trans_check_nodes.begin(), + trans_check_nodes.end(), + path[i]) ) && + (trans_check_nodes.end() == find(trans_check_nodes.begin(), + trans_check_nodes.end(), + path[i] * -1) ) ) + trans_good = false; + } + + sp_depth++; + } + + if (trans_good) + pathz.push_back(path); + + // now advance the right iterator + not_advanced = true; + sp_depth = species_num - 2; // this roves up & down species list + while ( (not_advanced) && (sp_depth != -1) ) + { + //cout << "foe\n"; + //cout << sp_depth << ".." << *(sp_nodes[sp_depth]) << endl; + (sp_nodes[sp_depth])++; // advance iter at current depth + //cout << sp_depth << ".." << *(sp_nodes[sp_depth]) << endl; + + // if we reached the end of the list, reset iter & go up one depth + if (sp_nodes[sp_depth] == sp_nodes_end[sp_depth]) + { + //cout << "fum\n"; + sp_nodes[sp_depth] = all_matches[sp_depth].begin(); + sp_depth--; + //cout << "depth = " << sp_depth << endl; + } + else + not_advanced = false; + } + + if (sp_depth == -1) // jumped up to first species, all paths searched + still_paths = false; + else // otherwise just reset to max depth and continue + sp_depth = species_num - 2; + } + } + } +} + + + + +/* + // loop thru all windows in first species + for (win_i = 0; win_i < window_num; win_i++) + { + path.clear(); + path.push_back(win_i); + cur_nodes = all_comparisons[0][1].matches(path[0]); + cur_nodes_i = cur_nodes.begin(); + cur_nodes_end = cur_nodes.end(); + path.push_back(0); + for (sp_i = 2; sp_i < species_num; sp_i++) + { + new_nodes = all_comparisons[0][sp_i].matches(path[0]); + new_nodes_i = new_nodes.begin(); + new_nodes_end = new_nodes.end(); + + while(cur_nodes_i != cur_nodes_end) + { + intersect_bad = false; + if ( (new_nodes.end() == find(new_nodes.begin(), new_nodes.end(), + *cur_nodes_i) ) && + (new_nodes.end() == find(new_nodes.begin(), new_nodes.end(), + *cur_nodes_i * -1) ) ) + intersect_bad = true; + + // if no matches to this sequence, we don't need to check this node + // against any of the remaining ones + if (intersect_bad) + cur_nodes_i = cur_nodes.erase(cur_nodes_i); // this advances the iter + else + ++cur_nodes_i; // just advance normally + + } + } + + } +*/ + + +/* + while(new_nodes_i != new_nodes_end) + + + path[1] = *new_nodes_i; + path_search(all_comparisons, path, 2); + +*/ + //if (new_nodes_i != new_nodes_end) + //cout << "* species 0 node: " << win_i << endl; + // cout << "foookin hell\n"; + + //cout << " * species 1 node: " << *new_nodes_i << endl; + + //cout << " * species " << depth << " node: " << *new_nodes_i << endl; + // check transitivity with previous nodes in path + +/* +void +Nway_Paths::path_search(vector > all_comparisons, vector path, int depth) +{ + list new_nodes, trans_check_nodes; + list::iterator new_nodes_i, new_nodes_end; + int i; + + new_nodes = all_comparisons[depth - 1][depth].matches(path[depth-1]); + new_nodes_i = new_nodes.begin(); + new_nodes_end = new_nodes.end(); + + if (trans_check_good) + { + // this makes sure path nodes are recorded with RC status relative to + // the base species + if ( path[depth-1] >= 0) + path.push_back(*new_nodes_i); + else + path.push_back(*new_nodes_i * -1); + + if (depth < species_num - 1) + path_search(all_comparisons, path, depth + 1); + else + pathz.push_back(path); + path.pop_back(); + } + ++new_nodes_i; + } +} +*/ +// cout << " ****I have the power...\n"; + +/* use this if I ever get the friggin seqcomp match lists to sort... + if (binary_search(trans_check_nodes.begin(), trans_check_nodes.end(), + *new_nodes_i)) +*/ diff --git a/mussa_nway_refine.cc b/mussa_nway_refine.cc deleted file mode 100644 index b5d665c..0000000 --- a/mussa_nway_refine.cc +++ /dev/null @@ -1,144 +0,0 @@ -// This file is part of the Mussa source distribution. -// http://mussa.caltech.edu/ -// Contact author: Tristan De Buysscher, tristan@caltech.edu - -// This program and all associated source code files are Copyright (C) 2005 -// the California Institute of Technology, Pasadena, CA, 91125 USA. It is -// under the GNU Public License; please see the included LICENSE.txt -// file for more information, or contact Tristan directly. - - -PathList -ExtendPathWindows(PathList raw_list) -{ - // to keep track of everything, this function acts like a finite state - // automata: 3 bitfields: reset, extending, scanning - ie 8 states - int reset = 0, extending = 0, scanning = 0; - - int species_num = raw_list.SpeciesNum(); - int win_num = raw_list.WinNum(); - - int *cur_path, *next_path; - - cur_path = new int[species_num]; - next_path = new int[species_num]; - - raw_list.ResetIndex(); - - while (no more windows avaible) - { - //cur_indices[0] + ref_ext == next_indices[0] + 1: - - // state 000 - start/nominal search - // - if !reset && !extending && !scanning - { - if cur_path[0] == next_path[0] - { - scanning = 1; // go to state 001 - raw_list.IncreIndex(); - } - else if cur_path[0] + 1 == next_path[0] - { - extending = 1; // go to state 010 - win_ext = 1; - raw_list.SetDirty(); - raw_list.IncreIndex(); - } - else - reset = 1; // go to state 100 - } - - // state 001 - scanning for ext window thru possible interleaving - // - else if !reset && !extending && scanning - { - if cur_path[0] == next_path[0] - raw_list.IncreIndex(); - else if cur_path[0] + 1 == next_path[0] - { - extending = 1; // go to state 011 - win_ext = 1; - raw_list.SetDirty(); - raw_list.IncreIndex(); - } - else - reset = 1; // go to state 101 - } - - // state 010 - extending window with no interleaving - // - else if !reset && extending && !scanning - { - if (cur_path[0] + win_ext) == next_path[0] - { - extending = 1; // go to state 011 - raw_list.IncreIndex(); - } - else if (cur_path[0] + win_ext + 1) == next_path[0] - { - win_ext++; - raw_list.SetDirty(); - raw_list.IncreIndex(); - } - else - reset = 1; // go to state 110 - } - - // state 011 - extending window with interleaving - // - else if !reset && extending && scanning - { - if (cur_path[0] + win_ext) == next_path[0] - raw_list.IncreIndex(); - else if (cur_path[0] + win_ext + 1) == next_path[0] - { - win_ext++; - raw_list.SetDirty(); - raw_list.IncreIndex(); - } - else - reset = 1; // go to state 111 - } - - - // reset condition states, return to 000 after taking appropiate action - - // state 100 - no extended window, no scanning happened - // save basic window to extended window list - if reset && !extending && !scanning - { - // return to start/nominal search state - reset = 0; - } - - // state 101 - no extended window, scanned for interleaving - // save basic window to extended window list, return to first clean - else if reset && !extending && scanning - { - // return to start/nominal search state - reset = 0; - scanning = 0; - } - - // state 110 - extended window, no interleaving - // calc extended window, save to extended window list - else if reset && extending && !scanning - { - // return to start/nominal search state - reset = 0; - extending = 0; - } - - // state 111 - extended window, interleaved - // calc extended window, save to ext win list, return to first clean - else if reset && extending && scanning - { - // return to start/nominal search state - reset = 0; - extending = 0; - scanning = 0; - } - - return ext_win; -} diff --git a/mussa_nway_refine.cxx b/mussa_nway_refine.cxx new file mode 100644 index 0000000..b5d665c --- /dev/null +++ b/mussa_nway_refine.cxx @@ -0,0 +1,144 @@ +// This file is part of the Mussa source distribution. +// http://mussa.caltech.edu/ +// Contact author: Tristan De Buysscher, tristan@caltech.edu + +// This program and all associated source code files are Copyright (C) 2005 +// the California Institute of Technology, Pasadena, CA, 91125 USA. It is +// under the GNU Public License; please see the included LICENSE.txt +// file for more information, or contact Tristan directly. + + +PathList +ExtendPathWindows(PathList raw_list) +{ + // to keep track of everything, this function acts like a finite state + // automata: 3 bitfields: reset, extending, scanning - ie 8 states + int reset = 0, extending = 0, scanning = 0; + + int species_num = raw_list.SpeciesNum(); + int win_num = raw_list.WinNum(); + + int *cur_path, *next_path; + + cur_path = new int[species_num]; + next_path = new int[species_num]; + + raw_list.ResetIndex(); + + while (no more windows avaible) + { + //cur_indices[0] + ref_ext == next_indices[0] + 1: + + // state 000 - start/nominal search + // + if !reset && !extending && !scanning + { + if cur_path[0] == next_path[0] + { + scanning = 1; // go to state 001 + raw_list.IncreIndex(); + } + else if cur_path[0] + 1 == next_path[0] + { + extending = 1; // go to state 010 + win_ext = 1; + raw_list.SetDirty(); + raw_list.IncreIndex(); + } + else + reset = 1; // go to state 100 + } + + // state 001 - scanning for ext window thru possible interleaving + // + else if !reset && !extending && scanning + { + if cur_path[0] == next_path[0] + raw_list.IncreIndex(); + else if cur_path[0] + 1 == next_path[0] + { + extending = 1; // go to state 011 + win_ext = 1; + raw_list.SetDirty(); + raw_list.IncreIndex(); + } + else + reset = 1; // go to state 101 + } + + // state 010 - extending window with no interleaving + // + else if !reset && extending && !scanning + { + if (cur_path[0] + win_ext) == next_path[0] + { + extending = 1; // go to state 011 + raw_list.IncreIndex(); + } + else if (cur_path[0] + win_ext + 1) == next_path[0] + { + win_ext++; + raw_list.SetDirty(); + raw_list.IncreIndex(); + } + else + reset = 1; // go to state 110 + } + + // state 011 - extending window with interleaving + // + else if !reset && extending && scanning + { + if (cur_path[0] + win_ext) == next_path[0] + raw_list.IncreIndex(); + else if (cur_path[0] + win_ext + 1) == next_path[0] + { + win_ext++; + raw_list.SetDirty(); + raw_list.IncreIndex(); + } + else + reset = 1; // go to state 111 + } + + + // reset condition states, return to 000 after taking appropiate action + + // state 100 - no extended window, no scanning happened + // save basic window to extended window list + if reset && !extending && !scanning + { + // return to start/nominal search state + reset = 0; + } + + // state 101 - no extended window, scanned for interleaving + // save basic window to extended window list, return to first clean + else if reset && !extending && scanning + { + // return to start/nominal search state + reset = 0; + scanning = 0; + } + + // state 110 - extended window, no interleaving + // calc extended window, save to extended window list + else if reset && extending && !scanning + { + // return to start/nominal search state + reset = 0; + extending = 0; + } + + // state 111 - extended window, interleaved + // calc extended window, save to ext win list, return to first clean + else if reset && extending && scanning + { + // return to start/nominal search state + reset = 0; + extending = 0; + scanning = 0; + } + + return ext_win; +} diff --git a/seqcomp.cc b/seqcomp.cc deleted file mode 100644 index f2bc843..0000000 --- a/seqcomp.cc +++ /dev/null @@ -1,94 +0,0 @@ -// This file is part of the Mussa source distribution. -// http://mussa.caltech.edu/ -// Contact author: Tristan De Buysscher, tristan@caltech.edu - -// This program and all associated source code files are Copyright (C) 2005 -// the California Institute of Technology, Pasadena, CA, 91125 USA. It is -// under the GNU Public License; please see the included LICENSE.txt -// file for more information, or contact Tristan directly. - - -#include "flp.hh" -#include -#include - -int main(int argc, char **argv) -{ - Sequence seqA, seqB; - FLPs analysis; - string seqA_file, seqB_file, output_file; - string ana_type; - int window, threshold; - int seqA_len, seqB_len; - - time_t t1, t2, begin, end; - double setuptime, comp1time, comp2time, sorttime, savetime, totaltime; - - begin = time(NULL); - - cout << "fee fie foe fum" << endl; - - ana_type = * ++argv; - seqA_file = * ++argv; - seqB_file = * ++argv; - window = atoi(* ++argv); - threshold = atoi(* ++argv); - output_file = * ++argv; - - t1 = time(NULL); - - seqA.load_fasta(seqA_file, 1, 0, 0); - seqA_len = seqA.len(); - //cout << setw(60) << seqA.hdr() << "\n"; - - seqB.load_fasta(seqB_file, 1, 0, 0); - seqB_len = seqB.len(); - //cout << seqB.hdr() << "\n"; - - - cout << "Length: Seq A = " << seqA_len; - cout << "; Seq B = " << seqB_len << "\n"; - - analysis.setup(ana_type, window, threshold, seqA_len, seqB_len); - - t2 = time(NULL); - setuptime = difftime(t2, t1); - - t1 = time(NULL); - analysis.seqcomp(seqA.seq(), seqB.seq(), false); - t2 = time(NULL); - comp1time = difftime(t2, t1); - - t1 = time(NULL); - analysis.seqcomp(seqA.seq(), seqB.rev_comp(), true); - t2 = time(NULL); - comp2time = difftime(t2, t1); - /* - t1 = time(NULL); - analysis.sort(); - t2 = time(NULL); - sorttime = difftime(t2, t1); - */ - t1 = time(NULL); - analysis.file_save(output_file); - t2 = time(NULL); - savetime = difftime(t2, t1); - - end = time(NULL); - totaltime = difftime(end, begin); - - cout << "setup\tcomp\trc_comp\tsave\ttotal\n"; - cout << setuptime << "\t"; - cout << comp1time << "\t"; - cout << comp2time << "\t"; - //cout << sorttime << "\t"; - cout << savetime << "\t"; - cout << totaltime << "\n"; -} - -/* - cout << "fee\n"; - cout << "fie\n"; - cout << "foe "; - cout << "fum\n"; -*/ diff --git a/seqcomp.cxx b/seqcomp.cxx new file mode 100644 index 0000000..c9c953e --- /dev/null +++ b/seqcomp.cxx @@ -0,0 +1,97 @@ +// This file is part of the Mussa source distribution. +// http://mussa.caltech.edu/ +// Contact author: Tristan De Buysscher, tristan@caltech.edu + +// This program and all associated source code files are Copyright (C) 2005 +// the California Institute of Technology, Pasadena, CA, 91125 USA. It is +// under the GNU Public License; please see the included LICENSE.txt +// file for more information, or contact Tristan directly. + + +#include "flp.hh" +#include "sequence.hh" +#include +#include + +using namespace std; + +int main(int argc, char **argv) +{ + Sequence seqA, seqB; + FLPs analysis; + string seqA_file, seqB_file, output_file; + string ana_type; + int window, threshold; + int seqA_len, seqB_len; + + time_t t1, t2, begin, end; + double setuptime, comp1time, comp2time, sorttime, savetime, totaltime; + + begin = time(NULL); + + cout << "fee fie foe fum" << endl; + + ana_type = * ++argv; + seqA_file = * ++argv; + seqB_file = * ++argv; + window = atoi(* ++argv); + threshold = atoi(* ++argv); + output_file = * ++argv; + + t1 = time(NULL); + + seqA.load_fasta(seqA_file, 1, 0, 0); + seqA_len = seqA.len(); + //cout << setw(60) << seqA.hdr() << "\n"; + + seqB.load_fasta(seqB_file, 1, 0, 0); + seqB_len = seqB.len(); + //cout << seqB.hdr() << "\n"; + + + cout << "Length: Seq A = " << seqA_len; + cout << "; Seq B = " << seqB_len << "\n"; + + analysis.setup(ana_type, window, threshold, seqA_len, seqB_len); + + t2 = time(NULL); + setuptime = difftime(t2, t1); + + t1 = time(NULL); + analysis.seqcomp(seqA.seq(), seqB.seq(), false); + t2 = time(NULL); + comp1time = difftime(t2, t1); + + t1 = time(NULL); + analysis.seqcomp(seqA.seq(), seqB.rev_comp(), true); + t2 = time(NULL); + comp2time = difftime(t2, t1); + /* + t1 = time(NULL); + analysis.sort(); + t2 = time(NULL); + sorttime = difftime(t2, t1); + */ + t1 = time(NULL); + analysis.file_save(output_file); + t2 = time(NULL); + savetime = difftime(t2, t1); + + end = time(NULL); + totaltime = difftime(end, begin); + + cout << "setup\tcomp\trc_comp\tsave\ttotal\n"; + cout << setuptime << "\t"; + cout << comp1time << "\t"; + cout << comp2time << "\t"; + //cout << sorttime << "\t"; + cout << savetime << "\t"; + cout << totaltime << "\n"; +} + +/* + cout << "fee\n"; + cout << "fie\n"; + cout << "foe "; + cout << "fum\n"; +*/ diff --git a/sequence.cc b/sequence.cc deleted file mode 100644 index 62025aa..0000000 --- a/sequence.cc +++ /dev/null @@ -1,675 +0,0 @@ -// This file is part of the Mussa source distribution. -// http://mussa.caltech.edu/ -// Contact author: Tristan De Buysscher, tristan@caltech.edu - -// This program and all associated source code files are Copyright (C) 2005 -// the California Institute of Technology, Pasadena, CA, 91125 USA. It is -// under the GNU Public License; please see the included LICENSE.txt -// file for more information, or contact Tristan directly. - - -// This file is part of the Mussa source distribution. -// http://mussa.caltech.edu/ -// Contact author: Tristan De Buysscher, tristan@caltech.edu - -// This program and all associated source code files are Copyright (C) 2005 -// the California Institute of Technology, Pasadena, CA, 91125 USA. It is -// under the GNU Public License; please see the included LICENSE.txt -// file for more information, or contact Tristan directly. - - -// ---------------------------------------- -// ---------- sequence.cc ----------- -// ---------------------------------------- - -#include "sequence.hh" -#include - -using namespace std; - -Sequence::Sequence() -{ -} - - -string -Sequence::load_fasta(string file_path, int seq_num, - int start_index, int end_index) -{ - fstream data_file; - string file_data_line; - int header_counter = 0; - bool read_seq = true; - string rev_comp; - char conversionTable[257]; - int seq_i, table_i, len; - string sequence_raw; - char * seq_tmp; // holds sequence during basic filtering - string err_msg; - - data_file.open(file_path.c_str(), ios::in); - - if (!data_file) - { - err_msg = "Sequence File: " + file_path + " not found"; - return err_msg; - } - // if file opened okay, read it - else - { - // search for the header of the fasta sequence we want - while ( (!data_file.eof()) && (header_counter < seq_num) ) - { - getline(data_file,file_data_line); - if (file_data_line.substr(0,1) == ">") - header_counter++; - } - - header = file_data_line.substr(1); - - sequence_raw = ""; - - while ( !data_file.eof() && read_seq ) - { - getline(data_file,file_data_line); - if (file_data_line.substr(0,1) == ">") - read_seq = false; - else sequence_raw += file_data_line; - } - - data_file.close(); - - // sequence filtering for upcasing agctn and convert non AGCTN to N - - len = sequence_raw.length(); - seq_tmp = (char*)sequence_raw.c_str(); - - sequence = ""; - - // Make a conversion table - - // everything we don't specify below will become 'N' - for(table_i=0; table_i < 256; table_i++) - { - conversionTable[table_i] = 'N'; - } - // add end of string character for printing out table for testing purposes - conversionTable[256] = '\0'; - - // we want these to map to themselves - ie not to change - conversionTable['A'] = 'A'; - conversionTable['T'] = 'T'; - conversionTable['G'] = 'G'; - conversionTable['C'] = 'C'; - // this is to upcase - conversionTable['a'] = 'A'; - conversionTable['t'] = 'T'; - conversionTable['g'] = 'G'; - conversionTable['c'] = 'C'; - - // finally, the actual conversion loop - for(seq_i = 0; seq_i < len; seq_i++) - { - table_i = (int) seq_tmp[seq_i]; - sequence += conversionTable[table_i]; - } - - - // Lastly, if subselection of the sequence was specified we keep cut out - // and only keep that part - - // end_index = 0 means no end was specified, so cut to the end - if (end_index == 0) - end_index = len; - - // start_index = 0 if no start was specified - sequence = sequence.substr(start_index, end_index - start_index); - - return ""; - } -} - - - // this doesn't work properly under gcc 3.x ... it can't recognize toupper - //transform(sequence.begin(), sequence.end(), sequence.begin(), toupper); - - -string -Sequence::load_annot(string file_path, int start_index, int end_index) -{ - fstream data_file; - string file_data_line; - annot an_annot; - int space_split_i; - string annot_value; - list::iterator list_i; - string err_msg; - - - annots.clear(); - data_file.open(file_path.c_str(), ios::in); - - if (!data_file) - { - err_msg = "Sequence File: " + file_path + " not found"; - return err_msg; - } - // if file opened okay, read it - else - { - getline(data_file,file_data_line); - species = file_data_line; - - // end_index = 0 means no end was specified, so cut to the end - if (end_index == 0) - end_index = sequence.length(); - - //cout << "START: " << start_index << " END: " << end_index << endl; - - while ( !data_file.eof() ) - { - getline(data_file,file_data_line); - if (file_data_line != "") - { - // need to get 4 values...almost same code 4 times... - // get annot start index - space_split_i = file_data_line.find(" "); - annot_value = file_data_line.substr(0,space_split_i); - an_annot.start = atoi (annot_value.c_str()); - file_data_line = file_data_line.substr(space_split_i+1); - // get annot end index - space_split_i = file_data_line.find(" "); - annot_value = file_data_line.substr(0,space_split_i); - an_annot.end = atoi (annot_value.c_str()); - file_data_line = file_data_line.substr(space_split_i+1); - - cout << "seq, annots: " << an_annot.start << ", " << an_annot.end - << endl; - - // get annot name - space_split_i = file_data_line.find(" "); - if (space_split_i == string::npos) // no entries for name & type - { - cout << "seq, annots - no name or type\n"; - an_annot.name = ""; - an_annot.type = ""; - } - else - { - annot_value = file_data_line.substr(0,space_split_i); - an_annot.name = annot_value; - file_data_line = file_data_line.substr(space_split_i+1); - // get annot type - space_split_i = file_data_line.find(" "); - if (space_split_i == string::npos) // no entry for type - an_annot.type = ""; - else - { - annot_value = file_data_line.substr(0,space_split_i); - an_annot.type = annot_value; - } - } - - - // add annot to list if it falls within the range of sequence specified - if ((start_index <= an_annot.start) && (end_index >= an_annot.end)) - { - an_annot.start -= start_index; - an_annot.end -= start_index; - annots.push_back(an_annot); - } - else - cout << "FAILED!!!!!!\n"; - } - } - - data_file.close(); - /* - // debugging check - for(list_i = annots.begin(); list_i != annots.end(); ++list_i) - { - cout << (*list_i).start << "," << (*list_i).end << "\t"; - cout << (*list_i).name << "\t" << (*list_i).type << endl; - } - */ - return ""; - } -} - - -int -Sequence::len() -{ - return sequence.length(); -} - - -string -Sequence::seq() -{ - return sequence; -} - - -string -Sequence::subseq(int start, int end) -{ - return sequence.substr(start, end); -} - - -const char * -Sequence::c_seq() -{ - return sequence.c_str(); -} - -string -Sequence::rev_comp() -{ - string rev_comp; - char conversionTable[257]; - int seq_i, table_i, len; - - len = sequence.length(); - rev_comp.reserve(len); - // make a conversion table - // init all parts of conversion table to '~' character - // '~' I doubt will ever appear in a sequence file (jeez, I hope) - // and may the fleas of 1000 camels infest the genitals of any biologist (and - // seven generations of their progeny) who decides to make it mean - // something special!!! - // PS - double the curse for any smartass non-biologist who tries it as well - for(table_i=0; table_i < 256; table_i++) - { - conversionTable[table_i] = '~'; - } - // add end of string character for printing out table for testing purposes - conversionTable[256] = '\0'; - - // add in the characters for the bases we want to convert - conversionTable['A'] = 'T'; - conversionTable['T'] = 'A'; - conversionTable['G'] = 'C'; - conversionTable['C'] = 'G'; - conversionTable['N'] = 'N'; - - // finally, the actual conversion loop - for(seq_i = len - 1; seq_i >= 0; seq_i--) - { - table_i = (int) sequence[seq_i]; - rev_comp += conversionTable[table_i]; - } - - return rev_comp; -} - - -string -Sequence::hdr() -{ - return header; -} - -string -Sequence::sp_name() -{ - return species; -} - - -void -Sequence::set_seq(string a_seq) -{ - sequence = a_seq; -} - - -/* -string -Sequence::species() -{ - return species; -} -*/ - -void -Sequence::clear() -{ - sequence = ""; - header = ""; - species = ""; - species_num = -4; - annots.clear(); -} - -void -Sequence::save(fstream &save_file) - //string save_file_path) -{ - //fstream save_file; - list::iterator annots_i; - int i; - - // not sure why, or if i'm doing something wrong, but can't seem to pass - // file pointers down to this method from the mussa control class - // so each call to save a sequence appends to the file started by mussa_class - //save_file.open(save_file_path.c_str(), ios::app); - - save_file << "" << endl; - save_file << sequence << endl; - save_file << "" << endl; - - save_file << "" << endl; - save_file << species << endl; - for (annots_i = annots.begin(); annots_i != annots.end(); ++annots_i) - { - save_file << annots_i->start << " " << annots_i->end << " " ; - save_file << annots_i->name << " " << annots_i->type << endl; - } - save_file << "" << endl; - //save_file.close(); -} - -void -Sequence::load_museq(string load_file_path, int seq_num) -{ - fstream load_file; - string file_data_line; - int seq_counter; - annot an_annot; - int space_split_i; - string annot_value; - - annots.clear(); - load_file.open(load_file_path.c_str(), ios::in); - - seq_counter = 0; - // search for the seq_num-th sequence - while ( (!load_file.eof()) && (seq_counter < seq_num) ) - { - getline(load_file,file_data_line); - if (file_data_line == "") - seq_counter++; - } - getline(load_file, file_data_line); - sequence = file_data_line; - getline(load_file, file_data_line); - getline(load_file, file_data_line); - if (file_data_line == "") - { - getline(load_file, file_data_line); - species = file_data_line; - while ( (!load_file.eof()) && (file_data_line != "") ) - { - getline(load_file,file_data_line); - if ((file_data_line != "") && (file_data_line != "")) - { - // need to get 4 values...almost same code 4 times... - // get annot start index - space_split_i = file_data_line.find(" "); - annot_value = file_data_line.substr(0,space_split_i); - an_annot.start = atoi (annot_value.c_str()); - file_data_line = file_data_line.substr(space_split_i+1); - // get annot end index - space_split_i = file_data_line.find(" "); - annot_value = file_data_line.substr(0,space_split_i); - an_annot.end = atoi (annot_value.c_str()); - - if (space_split_i == string::npos) // no entry for type or name - { - cout << "seq, annots - no type or name\n"; - an_annot.type = ""; - an_annot.name = ""; - } - else // else get annot type - { - file_data_line = file_data_line.substr(space_split_i+1); - space_split_i = file_data_line.find(" "); - annot_value = file_data_line.substr(0,space_split_i); - an_annot.type = annot_value; - if (space_split_i == string::npos) // no entry for name - { - cout << "seq, annots - no name\n"; - an_annot.name = ""; - } - else // get annot name - { - file_data_line = file_data_line.substr(space_split_i+1); - space_split_i = file_data_line.find(" "); - annot_value = file_data_line.substr(0,space_split_i); - an_annot.type = annot_value; - } - } - annots.push_back(an_annot); // don't forget to actually add the annot - } - cout << "seq, annots: " << an_annot.start << ", " << an_annot.end - << "-->" << an_annot.type << "::" << an_annot.name << endl; - } - } - load_file.close(); -} - - -string -Sequence::rc_motif(string a_motif) -{ - string rev_comp; - char conversionTable[257]; - int seq_i, table_i, len; - - len = a_motif.length(); - rev_comp.reserve(len); - - for(table_i=0; table_i < 256; table_i++) - { - conversionTable[table_i] = '~'; - } - // add end of string character for printing out table for testing purposes - conversionTable[256] = '\0'; - - // add in the characters for the bases we want to convert (IUPAC) - conversionTable['A'] = 'T'; - conversionTable['T'] = 'A'; - conversionTable['G'] = 'C'; - conversionTable['C'] = 'G'; - conversionTable['N'] = 'N'; - conversionTable['M'] = 'K'; - conversionTable['R'] = 'Y'; - conversionTable['W'] = 'W'; - conversionTable['S'] = 'S'; - conversionTable['Y'] = 'R'; - conversionTable['K'] = 'M'; - conversionTable['V'] = 'B'; - conversionTable['H'] = 'D'; - conversionTable['D'] = 'H'; - conversionTable['B'] = 'V'; - - // finally, the actual conversion loop - for(seq_i = len - 1; seq_i >= 0; seq_i--) - { - //cout << "** i = " << seq_i << " bp = " << - table_i = (int) a_motif[seq_i]; - rev_comp += conversionTable[table_i]; - } - - cout << "seq: " << a_motif << endl; - cout << "rc: " << rev_comp << endl; - - return rev_comp; -} - -string -Sequence::motif_validate(string a_motif) -{ - string valid_motif; - int seq_i, len; - - len = a_motif.length(); - valid_motif.reserve(len); - - // this just upcases IUPAC symbols. Eventually should return an error if non IUPAC is present. - // current nonIUPAC symbols are omitted, which is not reported atm - for(seq_i = 0; seq_i < len; seq_i++) - { - if ((a_motif[seq_i] == 'a') || (a_motif[seq_i] == 'A')) - valid_motif += 'A'; - else if ((a_motif[seq_i] == 't') || (a_motif[seq_i] == 'T')) - valid_motif += 'T'; - else if ((a_motif[seq_i] == 'g') || (a_motif[seq_i] == 'G')) - valid_motif += 'G'; - else if ((a_motif[seq_i] == 'c') || (a_motif[seq_i] == 'C')) - valid_motif += 'C'; - else if ((a_motif[seq_i] == 'n') || (a_motif[seq_i] == 'N')) - valid_motif += 'N'; - else if ((a_motif[seq_i] == 'm') || (a_motif[seq_i] == 'M')) - valid_motif += 'M'; - else if ((a_motif[seq_i] == 'r') || (a_motif[seq_i] == 'R')) - valid_motif += 'R'; - else if ((a_motif[seq_i] == 'w') || (a_motif[seq_i] == 'W')) - valid_motif += 'W'; - else if ((a_motif[seq_i] == 's') || (a_motif[seq_i] == 'S')) - valid_motif += 'S'; - else if ((a_motif[seq_i] == 'y') || (a_motif[seq_i] == 'Y')) - valid_motif += 'Y'; - else if ((a_motif[seq_i] == 'k') || (a_motif[seq_i] == 'K')) - valid_motif += 'G'; - else if ((a_motif[seq_i] == 'v') || (a_motif[seq_i] == 'V')) - valid_motif += 'V'; - else if ((a_motif[seq_i] == 'h') || (a_motif[seq_i] == 'H')) - valid_motif += 'H'; - else if ((a_motif[seq_i] == 'd') || (a_motif[seq_i] == 'D')) - valid_motif += 'D'; - else if ((a_motif[seq_i] == 'b') || (a_motif[seq_i] == 'B')) - valid_motif += 'B'; - } - - cout << "valid_motif is: " << valid_motif << endl; - - return valid_motif; -} - - -vector -Sequence::find_motif(string a_motif) -{ - vector motif_match_starts; - string a_motif_rc; - - - motif_match_starts.clear(); - - cout << "motif is: " << a_motif << endl; - a_motif = motif_validate(a_motif); - //cout << "motif is: " << a_motif << endl; - - - if (a_motif != "") - { - cout << "Sequence: none blank motif\n"; - motif_scan(a_motif, &motif_match_starts); - - a_motif_rc = rc_motif(a_motif); - // make sure not to do search again if it is a palindrome - if (a_motif_rc != a_motif) - motif_scan(a_motif_rc, &motif_match_starts); - } - return motif_match_starts; -} - -void -Sequence::motif_scan(string a_motif, vector * motif_match_starts) -{ - char * seq_c; - int seq_i, motif_i, motif_len; - - // faster to loop thru the sequence as a old c string (ie char array) - seq_c = (char*)sequence.c_str(); - //cout << "Sequence: motif, seq len = " << sequence.length() << endl; - motif_len = a_motif.length(); - - //cout << "motif_length: " << motif_len << endl; - //cout << "RAAARRRRR\n"; - - motif_i = 0; - - //cout << "motif: " << a_motif << endl; - - //cout << "Sequence: motif, length= " << length << endl; - seq_i = 0; - while (seq_i < sequence.length()) - { - cout << seq_c[seq_i]; - //if ((seq_i > 10885) && (seq_i < 10917)) - //cout << seq_c[seq_i] << "?" << a_motif[motif_i] << ":" << motif_i << " "; - // this is pretty much a straight translation of Nora's python code - // to match iupac letter codes - if (a_motif[motif_i] =='N') - motif_i++; - else if (a_motif[motif_i] == seq_c[seq_i]) - motif_i++; - else if ((a_motif[motif_i] =='M') && - ((seq_c[seq_i]=='A') || (seq_c[seq_i]=='C'))) - motif_i++; - else if ((a_motif[motif_i] =='R') && - ((seq_c[seq_i]=='A') || (seq_c[seq_i]=='G'))) - motif_i++; - else if ((a_motif[motif_i] =='W') && - ((seq_c[seq_i]=='A') || (seq_c[seq_i]=='T'))) - motif_i++; - else if ((a_motif[motif_i] =='S') && - ((seq_c[seq_i]=='C') || (seq_c[seq_i]=='G'))) - motif_i++; - else if ((a_motif[motif_i] =='Y') && - ((seq_c[seq_i]=='C') || (seq_c[seq_i]=='T'))) - motif_i++; - else if ((a_motif[motif_i] =='K') && - ((seq_c[seq_i]=='G') || (seq_c[seq_i]=='T'))) - motif_i++; - else if ((a_motif[motif_i] =='V') && - ((seq_c[seq_i]=='A') || (seq_c[seq_i]=='C') || - (seq_c[seq_i]=='G'))) - motif_i++; - else if ((a_motif[seq_i] =='H') && - ((seq_c[seq_i]=='A') || (seq_c[seq_i]=='C') || - (seq_c[seq_i]=='T'))) - motif_i++; - else if ((a_motif[motif_i] =='D') && - ((seq_c[seq_i]=='A') || (seq_c[seq_i]=='G') || - (seq_c[seq_i]=='T'))) - motif_i++; - else if ((a_motif[motif_i] =='B') && - ((seq_c[seq_i]=='C') || (seq_c[seq_i]=='G') || - (seq_c[seq_i]=='T'))) - motif_i++; - - else - { - seq_i -= motif_i; - motif_i = 0; - } - - // end Nora stuff, now we see if a match is found this pass - if (motif_i == motif_len) - { - //cout << "!!"; - motif_match_starts->push_back(seq_i - motif_len + 1); - motif_i = 0; - } - - seq_i++; - } - cout << endl; -} - -/* - // get annot start index - space_split_i = file_data_line.find(" "); - annot_value = file_data_line.substr(0,space_split_i); - an_annot.name = annot_value; - file_data_line = file_data_line.substr(space_split_i+1); - // get annot start index - space_split_i = file_data_line.find(" "); - annot_value = file_data_line.substr(0,space_split_i); - an_annot.type = annot_value; -*/ diff --git a/sequence.cxx b/sequence.cxx new file mode 100644 index 0000000..d6f363e --- /dev/null +++ b/sequence.cxx @@ -0,0 +1,682 @@ +// This file is part of the Mussa source distribution. +// http://mussa.caltech.edu/ +// Contact author: Tristan De Buysscher, tristan@caltech.edu + +// This program and all associated source code files are Copyright (C) 2005 +// the California Institute of Technology, Pasadena, CA, 91125 USA. It is +// under the GNU Public License; please see the included LICENSE.txt +// file for more information, or contact Tristan directly. + + +// This file is part of the Mussa source distribution. +// http://mussa.caltech.edu/ +// Contact author: Tristan De Buysscher, tristan@caltech.edu + +// This program and all associated source code files are Copyright (C) 2005 +// the California Institute of Technology, Pasadena, CA, 91125 USA. It is +// under the GNU Public License; please see the included LICENSE.txt +// file for more information, or contact Tristan directly. + + +// ---------------------------------------- +// ---------- sequence.cc ----------- +// ---------------------------------------- + +#include "sequence.hh" +#include + +using namespace std; + +Sequence::Sequence() +{ +} + +//! load a fasta file into a sequence +/*! + * \param file_path the location of the fasta file in the filesystem + * \param seq_num which sequence in the file to load + * \param start_index starting position in the fasta sequence, 0 for beginning + * \param end_index ending position in the fasta sequence, 0 for end + * \return error message, empty string if no error. (gag!) + */ +string +Sequence::load_fasta(string file_path, int seq_num, + int start_index, int end_index) +{ + fstream data_file; + string file_data_line; + int header_counter = 0; + bool read_seq = true; + string rev_comp; + char conversionTable[257]; + int seq_i, table_i, len; + string sequence_raw; + char * seq_tmp; // holds sequence during basic filtering + string err_msg; + + data_file.open(file_path.c_str(), ios::in); + + if (!data_file) + { + err_msg = "Sequence File: " + file_path + " not found"; + return err_msg; + } + // if file opened okay, read it + else + { + // search for the header of the fasta sequence we want + while ( (!data_file.eof()) && (header_counter < seq_num) ) + { + getline(data_file,file_data_line); + if (file_data_line.substr(0,1) == ">") + header_counter++; + } + + header = file_data_line.substr(1); + + sequence_raw = ""; + + while ( !data_file.eof() && read_seq ) + { + getline(data_file,file_data_line); + if (file_data_line.substr(0,1) == ">") + read_seq = false; + else sequence_raw += file_data_line; + } + + data_file.close(); + + // sequence filtering for upcasing agctn and convert non AGCTN to N + + len = sequence_raw.length(); + seq_tmp = (char*)sequence_raw.c_str(); + + sequence = ""; + + // Make a conversion table + + // everything we don't specify below will become 'N' + for(table_i=0; table_i < 256; table_i++) + { + conversionTable[table_i] = 'N'; + } + // add end of string character for printing out table for testing purposes + conversionTable[256] = '\0'; + + // we want these to map to themselves - ie not to change + conversionTable['A'] = 'A'; + conversionTable['T'] = 'T'; + conversionTable['G'] = 'G'; + conversionTable['C'] = 'C'; + // this is to upcase + conversionTable['a'] = 'A'; + conversionTable['t'] = 'T'; + conversionTable['g'] = 'G'; + conversionTable['c'] = 'C'; + + // finally, the actual conversion loop + for(seq_i = 0; seq_i < len; seq_i++) + { + table_i = (int) seq_tmp[seq_i]; + sequence += conversionTable[table_i]; + } + + + // Lastly, if subselection of the sequence was specified we keep cut out + // and only keep that part + + // end_index = 0 means no end was specified, so cut to the end + if (end_index == 0) + end_index = len; + + // start_index = 0 if no start was specified + sequence = sequence.substr(start_index, end_index - start_index); + + return ""; + } +} + + + // this doesn't work properly under gcc 3.x ... it can't recognize toupper + //transform(sequence.begin(), sequence.end(), sequence.begin(), toupper); + + +string +Sequence::load_annot(string file_path, int start_index, int end_index) +{ + fstream data_file; + string file_data_line; + annot an_annot; + int space_split_i; + string annot_value; + list::iterator list_i; + string err_msg; + + + annots.clear(); + data_file.open(file_path.c_str(), ios::in); + + if (!data_file) + { + err_msg = "Sequence File: " + file_path + " not found"; + return err_msg; + } + // if file opened okay, read it + else + { + getline(data_file,file_data_line); + species = file_data_line; + + // end_index = 0 means no end was specified, so cut to the end + if (end_index == 0) + end_index = sequence.length(); + + //cout << "START: " << start_index << " END: " << end_index << endl; + + while ( !data_file.eof() ) + { + getline(data_file,file_data_line); + if (file_data_line != "") + { + // need to get 4 values...almost same code 4 times... + // get annot start index + space_split_i = file_data_line.find(" "); + annot_value = file_data_line.substr(0,space_split_i); + an_annot.start = atoi (annot_value.c_str()); + file_data_line = file_data_line.substr(space_split_i+1); + // get annot end index + space_split_i = file_data_line.find(" "); + annot_value = file_data_line.substr(0,space_split_i); + an_annot.end = atoi (annot_value.c_str()); + file_data_line = file_data_line.substr(space_split_i+1); + + cout << "seq, annots: " << an_annot.start << ", " << an_annot.end + << endl; + + // get annot name + space_split_i = file_data_line.find(" "); + if (space_split_i == string::npos) // no entries for name & type + { + cout << "seq, annots - no name or type\n"; + an_annot.name = ""; + an_annot.type = ""; + } + else + { + annot_value = file_data_line.substr(0,space_split_i); + an_annot.name = annot_value; + file_data_line = file_data_line.substr(space_split_i+1); + // get annot type + space_split_i = file_data_line.find(" "); + if (space_split_i == string::npos) // no entry for type + an_annot.type = ""; + else + { + annot_value = file_data_line.substr(0,space_split_i); + an_annot.type = annot_value; + } + } + + + // add annot to list if it falls within the range of sequence specified + if ((start_index <= an_annot.start) && (end_index >= an_annot.end)) + { + an_annot.start -= start_index; + an_annot.end -= start_index; + annots.push_back(an_annot); + } + else + cout << "FAILED!!!!!!\n"; + } + } + + data_file.close(); + /* + // debugging check + for(list_i = annots.begin(); list_i != annots.end(); ++list_i) + { + cout << (*list_i).start << "," << (*list_i).end << "\t"; + cout << (*list_i).name << "\t" << (*list_i).type << endl; + } + */ + return ""; + } +} + + +int +Sequence::len() +{ + return sequence.length(); +} + + +string +Sequence::seq() +{ + return sequence; +} + + +string +Sequence::subseq(int start, int end) +{ + return sequence.substr(start, end); +} + + +const char * +Sequence::c_seq() +{ + return sequence.c_str(); +} + +string +Sequence::rev_comp() +{ + string rev_comp; + char conversionTable[257]; + int seq_i, table_i, len; + + len = sequence.length(); + rev_comp.reserve(len); + // make a conversion table + // init all parts of conversion table to '~' character + // '~' I doubt will ever appear in a sequence file (jeez, I hope) + // and may the fleas of 1000 camels infest the genitals of any biologist (and + // seven generations of their progeny) who decides to make it mean + // something special!!! + // PS - double the curse for any smartass non-biologist who tries it as well + for(table_i=0; table_i < 256; table_i++) + { + conversionTable[table_i] = '~'; + } + // add end of string character for printing out table for testing purposes + conversionTable[256] = '\0'; + + // add in the characters for the bases we want to convert + conversionTable['A'] = 'T'; + conversionTable['T'] = 'A'; + conversionTable['G'] = 'C'; + conversionTable['C'] = 'G'; + conversionTable['N'] = 'N'; + + // finally, the actual conversion loop + for(seq_i = len - 1; seq_i >= 0; seq_i--) + { + table_i = (int) sequence[seq_i]; + rev_comp += conversionTable[table_i]; + } + + return rev_comp; +} + + +string +Sequence::hdr() +{ + return header; +} + +string +Sequence::sp_name() +{ + return species; +} + + +void +Sequence::set_seq(string a_seq) +{ + sequence = a_seq; +} + + +/* +string +Sequence::species() +{ + return species; +} +*/ + +void +Sequence::clear() +{ + sequence = ""; + header = ""; + species = ""; + species_num = -4; + annots.clear(); +} + +void +Sequence::save(fstream &save_file) + //string save_file_path) +{ + //fstream save_file; + list::iterator annots_i; + int i; + + // not sure why, or if i'm doing something wrong, but can't seem to pass + // file pointers down to this method from the mussa control class + // so each call to save a sequence appends to the file started by mussa_class + //save_file.open(save_file_path.c_str(), ios::app); + + save_file << "" << endl; + save_file << sequence << endl; + save_file << "" << endl; + + save_file << "" << endl; + save_file << species << endl; + for (annots_i = annots.begin(); annots_i != annots.end(); ++annots_i) + { + save_file << annots_i->start << " " << annots_i->end << " " ; + save_file << annots_i->name << " " << annots_i->type << endl; + } + save_file << "" << endl; + //save_file.close(); +} + +void +Sequence::load_museq(string load_file_path, int seq_num) +{ + fstream load_file; + string file_data_line; + int seq_counter; + annot an_annot; + int space_split_i; + string annot_value; + + annots.clear(); + load_file.open(load_file_path.c_str(), ios::in); + + seq_counter = 0; + // search for the seq_num-th sequence + while ( (!load_file.eof()) && (seq_counter < seq_num) ) + { + getline(load_file,file_data_line); + if (file_data_line == "") + seq_counter++; + } + getline(load_file, file_data_line); + sequence = file_data_line; + getline(load_file, file_data_line); + getline(load_file, file_data_line); + if (file_data_line == "") + { + getline(load_file, file_data_line); + species = file_data_line; + while ( (!load_file.eof()) && (file_data_line != "") ) + { + getline(load_file,file_data_line); + if ((file_data_line != "") && (file_data_line != "")) + { + // need to get 4 values...almost same code 4 times... + // get annot start index + space_split_i = file_data_line.find(" "); + annot_value = file_data_line.substr(0,space_split_i); + an_annot.start = atoi (annot_value.c_str()); + file_data_line = file_data_line.substr(space_split_i+1); + // get annot end index + space_split_i = file_data_line.find(" "); + annot_value = file_data_line.substr(0,space_split_i); + an_annot.end = atoi (annot_value.c_str()); + + if (space_split_i == string::npos) // no entry for type or name + { + cout << "seq, annots - no type or name\n"; + an_annot.type = ""; + an_annot.name = ""; + } + else // else get annot type + { + file_data_line = file_data_line.substr(space_split_i+1); + space_split_i = file_data_line.find(" "); + annot_value = file_data_line.substr(0,space_split_i); + an_annot.type = annot_value; + if (space_split_i == string::npos) // no entry for name + { + cout << "seq, annots - no name\n"; + an_annot.name = ""; + } + else // get annot name + { + file_data_line = file_data_line.substr(space_split_i+1); + space_split_i = file_data_line.find(" "); + annot_value = file_data_line.substr(0,space_split_i); + an_annot.type = annot_value; + } + } + annots.push_back(an_annot); // don't forget to actually add the annot + } + cout << "seq, annots: " << an_annot.start << ", " << an_annot.end + << "-->" << an_annot.type << "::" << an_annot.name << endl; + } + } + load_file.close(); +} + + +string +Sequence::rc_motif(string a_motif) +{ + string rev_comp; + char conversionTable[257]; + int seq_i, table_i, len; + + len = a_motif.length(); + rev_comp.reserve(len); + + for(table_i=0; table_i < 256; table_i++) + { + conversionTable[table_i] = '~'; + } + // add end of string character for printing out table for testing purposes + conversionTable[256] = '\0'; + + // add in the characters for the bases we want to convert (IUPAC) + conversionTable['A'] = 'T'; + conversionTable['T'] = 'A'; + conversionTable['G'] = 'C'; + conversionTable['C'] = 'G'; + conversionTable['N'] = 'N'; + conversionTable['M'] = 'K'; + conversionTable['R'] = 'Y'; + conversionTable['W'] = 'W'; + conversionTable['S'] = 'S'; + conversionTable['Y'] = 'R'; + conversionTable['K'] = 'M'; + conversionTable['V'] = 'B'; + conversionTable['H'] = 'D'; + conversionTable['D'] = 'H'; + conversionTable['B'] = 'V'; + + // finally, the actual conversion loop + for(seq_i = len - 1; seq_i >= 0; seq_i--) + { + //cout << "** i = " << seq_i << " bp = " << + table_i = (int) a_motif[seq_i]; + rev_comp += conversionTable[table_i]; + } + + cout << "seq: " << a_motif << endl; + cout << "rc: " << rev_comp << endl; + + return rev_comp; +} + +string +Sequence::motif_validate(string a_motif) +{ + string valid_motif; + int seq_i, len; + + len = a_motif.length(); + valid_motif.reserve(len); + + // this just upcases IUPAC symbols. Eventually should return an error if non IUPAC is present. + // current nonIUPAC symbols are omitted, which is not reported atm + for(seq_i = 0; seq_i < len; seq_i++) + { + if ((a_motif[seq_i] == 'a') || (a_motif[seq_i] == 'A')) + valid_motif += 'A'; + else if ((a_motif[seq_i] == 't') || (a_motif[seq_i] == 'T')) + valid_motif += 'T'; + else if ((a_motif[seq_i] == 'g') || (a_motif[seq_i] == 'G')) + valid_motif += 'G'; + else if ((a_motif[seq_i] == 'c') || (a_motif[seq_i] == 'C')) + valid_motif += 'C'; + else if ((a_motif[seq_i] == 'n') || (a_motif[seq_i] == 'N')) + valid_motif += 'N'; + else if ((a_motif[seq_i] == 'm') || (a_motif[seq_i] == 'M')) + valid_motif += 'M'; + else if ((a_motif[seq_i] == 'r') || (a_motif[seq_i] == 'R')) + valid_motif += 'R'; + else if ((a_motif[seq_i] == 'w') || (a_motif[seq_i] == 'W')) + valid_motif += 'W'; + else if ((a_motif[seq_i] == 's') || (a_motif[seq_i] == 'S')) + valid_motif += 'S'; + else if ((a_motif[seq_i] == 'y') || (a_motif[seq_i] == 'Y')) + valid_motif += 'Y'; + else if ((a_motif[seq_i] == 'k') || (a_motif[seq_i] == 'K')) + valid_motif += 'G'; + else if ((a_motif[seq_i] == 'v') || (a_motif[seq_i] == 'V')) + valid_motif += 'V'; + else if ((a_motif[seq_i] == 'h') || (a_motif[seq_i] == 'H')) + valid_motif += 'H'; + else if ((a_motif[seq_i] == 'd') || (a_motif[seq_i] == 'D')) + valid_motif += 'D'; + else if ((a_motif[seq_i] == 'b') || (a_motif[seq_i] == 'B')) + valid_motif += 'B'; + } + + cout << "valid_motif is: " << valid_motif << endl; + + return valid_motif; +} + + +vector +Sequence::find_motif(string a_motif) +{ + vector motif_match_starts; + string a_motif_rc; + + + motif_match_starts.clear(); + + cout << "motif is: " << a_motif << endl; + a_motif = motif_validate(a_motif); + //cout << "motif is: " << a_motif << endl; + + + if (a_motif != "") + { + cout << "Sequence: none blank motif\n"; + motif_scan(a_motif, &motif_match_starts); + + a_motif_rc = rc_motif(a_motif); + // make sure not to do search again if it is a palindrome + if (a_motif_rc != a_motif) + motif_scan(a_motif_rc, &motif_match_starts); + } + return motif_match_starts; +} + +void +Sequence::motif_scan(string a_motif, vector * motif_match_starts) +{ + char * seq_c; + int seq_i, motif_i, motif_len; + + // faster to loop thru the sequence as a old c string (ie char array) + seq_c = (char*)sequence.c_str(); + //cout << "Sequence: motif, seq len = " << sequence.length() << endl; + motif_len = a_motif.length(); + + //cout << "motif_length: " << motif_len << endl; + //cout << "RAAARRRRR\n"; + + motif_i = 0; + + //cout << "motif: " << a_motif << endl; + + //cout << "Sequence: motif, length= " << length << endl; + seq_i = 0; + while (seq_i < sequence.length()) + { + cout << seq_c[seq_i]; + //if ((seq_i > 10885) && (seq_i < 10917)) + //cout << seq_c[seq_i] << "?" << a_motif[motif_i] << ":" << motif_i << " "; + // this is pretty much a straight translation of Nora's python code + // to match iupac letter codes + if (a_motif[motif_i] =='N') + motif_i++; + else if (a_motif[motif_i] == seq_c[seq_i]) + motif_i++; + else if ((a_motif[motif_i] =='M') && + ((seq_c[seq_i]=='A') || (seq_c[seq_i]=='C'))) + motif_i++; + else if ((a_motif[motif_i] =='R') && + ((seq_c[seq_i]=='A') || (seq_c[seq_i]=='G'))) + motif_i++; + else if ((a_motif[motif_i] =='W') && + ((seq_c[seq_i]=='A') || (seq_c[seq_i]=='T'))) + motif_i++; + else if ((a_motif[motif_i] =='S') && + ((seq_c[seq_i]=='C') || (seq_c[seq_i]=='G'))) + motif_i++; + else if ((a_motif[motif_i] =='Y') && + ((seq_c[seq_i]=='C') || (seq_c[seq_i]=='T'))) + motif_i++; + else if ((a_motif[motif_i] =='K') && + ((seq_c[seq_i]=='G') || (seq_c[seq_i]=='T'))) + motif_i++; + else if ((a_motif[motif_i] =='V') && + ((seq_c[seq_i]=='A') || (seq_c[seq_i]=='C') || + (seq_c[seq_i]=='G'))) + motif_i++; + else if ((a_motif[seq_i] =='H') && + ((seq_c[seq_i]=='A') || (seq_c[seq_i]=='C') || + (seq_c[seq_i]=='T'))) + motif_i++; + else if ((a_motif[motif_i] =='D') && + ((seq_c[seq_i]=='A') || (seq_c[seq_i]=='G') || + (seq_c[seq_i]=='T'))) + motif_i++; + else if ((a_motif[motif_i] =='B') && + ((seq_c[seq_i]=='C') || (seq_c[seq_i]=='G') || + (seq_c[seq_i]=='T'))) + motif_i++; + + else + { + seq_i -= motif_i; + motif_i = 0; + } + + // end Nora stuff, now we see if a match is found this pass + if (motif_i == motif_len) + { + //cout << "!!"; + motif_match_starts->push_back(seq_i - motif_len + 1); + motif_i = 0; + } + + seq_i++; + } + cout << endl; +} + +/* + // get annot start index + space_split_i = file_data_line.find(" "); + annot_value = file_data_line.substr(0,space_split_i); + an_annot.name = annot_value; + file_data_line = file_data_line.substr(space_split_i+1); + // get annot start index + space_split_i = file_data_line.find(" "); + annot_value = file_data_line.substr(0,space_split_i); + an_annot.type = annot_value; +*/ diff --git a/sequence.hh b/sequence.hh index 11a50cc..3bdc75a 100644 --- a/sequence.hh +++ b/sequence.hh @@ -22,14 +22,14 @@ // Sequence data class -using namespace std; - +//! Attach annotation information to a sequence track struct annot { int start, end; std::string name, type; }; +//! sequence track for mussa. class Sequence { friend class ConnView;