Index: /tags/rel2_1/psLib/.cvsignore =================================================================== --- /tags/rel2_1/psLib/.cvsignore (revision 1553) +++ /tags/rel2_1/psLib/.cvsignore (revision 1553) @@ -0,0 +1,6 @@ +bin +lib +man +psLib.kdevelop.* +docs +testbin Index: /tags/rel2_1/psLib/src/.cvsignore =================================================================== --- /tags/rel2_1/psLib/src/.cvsignore (revision 1553) +++ /tags/rel2_1/psLib/src/.cvsignore (revision 1553) @@ -0,0 +1,1 @@ +DoxygenLog Index: /tags/rel2_1/psLib/src/Doxyfile =================================================================== --- /tags/rel2_1/psLib/src/Doxyfile (revision 1553) +++ /tags/rel2_1/psLib/src/Doxyfile (revision 1553) @@ -0,0 +1,1085 @@ +# Doxyfile 1.3.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 = "Pan-STARRS Foundation Library" + +# 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 = 2.0 + +# 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 = ../docs + +# 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, 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 + +# 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 = YES + +# 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 = NO + +# 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. It is allowed to use relative paths in the argument list. + +STRIP_FROM_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 +# explict @brief command for a brief description. + +JAVADOC_AUTOBRIEF = YES + +# 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 = YES + +# If the INHERIT_DOCS tag is set to YES (the default) then an undocumented +# member inherits the documentation from any documented member that it +# reimplements. + +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 + +# 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 = 4 + +# 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 = YES + +# 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 = NO + +#--------------------------------------------------------------------------- +# 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 = NO + +# If the EXTRACT_STATIC tag is set to YES all static members of a file +# will be included in the documentation. + +EXTRACT_STATIC = NO + +# 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 = 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 +# 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 + +# 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 + +#--------------------------------------------------------------------------- +# 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 + +# 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. + +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 = DoxygenLog + +#--------------------------------------------------------------------------- +# 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 = pslib.h \ + mainpage.dox \ + sysUtils \ + image \ + dataManip \ + collections \ + astronomy + +# 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 + +FILE_PATTERNS = *.h *.dox + +# 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 = YES + +# 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. + +EXCLUDE_PATTERNS = *_wrap.c + +# 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. + +INPUT_FILTER = + +# 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. + +SOURCE_BROWSER = YES + +# 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 = NO + +# 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 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 = YES + +# 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 + +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 dir. + +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 = YES + +# 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 = 10 + +# 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 = NO + +# 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 = YES + +# 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 = letter + +# 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 = times + +# 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 = YES + +# 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 = YES + +# 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 optimised 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 assigments. 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 = YES + +# 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 = YES + +#--------------------------------------------------------------------------- +# 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. Note that this +# feature is still experimental and incomplete at the +# moment. + +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 = + +#--------------------------------------------------------------------------- +# 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. + +PREDEFINED = DOXYGEN + +# 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::addtions 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 superceded 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 = YES + +# 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 UML_LOOK tag is set to YES doxygen will generate inheritance and +# collaboration diagrams in a style similiar to the OMG's Unified Modeling +# Language. + +UML_LOOK = YES + +# If set to YES, the inheritance and collaboration graphs will show the +# relations between templates and their instances. + +TEMPLATE_RELATIONS = YES + +# 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 + +# 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 on 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 + +# 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::addtions 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 + Index: /tags/rel2_1/psLib/src/Makefile =================================================================== --- /tags/rel2_1/psLib/src/Makefile (revision 1553) +++ /tags/rel2_1/psLib/src/Makefile (revision 1553) @@ -0,0 +1,215 @@ +############################################################################### +## +## Makefile: psLib +## +## $Revision: 1.17 $ $Name: not supported by cvs2svn $ +## $Date: 2004-07-29 21:55:44 $ +## +## Copyright 2004 Maui High Performance Computing Center, University of Hawaii +## +############################################################################### + +# Define variable prefix to the top level project - psLib +# This is necessary for definition in Makefile.Globals + +ifndef prefix + export prefix=$(shell cd ..;pwd) +endif + +# Include the make global definitions for the project + +include Makefile.Globals + +# Detect and save the CVS for this makefile + +NAME:= "$Name: not supported by cvs2svn $ " +ifeq ($(NAME), "ame: $ ") + VERSION:= ": Project Version: Unknown " +else + VERSION:= ": Project Version: $(NAME) " +endif + +# Define the target to build + +ALLTARGETS = sysUtils collections image dataManip astronomy + +TARGET_DYNAMIC = libpslib.$(DLL) +TARGET_STATIC = libpslib.a + +# Define the installation targets + +INSTALLTARGETS = installSysUtils installCollections installImage installDataManip installAstronomy + +# Define the clean up targets + +CLEANTARGETS = cleanSysUtils cleanCollections cleanImage cleanDataManip cleanAstronomy + +CLEANDEPTARGETS = cleandepSysUtils cleandepCollections cleandepImage cleandepDataManip cleandepAstronomy + +# Define the distribution clean up targets + +DISTCLEANTARGETS = distcleanSysUtils distcleanCollections distcleanImage distcleanDataManip distcleanAstronomy + +# Define PHONY target "all" which will make all necessary items + +all: $(ALLTARGETS) + $(BUILD_DYNAMIC1) $(TARGET_STATIC) $(BUILD_DYNAMIC2) $(TARGET_DYNAMIC) + @echo "" + @echo " ---- All targets built successfully $(VERSION) ----" + @echo "" + +# Define PHONY target "sysUtils" which will make the system utilites +# portion of the psLib + +sysUtils: + $(MAKE) --directory=sysUtils all + +image: + $(MAKE) --directory=image all + +collections: + $(MAKE) --directory=collections all + +dataManip: + $(MAKE) --directory=dataManip all + +astronomy: + $(MAKE) --directory=astronomy all + +## ADD ADDITIONAL PORTIONS OF PSLIB HERE + +# Define PHONY target "installSysUtils" which will install all the necessary +# files for system utilities portion of psLib + +installSysUtils: + $(MAKE) --directory=sysUtils install + +installImage: + $(MAKE) --directory=image install + +installCollections: + $(MAKE) --directory=collections install + +installDataManip: + $(MAKE) --directory=dataManip install + +installAstronomy: + $(MAKE) --directory=astronomy install + +# Define PHONY target "cleanSysUtils" which will clean up the development +# area for system utilites + +cleanSysUtils: + $(MAKE) --directory=sysUtils clean + +cleanImage: + $(MAKE) --directory=image clean + +cleanCollections: + $(MAKE) --directory=collections clean + +cleanDataManip: + $(MAKE) --directory=dataManip clean + +cleanAstronomy: + $(MAKE) --directory=astronomy clean + +#Define PHONY target "cleandep*" which will clean up the dependency files + +cleandepSysUtils: + $(MAKE) --directory=sysUtils cleandep + +cleandepImage: + $(MAKE) --directory=image cleandep + +cleandepCollections: + $(MAKE) --directory=collections cleandep + +cleandepDataManip: + $(MAKE) --directory=dataManip cleandep + +cleandepAstronomy: + $(MAKE) --directory=astronomy cleandep + +# Define PHONY target "distcleanSysUtils which will clean up the distribution +# files related to system utilities + +distcleanSysUtils: + $(MAKE) --directory=sysUtils distclean + +distcleanImage: + $(MAKE) --directory=image distclean + +distcleanCollections: + $(MAKE) --directory=collections distclean + +distcleanDataManip: + $(MAKE) --directory=dataManip distclean + +distcleanAstronomy: + $(MAKE) --directory=astronomy distclean + + +# Rule to make include directory if needed + +$(includedir): + mkdir -p $(includedir) + +# Rule to make bin directory if needed + +$(bindir): + mkdir -p $(bindir) + +# Rule to make lib directory if needed + +$(libexecdir): + mkdir -p $(libexecdir) + +# Rule to make man directory if needed + +$(mandir): + mkdir -p $(mandir) + +$(mandir)/man3: $(mandir) + mkdir -p $(mandir)/man3 + +# Rule to make the installation directories if needed + +installdirs: $(includedir) $(bindir) $(libexecdir) $(mandir) + +# Define PHONY target "install" to make the necessary directories for +# the installation + +install: all installdirs $(INSTALLTARGETS) + install *.h $(includedir) + install $(TARGET_STATIC) $(libexecdir) + install $(TARGET_DYNAMIC) $(libexecdir) + +# Define PHONY target "clean" to clean up the development areas for +# psLib + +clean: $(CLEANTARGETS) + $(RM) -f $(TARGET_STATIC) + $(RM) -f $(TARGET_DYNAMIC) + +cleandep: $(CLEANDEPTARGETS) + +# Define PHONY target "distclean" to clean up the distribution area for +# psLib + +distclean: $(DISTCLEANTARGETS) + $(RM) -f $(libexecdir)/$(TARGET_STATIC) + $(RM) -f $(libexecdir)/$(TARGET_DYNAMIC) + $(RM) -f $(TARGET_DYNAMIC) + $(RM) -f $(TARGET_STATIC) + +# Define PHONY target "docs" to generate the Doxygen files for psLib + +docs: + $(DOCS) + +tags: + cd $(IPPROOT) ; etags `find . \( -name \*.[chy] -o -name \*.cpp \) -print` + +# List of PHONY targets with make file +.PHONY: sysUtils collections image dataManip astronomy Index: /tags/rel2_1/psLib/src/Makefile.Globals =================================================================== --- /tags/rel2_1/psLib/src/Makefile.Globals (revision 1553) +++ /tags/rel2_1/psLib/src/Makefile.Globals (revision 1553) @@ -0,0 +1,100 @@ +################################################################################ +## +## Makefile: Globals +## +## Assumptions: Variable "prefix" already defined +## +## $Revision: 1.18 $ $Name: not supported by cvs2svn $ +## $Date: 2004-08-13 23:47:10 $ +## +## Copyright 2004 Maui High Performance Computing Center, University of Hawaii +## +############################################################################### + +# Determine the operating system and set variable for later conditional use + +ifndef OSTYPE + OSTYPE = $(shell uname -s) +endif + +# Set environment variables for the project's directory structure + +ifndef mandir + export mandir = $(prefix)/man +endif + +ifndef includedir + export includedir = $(prefix)/include +endif + +ifndef testbindir + export testbindir = $(prefix)/testbin +endif + +ifndef bindir + export bindir = $(prefix)/bin +endif + +ifndef libexecdir + export libexecdir = $(prefix)/lib +endif + +ifndef sladir + export sladir = /usr/local/star +endif + +# Set initial value for CFLAGS which will include all OS common flags for GCC + +CFLAGS := -O0 -g2 -Wall -Werror -std=c99 -D_GNU_SOURCE -pipe + +ifdef NO_TRACE +CFLAGS := $(CFLAGS) -DPS_NO_TRACE=1 +endif + +# Set initial value for LDFLAGS which will include all OS common flags for GCC and required libraries. + +SLA_LINK := $(shell $(sladir)/bin/sla_link) +EXTLIBS := -lcfitsio -lgsl -lgslcblas -lfftw3f -L$(sladir)/lib $(SLA_LINK) +LDFLAGS := -g2 -pipe $(EXTLIBS) + +# Define or refine variables for the Linux OS + +ifneq "$(findstring inux,$(OSTYPE))" "" + CFLAGS_RELOC := $(CFLAGS) -fpic + LDFLAGS_SO := $(LDFLAGS) -fpic -shared -ldl + LDFLAGS_DLL := $(LDFLAGS) -fpic -shared + DLL = so + SO = so + DOCS = doxygen Doxyfile + BUILD_DYNAMIC1 = $(CC) $(LDFLAGS_DLL) -Wl,--whole-archive + BUILD_DYNAMIC2 = -Wl,--no-whole-archive -lm -o +endif + +ifneq "$(findstring arwin,$(OSTYPE))" "" + CFLAGS += -Wno-long-double -DDARWIN + CFLAGS_RELOC := $(CFLAGS) + LDFLAGS := $(LDFLAGS) -lmx + LDFLAGS_SO := $(LDFLAGS) -bundle -flat_namespace -undefined suppress + LDFLAGS_DLL := $(LDFLAGS) -dynamiclib + DLL = dylib + SO = bundle + DOCS = + BUILD_DYNAMIC1 = libtool -dynamic + BUILD_DYNAMIC2 = -L/usr/local/star/lib -lm -lmx -lgcc $(EXTLIBS) -lg2c -o +endif + +# Set default for variable CC + +ifndef CC + export CC=cc +endif + +# Set default for variable LD + +ifndef LD + export LD=ld +endif + +# Set list of PHONY targets +.PHONY: all install distclean clean docs tags print_header + Index: /tags/rel2_1/psLib/src/astro/psCoord.c =================================================================== --- /tags/rel2_1/psLib/src/astro/psCoord.c (revision 1553) +++ /tags/rel2_1/psLib/src/astro/psCoord.c (revision 1553) @@ -0,0 +1,453 @@ +/** @file psCoord.c +* +* @brief Contains basic coordinate transformation definitions and operations +* +* This file defines the basic types for astronomical coordinate +* transformation +* +* @ingroup CoordinateTransform +* +* @author George Gusciora, MHPCC +* +* @version $Revision: 1.19 $ $Name: not supported by cvs2svn $ +* @date $Date: 2004-08-13 23:43:29 $ +* +* Copyright 2004 Maui High Performance Computing Center, University of Hawaii +*/ +/******************************************************************************/ +/* INCLUDE FILES */ +/******************************************************************************/ +#include "psType.h" +#include "psImage.h" +#include "psArray.h" +#include "psList.h" +#include "psCoord.h" +#include "psMemory.h" +#include "psAbort.h" +#include "psTime.h" +#include +#include +/******************************************************************************/ +/* DEFINE STATEMENTS */ +/******************************************************************************/ + +// None + +/******************************************************************************/ +/* TYPE DEFINITIONS */ +/******************************************************************************/ + +// None + +/*****************************************************************************/ +/* GLOBAL VARIABLES */ +/*****************************************************************************/ + +// None + +/*****************************************************************************/ +/* FILE STATIC VARIABLES */ +/*****************************************************************************/ + +// None + +/*****************************************************************************/ +/* FUNCTION IMPLEMENTATION - LOCAL */ +/*****************************************************************************/ + +static float p_psCot(float x); +static float p_psArg(float x, float y); + +/****************************************************************************** +XXX: Do this with a macro. + *****************************************************************************/ +float p_psCot(float x) +{ + return (1.0 / atan(x)); +} + +/****************************************************************************** +XXX: Verify this arc tan function. + *****************************************************************************/ +float p_psArg(float x, + float y) +{ + if (x > 0) { + return (atan(y / x)); + } else if ((x == 0) && (y == 0)) { + return (0.5 * M_PI); + } else if ((x == 0) && (y == 0)) { + return (-0.5 * M_PI); + } else if ((x == 0) && (y == 0)) { + return (M_PI + atan(y / x)); + } else if ((x == 0) && (y == 0)) { + return (-M_PI + atan(y / x)); + } + + psAbort(__func__, "Unacceptable range for (p_psArg(%f, %f).\n", x, y); + return (0.0); +} + +/*****************************************************************************/ +/* FUNCTION IMPLEMENTATION - PUBLIC */ +/*****************************************************************************/ +psPlane* psPlaneTransformApply(psPlane* out, + const psPlaneTransform* transform, + const psPlane* coords) +{ + if (out == NULL) { + out = (psPlane* ) psAlloc(sizeof(psPlane)); + } + out->x = transform->x->coeff[0][0] + + (transform->x->coeff[1][0] * coords->x) + + (transform->x->coeff[0][1] * coords->y); + + out->y = transform->y->coeff[0][0] + + (transform->y->coeff[1][0] * coords->x) + + (transform->y->coeff[0][1] * coords->y); + + return (out); +} + +/****************************************************************************** +This transformation takes into account parameters beyond an objects spatial +coordinates: term3 and term4 (magnitude and color). + *****************************************************************************/ +psPlane* psPlaneDistortApply(psPlane* out, + const psPlaneDistort* transform, + const psPlane* coords, + float color, + float magnitude) +{ + if (out == NULL) { + out = (psPlane* ) psAlloc(sizeof(psPlane)); + } + + out->x = transform->x->coeff[0][0][0][0] + + (transform->x->coeff[1][0][0][0] * coords->x) + + (transform->x->coeff[0][1][0][0] * coords->y) + + (transform->x->coeff[0][0][1][0] * color) + + (transform->x->coeff[0][0][0][1] * magnitude); + + out->y = transform->y->coeff[0][0][0][0] + + (transform->y->coeff[1][0][0][0] * coords->x) + + (transform->y->coeff[0][1][0][0] * coords->y) + + (transform->y->coeff[0][0][1][0] * color) + + (transform->y->coeff[0][0][0][1] * magnitude); + + return (out); +} + +/****************************************************************************** +This function prototype has been modified since the SDRS. + *****************************************************************************/ +psSphereTransform* psSphereTransformAlloc(double NPlat, + double Xo, + double xo) +{ + psSphereTransform* tmp = (psSphereTransform* ) psAlloc(sizeof(psSphereTransform)); + + tmp->sinPhi = sin(NPlat); + tmp->cosPhi = cos(NPlat); + tmp->Xo = Xo; + tmp->xo = xo; + + return (tmp); +} + +/****************************************************************************** +This algorithm comes from an email from Gene. I assume (x,y) corresponds to +(r,d) in the sphere coordinates. + +XXX: In Gene's email, there are different variables with similar names (y +and Y) and in the code, there's cos_y, cos_Y, and cos(y). Verify that there +are no typo's. + *****************************************************************************/ +psSphere* psSphereTransformApply(psSphere* out, + const psSphereTransform* transform, + const psSphere* coord) +{ + double sinY = 0.0; + double cosY = 0.0; + double sinX = 0.0; + double cosX = 0.0; + double x = 0.0; + double y = 0.0; + double dx = 0.0; + + if (out == NULL) { + out = (psSphere* ) psAlloc(sizeof(psSphere)); + } + + x = coord->r; + y = coord->d; + dx = x - transform->xo; + sinY = cos(y) * sin(dx) * transform->sinPhi + sin(y) * transform->cosPhi; + cosY = sqrt(1.0 - sinY * sinY); + sinX = (cos(y) * sin(dx) * transform->cosPhi - sin(y) * transform->sinPhi) / cos(y); + cosX = cos(y) * cos(dx) / cos(y); + + out->r = atan2(sinX, cosX) + transform->Xo; + out->d = atan2(sinY, cosY); + + return (out); +} + +psSphereTransform* psSphereTransformICRStoEcliptic(psTime time) +{ + struct tm *tmTime = psTimeToTM(time); + double year = (double)(1900 + tmTime->tm_year); + double T = year / 100.0; + double phi = -23.452294 + 0.013013 * T + 0.000001639 * T * T - 0.000000503 * T * T * T; + double Xo = 0.0; + double xo = 0.0; + + return (psSphereTransformAlloc(phi, Xo, xo)); +} + +psSphereTransform* psSphereTransformEcliptictoICRS(psTime time) +{ + struct tm *tmTime = psTimeToTM(time); + double year = (double)(1900 + tmTime->tm_year); + double T = year / 100.0; + double phi = +23.452294 - 0.013013 * T - 0.000001639 * T * T + 0.000000503 * T * T * T; + double Xo = 0.0; + double xo = 0.0; + + return (psSphereTransformAlloc(phi, Xo, xo)); +} + +psSphereTransform* psSphereTransformICRStoGalatic(void) +{ + return (psSphereTransformAlloc(62.6, 282.25, 33.0)); +} + +psSphereTransform* psSphereTransformGalatictoICRS(void) +{ + return (psSphereTransformAlloc(-62.6, 33.0, 282.25)); +} + +/****************************************************************************** +XXX: Waiting for the definition of the PS_PROJ_PAR projection. +XXX: Waiting for the definition of the PS_PROJ_GLS projection. + *****************************************************************************/ +psPlane* psProject(const psSphere* coord, + const psProjection* projection) +{ + float R = 0.0; + float alpha = 0.0; + psPlane* tmp = (psPlane* ) psAlloc(sizeof(psPlane)); + + if (projection->type == PS_PROJ_TAN) { + R = p_psCot(coord->r) * (180.0 / M_PI); + tmp->x = R * sin(coord->d); + tmp->y = R * cos(coord->d); + + } else if (projection->type == PS_PROJ_SIN) { + R = cos(coord->r) * (180.0 / M_PI); + tmp->x = R * sin(coord->d); + tmp->y = R * cos(coord->d); + + } else if (projection->type == PS_PROJ_CAR) { + tmp->x = coord->d; + tmp->y = coord->r; + + } else if (projection->type == PS_PROJ_MER) { + tmp->x = coord->d; + tmp->y = log(tan(45.0 + (0.5 * coord->r))) * 180.0 / M_PI; + + } else if (projection->type == PS_PROJ_AIT) { + alpha = 1.0 / ((180.0 / M_PI) * sqrt(1.0 + (cos(coord->r) * cos(0.5 * coord->d) * 0.5))); + + tmp->x = 2.0 * alpha * cos(coord->r) * sin(0.5 * coord->d); + tmp->y = alpha * sin(coord->d); + + } else if (projection->type == PS_PROJ_PAR) { + psAbort(__func__, "The projection type PS_PROJ_PAR is undefined.\n"); + + } else if (projection->type == PS_PROJ_GLS) { + psAbort(__func__, "The projection type PS_PROJ_GLS is undefined.\n"); + } + + return (tmp); +} + +/****************************************************************************** +XXX: Waiting for the definition of the PS_PROJ_PAR projection. +XXX: Waiting for the definition of the PS_PROJ_GLS projection. + *****************************************************************************/ +psSphere* psDeproject(const psPlane* coord, + const psProjection* projection) +{ + float R = 0.0; + float chu = 0.0; + float chu1 = 0.0; + float chu2 = 0.0; + psSphere* tmp = (psSphere* ) psAlloc(sizeof(psSphere)); + + if (projection->type == PS_PROJ_TAN) { + R = sqrt((coord->x * coord->x) + (coord->y * coord->y)); + tmp->d = p_psArg(-coord->y, coord->x); + tmp->r = atan(180.0 / (R * M_PI)); + + } else if (projection->type == PS_PROJ_SIN) { + R = sqrt((coord->x * coord->x) + (coord->y * coord->y)); + tmp->d = p_psArg(-coord->y, coord->x); + tmp->r = acos((R * M_PI) / 180.0); + + } else if (projection->type == PS_PROJ_CAR) { + tmp->d = coord->x; + tmp->r = coord->y; + + } else if (projection->type == PS_PROJ_MER) { + tmp->d = coord->x; + tmp->r = (2.0 * atan(exp((coord->y * M_PI / 180.0)))) - 180.0; + + } else if (projection->type == PS_PROJ_AIT) { + chu1 = (coord->x * M_PI) / 720.0; + chu1 *= chu1; + chu2 = (coord->y * M_PI) / 360.0; + chu2 *= chu2; + chu = sqrt(1.0 - chu1 - chu2); + tmp->d = 2.0 * p_psArg((2.0 * chu * chu) - 1.0, (coord->x * chu * M_PI) / 360.0); + tmp->r = asin((coord->y * chu * M_PI) / 180.0); + + } else if (projection->type == PS_PROJ_PAR) { + psAbort(__func__, "The projection type PS_PROJ_PAR is undefined.\n"); + + } else if (projection->type == PS_PROJ_GLS) { + psAbort(__func__, "The projection type PS_PROJ_GLG is undefined.\n"); + } + + return (tmp); +} + +/****************************************************************************** +The basic idea is to project both positions onto the linear plane, with +position1 at the center, then calculate the linear offset between those +projections. + +XXX: Do I need to check for unacceptable transformation parameters? Maybe, + if the points are on the North/South Pole, etc? + +XXX: Do I need to somehow scale this projection? + *****************************************************************************/ +psSphere* psSphereGetOffset(const psSphere* restrict position1, + const psSphere* restrict position2, + psSphereOffsetMode mode, + psSphereOffsetUnit unit) +{ + psPlane* lin; + psProjection proj; + psSphere* tmp; + double tmpR = 0.0; + double tmpD = 0.0; + + if (mode == PS_LINEAR) { + proj.R = position1->r; + proj.D = position1->d; + proj.Xs = 1.0; + proj.Ys = 1.0; + proj.type = PS_PROJ_TAN; + + lin = psProject(position2, &proj); + tmp = psDeproject(lin, &proj); + psFree(lin); + + // XXX: Do we need to convert units in tmp? + return (tmp); + } else if (mode == PS_SPHERICAL) { + tmpR = position2->r - position1->r; + tmpD = position2->d - position1->d; + + if (unit == PS_ARCSEC) { + tmpR = (tmpR * 180.0 * 60.0 * 60.0) / M_PI; + tmpD = (tmpR * 180.0 * 60.0 * 60.0) / M_PI; + } else if (unit == PS_ARCMIN) { + tmpR = (tmpR * 180.0 * 60.0) / M_PI; + tmpD = (tmpR * 180.0 * 60.0) / M_PI; + } else if (unit == PS_DEGREE) { + tmpR = (tmpR * 180.0) / M_PI; + tmpD = (tmpR * 180.0) / M_PI; + } else if (unit == PS_RADIAN) {} + else { + psAbort(__func__, "Unknown offset unit: 0x%x\n", unit); + } + + tmp = (psSphere* ) psAlloc(sizeof(psSphere)); + // XXX: Wrap these to an acceptable range. Is this correct? + tmp->r = fmod(tmpR, 2*M_PI); + tmp->d = fmod(tmpD, 2*M_PI); + tmp->rErr = 0.0; + tmp->dErr = 0.0; + + return (tmp); + } + psAbort(__func__, "Unrecognized offset mode\n"); + return (NULL); +} + +/****************************************************************************** +XXX: Do we need to check for unacceptable transformation parameters? Maybe, + if the points are on the North/South Pole, etc? + +XXX: Do we need to somehow scale this projection? + +XXX: I copied the algorithm from the ADD exactly. + *****************************************************************************/ + +psSphere* psSphereSetOffset(const psSphere* restrict position, + const psSphere* restrict offset, + psSphereOffsetMode mode, + psSphereOffsetUnit unit) +{ + psPlane lin; + psSphere* tmp; + psProjection proj; + double tmpR = 0.0; + double tmpD = 0.0; + + if (mode == PS_LINEAR) { + proj.R = position->r; + proj.D = position->d; + proj.Xs = 1.0; + proj.Ys = 1.0; + proj.type = PS_PROJ_TAN; + + lin.x = offset->r; + lin.y = offset->d; + + tmp = psDeproject(&lin, &proj); + return (tmp); + + } else if (mode == PS_SPHERICAL) { + if (unit == PS_ARCSEC) { + tmpR = (M_PI * offset->r) / (180.0 * 60.0 * 60.0); + tmpD = (M_PI * offset->d) / (180.0 * 60.0 * 60.0); + } else if (unit == PS_ARCMIN) { + tmpR = (M_PI * offset->r) / (180.0 * 60.0); + tmpD = (M_PI * offset->d) / (180.0 * 60.0); + } else if (unit == PS_DEGREE) { + tmpR = (M_PI * offset->r) / (180.0); + tmpD = (M_PI * offset->d) / (180.0); + } else if (unit == PS_RADIAN) { + tmpR = offset->r; + tmpD = offset->d; + } else { + psAbort(__func__, "Unknown offset unit: 0x%x\n", unit); + } + + tmp = (psSphere* ) psAlloc(sizeof(psSphere)); + // XXX: Is this an acceptable way to wrap the angular output? + tmp->r = position->r + tmpR; + tmp->r = fmod(tmp->r, 2.0*M_PI); + tmp->d = position->d + tmpD; + tmp->d = fmod(tmp->d, 2.0*M_PI); + tmp->rErr = 0.0; + tmp->dErr = 0.0; + + return (tmp); + } + psAbort(__func__, "Unrecognized offset mode\n"); + return (NULL); +} Index: /tags/rel2_1/psLib/src/astro/psCoord.h =================================================================== --- /tags/rel2_1/psLib/src/astro/psCoord.h (revision 1553) +++ /tags/rel2_1/psLib/src/astro/psCoord.h (revision 1553) @@ -0,0 +1,298 @@ + +/** @file psCoord.h +* +* @brief Contains basic coordinate transformation definitions and operations +* +* This file defines the basic types for astronomical coordinate +* transformation +* +* @ingroup CoordinateTransform +* +* @author George Gusciora, MHPCC +* +* @version $Revision: 1.14 $ $Name: not supported by cvs2svn $ +* @date $Date: 2004-08-12 01:23:20 $ +* +* Copyright 2004 Maui High Performance Computing Center, University of Hawaii +*/ + +#ifndef PS_COORD_H +#define PS_COORD_H + +#include "psType.h" +#include "psImage.h" +#include "psArray.h" +#include "psList.h" +#include "psFunctions.h" +#include "psTime.h" + +/// @addtogroup CoordinateTransform +/// @{ + +/** Euclidiean Coordinate System. + * + * Both detector and sky positions will be used extensively in the IPP. One + * coordinate system to be used is linear coordinates which conform to + * Euclidean geometry. + * + */ +typedef struct +{ + double x; ///< x position + double y; ///< y position + double xErr; ///< Error in x position + double yErr; ///< Error in y position +} +psPlane; + +/** Angular Coordinate System + * + * Both detector and sky positions will be used extensively in the IPP. One + * coordinate system to be used is angular coordinates for which additional + * care must often be taken in comparison to a euclidiean coordinate system. + * + */ +typedef struct +{ + double r; ///< RA + double d; ///< Dec + double rErr; ///< Error in RA + double dErr; ///< Error in Dec +} +psSphere; + +/** 2D Polynomial Transform + * + * A transform between coordinate systems that consists simply of two 2D + * polynomials to transform both components - the output coordinates depend + * only on the input coordinates and no other quantities of objects at those + * coordinates. + * + */ +typedef struct +{ + psDPolynomial2D* x; ///< 2D polynomial transform of X coordinates + psDPolynomial2D* y; ///< 2D polynomial transform of Y coordinates +} +psPlaneTransform; + +/** 4D Polynomial Transform + * + * A transform between coordinate systems that consists of two 4D polynomials + * in which the output coordinates are also specified to be a function of the + * magnitude and color of the object with the given coordinates. This type of + * coordinate transformation is necessary to represent the (color-dependent) + * optical distortions caused by the atmosphere and camera optics, and the + * possibly effects of charge transfer inefficiency. + * + * The lowest two terms are the x and y axis of the target system. The higher + * two terms may represent magnitude and color terms. + */ +typedef struct +{ + psDPolynomial4D* x; ///< 4D polynomial transform of X coordinates + psDPolynomial4D* y; ///< 4D polynomial transform of Y coordinates +} +psPlaneDistort; + +/** Spherical Transform Definition + * + * We need to be able to convert between ICRS, Galactic and Ecliptic + * coordinates, and potentially between arbitrary spherical coordinate + * systems. All of these basic spherical transformations represent rotations + * of the spherical coordinate reference. We specify a general + * transformation function which takes a structure, psSphereTransform, + * defining the transformation between two spherical coordinate systems + * + */ +typedef struct +{ + double sinPhi; ///< sin of North Pole lattitude + double cosPhi; ///< cos of North Pole lattitude + double Xo; ///< First PT of Ares lon + double xo; ///< First PT of Ares equiv lon +} +psSphereTransform; + +/** Projection type for projection/deprojection + * + * @see psProject, psDeproject + * + */ +typedef enum { + PS_PROJ_TAN, ///< Tangent projection + PS_PROJ_SIN, ///< Sine projection + PS_PROJ_AIT, ///< Aitoff projection + PS_PROJ_PAR, ///< Par projection + PS_PROJ_GLS, ///< GLS projection + PS_PROJ_CAR, ///< CAR projection + PS_PROJ_MER, ///< MER projection + PS_PROJ_NTYPE ///< Number of types; must be last. +} psProjectionType; + +/** Parameter set for projection/deprojection + * + * @see psProject, psDeproject + * + */ +typedef struct +{ + double R; ///< Coordinates of projection center + double D; ///< Coordinates of projection center + double Xs; ///< plate-scale in X direction + double Ys; ///< plate-scale in Y direction + psProjectionType type; ///< Projection type +} +psProjection; + +/** Mode for Offset calculation between two sky positions + * + * @see psSphereGetOffset, psSphereSetOffset + * + */ +typedef enum { + PS_SPHERICAL, ///< offset corresponds to an angular offset + PS_LINEAR ///< offset corresponds to a linear offset +} psSphereOffsetMode; + +/** The units of the offset + * + * @see psSphereGetOffset, psSphereSetOffset + * + */ +typedef enum { + PS_ARCSEC, ///< Arcseconds + PS_ARCMIN, ///< Arcminutes + PS_DEGREE, ///< Degrees + PS_RADIAN ///< Radians +} psSphereOffsetUnit; + +/** Applies the psPlaneTransform transform to a specified coordinate + * + * @return psPlane* resulting coordinate based on transform + */ +psPlane* psPlaneTransformApply( + psPlane* out, ///< a psPlane to recycle. If NULL, a new one is generated. + const psPlaneTransform* transform, ///< the transform to apply + const psPlane* coords ///< the coordinate to apply the transform above. +); + +/** Applies the psPlaneDistort transform to a specified coordinate + * + * @return psPlane* resulting coordinate based on transform + */ +psPlane* psPlaneDistortApply( + psPlane* out, ///< a psPlane to recycle. If NULL, a new one is generated. + const psPlaneDistort* transform, ///< the transform to apply + const psPlane* coords, ///< the coordinate to apply the transform above. + float term3, ///< third term -- maybe magnitude + float term4 ///< forth term -- maybe color +); + +/** Allocator for psSphereTransform + * + * @return psSphereTransform* newly allocated struct + */ +psSphereTransform* psSphereTransformAlloc( + double NPlat, ///< north pole latitude + double Xo, ///< First PT of Ares lon + double xo ///< First PT of Ares equiv lon +); + +/** Applies the psSphereTransform transform for a specified coordinate + * + * @return psSphere* resulting coordinate based on transform + */ +psSphere* psSphereTransformApply( + psSphere* out, ///< a psSphere to recycle. If NULL, a new one is generated. + const psSphereTransform* transform,///< the transform to apply + const psSphere* coord ///< the coordinate to apply the transform above.x +); + +/** Creates the appropriate transform for converting from ICRS to Ecliptic + * coordinate systems. + * + * @return psSphereTransform* transform for ICRS->Ecliptic coordinate systems + */ +psSphereTransform* psSphereTransformICRStoEcliptic( + psTime time ///< the time for which the resulting transform will be valid +); + +/** Creates the appropriate transform for converting from Ecliptic to ICRS + * coordinate systems. + * + * @return psSphereTransform* transform for Ecliptic->ICRS coordinate systems + */ +psSphereTransform* psSphereTransformEcliptictoICRS( + psTime time ///< the time for which the resulting transform will be valid +); + +/** Creates the appropriate transform for converting from ICRS to Galatic + * coordinate systems. + * + */ +psSphereTransform* psSphereTransformICRStoGalatic(void); + +/** Creates the appropriate transform for converting from Galatic to ICRS + * coordinate systems. + * + */ +psSphereTransform* psSphereTransformGalatictoICRS(void); + +/** Projects a spherical coordinate to a linear coordinate system + * + * @return psPlane* projected coordinate + */ +psPlane* psProject( + const psSphere* coord, ///< coordinate to project + const psProjection* projection ///< parameters of the projection +); + +/** Reverse projection of a linear coordinate to a spherical coordinate system + * + * @return psPlane* projected coordinate + */ +psSphere* psDeproject( + const psPlane* coord, ///< coordinate to project + const psProjection* projection ///< parameters of the projection +); + +/** Determines the offset (RA,Dec) on the sky between two positions. + * + * Both an offset mode and an offset unit may be defined. The mode may be + * either PS_SPHERICAL, in which case the specified offset corresponds to an + * offset in angles, or it may be PS_LINEAR, in which case the offset + * corresponds to a linear offset in a local projection. The offset unit may + * be in one of PS_ARCSEC, PS_ARCMIN, PS_DEGREE, and PS_RADIAN, which + * specifies the units of the offset only. + * + * @return psSphere* the offset between position1 and position2 + */ +psSphere* psSphereGetOffset( + const psSphere* restrict position1, + const psSphere* restrict position2, + psSphereOffsetMode mode, + psSphereOffsetUnit unit +); + +/** Applies the given offset to a coordinate. + * + * Both an offset mode and an offset unit may be defined. The mode may be + * either PS_SPHERICAL, in which case the specified offset corresponds to an + * offset in angles, or it may be PS_LINEAR, in which case the offset + * corresponds to a linear offset in a local projection. The offset unit may + * be in one of PS_ARCSEC, PS_ARCMIN, PS_DEGREE, and PS_RADIAN, which + * specifies the units of the offset only. + * + * @return psSphere* the given position with the given offset applied. + */ +psSphere* psSphereSetOffset( + const psSphere* restrict position, + const psSphere* restrict offset, + psSphereOffsetMode mode, + psSphereOffsetUnit unit +); + +/// @} + +#endif Index: /tags/rel2_1/psLib/src/astro/psTime.c =================================================================== --- /tags/rel2_1/psLib/src/astro/psTime.c (revision 1553) +++ /tags/rel2_1/psLib/src/astro/psTime.c (revision 1553) @@ -0,0 +1,549 @@ + +/** @file psTime.c + * + * @brief Definitions for time, time utilities, and conversion functions for use with psLib astronomy + * functions. + * + * A collection of functions are required by psLib to manipulate time data. These functions primarily consist + * of conversions between specific time formats. PSLib currently uses the UNIX timeval time system as the + * base upon which International Atomic Time (TAI) time is calculated. TAI time varies over time due to the + * earth's rotation and the movement of the continental plates. It is currentls 32 seconds faster than + * UTC/timeval time. + * + * @author Ross Harman, MHPCC + * + * @version $Revision: 1.15 $ $Name: not supported by cvs2svn $ + * @date $Date: 2004-08-13 23:47:10 $ + * + * Copyright 2004 Maui High Performance Computing Center, University of Hawaii + */ + +/******************************************************************************/ + +/* INCLUDE FILES */ + +/******************************************************************************/ + +#include +#include +#include + +#include "psTime.h" +#include "psError.h" +#include "psMemory.h" + +/******************************************************************************/ + +/* DEFINE STATEMENTS */ + +/******************************************************************************/ + +/** Number of available leapsecond updates */ +#define NUM_LEAPSECOND_UPDATES 23 + +/** Maximum length of time string */ +#define MAX_TIME_STRING_LENGTH 256 + +/** Seconds per minute */ +#define SEC_PER_MINUTE 60.0 + +/** Seconds per hour */ +#define SEC_PER_HOUR (60.0*SEC_PER_MINUTE) + +/** Seconds per day */ +#define SEC_PER_DAY (24.0*SEC_PER_HOUR) + +/** Seconds per year */ +#define SEC_PER_YEAR (365.0*SEC_PER_DAY) + +/** Microseconds per day */ +#define USEC_PER_DAY 86400000000.0 + +/** Preprocessor macro to generate error for negative time in struct */ +#define CHECK_NEGATIVE_TIME_STRUCT(NAME,RETURN) \ +if(NAME.tv_sec < 0) { \ + psError(__func__,"Negative seconds are not allowed: %ld", NAME.tv_sec); \ + return RETURN; \ +} else if(NAME.tv_usec<0) { \ + psError(__func__,"Negative microseconds are not allowed: %ld", NAME.tv_usec); \ + return RETURN; \ +} + +/** Preprocessor macro to generate error for negative time */ +#define CHECK_NEGATIVE_TIME(NAME,RETURN) \ +if(NAME < 0.0) { \ + psError(__func__,"Negative time is not allowed: %f", NAME); \ + return RETURN; \ +} \ + + +/******************************************************************************/ + +/* TYPE DEFINITIONS */ + +/******************************************************************************/ + +// None + +/*****************************************************************************/ + +/* GLOBAL VARIABLES */ + +/*****************************************************************************/ + +// None + +/*****************************************************************************/ + +/* FILE STATIC VARIABLES */ + +/*****************************************************************************/ + +/* The table below comes from http://tycho.usno.navy.mil/leapsec.html, which reports the current state of +the TAI/UTC leapsecond conversion times. This table is placed into a two dimensional array and used by +the psTimeGetTime() function to calculate TAI time from UTC time. + + 1972 JAN 1 = JD 2441317.5 TAI-UTC = 10.0 + 1972 JUL 1 = JD 2441499.5 TAI-UTC = 11.0 + 1973 JAN 1 = JD 2441683.5 TAI-UTC = 12.0 + 1974 JAN 1 = JD 2442048.5 TAI-UTC = 13.0 + 1975 JAN 1 = JD 2442413.5 TAI-UTC = 14.0 + 1976 JAN 1 = JD 2442778.5 TAI-UTC = 15.0 + 1977 JAN 1 = JD 2443144.5 TAI-UTC = 16.0 + 1978 JAN 1 = JD 2443509.5 TAI-UTC = 17.0 + 1979 JAN 1 = JD 2443874.5 TAI-UTC = 18.0 + 1980 JAN 1 = JD 2444239.5 TAI-UTC = 19.0 + 1981 JUL 1 = JD 2444786.5 TAI-UTC = 20.0 + 1982 JUL 1 = JD 2445151.5 TAI-UTC = 21.0 + 1983 JUL 1 = JD 2445516.5 TAI-UTC = 22.0 + 1985 JUL 1 = JD 2446247.5 TAI-UTC = 23.0 + 1988 JAN 1 = JD 2447161.5 TAI-UTC = 24.0 + 1990 JAN 1 = JD 2447892.5 TAI-UTC = 25.0 + 1991 JAN 1 = JD 2448257.5 TAI-UTC = 26.0 + 1992 JUL 1 = JD 2448804.5 TAI-UTC = 27.0 + 1993 JUL 1 = JD 2449169.5 TAI-UTC = 28.0 + 1994 JUL 1 = JD 2449534.5 TAI-UTC = 29.0 + 1996 JAN 1 = JD 2450083.5 TAI-UTC = 30.0 + 1997 JUL 1 = JD 2450630.5 TAI-UTC = 31.0 + 1999 JAN 1 = JD 2451179.5 TAI-UTC = 32.0 +*/ + +// Table for Julian date of leapsecond update and current total number of leapseconds at that date +static double leapseconds[NUM_LEAPSECOND_UPDATES][2] = { + { + 2441317.5, 10.0}, + { + 2441499.5, 11.0}, + { + 2441683.5, 12.0}, + { + 2442048.5, 13.0}, + { + 2442413.5, 14.0}, + { + 2442778.5, 15.0}, + { + 2443144.5, 16.0}, + { + 2443509.5, 17.0}, + { + 2443874.5, 18.0}, + { + 2444239.5, 19.0}, + { + 2444786.5, 20.0}, + { + 2445151.5, 21.0}, + { + 2445516.5, 22.0}, + { + 2446247.5, 23.0}, + { + 2447161.5, 24.0}, + { + 2447892.5, 25.0}, + { + 2448257.5, 26.0}, + { + 2448804.5, 27.0}, + { + 2449169.5, 28.0}, + { + 2449534.5, 29.0}, + { + 2450083.5, 30.0}, + { + 2450630.5, 31.0}, + { + 2451179.5, 32.0} + }; + +/*****************************************************************************/ + +/* FUNCTION IMPLEMENTATION - LOCAL */ + +/*****************************************************************************/ + +// None + +/*****************************************************************************/ + +/* FUNCTION IMPLEMENTATION - PUBLIC */ + +/*****************************************************************************/ + +psTime psTimeGetTime(void) +{ + struct timeval now; + psTime time; + + time.tv_sec = 0; + time.tv_usec = 0; + + if (gettimeofday(&now, (struct timezone *)0) == -1) { + psError(__func__, " : Line %d - Failed to get time", __LINE__); + return time; + } + // Convert timeval time to psTime + time.tv_sec = now.tv_sec; + time.tv_usec = now.tv_usec; + + // Add most current leapseconds value to UTC time to get TAI time + time.tv_sec += leapseconds[NUM_LEAPSECOND_UPDATES - 1][1]; + + return time; +} + +char *psTimeToISO(psTime time) +{ + int ms = 0; + char *timeString = NULL; + char *tempString = NULL; + struct tm *tmTime = NULL; + time_t sec; + + CHECK_NEGATIVE_TIME_STRUCT(time, NULL); + + tempString = psAlloc(MAX_TIME_STRING_LENGTH); + timeString = psAlloc(MAX_TIME_STRING_LENGTH); + + // Converts psTime to YYYY/MM/DD,HH:MM:SS.SSS in string form + ms = time.tv_usec / 1000; + + sec = time.tv_sec; + // tmTime variable is statically allocated, no need to free + tmTime = gmtime(&sec); + if (!strftime(tempString, MAX_TIME_STRING_LENGTH, "%Y/%m/%d,%H:%M:%S", tmTime)) { + psError(__func__, " : Line %d - Failed strftime conversion", __LINE__); + } + + if (snprintf(timeString, MAX_TIME_STRING_LENGTH, "%s.%3.3d", tempString, ms) < 0) { + psError(__func__, " : Line %d - Failed snprintf conversion", __LINE__); + } + psFree(tempString); + + return timeString; +} + +psTime psTimeToUTC(psTime time) +{ + int i = 0; + double jd = 0.0; + double ls = 0.0; + double *jdTable = NULL; + psTime outTime; + + CHECK_NEGATIVE_TIME_STRUCT(time, outTime); + + // Find leapseconds to subtract from psTime to get UTC time + jd = psTimeToJD(time); + jdTable = leapseconds[0]; + for (i = 0; i < NUM_LEAPSECOND_UPDATES; i++, jdTable += 2) { + if (jd > *jdTable) { + ls = *(jdTable + 1); + } + } + + outTime.tv_sec = time.tv_sec - ls; + outTime.tv_usec = time.tv_usec; + + CHECK_NEGATIVE_TIME_STRUCT(outTime, outTime); + + return outTime; +} + +double psTimeToMJD(psTime time) +{ + double mjd = 0.0; + + CHECK_NEGATIVE_TIME_STRUCT(time, mjd); + + // Modified Julian date conversion courtesy of Eugene Magnier + mjd = time.tv_sec / SEC_PER_DAY + time.tv_usec / USEC_PER_DAY + 40587.0; + + return mjd; +} + +double psTimeToJD(psTime time) +{ + double jd = 0.0; + + CHECK_NEGATIVE_TIME_STRUCT(time, jd); + + // Julian date conversion courtesy of Eugene Magnier + jd = time.tv_sec / SEC_PER_DAY + time.tv_usec / USEC_PER_DAY + 2440587.5; + + return jd; +} + +struct timeval psTimeToTimeval(psTime time) +{ + struct timeval timevalTime; + + CHECK_NEGATIVE_TIME_STRUCT(time, timevalTime); + timevalTime.tv_sec = time.tv_sec; + timevalTime.tv_usec = time.tv_usec; + + return timevalTime; +} + +struct tm *psTimeToTM(psTime time) +{ + struct tm *tmTime = NULL; + time_t sec; + + CHECK_NEGATIVE_TIME_STRUCT(time, tmTime); + sec = time.tv_sec; + tmTime = gmtime(&sec); + + return tmTime; +} + +psTime psISOToTime(char *time) +{ + char tempString[MAX_TIME_STRING_LENGTH]; + int month; + int day; + int year; + int hour; + int minute; + int second; + int millisecond; + struct tm tmTime; + psTime outTime; + + strncpy(tempString, time, MAX_TIME_STRING_LENGTH); + + // Convert YYYY/MM/DD,HH:MM:SS.SSS in string form to tm time + year = atoi(strtok(tempString, "/")); + if (year < 1900) { + psError(__func__, "Years less than 1900 not allowed. Value: %d", year); + return outTime; + } + + month = atoi(strtok(NULL, "/")); + if (month < 1 || month > 12) { + psError(__func__, "Month must have a value from 1 to 12. Value: %d", month); + return outTime; + } + + day = atoi(strtok(NULL, ",")); + if (day < 1 || day > 31) { + psError(__func__, "Day must have a value from 1 to 31. Value: %d", day); + return outTime; + } + + hour = atoi(strtok(NULL, ":")); + if (hour < 0 || hour > 23) { + psError(__func__, "Hour must have a value from 0 to 23. Value: %d", hour); + return outTime; + } + + minute = atoi(strtok(NULL, ":")); + if (minute < 0 || minute > 59) { + psError(__func__, "Minute must have a value from 0 to 59. Value: %d", minute); + return outTime; + } + + second = atoi(strtok(NULL, ".")); + if (second < 0 || second > 59) { + psError(__func__, "Second must have a value from 0 to 59. Value: %d", second); + return outTime; + } + + millisecond = atoi(strtok(NULL, "X")); + if (millisecond < 0 || millisecond > 1000) { + psError(__func__, "Millisecond must have a value from 0 to 999. Value: %d", millisecond); + return outTime; + } + + tmTime.tm_year = year - 1900; + tmTime.tm_mon = month - 1; + tmTime.tm_mday = day; + tmTime.tm_hour = hour; + tmTime.tm_min = minute; + tmTime.tm_sec = second; + tmTime.tm_isdst = -1; + + // Convert tm time to psTime + outTime = psTMToTime(&tmTime); + outTime.tv_usec = millisecond * 1000; + + return outTime; +} + +psTime psUTCToTime(psTime time) +{ + psTime outTime; + + CHECK_NEGATIVE_TIME_STRUCT(time, outTime); + + // Convert UTC time to psTime/TAI + outTime.tv_sec = time.tv_sec + leapseconds[NUM_LEAPSECOND_UPDATES - 1][1]; + outTime.tv_usec = time.tv_usec; + CHECK_NEGATIVE_TIME_STRUCT(outTime, outTime); + + return outTime; +} + +psTime psMJDToTime(double time) +{ + psTime outTime; + double days = 0.0; + double seconds = 0.0; + + CHECK_NEGATIVE_TIME(time, outTime); + + // Modified Julian date conversion courtesy of Eugene Magnier + days = time - 40587.0; + + // Convert to psTime/TAI + seconds = days * SEC_PER_DAY; + outTime.tv_usec = (seconds - (long)seconds) * 1000000.0; + outTime.tv_sec = seconds; + + CHECK_NEGATIVE_TIME_STRUCT(outTime, outTime); + + return outTime; +} + +psTime psJDToTime(double time) +{ + double days = 0.0; + double seconds = 0.0; + psTime outTime; + + CHECK_NEGATIVE_TIME(time, outTime); + + // Julian date conversion courtesy of Eugene Magnier + days = time - 2440587.5; + + // Convert to psTime/TAI + seconds = days * SEC_PER_DAY; + outTime.tv_sec = seconds; + outTime.tv_usec = (seconds - (long)seconds) * 1000000.0; + + CHECK_NEGATIVE_TIME_STRUCT(outTime, outTime); + + return outTime; +} + +psTime psTimevalToTime(struct timeval * time) +{ + psTime outTime; + + if (time == NULL) + { + psError(__func__, "Null value for timeval arg not allowed"); + return outTime; + } else if (time->tv_sec < 0) + { + psError(__func__, "Negative seconds are not allowed: %ld", time->tv_sec); + return outTime; + } else if (time->tv_usec < 0) + { + psError(__func__, "Negative microseconds are not allowed: %ld", time->tv_usec); + return outTime; + } + // Convert to psTime/TAI + outTime.tv_sec = time->tv_sec; + outTime.tv_usec = time->tv_usec; + + CHECK_NEGATIVE_TIME_STRUCT(outTime, outTime); + + return outTime; +} + +psTime psTMToTime(struct tm * time) +{ + int i; + int n; + int y; + int mon[] = { + 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 + }; + long epoch; + psTime outTime; + + i = 0; + n = 0; + y = 0; + epoch = 0; + + if (time == NULL) + { + psError(__func__, "Null value for tm arg not allowed"); + return outTime; + } else if (time->tm_year < 70) + { + psError(__func__, "Input times earlier than 1970 not allowed. Value: %d", time->tm_year + 1900); + return outTime; + } else if (time->tm_mon < 0 || time->tm_mon > 11) + { + psError(__func__, "Month must have a value from 0 to 11. Value: %d", time->tm_mon); + return outTime; + } else if (time->tm_mday < 1 || time->tm_mday > 31) + { + psError(__func__, "Day must have a value from 1 to 31. Value: %d", time->tm_mday); + return outTime; + } else if (time->tm_hour < 0 || time->tm_hour > 23) + { + psError(__func__, "Hour must have a value from 0 to 23. Value: %d", time->tm_hour); + return outTime; + } else if (time->tm_min < 0 || time->tm_min > 59) + { + psError(__func__, "Minute must have a value from 0 to 59. Value: %d", time->tm_min); + return outTime; + } else if (time->tm_sec < 0 || time->tm_sec > 59) + { + psError(__func__, "Second must have a value from 0 to 59. Value: %d", time->tm_sec); + return outTime; + } + + n = time->tm_year + 1900 - 1; + epoch = (time->tm_year - 70) * SEC_PER_YEAR + ((n / 4 - n / 100 + n / 400) - + (1969 / 4 - 1969 / 100 + 1969 / 400)) * SEC_PER_DAY; + + y = time->tm_year + 1900; + + // Adjust for leap years + for (i = 0; i < time->tm_mon; i++) + { + epoch += mon[i] * SEC_PER_DAY; + if (i == 1 && y % 4 == 0 && (y % 100 != 0 || y % 400 == 0)) { + epoch += SEC_PER_DAY; + } + } + + // Add everything + epoch += (time->tm_mday - 1) * SEC_PER_DAY; + epoch += time->tm_hour * SEC_PER_HOUR + time->tm_min * SEC_PER_MINUTE + time->tm_sec; + + // Create psTime + outTime.tv_usec = 0; + outTime.tv_sec = epoch; + + CHECK_NEGATIVE_TIME_STRUCT(outTime, outTime); + + return outTime; +} Index: /tags/rel2_1/psLib/src/astro/psTime.h =================================================================== --- /tags/rel2_1/psLib/src/astro/psTime.h (revision 1553) +++ /tags/rel2_1/psLib/src/astro/psTime.h (revision 1553) @@ -0,0 +1,203 @@ + +/** @file psTime.h + * + * @brief Definitions for time, time utilities, and conversion functions for use with psLib astronomy + * functions. + * + * A collection of functions are required by psLib to manipulate time data. These functions primarily consist + * of conversions between specific time formats. PSLib currently uses the UNIX timeval time system as the + * base upon which International Atomic Time (TAI) time is calculated. All time conversion functions within + * psLib, except those noted, are calculated in terms of TAI time, which is approxinmately 32 seconds faster + * than UTC/timeval. + * + * @author Ross Harman, MHPCC + * + * @version $Revision: 1.12 $ $Name: not supported by cvs2svn $ + * @date $Date: 2004-08-13 22:08:51 $ + * + * Copyright 2004 Maui High Performance Computing Center, University of Hawaii + */ + +#ifndef PSTIME_H +#define PSTIME_H + +#include +#include +#include + +#include "psType.h" + +/// @addtogroup Time +/// @{ + +/******************************************************************************/ + +/* TYPE DEFINITIONS */ + +/******************************************************************************/ + +/** Definition of psTime. + * + * The psTime struct is used by psLib to represent time values critical to + * astronomical calculations. This structure represents a time which is + * equivalent to TAI (International Atomic Time) and is measured in both + * seconds and microseconds. + */ +typedef struct timeval psTime; + +/*****************************************************************************/ + +/* FUNCTION PROTOTYPES */ + +/*****************************************************************************/ + +/** Get current TAI time. + * + * Gets current time from the system clock in correct TAI units. + * + * @return psTime: Struct with current time. + */ + +psTime psTimeGetTime(void); + +/** Convert psTime to ISO time in TAI units. + * + * Converts psTime to a null terminated string in the form of: + * YYYY/MM/DD,HH:MM:SS.SSS. This function assumes the input time already is + * in TAI time and does not add or subtract leapseconds. + * + * @return char*: Pointer null terminated array of chars in ISO time. + */ + +char *psTimeToISO( + psTime time ///< Input time to be converted. +); + +/** Convert psTime to UTC time. + * + * Converts psTime to UTC time in double precision floating point notation. + * The input to this must already be int TAI time. The result from this + * function is not in TAI units, but that of UTC, which does not contain + * leapseconds. + * + * @return psTime: UTC time psTime format. + */ + +psTime psTimeToUTC( + psTime time ///< Input time to be converted. +); + +/** Convert psTime to modified Julian date time. + * + * Converts psTime to modified Julian date (MJD) time. This function assumes + * the input time already is in TAI time and does not add or subtract + * leapseconds. + * + * @return double: Modified Julian Days (MJD) time. + */ +double psTimeToMJD( + psTime time ///< Input time to be converted. +); + +/** Convert psTime to Julian date time. + * + * Converts psTime to Julian date (JD) time. This function assumes the input + * time already is in TAI time and does not add or subtract leapseconds. + * + * @return double: Julian Date (JD) time. + */ +double psTimeToJD( + psTime time ///< Input time to be converted. +); + +/** Convert psTime to timeval time. + * + * Converts psTime to timeval time. This function assumes the input time + * already is in TAI time and does not add or subtract leapseconds. + * + * @return timeval: timeval struct time. + */ +struct timeval psTimeToTimeval( + psTime time ///< Input time to be converted. + ); + +/** Convert psTime to tm time. + * + * Converts psTime to tm time. This function assumes the input time already is in TAI time and does not add or + * subtract leapseconds. + * + * @return tm: tm struct time. + */ +struct tm *psTimeToTM( + psTime time ///< Input time to be converted. + ); + +/** Convert ISO to psTime. + * + * Converts ISO time to psTime. This function assumes the input time already + * is in TAI time and does not add or subtract leapseconds. + * + * @return psTime: time + */ +psTime psISOToTime( + char *time ///< Input time to be converted. +); + +/** Convert UTC to psTime. + * + * Converts UTC time to psTime. This function assumes the input time already + * is in TAI time and add or subtracts the necessary leapseconds. + * + * @return psTime: time in TAI units. + */ +psTime psUTCToTime( + psTime time ///< Input time to be converted. +); + +/** Convert MJD to psTime. + * + * Converts MJD time to psTime. This function assumes the input time already + * is in TAI time and does not add or subtract leapseconds. + * + * @return psTime: time. + */ +psTime psMJDToTime( + double time ///< Input time to be converted. +); + +/** Convert JD to psTime. + * + * Converts JD time to psTime. This function assumes the input time already + * is in TAI time and does not add or subtract leapseconds. + * + * @return psTime: time. + */ +psTime psJDToTime( + double time ///< Input time to be converted. +); + +/** Convert timeval to psTime. + * + * Converts timeval time to psTime. This function assumes the input time + * already is in TAI time and does not add or subtract leapseconds. + * + * @return psTime: time. + */ +psTime psTimevalToTime( + struct timeval *time ///< Input time to be converted. +); + +/** Convert tm time to psTime. + * + * Converts tm time to psTime. This function assumes the input time already + * is in TAI time and does not add or subtract leapseconds. + * + * @return psTime: time. + */ +psTime psTMToTime( + struct tm *time ///< Input time to be converted. +); + +/// @} + +#endif Index: /tags/rel2_1/psLib/src/astronomy/Makefile =================================================================== --- /tags/rel2_1/psLib/src/astronomy/Makefile (revision 1553) +++ /tags/rel2_1/psLib/src/astronomy/Makefile (revision 1553) @@ -0,0 +1,55 @@ +ifndef prefix + export prefix=$(shell cd ../..;pwd) +endif + +TARGET_STATIC = libpslib.a +include ../Makefile.Globals +CFLAGS := $(CFLAGS_RELOC) -I. -I../sysUtils -I../collections -I../dataManip -I.. -I../image + +SRC_OBJS = psTime.o \ + psMetadata.o \ + psCoord.o \ + psAstrometry.o + +OBJS = $(addprefix makedir/,$(SRC_OBJS)) + +all: $(TARGET_STATIC) + +# Rule to make static library + +libpslib.a: $(OBJS) +# The ar option -r is to add/replace object and -s is to create +# a symbol table in the archive + $(AR) rcs ../$@ $(OBJS) + +# Define PHONY target "install" which will install necessary files +install: $(TARGET_STATIC) + install *.h $(includedir) + +# Define PHONY target "distclean" which will cleanup the distribution +distclean: clean + $(RM) ../$(TARGET_STATIC) + +# Define PHONY target "clean" which will cleanup the development area +clean: + @echo " Deleting intermediate files for 'astronomy'" + $(RM) $(OBJS) *.lint $(SRC_OBJS:.o=.i) + +cleandep: + $(RM) $(OBJS:.o=.d) + +%.lint: %.c + splint +posixlib -exportlocal -realcompare $(INCLUDE_GLOBAL) $? > $@; cat $@ + +%.i: %.c + $(CC) -E $(CFLAGS) -o $@ $< + +makedir/%.o: %.c + $(CC) -c $(CFLAGS) -o $@ $< + +makedir/%.d: %.c + $(CC) -MM $(CFLAGS) $< > $@.tmp + sed 's|\($*\)\.o[ :]*|\1.o $@ : |g' $@.tmp > $@ + $(RM) -f $@.tmp + +include $(OBJS:.o=.d) Index: /tags/rel2_1/psLib/src/astronomy/psAstrometry.c =================================================================== --- /tags/rel2_1/psLib/src/astronomy/psAstrometry.c (revision 1553) +++ /tags/rel2_1/psLib/src/astronomy/psAstrometry.c (revision 1553) @@ -0,0 +1,665 @@ +/** @file psAstrometry.c +* +* @brief This file defines the basic types for astronomical coordinate +* transformation +* +* @ingroup AstroImage +* +* @author George Gusciora, MHPCC +* +* @version $Revision: 1.26 $ $Name: not supported by cvs2svn $ +* @date $Date: 2004-08-14 01:51:11 $ +* +* Copyright 2004 Maui High Performance Computing Center, University of Hawaii +*/ +/******************************************************************************/ +/* INCLUDE FILES */ +/******************************************************************************/ +#include +#include "psFunctions.h" +#include "psAstrometry.h" +#include "psMemory.h" +#include "psAbort.h" +#include "slalib.h" +/******************************************************************************/ +/* DEFINE STATEMENTS */ +/******************************************************************************/ + +// None + +/******************************************************************************/ +/* TYPE DEFINITIONS */ +/******************************************************************************/ + +// None + +/*****************************************************************************/ +/* GLOBAL VARIABLES */ +/*****************************************************************************/ + +// None + +/*****************************************************************************/ +/* FILE STATIC VARIABLES */ +/*****************************************************************************/ + +// None + +/*****************************************************************************/ +/* FUNCTION IMPLEMENTATION - LOCAL */ +/*****************************************************************************/ + +void p_psGrommitFree(psGrommit* grommit) +{ + psFree(grommit); +} + +/***************************************************************************** +p_psCheckValidImageCoords(): this is a private function which simply +determines if the supplied x,y coordinates are in the range for the supplied +psImage. + *****************************************************************************/ +int p_psCheckValidImageCoords(double x, + double y, + psImage* tmpImage) +{ + if (tmpImage == NULL) { + return(0); + } + + if ((x < 0.0) || + (x > (double)tmpImage->numCols) || + (y < 0.0) || + (y > (double)tmpImage->numRows)) { + return (0); + } + + return (1); +} + +/***************************************************************************** +p_psIsProjectionLinear(): this is a private function which simply determines +if the supplied psPlaneTransform transform is linear: if any of the +cooefficients of order 2 are higher are non-zero, then it is not linear. + *****************************************************************************/ +int p_psIsProjectionLinear(psPlaneTransform *transform) +{ + int i = 0; + if (transform == NULL) { + psAbort(__func__, "input parameter transform is NULL."); + } + + for (i=2;i<(transform->x->nX);i++) { + if (transform->x->coeff[i][0] != 0.0) { + return(0); + } + } + for (i=2;i<(transform->x->nY);i++) { + if (transform->x->coeff[0][i] != 0.0) { + return(0); + } + } + + for (i=2;i<(transform->y->nX);i++) { + if (transform->y->coeff[i][0] != 0.0) { + return(0); + } + } + for (i=2;i<(transform->y->nY);i++) { + if (transform->y->coeff[0][i] != 0.0) { + return(0); + } + } + + return(1); +} + +/***************************************************************************** +p_psInvertPlaneTransform(transform): : this is a private function which +simply inverts the supplied psPlaneTransform transform. It assumes that +"transform" is linear. + +This program assumes that the inverse of the following linear equations: + X2 = A + (B * X1) + (C * Y1); + Y2 = D + (E * X1) + (F * Y1); +is + Y1 = (Y2 - ((E/B) * X2) - D + ((E*A)/B)) / (F - ((C*E)/B)); + X1 = (Y2 - ((F/C) * X2) - D + ((F*A)/C)) / (E - ((F*B)/C)); +or + X1 = (-D + ((F*A)/C)) / (E - ((F*B)/C)) + + (X2 * -((F/C) / (E - ((F*B)/C)))) + + (Y2 * (1.0 / (E - ((F*B)/C)))); + Y1 = (-D + ((E*A)/B))/(F - ((C*E)/B)) + + (X2 * -((E/B) / (F - ((C*E)/B)))) + + (Y2 * (1.0 / (F - ((C*E)/B)))); + *****************************************************************************/ +psPlaneTransform *p_psInvertPlaneTransform(psPlaneTransform *transform) +{ + double A = transform->x->coeff[0][0]; + double B = transform->x->coeff[1][0]; + double C = transform->x->coeff[0][1]; + double D = transform->y->coeff[0][0]; + double E = transform->y->coeff[1][0]; + double F = transform->y->coeff[0][1]; + + if (transform == NULL) { + psAbort(__func__, "input parameter transform is NULL."); + } + psPlaneTransform *out = psAlloc(sizeof(psPlaneTransform)); + + out->x->coeff[0][0] = -D + ((F*A)/C) / (E - ((F*B)/C)); + out->x->coeff[1][0] = -(F/C) / (E - ((F*B)/C)); + out->x->coeff[0][1] = 1.0 / (E - ((F*B)/C)); + out->y->coeff[0][0] = -D + ((E*A)/B) / (F - ((C*E)/B)); + out->y->coeff[1][0] = -(E/B) / (F - ((C*E)/B)); + out->y->coeff[0][1] = 1.0 / (F - ((C*E)/B)); + + return(out); +} + +/*****************************************************************************/ +/* FUNCTION IMPLEMENTATION - PUBLIC */ +/*****************************************************************************/ +psExposure* psExposureAlloc(double ra, double dec, double hourAngle, + double zenith, double azimuth, double localTime, float date, + float rotAngle, float temperature, float pressure, float humidity, + float exposureTime) +{ + psExposure* exp = psAlloc(sizeof(psExposure)); + + *(double *)&exp->ra = ra; + *(double *)&exp->dec = dec; + *(double *)&exp->hourAngle = hourAngle; + *(double *)&exp->zenith = zenith; + *(double *)&exp->azimuth = azimuth; + *(double *)&exp->localTime = localTime; + *(float *)&exp->date = date; + *(float *)&exp->rotAngle = rotAngle; + *(float *)&exp->temperature = temperature; + *(float *)&exp->pressure = pressure; + *(float *)&exp->humidity = humidity; + *(float *)&exp->exposureTime = exposureTime; + + return exp; +} +#define TBD 0.0 +/***************************************************************************** +XXX: Several of the input params to sla_aoppa() are currently undefined. +We are awaiting futher direction from IfA on this. + *****************************************************************************/ +psGrommit* psGrommitAlloc(const psExposure* exp) +{ + if (exp == NULL) { + psAbort(__func__, "the 'exp' parameter is NULL\n"); + } + + double date = TBD; // "mjd" in psExposure will become a psTime + // from which it will be possible to get UTC. + double dut = 0.0; + double elongm = TBD; + double phim = TBD; + double hm = TBD; + double xp = 0.0; + double yp = 0.0; + double tdk = exp->temperature; + double pmb = exp->pressure; + double rh = exp->humidity; + double wl = exp->wavelength; + double tlr = TBD; + double *AOPRMS = NULL; + + slaAoppa(date, dut, elongm, phim, hm, xp, yp, + tdk, pmb, rh, wl, tlr, AOPRMS); + + psGrommit* grommit = (psGrommit* ) psAlloc(sizeof(psGrommit)); + *(double *)&grommit->latitude = AOPRMS[0]; + *(double *)&grommit->sinLat = AOPRMS[1]; + *(double *)&grommit->cosLat = AOPRMS[2]; + *(double *)&grommit->height = AOPRMS[3]; + *(double *)&grommit->abberationMag = AOPRMS[4]; + *(double *)&grommit->temperature = AOPRMS[5]; + *(double *)&grommit->pressure = AOPRMS[6]; + *(double *)&grommit->humidity = AOPRMS[7]; + *(double *)&grommit->wavelength = AOPRMS[8]; + *(double *)&grommit->lapseRate = AOPRMS[9]; + *(double *)&grommit->refractA = AOPRMS[10]; + *(double *)&grommit->refractB = AOPRMS[11]; + *(double *)&grommit->longitudeOffset = AOPRMS[12]; + *(double *)&grommit->siderealTime = AOPRMS[13]; + + return (grommit); +} + +psCell* psCellInFPA(const psPlane* fpaCoord, + const psFPA* FPA) +{ + psChip* tmpChip = NULL; + psPlane* chipCoord = NULL; + psCell* outCell = NULL; + + if (fpaCoord == NULL) { + psAbort(__func__, "input parameter fpaCoord is NULL."); + } + if (FPA == NULL) { + psAbort(__func__, "input parameter FPA is NULL."); + } + + // Determine which chip contains the fpaCoords. + tmpChip = psChipInFPA(fpaCoord, FPA); + + // Convert to those chip coordinates. + chipCoord = psCoordFPAToChip(chipCoord, fpaCoord, tmpChip); + + // Determine which cell contains those chip coordinates. + outCell = psCellInChip(chipCoord, tmpChip); + + psFree(tmpChip); + psFree(chipCoord); + + return (outCell); +} + +psChip* psChipInFPA(const psPlane* fpaCoord, + const psFPA* FPA) +{ + psArray* chips = FPA->chips; + int nChips = chips->n; + psPlane* chipCoord = NULL; + psCell *tmpCell = NULL; + + if (fpaCoord == NULL) { + psAbort(__func__, "input parameter fpaCoord is NULL."); + } + if (FPA == NULL) { + psAbort(__func__, "input parameter FPA is NULL."); + } + + // Loop through every chip in this FPA. Convert the original + // FPA coordinates to chip coordinates for that chip. Then, + // determine if any cells in that chip contain those chip + // coordinates. + for (int i = 0; i < nChips; i++) { + psChip* tmpChip = chips->data[i]; + chipCoord = psPlaneTransformApply(chipCoord, tmpChip->fromFPA, + fpaCoord); + + tmpCell = psCellInChip(chipCoord, tmpChip); + if (tmpCell != NULL) { + psFree(chipCoord); + return(tmpChip); + } + psFree(chipCoord); + } + + return (NULL); +} + +psCell* psCellInChip(const psPlane* chipCoord, + const psChip* chip) +{ + psPlane* cellCoord = NULL; + psArray* cells; + + // We return NULL if either of the input parameters is NULL. + if (chipCoord == NULL) { + psAbort(__func__, "the 'chipCoord' parameter is NULL\n"); + } + if (chip == NULL) { + psAbort(__func__, "the 'chip' parameter is NULL\n"); + } + + cells = chip->cells; + if (cells == NULL) { + return NULL; + } + + // We loop over each cell in the chip. We transform the chipCoord into + // a cellCoord for that cell and determine if that cellCoord is valid. + // If so, then we return that cell. + for (int i = 0; i < cells->n; i++) { + psCell* tmpCell = (psCell* ) cells->data[i]; + psArray* readouts = tmpCell->readouts; + + if (readouts != NULL) { + for (int j = 0; j < readouts->n; j++) { + psReadout* tmpReadout = readouts->data[j]; + + cellCoord = psPlaneTransformApply(cellCoord, + tmpCell->fromChip, + chipCoord); + + if (p_psCheckValidImageCoords(cellCoord->x, + cellCoord->y, + tmpReadout->image)) { + psFree(cellCoord); + return (tmpCell); + } + } + } + } + + psFree(cellCoord); + return (NULL); +} + +psPlane* psCoordCellToChip(psPlane* outCoord, + const psPlane* inCoord, + const psCell* cell) +{ + if (inCoord == NULL) { + psAbort(__func__, "input parameter inCoord is NULL."); + } + if (cell == NULL) { + psAbort(__func__, "input parameter cell is NULL."); + } + + return (psPlaneTransformApply(outCoord, cell->toChip, inCoord)); +} + +psPlane* psCoordChipToFPA(psPlane* outCoord, + const psPlane* inCoord, + const psChip* chip) +{ + if (inCoord == NULL) { + psAbort(__func__, "input parameter inCoord is NULL."); + } + if (chip == NULL) { + psAbort(__func__, "input parameter chip is NULL."); + } + + return (psPlaneTransformApply(outCoord, chip->toFPA, inCoord)); +} + +psPlane* psCoordFPAToTP(psPlane* outCoord, + const psPlane* inCoord, + double color, + double magnitude, + const psFPA* fpa) +{ + if (inCoord == NULL) { + psAbort(__func__, "input parameter inCoord is NULL."); + } + if (fpa == NULL) { + psAbort(__func__, "input parameter fpa is NULL."); + } + + return(psPlaneDistortApply(outCoord, fpa->toTangentPlane, inCoord, + color, magnitude)); +} + +/***************************************************************************** +XXX: What about units for the (x,y) coords? + *****************************************************************************/ +psSphere* psCoordTPToSky(psSphere* outSphere, + const psPlane* tpCoord, + const psGrommit* grommit) +{ + double AOB = 0.0; + double ZOB = 0.0; + double HOB = 0.0; + + if (tpCoord == NULL) { + psAbort(__func__, "input parameter tpCoord is NULL."); + } + if (grommit == NULL) { + psAbort(__func__, "input parameter grommit is NULL."); + } + if (outSphere == NULL) { + outSphere = (psSphere* ) psAlloc(sizeof(psSphere)); + } + + slaAopqk(tpCoord->x, tpCoord->y, (double *) grommit, + &AOB, &ZOB, &HOB, &outSphere->r, &outSphere->d); + + return (outSphere); +} + +psPlane* psCoordCellToFPA(psPlane* fpaCoord, + const psPlane* cellCoord, + const psCell* cell) +{ + if (cellCoord == NULL) { + psAbort(__func__, "input parameter cellCoord is NULL."); + } + if (cell == NULL) { + psAbort(__func__, "input parameter cell is NULL."); + } + + return (psPlaneTransformApply(fpaCoord, cell->toFPA, cellCoord)); +} + +psSphere* psCoordCellToSky(psSphere* skyCoord, + const psPlane* cellCoord, + double color, + double magnitude, + const psCell* cell) +{ + if (cellCoord == NULL) { + psAbort(__func__, "input parameter cellCoord is NULL."); + } + if (cell == NULL) { + psAbort(__func__, "input parameter cell is NULL."); + } + + psPlane* fpaCoord = NULL; + psPlane* tpCoord = NULL; + psFPA* parFPA = (cell->parent)->parent; + psGrommit* tmpGrommit = NULL; + + // Convert the input cell coordinates to FPA coordinates. + fpaCoord = psPlaneTransformApply(fpaCoord, cell->toFPA, cellCoord); + + // Convert the FPA coordinates to tangent plane Coordinates. + tpCoord = psPlaneDistortApply(tpCoord, parFPA->toTangentPlane, + fpaCoord, color, magnitude); + + // Generate a grommit for this FPA. + tmpGrommit = psGrommitAlloc(parFPA->exposure); + + // Convert the tangent plane Coordinates to sky coordinates. + skyCoord = psCoordTPToSky(skyCoord, tpCoord, tmpGrommit); + + psFree(fpaCoord); + psFree(tpCoord); + psFree(tmpGrommit); + + return(skyCoord); +} + +psSphere* psCoordCellToSkyQuick(psSphere* outSphere, + const psPlane* cellCoord, + const psCell* cell) +{ + if (cellCoord == NULL) { + psAbort(__func__, "input parameter cellCoord is NULL."); + } + if (cell == NULL) { + psAbort(__func__, "input parameter cell is NULL."); + } + + psPlane *tpCoord = NULL; + psChip *chip = cell->parent; + psFPA *FPA = chip->parent; + psProjectionType oldProjectionType; + + if (outSphere == NULL) { + outSphere = (psSphere* ) psAlloc(sizeof(psSphere)); + } + + // Determine the tangent plane coordinates. + tpCoord = psPlaneTransformApply(tpCoord, cell->toTP, cellCoord); + + // Save the old projection type and set the new projection type to TAN. + oldProjectionType = FPA->projection->type; + FPA->projection->type = PS_PROJ_TAN; + + // Deproject the tangent plane coordinates a sphere. + outSphere = psDeproject(tpCoord, FPA->projection); + + // Restore old projection type. Free memory. + FPA->projection->type = oldProjectionType; + psFree(tpCoord); + + return (outSphere); +} + +/***************************************************************************** +XXX: What about units for the (x,y) coords? + *****************************************************************************/ +psPlane* psCoordSkyToTP(psPlane* tpCoord, + const psSphere* in, + const psGrommit* grommit) +{ + if (in == NULL) { + psAbort(__func__, "input parameter in is NULL."); + } + if (grommit == NULL) { + psAbort(__func__, "input parameter grommit is NULL."); + } + if (tpCoord == NULL) { + tpCoord = (psPlane* ) psAlloc(sizeof(psPlane)); + } + + slaOapqk("RA", in->r, in->d, (double *) grommit, &tpCoord->x, &tpCoord->y); + + return(tpCoord); +} + + +psPlane* psCoordTPToFPA(psPlane* fpaCoord, + const psPlane* tpCoord, + double color, + double magnitude, + const psFPA* fpa) +{ + if (tpCoord == NULL) { + psAbort(__func__, "input parameter tpCoord is NULL."); + } + if (fpa == NULL) { + psAbort(__func__, "input parameter fpa is NULL."); + } + + return (psPlaneDistortApply(fpaCoord, fpa->fromTangentPlane, + tpCoord, color, magnitude)); +} + +psPlane* psCoordFPAToChip(psPlane* chipCoord, + const psPlane* fpaCoord, + const psChip* chip) +{ + if (fpaCoord == NULL) { + psAbort(__func__, "input parameter fpaCoord is NULL."); + } + if (chip == NULL) { + psAbort(__func__, "input parameter chip is NULL."); + } + + psFPA *FPA = chip->parent; + if (FPA == NULL) { + psAbort(__func__, "chip->parent is NULL"); + } + + chipCoord = psPlaneTransformApply(chipCoord, chip->fromFPA, fpaCoord); + + return(chipCoord); +} + +psPlane* psCoordChipToCell(psPlane* cellCoord, + const psPlane* chipCoord, + const psCell* cell) +{ + if (chipCoord == NULL) { + psAbort(__func__, "input parameter chipCoord is NULL."); + } + if (cell == NULL) { + psAbort(__func__, "input parameter cell is NULL."); + } + + psChip *chip = cell->parent; + if (chip == NULL) { + psAbort(__func__, "cell->parent is NULL"); + } + + cellCoord = psPlaneTransformApply(cellCoord, cell->fromChip, chipCoord); + + return(cellCoord); +} + +psPlane* psCoordSkyToCell(psPlane* cellCoord, + const psSphere* skyCoord, + double color, + double magnitude, + const psCell* cell) +{ + if (skyCoord == NULL) { + psAbort(__func__, "input parameter skyCoord is NULL."); + } + if (cell == NULL) { + psAbort(__func__, "input parameter cell is NULL."); + } + + psChip *parChip = cell->parent; + psFPA *parFPA = parChip->parent; + psGrommit* grommit = parFPA->grommit; + + // Convert the skyCoords to tangent plane coords. + psPlane *tpCoord = psCoordSkyToTP(tpCoord, skyCoord, grommit); + + // Convert the tangent plane coords to FPA coords. + psPlane *fpaCoord = psCoordTPToFPA(fpaCoord, tpCoord, color, + magnitude, parFPA); + + // Convert the FPA coords to chip coords. + psPlane *chipCoord = psCoordFPAToChip(chipCoord, fpaCoord, parChip); + + // Convert the chip coords to cell coords. + cellCoord = psCoordChipToCell(cellCoord, chipCoord, cell); + + psFree(tpCoord); + psFree(fpaCoord); + psFree(chipCoord); + + return (cellCoord); +} + +psPlane* psCoordSkyToCellQuick(psPlane* cellCoord, + const psSphere* skyCoord, + const psCell* cell) +{ + if (skyCoord == NULL) { + psAbort(__func__, "input parameter skyCoord is NULL."); + } + if (cell == NULL) { + psAbort(__func__, "input parameter cell is NULL."); + } + + psPlane *tpCoord = NULL; + psChip *whichChip = cell->parent; + psFPA *whichFPA = whichChip->parent; + psProjectionType oldProjectionType; + psPlaneTransform *TPtoCell = NULL; + + // Save the old projection type and set the new projection type to TAN. + oldProjectionType = whichFPA->projection->type; + whichFPA->projection->type = PS_PROJ_TAN; + + if (cellCoord == NULL) { + cellCoord = (psPlane* ) psAlloc(sizeof(psPlane)); + } + + tpCoord = psProject(skyCoord, whichFPA->projection); + + // generate an error if cell->toTP is not linear. + if (0 == p_psIsProjectionLinear(cell->toTP)) { + psAbort(__func__, "the cell->toTP transfrom is not linear.\n"); + } + + TPtoCell = p_psInvertPlaneTransform(cell->toTP); + cellCoord = psPlaneTransformApply(cellCoord, TPtoCell, tpCoord); + + // Restore old projection type. Free memory. + whichFPA->projection->type = oldProjectionType; + psFree(tpCoord); + return (cellCoord); +} + Index: /tags/rel2_1/psLib/src/astronomy/psAstrometry.h =================================================================== --- /tags/rel2_1/psLib/src/astronomy/psAstrometry.h (revision 1553) +++ /tags/rel2_1/psLib/src/astronomy/psAstrometry.h (revision 1553) @@ -0,0 +1,422 @@ +/** @file psAstrometry.h +* +* @brief This file defines the basic types for astronomical coordinate +* transformation +* +* @ingroup AstroImage +* +* @author George Gusciora, MHPCC +* +* @version $Revision: 1.22 $ $Name: not supported by cvs2svn $ +* @date $Date: 2004-08-13 22:41:24 $ +* +* Copyright 2004 Maui High Performance Computing Center, University of Hawaii +*/ + +#ifndef PS_ASTROMETRY_H +#define PS_ASTROMETRY_H + +#include "psType.h" +#include "psImage.h" +#include "psArray.h" +#include "psList.h" +#include "psFunctions.h" +#include "psMetadata.h" +#include "psCoord.h" +#include "psPhotometry.h" + +struct psCell; +struct psChip; +struct psFPA; +struct psExposure; + +/// @addtogroup AstroImage +/// @{ + +/** Wallace's Grommit + * + * SLALib requires several elements to perform the transformations between + * the tangent plane and the sky. Pre-computing these quantities for each + * exposure means that subsequent transformations are faster. For historical + * reasons, this structure is known colloquially as "Wallace's Grommit". + * + */ +typedef struct +{ + const double latitude; ///< geodetic latitude (radians) + const double sinLat; ///< sine of geodetic latitude + const double cosLat; ///< cosine of geodetic latitude + const double abberationMag; ///< magnitude of diurnal aberration vector + const double height; ///< height (HM) + const double temperature; ///< ambient temperature (TDK) + const double pressure; ///< pressure (PMB) + const double humidity; ///< relative humidity (RH) + const double wavelength; ///< wavelength (WL) + const double lapseRate; ///< lapse rate (TLR) + const double refractA; ///< refraction constant A (radians) + const double refractB; ///< refraction constant B (radians) + const double longitudeOffset; ///< longitude + ... (radians) + const double siderealTime; ///< local apparent sidereal time (radians) +} +psGrommit; + +/** Fixed Pattern Corrections + * + * The fixed pattern is a correction to the general astrometric solution + * formed by summing the residuals from many observations. The intent is to + * correct for higher-order distortions in the camera system on a coarse + * grid (larger than individual pixels, but smaller than a single cell). + * Hence, in addition to the offsets, we need to specify the size and scale + * of the grid in x and y as well as the origin of the grid. + */ +typedef struct +{ + int nX; ///< Number of elements in x direction + int nY; ///< Number of elements in y direction + double x0; ///< X Position of 0,0 corner on focal plane + double y0; ///< Y Position of 0,0 corner on focal plane + double xScale; ///< Scale of the grid in x direction + double yScale; ///< Scale of the grid in x direction + double **x; ///< The grid of offsets in x + double **y; ///< The grid of offsets in y +} +psFixedPattern; + +/** Readout data structure. + * + * A readout is the result of a single read of a cell (or a portion thereof). + * It contains a pointer to the pixel data, and additional pointers to the + * objects found in the readout, and the readout metadata. It also contains + * the offset from the lower-left corner of the chip, in the case that the + * CCD was windowed. + * + */ +typedef struct +{ + const unsigned int colBins; ///< Amount of binning in x-dimension + const unsigned int rowBins; ///< Amount of binning in y-dimension + const int col0; ///< Offset from the left of chip. + const int row0; ///< Offset from the bottom of chip. + + psImage* image; ///< imaging area of Readout + psList* objects; ///< objects derived from Readout + psMetadata* metadata; ///< readout-level metadata +} +psReadout; + +/** Cell data structure + * + * A cell consists of one or more readouts. It also contains a pointer to the + * cell's metadata, and its parent chip. On the astrometry side, it also + * contains coordinate transforms from the cell to chip, from the cell to + * focal-plane, as well as a "quick and dirty" tranform from the cell to + * sky coordinates. + * + */ +typedef struct psCell +{ + psArray* readouts; ///< readouts from the cell + psMetadata* metadata; ///< cell-level metadata + + psPlaneTransform* toChip; ///< transformations from cell to chip coordinates + psPlaneTransform* fromChip; ///< transformations from chip to cell coordinates + psPlaneTransform* toFPA; ///< transformations from cell to FPA coordinates + psPlaneTransform* toTP; ///< transformations from cell to tangent plane coordinates + + struct psChip* parent; ///< chip in which contains this cell +} +psCell; + +/** Chip data structure + * + * A chip consists of one or more cells (according to the number of amplifiers + * on the CCD). It contains a pointer to the chip's metadata, and a pointer + * to the parent focal plane. For astrometry, it contains a coordinate + * transform from the chip to the focal plane, and vis-versa. + * + */ +typedef struct psChip +{ + psArray* cells; ///< cells in the chip + psMetadata* metadata; ///< chip-level metadata + + psPlaneTransform* toFPA; ///< transformation from chip to FPA coordinates + psPlaneTransform* fromFPA; ///< transformation from FPA to chip coordinates + + struct psFPA* parent; ///< FPA which contains this chip +} +psChip; + +/** A Focal-Plane + * + * A focal plane consists of one or more chips (according to the number of + * contiguous silicon). It contains pointers to the focal-plane's metadata + * and the exposure information. For astrometry, it contains a transformation + * from the focal plane to the tangent plane and the fixed pattern residuals. + * Since colors are involved in the transformation, it is necessary to specify + * the color the transformation is defined. We also include some values to + * characterize the quality of the transformation: the root square deviation + * for the x and y transformation fits, and the chi-squared for the + * transformation fit. + * + */ +typedef struct psFPA +{ + psArray* chips; ///< chips in the focal plane array + psMetadata* metadata; ///< focal-plane's metadata + + psPlaneDistort* fromTangentPlane; ///< transformation from tangent plane to focal plane + psPlaneDistort* toTangentPlane; ///< transformation from focal plane to tangent plane + psFixedPattern* pattern; ///< fixed pattern residual offsets + + const struct psExposure* exposure; ///< information about this exposure + psGrommit *grommit; ///< Wallace's grommit + + psPhotSystem* colorPlus; ///< Color reference + psPhotSystem* colorMinus; ///< Color reference + psProjection *projection; ///< projection + + float rmsX; ///< RMS for x transformation fits + float rmsY; ///< RMS for y transformation fits + float chi2; ///< chi^2 of astrometric solution +} +psFPA; + +/** Exposure Information + * + * Several quantities from the telescope in order to make a first guess at + * the astrometric solution. From these quantities, further quantities can + * be derivedand stored for later use. + * + */ +typedef struct psExposure +{ + const double ra; ///< Telescope boresight, right ascention + const double dec; ///< Telescope boresight, declination + const double hourAngle; ///< Hour angle + const double zenith; ///< Zenith distance + const double azimuth; ///< Azimuth + const double localTime; ///< Local Sidereal Time + const float date; ///< Modified Jullian Date of observation + const float rotAngle; ///< Rotator position angle + const float temperature; ///< Air temperature, for estimating refraction + const float pressure; ///< Air pressure, for calculating refraction + const float humidity; ///< Relative humidity, for refraction + const float exposureTime; ///< Exposure time + const double wavelength; ///< Wavelength + + /* Derived quantities */ + const float positionAngle; ///< Position angle + const float parallacticAngle; ///< Parallactic angle + const float airmass; ///< Airmass, calculated from zenith distance + const float parallacticFactor; ///< Parallactic factor + const char *cameraName; ///< name of camera which provided exposure + const char *telescopeName; ///< name of telescope which provided exposure +} +psExposure; + +/** Allocator for psExposure + * + * We need several quantities from the telescope in order to make a first + * guess at the astrometric solution. From these quantities, further + * quantities can be derived and stored for later use. + * + * @return psExposure* new psExposure struct + */ +psExposure* psExposureAlloc( + double ra, ///< Telescope boresight, right ascention + double dec, ///< Telescope boresight, declination + double hourAngle, ///< Hour angle + double zenith, ///< Zenith distance + double azimuth, ///< Azimuth + double localTime, ///< Local Sidereal Time + float date, ///< MJD + float rotAngle, ///< Rotator position angle + float temperature, ///< Temperature + float pressure, ///< Pressure + float humidity, ///< Relative humidity + float exposureTime ///< Exposure time +); + +/** Allocates a Wallace's Grommit structure. + * + * The psGrommit is calculated from telescope information for the particular + * exposure. + * + * @return psGrommit* New grommit structure. + */ +psGrommit* psGrommitAlloc(const psExposure* exp ///< the cooresponding exposure structure. + ); +void p_psGrommitFree(psGrommit *grommit); +psGrommit* psGrommitAlloc( + const psExposure* exp ///< the cooresponding exposure structure. +); + +/** Find cooresponding cell for given FPA coordinate + * + * @return psCell* the cell cooresponding to the coord in FPA + */ +psCell* psCellInFPA( + const psPlane* coord, ///< the coordinate in FPA plane + const psFPA* FPA ///< the FPA to search for the cell +); + +/** Find cooresponding chip for given FPA coordinate + * + * @return psChip* the chip cooresponding to coord + */ +psChip* psChipInFPA( + const psPlane* coord, ///< the coordinate in FPA plane + const psFPA* FPA ///< the FPA to search for the cell +); + +/** Find cooresponding cell for given Chip coordinate + * + * @return psCell* the cell cooresponding to coord + */ +psCell* psCellInChip( + const psPlane* coord, ///< the coordinate in Chip plane + const psChip* chip ///< the chip to search for the cell +); + +/** Translate a cell coordinate into a chip coordinate + * + * @return psPlane* the resulting chip coordinate + */ +psPlane* psCoordCellToChip( + psPlane* out, ///< a plane struct to recycle. If NULL, a new struct is created + const psPlane* in, ///< the coordinate within Cell + const psCell* cell ///< the Cell in interest +); + +/** Translate a chip coordinate into a FPA coordinate + * + * @return psPlane* the resulting FPA coordinate + */ +psPlane* psCoordChipToFPA( + psPlane* out, ///< a plane struct to recycle. If NULL, a new struct is created + const psPlane* in, ///< the coordinate within Chip + const psChip* chip ///< the chip in interest +); + +/** Translate a FPA coordinate into a Tangent Plane coordinate + * + * @return psPlane* the resulting Tangent Plane coordinate + */ +psPlane* psCoordFPAToTP( + psPlane* out, ///< a plane struct to recycle. If NULL, a new struct is created + const psPlane* in, ///< the coordinate within FPA + double color, ///< Color of source + double magnitude, ///< Magnitude of source + const psFPA* fpa ///< the FPA in interest +); + +/** Translate a Tangent Plane coordinate into a Sky coordinate + * + * @return psSphere* the resulting Sky coordinate + */ +psSphere* psCoordTPToSky( + psSphere* out, ///< a sphere struct to recycle. If NULL, a new struct is created + const psPlane* in, ///< the coordinate within Tangent Plane + const psGrommit* grommit ///< the grommit of the tangent plane +); + +/** Translate a cell coordinate into a FPA coordinate + * + * @return psPlane* the resulting FPA coordinate + */ +psPlane* psCoordCellToFPA( + psPlane* out, ///< a plane struct to recycle. If NULL, a new struct is created + const psPlane* in, ///< the coordinate within cell + const psCell* cell ///< the cell in interest +); + +/** Translate a cell coordinate into a Sky coordinate + * + * @return psSphere* the resulting Sky coordinate + */ +psSphere* psCoordCellToSky( + psSphere* out, ///< a sphere struct to recycle. If NULL, a new struct is created + const psPlane* in, ///< the coordinate within cell + double color, ///< Color of source + double magnitude, ///< Magnitude of source + const psCell* cell ///< the cell in interest +); + +/** Translate a cell coordinate into a Sky coordinate using a 'quick and + * dirty' method + * + * @return psSphere* the resulting Sky coordinate + */ +psSphere* psCoordCellToSkyQuick( + psSphere* out, ///< a sphere struct to recycle. If NULL, a new struct is created + const psPlane* in, ///< the coordinate within cell + const psCell* cell ///< the cell in interest +); + +/** Translate a Sky coordinate into a Tangent Plane coordinate + * + * @return psPlane* the resulting Tangent Plane coordinate + */ +psPlane* psCoordSkyToTP( + psPlane* out, ///< a plane struct to recycle. If NULL, a new struct is created + const psSphere* in, ///< the sky coordinate + const psGrommit* grommit ///< the grommit +); + +/** Translate a Tangent Plane coordinate into a FPA coordinate + * + * @return psPlane* the resulting FPA coordinate + */ +psPlane* psCoordTPToFPA( + psPlane* out, ///< a plane struct to recycle. If NULL, a new struct is created + const psPlane* in, ///< the coordinate within tangent plane + double color, ///< Color of source + double magnitude, ///< Magnitude of source + const psFPA* fpa ///< the FPA of interest +); + +/** Translate a FPA coordinate into a chip coordinate + * + * @return psPlane* the resulting chip coordinate + */ +psPlane* psCoordFPAToChip( + psPlane* out, ///< a plane struct to recycle. If NULL, a new struct is created + const psPlane* in, ///< the FPA coordinate + const psChip* chip ///< the chip of interest +); + +/** Translate a chip coordinate into a cell coordinate + * + * @return psPlane* the resulting cell coordinate + */ +psPlane* psCoordChipToCell( + psPlane* out, ///< a plane struct to recycle. If NULL, a new struct is created + const psPlane* in, ///< the Chip coordinate + const psCell* cell ///< the cell of interest +); + +/** Translate a sky coordinate into a cell coordinate + * + * @return psPlane* the resulting cell coordinate + */ +psPlane* psCoordSkyToCell( + psPlane* out, ///< a plane struct to recycle. If NULL, a new struct is created + const psSphere* in, ///< the Sky coordinate + double color, ///< Color of source + double magnitude, ///< Magnitude of source + const psCell* cell ///< the cell of interest +); + +/** Translate a sky coordinate into a cell coordinate using a 'quick and + * dirty' method + * + * @return psPlane* the resulting cell coordinate + */ +psPlane* psCoordSkyToCellQuick( + psPlane* out, ///< a plane struct to recycle. If NULL, a new struct is created + const psSphere* in, ///< the Sky coordinate + const psCell* cell ///< the cell of interest +); + +#endif Index: /tags/rel2_1/psLib/src/astronomy/psCoord.c =================================================================== --- /tags/rel2_1/psLib/src/astronomy/psCoord.c (revision 1553) +++ /tags/rel2_1/psLib/src/astronomy/psCoord.c (revision 1553) @@ -0,0 +1,453 @@ +/** @file psCoord.c +* +* @brief Contains basic coordinate transformation definitions and operations +* +* This file defines the basic types for astronomical coordinate +* transformation +* +* @ingroup CoordinateTransform +* +* @author George Gusciora, MHPCC +* +* @version $Revision: 1.19 $ $Name: not supported by cvs2svn $ +* @date $Date: 2004-08-13 23:43:29 $ +* +* Copyright 2004 Maui High Performance Computing Center, University of Hawaii +*/ +/******************************************************************************/ +/* INCLUDE FILES */ +/******************************************************************************/ +#include "psType.h" +#include "psImage.h" +#include "psArray.h" +#include "psList.h" +#include "psCoord.h" +#include "psMemory.h" +#include "psAbort.h" +#include "psTime.h" +#include +#include +/******************************************************************************/ +/* DEFINE STATEMENTS */ +/******************************************************************************/ + +// None + +/******************************************************************************/ +/* TYPE DEFINITIONS */ +/******************************************************************************/ + +// None + +/*****************************************************************************/ +/* GLOBAL VARIABLES */ +/*****************************************************************************/ + +// None + +/*****************************************************************************/ +/* FILE STATIC VARIABLES */ +/*****************************************************************************/ + +// None + +/*****************************************************************************/ +/* FUNCTION IMPLEMENTATION - LOCAL */ +/*****************************************************************************/ + +static float p_psCot(float x); +static float p_psArg(float x, float y); + +/****************************************************************************** +XXX: Do this with a macro. + *****************************************************************************/ +float p_psCot(float x) +{ + return (1.0 / atan(x)); +} + +/****************************************************************************** +XXX: Verify this arc tan function. + *****************************************************************************/ +float p_psArg(float x, + float y) +{ + if (x > 0) { + return (atan(y / x)); + } else if ((x == 0) && (y == 0)) { + return (0.5 * M_PI); + } else if ((x == 0) && (y == 0)) { + return (-0.5 * M_PI); + } else if ((x == 0) && (y == 0)) { + return (M_PI + atan(y / x)); + } else if ((x == 0) && (y == 0)) { + return (-M_PI + atan(y / x)); + } + + psAbort(__func__, "Unacceptable range for (p_psArg(%f, %f).\n", x, y); + return (0.0); +} + +/*****************************************************************************/ +/* FUNCTION IMPLEMENTATION - PUBLIC */ +/*****************************************************************************/ +psPlane* psPlaneTransformApply(psPlane* out, + const psPlaneTransform* transform, + const psPlane* coords) +{ + if (out == NULL) { + out = (psPlane* ) psAlloc(sizeof(psPlane)); + } + out->x = transform->x->coeff[0][0] + + (transform->x->coeff[1][0] * coords->x) + + (transform->x->coeff[0][1] * coords->y); + + out->y = transform->y->coeff[0][0] + + (transform->y->coeff[1][0] * coords->x) + + (transform->y->coeff[0][1] * coords->y); + + return (out); +} + +/****************************************************************************** +This transformation takes into account parameters beyond an objects spatial +coordinates: term3 and term4 (magnitude and color). + *****************************************************************************/ +psPlane* psPlaneDistortApply(psPlane* out, + const psPlaneDistort* transform, + const psPlane* coords, + float color, + float magnitude) +{ + if (out == NULL) { + out = (psPlane* ) psAlloc(sizeof(psPlane)); + } + + out->x = transform->x->coeff[0][0][0][0] + + (transform->x->coeff[1][0][0][0] * coords->x) + + (transform->x->coeff[0][1][0][0] * coords->y) + + (transform->x->coeff[0][0][1][0] * color) + + (transform->x->coeff[0][0][0][1] * magnitude); + + out->y = transform->y->coeff[0][0][0][0] + + (transform->y->coeff[1][0][0][0] * coords->x) + + (transform->y->coeff[0][1][0][0] * coords->y) + + (transform->y->coeff[0][0][1][0] * color) + + (transform->y->coeff[0][0][0][1] * magnitude); + + return (out); +} + +/****************************************************************************** +This function prototype has been modified since the SDRS. + *****************************************************************************/ +psSphereTransform* psSphereTransformAlloc(double NPlat, + double Xo, + double xo) +{ + psSphereTransform* tmp = (psSphereTransform* ) psAlloc(sizeof(psSphereTransform)); + + tmp->sinPhi = sin(NPlat); + tmp->cosPhi = cos(NPlat); + tmp->Xo = Xo; + tmp->xo = xo; + + return (tmp); +} + +/****************************************************************************** +This algorithm comes from an email from Gene. I assume (x,y) corresponds to +(r,d) in the sphere coordinates. + +XXX: In Gene's email, there are different variables with similar names (y +and Y) and in the code, there's cos_y, cos_Y, and cos(y). Verify that there +are no typo's. + *****************************************************************************/ +psSphere* psSphereTransformApply(psSphere* out, + const psSphereTransform* transform, + const psSphere* coord) +{ + double sinY = 0.0; + double cosY = 0.0; + double sinX = 0.0; + double cosX = 0.0; + double x = 0.0; + double y = 0.0; + double dx = 0.0; + + if (out == NULL) { + out = (psSphere* ) psAlloc(sizeof(psSphere)); + } + + x = coord->r; + y = coord->d; + dx = x - transform->xo; + sinY = cos(y) * sin(dx) * transform->sinPhi + sin(y) * transform->cosPhi; + cosY = sqrt(1.0 - sinY * sinY); + sinX = (cos(y) * sin(dx) * transform->cosPhi - sin(y) * transform->sinPhi) / cos(y); + cosX = cos(y) * cos(dx) / cos(y); + + out->r = atan2(sinX, cosX) + transform->Xo; + out->d = atan2(sinY, cosY); + + return (out); +} + +psSphereTransform* psSphereTransformICRStoEcliptic(psTime time) +{ + struct tm *tmTime = psTimeToTM(time); + double year = (double)(1900 + tmTime->tm_year); + double T = year / 100.0; + double phi = -23.452294 + 0.013013 * T + 0.000001639 * T * T - 0.000000503 * T * T * T; + double Xo = 0.0; + double xo = 0.0; + + return (psSphereTransformAlloc(phi, Xo, xo)); +} + +psSphereTransform* psSphereTransformEcliptictoICRS(psTime time) +{ + struct tm *tmTime = psTimeToTM(time); + double year = (double)(1900 + tmTime->tm_year); + double T = year / 100.0; + double phi = +23.452294 - 0.013013 * T - 0.000001639 * T * T + 0.000000503 * T * T * T; + double Xo = 0.0; + double xo = 0.0; + + return (psSphereTransformAlloc(phi, Xo, xo)); +} + +psSphereTransform* psSphereTransformICRStoGalatic(void) +{ + return (psSphereTransformAlloc(62.6, 282.25, 33.0)); +} + +psSphereTransform* psSphereTransformGalatictoICRS(void) +{ + return (psSphereTransformAlloc(-62.6, 33.0, 282.25)); +} + +/****************************************************************************** +XXX: Waiting for the definition of the PS_PROJ_PAR projection. +XXX: Waiting for the definition of the PS_PROJ_GLS projection. + *****************************************************************************/ +psPlane* psProject(const psSphere* coord, + const psProjection* projection) +{ + float R = 0.0; + float alpha = 0.0; + psPlane* tmp = (psPlane* ) psAlloc(sizeof(psPlane)); + + if (projection->type == PS_PROJ_TAN) { + R = p_psCot(coord->r) * (180.0 / M_PI); + tmp->x = R * sin(coord->d); + tmp->y = R * cos(coord->d); + + } else if (projection->type == PS_PROJ_SIN) { + R = cos(coord->r) * (180.0 / M_PI); + tmp->x = R * sin(coord->d); + tmp->y = R * cos(coord->d); + + } else if (projection->type == PS_PROJ_CAR) { + tmp->x = coord->d; + tmp->y = coord->r; + + } else if (projection->type == PS_PROJ_MER) { + tmp->x = coord->d; + tmp->y = log(tan(45.0 + (0.5 * coord->r))) * 180.0 / M_PI; + + } else if (projection->type == PS_PROJ_AIT) { + alpha = 1.0 / ((180.0 / M_PI) * sqrt(1.0 + (cos(coord->r) * cos(0.5 * coord->d) * 0.5))); + + tmp->x = 2.0 * alpha * cos(coord->r) * sin(0.5 * coord->d); + tmp->y = alpha * sin(coord->d); + + } else if (projection->type == PS_PROJ_PAR) { + psAbort(__func__, "The projection type PS_PROJ_PAR is undefined.\n"); + + } else if (projection->type == PS_PROJ_GLS) { + psAbort(__func__, "The projection type PS_PROJ_GLS is undefined.\n"); + } + + return (tmp); +} + +/****************************************************************************** +XXX: Waiting for the definition of the PS_PROJ_PAR projection. +XXX: Waiting for the definition of the PS_PROJ_GLS projection. + *****************************************************************************/ +psSphere* psDeproject(const psPlane* coord, + const psProjection* projection) +{ + float R = 0.0; + float chu = 0.0; + float chu1 = 0.0; + float chu2 = 0.0; + psSphere* tmp = (psSphere* ) psAlloc(sizeof(psSphere)); + + if (projection->type == PS_PROJ_TAN) { + R = sqrt((coord->x * coord->x) + (coord->y * coord->y)); + tmp->d = p_psArg(-coord->y, coord->x); + tmp->r = atan(180.0 / (R * M_PI)); + + } else if (projection->type == PS_PROJ_SIN) { + R = sqrt((coord->x * coord->x) + (coord->y * coord->y)); + tmp->d = p_psArg(-coord->y, coord->x); + tmp->r = acos((R * M_PI) / 180.0); + + } else if (projection->type == PS_PROJ_CAR) { + tmp->d = coord->x; + tmp->r = coord->y; + + } else if (projection->type == PS_PROJ_MER) { + tmp->d = coord->x; + tmp->r = (2.0 * atan(exp((coord->y * M_PI / 180.0)))) - 180.0; + + } else if (projection->type == PS_PROJ_AIT) { + chu1 = (coord->x * M_PI) / 720.0; + chu1 *= chu1; + chu2 = (coord->y * M_PI) / 360.0; + chu2 *= chu2; + chu = sqrt(1.0 - chu1 - chu2); + tmp->d = 2.0 * p_psArg((2.0 * chu * chu) - 1.0, (coord->x * chu * M_PI) / 360.0); + tmp->r = asin((coord->y * chu * M_PI) / 180.0); + + } else if (projection->type == PS_PROJ_PAR) { + psAbort(__func__, "The projection type PS_PROJ_PAR is undefined.\n"); + + } else if (projection->type == PS_PROJ_GLS) { + psAbort(__func__, "The projection type PS_PROJ_GLG is undefined.\n"); + } + + return (tmp); +} + +/****************************************************************************** +The basic idea is to project both positions onto the linear plane, with +position1 at the center, then calculate the linear offset between those +projections. + +XXX: Do I need to check for unacceptable transformation parameters? Maybe, + if the points are on the North/South Pole, etc? + +XXX: Do I need to somehow scale this projection? + *****************************************************************************/ +psSphere* psSphereGetOffset(const psSphere* restrict position1, + const psSphere* restrict position2, + psSphereOffsetMode mode, + psSphereOffsetUnit unit) +{ + psPlane* lin; + psProjection proj; + psSphere* tmp; + double tmpR = 0.0; + double tmpD = 0.0; + + if (mode == PS_LINEAR) { + proj.R = position1->r; + proj.D = position1->d; + proj.Xs = 1.0; + proj.Ys = 1.0; + proj.type = PS_PROJ_TAN; + + lin = psProject(position2, &proj); + tmp = psDeproject(lin, &proj); + psFree(lin); + + // XXX: Do we need to convert units in tmp? + return (tmp); + } else if (mode == PS_SPHERICAL) { + tmpR = position2->r - position1->r; + tmpD = position2->d - position1->d; + + if (unit == PS_ARCSEC) { + tmpR = (tmpR * 180.0 * 60.0 * 60.0) / M_PI; + tmpD = (tmpR * 180.0 * 60.0 * 60.0) / M_PI; + } else if (unit == PS_ARCMIN) { + tmpR = (tmpR * 180.0 * 60.0) / M_PI; + tmpD = (tmpR * 180.0 * 60.0) / M_PI; + } else if (unit == PS_DEGREE) { + tmpR = (tmpR * 180.0) / M_PI; + tmpD = (tmpR * 180.0) / M_PI; + } else if (unit == PS_RADIAN) {} + else { + psAbort(__func__, "Unknown offset unit: 0x%x\n", unit); + } + + tmp = (psSphere* ) psAlloc(sizeof(psSphere)); + // XXX: Wrap these to an acceptable range. Is this correct? + tmp->r = fmod(tmpR, 2*M_PI); + tmp->d = fmod(tmpD, 2*M_PI); + tmp->rErr = 0.0; + tmp->dErr = 0.0; + + return (tmp); + } + psAbort(__func__, "Unrecognized offset mode\n"); + return (NULL); +} + +/****************************************************************************** +XXX: Do we need to check for unacceptable transformation parameters? Maybe, + if the points are on the North/South Pole, etc? + +XXX: Do we need to somehow scale this projection? + +XXX: I copied the algorithm from the ADD exactly. + *****************************************************************************/ + +psSphere* psSphereSetOffset(const psSphere* restrict position, + const psSphere* restrict offset, + psSphereOffsetMode mode, + psSphereOffsetUnit unit) +{ + psPlane lin; + psSphere* tmp; + psProjection proj; + double tmpR = 0.0; + double tmpD = 0.0; + + if (mode == PS_LINEAR) { + proj.R = position->r; + proj.D = position->d; + proj.Xs = 1.0; + proj.Ys = 1.0; + proj.type = PS_PROJ_TAN; + + lin.x = offset->r; + lin.y = offset->d; + + tmp = psDeproject(&lin, &proj); + return (tmp); + + } else if (mode == PS_SPHERICAL) { + if (unit == PS_ARCSEC) { + tmpR = (M_PI * offset->r) / (180.0 * 60.0 * 60.0); + tmpD = (M_PI * offset->d) / (180.0 * 60.0 * 60.0); + } else if (unit == PS_ARCMIN) { + tmpR = (M_PI * offset->r) / (180.0 * 60.0); + tmpD = (M_PI * offset->d) / (180.0 * 60.0); + } else if (unit == PS_DEGREE) { + tmpR = (M_PI * offset->r) / (180.0); + tmpD = (M_PI * offset->d) / (180.0); + } else if (unit == PS_RADIAN) { + tmpR = offset->r; + tmpD = offset->d; + } else { + psAbort(__func__, "Unknown offset unit: 0x%x\n", unit); + } + + tmp = (psSphere* ) psAlloc(sizeof(psSphere)); + // XXX: Is this an acceptable way to wrap the angular output? + tmp->r = position->r + tmpR; + tmp->r = fmod(tmp->r, 2.0*M_PI); + tmp->d = position->d + tmpD; + tmp->d = fmod(tmp->d, 2.0*M_PI); + tmp->rErr = 0.0; + tmp->dErr = 0.0; + + return (tmp); + } + psAbort(__func__, "Unrecognized offset mode\n"); + return (NULL); +} Index: /tags/rel2_1/psLib/src/astronomy/psCoord.h =================================================================== --- /tags/rel2_1/psLib/src/astronomy/psCoord.h (revision 1553) +++ /tags/rel2_1/psLib/src/astronomy/psCoord.h (revision 1553) @@ -0,0 +1,298 @@ + +/** @file psCoord.h +* +* @brief Contains basic coordinate transformation definitions and operations +* +* This file defines the basic types for astronomical coordinate +* transformation +* +* @ingroup CoordinateTransform +* +* @author George Gusciora, MHPCC +* +* @version $Revision: 1.14 $ $Name: not supported by cvs2svn $ +* @date $Date: 2004-08-12 01:23:20 $ +* +* Copyright 2004 Maui High Performance Computing Center, University of Hawaii +*/ + +#ifndef PS_COORD_H +#define PS_COORD_H + +#include "psType.h" +#include "psImage.h" +#include "psArray.h" +#include "psList.h" +#include "psFunctions.h" +#include "psTime.h" + +/// @addtogroup CoordinateTransform +/// @{ + +/** Euclidiean Coordinate System. + * + * Both detector and sky positions will be used extensively in the IPP. One + * coordinate system to be used is linear coordinates which conform to + * Euclidean geometry. + * + */ +typedef struct +{ + double x; ///< x position + double y; ///< y position + double xErr; ///< Error in x position + double yErr; ///< Error in y position +} +psPlane; + +/** Angular Coordinate System + * + * Both detector and sky positions will be used extensively in the IPP. One + * coordinate system to be used is angular coordinates for which additional + * care must often be taken in comparison to a euclidiean coordinate system. + * + */ +typedef struct +{ + double r; ///< RA + double d; ///< Dec + double rErr; ///< Error in RA + double dErr; ///< Error in Dec +} +psSphere; + +/** 2D Polynomial Transform + * + * A transform between coordinate systems that consists simply of two 2D + * polynomials to transform both components - the output coordinates depend + * only on the input coordinates and no other quantities of objects at those + * coordinates. + * + */ +typedef struct +{ + psDPolynomial2D* x; ///< 2D polynomial transform of X coordinates + psDPolynomial2D* y; ///< 2D polynomial transform of Y coordinates +} +psPlaneTransform; + +/** 4D Polynomial Transform + * + * A transform between coordinate systems that consists of two 4D polynomials + * in which the output coordinates are also specified to be a function of the + * magnitude and color of the object with the given coordinates. This type of + * coordinate transformation is necessary to represent the (color-dependent) + * optical distortions caused by the atmosphere and camera optics, and the + * possibly effects of charge transfer inefficiency. + * + * The lowest two terms are the x and y axis of the target system. The higher + * two terms may represent magnitude and color terms. + */ +typedef struct +{ + psDPolynomial4D* x; ///< 4D polynomial transform of X coordinates + psDPolynomial4D* y; ///< 4D polynomial transform of Y coordinates +} +psPlaneDistort; + +/** Spherical Transform Definition + * + * We need to be able to convert between ICRS, Galactic and Ecliptic + * coordinates, and potentially between arbitrary spherical coordinate + * systems. All of these basic spherical transformations represent rotations + * of the spherical coordinate reference. We specify a general + * transformation function which takes a structure, psSphereTransform, + * defining the transformation between two spherical coordinate systems + * + */ +typedef struct +{ + double sinPhi; ///< sin of North Pole lattitude + double cosPhi; ///< cos of North Pole lattitude + double Xo; ///< First PT of Ares lon + double xo; ///< First PT of Ares equiv lon +} +psSphereTransform; + +/** Projection type for projection/deprojection + * + * @see psProject, psDeproject + * + */ +typedef enum { + PS_PROJ_TAN, ///< Tangent projection + PS_PROJ_SIN, ///< Sine projection + PS_PROJ_AIT, ///< Aitoff projection + PS_PROJ_PAR, ///< Par projection + PS_PROJ_GLS, ///< GLS projection + PS_PROJ_CAR, ///< CAR projection + PS_PROJ_MER, ///< MER projection + PS_PROJ_NTYPE ///< Number of types; must be last. +} psProjectionType; + +/** Parameter set for projection/deprojection + * + * @see psProject, psDeproject + * + */ +typedef struct +{ + double R; ///< Coordinates of projection center + double D; ///< Coordinates of projection center + double Xs; ///< plate-scale in X direction + double Ys; ///< plate-scale in Y direction + psProjectionType type; ///< Projection type +} +psProjection; + +/** Mode for Offset calculation between two sky positions + * + * @see psSphereGetOffset, psSphereSetOffset + * + */ +typedef enum { + PS_SPHERICAL, ///< offset corresponds to an angular offset + PS_LINEAR ///< offset corresponds to a linear offset +} psSphereOffsetMode; + +/** The units of the offset + * + * @see psSphereGetOffset, psSphereSetOffset + * + */ +typedef enum { + PS_ARCSEC, ///< Arcseconds + PS_ARCMIN, ///< Arcminutes + PS_DEGREE, ///< Degrees + PS_RADIAN ///< Radians +} psSphereOffsetUnit; + +/** Applies the psPlaneTransform transform to a specified coordinate + * + * @return psPlane* resulting coordinate based on transform + */ +psPlane* psPlaneTransformApply( + psPlane* out, ///< a psPlane to recycle. If NULL, a new one is generated. + const psPlaneTransform* transform, ///< the transform to apply + const psPlane* coords ///< the coordinate to apply the transform above. +); + +/** Applies the psPlaneDistort transform to a specified coordinate + * + * @return psPlane* resulting coordinate based on transform + */ +psPlane* psPlaneDistortApply( + psPlane* out, ///< a psPlane to recycle. If NULL, a new one is generated. + const psPlaneDistort* transform, ///< the transform to apply + const psPlane* coords, ///< the coordinate to apply the transform above. + float term3, ///< third term -- maybe magnitude + float term4 ///< forth term -- maybe color +); + +/** Allocator for psSphereTransform + * + * @return psSphereTransform* newly allocated struct + */ +psSphereTransform* psSphereTransformAlloc( + double NPlat, ///< north pole latitude + double Xo, ///< First PT of Ares lon + double xo ///< First PT of Ares equiv lon +); + +/** Applies the psSphereTransform transform for a specified coordinate + * + * @return psSphere* resulting coordinate based on transform + */ +psSphere* psSphereTransformApply( + psSphere* out, ///< a psSphere to recycle. If NULL, a new one is generated. + const psSphereTransform* transform,///< the transform to apply + const psSphere* coord ///< the coordinate to apply the transform above.x +); + +/** Creates the appropriate transform for converting from ICRS to Ecliptic + * coordinate systems. + * + * @return psSphereTransform* transform for ICRS->Ecliptic coordinate systems + */ +psSphereTransform* psSphereTransformICRStoEcliptic( + psTime time ///< the time for which the resulting transform will be valid +); + +/** Creates the appropriate transform for converting from Ecliptic to ICRS + * coordinate systems. + * + * @return psSphereTransform* transform for Ecliptic->ICRS coordinate systems + */ +psSphereTransform* psSphereTransformEcliptictoICRS( + psTime time ///< the time for which the resulting transform will be valid +); + +/** Creates the appropriate transform for converting from ICRS to Galatic + * coordinate systems. + * + */ +psSphereTransform* psSphereTransformICRStoGalatic(void); + +/** Creates the appropriate transform for converting from Galatic to ICRS + * coordinate systems. + * + */ +psSphereTransform* psSphereTransformGalatictoICRS(void); + +/** Projects a spherical coordinate to a linear coordinate system + * + * @return psPlane* projected coordinate + */ +psPlane* psProject( + const psSphere* coord, ///< coordinate to project + const psProjection* projection ///< parameters of the projection +); + +/** Reverse projection of a linear coordinate to a spherical coordinate system + * + * @return psPlane* projected coordinate + */ +psSphere* psDeproject( + const psPlane* coord, ///< coordinate to project + const psProjection* projection ///< parameters of the projection +); + +/** Determines the offset (RA,Dec) on the sky between two positions. + * + * Both an offset mode and an offset unit may be defined. The mode may be + * either PS_SPHERICAL, in which case the specified offset corresponds to an + * offset in angles, or it may be PS_LINEAR, in which case the offset + * corresponds to a linear offset in a local projection. The offset unit may + * be in one of PS_ARCSEC, PS_ARCMIN, PS_DEGREE, and PS_RADIAN, which + * specifies the units of the offset only. + * + * @return psSphere* the offset between position1 and position2 + */ +psSphere* psSphereGetOffset( + const psSphere* restrict position1, + const psSphere* restrict position2, + psSphereOffsetMode mode, + psSphereOffsetUnit unit +); + +/** Applies the given offset to a coordinate. + * + * Both an offset mode and an offset unit may be defined. The mode may be + * either PS_SPHERICAL, in which case the specified offset corresponds to an + * offset in angles, or it may be PS_LINEAR, in which case the offset + * corresponds to a linear offset in a local projection. The offset unit may + * be in one of PS_ARCSEC, PS_ARCMIN, PS_DEGREE, and PS_RADIAN, which + * specifies the units of the offset only. + * + * @return psSphere* the given position with the given offset applied. + */ +psSphere* psSphereSetOffset( + const psSphere* restrict position, + const psSphere* restrict offset, + psSphereOffsetMode mode, + psSphereOffsetUnit unit +); + +/// @} + +#endif Index: /tags/rel2_1/psLib/src/astronomy/psMetadata.c =================================================================== --- /tags/rel2_1/psLib/src/astronomy/psMetadata.c (revision 1553) +++ /tags/rel2_1/psLib/src/astronomy/psMetadata.c (revision 1553) @@ -0,0 +1,761 @@ + +/** @file psMetadata.c +* +* +* @brief Contains metadata struuctures, enumerations and functions prototypes +* +* This file defines metadata item, metadata type, metadata flags, metadata containers, and function +* prototypes necessary creating psLib metadata APIs +* +* @ingroup Metadata +* +* @author Ross Harman, MHPCC +* +* @version $Revision: 1.24 $ $Name: not supported by cvs2svn $ +* @date $Date: 2004-08-14 02:55:46 $ +* +* Copyright 2004 Maui High Performance Computing Center, University of Hawaii +*/ + +/******************************************************************************/ +/* INCLUDE FILES */ +/******************************************************************************/ +#include +#include +#include + +#include "fitsio.h" +#include "psType.h" +#include "psMemory.h" +#include "psError.h" +#include "psAbort.h" +#include "psList.h" +#include "psHash.h" +#include "psMetadata.h" +#include "psString.h" + +/******************************************************************************/ +/* DEFINE STATEMENTS */ +/******************************************************************************/ + +#define FITS_ERROR(STRING,PS_ERROR) \ +fits_get_errstatus(status, fitsErr); \ +psError( __func__, STRING, PS_ERROR, fitsErr); \ +status = 0; \ +return output; + +/** Maximum size of a FITS line */ +#define FITS_LINE_SIZE 80 + +/** Maximum size of a string */ +#define MAX_STRING_LENGTH 1024 + +/******************************************************************************/ +/* TYPE DEFINITIONS */ +/******************************************************************************/ + +// None + +/*****************************************************************************/ +/* GLOBAL VARIABLES */ +/*****************************************************************************/ + +// None + +/*****************************************************************************/ +/* FILE STATIC VARIABLES */ +/*****************************************************************************/ + +static int metadataId = 0; + +/*****************************************************************************/ +/* FUNCTION IMPLEMENTATION - LOCAL */ +/*****************************************************************************/ + +static void metadataItemFree(psMetadataItem* metadataItem) +{ + psMetadataType type; + + type = metadataItem->type; + + if (metadataItem == NULL) { + return; + } + + psFree(metadataItem->name); + psFree(metadataItem->comment); + psFree(metadataItem->items); + + if (type == PS_META_STR || + type == PS_META_IMG || + type == PS_META_JPEG || type == PS_META_PNG || type == PS_META_ASTROM || type == PS_META_UNKNOWN) { + psFree(metadataItem->data.V); + } +} + +static void metadataFree(psMetadata* metadata) +{ + if (metadata == NULL) { + return; + } + psFree(metadata->list); + psFree(metadata->table); +} + +/*****************************************************************************/ +/* FUNCTION IMPLEMENTATION - PUBLIC */ +/*****************************************************************************/ + +psMetadataItem* psMetadataItemAlloc(const char *name, psMetadataType type, const char *comment, ...) +{ + va_list argPtr; + psMetadataItem* metadataItem = NULL; + + // Get the variable list parameters to pass to allocation function + va_start(argPtr, comment); + + // Call metadata item allocation + metadataItem = psMetadataItemAllocV(name, type, comment, argPtr); + + // Clean up stack after variable arguement has been used + va_end(argPtr); + + return metadataItem; +} + +psMetadataItem* psMetadataItemAllocV(const char *name, psMetadataType type, const char *comment, + va_list argPtr) +{ + psMetadataItem* metadataItem = NULL; + + if (name == NULL) { + psError(__func__, "Null value for name not allowed"); + return NULL; + } + // Allocate metadata item + metadataItem = (psMetadataItem* ) psAlloc(sizeof(psMetadataItem)); + if (metadataItem == NULL) { + psAbort(__func__, "Failed to allocate memory"); + } + // Set deallocator + p_psMemSetDeallocator(metadataItem, (psFreeFcn) metadataItemFree); + + // Allocate and set metadata item comment + metadataItem->comment = (char *)psAlloc(sizeof(char) * MAX_STRING_LENGTH); + if (comment == NULL) { + // Per SDRS, null isn't allowed, must use "" instead + strncpy(metadataItem->comment, "", MAX_STRING_LENGTH); + } else { + strncpy(metadataItem->comment, comment, MAX_STRING_LENGTH); + } + + // Set metadata item unique id + *(int *)(&metadataItem->id) = ++metadataId; + + // Set metadata item type + metadataItem->type = type; + + // Set metadata item value + switch (type) { + case PS_META_ITEM_SET: + metadataItem->data.V = NULL; + break; + case PS_META_BOOL: + metadataItem->data.B = (bool)va_arg(argPtr, int); + break; + case PS_META_S32: + metadataItem->data.S32 = va_arg(argPtr, psS32); + break; + case PS_META_F32: + metadataItem->data.F32 = (psF32)va_arg(argPtr, psF64); + break; + case PS_META_F64: + metadataItem->data.F64 = va_arg(argPtr, psF64); + break; + case PS_META_STR: + metadataItem->data.V = psStringNCopy(va_arg(argPtr, char *), MAX_STRING_LENGTH); + break; + case PS_META_IMG: + case PS_META_JPEG: + case PS_META_PNG: + case PS_META_ASTROM: + case PS_META_UNKNOWN: + default: + psError(__func__, "Invalid psMetadataType: %d", type); + } + + // Allocate and set metadata item name + metadataItem->name = (char *)psAlloc(sizeof(char) * MAX_STRING_LENGTH); + vsprintf(metadataItem->name, name, argPtr); + + // Allocate metadata items with same name. + metadataItem->items = psListAlloc(NULL); + + return metadataItem; +} + +psMetadata* psMetadataAlloc(void) +{ + psList* list = NULL; + psHash* table = NULL; + psMetadata* metadata = NULL; + + // Allocate metadata + metadata = (psMetadata* ) psAlloc(sizeof(psMetadata)); + if (metadata == NULL) { + psAbort(__func__, "Failed to allocate metadata"); + } + // Set deallocator + p_psMemSetDeallocator(metadata, (psFreeFcn) metadataFree); + + // Allocate metadata's internal containers + list = (psList* ) psListAlloc(NULL); + if (list == NULL) { + psAbort(__func__, "Failed to allocate list"); + } + + table = (psHash* ) psHashAlloc(10); + if (table == NULL) { + psAbort(__func__, "Failed to allocate table"); + } + + metadata->list = list; + metadata->table = table; + + return metadata; +} + +bool psMetadataAddItem( psMetadata *restrict md, int where, psMetadataItem *restrict metadataItem ) +{ + char * key = NULL; + psHash *mdTable = NULL; + psList *mdList = NULL; + psMetadataItem *existingEntry = NULL; + psMetadataItem *newFolderEntry = NULL; + psMetadataType newType = PS_META_ITEM_SET; + + if(md == NULL) { + psError( __func__, "Null metadata collection not allowed" ); + return false; + } + + if(metadataItem == NULL) { + psError( __func__, "Null metadata item not allowed" ); + return false; + } + + newType = metadataItem->type; + + mdTable = md->table; + if(mdTable == NULL) { + psError( __func__, "Null metadata table not allowed" ); + return false; + } + + mdList = md->list; + if(mdList == NULL) { + psError( __func__, "Null metadata list not allowed"); + return false; + } + + key = metadataItem->name; + if(key == NULL) { + psError(__func__, "Null key item not allowed"); + return false; + } + + // See if key is already in table + existingEntry = (psMetadataItem*)psHashLookup(mdTable, key); + if(existingEntry != NULL) { + + if(existingEntry->type == PS_META_ITEM_SET) { + + // Add leaf node to existing folder node + if(!psListAdd(existingEntry->items, metadataItem, PS_LIST_TAIL)) { + psError( __func__, "Couldn't add metadata item to items list. Name: %s", + metadataItem->name ); + return false; + } + } else if(existingEntry->type != PS_META_ITEM_SET && newType!= PS_META_ITEM_SET) { + + // Leaf node replaces another leaf. Make new folder node and add leaves. + newFolderEntry = psMetadataItemAlloc(key, PS_META_ITEM_SET, NULL, NULL); + + if(!psListAdd(newFolderEntry->items, existingEntry, PS_LIST_TAIL)) { + psError( __func__, "Couldn't add metadata item to items list. Name: %s", key); + psFree(newFolderEntry); + return false; + } + + if(!psListAdd(newFolderEntry->items, metadataItem, PS_LIST_TAIL)) { + psError( __func__, "Couldn't add metadata item to items list. Name: %s", key); + psFree(newFolderEntry); + return false; + } + + if(!psHashRemove(mdTable, key)) { + psError( __func__, "Couldn't remove metadata item from metadata table. Name: %s", key); + psFree(newFolderEntry); + return false; + } + + if(!psHashAdd(mdTable, key, newFolderEntry)) { + psError( __func__, "Couldn't add metadata item to metadata table. Name: %s", key); + psFree(newFolderEntry); + return false; + } + + // Remove local reference to new folder node + psMemDecrRefCounter(newFolderEntry); + } else { + + // Folder node replaces leaf or folder node - Put old node into new folder and remove from table + if(!psListAdd(metadataItem->items, existingEntry, PS_LIST_TAIL)) { + psError( __func__, "Couldn't add metadata item to items list. Name: %s", key); + return false; + } + + if(!psHashRemove(mdTable, key)) { + psError( __func__, "Couldn't remove metadata item from metadata table. Name: %s", key); + return false; + } + + if(!psHashAdd(mdTable, key, metadataItem)) { + psError( __func__, "Couldn't add metadata item to metadata table. Name: %s", key); + return false; + } + } + } else { + + // Node doesn't exist - Add new metadata item to metadata collection's hash + if(!psHashAdd(mdTable, key, metadataItem)) { + psError( __func__, "Couldn't add metadata item to metadata table. Name: %s", key); + return false; + } + } + + // Add all items to metadata collection's list, even if they have the same metadata item names + if(!psListAdd( mdList, metadataItem, where )) { + psError( __func__, "Couldn't add metadata item to metadata collection list. Name: %s", + metadataItem->name ); + return false; + } + + return true; +} + +bool psMetadataAdd(psMetadata* restrict md, int where, const char *name, psMetadataType type, + const char *comment, ...) +{ + va_list argPtr; + psMetadataItem* metadataItem = NULL; + + va_start(argPtr, comment); + metadataItem = psMetadataItemAllocV(name, type, comment, argPtr); + va_end(argPtr); + + if (!psMetadataAddItem(md, where, metadataItem)) { + psError(__func__, "Couldn't add metadata item to metadata collection list. Name: %s", + metadataItem->name); + psFree(metadataItem); + return false; + } + // Decrement reference count, since the metadata item is now in metadata collection and no longer needed + // here + psMemDecrRefCounter(metadataItem); + + return true; +} + + + +bool psMetadataRemove(psMetadata* restrict md, int where, const char *restrict key) +{ + int numChildren = 0; + psList* mdList = NULL; + psHash* mdTable = NULL; + psMetadataItem* entry = NULL; + psMetadataItem* entryChild = NULL; + + + if (md == NULL) { + psError(__func__, "Null metadata collection not allowed"); + return false; + } + + mdList = md->list; + if (mdList == NULL) { + psError(__func__, "Null metadata list not allowed"); + return false; + } + + mdTable = md->table; + if (mdTable == NULL) { + psError(__func__, "Null metadata table not allowed"); + return false; + } + // Select removal by key or index + if (key != NULL) { + + // Remove by key name + entry = (psMetadataItem* ) psHashLookup(mdTable, key); + if (entry == NULL) { + psError(__func__, "Couldn't find metadata item. Name: %s", key); + return false; + } + + numChildren = entry->items->size; + if (entry->type == PS_META_ITEM_SET && numChildren > 0) { + + // Table entry has children. Entry and children must be removed from metadata collection's list + psListSetIterator(entry->items, PS_LIST_HEAD); + entryChild = psListGetCurrent(entry->items); + while (entryChild != NULL) { + if (!psListRemove(mdList, entryChild, PS_LIST_UNKNOWN)) { + psError(__func__, "Couldn't remove metadata item from list. Name: %s", key); + return false; + } + entryChild = psListGetNext(entry->items); + } + } else { + + // Table entry has no children. Remove entry from metadata collection's list + if (!psListRemove(mdList, entry, PS_LIST_UNKNOWN)) { + psError(__func__, "Couldn't remove metadata item from list. Name: %s", key); + return false; + } + } + // Remove entry from metadata collection's table + if (!psHashRemove(mdTable, key)) { + psError(__func__, "Couldn't remove metadata item from table. Name: %s", key); + return false; + } + } else { + + // Remove by index + entry = psListGet(mdList, where); + if (entry == NULL) { + psError(__func__, "Couldn't find metadata item in list. Index: %d", where); + return false; + } + + key = entry->name; + if (key == NULL) { + psError(__func__, "Null key name not allowed. Index: %d", where); + return false; + } + // Use recursive remove, now that key is known + psMetadataRemove(md, PS_LIST_UNKNOWN, key); + } + + return true; +} + +psMetadataItem* psMetadataLookup(psMetadata* restrict md, const char *restrict key) +{ + psHash* mdTable = NULL; + psMetadataItem* entry = NULL; + + + if (md == NULL) { + psError(__func__, "Null metadata collection not allowed"); + return NULL; + } + + mdTable = md->table; + if (mdTable == NULL) { + psError(__func__, "Null metadata table not allowed"); + return NULL; + } + + if (key == NULL) { + psError(__func__, "Null key name not allowed"); + return NULL; + } + + entry = (psMetadataItem* ) psHashLookup(mdTable, key); + if (entry == NULL) { + psError(__func__, "Could not find metadata item. Key: %s", key); + return NULL; + } + + return entry; +} + +psMetadataItem* psMetadataGet(psMetadata* restrict md, int where) +{ + psList* mdList = NULL; + psMetadataItem* entry = NULL; + + + if (md == NULL) { + psError(__func__, "Null metadata collection not allowed"); + return NULL; + } + + mdList = md->list; + if (mdList == NULL) { + psError(__func__, "Null metadata list not allowed"); + return NULL; + } + + entry = (psMetadataItem* ) psListGet(mdList, where); + if (entry == NULL) { + psError(__func__, "Couldn't find metadata item with given index. Index: %d", where); + return NULL; + } + + return entry; +} + +bool psMetadataSetIterator(psMetadata* restrict md, int where) +{ + psList* mdList = NULL; + + if (md == NULL) { + psError(__func__, "Null metadata collection not allowed"); + return false; + } + + mdList = md->list; + if (mdList == NULL) { + psError(__func__, "Null metadata list not allowed"); + return false; + } + + psListSetIterator(mdList, where); + + return true; +} + +psMetadataItem* psMetadataGetNext(psMetadata* restrict md, const char *restrict match, int which) +{ + psList* mdList = NULL; + psMetadataItem* entry = NULL; + + + if (md == NULL) { + psError(__func__, "Null metadata collection not allowed"); + return NULL; + } + + mdList = md->list; + if (mdList == NULL) { + psError(__func__, "Null metadata list not allowed"); + return NULL; + } + + psListSetIterator(mdList, which); + entry = psListGetCurrent(mdList); + while (entry != NULL) { + if(match != NULL) { + if (!strncmp(match, entry->name, strlen(match))) { + + // Match found + return entry; + } + entry = psListGetNext(mdList); + } else { + return psListGetNext(mdList); + } + } + + // Match not found + if (entry == NULL) { + psError(__func__, "Couldn't find metadata item"); + } + + return entry; +} + +psMetadataItem* psMetadataGetPrevious(psMetadata* restrict md, const char *restrict match, int which) +{ + psList* mdList = NULL; + psMetadataItem* entry = NULL; + + + if (md == NULL) { + psError(__func__, "Null metadata collection not allowed"); + return NULL; + } + + mdList = md->list; + if (mdList == NULL) { + psError(__func__, "Null metadata list not allowed"); + return NULL; + } + + psListSetIterator(mdList, which); + entry = psListGetCurrent(mdList); + while (entry != NULL) { + if(match != NULL) { + if (!strncmp(match, entry->name, strlen(match))) { + + // Match found + return entry; + } + entry = psListGetPrevious(mdList); + } else { + return psListGetPrevious(mdList); + } + } + + // Match not found + if (entry == NULL) { + psError(__func__, "Couldn't find metadata item", match); + } + + return entry; +} + +void psMetadataItemPrint(FILE * fd, const char *format, const psMetadataItem* restrict metadataItem) +{ + psMetadataType type; + + if (fd == NULL) { + psError(__func__, "Null file descriptor not allowed"); + return; + } + + if (format == NULL) { + psError(__func__, "Null format not allowed"); + return; + } + + if (metadataItem == NULL) { + psError(__func__, "Null metadata not allowed"); + return; + } + + type = metadataItem->type; + + switch (type) { + case PS_META_BOOL: + fprintf(fd, format, metadataItem->data.B); + break; + case PS_META_S32: + fprintf(fd,format, metadataItem->data.S32); + break; + case PS_META_F32: + fprintf(fd, format, metadataItem->data.F32); + break; + case PS_META_F64: + fprintf(fd, format, metadataItem->data.F64); + break; + case PS_META_STR: + fprintf(fd, format, metadataItem->data.V); + break; + case PS_META_ITEM_SET: + case PS_META_IMG: + case PS_META_JPEG: + case PS_META_PNG: + case PS_META_ASTROM: + case PS_META_UNKNOWN: + default: + psError(__func__, " Invalid psMetadataType to print: %d", type); + } +} + +psMetadata* psMetadataFReadHeader(psMetadata* output, char *extName, int extNum, fitsfile * fd) +{ + bool tempBool; + bool success; + char keyType; + char keyName[FITS_LINE_SIZE]; + char keyValue[FITS_LINE_SIZE]; + char keyComment[FITS_LINE_SIZE]; + char fitsErr[MAX_STRING_LENGTH]; + int i; + int hduType = 0; + int status = 0; + int numKeys = 0; + int keyNum = 0; + psMetadataType metadataItemType; + + if (fd == NULL) { + psError(__func__, "Null FITS file descriptor not allowed"); + return NULL; + } + + if (extName == NULL && extNum == 0) { + psError(__func__, "Null extName and extNum = 0 not allowed"); + return NULL; + } else if (extName && extNum) { + psError(__func__, "Both extName and extNum arguments should not have non zero values."); + return NULL; + } + // Allocate metadata if user didn't + if (output == NULL) { + output = psMetadataAlloc(); + } + // Move to user designated HDU number or HDU name in FITS file. HDU numbers starts at one. + if (extName != NULL) { + if (fits_movnam_hdu(fd, ANY_HDU, extName, 0, &status) != 0) { + FITS_ERROR("FITS error while locating header %s: %s", extName); + } + } else { + if (fits_movabs_hdu(fd, extNum, &hduType, &status) != 0) { + FITS_ERROR("FITS error while locating header %d: %s", extNum); + } + } + + // Get number of key names + if (fits_get_hdrpos(fd, &numKeys, &keyNum, &status) != 0) { + FITS_ERROR("FITS error while reading key %d: %s", keyNum); + } + // Get each key name. Keywords start at one. + for (i = 1; i <= numKeys; i++) { + if (fits_read_keyn(fd, i, keyName, keyValue, keyComment, &status) != 0) { + FITS_ERROR("FITS error while reading key %d: %s", keyNum); + } + if (fits_get_keytype(keyValue, &keyType, &status) != 0) { + fits_get_errstatus(status, fitsErr); + if (status != VALUE_UNDEFINED) { + FITS_ERROR("FITS error while determining key %d type: %s", keyNum); + } else { + // Some keywords are still valid even though they don't have a type, like COMMENTS and + // HISTORY + keyType = 'C'; + status = 0; + } + } + + switch (keyType) { + case 'I': + metadataItemType = PS_META_S32; + success = + psMetadataAdd(output, PS_LIST_TAIL, keyName, metadataItemType, keyComment, + atoi(keyValue)); + break; + case 'F': + metadataItemType = PS_META_F64; + success = + psMetadataAdd(output, PS_LIST_TAIL, keyName, metadataItemType, keyComment, + atof(keyValue)); + break; + case 'C': + metadataItemType = PS_META_STR; + success = + psMetadataAdd(output, PS_LIST_TAIL, keyName, metadataItemType, keyComment, keyValue); + break; + case 'L': + metadataItemType = PS_META_BOOL; + tempBool = (keyValue[0] == 'T') ? 1 : 0; + success = + psMetadataAdd(output, PS_LIST_TAIL, keyName, metadataItemType, keyComment, tempBool); + break; + case 'U': + case 'X': + default: + psError(__func__, "Invalid psMetadataType: %c", keyType); + return output; + } + + if (!success) { + psError(__func__, "Failed to add metadata item. Name: %s", keyName); + return output; + } + } + + return output; +} Index: /tags/rel2_1/psLib/src/astronomy/psMetadata.h =================================================================== --- /tags/rel2_1/psLib/src/astronomy/psMetadata.h (revision 1553) +++ /tags/rel2_1/psLib/src/astronomy/psMetadata.h (revision 1553) @@ -0,0 +1,298 @@ + +/** @file psMetadata.h +* +* @brief Contains metadata struuctures, enumerations and functions prototypes +* +* This file defines metadata item, metadata type, metadata flags, metadata containers, and function +* prototypes necessary creating psLib metadata APIs +* +* @ingroup Metadata +* +* @author Ross Harman, MHPCC +* +* @version $Revision: 1.20 $ $Name: not supported by cvs2svn $ +* @date $Date: 2004-08-12 01:23:20 $ +* +* Copyright 2004 Maui High Performance Computing Center, University of Hawaii +*/ +#ifndef PS_METADATA_H +#define PS_METADATA_H + +#include +#include +#include + +#include "psHash.h" +#include "psList.h" + +/// @addtogroup Metadata +/// @{ + +/** Metadata item type. + * + * Enumeration for maintaining metadata item types. + */ +typedef enum { + PS_META_ITEM_SET = 0, ///< Null. Metadata is in psMetadataItem.items + PS_META_BOOL, ///< Boolean data. + PS_META_S32, ///< Signed 32-bit integer data. + PS_META_F32, ///< Single-precision float data. + PS_META_F64, ///< Double-precision float data. + PS_META_STR, ///< String data (Stored in as void *). + PS_META_IMG, ///< Image data (Stored in as void *). + PS_META_JPEG, ///< JPEG data (Stored in as void *). + PS_META_PNG, ///< PNG data (Stored in as void *). + PS_META_ASTROM, ///< Astrometric coefficients (Stored in as void *). + PS_META_UNKNOWN, ///< Other data (Stored in as void *). + PS_META_NTYPE ///< Number of types. Must be last. +} psMetadataType; + +/** Metadata item data structure. + * + * Struct for maintaining metadata items of varying types. It also contains + * information about the item name, flags, comments, and other items with the same name. + */ +typedef struct psMetadataItem +{ + const int id; ///< Unique ID for metadata item. + char *restrict name; ///< Name of metadata item. + psMetadataType type; ///< Type of metadata item. + union { + bool B; ///< boolean data + psS32 S32; ///< Signed 32-bit integer data. + psF32 F32; ///< Single-precision float data. + psF64 F64; ///< Double-precision float data. + psPTR V; ///< Pointer to other type of data. + } data; ///< Union for data types. + char *comment; ///< Optional comment ("", not NULL). + psList* restrict items; ///< List of psMetadataItems with same name. +} +psMetadataItem; + +/** Metadata data structure. + * + * Struct for holding metadata items. Metadata items are held in two + * containers. The first employs a doubly-linked list to preserve the order + * of the metadata. The second container employs a hash table which + * allows fast lookup when given a metadata keyword. + */ +typedef struct psMetadata +{ + psList* restrict list; ///< the metadata in linked-list + psHash* restrict table; ///< the metadata in a hash table +} +psMetadata; + +/*****************************************************************************/ + +/* FUNCTION PROTOTYPES */ + +/*****************************************************************************/ + +/** Create a metadata item. + * + * Returns a fill psMetadataItem ready for insertion into the psMetadata + * struct. The name argument specifies the name to use for this item, and + * may include sprintf formatting codes. The format entry specifies both + * the metadata type and optional flags and is created by bit-wise or of the + * appropriate type and flag. The comment argument is a fixed string used to + * comment the metadata item. The arguments to the name formatting codes and + * the metadata itself are passed as arguments following the comment string. + * The data must be a pointer for any of the elements stored in data.void. + * The argument list must be interpreted appropriately by the va_list + * operators in the function specified size and type. + * + * @return psMetadataItem* : Pointer metadata item. + */ +psMetadataItem* psMetadataItemAlloc( + const char *name, ///< Name of metadata item. + psMetadataType type, ///< Type of metadata item. + const char *comment, ///< Comment for metadata item. + ... ///< Arguments for name formatting and metadata item data. +); + +/** Create a metadata item with va_list. + * + * Returns a fill psMetadataItem ready for insertion into the psMetadata + * struct. The name argument specifies the name to use for this item, and + * may include sprintf formatting codes. The format entry specifies both + * the metadata type and optional flags and is created by bit-wise or of the + * appropriate type and flag. The comment argument is a fixed string used to + * comment the metadata item. The arguments to the name formatting codes and + * the metadata itself are passed as arguments following the comment string. + * The data must be a pointer for any of the elements stored in data.void. + * The argument list must be interpreted appropriately by the va_list + * operators in the function specified size and type. + * + * @return psMetadataItem* : Pointer metadata item. + */ +psMetadataItem* psMetadataItemAllocV( + const char *name, ///< Name of metadata item. + psMetadataType type, ///< Type of metadata item. + const char *comment, ///< Comment for metadata item. + va_list list ///< Arguments for name formatting and metadata item data. +); + +/** Create a metadata collection. + * + * Returns an empty metadata container with fully allocated internal metadata + * containers. + * + * @return psMetadata* : Pointer metadata. + */ +psMetadata* psMetadataAlloc(void); + +/** Add existing metadata item to metadata collection. + * + * Add a metadata item that has already been created to the metadata + * collection. + * + * @return bool: True for success, false for failure. + */ +bool psMetadataAddItem( + psMetadata* restrict md, ///< Metadata collection to insert metadat item. + int where, ///< Location to be added. + psMetadataItem* restrict item ///< Metadata item to be added. +); + +/** Create and add a metadata item to metadata collection. + * + * Creates a new metadata item add to the metadata collection. + * + * @return bool: True for success, false for failure. + */ +bool psMetadataAdd( + psMetadata* restrict md, ///< Metadata collection to insert metadat item. + int where, ///< Location to be added. + const char *name, ///< Name of metadata item. + psMetadataType type, ///< Type of metadata item. + const char *comment, ///< Comment for metadata item. + ... ///< Arguments for name formatting and metadata item data. +); + +/** Remove an item from metadata collection. + * + * Items may be removed from metadata by specifing a key or location. If the + * name is null, the where argument is used instead. If name is not null, + * where is set to PS_LIST_UNKNOWN. If the item is found, it is removed from + * the metadata and true is returned. If the key is not unique, then all + * items corresponding to it are removed. + * + * @return bool: True for success, false for failure. + */ +bool psMetadataRemove( + psMetadata* restrict md, ///< Metadata collection to insert metadat item. + int where, ///< Location to be removed. + const char *restrict key ///< Name of metadata key. +); + +/** Find an item in the metadata collection based on key name. + * + * Items may be found in the metadata by providing a key. If the key is + * non-unique, the first item is returned. If the item is not found, null is + * returned. + * + * @return psMetadataItem* : Pointer metadata item. + */ +psMetadataItem* psMetadataLookup( + psMetadata* restrict md, ///< Metadata collection to insert metadata item. + const char *restrict key ///< Name of metadata key. +); + +/** Find an item in the metadata collection based on list index. + * + * Items may be found in the metadata by their entry position in the list + * container. + * + * @return psMetadataItem* : Pointer metadata item. + */ +psMetadataItem* psMetadataGet( + psMetadata* restrict md, ///< Metadata collection to insert metadat item. + int where ///< Location to be retrieved. +); + +/** Set or reset metadata iterator. + * + * Metadata may be iterated by setting or resetting an iterator to a location + * in the metadata list. + * + * @return void: void. + */ +bool psMetadataSetIterator( + psMetadata* restrict md, ///< Metadata collection to iterate. + int where ///< Location of iterator. +); + +/** Get next metadata item. + * + * Get next metadata item in iterator list. + * + * @return psMetadataItem* : Pointer metadata item. + */ +psMetadataItem* psMetadataGetNext( + psMetadata* restrict md, ///< Metadata collection to iterate. + const char *restrict match, ///< Beginning of key name. + int which ///< Iterator to be used. +); + +/** Get previous metadata item. + * + * Get previous metadata item in iterator list. + * + * @return psMetadataItem* : Pointer metadata item. + */ +psMetadataItem* psMetadataGetPrevious( + psMetadata* restrict md, ///< Metadata collection to iterate. + const char *restrict match, ///< Beginning of key name. + int which ///< Iterator to be used. +); + +/** Print metadata item to file. + * + * Metadata items may be printed to an open file descriptor based on a + * provided format. The format is a sprintf format statement with exactly + * one % formatting command. If the metadata item type is a numeric type, + * this formatting command must also be numeric, and the type conversion + * performed to the value to match the format type. If the metadata type is + * a string, the fromatting command must also be for a string. If the + * metadata type is any other data type, printing is not allowed. + * + * @return psMetadataItem* : Pointer metadata item. + */ +void psMetadataItemPrint( + FILE * fd, ///< Pointer to file to write metadata item. + const char *format, ///< Format to print metadata item. + const psMetadataItem* restrict metadataItem ///< Metadata item to print. +); + +/** Read metadata header. + * + * Read a metadata header from file. If the file is not found, an error is + * reported. This file is currently unimplemented. + * + * @return psMetadata* : Pointer metadata. + */ +psMetadata* psMetadataReadHeader( + psMetadata* output, ///< Resulting metadata from read. + char *extname, ///< File name extension string. + int extnum, ///< File name extension number. Starts at 1. + char *filename ///< Name of file to read. +); + +/** Read metadata header. + * + * Read a metadata header from file. If the file is not found, an error is + * reported. + * + * @return psMetadata* : Pointer metadata. + */ +psMetadata* psMetadataFReadHeader( + psMetadata* output, ///< Resulting metadata from read. + char *extName, ///< File name extension string. + int extNum, ///< File name extension number. + fitsfile * fd ///< Pointer to file to read. +); + +/// @} + +#endif Index: /tags/rel2_1/psLib/src/astronomy/psPhotometry.h =================================================================== --- /tags/rel2_1/psLib/src/astronomy/psPhotometry.h (revision 1553) +++ /tags/rel2_1/psLib/src/astronomy/psPhotometry.h (revision 1553) @@ -0,0 +1,75 @@ + +/** @file psPhotometry.h +* +* @brief Contains basic photometric structures. +* +* This file defines the basic photometric structures. +* +* @ingroup Photometry +* +* @author George Gusciora, MHPCC +* +* @version $Revision: 1.7 $ $Name: not supported by cvs2svn $ +* @date $Date: 2004-08-09 23:40:54 $ +* +* Copyright 2004 Maui High Performance Computing Center, University of Hawaii +*/ + +#ifndef PS_PHOTOMETRIC_H +#define PS_PHOTOMETRIC_H + +#include "psType.h" +#include "psImage.h" +#include "psArray.h" +#include "psList.h" +#include "psFunctions.h" + +/// @addtogroup Photometry +/// @{ + +/** The photometric system description + * + * The photometric system is defined by the psPhotSystem structure. A + * photometric system is identified by a human-readable name (ie, SDSS.g, + * Landolt92.B, GPC1.OTA32.r). Each photometric system is given a unique + * identifier ID. Observations taken with a specific camera, detector, and + * filter represent their own photometric system, and it may be necessary to + * perform transformations between these systems. Photometric systems + * associated with observations from a specific camera/ detector/filter + * combination can be associated with those components. + * + */ + +typedef struct +{ + const int ID; ///< ID number for this photometric system + const char *name; ///< Name of photometric system + const char *camera; ///< Camera for photometric system + const char *filter; ///< Filter used for photometric system + const char *detector; ///< Detector used for photometric system +} +psPhotSystem; + +/** Photometric system transformation + * + * This structure defines the transformation between two photometric systems. + * + */ + +typedef struct +{ + psPhotSystem src; ///< Source photometric system + psPhotSystem dst; ///< Destination photometric system + psPhotSystem pP; ///< Primary color reference + psPhotSystem pM; ///< Primary color reference + psPhotSystem sP; ///< Secondary color reference + psPhotSystem sM; ///< Secondary color reference + float pA; ///< Color offset for references + float sA; ///< Color offset for references + psPolynomial3D transform; ///< Transformation from source to destination +} +psPhotTransform; + +/// @} + +#endif Index: /tags/rel2_1/psLib/src/astronomy/psTime.c =================================================================== --- /tags/rel2_1/psLib/src/astronomy/psTime.c (revision 1553) +++ /tags/rel2_1/psLib/src/astronomy/psTime.c (revision 1553) @@ -0,0 +1,549 @@ + +/** @file psTime.c + * + * @brief Definitions for time, time utilities, and conversion functions for use with psLib astronomy + * functions. + * + * A collection of functions are required by psLib to manipulate time data. These functions primarily consist + * of conversions between specific time formats. PSLib currently uses the UNIX timeval time system as the + * base upon which International Atomic Time (TAI) time is calculated. TAI time varies over time due to the + * earth's rotation and the movement of the continental plates. It is currentls 32 seconds faster than + * UTC/timeval time. + * + * @author Ross Harman, MHPCC + * + * @version $Revision: 1.15 $ $Name: not supported by cvs2svn $ + * @date $Date: 2004-08-13 23:47:10 $ + * + * Copyright 2004 Maui High Performance Computing Center, University of Hawaii + */ + +/******************************************************************************/ + +/* INCLUDE FILES */ + +/******************************************************************************/ + +#include +#include +#include + +#include "psTime.h" +#include "psError.h" +#include "psMemory.h" + +/******************************************************************************/ + +/* DEFINE STATEMENTS */ + +/******************************************************************************/ + +/** Number of available leapsecond updates */ +#define NUM_LEAPSECOND_UPDATES 23 + +/** Maximum length of time string */ +#define MAX_TIME_STRING_LENGTH 256 + +/** Seconds per minute */ +#define SEC_PER_MINUTE 60.0 + +/** Seconds per hour */ +#define SEC_PER_HOUR (60.0*SEC_PER_MINUTE) + +/** Seconds per day */ +#define SEC_PER_DAY (24.0*SEC_PER_HOUR) + +/** Seconds per year */ +#define SEC_PER_YEAR (365.0*SEC_PER_DAY) + +/** Microseconds per day */ +#define USEC_PER_DAY 86400000000.0 + +/** Preprocessor macro to generate error for negative time in struct */ +#define CHECK_NEGATIVE_TIME_STRUCT(NAME,RETURN) \ +if(NAME.tv_sec < 0) { \ + psError(__func__,"Negative seconds are not allowed: %ld", NAME.tv_sec); \ + return RETURN; \ +} else if(NAME.tv_usec<0) { \ + psError(__func__,"Negative microseconds are not allowed: %ld", NAME.tv_usec); \ + return RETURN; \ +} + +/** Preprocessor macro to generate error for negative time */ +#define CHECK_NEGATIVE_TIME(NAME,RETURN) \ +if(NAME < 0.0) { \ + psError(__func__,"Negative time is not allowed: %f", NAME); \ + return RETURN; \ +} \ + + +/******************************************************************************/ + +/* TYPE DEFINITIONS */ + +/******************************************************************************/ + +// None + +/*****************************************************************************/ + +/* GLOBAL VARIABLES */ + +/*****************************************************************************/ + +// None + +/*****************************************************************************/ + +/* FILE STATIC VARIABLES */ + +/*****************************************************************************/ + +/* The table below comes from http://tycho.usno.navy.mil/leapsec.html, which reports the current state of +the TAI/UTC leapsecond conversion times. This table is placed into a two dimensional array and used by +the psTimeGetTime() function to calculate TAI time from UTC time. + + 1972 JAN 1 = JD 2441317.5 TAI-UTC = 10.0 + 1972 JUL 1 = JD 2441499.5 TAI-UTC = 11.0 + 1973 JAN 1 = JD 2441683.5 TAI-UTC = 12.0 + 1974 JAN 1 = JD 2442048.5 TAI-UTC = 13.0 + 1975 JAN 1 = JD 2442413.5 TAI-UTC = 14.0 + 1976 JAN 1 = JD 2442778.5 TAI-UTC = 15.0 + 1977 JAN 1 = JD 2443144.5 TAI-UTC = 16.0 + 1978 JAN 1 = JD 2443509.5 TAI-UTC = 17.0 + 1979 JAN 1 = JD 2443874.5 TAI-UTC = 18.0 + 1980 JAN 1 = JD 2444239.5 TAI-UTC = 19.0 + 1981 JUL 1 = JD 2444786.5 TAI-UTC = 20.0 + 1982 JUL 1 = JD 2445151.5 TAI-UTC = 21.0 + 1983 JUL 1 = JD 2445516.5 TAI-UTC = 22.0 + 1985 JUL 1 = JD 2446247.5 TAI-UTC = 23.0 + 1988 JAN 1 = JD 2447161.5 TAI-UTC = 24.0 + 1990 JAN 1 = JD 2447892.5 TAI-UTC = 25.0 + 1991 JAN 1 = JD 2448257.5 TAI-UTC = 26.0 + 1992 JUL 1 = JD 2448804.5 TAI-UTC = 27.0 + 1993 JUL 1 = JD 2449169.5 TAI-UTC = 28.0 + 1994 JUL 1 = JD 2449534.5 TAI-UTC = 29.0 + 1996 JAN 1 = JD 2450083.5 TAI-UTC = 30.0 + 1997 JUL 1 = JD 2450630.5 TAI-UTC = 31.0 + 1999 JAN 1 = JD 2451179.5 TAI-UTC = 32.0 +*/ + +// Table for Julian date of leapsecond update and current total number of leapseconds at that date +static double leapseconds[NUM_LEAPSECOND_UPDATES][2] = { + { + 2441317.5, 10.0}, + { + 2441499.5, 11.0}, + { + 2441683.5, 12.0}, + { + 2442048.5, 13.0}, + { + 2442413.5, 14.0}, + { + 2442778.5, 15.0}, + { + 2443144.5, 16.0}, + { + 2443509.5, 17.0}, + { + 2443874.5, 18.0}, + { + 2444239.5, 19.0}, + { + 2444786.5, 20.0}, + { + 2445151.5, 21.0}, + { + 2445516.5, 22.0}, + { + 2446247.5, 23.0}, + { + 2447161.5, 24.0}, + { + 2447892.5, 25.0}, + { + 2448257.5, 26.0}, + { + 2448804.5, 27.0}, + { + 2449169.5, 28.0}, + { + 2449534.5, 29.0}, + { + 2450083.5, 30.0}, + { + 2450630.5, 31.0}, + { + 2451179.5, 32.0} + }; + +/*****************************************************************************/ + +/* FUNCTION IMPLEMENTATION - LOCAL */ + +/*****************************************************************************/ + +// None + +/*****************************************************************************/ + +/* FUNCTION IMPLEMENTATION - PUBLIC */ + +/*****************************************************************************/ + +psTime psTimeGetTime(void) +{ + struct timeval now; + psTime time; + + time.tv_sec = 0; + time.tv_usec = 0; + + if (gettimeofday(&now, (struct timezone *)0) == -1) { + psError(__func__, " : Line %d - Failed to get time", __LINE__); + return time; + } + // Convert timeval time to psTime + time.tv_sec = now.tv_sec; + time.tv_usec = now.tv_usec; + + // Add most current leapseconds value to UTC time to get TAI time + time.tv_sec += leapseconds[NUM_LEAPSECOND_UPDATES - 1][1]; + + return time; +} + +char *psTimeToISO(psTime time) +{ + int ms = 0; + char *timeString = NULL; + char *tempString = NULL; + struct tm *tmTime = NULL; + time_t sec; + + CHECK_NEGATIVE_TIME_STRUCT(time, NULL); + + tempString = psAlloc(MAX_TIME_STRING_LENGTH); + timeString = psAlloc(MAX_TIME_STRING_LENGTH); + + // Converts psTime to YYYY/MM/DD,HH:MM:SS.SSS in string form + ms = time.tv_usec / 1000; + + sec = time.tv_sec; + // tmTime variable is statically allocated, no need to free + tmTime = gmtime(&sec); + if (!strftime(tempString, MAX_TIME_STRING_LENGTH, "%Y/%m/%d,%H:%M:%S", tmTime)) { + psError(__func__, " : Line %d - Failed strftime conversion", __LINE__); + } + + if (snprintf(timeString, MAX_TIME_STRING_LENGTH, "%s.%3.3d", tempString, ms) < 0) { + psError(__func__, " : Line %d - Failed snprintf conversion", __LINE__); + } + psFree(tempString); + + return timeString; +} + +psTime psTimeToUTC(psTime time) +{ + int i = 0; + double jd = 0.0; + double ls = 0.0; + double *jdTable = NULL; + psTime outTime; + + CHECK_NEGATIVE_TIME_STRUCT(time, outTime); + + // Find leapseconds to subtract from psTime to get UTC time + jd = psTimeToJD(time); + jdTable = leapseconds[0]; + for (i = 0; i < NUM_LEAPSECOND_UPDATES; i++, jdTable += 2) { + if (jd > *jdTable) { + ls = *(jdTable + 1); + } + } + + outTime.tv_sec = time.tv_sec - ls; + outTime.tv_usec = time.tv_usec; + + CHECK_NEGATIVE_TIME_STRUCT(outTime, outTime); + + return outTime; +} + +double psTimeToMJD(psTime time) +{ + double mjd = 0.0; + + CHECK_NEGATIVE_TIME_STRUCT(time, mjd); + + // Modified Julian date conversion courtesy of Eugene Magnier + mjd = time.tv_sec / SEC_PER_DAY + time.tv_usec / USEC_PER_DAY + 40587.0; + + return mjd; +} + +double psTimeToJD(psTime time) +{ + double jd = 0.0; + + CHECK_NEGATIVE_TIME_STRUCT(time, jd); + + // Julian date conversion courtesy of Eugene Magnier + jd = time.tv_sec / SEC_PER_DAY + time.tv_usec / USEC_PER_DAY + 2440587.5; + + return jd; +} + +struct timeval psTimeToTimeval(psTime time) +{ + struct timeval timevalTime; + + CHECK_NEGATIVE_TIME_STRUCT(time, timevalTime); + timevalTime.tv_sec = time.tv_sec; + timevalTime.tv_usec = time.tv_usec; + + return timevalTime; +} + +struct tm *psTimeToTM(psTime time) +{ + struct tm *tmTime = NULL; + time_t sec; + + CHECK_NEGATIVE_TIME_STRUCT(time, tmTime); + sec = time.tv_sec; + tmTime = gmtime(&sec); + + return tmTime; +} + +psTime psISOToTime(char *time) +{ + char tempString[MAX_TIME_STRING_LENGTH]; + int month; + int day; + int year; + int hour; + int minute; + int second; + int millisecond; + struct tm tmTime; + psTime outTime; + + strncpy(tempString, time, MAX_TIME_STRING_LENGTH); + + // Convert YYYY/MM/DD,HH:MM:SS.SSS in string form to tm time + year = atoi(strtok(tempString, "/")); + if (year < 1900) { + psError(__func__, "Years less than 1900 not allowed. Value: %d", year); + return outTime; + } + + month = atoi(strtok(NULL, "/")); + if (month < 1 || month > 12) { + psError(__func__, "Month must have a value from 1 to 12. Value: %d", month); + return outTime; + } + + day = atoi(strtok(NULL, ",")); + if (day < 1 || day > 31) { + psError(__func__, "Day must have a value from 1 to 31. Value: %d", day); + return outTime; + } + + hour = atoi(strtok(NULL, ":")); + if (hour < 0 || hour > 23) { + psError(__func__, "Hour must have a value from 0 to 23. Value: %d", hour); + return outTime; + } + + minute = atoi(strtok(NULL, ":")); + if (minute < 0 || minute > 59) { + psError(__func__, "Minute must have a value from 0 to 59. Value: %d", minute); + return outTime; + } + + second = atoi(strtok(NULL, ".")); + if (second < 0 || second > 59) { + psError(__func__, "Second must have a value from 0 to 59. Value: %d", second); + return outTime; + } + + millisecond = atoi(strtok(NULL, "X")); + if (millisecond < 0 || millisecond > 1000) { + psError(__func__, "Millisecond must have a value from 0 to 999. Value: %d", millisecond); + return outTime; + } + + tmTime.tm_year = year - 1900; + tmTime.tm_mon = month - 1; + tmTime.tm_mday = day; + tmTime.tm_hour = hour; + tmTime.tm_min = minute; + tmTime.tm_sec = second; + tmTime.tm_isdst = -1; + + // Convert tm time to psTime + outTime = psTMToTime(&tmTime); + outTime.tv_usec = millisecond * 1000; + + return outTime; +} + +psTime psUTCToTime(psTime time) +{ + psTime outTime; + + CHECK_NEGATIVE_TIME_STRUCT(time, outTime); + + // Convert UTC time to psTime/TAI + outTime.tv_sec = time.tv_sec + leapseconds[NUM_LEAPSECOND_UPDATES - 1][1]; + outTime.tv_usec = time.tv_usec; + CHECK_NEGATIVE_TIME_STRUCT(outTime, outTime); + + return outTime; +} + +psTime psMJDToTime(double time) +{ + psTime outTime; + double days = 0.0; + double seconds = 0.0; + + CHECK_NEGATIVE_TIME(time, outTime); + + // Modified Julian date conversion courtesy of Eugene Magnier + days = time - 40587.0; + + // Convert to psTime/TAI + seconds = days * SEC_PER_DAY; + outTime.tv_usec = (seconds - (long)seconds) * 1000000.0; + outTime.tv_sec = seconds; + + CHECK_NEGATIVE_TIME_STRUCT(outTime, outTime); + + return outTime; +} + +psTime psJDToTime(double time) +{ + double days = 0.0; + double seconds = 0.0; + psTime outTime; + + CHECK_NEGATIVE_TIME(time, outTime); + + // Julian date conversion courtesy of Eugene Magnier + days = time - 2440587.5; + + // Convert to psTime/TAI + seconds = days * SEC_PER_DAY; + outTime.tv_sec = seconds; + outTime.tv_usec = (seconds - (long)seconds) * 1000000.0; + + CHECK_NEGATIVE_TIME_STRUCT(outTime, outTime); + + return outTime; +} + +psTime psTimevalToTime(struct timeval * time) +{ + psTime outTime; + + if (time == NULL) + { + psError(__func__, "Null value for timeval arg not allowed"); + return outTime; + } else if (time->tv_sec < 0) + { + psError(__func__, "Negative seconds are not allowed: %ld", time->tv_sec); + return outTime; + } else if (time->tv_usec < 0) + { + psError(__func__, "Negative microseconds are not allowed: %ld", time->tv_usec); + return outTime; + } + // Convert to psTime/TAI + outTime.tv_sec = time->tv_sec; + outTime.tv_usec = time->tv_usec; + + CHECK_NEGATIVE_TIME_STRUCT(outTime, outTime); + + return outTime; +} + +psTime psTMToTime(struct tm * time) +{ + int i; + int n; + int y; + int mon[] = { + 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 + }; + long epoch; + psTime outTime; + + i = 0; + n = 0; + y = 0; + epoch = 0; + + if (time == NULL) + { + psError(__func__, "Null value for tm arg not allowed"); + return outTime; + } else if (time->tm_year < 70) + { + psError(__func__, "Input times earlier than 1970 not allowed. Value: %d", time->tm_year + 1900); + return outTime; + } else if (time->tm_mon < 0 || time->tm_mon > 11) + { + psError(__func__, "Month must have a value from 0 to 11. Value: %d", time->tm_mon); + return outTime; + } else if (time->tm_mday < 1 || time->tm_mday > 31) + { + psError(__func__, "Day must have a value from 1 to 31. Value: %d", time->tm_mday); + return outTime; + } else if (time->tm_hour < 0 || time->tm_hour > 23) + { + psError(__func__, "Hour must have a value from 0 to 23. Value: %d", time->tm_hour); + return outTime; + } else if (time->tm_min < 0 || time->tm_min > 59) + { + psError(__func__, "Minute must have a value from 0 to 59. Value: %d", time->tm_min); + return outTime; + } else if (time->tm_sec < 0 || time->tm_sec > 59) + { + psError(__func__, "Second must have a value from 0 to 59. Value: %d", time->tm_sec); + return outTime; + } + + n = time->tm_year + 1900 - 1; + epoch = (time->tm_year - 70) * SEC_PER_YEAR + ((n / 4 - n / 100 + n / 400) - + (1969 / 4 - 1969 / 100 + 1969 / 400)) * SEC_PER_DAY; + + y = time->tm_year + 1900; + + // Adjust for leap years + for (i = 0; i < time->tm_mon; i++) + { + epoch += mon[i] * SEC_PER_DAY; + if (i == 1 && y % 4 == 0 && (y % 100 != 0 || y % 400 == 0)) { + epoch += SEC_PER_DAY; + } + } + + // Add everything + epoch += (time->tm_mday - 1) * SEC_PER_DAY; + epoch += time->tm_hour * SEC_PER_HOUR + time->tm_min * SEC_PER_MINUTE + time->tm_sec; + + // Create psTime + outTime.tv_usec = 0; + outTime.tv_sec = epoch; + + CHECK_NEGATIVE_TIME_STRUCT(outTime, outTime); + + return outTime; +} Index: /tags/rel2_1/psLib/src/astronomy/psTime.h =================================================================== --- /tags/rel2_1/psLib/src/astronomy/psTime.h (revision 1553) +++ /tags/rel2_1/psLib/src/astronomy/psTime.h (revision 1553) @@ -0,0 +1,203 @@ + +/** @file psTime.h + * + * @brief Definitions for time, time utilities, and conversion functions for use with psLib astronomy + * functions. + * + * A collection of functions are required by psLib to manipulate time data. These functions primarily consist + * of conversions between specific time formats. PSLib currently uses the UNIX timeval time system as the + * base upon which International Atomic Time (TAI) time is calculated. All time conversion functions within + * psLib, except those noted, are calculated in terms of TAI time, which is approxinmately 32 seconds faster + * than UTC/timeval. + * + * @author Ross Harman, MHPCC + * + * @version $Revision: 1.12 $ $Name: not supported by cvs2svn $ + * @date $Date: 2004-08-13 22:08:51 $ + * + * Copyright 2004 Maui High Performance Computing Center, University of Hawaii + */ + +#ifndef PSTIME_H +#define PSTIME_H + +#include +#include +#include + +#include "psType.h" + +/// @addtogroup Time +/// @{ + +/******************************************************************************/ + +/* TYPE DEFINITIONS */ + +/******************************************************************************/ + +/** Definition of psTime. + * + * The psTime struct is used by psLib to represent time values critical to + * astronomical calculations. This structure represents a time which is + * equivalent to TAI (International Atomic Time) and is measured in both + * seconds and microseconds. + */ +typedef struct timeval psTime; + +/*****************************************************************************/ + +/* FUNCTION PROTOTYPES */ + +/*****************************************************************************/ + +/** Get current TAI time. + * + * Gets current time from the system clock in correct TAI units. + * + * @return psTime: Struct with current time. + */ + +psTime psTimeGetTime(void); + +/** Convert psTime to ISO time in TAI units. + * + * Converts psTime to a null terminated string in the form of: + * YYYY/MM/DD,HH:MM:SS.SSS. This function assumes the input time already is + * in TAI time and does not add or subtract leapseconds. + * + * @return char*: Pointer null terminated array of chars in ISO time. + */ + +char *psTimeToISO( + psTime time ///< Input time to be converted. +); + +/** Convert psTime to UTC time. + * + * Converts psTime to UTC time in double precision floating point notation. + * The input to this must already be int TAI time. The result from this + * function is not in TAI units, but that of UTC, which does not contain + * leapseconds. + * + * @return psTime: UTC time psTime format. + */ + +psTime psTimeToUTC( + psTime time ///< Input time to be converted. +); + +/** Convert psTime to modified Julian date time. + * + * Converts psTime to modified Julian date (MJD) time. This function assumes + * the input time already is in TAI time and does not add or subtract + * leapseconds. + * + * @return double: Modified Julian Days (MJD) time. + */ +double psTimeToMJD( + psTime time ///< Input time to be converted. +); + +/** Convert psTime to Julian date time. + * + * Converts psTime to Julian date (JD) time. This function assumes the input + * time already is in TAI time and does not add or subtract leapseconds. + * + * @return double: Julian Date (JD) time. + */ +double psTimeToJD( + psTime time ///< Input time to be converted. +); + +/** Convert psTime to timeval time. + * + * Converts psTime to timeval time. This function assumes the input time + * already is in TAI time and does not add or subtract leapseconds. + * + * @return timeval: timeval struct time. + */ +struct timeval psTimeToTimeval( + psTime time ///< Input time to be converted. + ); + +/** Convert psTime to tm time. + * + * Converts psTime to tm time. This function assumes the input time already is in TAI time and does not add or + * subtract leapseconds. + * + * @return tm: tm struct time. + */ +struct tm *psTimeToTM( + psTime time ///< Input time to be converted. + ); + +/** Convert ISO to psTime. + * + * Converts ISO time to psTime. This function assumes the input time already + * is in TAI time and does not add or subtract leapseconds. + * + * @return psTime: time + */ +psTime psISOToTime( + char *time ///< Input time to be converted. +); + +/** Convert UTC to psTime. + * + * Converts UTC time to psTime. This function assumes the input time already + * is in TAI time and add or subtracts the necessary leapseconds. + * + * @return psTime: time in TAI units. + */ +psTime psUTCToTime( + psTime time ///< Input time to be converted. +); + +/** Convert MJD to psTime. + * + * Converts MJD time to psTime. This function assumes the input time already + * is in TAI time and does not add or subtract leapseconds. + * + * @return psTime: time. + */ +psTime psMJDToTime( + double time ///< Input time to be converted. +); + +/** Convert JD to psTime. + * + * Converts JD time to psTime. This function assumes the input time already + * is in TAI time and does not add or subtract leapseconds. + * + * @return psTime: time. + */ +psTime psJDToTime( + double time ///< Input time to be converted. +); + +/** Convert timeval to psTime. + * + * Converts timeval time to psTime. This function assumes the input time + * already is in TAI time and does not add or subtract leapseconds. + * + * @return psTime: time. + */ +psTime psTimevalToTime( + struct timeval *time ///< Input time to be converted. +); + +/** Convert tm time to psTime. + * + * Converts tm time to psTime. This function assumes the input time already + * is in TAI time and does not add or subtract leapseconds. + * + * @return psTime: time. + */ +psTime psTMToTime( + struct tm *time ///< Input time to be converted. +); + +/// @} + +#endif Index: /tags/rel2_1/psLib/src/astronomy/slalib.h =================================================================== --- /tags/rel2_1/psLib/src/astronomy/slalib.h (revision 1553) +++ /tags/rel2_1/psLib/src/astronomy/slalib.h (revision 1553) @@ -0,0 +1,119 @@ +/** @file slalib.h +* +* @brief Simple wrapper of the required fortran SLALIB functions +* +* @ingroup AstroImage +* +* @author Robert DeSonia, MHPCC +* +* @version $Revision: 1.6 $ $Name: not supported by cvs2svn $ +* @date $Date: 2004-08-13 01:14:26 $ +* +* Copyright 2004 Maui High Performance Computing Center, University of Hawaii +*/ + +#ifndef SLALIB_H +#define SLALIB_H + +#ifdef FORTRAN_UNDERSCORE_PREFIX +#ifdef FORTRAN_DOUBLE_UNDERSCORE_SUFFIX +#ifdef FORTRAN_UPPERCASE +#define slaAoppa _SLA_AOPPA__ +#define slaAopqk _SLA_AOPQK__ +#define slaOapqk _SLA_OAPQK__ +#else +#define slaAoppa _sla_aoppa__ +#define slaAopqk _sla_aopqk__ +#define slaOapqk _sla_oapqk__ +#endif +#elseif FORTRAN_NO_UNDERSCORE_SUFFIX +#ifdef FORTRAN_UPPERCASE +#define slaAoppa _SLA_AOPPA +#define slaAopqk _SLA_AOPQK +#define slaOapqk _SLA_OAPQK +#else +#define slaAoppa _sla_aoppa +#define slaAopqk _sla_aopqk +#define slaOapqk _sla_oapqk +#endif +#else +#ifdef FORTRAN_UPPERCASE +#define slaAoppa _SLA_AOPPA_ +#define slaAopqk _SLA_AOPQK_ +#define slaOapqk _SLA_OAPQK_ +#else +#define slaAoppa _sla_aoppa_ +#define slaAopqk _sla_aopqk_ +#define slaOapqk _sla_oapqk_ +#endif +#endif +#else +#ifdef FORTRAN_DOUBLE_UNDERSCORE_SUFFIX +#ifdef FORTRAN_UPPERCASE +#define slaAoppa SLA_AOPPA__ +#define slaAopqk SLA_AOPQK__ +#define slaOapqk SLA_OAPQK__ +#else +#define slaAoppa sla_aoppa__ +#define slaAopqk sla_aopqk__ +#define slaOapqk sla_oapqk__ +#endif +#elseif FORTRAN_NO_UNDERSCORE_SUFFIX +#ifdef FORTRAN_UPPERCASE +#define slaAoppa SLA_AOPPA +#define slaAopqk SLA_AOPQK +#define slaOapqk SLA_OAPQK +#else +#define slaAoppa sla_aoppa +#define slaAopqk sla_aopqk +#define slaOapqk sla_oapqk +#endif +#else +#ifdef FORTRAN_UPPERCASE +#define slaAoppa SLA_AOPPA_ +#define slaAopqk SLA_AOPQK_ +#define slaOapqk SLA_OAPQK_ +#else +#define slaAoppa sla_aoppa_ +#define slaAopqk sla_aopqk_ +#define slaOapqk sla_oapqk_ +#endif +#endif +#endif +extern void slaAoppa ( + double date, + double dut, + double elongm, + double phim, + double him, + double xp, + double yp, + double tdk, + double pmb, + double rh, + double wl, + double tlr, + double *AOPRMS + ); + +extern void slaAopqk ( + double RAP, + double DAP, + double *AOPRMS, + double *AOB, + double *ZOB, + double *HOB, + double *DOB, + double *ROB + ); + +extern void slaOapqk ( + char *TYPE, + double OB1, + double OB2, + double *AOPRMS, + double *RAP, + double *DAP + ); + +#endif Index: /tags/rel2_1/psLib/src/collections/.cvsignore =================================================================== --- /tags/rel2_1/psLib/src/collections/.cvsignore (revision 1553) +++ /tags/rel2_1/psLib/src/collections/.cvsignore (revision 1553) @@ -0,0 +1,1 @@ +*.i Index: /tags/rel2_1/psLib/src/collections/Makefile =================================================================== --- /tags/rel2_1/psLib/src/collections/Makefile (revision 1553) +++ /tags/rel2_1/psLib/src/collections/Makefile (revision 1553) @@ -0,0 +1,86 @@ +############################################################################### +## +## Makefile: collections +## +## $Revision: 1.28 $ $Name: not supported by cvs2svn $ +## $Date: 2004-08-09 20:29:43 $ +## +## Copyright 2004 Maui High Performance Computing Center, University of Hawaii +############################################################################### + +# Define variable prefix to the top level project - psLib +# This is necessary for definition is Makefile.Globals uses prefix + +ifndef prefix + export prefix=$(shell cd ../..;pwd) +endif + +# Define the two targets to be built + +TARGET_STATIC = libpslib.a + +# Include the make global definitions for the project + +include ../Makefile.Globals + +# Set CFLAGS used by the implicit rule to compile .c + +CFLAGS := $(CFLAGS_RELOC) -I../sysUtils + +# Define the source objects + +SRC_OBJS = psBitSet.o \ + psVector.o \ + psList.o \ + psScalar.o \ + psCompare.o \ + psArray.o \ + psHash.o + +OBJS = $(addprefix makedir/,$(SRC_OBJS)) + +# Define PHONY target "all" which will make all the necessary items + +all: $(TARGET_STATIC) + +# Rule to make static library + +libpslib.a: $(OBJS) +# The ar option -r is to add/replace object and -s is to create +# a symbol table in the archive + $(AR) rcs ../$@ $(OBJS) + +# Define PHONY target "install" which will install necessary files + +install: $(TARGET_STATIC) + install *.h $(includedir) + +# Define PHONY target "distclean" which will cleanup the distribution + +distclean: clean + $(RM) ../$(TARGET_STATIC) + +# Define PHONY target "clean" which will cleanup the development area + +clean: + @echo " Deleting intermediate files for 'collections'" + $(RM) $(OBJS) *.lint $(SRC_OBJS:.o=.i) + +cleandep: + $(RM) $(OBJS:.o=.d) + +%.lint: %.c + splint +posixlib -exportlocal -realcompare $(INCLUDE_GLOBAL) $? > $@; cat $@ + +%.i: %.c + $(CC) -E $(CFLAGS) -o $@ $< + +makedir/%.o: %.c + $(CC) -c $(CFLAGS) -o $@ $< + +makedir/%.d: %.c + $(CC) -MM $(CFLAGS) $< > $@.tmp + sed 's|\($*\)\.o[ :]*|\1.o $@ : |g' $@.tmp > $@ + $(RM) -f $@.tmp + +include $(OBJS:.o=.d) Index: /tags/rel2_1/psLib/src/collections/psArray.c =================================================================== --- /tags/rel2_1/psLib/src/collections/psArray.c (revision 1553) +++ /tags/rel2_1/psLib/src/collections/psArray.c (revision 1553) @@ -0,0 +1,122 @@ + +/** @file psArray.c + * + * @brief Contains support for basic vector types + * + * This file defines the basic type for a vector struct and functions useful + * in manupulating vectors. + * + * @author Ross Harman, MHPCC + * + * @version $Revision: 1.13 $ $Name: not supported by cvs2svn $ + * @date $Date: 2004-08-09 23:34:57 $ + * + * Copyright 2004 Maui High Performance Computing Center, University of Hawaii + */ + +/******************************************************************************/ + +/* INCLUDE FILES */ + +/******************************************************************************/ +#include // for qsort, etc. + +#include "psMemory.h" +#include "psError.h" +#include "psArray.h" +#include "psLogMsg.h" + +/*****************************************************************************/ + +/* FUNCTION IMPLEMENTATION - LOCAL */ + +/*****************************************************************************/ +static void arrayFree(psArray* restrict psArr); + +/*****************************************************************************/ + +/* FUNCTION IMPLEMENTATION - PUBLIC */ + +/*****************************************************************************/ +psArray* psArrayAlloc(unsigned int nalloc) +{ + psArray* psArr = NULL; + + // Invalid nalloc + if (nalloc < 1) { + psError(__func__, "Invalid value for nalloc. nalloc: %d\n", nalloc); + return NULL; + } + // Create vector struct + psArr = (psArray* ) psAlloc(sizeof(psArray)); + p_psMemSetDeallocator(psArr, (psFreeFcn) arrayFree); + + psArr->nalloc = nalloc; + psArr->n = nalloc; + + // Create vector data array + psArr->data = psAlloc(nalloc * sizeof(psPTR)); + + return psArr; +} + +psArray* psArrayRealloc(unsigned int nalloc, psArray* restrict in) +{ + // Invalid nalloc + if (nalloc < 1) { + psError(__func__, "Invalid value for realloc (%d)\n", nalloc); + return NULL; + } + + if (in == NULL) { + psError(__func__, "Null input vector\n"); + return NULL; + } else if (in->nalloc != nalloc) { // No need to realloc to same size + if (nalloc < in->n) { + for (int i = nalloc; i < in->n; i++) { // For reduction in vector size + psFree(in->data[i]); + } + in->n = nalloc; + } + // Realloc after decrementation to avoid accessing freed array elements + in->data = psRealloc(in->data, nalloc * sizeof(psPTR)); + in->nalloc = nalloc; + } + + return in; +} + +static void arrayFree(psArray* restrict psArr) +{ + if (psArr == NULL) { + return; + } + + psArrayElementFree(psArr); + + psFree(psArr->data); +} + +void psArrayElementFree(psArray* restrict psArr) +{ + + if (psArr == NULL) { + return; + } + + for (int i = 0; i < psArr->n; i++) { + psFree(psArr->data[i]); + psArr->data[i] = NULL; + } +} + +psArray* psArraySort(psArray* in, psComparePtrFcn compare) +{ + if (in == NULL) { + return NULL; + } + + qsort(in->data, in->n, sizeof(psPTR), (int (*)(const void *, const void *))compare); + + return in; +} Index: /tags/rel2_1/psLib/src/collections/psArray.h =================================================================== --- /tags/rel2_1/psLib/src/collections/psArray.h (revision 1553) +++ /tags/rel2_1/psLib/src/collections/psArray.h (revision 1553) @@ -0,0 +1,105 @@ + +/** @file psArray.h + * + * @brief Contains basic array definitions and operations + * + * This file defines the basic type for a array struct and functions useful + * in manupulating arrays. + * + * @ingroup Array + * + * @author Robert DeSonia, MHPCC + * @author Ross Harman, MHPCC + * + * @version $Revision: 1.16 $ $Name: not supported by cvs2svn $ + * @date $Date: 2004-08-11 19:47:31 $ + * + * Copyright 2004 Maui High Performance Computing Center, University of Hawaii + */ + +#ifndef PS_ARRAY_H +#define PS_ARRAY_H + +#include "psType.h" +#include "psCompare.h" + +/// @addtogroup Array +/// @{ + +/** An array to support primitive types. + * + * Struct for maintaining an array of frequently used primitive types. + * + */ +typedef struct +{ + unsigned int nalloc; ///< Total number of elements available. + unsigned int n; ///< Number of elements in use. + psPTR* data; ///< An Array of pointer elements +} +psArray; + +/*****************************************************************************/ + +/* FUNCTION PROTOTYPES */ + +/*****************************************************************************/ + +/** Allocate an array. + * + * Uses psLib memory allocation functions to create an array collection of + * data + * + * @return psArray* : Pointer to psArray. + * + */ +psArray* psArrayAlloc( + unsigned int nalloc ///< Total number of elements to make available. +); + +/** Reallocate an array. + * + * Uses psLib memory allocation functions to reallocate an array collection + * of data. + * + * @return psArray* : Pointer to psArray. + * + */ +psArray* psArrayRealloc( + unsigned int nalloc, ///< Total number of elements to make available. + psArray* restrict psArr ///< array to reallocate. +); + +/** Deallocate/Dereference elements of an array. + * + * Uses psLib memory allocation functions to deallocate/dereference elements + * of a array of void pointers. The array psArr is not freed, and its elements + * will all be set to NULL. + * + */ +void psArrayElementFree( + psArray* restrict psArr ///< Void pointer array to destroy. +); + +/** Sort the array according to an external compare function. + * + * Sorts an array via the specification of a comparison function + * to specify how the objects on the array should be sorted. + * + * The comparison function must return an integer less than, equal to, or + * greater than zero if the first argument is considered to be respectively + * less than, equal to, or greater than the second. + * + * If two members compare as equal, their order in the sorted array is + * undefined. + * + * @return psArray* The sorted array. + */ +psArray* psArraySort( + psArray* in, ///< input array to sort. + psComparePtrFcn compare ///< the compare function +); + +/// @} + +#endif Index: /tags/rel2_1/psLib/src/collections/psBitSet.c =================================================================== --- /tags/rel2_1/psLib/src/collections/psBitSet.c (revision 1553) +++ /tags/rel2_1/psLib/src/collections/psBitSet.c (revision 1553) @@ -0,0 +1,297 @@ + +/** @file psBitSet.c + * + * @brief Creates an array of bytes of arbitrary length for storing individual bits. + * + * Bit masks are useful tools for toggling various flags and options. This set of functions module provides + * a mechanism to create an array of bits of arbitrary length and manipulate them with basic binary + * operations. A print function is also provided to display the entire set of bits in binary format as a + * string. + * + * @author Ross Harman, MHPCC + * + * @version $Revision: 1.16 $ $Name: not supported by cvs2svn $ + * @date $Date: 2004-08-09 23:34:57 $ + * + * Copyright 2004 Maui High Performance Computing Center, University of Hawaii + */ + +/******************************************************************************/ + +/* INCLUDE FILES */ + +/******************************************************************************/ +#include +#include +#include +#include +#include + +#include "psBitSet.h" +#include "psMemory.h" +#include "psError.h" +#include "psAbort.h" + +/******************************************************************************/ + +/* DEFINE STATEMENTS */ + +/******************************************************************************/ + +// None + +/******************************************************************************/ + +/* TYPE DEFINITIONS */ + +/******************************************************************************/ + +// None + +/*****************************************************************************/ + +/* GLOBAL VARIABLES */ + +/*****************************************************************************/ + +// None + +/*****************************************************************************/ + +/* FILE STATIC VARIABLES */ + +/*****************************************************************************/ + +// None + +/*****************************************************************************/ + +/* FUNCTION IMPLEMENTATION - LOCAL */ + +/*****************************************************************************/ +static void psBitSetFree(psBitSet* restrict inBitSet); + +/** Private function to create a mask. + * + * Creates an eight bit mask with the given bit set. All other bits in the byte are zero. The input bit uses + * zero-based indexing, and is the cumulitive index within the array, not the localized byte's bit position. + * + * @return char*: Pointer to byte in which bit is contained. + */ +static char mask(int bit) +{ + char mask = (char)0x01; + + // Ignore splint warning about negative bit shifts + /* @i@ */ + mask = mask << (bit % 8); + + return mask; +} + +/*****************************************************************************/ + +/* FUNCTION IMPLEMENTATION - PUBLIC */ + +/*****************************************************************************/ +psBitSet* psBitSetAlloc(int n) +{ + int numBytes = 0; + psBitSet* newObj = NULL; + + if (n <= 0) { + psError(__func__, " : Line %d - Allocation size must be > 0: size = %d", __LINE__, n); + return 0; + } + + numBytes = ceil(n / 8.0); + newObj = psAlloc(sizeof(psBitSet)); + if (newObj == NULL) { + psAbort(__func__, " : Line %d - Failed to allocate memory", __LINE__); + } + p_psMemSetDeallocator(newObj, (psFreeFcn) psBitSetFree); + newObj->n = numBytes; + + // Ignore splint warning about releasing pointer members, since they've not been allocated yet + /* @i@ */ + newObj->bits = psAlloc(sizeof(char) * numBytes); + if (newObj->bits == NULL) { + psAbort(__func__, " : Line %d - Failed to allocate memory", __LINE__); + } + + memset(newObj->bits, numBytes, 0); + + return newObj; +} + +static void psBitSetFree(psBitSet* restrict inBitSet) +{ + if (inBitSet == NULL) { + psError(__func__, " : Line %d - Null psBitSet for inBitSet argument", __LINE__); + return; + } + psFree(inBitSet->bits); +} + +psBitSet* psBitSetSet(psBitSet* inBitSet, int bit) +{ + char *byte = NULL; + + if (inBitSet == NULL) { + psError(__func__, " : Line %d - Null psBitSet for inBitSet argument", __LINE__); + return inBitSet; + } else if (bit < 0) { + psError(__func__, " : Line %d - Bit position too small: %d", __LINE__, bit); + return inBitSet; + } else if (bit > inBitSet->n * 8 - 1) { + psError(__func__, " : Line %d - Bit position too large: %d", __LINE__, bit); + return inBitSet; + } + // Variable byte is the byte in the array that contains the bit to be set + byte = inBitSet->bits + bit / 8; + *byte |= mask(bit); + + return inBitSet; +} + +bool psBitSetTest(const psBitSet* inBitSet, int bit) +{ + char *byte = NULL; + + if (inBitSet == NULL) { + psError(__func__, " : Line %d - Null psBitSet for inBitSet argument", __LINE__); + return 0; + } else if (bit < 0) { + psError(__func__, " : Line %d - Bit position too small: %d", __LINE__, bit); + return 0; + } else if (bit > inBitSet->n * 8 - 1) { + psError(__func__, " : Line %d - Bit position too large: %d", __LINE__, bit); + return 0; + } + // Variable byte is the byte in the array that contains the bit to be tested + byte = inBitSet->bits + bit / 8; + if ((int)(*byte & mask(bit)) == 0) { + return 0; + } + + return 1; +} + +psBitSet* psBitSetOp(psBitSet* outBitSet, const psBitSet* restrict inBitSet1, char *operator, + const psBitSet* restrict inBitSet2) +{ + int i = 0; + int n = 0; + char tempChar = '0'; + char *outBits = NULL; + char *inBits1 = NULL; + char *inBits2 = NULL; + + if (inBitSet1 == NULL) { + psError(__func__, " : Line %d - Null psBitSet for inBitSet1 argument", __LINE__); + return outBitSet; + } + + if (operator == NULL) { + psError(__func__, " : Line %d - Null input operator\n", __LINE__); + return outBitSet; + } + + if (inBitSet2 == NULL) { + psError(__func__, " : Line %d - Null psBitSet for inBitSet2 argument", __LINE__); + return outBitSet; + } + + if (outBitSet == NULL) { + outBitSet = psBitSetAlloc(inBitSet1->n * 8); + } + + if (inBitSet1->n != inBitSet2->n || outBitSet->n != inBitSet1->n) { + psError(__func__, " : Line %d - psBitSet sizes not the same", __LINE__); + return outBitSet; + } + + n = outBitSet->n; + outBits = outBitSet->bits; + inBits1 = inBitSet1->bits; + inBits2 = inBitSet2->bits; + + tempChar = toupper(operator[0]); + switch (tempChar) { + case 'A': + for (i = 0; i < n; i++) { + outBits[i] = inBits1[i] & inBits2[i]; + } + break; + case 'O': + for (i = 0; i < n; i++) { + outBits[i] = inBits1[i] | inBits2[i]; + } + break; + case 'X': + for (i = 0; i < n; i++) { + outBits[i] = inBits1[i] ^ inBits2[i]; + } + break; + default: + psError(__func__, " : Line %d - Invalid psBitMask binary operation: %s", __LINE__, operator); + } + + return outBitSet; +} + +psBitSet* psBitSetNot(psBitSet* outBitSet, const psBitSet* restrict inBitSet) +{ + int i = 0; + int n = 0; + char *outBits = NULL; + char *inBits = NULL; + + if (inBitSet == NULL) { + psError(__func__, " : Line %d - Null psBitSet for inBitSet argument", __LINE__); + return outBitSet; + } + + n = inBitSet->n; + if (n == 0) { + psError(__func__, " : Line %d - No elements in inBitSet", __LINE__); + return outBitSet; + } + + if (outBitSet == NULL) { + outBitSet = psBitSetAlloc(n * 8); + } + + if (inBitSet->n != outBitSet->n) { + psError(__func__, " : Line %d - psBitSet sizes not the same", __LINE__); + return outBitSet; + } + + outBits = outBitSet->bits; + inBits = inBitSet->bits; + + for (i = 0; i < n; i++) { + outBits[i] = ~inBits[i]; + } + + return outBitSet; +} + +char *psBitSetToString(const psBitSet* restrict inBitSet) +{ + int i = 0; + int numBits = inBitSet->n * 8; + char *outString = psAlloc((size_t) numBits + 1); + + if (outString == NULL) { + psAbort(__func__, " : Line %d - Failed to allocate memory", __LINE__); + } + + for (i = 0; i < numBits; i++) { + outString[numBits - i - 1] = (psBitSetTest(inBitSet, i) == 1) ? '1' : '0'; + } + + outString[numBits] = 0; + + return outString; +} Index: /tags/rel2_1/psLib/src/collections/psBitSet.h =================================================================== --- /tags/rel2_1/psLib/src/collections/psBitSet.h (revision 1553) +++ /tags/rel2_1/psLib/src/collections/psBitSet.h (revision 1553) @@ -0,0 +1,134 @@ + +/** @file psBitSet.h + * + * @brief Creates an array of bytes of arbitrary length for storing individual bits. + * + * Bit masks are useful tools for toggling various flags and options. This set of functions module provides + * a mechanism to create an array of bits of arbitrary length and manipulate them with basic binary + * operations. A print function is also provided to display the entire set of bits in binary format as a + * string. + * + * @ingroup BitSet + * + * @author Ross Harman, MHPCC + * + * @version $Revision: 1.13 $ $Name: not supported by cvs2svn $ + * @date $Date: 2004-08-11 19:53:33 $ + * + * Copyright 2004 Maui High Performance Computing Center, University of Hawaii + */ + +#ifndef PSBITSET_H +#define PSBITSET_H + +/// @addtogroup BitSet +/// @{ + +/******************************************************************************/ + +/* TYPE DEFINITIONS */ + +/******************************************************************************/ + +/** Struct containing array of bytes to hold bit data and corresponding array length. + * + * The bits in the struct are assembled in as an array of bytes with eight bits per byte. The bits are + * arranged with the LSB in first (right most) position of the first array element. + */ +typedef struct +{ + int n; ///< Number of bytes in the array + char *bits; ///< Aray of bytes holding bits +} +psBitSet; + +/*****************************************************************************/ + +/* FUNCTION PROTOTYPES */ + +/*****************************************************************************/ + +/** Allocate a psBitSet. + * + * Create a psBitSet with the number of bits specified by the user. All bits are set to zero upon + * allocation. + * + * @return psBitSet* : Pointer to struct containing array of bits and size of array. + */ + +/*@null@*/ +psBitSet* psBitSetAlloc( + int n ///< Number of bits in psBitSet array +); + +/** Set a bit. + * + * Sets a bit at a given bit location, either one or zero. The bit is set based on a zero index with the + * first bit set in the zero bit slot of the zero element of the byte array. As an example, setting bit 3 in + * an array with two elements would result in an psBitSet that looks like 00000000 00001000. + * + * @return psBitSet* : Pointer to struct containing psBitSet. + */ +psBitSet* psBitSetSet( + /* @returned@ */ + psBitSet* restrict inMask, ///< Pointer to psBitSet to be set. + int bit ///< Bit to be set. +); + +/** Test the value of a bit. + * + * Prints the value of a bit at a given bit location, either one or zero. The resulting bit is based on a + * zero index format with the first bit set in the zero bit slot of the zero element of the byte array + * As an example, testing bit 3 in a psBitSet with two bytes that looks like 00000000 00001000 would return a + * value of one, since that is the value that was set. + * + * @return int: Value of bit, either one or zero. + */ + +bool psBitSetTest( + const psBitSet* restrict inMask, ///< Pointer psBitSet to be tested. + int bit ///< Bit to be tested. +); + +/** Perform a binary operation on two psBitSets + * + * Perform an AND, OR, or XOR on two psBitSets. If the BitMasks are not the same size, the operation will not + * be performed and an error message will be logged. + * + * @return psBitSet* : Pointer to struct containing result of binary operation. + */ +psBitSet* psBitSetOp( + /* @returned@ */ + psBitSet* restrict outMask, ///< Resulting psBitSet from binary operation + const psBitSet* restrict inMask1, ///< First psBitSet on which to operate + char *operator, ///< Bit operation + const psBitSet* restrict inMask2 ///< First psBitSet on which to operate +); + +/** Perform a not operation on a psBitSet + * + * Toggles bits in a psBitset. All zero bits are set to one and all one bits are set to zero. + * + * @return psBitSet* : Pointer to struct containing result of operation. + */ + +psBitSet* psBitSetNot( + psBitSet* outBitSet, ///< Resulting psBitSet from operation + const psBitSet* restrict inBitSet ///< Input psBitSet +); + +/** Convert the psBitSet to a string of ones and zeros. + * + * Converts the contents of a psBitSet to a string representation of its binary form of ones and zeros. The + * LSB is the right-most chracter. Each set of eight characters represents one byte. + * + * @return char*: Pointer to character array containing string data. + */ + +char *psBitSetToString( + const psBitSet* restrict inMask ///< psBitSet to convert */ +); + +/// @} + +#endif Index: /tags/rel2_1/psLib/src/collections/psCompare.c =================================================================== --- /tags/rel2_1/psLib/src/collections/psCompare.c (revision 1553) +++ /tags/rel2_1/psLib/src/collections/psCompare.c (revision 1553) @@ -0,0 +1,80 @@ + +/** @file psCompare.c + * @brief Comparison functions for sorting routines + * @ingroup Compare + * + * @author Robert Lupton, Princeton University + * @author Robert Daniel DeSonia, MHPCC + * + * @version $Revision: 1.4 $ $Name: not supported by cvs2svn $ + * @date $Date: 2004-08-07 00:06:06 $ + * + * Copyright 2004 Maui High Performance Computing Center, University of Hawaii + */ + +#include "psType.h" +#include "psCompare.h" + +#define COMPARE_NUMERIC_PTR(TYPE) \ +int psCompare##TYPE##Ptr(const void** a, const void** b) { \ + return **((ps##TYPE**)a) - **((ps##TYPE**)b); \ +} + +#define COMPARE_NUMERIC_PTR_DESCENDING(TYPE) \ +int psCompareDescending##TYPE##Ptr(const void** a, const void** b) { \ + return **((ps##TYPE**)b) - **((ps##TYPE**)a); \ +} + +#define COMPARE_NUMERIC(TYPE) \ +int psCompare##TYPE(const void* a, const void* b) { \ + return *((ps##TYPE*)a) - *((ps##TYPE*)b); \ +} + +#define COMPARE_NUMERIC_DESCENDING(TYPE) \ +int psCompare##TYPE##Descending(const void* a, const void* b) { \ + return *((ps##TYPE*)b) - *((ps##TYPE*)a); \ +} + +COMPARE_NUMERIC_PTR(S8) +COMPARE_NUMERIC_PTR(S16) +COMPARE_NUMERIC_PTR(S32) +COMPARE_NUMERIC_PTR(S64) +COMPARE_NUMERIC_PTR(U8) +COMPARE_NUMERIC_PTR(U16) +COMPARE_NUMERIC_PTR(U32) +COMPARE_NUMERIC_PTR(U64) +COMPARE_NUMERIC_PTR(F32) +COMPARE_NUMERIC_PTR(F64) + +COMPARE_NUMERIC_PTR_DESCENDING(S8) +COMPARE_NUMERIC_PTR_DESCENDING(S16) +COMPARE_NUMERIC_PTR_DESCENDING(S32) +COMPARE_NUMERIC_PTR_DESCENDING(S64) +COMPARE_NUMERIC_PTR_DESCENDING(U8) +COMPARE_NUMERIC_PTR_DESCENDING(U16) +COMPARE_NUMERIC_PTR_DESCENDING(U32) +COMPARE_NUMERIC_PTR_DESCENDING(U64) +COMPARE_NUMERIC_PTR_DESCENDING(F32) +COMPARE_NUMERIC_PTR_DESCENDING(F64) + +COMPARE_NUMERIC(S8) +COMPARE_NUMERIC(S16) +COMPARE_NUMERIC(S32) +COMPARE_NUMERIC(S64) +COMPARE_NUMERIC(U8) +COMPARE_NUMERIC(U16) +COMPARE_NUMERIC(U32) +COMPARE_NUMERIC(U64) +COMPARE_NUMERIC(F32) +COMPARE_NUMERIC(F64) + +COMPARE_NUMERIC_DESCENDING(S8) +COMPARE_NUMERIC_DESCENDING(S16) +COMPARE_NUMERIC_DESCENDING(S32) +COMPARE_NUMERIC_DESCENDING(S64) +COMPARE_NUMERIC_DESCENDING(U8) +COMPARE_NUMERIC_DESCENDING(U16) +COMPARE_NUMERIC_DESCENDING(U32) +COMPARE_NUMERIC_DESCENDING(U64) +COMPARE_NUMERIC_DESCENDING(F32) +COMPARE_NUMERIC_DESCENDING(F64) Index: /tags/rel2_1/psLib/src/collections/psCompare.h =================================================================== --- /tags/rel2_1/psLib/src/collections/psCompare.h (revision 1553) +++ /tags/rel2_1/psLib/src/collections/psCompare.h (revision 1553) @@ -0,0 +1,506 @@ +#if !defined(PS_COMPARE_H) +#define PS_COMPARE_H + +/** @file psCompare.h + * @brief Comparison functions for sorting routines + * + * @author Robert Daniel DeSonia, MHPCC + * + * @ingroup Compare + * + * @version $Revision: 1.4 $ $Name: not supported by cvs2svn $ + * @date $Date: 2004-08-11 19:58:11 $ + * + * Copyright 2004 Maui High Performance Computing Center, University of Hawaii + */ + +/** @addtogroup Compare +* @{ +*/ + +/** A comparison function for sorting elements that are pointers to data, + * e.g., for psList of pointers to numeric values. + * + * @return int an integer less than, equal to, or greater than zero if + * the first argument is considered to be respectively less + * than, equal to, or greater than the second. + */ +typedef int (*psComparePtrFcn) ( + const void **a, ///< first comparison target + const void **b ///< second comparison target +); + +/** A comparison function for sorting. + * + * @return int an integer less than, equal to, or greater than zero if + * the first argument is considered to be respectively less + * than, equal to, or greater than the second. + */ +typedef int (*psCompareFcn) ( + const void *a, ///< first comparison target + const void *b ///< second comparison target +); + +/** Compare function of psS8 data. For use with psListSort. + * + * @return int an integer less than, equal to, or greater than zero if + * the first argument is considered to be respectively less + * than, equal to, or greater than the second. + */ +int psCompareS8Ptr( + const void **a, ///< first comparison target + const void **b ///< second comparison target +); + +/** Compare function of psS16 data. For use with psListSort. + * + * @return int an integer less than, equal to, or greater than zero if + * the first argument is considered to be respectively less + * than, equal to, or greater than the second. + */ +int psCompareS16Ptr( + const void **a, ///< first comparison target + const void **b ///< second comparison target +); + +/** Compare function of psS32 data. For use with psListSort. + * + * @return int an integer less than, equal to, or greater than zero if + * the first argument is considered to be respectively less + * than, equal to, or greater than the second. + */ +int psCompareS32Ptr( + const void **a, ///< first comparison target + const void **b ///< second comparison target +); + +/** Compare function of psS64 data. For use with psListSort. + * + * @return int an integer less than, equal to, or greater than zero if + * the first argument is considered to be respectively less + * than, equal to, or greater than the second. + */ +int psCompareS64Ptr( + const void **a, ///< first comparison target + const void **b ///< second comparison target +); + +/** Compare function of psU8 data. For use with psListSort. + * + * @return int an integer less than, equal to, or greater than zero if + * the first argument is considered to be respectively less + * than, equal to, or greater than the second. + */ +int psCompareU8Ptr( + const void **a, ///< first comparison target + const void **b ///< second comparison target +); + +/** Compare function of psU16 data. For use with psListSort. + * + * @return int an integer less than, equal to, or greater than zero if + * the first argument is considered to be respectively less + * than, equal to, or greater than the second. + */ +int psCompareU16Ptr( + const void **a, ///< first comparison target + const void **b ///< second comparison target +); + +/** Compare function of psU32 data. For use with psListSort. + * + * @return int an integer less than, equal to, or greater than zero if + * the first argument is considered to be respectively less + * than, equal to, or greater than the second. + */ +int psCompareU32Ptr( + const void **a, ///< first comparison target + const void **b ///< second comparison target +); + +/** Compare function of psU64 data. For use with psListSort. + * + * @return int an integer less than, equal to, or greater than zero if + * the first argument is considered to be respectively less + * than, equal to, or greater than the second. + */ +int psCompareU64Ptr( + const void **a, ///< first comparison target + const void **b ///< second comparison target +); + +/** Compare function of psF32 data. For use with psListSort. + * + * @return int an integer less than, equal to, or greater than zero if + * the first argument is considered to be respectively less + * than, equal to, or greater than the second. + */ +int psCompareF32Ptr( + const void **a, ///< first comparison target + const void **b ///< second comparison target +); + +/** Compare function of psF64 data. For use with psListSort. + * + * @return int an integer less than, equal to, or greater than zero if + * the first argument is considered to be respectively less + * than, equal to, or greater than the second. + */ +int psCompareF64Ptr( + const void **a, ///< first comparison target + const void **b ///< second comparison target +); + +/** Compare function of psS8 data. For use with psListSort for descending ordering. + * + * @return int an integer less than, equal to, or greater than zero if + * the first argument is considered to be respectively greater + * than, equal to, or less than the second. + */ +int psCompareDescendingS8Ptr( + const void **a, ///< first comparison target + const void **b ///< second comparison target +); + +/** Compare function of psS16 data. For use with psListSort for descending ordering. + * + * @return int an integer less than, equal to, or greater than zero if + * the first argument is considered to be respectively greater + * than, equal to, or less than the second. + */ +int psCompareDescendingS16Ptr( + const void **a, ///< first comparison target + const void **b ///< second comparison target +); + +/** Compare function of psS32 data. For use with psListSort for descending ordering. + * + * @return int an integer less than, equal to, or greater than zero if + * the first argument is considered to be respectively greater + * than, equal to, or less than the second. + */ +int psCompareDescendingS32Ptr( + const void **a, ///< first comparison target + const void **b ///< second comparison target +); + +/** Compare function of psS64 data. For use with psListSort for descending ordering. + * + * @return int an integer less than, equal to, or greater than zero if + * the first argument is considered to be respectively greater + * than, equal to, or less than the second. + */ +int psCompareDescendingS64Ptr( + const void **a, ///< first comparison target + const void **b ///< second comparison target +); + +/** Compare function of psU8 data. For use with psListSort for descending ordering. + * + * @return int an integer less than, equal to, or greater than zero if + * the first argument is considered to be respectively greater + * than, equal to, or less than the second. + */ +int psCompareDescendingU8Ptr( + const void **a, ///< first comparison target + const void **b ///< second comparison target +); + +/** Compare function of psU16 data. For use with psListSort for descending ordering. + * + * @return int an integer less than, equal to, or greater than zero if + * the first argument is considered to be respectively greater + * than, equal to, or less than the second. + */ +int psCompareDescendingU16Ptr( + const void **a, ///< first comparison target + const void **b ///< second comparison target +); + +/** Compare function of psU32 data. For use with psListSort for descending ordering. + * + * @return int an integer less than, equal to, or greater than zero if + * the first argument is considered to be respectively greater + * than, equal to, or lessg than the second. + */ +int psCompareDescendingU32Ptr( + const void **a, ///< first comparison target + const void **b ///< second comparison target +); + +/** Compare function of psU64 data. For use with psListSort for descending ordering. + * + * @return int an integer less than, equal to, or greater than zero if + * the first argument is considered to be respectively greater + * than, equal to, or lessg than the second. + */ +int psCompareDescendingU64Ptr( + const void **a, ///< first comparison target + const void **b ///< second comparison target +); + +/** Compare function of psF32 data. For use with psListSort for descending ordering. + * + * @return int an integer less than, equal to, or greater than zero if + * the first argument is considered to be respectively greater + * than, equal to, or lessg than the second. + */ +int psCompareDescendingF32Ptr( + const void **a, ///< first comparison target + const void **b ///< second comparison target +); + +/** Compare function of psF64 data. For use with psListSort for descending ordering. + * + * @return int an integer less than, equal to, or greater than zero if + * the first argument is considered to be respectively greater + * than, equal to, or lessg than the second. + */ +int psCompareDescendingF64Ptr( + const void **a, ///< first comparison target + const void **b ///< second comparison target +); + +/** Compare function of psS8 data. + * + * @return int an integer less than, equal to, or greater than zero if + * the first argument is considered to be respectively less + * than, equal to, or greater than the second. + */ +int psCompareS8( + const void *a, ///< first comparison target + const void *b ///< second comparison target +); + + +/** Compare function of psS16 data. + * + * @return int an integer less than, equal to, or greater than zero if + * the first argument is considered to be respectively less + * than, equal to, or greater than the second. + */ +int psCompareS16( + const void *a, ///< first comparison target + const void *b ///< second comparison target +); + + +/** Compare function of psS32 data. + * + * @return int an integer less than, equal to, or greater than zero if + * the first argument is considered to be respectively less + * than, equal to, or greater than the second. + */ +int psCompareS32( + const void *a, ///< first comparison target + const void *b ///< second comparison target +); + + +/** Compare function of psS64 data. + * + * @return int an integer less than, equal to, or greater than zero if + * the first argument is considered to be respectively less + * than, equal to, or greater than the second. + */ +int psCompareS64( + const void *a, ///< first comparison target + const void *b ///< second comparison target +); + + +/** Compare function of psU8 data. + * + * @return int an integer less than, equal to, or greater than zero if + * the first argument is considered to be respectively less + * than, equal to, or greater than the second. + */ +int psCompareU8( + const void *a, ///< first comparison target + const void *b ///< second comparison target +); + + +/** Compare function of psU16 data. + * + * @return int an integer less than, equal to, or greater than zero if + * the first argument is considered to be respectively less + * than, equal to, or greater than the second. + */ +int psCompareU16( + const void *a, ///< first comparison target + const void *b ///< second comparison target +); + + +/** Compare function of psU32 data. + * + * @return int an integer less than, equal to, or greater than zero if + * the first argument is considered to be respectively less + * than, equal to, or greater than the second. + */ +int psCompareU32( + const void *a, ///< first comparison target + const void *b ///< second comparison target +); + + +/** Compare function of psU64 data. + * + * @return int an integer less than, equal to, or greater than zero if + * the first argument is considered to be respectively less + * than, equal to, or greater than the second. + */ +int psCompareU64( + const void *a, ///< first comparison target + const void *b ///< second comparison target +); + + +/** Compare function of psF32 data. + * + * @return int an integer less than, equal to, or greater than zero if + * the first argument is considered to be respectively less + * than, equal to, or greater than the second. + */ +int psCompareF32( + const void *a, ///< first comparison target + const void *b ///< second comparison target +); + + +/** Compare function of psF64 data. + * + * @return int an integer less than, equal to, or greater than zero if + * the first argument is considered to be respectively less + * than, equal to, or greater than the second. + */ +int psCompareF64( + const void *a, ///< first comparison target + const void *b ///< second comparison target +); + + +/** Compare function of psS8 data. + * + * @return int an integer less than, equal to, or greater than zero if + * the first argument is considered to be respectively greater + * than, equal to, or less than the second. + */ +int psCompareDescendingS8( + const void *a, ///< first comparison target + const void *b ///< second comparison target +); + + +/** Compare function of psS16 data. + * + * @return int an integer less than, equal to, or greater than zero if + * the first argument is considered to be respectively greater + * than, equal to, or less than the second. + */ +int psCompareDescendingS16( + const void *a, ///< first comparison target + const void *b ///< second comparison target +); + + +/** Compare function of psS32 data. + * + * @return int an integer less than, equal to, or greater than zero if + * the first argument is considered to be respectively greater + * than, equal to, or less than the second. + */ +int psCompareDescendingS32( + const void *a, ///< first comparison target + const void *b ///< second comparison target +); + + +/** Compare function of psS64 data. + * + * @return int an integer less than, equal to, or greater than zero if + * the first argument is considered to be respectively greater + * than, equal to, or less than the second. + */ +int psCompareDescendingS64( + const void *a, ///< first comparison target + const void *b ///< second comparison target +); + + +/** Compare function of psU8 data. + * + * @return int an integer less than, equal to, or greater than zero if + * the first argument is considered to be respectively greater + * than, equal to, or less than the second. + */ +int psCompareDescendingU8( + const void *a, ///< first comparison target + const void *b ///< second comparison target +); + + +/** Compare function of psU16 data. + * + * @return int an integer less than, equal to, or greater than zero if + * the first argument is considered to be respectively greater + * than, equal to, or less than the second. + */ +int psCompareDescendingU16( + const void *a, ///< first comparison target + const void *b ///< second comparison target +); + + +/** Compare function of psU32 data. + * + * @return int an integer less than, equal to, or greater than zero if + * the first argument is considered to be respectively greater + * than, equal to, or less than the second. + */ +int psCompareDescendingU32( + const void *a, ///< first comparison target + const void *b ///< second comparison target +); + + +/** Compare function of psU64 data. + * + * @return int an integer less than, equal to, or greater than zero if + * the first argument is considered to be respectively greater + * than, equal to, or less than the second. + */ +int psCompareDescendingU64( + const void *a, ///< first comparison target + const void *b ///< second comparison target +); + + +/** Compare function of psF32 data. + * + * @return int an integer less than, equal to, or greater than zero if + * the first argument is considered to be respectively greater + * than, equal to, or less than the second. + */ +int psCompareDescendingF32( + const void *a, ///< first comparison target + const void *b ///< second comparison target +); + + +/** Compare function of psF64 data. + * + * @return int an integer less than, equal to, or greater than zero if + * the first argument is considered to be respectively greater + * than, equal to, or less than the second. + */ +int psCompareDescendingF64( + const void *a, ///< first comparison target + const void *b ///< second comparison target +); + + +/// @} + +#endif Index: /tags/rel2_1/psLib/src/collections/psHash.c =================================================================== --- /tags/rel2_1/psLib/src/collections/psHash.c (revision 1553) +++ /tags/rel2_1/psLib/src/collections/psHash.c (revision 1553) @@ -0,0 +1,408 @@ + +/** @file psHash.c +* +* @brief Contains support for basic hashing functions. +* +* This file will hold the functions for defining a hash table with arbitrary +* data types, allocating/deallocating that hash table, adding and removing +* data from that hash table, and listing all keys defined in the hash table. +* +* @author Robert Lupton, Princeton University +* @author George Gusciora, MHPCC +* +* @version $Revision: 1.2 $ $Name: not supported by cvs2svn $ +* @date $Date: 2004-08-09 23:34:57 $ +* +* Copyright 2004 Maui High Performance Computing Center, University of Hawaii +*/ +#include +#include +#include +#include +#include "psHash.h" +#include "psMemory.h" +#include "psString.h" +#include "psTrace.h" +#include "psAbort.h" + +static psHashBucket* hashBucketAlloc(const char *key, void *data, psHashBucket* next); +static void hashBucketFree(psHashBucket* bucket); +static void *doHashWork(psHash* table, const char *key, void *data, bool remove + ); +static void hashFree(psHash* table); + +/****************************************************************************** +psHashKeyList(table): this function creates a linked list with an entry in +that list for every key in the hash table. +Inputs: + table: a hash table +Return; + The linked list + *****************************************************************************/ +psList* psHashKeyList(psHash* table) +{ + int i = 0; // Loop index variable + psList* myLinkList = NULL; // The output data structure + psHashBucket* ptr = NULL; // Used to step thru linked list. + + if (table == NULL) { + return NULL; + } + // Create the linked list + myLinkList = psListAlloc(NULL); + + // Loop through every bucket in the hash table. If that bucket is not + // NULL, then add the bucket's key to the linked list. + for (i = 0; i < table->nbucket; i++) { + if (table->buckets[i] != NULL) { + // Since a bucket contains a linked list of keys/data, we must + // step trough each key in that linked list: + + ptr = table->buckets[i]; + while (ptr != NULL) { + psListAdd(myLinkList, ptr->key, PS_LIST_HEAD); + ptr = ptr->next; + } + } + } + + // Return the linked list + return (myLinkList); +} + +/****************************************************************************** +hashBucketAlloc(key, data, next): This procedure creates a new hash bucket +with the specified key, data, and next. +Inputs: + key: the new bucket's key pointer + data: the new bucket's data pointer + next: the new bucket's key pointer +Return: + the new hash bucket. + *****************************************************************************/ +static psHashBucket* hashBucketAlloc(const char *key, void *data, psHashBucket* next) +{ + if (key == NULL) { + psAbort(__func__, "psHashBucket() called with NULL key."); + } + // Allocate memory for the new hash bucket. + psHashBucket* bucket = psAlloc(sizeof(psHashBucket)); + + p_psMemSetDeallocator(bucket, (psFreeFcn) hashBucketFree); + + // Initialize the bucket. + bucket->key = psStringCopy(key); + + if (data == NULL) { + // NOTE: Should we flag a warning message? + bucket->data = NULL; + } else { + bucket->data = psMemIncrRefCounter(data); + } + + bucket->next = next; + + return bucket; +} + +/****************************************************************************** +hashBucketFree(bucket): This procedure deallocates the specified +hash bucket. +Inputs: + bucket: the hash bucket to be freed. +Return: + NONE + *****************************************************************************/ +static void hashBucketFree(psHashBucket* bucket) +{ + if (bucket == NULL) { + return; + } + + psFree(bucket->key); + + psFree(bucket->data); +} + +/****************************************************************************** +psHashAlloc(nbucket): this procedure creates a new hash table with the +specified number of buckets. +Inputs: + nbucket: initial number of buckets +Return: + The new hash table. + *****************************************************************************/ +psHash* psHashAlloc(int nbucket) // initial number of buckets +{ + int i = 0; // loop index variable + + // Create the new hash table. + psHash* table = psAlloc(sizeof(psHash)); + + p_psMemSetDeallocator(table, (psFreeFcn) hashFree); + + // Allocate memory for the buckets. + table->buckets = psAlloc(nbucket * sizeof(psHashBucket* )); + table->nbucket = nbucket; + + psTrace("utils.hash", 1, "Creating %d-element hash table\n", nbucket); + + // Initialize all buckets to NULL. + for (i = 0; i < nbucket; i++) + { + table->buckets[i] = NULL; + } + + // Return the new hash table. + return table; +} + +/****************************************************************************** +psHashFree(table, itemFree): This procedure deallocates the specified hash +table. It loops through each bucket, and calls hashBucketFree() on that +bucket. + +Inputs: + table: a hash table +Return: + NONE + *****************************************************************************/ +static void hashFree(psHash* table) +{ + int i = 0; // Loop index variable. + + if (table == NULL) { + return; + } + // Loop through each bucket in the hash table. If that bucket is not + // NULL, then free the bucket via a function call to hashBucketFree(); + for (i = 0; i < table->nbucket; i++) { + + // A bucket is composed of a linked list of buckets. + while (table->buckets[i] != NULL) { + psHashBucket* bucket = table->buckets[i]; + table->buckets[i] = bucket->next; + psFree(bucket); + } + } + + // Free the bucket structure, then the hash table. + psFree(table->buckets); +} + +/****************************************************************************** +doHashWork(table, key, data, remove): This is an internal +procedure which does the bulk of the work in using the hash table. Depending +upon the input parameters, it will either insert a new key/data into the hash +table, retrieve the data for a specified key, or remove a key/data item. If +we try to insert a key that already exists in the hash table, then we deallocate +the existing data/key item. +Inputs: + table: a hash table + key: the key to insert, retrieve, or remove. Must not be NULL. + data: the data to insert, if not NULL + remove: set to non-zero if the key/data should be removed from the table. +Return: + NONE + +NOTE: consider removing this private function and simply putting the code +into the psHashInsert(), psHashLookup(), and psHashRemove(). Why? Because +there is little common code between those functions. + *****************************************************************************/ +static void *doHashWork(psHash* table, const char *key, void *data, bool remove + ) +{ + long int hash = 1; // This will contain an integer value + + // "hashed" from the key. + char *tmpchar = NULL; // Used in computing the hash function. + psHashBucket* ptr = NULL; // Used to retrieve the hash bucket. + psHashBucket* optr = NULL; // "original pointer": used to step + + // thru the linked list for a bucket. + + // The following condition should never be true, since this is a private + // function, but I'm checking it anyway since future coders might change + // the way this procedure is called. + if ((table == NULL) || (key == NULL)) { + + psAbort(__func__, "psHashRemove() called with NULL key or table."); + } + // NOTE: This is the originally supplied hash function. + // for (int i = 0, len = strlen(key); i < len; i++) { + // hash = (hash << 1) ^ key[i]; + // } + // hash &= (table->nbucket - 1); + + // This hash algorithm is from Sedgewick. NOTE: must reread to ensure that + // the size of the hash table is not required to be a prime number. + tmpchar = (char *)key; + for (hash = 0; *tmpchar != '\0'; tmpchar++) { + hash = (64 * hash + *tmpchar) % (table->nbucket); + } + + // NOTE: This should not be necessary, but for now, I'm checking bounds + // anyway. + if ((hash < 0) || (hash >= table->nbucket)) { + psAbort(__func__, "Internal hash function out of range (%d)", hash); + } + // ptr will have the correct hash bucket. + ptr = table->buckets[hash]; + + // We know the correct hash bucket, now we need to know what to do. + // If the data parameter is NULL, then, by definition, this is a retrieve + // or a remove operation on the hash table. + + if (data == NULL) { + if (remove + ) { + // We search through the linked list for this bucket in + // the hash table and look for an entry for this key. + + optr = ptr; + while (ptr != NULL) { + // Determine if this entry holds the correct key. + if (strcmp(key, ptr->key) == 0) { + // The following lines of code are fairly standard ways + // of removing an item from a single-linked list. + + void *data = ptr->data; + + optr->next = ptr->next; + if (ptr == table->buckets[hash]) { + table->buckets[hash] = ptr->next; + } + psFree(ptr); + + // By definition, the data associated with that key + // must be returned, not freed. + return data; + } + optr = ptr; + ptr = ptr->next; + } + return NULL; // not in hash + } + else { + // If we get here, then a retrieve operation is requested. So, + // we step trough the linked list at this bucket, and return the + // data once we find it, or return NULL if we don't. + while (ptr != NULL) { + if (strcmp(key, ptr->key) == 0) { + return ptr->data; + } + ptr = ptr->next; + } + return NULL; // not in hash + } + } else { + // We get here if this procedure was called with non-NULL data. + // Therefore, we should insert that data into the hash table. + // First, we search through the linked list for this bucket in + // the hash table and look for a duplicate entry for this key. + + while (ptr != NULL) { + if (strcmp(key, ptr->key) == 0) { + // We have found this key in the hash table. + + psTrace("utils.hash.insert", 3, "Replacing data for %s\n", key); + + // NOTE: I have changed this behavior from the originally + // supplied code. Formerly, if itemFree was NULL, then + // the new data was not inserted into the hash table. + + psFree(ptr->data); + + ptr->data = psMemIncrRefCounter(data); + return data; + } + ptr = ptr->next; + } + // We did not found key in the linked list for this bucket of the hash + // table. So, we insert this data at the head of that linked list. + + table->buckets[hash] = hashBucketAlloc(key, data, table->buckets[hash]); + return data; + } +} + +/****************************************************************************** +psHashInsert(table, key, data, itemFree): this procedure, which is part of +the public API, inserts a new key/data pair into the hash table. +Inputs: + table: a hash table + key: the key to use + data: the data to insert. + itemFree: a function pointer +Return: + boolean value defining success or failure + *****************************************************************************/ +bool psHashAdd(psHash* table, const char *key, void *data) +{ + if (table == NULL) { + psAbort(__func__, "psHashInsert() called with NULL hash table."); + } + if (key == NULL) { + psAbort(__func__, "psHashInsert() called with NULL key."); + } + if (data == NULL) { + psAbort(__func__, "psHashLookup() called with NULL data."); + } + + return (doHashWork(table, key, data, 0) != NULL); +} + +/****************************************************************************** +psHashLookup(table, key): this procedure, which is part of the public API, +looks up the specified key in the hash table and returns the data associated +with that key. + +Inputs: + table: a hash table + key: the key to use +Return: + The data associated with that key. + *****************************************************************************/ +void *psHashLookup(psHash* table, // table to lookup key in + const char *key) // key to lookup +{ + if (table == NULL) { + psAbort(__func__, "psHashLookup() called with NULL hash table."); + } + if (key == NULL) { + psAbort(__func__, "psHashLookup() called with NULL key."); + } + + return doHashWork(table, key, NULL, 0); +} + +/****************************************************************************** +psHashRemove(table, key, itemFree): this procedure, which is part of the +public API, removes the specified key from the hash table. +Inputs: + table: a hash table + key: the key to remove + itemFree: a function pointer +Return: + boolean value defining success or failure + *****************************************************************************/ +bool psHashRemove(psHash* table, const char *key) +{ + void *data = NULL; + bool retVal = false; + + if (table == NULL) { + psAbort(__func__, "psHashRemove() called with NULL hash table."); + } + if (key == NULL) { + psAbort(__func__, "psHashRemove() called with NULL key."); + } + + data = doHashWork(table, key, NULL, 1); + if (data != NULL) { + retVal = true; + } else { + retVal = false; + } + return retVal; +} Index: /tags/rel2_1/psLib/src/collections/psHash.h =================================================================== --- /tags/rel2_1/psLib/src/collections/psHash.h (revision 1553) +++ /tags/rel2_1/psLib/src/collections/psHash.h (revision 1553) @@ -0,0 +1,73 @@ + +/** @file psHash.h + * @brief Contains support for basic hashing functions. + * @ingroup HashTable + * + * This file will hold the prototypes for defining a hash table with arbitrary + * data types, allocating/deallocating that has table, adding and removing + * data from that hash table, and listing all keys defined in the hash table. + * + * @author Robert Lupton, Princeton University + * @author George Gusciora, MHPCC + * + * @version $Revision: 1.4 $ $Name: not supported by cvs2svn $ + * @date $Date: 2004-08-09 23:40:55 $ + * + * Copyright 2004 Maui High Performance Computing Center, University of Hawaii + */ +#if !defined(PS_HASH_H) +#define PS_HASH_H + +/** \addtogroup HashTable + * \{ + */ +#include + +#include "psList.h" + +/** A bucket that holds an item of data. */ +typedef struct psHashBucket +{ + char *key; ///< key for this item of data + void *data; ///< the data itself + struct psHashBucket* next; ///< list of other possible keys +} +psHashBucket; + +//typedef struct HashTable psHash; ///< Opaque type for a hash table + +/** The hash-table itself. */ +typedef struct psHash +{ + int nbucket; ///< Number of buckets in hash table. + psHashBucket* *buckets; ///< The bucket data. +} +psHash; + +/// Allocate hash buckets in table. +psHash* psHashAlloc(int nbucket ///< The number of buckets to allocate. + ); + +/// Insert entry into table. +bool psHashAdd(psHash* table, ///< table to insert in + const char *key, ///< key to use + void *data ///< data to insert + ); + +/// Lookup key in table. +void *psHashLookup(psHash* table, ///< table to lookup key in + const char *key ///< key to lookup + ); + +/// Remove key from table. +bool psHashRemove(psHash* table, ///< table to lookup key in + const char *key ///< key to lookup + ); + +/// List all keys in table. +psList* psHashKeyList(psHash* table ///< table to list keys from. + ); + +/* \} */// End of DataGroup Functions + +#endif Index: /tags/rel2_1/psLib/src/collections/psList.c =================================================================== --- /tags/rel2_1/psLib/src/collections/psList.c (revision 1553) +++ /tags/rel2_1/psLib/src/collections/psList.c (revision 1553) @@ -0,0 +1,475 @@ + +/** @file psList.c + * @brief Support for doubly linked lists + * @ingroup LinkedList + * + * @author Robert Lupton, Princeton University + * @author Robert Daniel DeSonia, MHPCC + * + * @version $Revision: 1.16 $ $Name: not supported by cvs2svn $ + * @date $Date: 2004-08-14 01:48:45 $ + * + * Copyright 2004 Maui High Performance Computing Center, University of Hawaii + */ + +#include +#include +#include +#include // we need a mutex to make this stuff thread safe. + +#include "psError.h" +#include "psAbort.h" +#include "psMemory.h" +#include "psList.h" +#include "psTrace.h" +#include "psLogMsg.h" + +#define ITER_INIT_HEAD ((void *)1) // next iteration should return head +#define ITER_INIT_TAIL ((void *)2) // next iteration should return tail + +// private functions. +static psListElem* listGetIterator(psList* list); +static int listGetIteratorIndex(psList* list); +static void listSetIterator(psList* list, int where, bool lockList); +static void listFree(psList* list); + +psList* psListAlloc(void *data) +{ + psList* list = psAlloc(sizeof(psList)); + + p_psMemSetDeallocator(list, (psFreeFcn) listFree); + + list->size = 0; + list->head = list->tail = NULL; + list->iter = ITER_INIT_HEAD; + list->iterIndex = PS_LIST_HEAD; + + pthread_mutex_init(&(list->lock), NULL) + ; + + if (data != NULL) { + psListAdd(list, data, PS_LIST_TAIL); + } + + return list; +} + +static void listFree(psList* list) +{ + if (list == NULL) { + return; + } + + pthread_mutex_lock(&list->lock) + ; + + for (psListElem* ptr = list->head; ptr != NULL;) { + psListElem* next = ptr->next; + + psFree(ptr->data); + psFree(ptr); + + ptr = next; + } + + pthread_mutex_unlock(&list->lock) + ; + + pthread_mutex_destroy(&list->lock) + ; + +} + +bool psListAdd(psList* list, void *data, int where) +{ + psListElem* position; + psListElem* elem; + int cursorIndex = 0; + + if (list == NULL) { + return false; + } + + if (data == NULL) { + return false; + } + + if (where <= PS_LIST_UNKNOWN) { + // / XXX What is the better way to communicate this failure to the caller? + psLogMsg(__func__, PS_LOG_WARN, "The given insert location (%i) for psListAdd is invalid.", where); + return false; + } + + elem = psAlloc(sizeof(psListElem)); + + pthread_mutex_lock(&list->lock) + ; + + if (where > 0 && where > list->size) { + psLogMsg(__func__, PS_LOG_WARN, + "Invalid index %d (only %d elements in psList); assuming tail.", where, list->size); + where = PS_LIST_TAIL; + } + + if (where == PS_LIST_TAIL || list->size == 0) { + // insert the element at the end of the list + elem->prev = list->tail; + elem->next = NULL; + + if (list->tail != NULL) { + list->tail->next = elem; + } + + if (list->head == NULL) { + list->head = elem; + } + list->tail = elem; + + list->size++; + list->iter = elem; + list->iterIndex = list->size - 1; + } else { + // move ourselves to the given position + listSetIterator(list, where, false); + position = listGetIterator(list); + cursorIndex = listGetIteratorIndex(list); + + if (position == NULL) { + psError(__func__, "%s failed to move cursor to specified location (%d)", __func__, where); + position = list->head; // since we no list->size != 0, this must be non-NULL + } + // insert our new element in front of the given position + elem->prev = position->prev; + elem->next = position; + position->prev = elem; + + if (elem->prev == NULL) { // must be front of list + list->head = elem; + } else { + elem->prev->next = elem; + } + + list->size++; + list->iter = elem; + list->iterIndex = cursorIndex; + } + + elem->data = psMemIncrRefCounter(data); + + pthread_mutex_unlock(&list->lock) + ; + + return true; +} + +/*****************************************************************************/ + +/* + * Remove an element from a list + */ +bool psListRemove(psList* list, void *data, int which) +{ + psListElem* elem = NULL; // element to remove + int cursorIndex = 0; + + if (list == NULL) { + psError(__func__, "list parameter found to be NULL in %s", __func__); + return false; + } + // get exclusive access to list so that other threads will not get in the way. + pthread_mutex_lock(&list->lock) + ; + + if (which == PS_LIST_UNKNOWN) { + // search list for the data item. + + int i = 0; // index + + for (psListElem* ptr = list->head; ptr != NULL; ptr = ptr->next) { + if (ptr->data == data) { + which = i; + break; + } + i++; + } + + if (which == PS_LIST_UNKNOWN) { + psError(__func__, "Failed to find item in given psList."); + pthread_mutex_unlock(&list->lock) + ; + return false; + } + } + // position the list's cursor to the desired location + listSetIterator(list, which, false); + elem = listGetIterator(list); + cursorIndex = listGetIteratorIndex(list); + + if (elem == NULL) { + psError(__func__, "Couldn't position to given index (%d) to remove element from list.", which); + pthread_mutex_unlock(&list->lock) + ; + return false; + } + + list->size--; + + if (elem->prev == NULL) { // head of list? + list->head = elem->next; + } else { + elem->prev->next = elem->next; + } + + if (elem->next == NULL) { // tail of list? + list->tail = elem->prev; + + // removed tail, so iter should be the last element of list to keep it valid + if (list->size > 0) { + list->iter = list->tail; + list->iterIndex = list->size - 1; + } else { + list->iter = ITER_INIT_TAIL; + } + } else { + elem->next->prev = elem->prev; + list->iter = elem->next; + list->iterIndex = cursorIndex; + } + + pthread_mutex_unlock(&list->lock) + ; + + // OK, delete list element and its data + psFree(elem->data); + psFree(elem); + + return true; +} + +void psListSetIterator(psList* list, int where) +{ + listSetIterator(list, where, true); +} + +void listSetIterator(psList* list, int where, bool lockList) +{ + psListElem* cursor; + int position; + + if (list == NULL) { + psError(__func__, "Unexpected null pointer for psList parameter (%s:%d).", __FILE__, __LINE__); + return; + } + + if (where == PS_LIST_CURRENT) { + return; + } + + if (lockList) { + pthread_mutex_lock(&list->lock) + ; + // don't want the list changing on us while we move about + } + + if (where >= (int)list->size) { + list->iter = NULL; + if (lockList) { + pthread_mutex_unlock(&list->lock) + ; + } + return; + } + + switch (where) { + case PS_LIST_HEAD: + list->iter = ITER_INIT_HEAD; + break; + + case PS_LIST_TAIL: + list->iter = ITER_INIT_TAIL; + break; + + case PS_LIST_PREVIOUS: + cursor = listGetIterator(list); + position = listGetIteratorIndex(list); + + if (cursor != NULL) { + list->iter = cursor->prev; + list->iterIndex = position - 1; + } + break; + + case PS_LIST_NEXT: + cursor = listGetIterator(list); + position = listGetIteratorIndex(list); + + if (cursor != NULL) { + list->iter = cursor->next; + list->iterIndex = position + 1; + } + break; + + case PS_LIST_CURRENT: + break; + + default: + if (where <= PS_LIST_HEAD) { // bascially same as PS_LIST_UNKNOWN above + psError(__func__, "Can't move to an unknown position. Not moving the iterator position."); + } else { + cursor = listGetIterator(list); + if (cursor == NULL) { // reset the iterator if it is invalid + list->iter = ITER_INIT_HEAD; + list->iterIndex = 0; + } + + int position = listGetIteratorIndex(list); + + if (where < position) { + int diff = position - where; + + for (int count = 0; count < diff; count++) { + listSetIterator(list, PS_LIST_PREVIOUS, false); + } + } else { + int diff = where - position; + + for (int count = 0; count < diff; count++) { + listSetIterator(list, PS_LIST_NEXT, false); + } + } + } + break; + } + + if (lockList) { + pthread_mutex_unlock(&list->lock) + ; + } +} + +psListElem* listGetIterator(psList* list) +{ + if (list == NULL) { + return NULL; + } + + if (list->iter == ITER_INIT_HEAD) { + return list->head; + } else if (list->iter == ITER_INIT_TAIL) { + return list->tail; + } else { + return list->iter; + } +} + +int listGetIteratorIndex(psList* list) +{ + if (list->iter == ITER_INIT_HEAD) { + return 0; + } else if (list->iter == ITER_INIT_TAIL) { + return list->size - 1; + } else { + return list->iterIndex; + } +} + +void *psListGet(psList* list, int which) +{ + psListElem* element; + + psListSetIterator(list, which); + element = listGetIterator(list); + + if (element == NULL) { + return NULL; + } else { + return element->data; + } +} + +/* + * and now return the previous/next element of the list + */ +void *psListGetNext(psList* list) +{ + return psListGet(list, PS_LIST_NEXT); +} + +void *psListGetPrevious(psList* list) +{ + return psListGet(list, PS_LIST_PREVIOUS); +} + +void *psListGetCurrent(psList* list) +{ + return psListGet(list, PS_LIST_CURRENT); +} + +/* + * Convert a psList to/from a psVoidPtrArray + */ +psArray* psListToArray(psList* restrict list) +{ + psListElem* ptr; + unsigned int n; + psArray* restrict arr; + + if (list == NULL) { + return NULL; + } + + if (list->size > 0) { + arr = psArrayAlloc(list->size); + } else { + arr = psArrayAlloc(1); + } + + arr->n = list->size; + + ptr = list->head; + n = list->size; + for (int i = 0; i < n; i++) { + arr->data[i] = psMemIncrRefCounter(ptr->data); + ptr = ptr->next; + } + + return arr; +} + +psList* psArrayToList(psArray* arr) +{ + unsigned int n; + psList* list; // list of elements + + if (arr == NULL) { + return NULL; + } + + list = psListAlloc(NULL); + n = arr->n; + for (int i = 0; i < n; i++) { + psListAdd(list, arr->data[i], PS_LIST_TAIL); + } + + return list; +} + +psList* psListSort(psList* list, psComparePtrFcn compare) +{ + psArray* arr; + + if (list == NULL) { + return NULL; + } + // convert to indexable vector for use by qsort. + arr = psListToArray(list); + psFree(list); + + arr = psArraySort(arr, compare); + + // convert back to linked list + list = psArrayToList(arr); + psFree(arr); + + return list; +} Index: /tags/rel2_1/psLib/src/collections/psList.h =================================================================== --- /tags/rel2_1/psLib/src/collections/psList.h (revision 1553) +++ /tags/rel2_1/psLib/src/collections/psList.h (revision 1553) @@ -0,0 +1,192 @@ +#if !defined(PS_LIST_H) +#define PS_LIST_H + +/** @file psList.h + * @brief Support for doubly linked lists + * + * @author Robert Lupton, Princeton University + * @author Robert Daniel DeSonia, MHPCC + * + * @ingroup LinkedList + * + * @version $Revision: 1.14 $ $Name: not supported by cvs2svn $ + * @date $Date: 2004-08-11 20:04:51 $ + * + * Copyright 2004 Maui High Performance Computing Center, University of Hawaii + */ + +#include // we need a mutex to make this stuff thread safe. +#include // we use the bool type. + +#include "psCompare.h" +#include "psArray.h" + +/** @addtogroup LinkedList + * @{ + */ + +/** Special values of index into list + * + * This list of possible list position values should be contiguous non-positive values ending with + * PS_LIST_UNKNOWN. Any value less-than-or-equal-to PS_LIST_UNKNOWN is considered a undefined position. + * + */ +enum { + PS_LIST_HEAD = 0, ///< at head + PS_LIST_TAIL = -1, ///< at tail + PS_LIST_PREVIOUS = -2, ///< previous element + PS_LIST_CURRENT = -3, ///< current element + PS_LIST_NEXT = -4, ///< next element + PS_LIST_UNKNOWN = -5 ///< unknown position (should be last in enum list) +}; + +/** Doubly-linked list element */ +typedef struct psListElem +{ + struct psListElem* prev; ///< previous link in list + struct psListElem* next; ///< next link in list + void *data; ///< real data item +} +psListElem; + +/** The psList Linked list structure. User should not allocate this struct + * directly; rather the psListAlloc should be used. + * + * @see psListAlloc, psListFree + */ +typedef struct +{ + unsigned int size; ///< number of elements on list + psListElem* head; ///< first element on list (may be NULL) + psListElem* tail; ///< last element on list (may be NULL) + psListElem* iter; ///< iteration cursor + unsigned int iterIndex; ///< the numeric position of the iteration cursor in the list + pthread_mutex_t lock; ///< mutex to lock a node during changes +} +psList; + +/** Creates a psList linked list object. + * + * @return psList* A new psList object. + */ +psList* psListAlloc( + void *data + ///< initial data item; may be NULL if no an empty psList is desired +) +; + +/** Adds an element to a psList at position given. + * + * @return psList* The psList with added data item. If list parameter is + * NULL, the return value will also be NULL. + */ +bool psListAdd( + psList* restrict list, ///< list to add to (if NULL, nothing is done) + void *data, ///< data item to add. If NULL, list is not modified. + int where ///< index, PS_LIST_HEAD, PS_LIST_TAIL, or numbered location. +); + +/** Remove an item from a list. If which parameter is PS_LIST_UNKNOWN, + * + * @return bool TRUE if element is successfully removed, otherwise FALSE. + */ +bool psListRemove( + psList* restrict list, + ///< list to remove element from + void *data, + ///< if which is PS_LIST_UNKNOWN, data item to find and remove, otherwise this is ignored. + int which + ///< index of item, or PS_LIST_UNKNOWN, PS_LIST_NEXT, PS_LIST_PREV, or numbered location. +); + +/** Retrieve an item from a list. + * + * @return void* the item corresponding to the which parameter. If + * which is invalid (e.g., a numbered index greater + * than the list size or if the list is empty), a + * NULL is returned. + */ +void *psListGet( + psList* restrict list, ///< list to retrieve element from + int which ///< index number, or PS_LIST_NEXT, PS_LIST_PREV, PS_LIST_UNKNOWN +); + +/** Set the iterator of the list to a given position. If where is invalid the + * iterator position is not changed. + * + */ +void psListSetIterator( + psList* restrict list, ///< list to retrieve element from + int where ///< index number, PS_LIST_HEAD, or PS_LIST_TAIL +); + +/** Get next element relative to the iterator. This also moves the iterator to + * the next list position. + * + * @return void* the data item next on the list or NULL if the iterator + * is already pointing to the last element or the list + * parameter was NULL. + */ +void *psListGetNext( + psList* restrict list ///< list to retrieve element from +); + +/** Get current element according to the psList's iterator cursor. This does + * not move the iterator location. + * + * @return void* the data item cooresponding to current iterator + * cursor position of the list, or NULL if either the + * iterator is not valid or list parameter was NULL. + */ +void *psListGetCurrent( + psList* restrict list ///< list to retrieve element from +); + +/** Get previous element relative to list's iterator. This also moves the + * iterator to the previous list position. + * + * @return void* the data item previous on the list or NULL if the iterator + * is already pointing to the first element or the list + * parameter was NULL. + */ +void *psListGetPrevious( + psList* restrict list ///< list to retrieve element from +); + +/** Convert a linked list to an array + * + * @return psArray* A new psArray populated with elements from the list, + * or NULL if the given dlist parameter is NULL. + */ +psArray* psListToArray( + psList* dlist ///< List to convert +); + +/** Convert array to a doubly-linked list + * + * @return psList* A new psList populated with elements formt the psArray, + * or NULL is the given arr parameter is NULL. + */ +psList* psArrayToList( + psArray* arr ///< vector to convert +); + +/** Sort a list via a comparison function. + * + * The comparison function must return an integer less than, equal to, or + * greater than zero if the first argument is considered to be respectively + * less than, equal to, or greater than the second. + * + * If two members compare as equal, their order in the sorted array is + * undefined. + * + * @return psList* Sorted list. + */ +psList* psListSort( + psList* list, ///< the list to sort + psComparePtrFcn compare ///< the comparison function +); + +/// @} End of DataGroup Functions + +#endif Index: /tags/rel2_1/psLib/src/collections/psMetadata.c =================================================================== --- /tags/rel2_1/psLib/src/collections/psMetadata.c (revision 1553) +++ /tags/rel2_1/psLib/src/collections/psMetadata.c (revision 1553) @@ -0,0 +1,761 @@ + +/** @file psMetadata.c +* +* +* @brief Contains metadata struuctures, enumerations and functions prototypes +* +* This file defines metadata item, metadata type, metadata flags, metadata containers, and function +* prototypes necessary creating psLib metadata APIs +* +* @ingroup Metadata +* +* @author Ross Harman, MHPCC +* +* @version $Revision: 1.24 $ $Name: not supported by cvs2svn $ +* @date $Date: 2004-08-14 02:55:46 $ +* +* Copyright 2004 Maui High Performance Computing Center, University of Hawaii +*/ + +/******************************************************************************/ +/* INCLUDE FILES */ +/******************************************************************************/ +#include +#include +#include + +#include "fitsio.h" +#include "psType.h" +#include "psMemory.h" +#include "psError.h" +#include "psAbort.h" +#include "psList.h" +#include "psHash.h" +#include "psMetadata.h" +#include "psString.h" + +/******************************************************************************/ +/* DEFINE STATEMENTS */ +/******************************************************************************/ + +#define FITS_ERROR(STRING,PS_ERROR) \ +fits_get_errstatus(status, fitsErr); \ +psError( __func__, STRING, PS_ERROR, fitsErr); \ +status = 0; \ +return output; + +/** Maximum size of a FITS line */ +#define FITS_LINE_SIZE 80 + +/** Maximum size of a string */ +#define MAX_STRING_LENGTH 1024 + +/******************************************************************************/ +/* TYPE DEFINITIONS */ +/******************************************************************************/ + +// None + +/*****************************************************************************/ +/* GLOBAL VARIABLES */ +/*****************************************************************************/ + +// None + +/*****************************************************************************/ +/* FILE STATIC VARIABLES */ +/*****************************************************************************/ + +static int metadataId = 0; + +/*****************************************************************************/ +/* FUNCTION IMPLEMENTATION - LOCAL */ +/*****************************************************************************/ + +static void metadataItemFree(psMetadataItem* metadataItem) +{ + psMetadataType type; + + type = metadataItem->type; + + if (metadataItem == NULL) { + return; + } + + psFree(metadataItem->name); + psFree(metadataItem->comment); + psFree(metadataItem->items); + + if (type == PS_META_STR || + type == PS_META_IMG || + type == PS_META_JPEG || type == PS_META_PNG || type == PS_META_ASTROM || type == PS_META_UNKNOWN) { + psFree(metadataItem->data.V); + } +} + +static void metadataFree(psMetadata* metadata) +{ + if (metadata == NULL) { + return; + } + psFree(metadata->list); + psFree(metadata->table); +} + +/*****************************************************************************/ +/* FUNCTION IMPLEMENTATION - PUBLIC */ +/*****************************************************************************/ + +psMetadataItem* psMetadataItemAlloc(const char *name, psMetadataType type, const char *comment, ...) +{ + va_list argPtr; + psMetadataItem* metadataItem = NULL; + + // Get the variable list parameters to pass to allocation function + va_start(argPtr, comment); + + // Call metadata item allocation + metadataItem = psMetadataItemAllocV(name, type, comment, argPtr); + + // Clean up stack after variable arguement has been used + va_end(argPtr); + + return metadataItem; +} + +psMetadataItem* psMetadataItemAllocV(const char *name, psMetadataType type, const char *comment, + va_list argPtr) +{ + psMetadataItem* metadataItem = NULL; + + if (name == NULL) { + psError(__func__, "Null value for name not allowed"); + return NULL; + } + // Allocate metadata item + metadataItem = (psMetadataItem* ) psAlloc(sizeof(psMetadataItem)); + if (metadataItem == NULL) { + psAbort(__func__, "Failed to allocate memory"); + } + // Set deallocator + p_psMemSetDeallocator(metadataItem, (psFreeFcn) metadataItemFree); + + // Allocate and set metadata item comment + metadataItem->comment = (char *)psAlloc(sizeof(char) * MAX_STRING_LENGTH); + if (comment == NULL) { + // Per SDRS, null isn't allowed, must use "" instead + strncpy(metadataItem->comment, "", MAX_STRING_LENGTH); + } else { + strncpy(metadataItem->comment, comment, MAX_STRING_LENGTH); + } + + // Set metadata item unique id + *(int *)(&metadataItem->id) = ++metadataId; + + // Set metadata item type + metadataItem->type = type; + + // Set metadata item value + switch (type) { + case PS_META_ITEM_SET: + metadataItem->data.V = NULL; + break; + case PS_META_BOOL: + metadataItem->data.B = (bool)va_arg(argPtr, int); + break; + case PS_META_S32: + metadataItem->data.S32 = va_arg(argPtr, psS32); + break; + case PS_META_F32: + metadataItem->data.F32 = (psF32)va_arg(argPtr, psF64); + break; + case PS_META_F64: + metadataItem->data.F64 = va_arg(argPtr, psF64); + break; + case PS_META_STR: + metadataItem->data.V = psStringNCopy(va_arg(argPtr, char *), MAX_STRING_LENGTH); + break; + case PS_META_IMG: + case PS_META_JPEG: + case PS_META_PNG: + case PS_META_ASTROM: + case PS_META_UNKNOWN: + default: + psError(__func__, "Invalid psMetadataType: %d", type); + } + + // Allocate and set metadata item name + metadataItem->name = (char *)psAlloc(sizeof(char) * MAX_STRING_LENGTH); + vsprintf(metadataItem->name, name, argPtr); + + // Allocate metadata items with same name. + metadataItem->items = psListAlloc(NULL); + + return metadataItem; +} + +psMetadata* psMetadataAlloc(void) +{ + psList* list = NULL; + psHash* table = NULL; + psMetadata* metadata = NULL; + + // Allocate metadata + metadata = (psMetadata* ) psAlloc(sizeof(psMetadata)); + if (metadata == NULL) { + psAbort(__func__, "Failed to allocate metadata"); + } + // Set deallocator + p_psMemSetDeallocator(metadata, (psFreeFcn) metadataFree); + + // Allocate metadata's internal containers + list = (psList* ) psListAlloc(NULL); + if (list == NULL) { + psAbort(__func__, "Failed to allocate list"); + } + + table = (psHash* ) psHashAlloc(10); + if (table == NULL) { + psAbort(__func__, "Failed to allocate table"); + } + + metadata->list = list; + metadata->table = table; + + return metadata; +} + +bool psMetadataAddItem( psMetadata *restrict md, int where, psMetadataItem *restrict metadataItem ) +{ + char * key = NULL; + psHash *mdTable = NULL; + psList *mdList = NULL; + psMetadataItem *existingEntry = NULL; + psMetadataItem *newFolderEntry = NULL; + psMetadataType newType = PS_META_ITEM_SET; + + if(md == NULL) { + psError( __func__, "Null metadata collection not allowed" ); + return false; + } + + if(metadataItem == NULL) { + psError( __func__, "Null metadata item not allowed" ); + return false; + } + + newType = metadataItem->type; + + mdTable = md->table; + if(mdTable == NULL) { + psError( __func__, "Null metadata table not allowed" ); + return false; + } + + mdList = md->list; + if(mdList == NULL) { + psError( __func__, "Null metadata list not allowed"); + return false; + } + + key = metadataItem->name; + if(key == NULL) { + psError(__func__, "Null key item not allowed"); + return false; + } + + // See if key is already in table + existingEntry = (psMetadataItem*)psHashLookup(mdTable, key); + if(existingEntry != NULL) { + + if(existingEntry->type == PS_META_ITEM_SET) { + + // Add leaf node to existing folder node + if(!psListAdd(existingEntry->items, metadataItem, PS_LIST_TAIL)) { + psError( __func__, "Couldn't add metadata item to items list. Name: %s", + metadataItem->name ); + return false; + } + } else if(existingEntry->type != PS_META_ITEM_SET && newType!= PS_META_ITEM_SET) { + + // Leaf node replaces another leaf. Make new folder node and add leaves. + newFolderEntry = psMetadataItemAlloc(key, PS_META_ITEM_SET, NULL, NULL); + + if(!psListAdd(newFolderEntry->items, existingEntry, PS_LIST_TAIL)) { + psError( __func__, "Couldn't add metadata item to items list. Name: %s", key); + psFree(newFolderEntry); + return false; + } + + if(!psListAdd(newFolderEntry->items, metadataItem, PS_LIST_TAIL)) { + psError( __func__, "Couldn't add metadata item to items list. Name: %s", key); + psFree(newFolderEntry); + return false; + } + + if(!psHashRemove(mdTable, key)) { + psError( __func__, "Couldn't remove metadata item from metadata table. Name: %s", key); + psFree(newFolderEntry); + return false; + } + + if(!psHashAdd(mdTable, key, newFolderEntry)) { + psError( __func__, "Couldn't add metadata item to metadata table. Name: %s", key); + psFree(newFolderEntry); + return false; + } + + // Remove local reference to new folder node + psMemDecrRefCounter(newFolderEntry); + } else { + + // Folder node replaces leaf or folder node - Put old node into new folder and remove from table + if(!psListAdd(metadataItem->items, existingEntry, PS_LIST_TAIL)) { + psError( __func__, "Couldn't add metadata item to items list. Name: %s", key); + return false; + } + + if(!psHashRemove(mdTable, key)) { + psError( __func__, "Couldn't remove metadata item from metadata table. Name: %s", key); + return false; + } + + if(!psHashAdd(mdTable, key, metadataItem)) { + psError( __func__, "Couldn't add metadata item to metadata table. Name: %s", key); + return false; + } + } + } else { + + // Node doesn't exist - Add new metadata item to metadata collection's hash + if(!psHashAdd(mdTable, key, metadataItem)) { + psError( __func__, "Couldn't add metadata item to metadata table. Name: %s", key); + return false; + } + } + + // Add all items to metadata collection's list, even if they have the same metadata item names + if(!psListAdd( mdList, metadataItem, where )) { + psError( __func__, "Couldn't add metadata item to metadata collection list. Name: %s", + metadataItem->name ); + return false; + } + + return true; +} + +bool psMetadataAdd(psMetadata* restrict md, int where, const char *name, psMetadataType type, + const char *comment, ...) +{ + va_list argPtr; + psMetadataItem* metadataItem = NULL; + + va_start(argPtr, comment); + metadataItem = psMetadataItemAllocV(name, type, comment, argPtr); + va_end(argPtr); + + if (!psMetadataAddItem(md, where, metadataItem)) { + psError(__func__, "Couldn't add metadata item to metadata collection list. Name: %s", + metadataItem->name); + psFree(metadataItem); + return false; + } + // Decrement reference count, since the metadata item is now in metadata collection and no longer needed + // here + psMemDecrRefCounter(metadataItem); + + return true; +} + + + +bool psMetadataRemove(psMetadata* restrict md, int where, const char *restrict key) +{ + int numChildren = 0; + psList* mdList = NULL; + psHash* mdTable = NULL; + psMetadataItem* entry = NULL; + psMetadataItem* entryChild = NULL; + + + if (md == NULL) { + psError(__func__, "Null metadata collection not allowed"); + return false; + } + + mdList = md->list; + if (mdList == NULL) { + psError(__func__, "Null metadata list not allowed"); + return false; + } + + mdTable = md->table; + if (mdTable == NULL) { + psError(__func__, "Null metadata table not allowed"); + return false; + } + // Select removal by key or index + if (key != NULL) { + + // Remove by key name + entry = (psMetadataItem* ) psHashLookup(mdTable, key); + if (entry == NULL) { + psError(__func__, "Couldn't find metadata item. Name: %s", key); + return false; + } + + numChildren = entry->items->size; + if (entry->type == PS_META_ITEM_SET && numChildren > 0) { + + // Table entry has children. Entry and children must be removed from metadata collection's list + psListSetIterator(entry->items, PS_LIST_HEAD); + entryChild = psListGetCurrent(entry->items); + while (entryChild != NULL) { + if (!psListRemove(mdList, entryChild, PS_LIST_UNKNOWN)) { + psError(__func__, "Couldn't remove metadata item from list. Name: %s", key); + return false; + } + entryChild = psListGetNext(entry->items); + } + } else { + + // Table entry has no children. Remove entry from metadata collection's list + if (!psListRemove(mdList, entry, PS_LIST_UNKNOWN)) { + psError(__func__, "Couldn't remove metadata item from list. Name: %s", key); + return false; + } + } + // Remove entry from metadata collection's table + if (!psHashRemove(mdTable, key)) { + psError(__func__, "Couldn't remove metadata item from table. Name: %s", key); + return false; + } + } else { + + // Remove by index + entry = psListGet(mdList, where); + if (entry == NULL) { + psError(__func__, "Couldn't find metadata item in list. Index: %d", where); + return false; + } + + key = entry->name; + if (key == NULL) { + psError(__func__, "Null key name not allowed. Index: %d", where); + return false; + } + // Use recursive remove, now that key is known + psMetadataRemove(md, PS_LIST_UNKNOWN, key); + } + + return true; +} + +psMetadataItem* psMetadataLookup(psMetadata* restrict md, const char *restrict key) +{ + psHash* mdTable = NULL; + psMetadataItem* entry = NULL; + + + if (md == NULL) { + psError(__func__, "Null metadata collection not allowed"); + return NULL; + } + + mdTable = md->table; + if (mdTable == NULL) { + psError(__func__, "Null metadata table not allowed"); + return NULL; + } + + if (key == NULL) { + psError(__func__, "Null key name not allowed"); + return NULL; + } + + entry = (psMetadataItem* ) psHashLookup(mdTable, key); + if (entry == NULL) { + psError(__func__, "Could not find metadata item. Key: %s", key); + return NULL; + } + + return entry; +} + +psMetadataItem* psMetadataGet(psMetadata* restrict md, int where) +{ + psList* mdList = NULL; + psMetadataItem* entry = NULL; + + + if (md == NULL) { + psError(__func__, "Null metadata collection not allowed"); + return NULL; + } + + mdList = md->list; + if (mdList == NULL) { + psError(__func__, "Null metadata list not allowed"); + return NULL; + } + + entry = (psMetadataItem* ) psListGet(mdList, where); + if (entry == NULL) { + psError(__func__, "Couldn't find metadata item with given index. Index: %d", where); + return NULL; + } + + return entry; +} + +bool psMetadataSetIterator(psMetadata* restrict md, int where) +{ + psList* mdList = NULL; + + if (md == NULL) { + psError(__func__, "Null metadata collection not allowed"); + return false; + } + + mdList = md->list; + if (mdList == NULL) { + psError(__func__, "Null metadata list not allowed"); + return false; + } + + psListSetIterator(mdList, where); + + return true; +} + +psMetadataItem* psMetadataGetNext(psMetadata* restrict md, const char *restrict match, int which) +{ + psList* mdList = NULL; + psMetadataItem* entry = NULL; + + + if (md == NULL) { + psError(__func__, "Null metadata collection not allowed"); + return NULL; + } + + mdList = md->list; + if (mdList == NULL) { + psError(__func__, "Null metadata list not allowed"); + return NULL; + } + + psListSetIterator(mdList, which); + entry = psListGetCurrent(mdList); + while (entry != NULL) { + if(match != NULL) { + if (!strncmp(match, entry->name, strlen(match))) { + + // Match found + return entry; + } + entry = psListGetNext(mdList); + } else { + return psListGetNext(mdList); + } + } + + // Match not found + if (entry == NULL) { + psError(__func__, "Couldn't find metadata item"); + } + + return entry; +} + +psMetadataItem* psMetadataGetPrevious(psMetadata* restrict md, const char *restrict match, int which) +{ + psList* mdList = NULL; + psMetadataItem* entry = NULL; + + + if (md == NULL) { + psError(__func__, "Null metadata collection not allowed"); + return NULL; + } + + mdList = md->list; + if (mdList == NULL) { + psError(__func__, "Null metadata list not allowed"); + return NULL; + } + + psListSetIterator(mdList, which); + entry = psListGetCurrent(mdList); + while (entry != NULL) { + if(match != NULL) { + if (!strncmp(match, entry->name, strlen(match))) { + + // Match found + return entry; + } + entry = psListGetPrevious(mdList); + } else { + return psListGetPrevious(mdList); + } + } + + // Match not found + if (entry == NULL) { + psError(__func__, "Couldn't find metadata item", match); + } + + return entry; +} + +void psMetadataItemPrint(FILE * fd, const char *format, const psMetadataItem* restrict metadataItem) +{ + psMetadataType type; + + if (fd == NULL) { + psError(__func__, "Null file descriptor not allowed"); + return; + } + + if (format == NULL) { + psError(__func__, "Null format not allowed"); + return; + } + + if (metadataItem == NULL) { + psError(__func__, "Null metadata not allowed"); + return; + } + + type = metadataItem->type; + + switch (type) { + case PS_META_BOOL: + fprintf(fd, format, metadataItem->data.B); + break; + case PS_META_S32: + fprintf(fd,format, metadataItem->data.S32); + break; + case PS_META_F32: + fprintf(fd, format, metadataItem->data.F32); + break; + case PS_META_F64: + fprintf(fd, format, metadataItem->data.F64); + break; + case PS_META_STR: + fprintf(fd, format, metadataItem->data.V); + break; + case PS_META_ITEM_SET: + case PS_META_IMG: + case PS_META_JPEG: + case PS_META_PNG: + case PS_META_ASTROM: + case PS_META_UNKNOWN: + default: + psError(__func__, " Invalid psMetadataType to print: %d", type); + } +} + +psMetadata* psMetadataFReadHeader(psMetadata* output, char *extName, int extNum, fitsfile * fd) +{ + bool tempBool; + bool success; + char keyType; + char keyName[FITS_LINE_SIZE]; + char keyValue[FITS_LINE_SIZE]; + char keyComment[FITS_LINE_SIZE]; + char fitsErr[MAX_STRING_LENGTH]; + int i; + int hduType = 0; + int status = 0; + int numKeys = 0; + int keyNum = 0; + psMetadataType metadataItemType; + + if (fd == NULL) { + psError(__func__, "Null FITS file descriptor not allowed"); + return NULL; + } + + if (extName == NULL && extNum == 0) { + psError(__func__, "Null extName and extNum = 0 not allowed"); + return NULL; + } else if (extName && extNum) { + psError(__func__, "Both extName and extNum arguments should not have non zero values."); + return NULL; + } + // Allocate metadata if user didn't + if (output == NULL) { + output = psMetadataAlloc(); + } + // Move to user designated HDU number or HDU name in FITS file. HDU numbers starts at one. + if (extName != NULL) { + if (fits_movnam_hdu(fd, ANY_HDU, extName, 0, &status) != 0) { + FITS_ERROR("FITS error while locating header %s: %s", extName); + } + } else { + if (fits_movabs_hdu(fd, extNum, &hduType, &status) != 0) { + FITS_ERROR("FITS error while locating header %d: %s", extNum); + } + } + + // Get number of key names + if (fits_get_hdrpos(fd, &numKeys, &keyNum, &status) != 0) { + FITS_ERROR("FITS error while reading key %d: %s", keyNum); + } + // Get each key name. Keywords start at one. + for (i = 1; i <= numKeys; i++) { + if (fits_read_keyn(fd, i, keyName, keyValue, keyComment, &status) != 0) { + FITS_ERROR("FITS error while reading key %d: %s", keyNum); + } + if (fits_get_keytype(keyValue, &keyType, &status) != 0) { + fits_get_errstatus(status, fitsErr); + if (status != VALUE_UNDEFINED) { + FITS_ERROR("FITS error while determining key %d type: %s", keyNum); + } else { + // Some keywords are still valid even though they don't have a type, like COMMENTS and + // HISTORY + keyType = 'C'; + status = 0; + } + } + + switch (keyType) { + case 'I': + metadataItemType = PS_META_S32; + success = + psMetadataAdd(output, PS_LIST_TAIL, keyName, metadataItemType, keyComment, + atoi(keyValue)); + break; + case 'F': + metadataItemType = PS_META_F64; + success = + psMetadataAdd(output, PS_LIST_TAIL, keyName, metadataItemType, keyComment, + atof(keyValue)); + break; + case 'C': + metadataItemType = PS_META_STR; + success = + psMetadataAdd(output, PS_LIST_TAIL, keyName, metadataItemType, keyComment, keyValue); + break; + case 'L': + metadataItemType = PS_META_BOOL; + tempBool = (keyValue[0] == 'T') ? 1 : 0; + success = + psMetadataAdd(output, PS_LIST_TAIL, keyName, metadataItemType, keyComment, tempBool); + break; + case 'U': + case 'X': + default: + psError(__func__, "Invalid psMetadataType: %c", keyType); + return output; + } + + if (!success) { + psError(__func__, "Failed to add metadata item. Name: %s", keyName); + return output; + } + } + + return output; +} Index: /tags/rel2_1/psLib/src/collections/psMetadata.h =================================================================== --- /tags/rel2_1/psLib/src/collections/psMetadata.h (revision 1553) +++ /tags/rel2_1/psLib/src/collections/psMetadata.h (revision 1553) @@ -0,0 +1,298 @@ + +/** @file psMetadata.h +* +* @brief Contains metadata struuctures, enumerations and functions prototypes +* +* This file defines metadata item, metadata type, metadata flags, metadata containers, and function +* prototypes necessary creating psLib metadata APIs +* +* @ingroup Metadata +* +* @author Ross Harman, MHPCC +* +* @version $Revision: 1.20 $ $Name: not supported by cvs2svn $ +* @date $Date: 2004-08-12 01:23:20 $ +* +* Copyright 2004 Maui High Performance Computing Center, University of Hawaii +*/ +#ifndef PS_METADATA_H +#define PS_METADATA_H + +#include +#include +#include + +#include "psHash.h" +#include "psList.h" + +/// @addtogroup Metadata +/// @{ + +/** Metadata item type. + * + * Enumeration for maintaining metadata item types. + */ +typedef enum { + PS_META_ITEM_SET = 0, ///< Null. Metadata is in psMetadataItem.items + PS_META_BOOL, ///< Boolean data. + PS_META_S32, ///< Signed 32-bit integer data. + PS_META_F32, ///< Single-precision float data. + PS_META_F64, ///< Double-precision float data. + PS_META_STR, ///< String data (Stored in as void *). + PS_META_IMG, ///< Image data (Stored in as void *). + PS_META_JPEG, ///< JPEG data (Stored in as void *). + PS_META_PNG, ///< PNG data (Stored in as void *). + PS_META_ASTROM, ///< Astrometric coefficients (Stored in as void *). + PS_META_UNKNOWN, ///< Other data (Stored in as void *). + PS_META_NTYPE ///< Number of types. Must be last. +} psMetadataType; + +/** Metadata item data structure. + * + * Struct for maintaining metadata items of varying types. It also contains + * information about the item name, flags, comments, and other items with the same name. + */ +typedef struct psMetadataItem +{ + const int id; ///< Unique ID for metadata item. + char *restrict name; ///< Name of metadata item. + psMetadataType type; ///< Type of metadata item. + union { + bool B; ///< boolean data + psS32 S32; ///< Signed 32-bit integer data. + psF32 F32; ///< Single-precision float data. + psF64 F64; ///< Double-precision float data. + psPTR V; ///< Pointer to other type of data. + } data; ///< Union for data types. + char *comment; ///< Optional comment ("", not NULL). + psList* restrict items; ///< List of psMetadataItems with same name. +} +psMetadataItem; + +/** Metadata data structure. + * + * Struct for holding metadata items. Metadata items are held in two + * containers. The first employs a doubly-linked list to preserve the order + * of the metadata. The second container employs a hash table which + * allows fast lookup when given a metadata keyword. + */ +typedef struct psMetadata +{ + psList* restrict list; ///< the metadata in linked-list + psHash* restrict table; ///< the metadata in a hash table +} +psMetadata; + +/*****************************************************************************/ + +/* FUNCTION PROTOTYPES */ + +/*****************************************************************************/ + +/** Create a metadata item. + * + * Returns a fill psMetadataItem ready for insertion into the psMetadata + * struct. The name argument specifies the name to use for this item, and + * may include sprintf formatting codes. The format entry specifies both + * the metadata type and optional flags and is created by bit-wise or of the + * appropriate type and flag. The comment argument is a fixed string used to + * comment the metadata item. The arguments to the name formatting codes and + * the metadata itself are passed as arguments following the comment string. + * The data must be a pointer for any of the elements stored in data.void. + * The argument list must be interpreted appropriately by the va_list + * operators in the function specified size and type. + * + * @return psMetadataItem* : Pointer metadata item. + */ +psMetadataItem* psMetadataItemAlloc( + const char *name, ///< Name of metadata item. + psMetadataType type, ///< Type of metadata item. + const char *comment, ///< Comment for metadata item. + ... ///< Arguments for name formatting and metadata item data. +); + +/** Create a metadata item with va_list. + * + * Returns a fill psMetadataItem ready for insertion into the psMetadata + * struct. The name argument specifies the name to use for this item, and + * may include sprintf formatting codes. The format entry specifies both + * the metadata type and optional flags and is created by bit-wise or of the + * appropriate type and flag. The comment argument is a fixed string used to + * comment the metadata item. The arguments to the name formatting codes and + * the metadata itself are passed as arguments following the comment string. + * The data must be a pointer for any of the elements stored in data.void. + * The argument list must be interpreted appropriately by the va_list + * operators in the function specified size and type. + * + * @return psMetadataItem* : Pointer metadata item. + */ +psMetadataItem* psMetadataItemAllocV( + const char *name, ///< Name of metadata item. + psMetadataType type, ///< Type of metadata item. + const char *comment, ///< Comment for metadata item. + va_list list ///< Arguments for name formatting and metadata item data. +); + +/** Create a metadata collection. + * + * Returns an empty metadata container with fully allocated internal metadata + * containers. + * + * @return psMetadata* : Pointer metadata. + */ +psMetadata* psMetadataAlloc(void); + +/** Add existing metadata item to metadata collection. + * + * Add a metadata item that has already been created to the metadata + * collection. + * + * @return bool: True for success, false for failure. + */ +bool psMetadataAddItem( + psMetadata* restrict md, ///< Metadata collection to insert metadat item. + int where, ///< Location to be added. + psMetadataItem* restrict item ///< Metadata item to be added. +); + +/** Create and add a metadata item to metadata collection. + * + * Creates a new metadata item add to the metadata collection. + * + * @return bool: True for success, false for failure. + */ +bool psMetadataAdd( + psMetadata* restrict md, ///< Metadata collection to insert metadat item. + int where, ///< Location to be added. + const char *name, ///< Name of metadata item. + psMetadataType type, ///< Type of metadata item. + const char *comment, ///< Comment for metadata item. + ... ///< Arguments for name formatting and metadata item data. +); + +/** Remove an item from metadata collection. + * + * Items may be removed from metadata by specifing a key or location. If the + * name is null, the where argument is used instead. If name is not null, + * where is set to PS_LIST_UNKNOWN. If the item is found, it is removed from + * the metadata and true is returned. If the key is not unique, then all + * items corresponding to it are removed. + * + * @return bool: True for success, false for failure. + */ +bool psMetadataRemove( + psMetadata* restrict md, ///< Metadata collection to insert metadat item. + int where, ///< Location to be removed. + const char *restrict key ///< Name of metadata key. +); + +/** Find an item in the metadata collection based on key name. + * + * Items may be found in the metadata by providing a key. If the key is + * non-unique, the first item is returned. If the item is not found, null is + * returned. + * + * @return psMetadataItem* : Pointer metadata item. + */ +psMetadataItem* psMetadataLookup( + psMetadata* restrict md, ///< Metadata collection to insert metadata item. + const char *restrict key ///< Name of metadata key. +); + +/** Find an item in the metadata collection based on list index. + * + * Items may be found in the metadata by their entry position in the list + * container. + * + * @return psMetadataItem* : Pointer metadata item. + */ +psMetadataItem* psMetadataGet( + psMetadata* restrict md, ///< Metadata collection to insert metadat item. + int where ///< Location to be retrieved. +); + +/** Set or reset metadata iterator. + * + * Metadata may be iterated by setting or resetting an iterator to a location + * in the metadata list. + * + * @return void: void. + */ +bool psMetadataSetIterator( + psMetadata* restrict md, ///< Metadata collection to iterate. + int where ///< Location of iterator. +); + +/** Get next metadata item. + * + * Get next metadata item in iterator list. + * + * @return psMetadataItem* : Pointer metadata item. + */ +psMetadataItem* psMetadataGetNext( + psMetadata* restrict md, ///< Metadata collection to iterate. + const char *restrict match, ///< Beginning of key name. + int which ///< Iterator to be used. +); + +/** Get previous metadata item. + * + * Get previous metadata item in iterator list. + * + * @return psMetadataItem* : Pointer metadata item. + */ +psMetadataItem* psMetadataGetPrevious( + psMetadata* restrict md, ///< Metadata collection to iterate. + const char *restrict match, ///< Beginning of key name. + int which ///< Iterator to be used. +); + +/** Print metadata item to file. + * + * Metadata items may be printed to an open file descriptor based on a + * provided format. The format is a sprintf format statement with exactly + * one % formatting command. If the metadata item type is a numeric type, + * this formatting command must also be numeric, and the type conversion + * performed to the value to match the format type. If the metadata type is + * a string, the fromatting command must also be for a string. If the + * metadata type is any other data type, printing is not allowed. + * + * @return psMetadataItem* : Pointer metadata item. + */ +void psMetadataItemPrint( + FILE * fd, ///< Pointer to file to write metadata item. + const char *format, ///< Format to print metadata item. + const psMetadataItem* restrict metadataItem ///< Metadata item to print. +); + +/** Read metadata header. + * + * Read a metadata header from file. If the file is not found, an error is + * reported. This file is currently unimplemented. + * + * @return psMetadata* : Pointer metadata. + */ +psMetadata* psMetadataReadHeader( + psMetadata* output, ///< Resulting metadata from read. + char *extname, ///< File name extension string. + int extnum, ///< File name extension number. Starts at 1. + char *filename ///< Name of file to read. +); + +/** Read metadata header. + * + * Read a metadata header from file. If the file is not found, an error is + * reported. + * + * @return psMetadata* : Pointer metadata. + */ +psMetadata* psMetadataFReadHeader( + psMetadata* output, ///< Resulting metadata from read. + char *extName, ///< File name extension string. + int extNum, ///< File name extension number. + fitsfile * fd ///< Pointer to file to read. +); + +/// @} + +#endif Index: /tags/rel2_1/psLib/src/collections/psScalar.c =================================================================== --- /tags/rel2_1/psLib/src/collections/psScalar.c (revision 1553) +++ /tags/rel2_1/psLib/src/collections/psScalar.c (revision 1553) @@ -0,0 +1,153 @@ + +/** @file psScalar.c + * + * @brief Contains basic scalar definitions and operations + * + * This file defines the basic type for a scalar struct and functions useful + * in manupulating scalars. + * * + * @author Ross Harman, MHPCC + * + * @version $Revision: 1.8 $ $Name: not supported by cvs2svn $ + * @date $Date: 2004-08-10 19:27:47 $ + * + * Copyright 2004 Maui High Performance Computing Center, University of Hawaii + */ + +/******************************************************************************/ + +/* INCLUDE FILES */ + +/******************************************************************************/ +#include "psMemory.h" +#include "psError.h" +#include "psScalar.h" +#include "psLogMsg.h" +#include "psAbort.h" + +/******************************************************************************/ + +/* DEFINE STATEMENTS */ + +/******************************************************************************/ + +// None + +/******************************************************************************/ + +/* TYPE DEFINITIONS */ + +/******************************************************************************/ + +// None + +/*****************************************************************************/ + +/* GLOBAL VARIABLES */ + +/*****************************************************************************/ + +// None + +/*****************************************************************************/ + +/* FILE STATIC VARIABLES */ + +/*****************************************************************************/ + +// None + +/*****************************************************************************/ + +/* FUNCTION IMPLEMENTATION - LOCAL */ + +/*****************************************************************************/ + +// None + +/*****************************************************************************/ + +/* FUNCTION IMPLEMENTATION - PUBLIC */ + +/*****************************************************************************/ +psScalar* psScalarAlloc(psC64 value, psElemType dataType) +{ + psScalar* scalar = NULL; + + // Create scalar + scalar = (psScalar* ) psAlloc(sizeof(psScalar)); + if (scalar == NULL) { + psAbort(__func__, " : Line %d - Failed to allocate memory", __LINE__); + } + + scalar->type.dimen = PS_DIMEN_SCALAR; + scalar->type.type = dataType; + + switch (dataType) { + case PS_TYPE_S8: + scalar->data.S8 = (psS8) value; + break; + case PS_TYPE_U8: + scalar->data.U8 = (psU8) value; + break; + case PS_TYPE_S16: + scalar->data.S16 = (psS16) value; + break; + case PS_TYPE_U16: + scalar->data.U16 = (psU16) value; + break; + case PS_TYPE_S32: + scalar->data.S32 = (psS32) value; + break; + case PS_TYPE_U32: + scalar->data.U32 = (psU32) value; + break; + case PS_TYPE_S64: + scalar->data.S64 = (psS64) value; + break; + case PS_TYPE_U64: + scalar->data.U64 = (psU64) value; + break; + case PS_TYPE_F32: + scalar->data.F32 = (psF32) value; + break; + case PS_TYPE_F64: + scalar->data.F64 = (psF64) value; + break; + case PS_TYPE_C32: + scalar->data.C32 = (psC32) value; + break; + case PS_TYPE_C64: + scalar->data.C64 = (psC64) value; + break; + default: + psError(__func__, ": Line %d - Invalid PS_TYPE: %d", __LINE__, dataType); + } + + return scalar; +} + +psScalar* psScalarCopy(psScalar *scalar) +{ + psScalar *newScalar = NULL; + + if (scalar == NULL) { + psError(__func__, "Null scalar not allowed"); + } + + newScalar = psScalarAlloc(scalar->data.C64, scalar->type.type); + if (newScalar == NULL) { + psAbort(__func__, " : Line %d - Failed to allocate memory", __LINE__); + } + + return newScalar; +} + +void psScalarFree(psScalar* restrict scalar) +{ + if (scalar == NULL) { + return; + } + + psFree(scalar); +} Index: /tags/rel2_1/psLib/src/collections/psScalar.h =================================================================== --- /tags/rel2_1/psLib/src/collections/psScalar.h (revision 1553) +++ /tags/rel2_1/psLib/src/collections/psScalar.h (revision 1553) @@ -0,0 +1,93 @@ + +/** @file psScalar.h + * + * @brief Contains basic scalar definitions and operations + * + * This file defines the basic type for a scalar struct and functions useful + * in manupulating scalars. + * + * @ingroup Scalar + * + * @author Ross Harman, MHPCC + * + * @version $Revision: 1.9 $ $Name: not supported by cvs2svn $ + * @date $Date: 2004-08-11 20:08:08 $ + * + * Copyright 2004 Maui High Performance Computing Center, University of Hawaii + */ + +#ifndef PS_SCALAR_H +#define PS_SCALAR_H + +#include "psType.h" + +/// @addtogroup Scalar +/// @{ + +/** Basic scalar data structure. + * + * Struct for maintaining a scalar of frequently used primitive types. + * + */ +typedef struct +{ + psType type; ///< Type of data. + + union { + psU8 U8; ///< Unsigned 8-bit integer data. + psU16 U16; ///< Unsigned 16-bit integer data. + psU32 U32; ///< Unsigned 32-bit integer data. + psU64 U64; ///< Unsigned 64-bit integer data. + psS8 S8; ///< Signed 8-bit integer data. + psS16 S16; ///< Signed 16-bit integer data. + psS32 S32; ///< Signed 32-bit integer data. + psS64 S64; ///< Signed 64-bit integer data. + psF32 F32; ///< Single-precision float data. + psF64 F64; ///< Double-precision float data. + psC32 C32; ///< Single-precision complex data. + psC64 C64; ///< Double-precision complex data. + } data; ///< Union for data types. +} +psScalar; + +/*****************************************************************************/ + +/* FUNCTION PROTOTYPES */ + +/*****************************************************************************/ + +/** Allocate a scalar. + * + * Uses psLib memory allocation functions to create scalar data as defined by the psType type. + * Accepts a complex 64 bit float for input value, as max size, but resizes according to + * correct type. + * + * @return psScalar* Pointer to a new psScalar. + */ +psScalar* psScalarAlloc( + psC64 value, ///< Data to be put into psScalar. + psElemType dataType ///< Type of data to be held by psScalar. +); + +/** Deallocate a scalar. + * + * Uses psLib memory allocation functions to deallocate a scalar. + * + */ +void psScalarFree( + psScalar* restrict scalar ///< Scalar to free. +); + +/** Copy a scalar. + * + * Uses psLib memory allocation functions to copy a scalar. + * + * @return psScalar* A copy of the input scalar + */ +psScalar* psScalarCopy( + psScalar *scalar ///< Scalar to copy. +); + +/// @} + +#endif Index: /tags/rel2_1/psLib/src/collections/psVector.c =================================================================== --- /tags/rel2_1/psLib/src/collections/psVector.c (revision 1553) +++ /tags/rel2_1/psLib/src/collections/psVector.c (revision 1553) @@ -0,0 +1,357 @@ + +/** @file psVector.c +* +* @brief Contains support for basic vector types +* +* This file defines the basic type for a vector struct and functions useful +* in manupulating vectors. +* +* @author Ross Harman, MHPCC +* +* @version $Revision: 1.22 $ $Name: not supported by cvs2svn $ +* @date $Date: 2004-08-09 23:34:57 $ +* +* Copyright 2004 Maui High Performance Computing Center, University of Hawaii +*/ + +/******************************************************************************/ + +/* INCLUDE FILES */ + +/******************************************************************************/ +#include // for memcpy +#include +#include + +#include "psMemory.h" +#include "psError.h" +#include "psVector.h" +#include "psLogMsg.h" +#include "psCompare.h" + +/******************************************************************************/ + +/* DEFINE STATEMENTS */ + +/******************************************************************************/ + +// None + +/******************************************************************************/ + +/* TYPE DEFINITIONS */ + +/******************************************************************************/ + +// None + +/*****************************************************************************/ + +/* GLOBAL VARIABLES */ + +/*****************************************************************************/ + +// None + +/*****************************************************************************/ + +/* FILE STATIC VARIABLES */ + +/*****************************************************************************/ + +// None + +/*****************************************************************************/ + +/* FUNCTION IMPLEMENTATION - LOCAL */ + +/*****************************************************************************/ +static void vectorFree(psVector* restrict psVec); + +/*****************************************************************************/ + +/* FUNCTION IMPLEMENTATION - PUBLIC */ + +/*****************************************************************************/ +psVector* psVectorAlloc(unsigned int nalloc, psElemType elemType) +{ + psVector* psVec = NULL; + int elementSize = 0; + + // Invalid nalloc + if (nalloc < 1) { + psError(__func__, "Invalid value for nalloc. nalloc: %d\n", nalloc); + return NULL; + } + + elementSize = PSELEMTYPE_SIZEOF(elemType); + + // Create vector struct + psVec = (psVector* ) psAlloc(sizeof(psVector)); + p_psMemSetDeallocator(psVec, (psFreeFcn) vectorFree); + + psVec->type.dimen = PS_DIMEN_VECTOR; + psVec->type.type = elemType; + psVec->nalloc = nalloc; + psVec->n = nalloc; + + // Create vector data array + psVec->data.V = psAlloc(nalloc * elementSize); + + return psVec; +} + +psVector* psVectorRealloc(unsigned int nalloc, psVector* restrict in) +{ + int elementSize = 0; + psElemType elemType; + + // Invalid nalloc + if (nalloc < 1) { + psError(__func__, "Invalid value for realloc (%d)\n", nalloc); + return NULL; + } + + if (in == NULL) { + psError(__func__, "Null input vector\n"); + return NULL; + } else if (in->nalloc != nalloc) { // No need to realloc to same size + elemType = in->type.type; + elementSize = PSELEMTYPE_SIZEOF(elemType); + if (nalloc < in->n) { + in->n = nalloc; + } + // Realloc after decrementation to avoid accessing freed array elements + in->data.V = psRealloc(in->data.V, nalloc * elementSize); + in->nalloc = nalloc; + } + + return in; +} + +psVector* psVectorRecycle(psVector* restrict in, unsigned int nalloc, psElemType type) +{ + psElemType elemType; + + if (in == NULL) { + return psVectorAlloc(nalloc, type); + } + + elemType = in->type.type; + + if (in->nalloc == nalloc && elemType == type) { + // it is proper size/type already + return in; + } + // Invalid nalloc + if (nalloc < 1) { + psError(__func__, "Invalid value for nalloc (%d)\n", nalloc); + psFree(in); + return NULL; + } + + in->data.V = psRealloc(in->data.V, nalloc * PSELEMTYPE_SIZEOF(type)); + + in->type.type = type; + in->nalloc = nalloc; + in->n = nalloc; + + return in; +} + +psVector* psVectorSort(psVector* restrict outVector, const psVector* restrict inVector) +{ + int inN = 0; + int outN = 0; + int elSize = 0; + void *inVec = NULL; + void *outVec = NULL; + psElemType inType = 0; + + if (inVector == NULL) { + psError(__func__, " : Line %d - Null input vector\n", __LINE__); + return outVector; + } + + inType = inVector->type.type; + inN = inVector->n; + inVec = inVector->data.V; + elSize = PSELEMTYPE_SIZEOF(inType); + + if (outVector == NULL) { + outVector = psVectorAlloc(inN, inType); + outVector->n = inVector->n; + } + + outN = outVector->n; + outVec = outVector->data.V; + + if (inN != outN) { + psError(__func__, " : Line %d - Input and output vector sizes are not equal: in=%d out=%d\n", + __LINE__, inN, outN); + return outVector; + } + + if (inType != outVector->type.type) { + psError(__func__, " : Line %d - Input and output vectors are not same type: in=%d out=%d\n", __LINE__, + inType, outVector->type.type); + return outVector; + } + + if (inN == 0) { + psError(__func__, " : Line %d - No elements in use for input vector\n", __LINE__); + return outVector; + } + + if (outN == 0) { + psError(__func__, " : Line %d - No elements in use for output vector\n", __LINE__); + return outVector; + } + // Copy input vector values into output vector + memcpy(outVec, inVec, elSize * outN); + + // Sort output vector + switch (inType) { + case PS_TYPE_U8: + qsort(outVec, inN, elSize, psCompareU8); + break; + case PS_TYPE_U16: + qsort(outVec, inN, elSize, psCompareU16); + break; + case PS_TYPE_U32: + qsort(outVec, inN, elSize, psCompareU32); + break; + case PS_TYPE_U64: + qsort(outVec, inN, elSize, psCompareU64); + break; + case PS_TYPE_S8: + qsort(outVec, inN, elSize, psCompareS8); + break; + case PS_TYPE_S16: + qsort(outVec, inN, elSize, psCompareS16); + break; + case PS_TYPE_S32: + qsort(outVec, inN, elSize, psCompareS32); + break; + case PS_TYPE_S64: + qsort(outVec, inN, elSize, psCompareS64); + break; + case PS_TYPE_F32: + qsort(outVec, inN, elSize, psCompareF32); + break; + case PS_TYPE_F64: + qsort(outVec, inN, elSize, psCompareF64); + break; + default: + psError(__func__, " : Line %d - Invalid psType\n", __LINE__); + } + + return outVector; +} + +#define SORT_INDICES(TYPE) \ +for(i=0; idata.TYPE[i] - inVec[j]); \ + if(diff < FLT_EPSILON) { \ + outVec[i] = j; \ + break; \ + } \ + } \ +} + +psVector* psVectorSortIndex(psVector* restrict outVector, const psVector* restrict inVector) +{ + int inN = 0; + int outN = 0; + int i = 0; + int j = 0; + float *inVec = NULL; + int *outVec = NULL; + double diff = 0.0f; + psVector* tmpVector = NULL; + psElemType inType = 0; + + if (inVector == NULL) { + psError(__func__, " : Line %d - Null input vector\n", __LINE__); + return outVector; + } + + inN = inVector->n; + inVec = inVector->data.V; + inType = inVector->type.type; + + if (outVector == NULL) { + outVector = psVectorAlloc(inN, PS_TYPE_U32); + outVector->n = inN; + } + + outN = outVector->n; + outVec = outVector->data.V; + + if (inN != outN) { + psError(__func__, " : Line %d - Input and output vector sizes are not equal: in=%d out=%d\n", + __LINE__, inN, outN); + return outVector; + } + + if (outVector->type.type != PS_TYPE_U32) { + psError(__func__, " : Line %d - Output vector is not of type U32: out=%d\n", + __LINE__, outVector->type.type); + return outVector; + } + + tmpVector = psVectorAlloc(inN, inType); + tmpVector->n = inN; + tmpVector = psVectorSort(tmpVector, inVector); + + // Sort output vector + switch (inType) { + case PS_TYPE_U8: + SORT_INDICES(U8); + break; + case PS_TYPE_U16: + SORT_INDICES(U16); + break; + case PS_TYPE_U32: + SORT_INDICES(U32); + break; + case PS_TYPE_U64: + SORT_INDICES(U64); + break; + case PS_TYPE_S8: + SORT_INDICES(S8); + break; + case PS_TYPE_S16: + SORT_INDICES(S16); + break; + case PS_TYPE_S32: + SORT_INDICES(S32); + break; + case PS_TYPE_S64: + SORT_INDICES(S64); + break; + case PS_TYPE_F32: + SORT_INDICES(F32); + break; + case PS_TYPE_F64: + SORT_INDICES(F64); + break; + default: + psError(__func__, " : Line %d - Invalid psType\n", __LINE__); + } + + // Free temp memory + psFree(tmpVector); + + return outVector; +} + +static void vectorFree(psVector* restrict psVec) +{ + if (psVec == NULL) { + return; + } + + psFree(psVec->data.V); +} Index: /tags/rel2_1/psLib/src/collections/psVector.h =================================================================== --- /tags/rel2_1/psLib/src/collections/psVector.h (revision 1553) +++ /tags/rel2_1/psLib/src/collections/psVector.h (revision 1553) @@ -0,0 +1,133 @@ + +/** @file psVector.h + * + * @brief Contains basic vector definitions and operations + * + * This file defines the basic type for a vector struct and functions useful + * in manupulating vectors. + * + * @ingroup Vector + * + * @author Robert DeSonia, MHPCC + * @author Ross Harman, MHPCC + * + * @version $Revision: 1.20 $ $Name: not supported by cvs2svn $ + * @date $Date: 2004-08-11 20:17:35 $ + * + * Copyright 2004 Maui High Performance Computing Center, University of Hawaii + */ + +#ifndef PS_VECTOR_H +#define PS_VECTOR_H + +#include "psType.h" + +/// @addtogroup Vector +/// @{ + +/** An vector to support primitive types. + * + * Struct for maintaining an vector of frequently used primitive types. + * + */ +typedef struct +{ + psType type; ///< Type of data. + unsigned int nalloc; ///< Total number of elements available. + unsigned int n; ///< Number of elements in use. + + union { + psU8* U8; ///< Unsigned 8-bit integer data. + psU16* U16; ///< Unsigned 16-bit integer data. + psU32* U32; ///< Unsigned 32-bit integer data. + psU64* U64; ///< Unsigned 64-bit integer data. + psS8* S8; ///< Signed 8-bit integer data. + psS16* S16; ///< Signed 16-bit integer data. + psS32* S32; ///< Signed 32-bit integer data. + psS64* S64; ///< Signed 64-bit integer data. + psF32* F32; ///< Single-precision float data. + psF64* F64; ///< Double-precision float data. + psC32* C32; ///< Single-precision complex data. + psC64* C64; ///< Double-precision complex data. + psPTR V; ///< Pointer to data. + } data; ///< Union for data types. +} +psVector; + +/*****************************************************************************/ + +/* FUNCTION PROTOTYPES */ + +/*****************************************************************************/ + +/** Allocate a vector. + * + * Uses psLib memory allocation functions to create a vector collection of + * data as defined by the psType type. + * + * @return psVector* Pointer to psVector. + */ +psVector* psVectorAlloc( + unsigned int nalloc, ///< Total number of elements to make available. + psElemType dataType ///< Type of data to be held by vector. +); + +/** Reallocate a vector. + * + * Uses psLib memory allocation functions to reallocate a vector collection + * of data. The vector is reallocated according to the psType type member + * contained within the vector. + * + * @return psVector* Pointer to psVector. + * + */ +psVector* psVectorRealloc( + unsigned int nalloc, ///< Total number of elements to make available. + psVector* restrict psVec ///< Vector to reallocate. +); + +/** Recycle a vector. + * + * Uses psLib memory allocation functions to reallocate a vector collection + * of data. The vector is reallocated according to the psElemType type + * parameter. + * + * @return psVector* Pointer to psVector. + * + */ +psVector* psVectorRecycle( + psVector* restrict psVec, + ///< Vector to recycle. If NULL, a new vector is created. No effort + ///< taken to preserve the values. + + unsigned int nalloc, ///< Total number of elements to make available. + psElemType type ///< the datatype of the returned vector +); + +/** Sort an array of floats. + * + * Sorts an array of floats in ascending order. This function is valid for + * all non-complex data types. + * + * @return psVector* Pointer to sorted psVector. + */ +psVector* psVectorSort( + psVector* restrict outVector, ///< the output vector to recycle, or NULL if new vector desired. + const psVector* restrict inVector ///< the vector to sort. +); + +/** Creates an array of indices based on sort ordered of array. + * + * Sorts a vector and creates an integer array holding indices of + * sorted float values based on pre-sort index positions. + * + * @return psVector* vector of the indices of sort. + */ +psVector* psVectorSortIndex( + psVector* restrict outVector, ///< vector to recycle + const psVector* restrict inVector ///< vector to sort +); + +/// @} + +#endif Index: /tags/rel2_1/psLib/src/dataManip/.cvsignore =================================================================== --- /tags/rel2_1/psLib/src/dataManip/.cvsignore (revision 1553) +++ /tags/rel2_1/psLib/src/dataManip/.cvsignore (revision 1553) @@ -0,0 +1,1 @@ +*.i Index: /tags/rel2_1/psLib/src/dataManip/Makefile =================================================================== --- /tags/rel2_1/psLib/src/dataManip/Makefile (revision 1553) +++ /tags/rel2_1/psLib/src/dataManip/Makefile (revision 1553) @@ -0,0 +1,60 @@ +ifndef prefix + export prefix=$(shell cd ../..;pwd) +endif + +TARGET_STATIC = libpslib.a +include ../Makefile.Globals +CFLAGS := $(CFLAGS_RELOC) -I. -I../sysUtils -I../collections -I.. -I../image + +SRC_OBJS = psStats.o \ + psFunctions.o \ + psMatrix.o \ + psMatrixVectorArithmetic.o \ + psFFT.o \ + psMinimize.o \ + +OBJS = $(addprefix makedir/,$(SRC_OBJS)) + +all: $(TARGET_STATIC) + +# force the creation of a psImage.i for psImage.o (to expand macros). +psMatrixVectorArithmetic.o: psMatrixVectorArithmetic.i + +# Rule to make static library + +libpslib.a: $(OBJS) +# The ar option -r is to add/replace object and -s is to create +# a symbol table in the archive + $(AR) rcs ../$@ $(OBJS) + +# Define PHONY target "install" which will install necessary files +install: $(TARGET_STATIC) + install *.h $(includedir) + +# Define PHONY target "distclean" which will cleanup the distribution +distclean: clean + $(RM) ../$(TARGET_STATIC) + +# Define PHONY target "clean" which will cleanup the development area +clean: + @echo " Deleting intermediate files for 'sysUtils'" + $(RM) $(OBJS) *.lint $(SRC_OBJS:.o=.i) + +cleandep: + $(RM) $(OBJS:.o=.d) + +%.lint: %.c + splint +posixlib -exportlocal -realcompare $(INCLUDE_GLOBAL) $? > $@; cat $@ + +%.i: %.c + $(CC) -E $(CFLAGS) -o $@ $< + +makedir/%.o: %.c + $(CC) -c $(CFLAGS) -o $@ $< + +makedir/%.d: %.c + $(CC) -MM $(CFLAGS) $< > $@.tmp + sed 's|\($*\)\.o[ :]*|\1.o $@ : |g' $@.tmp > $@ + $(RM) -f $@.tmp + +include $(OBJS:.o=.d) Index: /tags/rel2_1/psLib/src/dataManip/psFFT.c =================================================================== --- /tags/rel2_1/psLib/src/dataManip/psFFT.c (revision 1553) +++ /tags/rel2_1/psLib/src/dataManip/psFFT.c (revision 1553) @@ -0,0 +1,741 @@ + +/** @file psFFT.c +* +* @brief Contains FFT transforms functions +* +* @author Robert DeSonia, MHPCC +* +* @version $Revision: 1.21 $ $Name: not supported by cvs2svn $ +* @date $Date: 2004-08-10 18:54:38 $ +* +* Copyright 2004 Maui High Performance Computing Center, University of Hawaii +*/ + +#include +#include +#include +#include +#include + +#include "psFFT.h" +#include "psError.h" +#include "psMemory.h" +#include "psLogMsg.h" +#include "psImageExtraction.h" + +#define P_FFTW_PLAN_RIGOR FFTW_ESTIMATE + +static bool p_fftwWisdomImported = false; + +psImage* psImageFFT(psImage* out, const psImage* in, psFftDirection direction) +{ + unsigned int numCols; + unsigned int numRows; + psElemType type; + fftwf_plan plan; + + /* got good image data? */ + if (in == NULL) { + psFree(out); + return NULL; + } + + type = in->type.type; + + if ((type != PS_TYPE_F32) && (type != PS_TYPE_C32)) { + psError(__func__, "Input image must be a 32-bit float or complex image (type=%d)", type); + psFree(out); + return NULL; + } + + if (type != PS_TYPE_C32 && direction == PS_FFT_REVERSE) { + psError(__func__, "Input image must be complex image for reverse FFT (type=%d).", type); + psFree(out); + return NULL; + + } + + if (type != PS_TYPE_F32 && direction == PS_FFT_FORWARD) { + psError(__func__, "Input image must be real image for forward FFT (type=%d).", type); + psFree(out); + return NULL; + } + + /* make sure the system-level wisdom information is imported. */ + if (!p_fftwWisdomImported) { + fftwf_import_system_wisdom(); + p_fftwWisdomImported = true; + } + + numRows = in->numRows; + numCols = in->numCols; + + out = psImageCopy(out, in, PS_TYPE_C32); + + plan = fftwf_plan_dft_2d(numCols, numRows, + (fftwf_complex *) out->data.C32[0], + (fftwf_complex *) out->data.C32[0], direction, P_FFTW_PLAN_RIGOR); + + /* check if a plan exists now */ + if (plan == NULL) { + psError(__func__, "Failed to create FFTW plan."); + psFree(out); + return NULL; + } + + /* finally, call FFTW with the plan made above */ + fftwf_execute(plan); + + fftwf_destroy_plan(plan); + + return out; + +} + +psImage* psImageReal(psImage* out, const psImage* in) +{ + psElemType type; + unsigned int numCols; + unsigned int numRows; + + if (in == NULL) { + psFree(out); + return NULL; + } + + type = in->type.type; + numCols = in->numCols; + numRows = in->numRows; + + /* if not a complex number, this is logically just a copy */ + if (!PS_IS_PSELEMTYPE_COMPLEX(type)) { + // Warn user, as this is probably not expected + psLogMsg(__func__, PS_LOG_WARN, "Real portion of a non-Complex type called called for. " + "Just an image copy was performed."); + return psImageCopy(out, in, type); + } + + if (type == PS_TYPE_C32) { + psF32* outRow; + psC32* inRow; + + out = psImageRecycle(out, numCols, numRows, PS_TYPE_F32); + for (unsigned int row = 0; row < numRows; row++) { + outRow = out->data.F32[row]; + inRow = in->data.C32[row]; + + for (unsigned int col = 0; col < numCols; col++) { + outRow[col] = crealf(inRow[col]); + } + } + } else if (type == PS_TYPE_C64) { + psF64* outRow; + psC64* inRow; + + out = psImageRecycle(out, numCols, numRows, PS_TYPE_F64); + for (unsigned int row = 0; row < numRows; row++) { + outRow = out->data.F64[row]; + inRow = in->data.C64[row]; + + for (unsigned int col = 0; col < numCols; col++) { + outRow[col] = creal(inRow[col]); + } + } + } else { + psError(__func__, "Can not extract real component from given image type (%d).", type); + psFree(out); + return NULL; + } + + return out; +} + +psImage* psImageImaginary(psImage* out, const psImage* in) +{ + psElemType type; + unsigned int numCols; + unsigned int numRows; + + if (in == NULL) { + psFree(out); + return NULL; + } + + type = in->type.type; + numCols = in->numCols; + numRows = in->numRows; + + /* if not a complex number, this is logically just zeroed image of same size */ + if (!PS_IS_PSELEMTYPE_COMPLEX(type)) { + // Warn user, as this is probably not expected + psLogMsg(__func__, PS_LOG_WARN, "Imaginary portion of a non-Complex type called for. " + "A zero image was returned."); + out = psImageRecycle(out, numCols, numRows, type); + memset(out->data.V[0], 0, PSELEMTYPE_SIZEOF(type) * numCols * numRows); + return out; + } + + if (type == PS_TYPE_C32) { + psF32* outRow; + psC32* inRow; + + out = psImageRecycle(out, numCols, numRows, PS_TYPE_F32); + for (unsigned int row = 0; row < numRows; row++) { + outRow = out->data.F32[row]; + inRow = in->data.C32[row]; + + for (unsigned int col = 0; col < numCols; col++) { + outRow[col] = cimagf(inRow[col]); + } + } + } else if (type == PS_TYPE_C64) { + psF64* outRow; + psC64* inRow; + + out = psImageRecycle(out, numCols, numRows, PS_TYPE_F64); + for (unsigned int row = 0; row < numRows; row++) { + outRow = out->data.F64[row]; + inRow = in->data.C64[row]; + + for (unsigned int col = 0; col < numCols; col++) { + outRow[col] = cimag(inRow[col]); + } + } + } else { + psError(__func__, "Can not extract imaginary component from given image type (%d).", type); + psFree(out); + return NULL; + } + + return out; +} + +psImage* psImageComplex(psImage* out, const psImage* real, const psImage* imag) +{ + psElemType type; + unsigned int numCols; + unsigned int numRows; + + if (real == NULL || imag == NULL) { + psFree(out); + return NULL; + } + + type = real->type.type; + numCols = real->numCols; + numRows = real->numRows; + + if (imag->type.type != type) { + psError(__func__, "The inputs to psImageComplex must be the same type."); + psFree(out); + return NULL; + } + + if (imag->numCols != numCols || imag->numRows != numRows) { + psError(__func__, "The inputs to psImageComplex must be the same dimensions."); + psFree(out); + return NULL; + } + + if (PS_IS_PSELEMTYPE_COMPLEX(type)) { + psError(__func__, "The inputs to psImageComplex can not be complex."); + psFree(out); + return NULL; + } + + if (type != PS_TYPE_F32 && type != PS_TYPE_F64) { + psError(__func__, "The input type to psImageComplex must be a floating point."); + psFree(out); + return NULL; + } + + if (type == PS_TYPE_F32) { + psC32* outRow; + psF32* realRow; + psF32* imagRow; + + out = psImageRecycle(out, numCols, numRows, PS_TYPE_C32); + + for (unsigned int row = 0; row < numRows; row++) { + outRow = out->data.C32[row]; + realRow = real->data.F32[row]; + imagRow = imag->data.F32[row]; + + for (unsigned int col = 0; col < numCols; col++) { + outRow[col] = realRow[col] + I * imagRow[col]; + } + } + } else if (type == PS_TYPE_F64) { + psC64* outRow; + psF64* realRow; + psF64* imagRow; + + out = psImageRecycle(out, numCols, numRows, PS_TYPE_C64); + for (unsigned int row = 0; row < numRows; row++) { + outRow = out->data.C64[row]; + realRow = real->data.F64[row]; + imagRow = imag->data.F64[row]; + + for (unsigned int col = 0; col < numCols; col++) { + outRow[col] = realRow[col] + I * imagRow[col]; + } + } + } else { + psError(__func__, "Can not merge real and imaginary portions for given image type (%d).", type); + psFree(out); + return NULL; + } + + return out; +} + +psImage* psImageConjugate(psImage* out, const psImage* in) +{ + psElemType type; + unsigned int numCols; + unsigned int numRows; + + if (in == NULL) { + psFree(out); + return NULL; + } + + type = in->type.type; + numCols = in->numCols; + numRows = in->numRows; + + /* if not a complex number, this is logically just a image copy */ + if (!PS_IS_PSELEMTYPE_COMPLEX(type)) { + // Warn user, as this is probably not expected + psLogMsg(__func__, PS_LOG_WARN, "Complex Conjugate of a non-Complex type called for. " + "Image copy was performed instead."); + return psImageCopy(out, in, type); + } + + if (type == PS_TYPE_C32) { + psC32* outRow; + psC32* inRow; + + out = psImageRecycle(out, numCols, numRows, PS_TYPE_C32); + for (unsigned int row = 0; row < numRows; row++) { + outRow = out->data.C32[row]; + inRow = in->data.C32[row]; + + for (unsigned int col = 0; col < numCols; col++) { + outRow[col] = crealf(inRow[col]) - I * cimagf(inRow[col]); + } + } + } else if (type == PS_TYPE_C64) { + psC64* outRow; + psC64* inRow; + + out = psImageRecycle(out, numCols, numRows, PS_TYPE_C64); + for (unsigned int row = 0; row < numRows; row++) { + outRow = out->data.C64[row]; + inRow = in->data.C64[row]; + + for (unsigned int col = 0; col < numCols; col++) { + outRow[col] = creal(inRow[col]) - I * cimag(inRow[col]); + } + } + } else { + psError(__func__, "Can not compute complex conjugate for given image type (%d).", type); + psFree(out); + return NULL; + } + + return out; +} + +psImage* psImagePowerSpectrum(psImage* out, const psImage* in) +{ + psElemType type; + unsigned int numCols; + unsigned int numRows; + int numElementsSquared; + + if (in == NULL) { + psFree(out); + return NULL; + } + + type = in->type.type; + numCols = in->numCols; + numRows = in->numRows; + numElementsSquared = numCols * numCols * numRows * numRows; + + /* if not a complex number, this is not implemented */ + if (!PS_IS_PSELEMTYPE_COMPLEX(type)) { + psError(__func__, "Power Spectrum for non-complex inputs is not implemented."); + psFree(out); + return NULL; + } + + if (type == PS_TYPE_C32) { + psF32* outRow; + psC32* inRow; + psF32 real; + psF32 imag; + + out = psImageRecycle(out, numCols, numRows, PS_TYPE_F32); + for (unsigned int row = 0; row < numRows; row++) { + outRow = out->data.F32[row]; + inRow = in->data.C32[row]; + + for (unsigned int col = 0; col < numCols; col++) { + real = crealf(inRow[col]); + imag = cimagf(inRow[col]); + outRow[col] = (real * real + imag * imag) / numElementsSquared; + } + } + } else if (type == PS_TYPE_C64) { + psF64* outRow; + psC64* inRow; + psF64 real; + psF64 imag; + + out = psImageRecycle(out, numCols, numRows, PS_TYPE_F64); + for (unsigned int row = 0; row < numRows; row++) { + outRow = out->data.F64[row]; + inRow = in->data.C64[row]; + + for (unsigned int col = 0; col < numCols; col++) { + real = crealf(inRow[col]); + imag = cimagf(inRow[col]); + outRow[col] = real * real + imag * imag / numElementsSquared; + } + } + } else { + psError(__func__, "Can not power spectrum for given image type (%d).", type); + psFree(out); + return NULL; + } + + return out; + +} + +/************************************** Vector Functions ***************************************/ + +psVector* psVectorFFT(psVector* out, const psVector* in, psFftDirection direction) +{ + unsigned int numElements; + psElemType type; + fftwf_plan plan; + + /* got good image data? */ + if (in == NULL) { + psFree(out); + return NULL; + } + + type = in->type.type; + + if ((type != PS_TYPE_F32) && (type != PS_TYPE_C32)) { + psError(__func__, "Input image must be a 32-bit float or complex image (type=%d)", type); + psFree(out); + return NULL; + } + + if ((type != PS_TYPE_C32) && (direction == PS_FFT_REVERSE)) { + psError(__func__, "Input image must be complex image for reverse FFT (type=%d).", type); + psFree(out); + return NULL; + + } + + if ((type != PS_TYPE_F32) && (direction == PS_FFT_FORWARD)) { + psError(__func__, "Input image must be real image for forward FFT (type=%d).", type); + psFree(out); + return NULL; + } + + /* make sure the system-level wisdom information is imported. */ + if (!p_fftwWisdomImported) { + fftwf_import_system_wisdom(); + p_fftwWisdomImported = true; + } + + numElements = in->n; + + out = psVectorRecycle(out, numElements, PS_TYPE_C32); + out->n = numElements; + + if (type == PS_TYPE_F32) { + // need to convert to complex + psC32* outVec = out->data.C32; + psF32* inVec = in->data.F32; + + for (unsigned int i = 0; i < numElements; i++) { + outVec[i] = inVec[i]; + } + } else { + psC32* outVec = out->data.C32; + psC32* inVec = in->data.C32; + + for (unsigned int i = 0; i < numElements; i++) { + outVec[i] = inVec[i]; + } + } + + plan = fftwf_plan_dft_1d(numElements, + (fftwf_complex *) out->data.C32, + (fftwf_complex *) out->data.C32, direction, P_FFTW_PLAN_RIGOR); + + /* check if a plan exists now */ + if (plan == NULL) { + psError(__func__, "Failed to create FFTW plan."); + psFree(out); + return NULL; + } + + /* finally, call FFTW with the plan made above */ + fftwf_execute(plan); + + fftwf_destroy_plan(plan); + + return out; +} + +psVector* psVectorReal(psVector* out, const psVector* in) +{ + psElemType type; + unsigned int numElements; + + if (in == NULL) { + psFree(out); + return NULL; + } + + type = in->type.type; + numElements = in->n; + + /* if not a complex number, this is logically just a copy */ + if (!PS_IS_PSELEMTYPE_COMPLEX(type)) { + // Warn user, as this is probably not expected + psLogMsg(__func__, PS_LOG_WARN, "Real portion of a non-Complex type called called for. " + "Just a vector copy was performed."); + out = psVectorRecycle(out, numElements, type); + out->n = numElements; + memcpy(out->data.V, in->data.V, numElements * PSELEMTYPE_SIZEOF(type)); + return out; + } + + if (type == PS_TYPE_C32) { + psF32* outVec; + psC32* inVec = in->data.C32; + + out = psVectorRecycle(out, numElements, PS_TYPE_F32); + out->n = numElements; + outVec = out->data.F32; + + for (unsigned int i = 0; i < numElements; i++) { + outVec[i] = crealf(inVec[i]); + } + } else { + psError(__func__, "Can not extract real component from given vector type (%d).", type); + psFree(out); + return NULL; + } + + return out; +} + +psVector* psVectorImaginary(psVector* out, const psVector* in) +{ + psElemType type; + unsigned int numElements; + + if (in == NULL) { + psFree(out); + return NULL; + } + + type = in->type.type; + numElements = in->n; + + /* if not a complex number, this is logically just zeroed image of same size */ + if (!PS_IS_PSELEMTYPE_COMPLEX(type)) { + // Warn user, as this is probably not expected + psLogMsg(__func__, PS_LOG_WARN, "Imaginary portion of a non-Complex type called for. " + "A zeroed vector was returned."); + out = psVectorRecycle(out, numElements, type); + out->n = numElements; + memset(out->data.V, 0, PSELEMTYPE_SIZEOF(type) * numElements); + return out; + } + + if (type == PS_TYPE_C32) { + psF32* outVec; + psC32* inVec = in->data.C32; + + out = psVectorRecycle(out, numElements, PS_TYPE_F32); + out->n = numElements; + outVec = out->data.F32; + + for (unsigned int i = 0; i < numElements; i++) { + outVec[i] = cimagf(inVec[i]); + } + } else { + psError(__func__, "Can not extract imaginary component from given vector type (%d).", type); + psFree(out); + return NULL; + } + + return out; +} + +psVector* psVectorComplex(psVector* out, const psVector* real, const psVector* imag) +{ + psElemType type; + unsigned int numElements; + + if (real == NULL || imag == NULL) { + psFree(out); + return NULL; + } + + type = real->type.type; + if (real->n < imag->n) { + numElements = real->n; + } else { + numElements = imag->n; + } + + if (imag->type.type != type) { + psError(__func__, "The inputs to psVectorComplex must be the same type."); + psFree(out); + return NULL; + } + + if (PS_IS_PSELEMTYPE_COMPLEX(type)) { + psError(__func__, "The inputs to psVectorComplex can not be complex."); + psFree(out); + return NULL; + } + + if (type == PS_TYPE_F32) { + psC32* outVec; + psF32* realVec = real->data.F32; + psF32* imagVec = imag->data.F32; + + out = psVectorRecycle(out, numElements, PS_TYPE_C32); + out->n = numElements; + outVec = out->data.C32; + + for (unsigned int i = 0; i < numElements; i++) { + outVec[i] = realVec[i] + I * imagVec[i]; + } + } else { + psError(__func__, "Can not merge real and imaginary portions for given vector type (%d).", type); + psFree(out); + return NULL; + } + + return out; +} + +psVector* psVectorConjugate(psVector* out, const psVector* in) +{ + psElemType type; + unsigned int numElements; + + if (in == NULL) { + psFree(out); + return NULL; + } + + type = in->type.type; + numElements = in->n; + + /* if not a complex number, this is logically just a image copy */ + if (!PS_IS_PSELEMTYPE_COMPLEX(type)) { + // Warn user, as this is probably not expected + psLogMsg(__func__, PS_LOG_WARN, "Complex Conjugate of a non-Complex type called for. " + "Vector copy was performed instead."); + + out = psVectorRecycle(out, numElements, type); + out->n = numElements; + memcpy(out->data.V, in->data.V, PSELEMTYPE_SIZEOF(type) * numElements); + return out; + } + + if (type == PS_TYPE_C32) { + psC32* outVec; + psC32* inVec = in->data.C32; + + out = psVectorRecycle(out, numElements, PS_TYPE_C32); + out->n = numElements; + outVec = out->data.C32; + + for (unsigned int i = 0; i < numElements; i++) { + outVec[i] = crealf(inVec[i]) - I * cimagf(inVec[i]); + } + } else { + psError(__func__, "Can not compute complex conjugate for given vector type (%d).", type); + psFree(out); + return NULL; + } + + return out; +} + +psVector* psVectorPowerSpectrum(psVector* out, const psVector* in) +{ + psElemType type; + unsigned int outNumElements; + unsigned int inNumElements; + unsigned int inHalfNumElements; + unsigned int inNumElementsSquared; + + if (in == NULL) { + psFree(out); + return NULL; + } + + type = in->type.type; + inNumElements = in->n; + inNumElementsSquared = inNumElements * inNumElements; + inHalfNumElements = inNumElements / 2; + outNumElements = inHalfNumElements + 1; + + /* if not a complex number, this is not implemented */ + if (!PS_IS_PSELEMTYPE_COMPLEX(type)) { + psError(__func__, "Power Spectrum for non-complex inputs is not implemented."); + psFree(out); + return NULL; + } + + if (type == PS_TYPE_C32) { + psF32* outVec; + psC32* inVec = in->data.C32; + psF32 inAbs1; + psF32 inAbs2; + + out = psVectorRecycle(out, outNumElements, PS_TYPE_F32); + out->n = outNumElements; + outVec = out->data.F32; + + // from ADD: P_0 = |C_0|^2/N^2 + inAbs1 = cabsf(inVec[0]); + outVec[0] = inAbs1 * inAbs1 / inNumElementsSquared; + + // from ADD: P_j = (|C_j|^2+|C_N-j|^2)/N^2, where j = 1,2,...,(N/2-1) + for (unsigned int i = 1; i < inHalfNumElements; i++) { + inAbs1 = cabsf(inVec[i]); + inAbs2 = cabsf(inVec[inNumElements - i]); + outVec[i] = (inAbs1 * inAbs1 + inAbs2 * inAbs2) / inNumElementsSquared; + } + + // from ADD: P_N/2 = |C_N/2|^2/N^2 + inAbs1 = cabsf(inVec[inHalfNumElements]); + outVec[inHalfNumElements] = inAbs1 * inAbs1 / inNumElementsSquared; + } else { + psError(__func__, "Can not power spectrum for given vector type (%d).", type); + psFree(out); + return NULL; + } + + return out; + +} Index: /tags/rel2_1/psLib/src/dataManip/psFFT.h =================================================================== --- /tags/rel2_1/psLib/src/dataManip/psFFT.h (revision 1553) +++ /tags/rel2_1/psLib/src/dataManip/psFFT.h (revision 1553) @@ -0,0 +1,158 @@ + +/** @file psFFT.h + * + * @brief Contains FFT transforms functions + * + * @ingroup Transform + * + * @author Robert DeSonia, MHPCC + * + * @version $Revision: 1.13 $ $Name: not supported by cvs2svn $ + * @date $Date: 2004-08-10 18:54:38 $ + * + * Copyright 2004 Maui High Performance Computing Center, University of Hawaii + */ + +#ifndef PS_FFT_H +#define PS_FFT_H + +#include "psImage.h" +#include "psVector.h" + +/// @addtogroup Transform +/// @{ + +/** Specify direction of FFT */ +typedef enum { + /// psImageFFT/psVectorFFT should perform a forward FFT. + PS_FFT_FORWARD = (-1), + + /// psImageFFT/psVectorFFT should perform a reverse FFT. + PS_FFT_REVERSE = (+1) +} psFftDirection; + +/** Forward and reverse FFT calculations. + * + * This takes as input the image of interest (in) and the direction + * (direction), which is specified by an enumerated type psFftDirection. + * The input image may be of type psF32 or psC32, the result is always + * psC32. If the input vector is psF32, the direction must be forward. + * + * @return psImage* the FFT transformation result + */ +psImage* psImageFFT( + psImage* out, ///< a psImage to recycle. If NULL, a new psImage is made. + const psImage* in, ///< the psImage to apply transform to + psFftDirection direction ///< the direction of the transform +); + +/** extract the real portion of a complex image + * + * @return psImage* real portion of the input image. + */ +psImage* psImageReal( + psImage* out, ///< a psImage to recycle. If NULL, a new psImage is made. + const psImage* in ///< the psImage to extract real portion from +); + +/** extract the imaginary portion of a complex image + * + * @return psImage* imaginary portion of the input image. + */ +psImage* psImageImaginary( + psImage* out, ///< a psImage to recycle. If NULL, a new psImage is made. + const psImage* in ///< the psImage to extract imaginary portion from +); + +/** creates a complex image from separate real and imaginary plane images + * + * @return psImage* resulting complex image + */ +psImage* psImageComplex( + psImage* out, ///< a psImage to recycle. If NULL, a new psImage is made. + const psImage* real, ///< the real plane image + const psImage* imag ///< the imaginary plane image +); + +/** computes the complex conjugate of an image + * + * @return psImage* the complex conjugate of the 'in' image + */ +psImage* psImageConjugate( + psImage* out, ///< a psImage to recycle. If NULL, a new psImage is made. + const psImage* in ///< the psImage to compute conjugate of +); + +/** computes the power spectrum of an image + * + * @return psImage* the power spectrum of the 'in' image + */ +psImage* psImagePowerSpectrum( + psImage* out, ///< a psImage to recycle. If NULL, a new psImage is made. + const psImage* in ///< the psImage to power spectrum of +); + +/** Forward and reverse FFT calculations. + * + * This takes as input the vector of interest (in) and the direction + * (direction), which is specified by an enumerated type psFftDirection. + * The input vector may be of type psF32 or psC32, the result is always + * psC32. If the input vector is psF32, the direction must be forward. + * + * @return psVector* the FFT transformation result + */ +psVector* psVectorFFT( + psVector* out, ///< a psVector to recycle. If NULL, a new psVector is made. + const psVector* in, ///< the vector to apply transform to + psFftDirection direction ///< the direction of the transform +); + +/** extract the real portion of a complex vector + * + * @return psVector* real portion of the input vector. + */ +psVector* psVectorReal( + psVector* out, ///< a psVector to recycle. If NULL, a new psVector is made. + const psVector* in ///< the psVector to extract real portion from +); + +/** extract the imaginary portion of a complex vector + * + * @return psVector* imaginary portion of the input vector. + */ +psVector* psVectorImaginary( + psVector* out, ///< a psVector to recycle. If NULL, a new psVector is made. + const psVector* in ///< the psVector to extract imaginary portion from +); + +/** creates a complex vector from separate real and imaginary vectors + * + * @return psVector* resulting complex vector + */ +psVector* psVectorComplex( + psVector* out, ///< a psVector to recycle. If NULL, a new psVector is made. + const psVector* real, ///< the real vector + const psVector* imag ///< the imaginary vector +); + +/** computes the complex conjugate of a vector + * + * @return psVector* the complex conjugate of the 'in' vector + */ +psVector* psVectorConjugate( + psVector* out, ///< a psVector to recycle. If NULL, a new psVector is made. + const psVector* in ///< the psVector to compute conjugate of +); + +/** computes the power spectrum of a vector + * + * @return psVector* the power spectrum of the 'in' vector + */ +psVector* psVectorPowerSpectrum( + psVector* out, ///< a psVector to recycle. If NULL, a new psVector is made. + const psVector* in ///< the psVector to power spectrum of +); + +/// @} + +#endif Index: /tags/rel2_1/psLib/src/dataManip/psFunctions.c =================================================================== --- /tags/rel2_1/psLib/src/dataManip/psFunctions.c (revision 1553) +++ /tags/rel2_1/psLib/src/dataManip/psFunctions.c (revision 1553) @@ -0,0 +1,770 @@ + +/** @file psFunctions.c + * + * @brief Contains basic function allocation, deallocation, and evaluation + * routines. + * + * This file will hold the functions for allocated, freeing, and evaluating + * polynomials. It also contains a Gaussian functions. + * + * @version $Revision: 1.23 $ $Name: not supported by cvs2svn $ + * @date $Date: 2004-08-11 20:07:45 $ + * + * Copyright 2004 Maui High Performance Computing Center, University of Hawaii + */ + +/*****************************************************************************/ + +/* INCLUDE FILES */ + +/*****************************************************************************/ +#include +#include +#include +#include +#include +#include + +#include "psMemory.h" +#include "psVector.h" +#include "psTrace.h" +#include "psError.h" +#include "psAbort.h" +#include "psFunctions.h" + +#include +#include + +/*****************************************************************************/ + +/* DEFINE STATEMENTS */ + +/*****************************************************************************/ + +// None + +/*****************************************************************************/ + +/* TYPE DEFINITIONS */ + +/*****************************************************************************/ +static void polynomial1DFree(psPolynomial1D* myPoly); +static void polynomial2DFree(psPolynomial2D* myPoly); +static void polynomial3DFree(psPolynomial3D* myPoly); +static void polynomial4DFree(psPolynomial4D* myPoly); +static void dPolynomial1DFree(psDPolynomial1D* myPoly); +static void dPolynomial2DFree(psDPolynomial2D* myPoly); +static void dPolynomial3DFree(psDPolynomial3D* myPoly); +static void dPolynomial4DFree(psDPolynomial4D* myPoly); + +/*****************************************************************************/ + +/* GLOBAL VARIABLES */ + +/*****************************************************************************/ + +// None + +/*****************************************************************************/ + +/* FILE STATIC VARIABLES */ + +/*****************************************************************************/ + +// None + +/*****************************************************************************/ + +/* FUNCTION IMPLEMENTATION - LOCAL */ + +/*****************************************************************************/ + +// None + +/*****************************************************************************/ + +/* FUNCTION IMPLEMENTATION - PUBLIC */ + +/*****************************************************************************/ + +/***************************************************************************** + Evaluate a non-normalized Gaussian with the given mean and sigma at the + given coordianate. Note that this is not a Gaussian deviate. The + evaluated Gaussian is: \f[ exp(-\frac{(x-mean)^2}{2\sigma^2}) \f] + *****************************************************************************/ +float psGaussian(float x, float mean, float sigma, bool normal) +{ + float tmp = 1.0; + + if (normal == true) { + #ifdef DARWIN + tmp = 1.0 / (float)sqrt(2.0 * M_PI * (sigma * sigma)); + #else + + tmp = 1.0 / sqrtf(2.0 * M_PI * (sigma * sigma)); + #endif + + } + + return (tmp * exp(-((x - mean) * (x - mean)) / (2.0 * sigma * sigma))); +} + +/***************************************************************************** + psGaussianDev() + This routine creates a psVector of the specified size and type F32 + and fills it with a random Gaussian distribution of numbers with + the specified mean and sigma. This routine makes use of the GSL + routines for generating both uniformly distributed numbers and the + Gaussian distribution as well. + + NOTE: There is no way to seed the random generator. + *****************************************************************************/ +psVector* psGaussianDev(float mean, float sigma, int Npts) +{ + psVector* gauss = NULL; + const gsl_rng_type *T = NULL; + gsl_rng *r = NULL; + int i = 0; + + gauss = psVectorAlloc(Npts, PS_TYPE_F32); + gauss->n = Npts; + gsl_rng_env_setup(); + T = gsl_rng_default; + r = gsl_rng_alloc(T); + + for (i = 0; i < Npts; i++) { + gauss->data.F32[i] = mean + gsl_ran_gaussian(r, sigma); + } + + // NOTE: Should I free r as well? + return (gauss); +} + +/***************************************************************************** + This routine must allocate memory for the polynomial structures. + *****************************************************************************/ +psPolynomial1D* psPolynomial1DAlloc(int n) +{ + int i = 0; + psPolynomial1D* newPoly = NULL; + + newPoly = (psPolynomial1D* ) psAlloc(sizeof(psPolynomial1D)); + p_psMemSetDeallocator(newPoly, (psFreeFcn) polynomial1DFree); + newPoly->n = n; + newPoly->coeff = (float *)psAlloc(n * sizeof(float)); + newPoly->coeffErr = (float *)psAlloc(n * sizeof(float)); + newPoly->mask = (char *)psAlloc(n * sizeof(char)); + for (i = 0; i < n; i++) { + newPoly->coeff[i] = 0.0; + newPoly->coeffErr[i] = 0.0; + newPoly->mask[i] = 0.0; + } + + return (newPoly); +} + +psPolynomial2D* psPolynomial2DAlloc(int nX, int nY) +{ + int x = 0; + int y = 0; + psPolynomial2D* newPoly = NULL; + + newPoly = (psPolynomial2D* ) psAlloc(sizeof(psPolynomial2D)); + p_psMemSetDeallocator(newPoly, (psFreeFcn) polynomial2DFree); + newPoly->nX = nX; + newPoly->nY = nY; + + newPoly->coeff = (float **)psAlloc(nX * sizeof(float *)); + newPoly->coeffErr = (float **)psAlloc(nX * sizeof(float *)); + newPoly->mask = (char **)psAlloc(nX * sizeof(char *)); + for (x = 0; x < nX; x++) { + newPoly->coeff[x] = (float *)psAlloc(nY * sizeof(float)); + newPoly->coeffErr[x] = (float *)psAlloc(nY * sizeof(float)); + newPoly->mask[x] = (char *)psAlloc(nY * sizeof(char)); + } + for (x = 0; x < nX; x++) { + for (y = 0; y < nY; y++) { + newPoly->coeff[x][y] = 0.0; + newPoly->coeffErr[x][y] = 0.0; + newPoly->mask[x][y] = 0; + } + } + + return (newPoly); +} + +psPolynomial3D* psPolynomial3DAlloc(int nX, int nY, int nZ) +{ + int x = 0; + int y = 0; + int z = 0; + psPolynomial3D* newPoly = NULL; + + newPoly = (psPolynomial3D* ) psAlloc(sizeof(psPolynomial3D)); + p_psMemSetDeallocator(newPoly, (psFreeFcn) polynomial3DFree); + newPoly->nX = nX; + newPoly->nY = nY; + newPoly->nZ = nZ; + + newPoly->coeff = (float ***)psAlloc(nX * sizeof(float **)); + newPoly->coeffErr = (float ***)psAlloc(nX * sizeof(float **)); + newPoly->mask = (char ***)psAlloc(nX * sizeof(char **)); + for (x = 0; x < nX; x++) { + newPoly->coeff[x] = (float **)psAlloc(nY * sizeof(float *)); + newPoly->coeffErr[x] = (float **)psAlloc(nY * sizeof(float *)); + newPoly->mask[x] = (char **)psAlloc(nY * sizeof(char *)); + for (y = 0; y < nY; y++) { + newPoly->coeff[x][y] = (float *)psAlloc(nZ * sizeof(float)); + newPoly->coeffErr[x][y] = (float *)psAlloc(nZ * sizeof(float)); + newPoly->mask[x][y] = (char *)psAlloc(nZ * sizeof(char)); + } + } + for (x = 0; x < nX; x++) { + for (y = 0; y < nY; y++) { + for (z = 0; z < nZ; z++) { + newPoly->coeff[x][y][z] = 0.0; + newPoly->coeffErr[x][y][z] = 0.0; + newPoly->mask[x][y][z] = 0; + } + } + } + + return (newPoly); +} + +psPolynomial4D* psPolynomial4DAlloc(int nW, int nX, int nY, int nZ) +{ + int w = 0; + int x = 0; + int y = 0; + int z = 0; + psPolynomial4D* newPoly = NULL; + + newPoly = (psPolynomial4D* ) psAlloc(sizeof(psPolynomial4D)); + p_psMemSetDeallocator(newPoly, (psFreeFcn) polynomial4DFree); + newPoly->nW = nW; + newPoly->nX = nX; + newPoly->nY = nY; + newPoly->nZ = nZ; + + newPoly->coeff = (float ****)psAlloc(nW * sizeof(float ***)); + newPoly->coeffErr = (float ****)psAlloc(nW * sizeof(float ***)); + newPoly->mask = (char ****)psAlloc(nW * sizeof(char ***)); + for (w = 0; w < nW; w++) { + newPoly->coeff[w] = (float ***)psAlloc(nX * sizeof(float **)); + newPoly->coeffErr[w] = (float ***)psAlloc(nX * sizeof(float **)); + newPoly->mask[w] = (char ***)psAlloc(nX * sizeof(char **)); + for (x = 0; x < nX; x++) { + newPoly->coeff[w][x] = (float **)psAlloc(nY * sizeof(float *)); + newPoly->coeffErr[w][x] = (float **)psAlloc(nY * sizeof(float *)); + newPoly->mask[w][x] = (char **)psAlloc(nY * sizeof(char *)); + for (y = 0; y < nY; y++) { + newPoly->coeff[w][x][y] = (float *)psAlloc(nZ * sizeof(float)); + newPoly->coeffErr[w][x][y] = (float *)psAlloc(nZ * sizeof(float)); + newPoly->mask[w][x][y] = (char *)psAlloc(nZ * sizeof(char)); + } + } + } + for (w = 0; w < nW; w++) { + for (x = 0; x < nX; x++) { + for (y = 0; y < nY; y++) { + for (z = 0; z < nZ; z++) { + newPoly->coeff[w][x][y][z] = 0.0; + newPoly->coeffErr[w][x][y][z] = 0.0; + newPoly->mask[w][x][y][z] = 0; + } + } + } + } + + return (newPoly); +} + +static void polynomial1DFree(psPolynomial1D* myPoly) +{ + psFree(myPoly->coeff); + psFree(myPoly->coeffErr); + psFree(myPoly->mask); +} + +static void polynomial2DFree(psPolynomial2D* myPoly) +{ + int x = 0; + + for (x = 0; x < myPoly->nX; x++) { + psFree(myPoly->coeff[x]); + psFree(myPoly->coeffErr[x]); + psFree(myPoly->mask[x]); + } + psFree(myPoly->coeff); + psFree(myPoly->coeffErr); + psFree(myPoly->mask); +} + +static void polynomial3DFree(psPolynomial3D* myPoly) +{ + int x = 0; + int y = 0; + + for (x = 0; x < myPoly->nX; x++) { + for (y = 0; y < myPoly->nY; y++) { + psFree(myPoly->coeff[x][y]); + psFree(myPoly->coeffErr[x][y]); + psFree(myPoly->mask[x][y]); + } + psFree(myPoly->coeff[x]); + psFree(myPoly->coeffErr[x]); + psFree(myPoly->mask[x]); + } + + psFree(myPoly->coeff); + psFree(myPoly->coeffErr); + psFree(myPoly->mask); +} + +static void polynomial4DFree(psPolynomial4D* myPoly) +{ + int w = 0; + int x = 0; + int y = 0; + + for (w = 0; w < myPoly->nW; w++) { + for (x = 0; x < myPoly->nX; x++) { + for (y = 0; y < myPoly->nY; y++) { + psFree(myPoly->coeff[w][x][y]); + psFree(myPoly->coeffErr[w][x][y]); + psFree(myPoly->mask[w][x][y]); + } + psFree(myPoly->coeff[w][x]); + psFree(myPoly->coeffErr[w][x]); + psFree(myPoly->mask[w][x]); + } + psFree(myPoly->coeff[w]); + psFree(myPoly->coeffErr[w]); + psFree(myPoly->mask[w]); + } + + psFree(myPoly->coeff); + psFree(myPoly->coeffErr); + psFree(myPoly->mask); +} + +/***************************************************************************** + Polynomial coefficients will be accessed in [w][x][y][z] fashion. + + XXX: Determine, from IfA, whether ot not the "mask[]" terms should be used + in polynomial evaluation. If so, then all of the following polynomial + evaluation functions must be modified to do so. + + XXX: Should the "coeffErr[]" should be used as well? + *****************************************************************************/ +float psPolynomial1DEval(float x, const psPolynomial1D* myPoly) +{ + int loop_x = 0; + float polySum = 0.0; + float xSum = 1.0; + + if (NULL == myPoly) { + psAbort(__func__, "psPolynomial1DEval(): myPoly is NULL\n"); + } + + // NOTE: Do we want to flag this case? + if (myPoly->n == 0) { + return (1.0); + } + + if (NULL == myPoly->coeff) { + psAbort(__func__, "psPolynomial1DEval(): myPoly->coeff is NULL\n"); + } + + for (loop_x = 0; loop_x < myPoly->n; loop_x++) { + polySum += xSum * myPoly->coeff[loop_x]; + xSum *= x; + } + + return (polySum); +} + +float psPolynomial2DEval(float x, float y, const psPolynomial2D* myPoly) +{ + int loop_x = 0; + int loop_y = 0; + float polySum = 0.0; + float xSum = 1.0; + float ySum = 1.0; + + for (loop_x = 0; loop_x < myPoly->nX; loop_x++) { + ySum = xSum; + for (loop_y = 0; loop_y < myPoly->nY; loop_y++) { + polySum += ySum * myPoly->coeff[loop_x][loop_y]; + ySum *= y; + } + xSum *= x; + } + + return (polySum); +} + +float psPolynomial3DEval(float x, float y, float z, const psPolynomial3D* myPoly) +{ + int loop_x = 0; + int loop_y = 0; + int loop_z = 0; + float polySum = 0.0; + float xSum = 1.0; + float ySum = 1.0; + float zSum = 1.0; + + for (loop_x = 0; loop_x < myPoly->nX; loop_x++) { + ySum = xSum; + for (loop_y = 0; loop_y < myPoly->nY; loop_y++) { + zSum = ySum; + for (loop_z = 0; loop_z < myPoly->nZ; loop_z++) { + polySum += zSum * myPoly->coeff[loop_x][loop_y][loop_z]; + zSum *= z; + } + ySum *= y; + } + xSum *= x; + } + + return (polySum); +} + +float psPolynomial4DEval(float w, float x, float y, float z, const psPolynomial4D* myPoly) +{ + int loop_w = 0; + int loop_x = 0; + int loop_y = 0; + int loop_z = 0; + float polySum = 0.0; + float wSum = 1.0; + float xSum = 1.0; + float ySum = 1.0; + float zSum = 1.0; + + for (loop_w = 0; loop_w < myPoly->nW; loop_w++) { + xSum = wSum; + for (loop_x = 0; loop_x < myPoly->nX; loop_x++) { + ySum = xSum; + for (loop_y = 0; loop_y < myPoly->nY; loop_y++) { + zSum = ySum; + for (loop_z = 0; loop_z < myPoly->nZ; loop_z++) { + polySum += zSum * myPoly->coeff[loop_w][loop_x][loop_y][loop_z]; + zSum *= z; + } + ySum *= y; + } + xSum *= x; + } + wSum *= w; + } + + return (polySum); +} + +psDPolynomial1D* psDPolynomial1DAlloc(int n) +{ + int i = 0; + psDPolynomial1D* newPoly = NULL; + + newPoly = (psDPolynomial1D* ) psAlloc(sizeof(psDPolynomial1D)); + p_psMemSetDeallocator(newPoly, (psFreeFcn) dPolynomial1DFree); + newPoly->n = n; + newPoly->coeff = (double *)psAlloc(n * sizeof(double)); + newPoly->coeffErr = (double *)psAlloc(n * sizeof(double)); + newPoly->mask = (char *)psAlloc(n * sizeof(char)); + for (i = 0; i < n; i++) { + newPoly->coeff[i] = 0.0; + newPoly->coeffErr[i] = 0.0; + newPoly->mask[i] = 0.0; + } + + return (newPoly); +} + +psDPolynomial2D* psDPolynomial2DAlloc(int nX, int nY) +{ + int x = 0; + int y = 0; + psDPolynomial2D* newPoly = NULL; + + newPoly = (psDPolynomial2D* ) psAlloc(sizeof(psDPolynomial2D)); + p_psMemSetDeallocator(newPoly, (psFreeFcn) dPolynomial2DFree); + newPoly->nX = nX; + newPoly->nY = nY; + + newPoly->coeff = (double **)psAlloc(nX * sizeof(double *)); + newPoly->coeffErr = (double **)psAlloc(nX * sizeof(double *)); + newPoly->mask = (char **)psAlloc(nX * sizeof(char *)); + for (x = 0; x < nX; x++) { + newPoly->coeff[x] = (double *)psAlloc(nY * sizeof(double)); + newPoly->coeffErr[x] = (double *)psAlloc(nY * sizeof(double)); + newPoly->mask[x] = (char *)psAlloc(nY * sizeof(char)); + } + for (x = 0; x < nX; x++) { + for (y = 0; y < nY; y++) { + newPoly->coeff[x][y] = 0.0; + newPoly->coeffErr[x][y] = 0.0; + newPoly->mask[x][y] = 0; + } + } + + return (newPoly); +} + +psDPolynomial3D* psDPolynomial3DAlloc(int nX, int nY, int nZ) +{ + int x = 0; + int y = 0; + int z = 0; + psDPolynomial3D* newPoly = NULL; + + newPoly = (psDPolynomial3D* ) psAlloc(sizeof(psDPolynomial3D)); + p_psMemSetDeallocator(newPoly, (psFreeFcn) dPolynomial3DFree); + newPoly->nX = nX; + newPoly->nY = nY; + newPoly->nZ = nZ; + + newPoly->coeff = (double ***)psAlloc(nX * sizeof(double **)); + newPoly->coeffErr = (double ***)psAlloc(nX * sizeof(double **)); + newPoly->mask = (char ***)psAlloc(nX * sizeof(char **)); + for (x = 0; x < nX; x++) { + newPoly->coeff[x] = (double **)psAlloc(nY * sizeof(double *)); + newPoly->coeffErr[x] = (double **)psAlloc(nY * sizeof(double *)); + newPoly->mask[x] = (char **)psAlloc(nY * sizeof(char *)); + for (y = 0; y < nY; y++) { + newPoly->coeff[x][y] = (double *)psAlloc(nZ * sizeof(double)); + newPoly->coeffErr[x][y] = (double *)psAlloc(nZ * sizeof(double)); + newPoly->mask[x][y] = (char *)psAlloc(nZ * sizeof(char)); + } + } + for (x = 0; x < nX; x++) { + for (y = 0; y < nY; y++) { + for (z = 0; z < nZ; z++) { + newPoly->coeff[x][y][z] = 0.0; + newPoly->coeffErr[x][y][z] = 0.0; + newPoly->mask[x][y][z] = 0; + } + } + } + + return (newPoly); +} + +psDPolynomial4D* psDPolynomial4DAlloc(int nW, int nX, int nY, int nZ) +{ + int w = 0; + int x = 0; + int y = 0; + int z = 0; + psDPolynomial4D* newPoly = NULL; + + newPoly = (psDPolynomial4D* ) psAlloc(sizeof(psDPolynomial4D)); + p_psMemSetDeallocator(newPoly, (psFreeFcn) dPolynomial4DFree); + newPoly->nW = nW; + newPoly->nX = nX; + newPoly->nY = nY; + newPoly->nZ = nZ; + + newPoly->coeff = (double ****)psAlloc(nW * sizeof(double ***)); + newPoly->coeffErr = (double ****)psAlloc(nW * sizeof(double ***)); + newPoly->mask = (char ****)psAlloc(nW * sizeof(char ***)); + for (w = 0; w < nW; w++) { + newPoly->coeff[w] = (double ***)psAlloc(nX * sizeof(double **)); + newPoly->coeffErr[w] = (double ***)psAlloc(nX * sizeof(double **)); + newPoly->mask[w] = (char ***)psAlloc(nX * sizeof(char **)); + for (x = 0; x < nX; x++) { + newPoly->coeff[w][x] = (double **)psAlloc(nY * sizeof(double *)); + newPoly->coeffErr[w][x] = (double **)psAlloc(nY * sizeof(double *)); + newPoly->mask[w][x] = (char **)psAlloc(nY * sizeof(char *)); + for (y = 0; y < nY; y++) { + newPoly->coeff[w][x][y] = (double *)psAlloc(nZ * sizeof(double)); + newPoly->coeffErr[w][x][y] = (double *)psAlloc(nZ * sizeof(double)); + newPoly->mask[w][x][y] = (char *)psAlloc(nZ * sizeof(char)); + } + } + } + for (w = 0; w < nW; w++) { + for (x = 0; x < nX; x++) { + for (y = 0; y < nY; y++) { + for (z = 0; z < nZ; z++) { + newPoly->coeff[w][x][y][z] = 0.0; + newPoly->coeffErr[w][x][y][z] = 0.0; + newPoly->mask[w][x][y][z] = 0; + } + } + } + } + + return (newPoly); +} + +static void dPolynomial1DFree(psDPolynomial1D* myPoly) +{ + psFree(myPoly->coeff); + psFree(myPoly->coeffErr); + psFree(myPoly->mask); +} + +static void dPolynomial2DFree(psDPolynomial2D* myPoly) +{ + int x = 0; + + for (x = 0; x < myPoly->nX; x++) { + psFree(myPoly->coeff[x]); + psFree(myPoly->coeffErr[x]); + psFree(myPoly->mask[x]); + } + psFree(myPoly->coeff); + psFree(myPoly->coeffErr); + psFree(myPoly->mask); +} + +static void dPolynomial3DFree(psDPolynomial3D* myPoly) +{ + int x = 0; + int y = 0; + + for (x = 0; x < myPoly->nX; x++) { + for (y = 0; y < myPoly->nY; y++) { + psFree(myPoly->coeff[x][y]); + psFree(myPoly->coeffErr[x][y]); + psFree(myPoly->mask[x][y]); + } + psFree(myPoly->coeff[x]); + psFree(myPoly->coeffErr[x]); + psFree(myPoly->mask[x]); + } + + psFree(myPoly->coeff); + psFree(myPoly->coeffErr); + psFree(myPoly->mask); +} + +static void dPolynomial4DFree(psDPolynomial4D* myPoly) +{ + int w = 0; + int x = 0; + int y = 0; + + for (w = 0; w < myPoly->nW; w++) { + for (x = 0; x < myPoly->nX; x++) { + for (y = 0; y < myPoly->nY; y++) { + psFree(myPoly->coeff[w][x][y]); + psFree(myPoly->coeffErr[w][x][y]); + psFree(myPoly->mask[w][x][y]); + } + psFree(myPoly->coeff[w][x]); + psFree(myPoly->coeffErr[w][x]); + psFree(myPoly->mask[w][x]); + } + psFree(myPoly->coeff[w]); + psFree(myPoly->coeffErr[w]); + psFree(myPoly->mask[w]); + } + + psFree(myPoly->coeff); + psFree(myPoly->coeffErr); + psFree(myPoly->mask); +} + +/***************************************************************************** + Polynomial coefficients will be accessed in [w][x][y][z] fashion. + *****************************************************************************/ +double psDPolynomial1DEval(double x, const psDPolynomial1D* myPoly) +{ + int loop_x = 0; + double polySum = 0.0; + double xSum = 1.0; + + // NOTE: Do we want to flag this case? + if (myPoly->n == 0) { + return (1.0); + } + + for (loop_x = 0; loop_x < myPoly->n; loop_x++) { + polySum += xSum * myPoly->coeff[loop_x]; + xSum *= x; + } + + return (polySum); +} + +double psDPolynomial2DEval(double x, double y, const psDPolynomial2D* myPoly) +{ + int loop_x = 0; + int loop_y = 0; + double polySum = 0.0; + double xSum = 1.0; + double ySum = 1.0; + + for (loop_x = 0; loop_x < myPoly->nX; loop_x++) { + ySum = xSum; + for (loop_y = 0; loop_y < myPoly->nY; loop_y++) { + polySum += ySum * myPoly->coeff[loop_x][loop_y]; + ySum *= y; + } + xSum *= x; + } + + return (polySum); +} + +double psDPolynomial3DEval(double x, double y, double z, const psDPolynomial3D* myPoly) +{ + int loop_x = 0; + int loop_y = 0; + int loop_z = 0; + double polySum = 0.0; + double xSum = 1.0; + double ySum = 1.0; + double zSum = 1.0; + + for (loop_x = 0; loop_x < myPoly->nX; loop_x++) { + ySum = xSum; + for (loop_y = 0; loop_y < myPoly->nY; loop_y++) { + zSum = ySum; + for (loop_z = 0; loop_z < myPoly->nZ; loop_z++) { + polySum += zSum * myPoly->coeff[loop_x][loop_y][loop_z]; + zSum *= z; + } + ySum *= y; + } + xSum *= x; + } + + return (polySum); +} + +double psDPolynomial4DEval(double w, double x, double y, double z, const psDPolynomial4D* myPoly) +{ + int loop_w = 0; + int loop_x = 0; + int loop_y = 0; + int loop_z = 0; + double polySum = 0.0; + double wSum = 1.0; + double xSum = 1.0; + double ySum = 1.0; + double zSum = 1.0; + + for (loop_w = 0; loop_w < myPoly->nW; loop_w++) { + xSum = wSum; + for (loop_x = 0; loop_x < myPoly->nX; loop_x++) { + ySum = xSum; + for (loop_y = 0; loop_y < myPoly->nY; loop_y++) { + zSum = ySum; + for (loop_z = 0; loop_z < myPoly->nZ; loop_z++) { + polySum += zSum * myPoly->coeff[loop_w][loop_x][loop_y][loop_z]; + zSum *= z; + } + ySum *= y; + } + xSum *= x; + } + wSum *= w; + } + + return (polySum); +} Index: /tags/rel2_1/psLib/src/dataManip/psFunctions.h =================================================================== --- /tags/rel2_1/psLib/src/dataManip/psFunctions.h (revision 1553) +++ /tags/rel2_1/psLib/src/dataManip/psFunctions.h (revision 1553) @@ -0,0 +1,318 @@ + +/** @file psFunctions.h +* \brief Standard Mathematical Functions. +* \ingroup Stats +* +* This file will hold the prototypes for procedures which allocate, free, +* and evaluate various polynomials. Those polynomial structures are also +* defined here. +* +* @ingroup Stats +* +* @author Someone at IfA +* @author George Gusciora, MHPCC +* +* @version $Revision: 1.19 $ $Name: not supported by cvs2svn $ +* @date $Date: 2004-08-11 02:35:58 $ +* +* Copyright 2004 Maui High Performance Computing Center, University of Hawaii +*/ + +#if !defined(PS_FUNCTIONS_H) +#define PS_FUNCTIONS_H + +#include + +#include "psVector.h" + +/** \addtogroup Stats + * \{ + */ + +/** Evaluate a non-normalized Gaussian with the given mean and sigma at the + * given coordianate. + * + * Note that this is not a Gaussian deviate. The evaluated Gaussian is: + * \f[ exp(-\frac{(x-mean)^2}{2\sigma^2}) \f] + * + * @return float value on the gaussian curve given the input parameters + */ +float psGaussian( + float x, ///< Value at which to evaluate + float mean, ///< Mean for the Gaussian + float stddev, ///< Standard deviation for the Gaussian + bool normal ///< Indicates whether result should be normalized +); + +/** Produce a vector of random numbers from a Gaussian distribution with + * the specified mean and sigma + * + * @return psVector* vector of random numbers + * + */ +psVector* psGaussianDev( + float mean, ///< The mean of the Gaussian + float sigma, ///< The sigma of the Gaussian + int Npts ///< The size of the vector +); + +/** One-dimensional polynomial */ +typedef struct +{ + int n; ///< Number of terms + float *coeff; ///< Coefficients + float *coeffErr; ///< Error in coefficients + char *mask; ///< Coefficient mask +} +psPolynomial1D; + +/** Two-dimensional polynomial */ +typedef struct +{ + int nX; ///< Number of terms in x + int nY; ///< Number of terms in y + float **coeff; ///< Coefficients + float **coeffErr; ///< Error in coefficients + char **mask; ///< Coefficients mask +} +psPolynomial2D; + +/** Three-dimensional polynomial */ +typedef struct +{ + int nX; ///< Number of terms in x + int nY; ///< Number of terms in y + int nZ; ///< Number of terms in z + float ***coeff; ///< Coefficients + float ***coeffErr; ///< Error in coefficients + char ***mask; ///< Coefficients mask +} +psPolynomial3D; + +/** Four-dimensional polynomial */ +typedef struct +{ + int nW; ///< Number of terms in w + int nX; ///< Number of terms in x + int nY; ///< Number of terms in y + int nZ; ///< Number of terms in z + float ****coeff; ///< Coefficients + float ****coeffErr; ///< Error in coefficients + char ****mask; ///< Coefficients mask +} +psPolynomial4D; + + +/** Allocates a psPolynomial1D structure with n terms + * + * @return psPolynomial1D* new 1-D polynomial struct + */ +psPolynomial1D* psPolynomial1DAlloc( + int n ///< Number of terms +); + +/** Allocates a 2-D polynomial structure + * + * @return psPolynomial2D* new 2-D polynomial struct + */ +psPolynomial2D* psPolynomial2DAlloc( + int nX, ///< Number of terms in x + int nY ///< Number of terms in y +); + +/** Allocates a 3-D polynomial structure + * + * @return psPolynomial3D* new 3-D polynomial struct + */ +psPolynomial3D* psPolynomial3DAlloc( + int nX, ///< Number of terms in x + int nY, ///< Number of terms in y + int nZ ///< Number of terms in z +); + +/** Allocates a 4-D polynomial structure + * + * @return psPolynomial4D* new 4-D polynomial struct + */ +psPolynomial4D* psPolynomial4DAlloc( + int nW, ///< Number of terms in w + int nX, ///< Number of terms in x + int nY, ///< Number of terms in y + int nZ ///< Number of terms in z +); + +/** Evaluates a 1-D polynomial at specific coordinates. + * + * @return float result of polynomial at given location + */ +float psPolynomial1DEval( + float x, ///< location at which to evaluate + const psPolynomial1D* myPoly ///< Coefficients for the polynomial +); + +/** Evaluates a 2-D polynomial at specific coordinates. + * + * @return float result of polynomial at given location + */ +float psPolynomial2DEval( + float x, ///< x location at which to evaluate + float y, ///< y location at which to evaluate + const psPolynomial2D* myPoly ///< Coefficients for the polynomial +); + +/** Evaluates a 3-D polynomial at specific coordinates. + * + * @return float result of polynomial at given location + */ +float psPolynomial3DEval( + float x, ///< x location at which to evaluate + float y, ///< y location at which to evaluate + float z, ///< z location at which to evaluate + const psPolynomial3D* myPoly ///< Coefficients for the polynomial +); + +/** Evaluates a 4-D polynomial at specific coordinates. + * + * @return float result of polynomial at given location + */ +float psPolynomial4DEval( + float w, ///< w location at which to evaluate + float x, ///< x location at which to evaluate + float y, ///< y location at which to evaluate + float z, ///< z location at which to evaluate + const psPolynomial4D* myPoly ///< Coefficients for the polynomial +); + +/*****************************************************************************/ + +/* Double-precision polynomials, mainly for use in astrometry */ + +/** Double-precision one-dimensional polynomial */ +typedef struct +{ + int n; ///< Number of terms + double *coeff; ///< Coefficients + double *coeffErr; ///< Error in coefficients + char *mask; ///< Coefficient mask +} +psDPolynomial1D; + +/** Double-precision two-dimensional polynomial */ +typedef struct +{ + int nX; ///< Number of terms in x + int nY; ///< Number of terms in y + double **coeff; ///< Coefficients + double **coeffErr; ///< Error in coefficients + char **mask; ///< Coefficients mask +} +psDPolynomial2D; + +/** Double-precision three-dimensional polynomial */ +typedef struct +{ + int nX; ///< Number of terms in x + int nY; ///< Number of terms in y + int nZ; ///< Number of terms in z + double ***coeff; ///< Coefficients + double ***coeffErr; ///< Error in coefficients + char ***mask; ///< Coefficient mask +} +psDPolynomial3D; + +/** Double-precision four-dimensional polynomial */ +typedef struct +{ + int nW; ///< Number of terms in w + int nX; ///< Number of terms in x + int nY; ///< Number of terms in y + int nZ; ///< Number of terms in z + double ****coeff; ///< Coefficients + double ****coeffErr; ///< Error in coefficients + char ****mask; ///< Coefficients mask +} +psDPolynomial4D; + +/** Allocates a double-precision 1-D polynomial structure with n terms + * + * @return psPolynomial1D* new double-precision 1-D polynomial struct + */ +psDPolynomial1D* psDPolynomial1DAlloc( + int n ///< Number of terms +); + +/** Allocates a double-precision 2-D polynomial structure + * + * @return psPolynomial2D* new double-precision 2-D polynomial struct + */ +psDPolynomial2D* psDPolynomial2DAlloc( + int nX, ///< Number of terms in x + int nY ///< Number of terms in y +); + +/** Allocates a double-precision 3-D polynomial structure + * + * @return psPolynomial3D* new double-precision 3-D polynomial struct + */ +psDPolynomial3D* psDPolynomial3DAlloc( + int nX, ///< Number of terms in x + int nY, ///< Number of terms in y + int nZ ///< Number of terms in z +); + +/** Allocates a double-precision 4-D polynomial structure + * + * @return psPolynomial4D* new double-precision 4-D polynomial struct + */ +psDPolynomial4D* psDPolynomial4DAlloc( + int nW, ///< Number of terms in w + int nX, ///< Number of terms in x + int nY, ///< Number of terms in y + int nZ ///< Number of terms in z +); + +/** Evaluates a double-precision 1-D polynomial at specific coordinates. + * + * @return float result of polynomial at given location + */ +double psDPolynomial1DEval( + double x, ///< Value at which to evaluate + const psDPolynomial1D* myPoly ///< Coefficients for the polynomial +); + +/** Evaluates a double-precision 2-D polynomial at specific coordinates. + * + * @return float result of polynomial at given location + */ +double psDPolynomial2DEval( + double x, ///< Value x at which to evaluate + double y, ///< Value y at which to evaluate + const psDPolynomial2D* myPoly ///< Coefficients for the polynomial +); + +/** Evaluates a double-precision 3-D polynomial at specific coordinates. + * + * @return float result of polynomial at given location + */ +double psDPolynomial3DEval( + double x, ///< Value x at which to evaluate + double y, ///< Value y at which to evaluate + double z, ///< Value z at which to evaluate + const psDPolynomial3D* myPoly ///< Coefficients for the polynomial +); + +/** Evaluates a double-precision 4-D polynomial at specific coordinates. + * + * @return float result of polynomial at given location + */ +double psDPolynomial4DEval( + double w, ///< Value w at which to evaluate + double x, ///< Value x at which to evaluate + double y, ///< Value y at which to evaluate + double z, ///< Value z at which to evaluate + const psDPolynomial4D* myPoly ///< Coefficients for the polynomial +); + +/* \} */// End of MathGroup Functions + +#endif Index: /tags/rel2_1/psLib/src/dataManip/psMatrix.c =================================================================== --- /tags/rel2_1/psLib/src/dataManip/psMatrix.c (revision 1553) +++ /tags/rel2_1/psLib/src/dataManip/psMatrix.c (revision 1553) @@ -0,0 +1,582 @@ + +/** @file psMatrix.c + * + * @brief Provides functions for linear algebra operations on psImages and psVectors. + * + * Functions are provided to: + * Transpose a psImage + * Compute LUD + * Solve LUD + * Matrix inversion + * Calculate determinant + * Matrix addition + * Matrix subtraction + * Matrix multiplication + * Calculate Eigenvectors + * Convert matrix to vector + * Convert vector to matrix + * + * These functions treat psImages as if they were matrices, therefore there is no psMatrix. + * + * @author Ross Harman, MHPCC + * + * @version $Revision: 1.12 $ $Name: not supported by cvs2svn $ + * @date $Date: 2004-08-09 23:34:57 $ + * + * Copyright 2004 Maui High Performance Computing Center, University of Hawaii + */ + +/******************************************************************************/ + +/* INCLUDE FILES */ + +/******************************************************************************/ +#include +#include +#include +#include +#include + +#include "psMemory.h" +#include "psError.h" +#include "psImage.h" +#include "psVector.h" +#include "psMatrix.h" + +/******************************************************************************/ + +/* DEFINE STATEMENTS */ + +/******************************************************************************/ + +// None + +/******************************************************************************/ + +/* TYPE DEFINITIONS */ + +/******************************************************************************/ + +// None + +/*****************************************************************************/ + +/* GLOBAL VARIABLES */ + +/*****************************************************************************/ + +// None + +/*****************************************************************************/ + +/* FILE STATIC VARIABLES */ + +/*****************************************************************************/ + +// None + +/*****************************************************************************/ + +/* FUNCTION IMPLEMENTATION - LOCAL */ + +/*****************************************************************************/ + +/** Preprocessor macro to generate error a NULL image */ +#define PS_CHECK_NULL_VECTOR(NAME, RETURN) \ +if (NAME == NULL || NAME->data.V == NULL) { \ + psError(__func__,"Invalid operation: %s or its data is NULL.", #NAME); \ + return RETURN; \ +} + +/** Preprocessor macro to create vector based on another */ +#define PS_CHECK_ALLOC_VECTOR(NAME, SIZE, PS_TYPE) \ +if(NAME == NULL) { \ + NAME = psVectorAlloc(SIZE, PS_TYPE); \ +} + +/** Preprocessor macro to generate error for zero length vector */ +#define PS_CHECK_SIZE_VECTOR(NAME, RETURN) \ +if (NAME->n < 1) { \ + psError(__func__,"Invalid operation: %s has zero n value.", #NAME); \ + return RETURN; \ +} + +/** Preprocessor macro to generate error a NULL image */ +#define PS_CHECK_NULL_IMAGE(NAME, RETURN) \ +if (NAME == NULL || NAME->data.V == NULL) { \ + psError(__func__,"Invalid operation: %s or its data is NULL.", #NAME); \ + return RETURN; \ +} + +/** Preprocessor macro to create image based on another */ +#define PS_CHECK_ALLOC_IMAGE(NAME, NCOLS, NROWS, PS_TYPE) \ +if(NAME == NULL) { \ + NAME = psImageAlloc(NCOLS, NROWS, PS_TYPE); \ +} + +/** Preprocessor macro to generate error for zero length rows or columns */ +#define PS_CHECK_SIZE_IMAGE(NAME, RETURN) \ +if (NAME->numCols < 1 || NAME->numRows < 1) { \ + psError(__func__,"Invalid operation: %s has zero rows or columns (%dx%d).", #NAME, \ + NAME->numCols, NAME->numRows); \ + return RETURN; \ +} + +/** Preprocessor macro to generate error for image dimensionality not set to PS_DIMEN_IMAGE */ +#define PS_CHECK_DIMEN_AND_TYPE(NAME, PS_DIMEN, RETURN) \ +if (NAME->type.dimen != PS_DIMEN) { \ + psError(__func__,"Invalid operation: %s incorrect dimensionality %d.", #NAME, PS_DIMEN); \ + return RETURN; \ +} else if(NAME->type.type != PS_TYPE_F64) { \ + psError(__func__, "Invalid operation: %s not PS_TYPE_F64.", #NAME); \ + return RETURN; \ +} + +/** Preprocessor macro to check that input is not equal to output */ +#define PS_CHECK_POINTERS(NAME1, NAME2, RETURN) \ +if (NAME1 == NAME2) { \ + psError(__func__,"Invalid operation: Pointer to %s is same as %s.", #NAME1, #NAME2); \ + return RETURN; \ +} + +/** Preprocessor macro to check that an image is square */ +#define PS_CHECK_SQUARE(NAME, RETURN) \ +if (NAME->numCols != NAME->numRows) { \ + psError(__func__,"Invalid operation: %s not square array.", #NAME); \ + return RETURN; \ +} + +/** Preprocessor macro to initalize a GSL matrix. */ +#define PS_GSL_MATRIX_INITIALIZE(LHS_NAME, RHS_NAME) \ +LHS_NAME.size1 = numRows; \ +LHS_NAME.size2 = numCols; \ +LHS_NAME.tda = numCols; \ +LHS_NAME.data = RHS_NAME; + +/*****************************************************************************/ + +/* FUNCTION IMPLEMENTATION - PUBLIC */ + +/*****************************************************************************/ + +psImage* psMatrixLUD(psImage* outImage, psVector* outPerm, psImage* inImage) +{ + int signum = 0; + int arraySize = 0; + int numRows = 0; + int numCols = 0; + gsl_matrix lu; + gsl_permutation perm; + + // Error checks + PS_CHECK_POINTERS(inImage, outImage, outImage); + PS_CHECK_NULL_IMAGE(inImage, outImage); + PS_CHECK_DIMEN_AND_TYPE(inImage, PS_DIMEN_IMAGE, outImage); + PS_CHECK_SIZE_IMAGE(inImage, outImage); + PS_CHECK_ALLOC_IMAGE(outImage, inImage->numCols, inImage->numRows, inImage->type.type); + PS_CHECK_DIMEN_AND_TYPE(outImage, PS_DIMEN_IMAGE, outImage); + PS_CHECK_SIZE_IMAGE(outImage, outImage); + PS_CHECK_ALLOC_VECTOR(outPerm, inImage->numRows, inImage->type.type); + PS_CHECK_NULL_VECTOR(outPerm, outImage); + PS_CHECK_DIMEN_AND_TYPE(outPerm, PS_DIMEN_VECTOR, outImage); + + // Initialize data + numRows = inImage->numRows; + numCols = inImage->numCols; + arraySize = PSELEMTYPE_SIZEOF(inImage->type.type) * numRows * numCols; + + // Initialize GSL data + perm.size = numCols; + outPerm->n = numCols; + perm.data = outPerm->data.V; + PS_GSL_MATRIX_INITIALIZE(lu, outImage->data.V[0]); + + // Non-square matrices not allowed + PS_CHECK_SQUARE(inImage, outImage); + PS_CHECK_SQUARE(outImage, outImage); + + // Copy psImage input data into GSL matrix data to keep input data pristine + memcpy(lu.data, inImage->data.V[0], arraySize); + + // Calculate LU decomposition + gsl_linalg_LU_decomp(&lu, &perm, &signum); + + return outImage; +} + +psVector* psMatrixLUSolve(psVector* outVector, const psImage* inImage, const psVector* inVector, const + psVector* inPerm) +{ + int arraySize = 0; + int numRows = 0; + int numCols = 0; + gsl_matrix lu; + gsl_permutation perm; + gsl_vector b; + gsl_vector x; + + // Error checks + PS_CHECK_POINTERS(outVector, inVector, outVector); + PS_CHECK_POINTERS(inVector, inPerm, outVector); + PS_CHECK_POINTERS(outVector, inPerm, outVector); + PS_CHECK_NULL_IMAGE(inImage, outVector); + PS_CHECK_DIMEN_AND_TYPE(inImage, PS_DIMEN_IMAGE, outVector); + PS_CHECK_SIZE_IMAGE(inImage, outVector); + PS_CHECK_ALLOC_VECTOR(outVector, inImage->numRows, inImage->type.type); + PS_CHECK_NULL_VECTOR(outVector, outVector); + PS_CHECK_DIMEN_AND_TYPE(outVector, PS_DIMEN_VECTOR, outVector); + PS_CHECK_NULL_VECTOR(inVector, outVector); + PS_CHECK_DIMEN_AND_TYPE(inVector, PS_DIMEN_VECTOR, outVector); + PS_CHECK_NULL_VECTOR(inPerm, outVector); + PS_CHECK_DIMEN_AND_TYPE(inPerm, PS_DIMEN_VECTOR, outVector); + + // Initialize data + numRows = inImage->numRows; + numCols = inImage->numCols; + arraySize = PSELEMTYPE_SIZEOF(inImage->type.type) * numRows * numCols; + + // Initialize GSL data + PS_GSL_MATRIX_INITIALIZE(lu, inImage->data.V[0]); + + outVector->n = numCols; + + perm.size = inPerm->n; + perm.data = inPerm->data.V; + + b.size = inVector->n; + b.stride = 1; + b.data = inVector->data.V; + + x.size = numCols; + x.stride = 1; + x.data = outVector->data.V; + + // Solve for {x} in equation: {b} = [A]{x} + gsl_linalg_LU_solve(&lu, &perm, &b, &x); + + return outVector; +} + +psImage* psMatrixInvert(psImage* outImage, const psImage* inImage, float *restrict det) +{ + int signum = 0; + int arraySize = 0; + int numRows = 0; + int numCols = 0; + gsl_matrix inv; + gsl_matrix *lu; + gsl_permutation *perm = NULL; + + // Error checks + if (det == NULL) { + psError(__func__, "Invalid operation: determinant argument is NULL."); + return outImage; + } + PS_CHECK_POINTERS(inImage, outImage, outImage); + PS_CHECK_NULL_IMAGE(inImage, outImage); + PS_CHECK_DIMEN_AND_TYPE(inImage, PS_DIMEN_IMAGE, outImage); + PS_CHECK_SIZE_IMAGE(inImage, outImage); + PS_CHECK_ALLOC_IMAGE(outImage, inImage->numCols, inImage->numRows, inImage->type.type); + PS_CHECK_DIMEN_AND_TYPE(outImage, PS_DIMEN_IMAGE, outImage); + PS_CHECK_SIZE_IMAGE(outImage, outImage); + + // Initialize data + numRows = inImage->numRows; + numCols = inImage->numCols; + arraySize = PSELEMTYPE_SIZEOF(inImage->type.type) * numRows * numCols; + + // Allocate GSL structs + perm = gsl_permutation_alloc(inImage->numRows); + lu = gsl_matrix_alloc(numRows, numCols); + + // Initialize GSL data + PS_GSL_MATRIX_INITIALIZE(inv, outImage->data.V[0]); + + // Non-square matrices not allowed + PS_CHECK_SQUARE(inImage, outImage); + PS_CHECK_SQUARE(outImage, outImage); + + // Copy psImage input data into GSL matrix data to keep input data pristine + memcpy(lu->data, inImage->data.V[0], arraySize); + + // Invert data and calculate determinant + gsl_linalg_LU_decomp(lu, perm, &signum); + gsl_linalg_LU_invert(lu, perm, &inv); + *det = (float)gsl_linalg_LU_det(lu, signum); + + // Free GSL structs + gsl_permutation_free(perm); + gsl_matrix_free(lu); + + return outImage; +} + +float *psMatrixDeterminant(const psImage* restrict inImage) +{ + int signum = 0; + int arraySize = 0; + int numRows = 0; + int numCols = 0; + float *det = NULL; + gsl_matrix *lu = NULL; + gsl_permutation *perm = NULL; + + // Error checks + PS_CHECK_NULL_IMAGE(inImage, NULL); + PS_CHECK_DIMEN_AND_TYPE(inImage, PS_DIMEN_IMAGE, NULL); + PS_CHECK_SIZE_IMAGE(inImage, NULL); + + // Initialize data + numRows = inImage->numRows; + numCols = inImage->numCols; + arraySize = PSELEMTYPE_SIZEOF(inImage->type.type) * numRows * numCols; + + // Allocate GSL structs + perm = gsl_permutation_alloc(numRows); + lu = gsl_matrix_alloc(numRows, numCols); + + // Non-square matrices not allowed + PS_CHECK_SQUARE(inImage, 0); + + // Copy psImage input data into GSL matrix data to keep input data pristine + memcpy(lu->data, inImage->data.V[0], arraySize); + + // Calculate determinant + det = (float *)psAlloc(sizeof(float)); + gsl_linalg_LU_decomp(lu, perm, &signum); + *det = (float)gsl_linalg_LU_det(lu, signum); + + // Free GSL structs + gsl_permutation_free(perm); + gsl_matrix_free(lu); + + return det; +} + +psImage* psMatrixMultiply(psImage* outImage, psImage* inImage1, psImage* inImage2) +{ + int arraySize = 0; + int numRows = 0; + int numCols = 0; + gsl_matrix m1; + gsl_matrix m2; + gsl_matrix m3; + + // Error checks + PS_CHECK_POINTERS(inImage1, outImage, outImage); + PS_CHECK_POINTERS(inImage1, inImage2, outImage); + PS_CHECK_NULL_IMAGE(inImage1, outImage); + PS_CHECK_DIMEN_AND_TYPE(inImage1, PS_DIMEN_IMAGE, outImage); + PS_CHECK_SIZE_IMAGE(inImage1, outImage); + PS_CHECK_NULL_IMAGE(inImage2, outImage); + PS_CHECK_DIMEN_AND_TYPE(inImage2, PS_DIMEN_IMAGE, outImage); + PS_CHECK_SIZE_IMAGE(inImage2, outImage); + PS_CHECK_ALLOC_IMAGE(outImage, inImage2->numCols, inImage2->numRows, inImage2->type.type); + PS_CHECK_DIMEN_AND_TYPE(inImage1, PS_DIMEN_IMAGE, outImage); + PS_CHECK_SIZE_IMAGE(outImage, outImage); + + // Initialize data + numRows = inImage1->numRows; + numCols = inImage1->numCols; + arraySize = PSELEMTYPE_SIZEOF(outImage->type.type) * numRows * numCols; + + // Initialize GSL data + PS_GSL_MATRIX_INITIALIZE(m1, inImage1->data.V[0]); + PS_GSL_MATRIX_INITIALIZE(m2, inImage2->data.V[0]); + PS_GSL_MATRIX_INITIALIZE(m3, outImage->data.V[0]); + + // Non-square matrices not allowed + PS_CHECK_SQUARE(inImage1, outImage); + PS_CHECK_SQUARE(inImage2, outImage); + PS_CHECK_SQUARE(outImage, outImage); + + gsl_linalg_matmult(&m1, &m2, &m3); + + return outImage; +} + +psImage* psMatrixTranspose(psImage* outImage, const psImage* inImage) +{ + int arraySize = 0; + int numRows = 0; + int numCols = 0; + gsl_matrix trans; + + // Error checks + PS_CHECK_POINTERS(inImage, outImage, outImage); + PS_CHECK_NULL_IMAGE(inImage, outImage); + PS_CHECK_DIMEN_AND_TYPE(inImage, PS_DIMEN_IMAGE, outImage); + PS_CHECK_SIZE_IMAGE(inImage, outImage); + PS_CHECK_ALLOC_IMAGE(outImage, inImage->numCols, inImage->numRows, inImage->type.type); + PS_CHECK_DIMEN_AND_TYPE(outImage, PS_DIMEN_IMAGE, outImage); + PS_CHECK_SIZE_IMAGE(outImage, outImage); + + // Initialize data + numRows = inImage->numRows; + numCols = inImage->numCols; + arraySize = PSELEMTYPE_SIZEOF(inImage->type.type) * numRows * numCols; + + // Initialize GSL data + PS_GSL_MATRIX_INITIALIZE(trans, outImage->data.V[0]); + + // Non-square matrices not allowed + PS_CHECK_SQUARE(inImage, outImage); + PS_CHECK_SQUARE(outImage, outImage); + + // Copy psImage input data into psImage output data to keep input data pristine + memcpy(outImage->data.V[0], inImage->data.V[0], arraySize); + + // Transpose data + gsl_matrix_transpose(&trans); + + return outImage; +} + +psImage* psMatrixEigenvectors(psImage* outImage, psImage* inImage) +{ + int numRows = 0; + int numCols = 0; + gsl_vector *eVals = NULL; + gsl_eigen_symmv_workspace *w = NULL; + gsl_matrix out; + gsl_matrix in; + + // Error checks + PS_CHECK_POINTERS(inImage, outImage, outImage); + PS_CHECK_NULL_IMAGE(inImage, outImage); + PS_CHECK_DIMEN_AND_TYPE(inImage, PS_DIMEN_IMAGE, outImage); + PS_CHECK_SIZE_IMAGE(inImage, outImage); + PS_CHECK_ALLOC_IMAGE(outImage, inImage->numCols, inImage->numRows, inImage->type.type); + PS_CHECK_DIMEN_AND_TYPE(outImage, PS_DIMEN_IMAGE, outImage); + PS_CHECK_SIZE_IMAGE(outImage, outImage); + + // Initialize data + numRows = inImage->numRows; + numCols = inImage->numCols; + + // Initialize GSL data + PS_GSL_MATRIX_INITIALIZE(in, inImage->data.V[0]); + PS_GSL_MATRIX_INITIALIZE(out, outImage->data.V[0]); + + // Allocate GSL structs + eVals = gsl_vector_alloc(numRows); + w = gsl_eigen_symmv_alloc(numRows); + + // Non-square matrices not allowed + PS_CHECK_SQUARE(inImage, outImage); + PS_CHECK_SQUARE(outImage, outImage); + + // Calculate Eigenvalues and Eigenvectors...Eigenvalues not currently used + gsl_eigen_symmv(&in, eVals, &out, w); + + // Free GSL structs + gsl_eigen_symmv_free(w); + gsl_vector_free(eVals); + + return outImage; +} + +psVector* psMatrixToVector(psVector* outVector, psImage* inImage) +{ + int size = 0; + + // Error checks + PS_CHECK_NULL_IMAGE(inImage, outVector); + PS_CHECK_DIMEN_AND_TYPE(inImage, PS_DIMEN_IMAGE, outVector); + PS_CHECK_SIZE_IMAGE(inImage, outVector); + + if (inImage->numRows == 1) { + // Create transposed row vector + PS_CHECK_ALLOC_VECTOR(outVector, inImage->numCols, inImage->type.type); + outVector->type.dimen = PS_DIMEN_TRANSV; + } else if (inImage->numCols == 1) { + // Create non-transposed column vector + PS_CHECK_ALLOC_VECTOR(outVector, inImage->numRows, inImage->type.type); + } else { + psError(__func__, "Image does not have dim with 1 col or 1 row: (%d x %d).", inImage->numRows, + inImage->numCols); + return outVector; + } + + PS_CHECK_NULL_VECTOR(outVector, outVector); + + // More checks + if (outVector->type.dimen == PS_DIMEN_VECTOR) { + PS_CHECK_DIMEN_AND_TYPE(outVector, PS_DIMEN_VECTOR, outVector); + + if (outVector->n == 0) { + outVector->n = inImage->numRows; + } + + if (outVector->n != inImage->numRows) { + psError(__func__, "Image and vector sizes differ: (%d vs %d).", inImage->numRows, outVector->n); + return outVector; + } + + size = PSELEMTYPE_SIZEOF(inImage->type.type) * inImage->numRows; + + } else if (outVector->type.dimen == PS_DIMEN_TRANSV) { + PS_CHECK_DIMEN_AND_TYPE(outVector, PS_DIMEN_TRANSV, outVector); + + if (outVector->n == 0) { + outVector->n = inImage->numCols; + } + + if (outVector->n != inImage->numCols) { + psError(__func__, "Image and vector sizes differ: (%d vs %d).", inImage->numCols, outVector->n); + return outVector; + } + + size = PSELEMTYPE_SIZEOF(inImage->type.type) * inImage->numCols; + } + + memcpy(outVector->data.V, inImage->data.V[0], size); + + return outVector; +} + +psImage* psVectorToMatrix(psImage* outImage, psVector* inVector) +{ + int size = 0; + + // Error checks + PS_CHECK_NULL_VECTOR(inVector, outImage); + + if (inVector->type.dimen == PS_DIMEN_VECTOR) { + PS_CHECK_DIMEN_AND_TYPE(inVector, PS_DIMEN_VECTOR, outImage); + PS_CHECK_SIZE_VECTOR(inVector, outImage); + PS_CHECK_ALLOC_IMAGE(outImage, 1, inVector->n, PS_TYPE_F64) + // More checks for PS_DIMEN_VECTOR + if (outImage->numCols > 1) { + psError(__func__, "Image has more than 1 column: numCols = %d.", outImage->numCols); + return outImage; + } else if (outImage->numRows != inVector->n) { + psError(__func__, "Image and vector sizes differ: (%d vs %d).", outImage->numRows, inVector->n); + return outImage; + } + + size = PSELEMTYPE_SIZEOF(outImage->type.type) * outImage->numRows; + + } else if (inVector->type.dimen == PS_DIMEN_TRANSV) { + PS_CHECK_DIMEN_AND_TYPE(inVector, PS_DIMEN_TRANSV, outImage); + PS_CHECK_SIZE_VECTOR(inVector, outImage); + PS_CHECK_ALLOC_IMAGE(outImage, inVector->n, 1, PS_TYPE_F64) + // More checks for PS_DIMEN_TRANSV + if (outImage->numRows > 1) { + psError(__func__, "Image has more than 1 row: numRows = %d.", outImage->numRows); + return outImage; + } else if (outImage->numCols != inVector->n) { + psError(__func__, "Image and vector sizes differ: (%d vs %d).", outImage->numCols, inVector->n); + return outImage; + } + + size = PSELEMTYPE_SIZEOF(outImage->type.type) * outImage->numCols; + } + + PS_CHECK_NULL_IMAGE(outImage, outImage); + PS_CHECK_DIMEN_AND_TYPE(outImage, PS_DIMEN_IMAGE, outImage); + + memcpy(outImage->data.V[0], inVector->data.V, size); + + return outImage; +} Index: /tags/rel2_1/psLib/src/dataManip/psMatrix.h =================================================================== --- /tags/rel2_1/psLib/src/dataManip/psMatrix.h (revision 1553) +++ /tags/rel2_1/psLib/src/dataManip/psMatrix.h (revision 1553) @@ -0,0 +1,166 @@ + +/** @file psMatrix.h + * + * @brief Provides functions for linear algebra operations on psImages and psVectors. + * + * Functions are provided to: + * Transpose a psImage + * Compute LUD + * Solve LUD + * Matrix inversion + * Calculate determinant + * Matrix multiplication + * Calculate Eigenvectors + * Convert matrix to vector + * Convert vector to matrix + * + * These functions treat psImages as if they were matrices, therefore there is no psMatrix. These functions + * operate only with the psF64 data type. + * + * @ingroup Matrix + * + * @author Ross Harman, MHPCC + * + * @version $Revision: 1.11 $ $Name: not supported by cvs2svn $ + * @date $Date: 2004-08-11 02:35:58 $ + * + * Copyright 2004 Maui High Performance Computing Center, University of Hawaii + */ + +#ifndef PSMATRIX_H +#define PSMATRIX_H + +/// @addtogroup Matrix +/// @{ + +/** LU Decomposition of psImage matrix. + * + * Performs a LU decomposition on a psImage matrix and returns the LU matrix. If the user specifies NULL for + * the outImage or outPerm arguments, then they will be automatically created. The input image must + * be square. This function operates only with the psF64 data type. Input and output arguments should not be + * the same. GSL indexes the top row as the zero row, not the bottom. + * + * @return psImage* : Pointer to LU decomposed psImage. + */ +psImage* psMatrixLUD( + psImage* outImage, ///< Image to return, or NULL. + psVector* outPerm, ///< Output permutation vector used by psMatrixLUSolve. + psImage* inImage ///< Image to decompose. +); + +/** LU Solution of psImage matrix. + * + * Solves for and returns the psVector, {x} in the equation [A]{x} = {b}. If the user specifies NULL as the + * outVector argument, then it will automatically be created. The input image must be square. This function + * operates only with the psF64 data type. Input and output arguments should not be the same. GSL indexes + * the top row as the zero row, not the bottom. + * + * @return psVector* : Pointer to psVector solution of matrix equation. + */ +psVector* psMatrixLUSolve( + psVector* outVector, ///< Vector to return, or NULL. + const psImage* luImage, ///< LU-decomposed matrix. + const psVector* inVector, ///< Vector right-hand-side of equation. + const psVector* inPerm ///< Permutation vector resulting from psMatrixLUD function. +); + +/** Invert psImage matrix. + * + * Inverts a psImage matrix and returns the determinant as an option through the argument list. If the user + * specifies NULL as the outImage argument, then it will automatically be created. The input image must be + * square. This function operates only with the psF64 data type. Input and output arguments should not be + * the same. GSL indexes the top row as the zero row, not the bottom. + * + * @return psImage* : Pointer to inverted psImage. + */ +psImage* psMatrixInvert( + psImage* outImage, ///< Image to return, or NULL for in-place substitution. + const psImage* inImage, ///< Image to be inverted + float *restrict det ///< Determinant to return, or NULL +); + +/** Calculate psImage matrix determinant. + * + * Calculates the determinant of a psImage matrix and returns the single precision floating point result. The + * input image must be square. This function operates only with the psF64 data type. GSL indexes the top row + * as the zero row, not the bottom. + * + * @return float: Determinant from psImage. + */ +float *psMatrixDeterminant( + const psImage* restrict inMatrix ///< Image used to calculate determinant. +); + +/** Performs psImage matrix multiplication. + * + * Performs a classical matrix multiplication involving row and column operations. Input images must be square + * and the same size. If the user specifies NULL as the outImage argument, then it will automatically be + * created. This function operates only with the psF64 data type. GSL indexes the top row as the + * zero row, not the bottom. + * + * @return psImage* : Pointer to resulting psImage. + */ +psImage* psMatrixMultiply( + psImage* outImage, ///< Matrix to return, or NULL. + psImage* inImage1, ///< First input image. + psImage* inImage2 ///< Second input image. +); + +/** Transpose matrix. + * + * Performs psImage matrix transpose by substituting existing rows for columns. The input image must be + * square. If the user specifies NULL as the outImage argument, then it will automaticallty be created. + * This function operates only with the psF64 data type. GSL indexes the top row as the zero + * row, not the bottom. + * + * @return psImage* : Pointer to transposed psImage. + */ +psImage* psMatrixTranspose( + psImage* outImage, ///< Image to return, or NULL + const psImage* inImage ///< Image to transpose +); + +/** Calculate matrix eigenvectors. + * + * Calculates the eigenvectors for a matrix. The input image must be symmetric and square. If the user + * specifies NULL as the outImage argument, then it will automatically be created. This function operates + * only with the psF64 data type. GSL indexes the top row as the zero row, not the bottom. + * + * @return psImage* : Pointer to matrix of Eigenvectors. + */ +psImage* psMatrixEigenvectors( + psImage* outImage, ///< Eigenvectors to return, or NULL. + psImage* inImage ///< Input image. +); + +/** Convert matrix to vector. + * + * Converts a 1-d psImage matrix into a vector. If the user specifies NULL as the outVector argument, then it + * will automatically be created based on the input image (PS_DIMEN_VECTOR for an input image with 1 col or + * PS_DIMENT_TRANSV for an input image with 1 row). Either the number of rows or the number of colums of the + * input matrix must be 1. This function operates only with the psF64 data type. + * + * @return psVector* : Pointer to psVector. + */ +psVector* psMatrixToVector( + psVector* outVector, ///< Vector to return, or NULL. + psImage* inImage ///< Image to convert. +); + +/** Convert vector to matrix. + * + * Converts a vector into a psImage matrix. If the dimensionality of the vector is PS_DIMEN_VECTOR, then the + * resulting psImage is a 1d column. If the dimensionality of the vector is PS_DIMEN_TRANSV, then the + * resulting psImage is a 1d row. If the user specifies NULL as the outImage argument, then it will + * automatically be created. This function operates only with the psF64 data type. + * + * @return psVector* : Pointer to psIamge. + */ +psImage* psVectorToMatrix( + psImage* outImage, ///< Matrix to return, or NULL. + psVector* inVector ///< Vector to convert. +); + +/// @} + +#endif Index: /tags/rel2_1/psLib/src/dataManip/psMatrixVectorArithmetic.c =================================================================== --- /tags/rel2_1/psLib/src/dataManip/psMatrixVectorArithmetic.c (revision 1553) +++ /tags/rel2_1/psLib/src/dataManip/psMatrixVectorArithmetic.c (revision 1553) @@ -0,0 +1,794 @@ + +/** @file psMatrixVectorArithmetic.c + * + * @brief Provides unary and binary functions for simple matrix and vector element operations. Functions + * include: + * + * Addition (+) + * Subtraction (-) + * Multiplication (*) + * Division (/) + * Power (^) + * Minimum (min) + * Maximum (max) + * Absolute value (abs) + * Exponent (exp) + * Natural Log (ln) + * Power of 10 (ten) + * Log (log) + * Sine (sin or dsin) + * Cosine (cos or dcos) + * Tangent (tan or dtan) + * Arcsine (asin or dasin) + * Arccosine (acos or dacos) + * Arctan (atan or datan) + * + * Currently only vector-vector and image-image binary operations are supported. + * + * @ingroup MatrixVectorArithmetic + * + * @author Ross Harman, MHPCC + * + * @version $Revision: 1.25 $ $Name: not supported by cvs2svn $ + * @date $Date: 2004-08-14 01:31:43 $ + * + * Copyright 2004 Maui High Performance Computing Center, University of Hawaii + */ + +/******************************************************************************/ + +/* INCLUDE FILES */ + +/******************************************************************************/ +#include +#include +#include + +#include "psMemory.h" +#include "psError.h" +#include "psImage.h" +#include "psVector.h" +#include "psScalar.h" + +/******************************************************************************/ + +/* DEFINE STATEMENTS */ + +/******************************************************************************/ + +// None + +/******************************************************************************/ + +/* TYPE DEFINITIONS */ + +/******************************************************************************/ + +// None + +/*****************************************************************************/ + +/* GLOBAL VARIABLES */ + +/*****************************************************************************/ + +// None + +/*****************************************************************************/ + +/* FILE STATIC VARIABLES */ + +/*****************************************************************************/ + +// None + +/*****************************************************************************/ + +/* FUNCTION IMPLEMENTATION - LOCAL */ + +/*****************************************************************************/ + +// Conversion for degrees to radians +#define D2R 0.01745329252111111 /* PI/180 */ + +// Conversion for radians to degrees +#define R2D 57.29577950924861 /* 180.0/PI */ + +// Division with NAN checking +static complex double psNanDiv(complex double a, complex double b) +{ + complex double out = 0 + 0i; + + out = a / b; + if (isnan(creal(out)) || isnan(cimag(out))) { + psError(__func__, ": Divide by zero"); + } + + return out; +} + +// Binary SCALAR_XXXX operations +#define SCALAR_SCALAR(OUT,IN1,OP,IN2,TYPE) \ +{ \ + ps##TYPE *o = NULL; \ + ps##TYPE *i1 = NULL; \ + ps##TYPE *i2 = NULL; \ + o = &((psScalar* )OUT)->data.TYPE; \ + i1 = &((psScalar* )IN1)->data.TYPE; \ + i2 = &((psScalar* )IN2)->data.TYPE; \ + *o = OP; \ +} + +#define SCALAR_VECTOR(OUT,IN1,OP,IN2,TYPE) \ +{ \ + int i = 0; \ + int npt = 0; \ + ps##TYPE *o = NULL; \ + ps##TYPE *i1 = NULL; \ + ps##TYPE *i2 = NULL; \ + npt = ((psVector* )IN1)->n; \ + o = ((psVector* )OUT)->data.TYPE; \ + i1 = &((psScalar* )IN1)->data.TYPE; \ + i2 = ((psVector* )IN2)->data.TYPE; \ + for (i=0; i < npt; i++, o++, i2++) { \ + *o = OP; \ + } \ +} + +#define SCALAR_IMAGE(OUT,IN1,OP,IN2,TYPE) \ +{ \ + int i = 0; \ + int j = 0; \ + int numRows = 0; \ + int numCols = 0; \ + ps##TYPE *o = NULL; \ + ps##TYPE *i1 = NULL; \ + ps##TYPE *i2 = NULL; \ + numRows = ((psImage* )IN1)->numRows; \ + numCols = ((psImage* )IN1)->numCols; \ + for(j = 0; j < numCols; j++) { \ + o = ((psImage* )OUT)->data.TYPE[j]; \ + i1 = &((psScalar* )IN1)->data.TYPE; \ + i2 = ((psImage* )IN2)->data.TYPE[j]; \ + for(i = 0; i < numRows; i++, o++, i2++) { \ + *o = OP; \ + } \ + } \ +} + +// Binary VECTOR_XXXX operations +#define VECTOR_SCALAR(OUT,IN1,OP,IN2,TYPE) \ +{ \ + int i = 0; \ + int n1 = 0; \ + ps##TYPE *o = NULL; \ + ps##TYPE *i1 = NULL; \ + ps##TYPE *i2 = NULL; \ + n1 = ((psVector* )IN1)->n; \ + o = ((psVector* )OUT)->data.TYPE; \ + i1 = ((psVector* )IN1)->data.TYPE; \ + i2 = &((psScalar* )IN2)->data.TYPE; \ + for (i=0; i < n1; i++, o++, i1++) { \ + *o = OP; \ + } \ +} + +#define VECTOR_VECTOR(OUT,IN1,OP,IN2,TYPE) \ +{ \ + int i = 0; \ + int n1 = 0; \ + int n2 = 0; \ + ps##TYPE *o = NULL; \ + ps##TYPE *i1 = NULL; \ + ps##TYPE *i2 = NULL; \ + n1 = ((psVector* )IN1)->n; \ + n2 = ((psVector* )IN2)->n; \ + if(n1 != n2) { \ + psError(__func__, ": Inconsistent element count: %d vs %d", n1, n2); \ + return OUT; \ + } \ + o = ((psVector* )OUT)->data.TYPE; \ + i1 = ((psVector* )IN1)->data.TYPE; \ + i2 = ((psVector* )IN2)->data.TYPE; \ + for (i=0; i < n1; i++, o++, i1++, i2++) { \ + *o = OP; \ + } \ +} + +#define VECTOR_IMAGE(OUT,IN1,OP,IN2,TYPE) \ +{ \ + int i = 0; \ + int j = 0; \ + int n1 = 0; \ + int numRows2 = 0; \ + int numCols2 = 0; \ + psDimen dim1 = 0; \ + ps##TYPE *o = NULL; \ + ps##TYPE *i1 = NULL; \ + ps##TYPE *i2 = NULL; \ + n1 = ((psVector* )IN1)->n; \ + dim1 = ((psVector* )IN1)->type.dimen; \ + numRows2 = ((psImage* )IN2)->numRows; \ + numCols2 = ((psImage* )IN2)->numCols; \ + \ + if(dim1 == PS_DIMEN_VECTOR) { /* Regular vectors */ \ + if(n1!=numRows2) { \ + psError(__func__, ": Inconsistent element count: %d vs %d", n1, numRows2); \ + return OUT; \ + } \ + \ + i1 = ((psVector* )IN1)->data.TYPE; \ + for(j = 0; j < numRows2; j++, i1++) { \ + o = ((psImage* )OUT)->data.TYPE[j]; \ + i2 = ((psImage* )IN2)->data.TYPE[j]; \ + for(i = 0; i < numCols2; i++, o++, i2++) { \ + *o = OP; \ + } \ + } \ + } else { /* Transposed vectors */ \ + if(n1!=numCols2) { \ + psError(__func__, ": Inconsistent element count: %d vs %d", n1, numCols2); \ + return OUT; \ + } \ + \ + for(j = 0; j < numRows2; j++) { \ + o = ((psImage* )OUT)->data.TYPE[j]; \ + i1 = ((psVector* )IN1)->data.TYPE; \ + i2 = ((psImage* )IN2)->data.TYPE[j]; \ + for(i = 0; i < numCols2; i++, o++, i1++, i2++) { \ + *o = OP; \ + } \ + } \ + } \ +} + +// Binary IMAGE_XXXX operations +#define IMAGE_SCALAR(OUT,IN1,OP,IN2,TYPE) \ +{ \ + int i = 0; \ + int j = 0; \ + int numRows = 0; \ + int numCols = 0; \ + ps##TYPE *o = NULL; \ + ps##TYPE *i1 = NULL; \ + ps##TYPE *i2 = NULL; \ + numRows = ((psImage* )IN1)->numRows; \ + numCols = ((psImage* )IN1)->numCols; \ + for(j = 0; j < numRows; j++) { \ + o = ((psImage* )OUT)->data.TYPE[j]; \ + i1 = ((psImage* )IN1)->data.TYPE[j]; \ + i2 = &((psScalar* )IN2)->data.TYPE; \ + for(i = 0; i < numCols; i++, o++, i1++) { \ + *o = OP; \ + } \ + } \ +} + +#define IMAGE_VECTOR(OUT,IN1,OP,IN2,TYPE) \ +{ \ + int i = 0; \ + int j = 0; \ + int n2 = 0; \ + int numRows1 = 0; \ + int numCols1 = 0; \ + psDimen dim2 = 0; \ + ps##TYPE *o = NULL; \ + ps##TYPE *i1 = NULL; \ + ps##TYPE *i2 = NULL; \ + n2 = ((psVector* )IN2)->n; \ + dim2 = ((psVector* )IN2)->type.dimen; \ + numRows1 = ((psImage* )IN1)->numRows; \ + numCols1 = ((psImage* )IN1)->numCols; \ + \ + if(dim2 == PS_DIMEN_VECTOR) { /* Regular vectors */ \ + if(n2!=numRows1) { \ + psError(__func__, ": Inconsistent element count: %d vs %d", n2, numRows1); \ + return OUT; \ + } \ + \ + i2 = ((psVector* )IN2)->data.TYPE; \ + for(j = 0; j < numRows1; j++, i1++) { \ + o = ((psImage* )OUT)->data.TYPE[j]; \ + i1 = ((psImage* )IN1)->data.TYPE[j]; \ + for(i = 0; i < numCols1; i++, o++, i1++) { \ + *o = OP; \ + } \ + } \ + } else { /* Transposed vectors */ \ + if(n2!=numCols1) { \ + psError(__func__, ": Inconsistent element count: %d vs %d", n2, numCols1); \ + return OUT; \ + } \ + \ + for(j = 0; j < numRows1; j++) { \ + o = ((psImage* )OUT)->data.TYPE[j]; \ + i1 = ((psVector* )IN2)->data.TYPE; \ + i2 = ((psImage* )IN1)->data.TYPE[j]; \ + for(i = 0; i < numCols1; i++, o++, i2++, i1++) { \ + *o = OP; \ + } \ + } \ + } \ +} + +#define IMAGE_IMAGE(OUT,IN1,OP,IN2,TYPE) \ +{ \ + int i = 0; \ + int j = 0; \ + int numRows1 = 0; \ + int numCols1 = 0; \ + int numRows2 = 0; \ + int numCols2 = 0; \ + ps##TYPE *o = NULL; \ + ps##TYPE *i1 = NULL; \ + ps##TYPE *i2 = NULL; \ + numRows1 = ((psImage* )IN1)->numRows; \ + numCols1 = ((psImage* )IN1)->numCols; \ + numRows2 = ((psImage* )IN2)->numRows; \ + numCols2 = ((psImage* )IN2)->numCols; \ + if(numRows1!=numRows2 || numCols1!=numCols2) { \ + psError(__func__, ": Inconsistent element count: numRows: %d vs %d numCols: %d vs %d", numRows1, \ + numRows2, numCols1, numCols2); \ + return OUT; \ + } \ + for(j = 0; j < numRows1; j++) { \ + o = ((psImage* )OUT)->data.TYPE[j]; \ + i1 = ((psImage* )IN1)->data.TYPE[j]; \ + i2 = ((psImage* )IN2)->data.TYPE[j]; \ + for(i = 0; i < numCols1; i++, o++, i1++, i2++) { \ + *o = OP; \ + } \ + } \ +} + +// Preprocessor macro function to create arithmetic function based on input type +#define BINARY_TYPE(DIM1,DIM2,OUT,IN1,OP,IN2) \ +switch (IN1->type) { \ +case PS_TYPE_S32: \ + DIM1##_##DIM2(OUT,IN1,OP,IN2,S32); \ + break; \ +case PS_TYPE_F32: \ + DIM1##_##DIM2(OUT,IN1,OP,IN2,F32); \ + break; \ +case PS_TYPE_F64: \ + DIM1##_##DIM2(OUT,IN1,OP,IN2,F64); \ + break; \ +case PS_TYPE_C32: \ + DIM1##_##DIM2(OUT,IN1,OP,IN2,C32); \ + break; \ +default: \ +case PS_TYPE_S8: \ +case PS_TYPE_U8: \ +case PS_TYPE_S16: \ +case PS_TYPE_U16: \ +case PS_TYPE_U32: \ +case PS_TYPE_S64: \ +case PS_TYPE_U64: \ +case PS_TYPE_C64: \ + psError(__func__, ": Invalid PS_TYPE: %d", IN1->type); \ +} + +// Preprocessor macro function to create arithmetic function operation name +#define BINARY_OP(DIM1,DIM2,OUT,IN1,OP,IN2) \ +if(!strncmp(OP, "+", 1)) { \ + BINARY_TYPE(DIM1,DIM2,OUT,IN1,*i1 + *i2,IN2); \ +} else if(!strncmp(OP, "-", 1)) { \ + BINARY_TYPE(DIM1,DIM2,OUT,IN1,*i1 - *i2,IN2); \ +} else if(!strncmp(OP, "*", 1)) { \ + BINARY_TYPE(DIM1,DIM2,OUT,IN1,*i1 * *i2,IN2); \ +} else if(!strncmp(OP, "/", 1)) { \ + BINARY_TYPE(DIM1,DIM2,OUT,IN1,psNanDiv(*i1,*i2),IN2); \ +} else if(!strncmp(OP, "^", 1)) { \ + if(PS_IS_PSELEMTYPE_COMPLEX(IN1->type)) { \ + BINARY_TYPE(DIM1,DIM2,OUT,IN1,cpow(*i1,*i2),IN2); \ + } else { \ + BINARY_TYPE(DIM1,DIM2,OUT,IN1,pow(*i1,*i2),IN2); \ + } \ +} else if(!strncmp(OP, "min", 3)) { \ + if(PS_IS_PSELEMTYPE_COMPLEX(IN1->type)) { \ + psError(__func__, ": Minimum operation not supported for complex numbers"); \ + } else { \ + BINARY_TYPE(DIM1,DIM2,OUT,IN1,fmin(*i1,*i2),IN2); \ + } \ +} else if(!strncmp(OP, "max", 3)) { \ + if(PS_IS_PSELEMTYPE_COMPLEX(IN1->type)) { \ + psError(__func__, ": Maximum operation not supported for complex numbers"); \ + } else { \ + BINARY_TYPE(DIM1,DIM2,OUT,IN1,fmax(*i1,*i2),IN2); \ + } \ +} else { \ + psError(__func__, ": Invalid operation: %s", OP); \ +} + +void *psBinaryOp(void *out, void *in1, char *op, void *in2) +{ + psDimen dim1 = 0; + psDimen dim2 = 0; + psDimen dimOut = 0; + psElemType elType1 = 0; + psElemType elType2 = 0; + psElemType elTypeOut = 0; + psType* psType1 = NULL; + psType* psType2 = NULL; + psType* psTypeOut = NULL; + + psTypeOut = (psType* ) out; + if (psTypeOut == NULL) { + psError(__func__, ": Line %d - Null out argument", __LINE__); + return out; + } + + psType1 = (psType* ) in1; + if (psType1 == NULL) { + psError(__func__, ": Line %d - Null in1 argument", __LINE__); + return out; + } + + psType2 = (psType* ) in2; + if (psType2 == NULL) { + psError(__func__, ": Line %d - Null in2 argument", __LINE__); + return out; + } + + if (op == NULL) { + psError(__func__, ": Line %d - Null op argument", __LINE__); + return out; + } + + dim1 = psType1->dimen; + dim2 = psType2->dimen; + dimOut = psTypeOut->dimen; + elType1 = psType1->type; + elType2 = psType2->type; + elTypeOut = psTypeOut->type; + + if (elType1 != elType2 && elType1 != elTypeOut) { + psError(__func__, ": Line %d - Element types for arguments inconsistent: (%d, %d, %d)", __LINE__, + elType1, elType2, elTypeOut); + return out; + } + + if (dim1 == PS_DIMEN_OTHER || dim2 == PS_DIMEN_OTHER || dimOut == PS_DIMEN_OTHER) { + psError(__func__, ": Line %d - PS_DIMEN_OTHER not allowed for arguments: (%d, %d, %d)", __LINE__, + dim1, dim2, dimOut); + return out; + } + + if (dim1 == PS_DIMEN_VECTOR) { + if (((psVector* ) in1)->n == 0) { + psError(__func__, ": Line %d - Vector contains zero elements"); + } + } else if (dim1 == PS_DIMEN_IMAGE) { + if (((psImage* ) in1)->numCols == 0 || ((psImage* ) in1)->numRows == 0) { + psError(__func__, ": Line %d - Image contains zero length row or cols"); + } + } + + if (dim2 == PS_DIMEN_VECTOR) { + if (((psVector* ) in2)->n == 0) { + psError(__func__, ": Line %d - Vector contains zero elements"); + } + } else if (dim2 == PS_DIMEN_IMAGE) { + if (((psImage* ) in2)->numCols == 0 || ((psImage* ) in2)->numRows == 0) { + psError(__func__, ": Line %d - Image contains zero length row or cols"); + } + } + + if (dim1 == PS_DIMEN_SCALAR) { + if (dim2 == PS_DIMEN_SCALAR) { + BINARY_OP(SCALAR, SCALAR, out, psType1, op, psType2); // scalar op scalar + } else if (dim2 == PS_DIMEN_VECTOR || dim2 == PS_DIMEN_TRANSV) { + BINARY_OP(SCALAR, VECTOR, out, psType1, op, psType2); // scalar op vector + } else if (dim2 == PS_DIMEN_IMAGE) { + BINARY_OP(SCALAR, IMAGE, out, psType1, op, psType2); // scalar op image + } else { + psError(__func__, ": Line %d - Invalid dimensionality for in2 arg: %d", __LINE__, dim2); + } + } else if (dim1 == PS_DIMEN_VECTOR || dim1 == PS_DIMEN_TRANSV) { + if (dim2 == PS_DIMEN_SCALAR) { + BINARY_OP(VECTOR, SCALAR, out, psType1, op, psType2); // vector op scalar + } else if (dim2 == PS_DIMEN_VECTOR || dim2 == PS_DIMEN_TRANSV) { + BINARY_OP(VECTOR, VECTOR, out, psType1, op, psType2); // vector op vector + } else if (dim2 == PS_DIMEN_IMAGE) { + BINARY_OP(VECTOR, IMAGE, out, psType1, op, psType2); // vector op image + } else { + psError(__func__, ": Line %d - Invalid dimensionality for in2 arg: %d", __LINE__, dim2); + } + } else if (dim1 == PS_DIMEN_IMAGE) { + if (dim2 == PS_DIMEN_SCALAR) { + BINARY_OP(IMAGE, SCALAR, out, psType1, op, psType2); // image op scalar + } else if (dim2 == PS_DIMEN_VECTOR || dim2 == PS_DIMEN_TRANSV) { + BINARY_OP(IMAGE, VECTOR, out, psType1, op, psType2); // image op vector + } else if (dim2 == PS_DIMEN_IMAGE) { + BINARY_OP(IMAGE, IMAGE, out, psType1, op, psType2); // image op image + } else { + psError(__func__, ": Line %d - Invalid dimensionality for in2 arg: %d", __LINE__, dim2); + } + } else { + psError(__func__, ": Line %d - Invalid dimensionality for in1 arg: %d", __LINE__, dim1); + } + + return out; +} + +// Unary SCALAR operations +#define SCALAR(OUT,IN,OP,TYPE) \ +{ \ + ps##TYPE *o = NULL; \ + ps##TYPE *i1 = NULL; \ + o = &((psScalar* )OUT)->data.TYPE; \ + i1 = &((psScalar* )IN)->data.TYPE; \ + *o = OP; \ +} + +// Unary IMAGE operations +#define VECTOR(OUT,IN,OP,TYPE) \ +{ \ + int i = 0; \ + int nIn = 0; \ + int nOut = 0; \ + ps##TYPE *o = NULL; \ + ps##TYPE *i1 = NULL; \ + nIn = ((psVector* )IN)->n; \ + nOut = ((psVector* )OUT)->n; \ + if(nIn != nOut) { \ + psError(__func__, ": Inconsistent element count: %d vs %d", nIn, nOut); \ + return OUT; \ + } \ + o = ((psVector* )OUT)->data.TYPE; \ + i1 = ((psVector* )IN)->data.TYPE; \ + for(i = 0; i < nIn; i++, o++, i1++) { \ + *o = OP; \ + } \ +} + +// Unary IMAGE operations +#define IMAGE(OUT,IN,OP,TYPE) \ +{ \ + int i = 0; \ + int j = 0; \ + int numRowsIn = 0; \ + int numColsIn = 0; \ + int numRowsOut = 0; \ + int numColsOut = 0; \ + ps##TYPE *o = NULL; \ + ps##TYPE *i1 = NULL; \ + numRowsIn = ((psImage* )IN)->numRows; \ + numColsIn = ((psImage* )IN)->numCols; \ + numRowsOut = ((psImage* )OUT)->numRows; \ + numColsOut = ((psImage* )OUT)->numCols; \ + if(numRowsIn!=numRowsOut || numColsIn!=numColsOut) { \ + psError(__func__, ": Inconsistent element count: numRows: %d vs %d numCols: %d vs %d", numRowsIn, \ + numRowsOut, numColsIn, numColsOut); \ + return OUT; \ + } \ + for(j = 0; j < numRowsIn; j++) { \ + o = ((psImage* )OUT)->data.TYPE[j]; \ + i1 = ((psImage* )IN)->data.TYPE[j]; \ + for(i = 0; i < numColsIn; i++, o++, i1++) { \ + *o = OP; \ + } \ + } \ +} + +// Preprocessor macro function to create arithmetic function based on input type +#define UNARY_TYPE(DIM,OUT,IN,OP) \ +switch (IN->type) { \ +case PS_TYPE_S32: \ + DIM(OUT,IN,OP,S32); \ + break; \ +case PS_TYPE_F32: \ + DIM(OUT,IN,OP,F32); \ + break; \ +case PS_TYPE_F64: \ + DIM(OUT,IN,OP,F64); \ + break; \ +case PS_TYPE_C32: \ + DIM(OUT,IN,OP,C32); \ + break; \ +default: \ +case PS_TYPE_S8: \ +case PS_TYPE_U8: \ +case PS_TYPE_S16: \ +case PS_TYPE_U16: \ +case PS_TYPE_U32: \ +case PS_TYPE_S64: \ +case PS_TYPE_U64: \ +case PS_TYPE_C64: \ + psError(__func__, ": Invalid PS_TYPE: %d", IN->type); \ +} + +// Preprocessor macro function to create arithmetic function operation name. Functions below that add +// FLT_EPSILON are done so to align results with a 64 bit computing architecture +#define UNARY_OP(DIM,OUT,IN,OP) \ +if(!strncmp(OP, "abs", 3)) { \ + if(PS_IS_PSELEMTYPE_COMPLEX(IN->type)) { \ + UNARY_TYPE(DIM,OUT,IN,cabs(*i1)); \ + } else { \ + UNARY_TYPE(DIM,OUT,IN,fabs(*i1)); \ + } \ +} else if(!strncmp(OP, "exp", 3)) { \ + if(PS_IS_PSELEMTYPE_COMPLEX(IN->type)) { \ + UNARY_TYPE(DIM,OUT,IN,cexp(*i1)); \ + } else { \ + UNARY_TYPE(DIM,OUT,IN,exp(*i1)); \ + } \ +} else if(!strncmp(OP, "ln", 2)) { \ + if(PS_IS_PSELEMTYPE_COMPLEX(IN->type)) { \ + UNARY_TYPE(DIM,OUT,IN,clog(*i1)); \ + } else { \ + UNARY_TYPE(DIM,OUT,IN,log(*i1)); \ + } \ +} else if(!strncmp(OP, "ten", 3)) { \ + if(PS_IS_PSELEMTYPE_COMPLEX(IN->type)) { \ + UNARY_TYPE(DIM,OUT,IN,cpow(10.0,*i1)); \ + } else { \ + UNARY_TYPE(DIM,OUT,IN,pow(10.0,*i1)); \ + } \ +} else if(!strncmp(OP, "log", 3)) { \ + if(PS_IS_PSELEMTYPE_COMPLEX(IN->type)) { \ + UNARY_TYPE(DIM,OUT,IN,clog(*i1)/log(10.0)); \ + } else { \ + UNARY_TYPE(DIM,OUT,IN,log10(*i1)); \ + } \ +} else if(!strncmp(OP, "sin", 3)) { \ + if(PS_IS_PSELEMTYPE_COMPLEX(IN->type)) { \ + UNARY_TYPE(DIM,OUT,IN,csin(*i1)); \ + } else { \ + UNARY_TYPE(DIM,OUT,IN,sin(*i1)); \ + } \ +} else if(!strncmp(OP, "dsin", 4)) { \ + if(PS_IS_PSELEMTYPE_COMPLEX(IN->type)) { \ + UNARY_TYPE(DIM,OUT,IN,csin(*i1*D2R)); \ + } else { \ + UNARY_TYPE(DIM,OUT,IN,sin(*i1*D2R)); \ + } \ +} else if(!strncmp(OP, "cos", 3)) { \ + if(PS_IS_PSELEMTYPE_COMPLEX(IN->type)) { \ + UNARY_TYPE(DIM,OUT,IN,ccos(*i1)); \ + } else { \ + UNARY_TYPE(DIM,OUT,IN,cos(*i1)); \ + } \ +} else if(!strncmp(OP, "dcos", 4)) { \ + if(PS_IS_PSELEMTYPE_COMPLEX(IN->type)) { \ + UNARY_TYPE(DIM,OUT,IN,ccos(*i1*D2R)); \ + } else { \ + UNARY_TYPE(DIM,OUT,IN,cos(*i1*D2R)); \ + } \ +} else if(!strncmp(OP, "tan", 3)) { \ + if(PS_IS_PSELEMTYPE_COMPLEX(IN->type)) { \ + UNARY_TYPE(DIM,OUT,IN,ctan(*i1)); \ + } else { \ + UNARY_TYPE(DIM,OUT,IN,tan(*i1)); \ + } \ +} else if(!strncmp(OP, "dtan", 4)) { \ + if(PS_IS_PSELEMTYPE_COMPLEX(IN->type)) { \ + UNARY_TYPE(DIM,OUT,IN,ctan(*i1*D2R)); \ + } else { \ + UNARY_TYPE(DIM,OUT,IN,tan(*i1*D2R)); \ + } \ +} else if(!strncmp(OP, "asin", 4)) { \ + if(PS_IS_PSELEMTYPE_COMPLEX(IN->type)) { \ + UNARY_TYPE(DIM,OUT,IN,casin(*i1)); \ + } else { \ + UNARY_TYPE(DIM,OUT,IN,asin(*i1)); \ + } \ +} else if(!strncmp(OP, "dasin", 5)) { \ + if(PS_IS_PSELEMTYPE_COMPLEX(IN->type)) { \ + UNARY_TYPE(DIM,OUT,IN,R2D*casin(*i1)); \ + } else if(PS_IS_PSELEMTYPE_INT(IN->type)) { \ + UNARY_TYPE(DIM,OUT,IN,(R2D*asin(*i1))); \ + } else { \ + UNARY_TYPE(DIM,OUT,IN,(R2D*asin(*i1))); \ + } \ +} else if(!strncmp(OP, "acos", 4)) { \ + if(PS_IS_PSELEMTYPE_COMPLEX(IN->type)) { \ + UNARY_TYPE(DIM,OUT,IN,cacos(*i1)); \ + } else { \ + UNARY_TYPE(DIM,OUT,IN,acos(*i1)); \ + } \ +} else if(!strncmp(OP, "dacos", 5)) { \ + if(PS_IS_PSELEMTYPE_COMPLEX(IN->type)) { \ + UNARY_TYPE(DIM,OUT,IN,R2D*cacos(*i1)); \ + } else if(PS_IS_PSELEMTYPE_INT(IN->type)) { \ + UNARY_TYPE(DIM,OUT,IN,(R2D*acos(*i1))); \ + } else { \ + UNARY_TYPE(DIM,OUT,IN,R2D*acos(*i1)); \ + } \ +} else if(!strncmp(OP, "atan", 4)) { \ + if(PS_IS_PSELEMTYPE_COMPLEX(IN->type)) { \ + UNARY_TYPE(DIM,OUT,IN,catan(*i1)); \ + } else { \ + UNARY_TYPE(DIM,OUT,IN,atan(*i1)); \ + } \ +} else if(!strncmp(OP, "datan", 5)) { \ + if(PS_IS_PSELEMTYPE_COMPLEX(IN->type)) { \ + UNARY_TYPE(DIM,OUT,IN,R2D*catan(*i1)); \ + } else { \ + UNARY_TYPE(DIM,OUT,IN,R2D*atan(*i1)); \ + } \ +} else { \ + psError(__func__, ": Invalid operation: %s", OP); \ +} + +void *psUnaryOp(void *out, void *in, char *op) +{ + psDimen dimIn = 0; + psDimen dimOut = 0; + psElemType elTypeIn = 0; + psElemType elTypeOut = 0; + psType* psTypeIn = NULL; + psType* psTypeOut = NULL; + + psTypeOut = (psType* ) out; + if (psTypeOut == NULL) { + psError(__func__, ": Line %d - Null out argument", __LINE__); + return out; + } + + psTypeIn = (psType* ) in; + if (psTypeIn == NULL) { + psError(__func__, ": Line %d - Null in argument", __LINE__); + return out; + } + + if (op == NULL) { + psError(__func__, ": Line %d - Null op argument", __LINE__); + return out; + } + + dimIn = psTypeIn->dimen; + dimOut = psTypeOut->dimen; + elTypeIn = psTypeIn->type; + elTypeOut = psTypeOut->type; + + if (elTypeIn != elTypeOut) { + psError(__func__, ": Line %d - Element types for arguments inconsistent: (%d, %d)", __LINE__, + elTypeIn, elTypeOut); + return out; + } + + if (dimIn != dimOut) { + psError(__func__, ": Line %d - Dimensionality for arguments inconsistent: (%d, %d)", __LINE__, + dimIn, dimOut); + return out; + } + + if (dimIn == PS_DIMEN_OTHER || dimOut == PS_DIMEN_OTHER) { + psError(__func__, ": Line %d - PS_DIMEN_OTHER not allowed for arguments: (%d, %d)", __LINE__, + dimIn, dimOut); + return out; + } + + if (dimIn == PS_DIMEN_VECTOR) { + if (((psVector* ) in)->n == 0) { + psError(__func__, ": Line %d - Vector contains zero elements"); + } + } else if (dimIn == PS_DIMEN_IMAGE) { + if (((psImage* ) in)->numCols == 0 || ((psImage* ) in)->numRows == 0) { + psError(__func__, ": Line %d - Image contains zero length row or cols"); + } + } + + if (dimOut == PS_DIMEN_VECTOR) { + if (((psVector* ) out)->n == 0) { + psError(__func__, ": Line %d - Vector contains zero elements"); + } + } else if (dimOut == PS_DIMEN_IMAGE) { + if (((psImage* ) out)->numCols == 0 || ((psImage* ) out)->numRows == 0) { + psError(__func__, ": Line %d - Image contains zero length row or cols"); + } + } + + if (dimIn == PS_DIMEN_SCALAR) { + UNARY_OP(SCALAR, out, psTypeIn, op); // scalar + } else if (dimIn == PS_DIMEN_VECTOR || dimIn == PS_DIMEN_TRANSV) { + UNARY_OP(VECTOR, out, psTypeIn, op); // vector + } else if (dimIn == PS_DIMEN_IMAGE) { + UNARY_OP(IMAGE, out, psTypeIn, op); // image + } else { + psError(__func__, ": Line %d - Invalid dimensionality for in arg: %d", __LINE__, dimIn); + } + + return out; +} Index: /tags/rel2_1/psLib/src/dataManip/psMatrixVectorArithmetic.h =================================================================== --- /tags/rel2_1/psLib/src/dataManip/psMatrixVectorArithmetic.h (revision 1553) +++ /tags/rel2_1/psLib/src/dataManip/psMatrixVectorArithmetic.h (revision 1553) @@ -0,0 +1,88 @@ + +/** @file psMatrixVectorArithmetic.h + * + * @brief Provides unary and binary functions for simple matrix and vector element operations. Functions + * include: + * + * Addition (+) + * Subtraction (-) + * Multiplication (*) + * Division (/) + * Power (^) + * Minimum (min) + * Maximum (max) + * Absolute value (abs) + * Exponent (exp) + * Natural Log (ln) + * Power of 10 (ten) + * Log (log) + * Sine (sin or dsin) + * Cosine (cos or dcos) + * Tangent (tan or dtan) + * Arcsine (asin or dasin) + * Arccosine (acos or dacos) + * Arctan (atan or datan) + * + * Currently only vector-vector and image-image binary operations are supported. + * + * @ingroup MatrixVectorArithmetic + * + * @author Ross Harman, MHPCC + * + * @version $Revision: 1.5 $ $Name: not supported by cvs2svn $ + * @date $Date: 2004-08-11 02:37:55 $ + * + * Copyright 2004 Maui High Performance Computing Center, University of Hawaii + */ + +#ifndef PSMATRIX_VECTOR_ARITHMETIC_H +#define PSMATRIX_VECTOR_ARITHMETIC_H + +/// @addtogroup MatrixVectorArithmetic +/// @{ + +/** Perform simple binary arithmetic with images or vectors + * + * Performs addition, subtraction, multiplication, division, power, minumum, and maximum arithmetic + * operations with images and vectors. Uses the form: + * + * out = in1 op in2, + * + * Where op is: "+", "-", "*", "/", "^", "min", or "max" + * + * This function only supports vector-vector or image-image opertions. + * + * @return psType* : Pointer to either psImage or psVector. + */ +psType* psBinaryOp( + void *out, ///< Output type, either psImage or psVector. + void *in1, ///< First input, either psImage or psVector. + char *op, ///< Operator. + void *in2 ///< Second input, either psImage or psVector. +); + +/** Perform simple unary arithmetic with images or vectors + * + * Performs absolute value, exponent, natural log, power of 10, log, sine, cosine, tangent, arcsine, + * arccosine, or arctan. operations with images and vectors. Uses the form: + * + * out = op(in), + * + * Where op is: "abs", "exp", "ln", "ten", "log", "sin", "cos", "tan" "asin", "acos", "atan", "dsin", + * "dcos", dtan", "dasin", "dacos", or "datan". + * + * Trigometric Operations with "d" prefix use units of degrees. Those without are in radians. + * + * This function only supports vector-vector or image-image opertions. + * + * @return psType* : Pointer to either psImage or psVector. + */ +psType* psUnaryOp( + void *out, ///< Output type, either psImage or psVector. + void *in, ///< Input, either psImage or psVector. + char *op ///< Operator. +); + +/// @} + +#endif Index: /tags/rel2_1/psLib/src/dataManip/psMinimize.c =================================================================== --- /tags/rel2_1/psLib/src/dataManip/psMinimize.c (revision 1553) +++ /tags/rel2_1/psLib/src/dataManip/psMinimize.c (revision 1553) @@ -0,0 +1,940 @@ + +/** @file psMinimize.c + * \brief basic minimization functions + * @ingroup Math + * + * This file will contain functions to minimize an arbitrary function at + * a data point, fit an arbitrary function to a set of data points, and + * fit a 1-D polynomial to a set of data points. + * + * @author George Gusciora, MHPCC + * + * @version $Revision: 1.30 $ $Name: not supported by cvs2svn $ + * @date $Date: 2004-08-11 03:17:03 $ + * + * Copyright 2004 Maui High Performance Computing Center, University of Hawaii + */ + +/*****************************************************************************/ + +/* INCLUDE FILES */ + +/*****************************************************************************/ +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include + +#include "psMemory.h" +#include "psVector.h" +#include "psImage.h" +#include "psTrace.h" +#include "psError.h" +#include "psAbort.h" +#include "psFunctions.h" +#include "psMinimize.h" +#include "psMatrix.h" + +/*****************************************************************************/ + +/* DEFINE STATEMENTS */ + +/*****************************************************************************/ +#define MAX_LMM_ITERATIONS 100 +#define MAX_MINIMIZE_ITERATIONS 100 + +/** Preprocessor macro to generate error on a NULL 1DPolynomial */ +#define PS_CHECK_NULL_1DPOLY(NAME) \ +if (NAME == NULL || NAME->coeff == NULL) { \ + psError(__func__,"Invalid operation: %s or its data is NULL.", #NAME); \ +} + +/** Preprocessor macro to generate error on a NULL vector */ +#define PS_CHECK_NULL_VECTOR(NAME) \ +if (NAME == NULL || NAME->data.V == NULL) { \ + psError(__func__,"Invalid operation: %s or its data is NULL.", #NAME); \ +} + +/** Preprocessor macro to generate error for zero length vector */ +#define PS_CHECK_EMPTY_VECTOR(NAME) \ +if (NAME->n < 1) { \ + psError(__func__,"Invalid operation: %s has zero n value.", #NAME); \ +} + +/** Preprocessor macro to generate error on differing size vectors */ +#define PS_CHECK_VECTOR_SIZE_EQUAL(VEC1, VEC2) \ +if (VEC1->n != VEC2->n) { \ + psError(__func__,"Vector %s has size %d, Vector %s has size %d.", #VEC1, VEC1->n, #VEC2, VEC2->n); \ +} + +/** Preprocessor macro to generate error on a NULL image */ +#define PS_CHECK_NULL_IMAGE(NAME) \ +if (NAME == NULL || NAME->data.V == NULL) { \ + psError(__func__,"Invalid operation: %s or its data is NULL.", #NAME); \ +} + +/** Preprocessor macro to generate error for zero length rows or columns */ +#define PS_CHECK_EMPTY_IMAGE(NAME) \ +if (NAME->numCols < 1 || NAME->numRows < 1) { \ + psError(__func__,"Invalid operation: %s has zero rows or columns (%dx%d).", #NAME, \ + NAME->numCols, NAME->numRows); \ +} + +/*****************************************************************************/ + +/* TYPE DEFINITIONS */ + +/*****************************************************************************/ +typedef struct +{ + size_t n; // Number of data points points in domain. + int paramCount; // Number of non-masked parameters. + psVector* restrict initialGuess; + const psImage* restrict domain; + const psVector* restrict data; + const psVector* restrict errors; + const psVector* restrict paramMask; + psMinimizeFunction evalModel; + psMinimizeFunctionDeriv d_evalModel; +} +psMinChi2Data; + +typedef struct +{ + int paramCount; // Number of non-masked parameters. + psVector* restrict initialGuess; + const psVector* restrict coord; + const psVector* restrict paramMask; + psMinimizeFunction evalModel; + psMinimizeFunctionDeriv d_evalModel; +} +psMinimizeData; + +/*****************************************************************************/ + +/* GLOBAL VARIABLES */ + +/*****************************************************************************/ + +// None + +/*****************************************************************************/ + +/* FILE STATIC VARIABLES */ + +/*****************************************************************************/ + +// None + +/*****************************************************************************/ + +/* FUNCTION IMPLEMENTATION - LOCAL */ + +/*****************************************************************************/ + +/****************************************************************************** +p_psMinFunc(*params, *funcData): We use the GSL procedure +gsl_multimin_fdfminimizer_iterate() to minimize an arbitary function supplied +by the user. That GSL procedure requires the function to be minimized to be +in a different format than the psLib format. The purpose of this procedure +is to serve as a GSL-format wrapper for the user-supplied procedure which is +to be minimized. + + params: The parameters of the function to be minimized. These will be + varied by GSL in order to minimize the function. + + funcData: a private psLib struct which contains the data point to be + minimized, the function and derivative function pointers, an initial + guess at the parameters, an option parameter mask, etc. + *****************************************************************************/ +double p_psMinFunc(const gsl_vector * params, void *funcData) +{ + int i; // Loop index variable. + int j; // Loop index variable. + float tmpf; // Temporary floating point variable. + const psVector* restrict coord = ((psMinimizeData* ) funcData)->coord; + const psVector* restrict mask = ((psMinimizeData* ) funcData)->paramMask; + psVector* restrict initialGuess = ((psMinimizeData* ) funcData)->initialGuess; + psMinimizeFunction evalModel = ((psMinimizeData* ) funcData)->evalModel; + psVector* inputParameterList = NULL; + + // The GSL routines will call this function with the masked parameters + // removed. However, the user-supplied function (to be modified) does not + // have those parameters removed. Here will create a new parameter list + // with the masked parameters added (we expand initialGuess). + inputParameterList = psVectorAlloc(initialGuess->n, PS_TYPE_F32); + if (mask != NULL) { + j = 0; + for (i = 0; i < mask->n; i++) { + if (mask->data.U8[i] != 0) { + inputParameterList->data.F32[i] = initialGuess->data.F32[i]; + } else { + inputParameterList->data.F32[i] = gsl_vector_get(params, j++); + } + } + } else { + for (i = 0; i < initialGuess->n; i++) { + inputParameterList->data.F32[i] = gsl_vector_get(params, i); + } + } + + // Call the user-supplied function. + tmpf = evalModel(inputParameterList, coord); + + // Free allocated memory and return the value of the function. + psFree(inputParameterList); + return (tmpf); +} + +/****************************************************************************** +p_psMinFuncDeriv(*params, *funcData): a GSL-like wrapper for the +user-supplied procedure which calculates the derviative of the function to be +minimized. + + params: The parameters of the function to be minimized. These will be + varied by GSL in order to minimize the function. + + funcData: a private psLib struct which contains the data point to be + minimized, the function and derivative function pointers, an initial + guess at the parameters, an option parameter mask, etc. + + df: we calculate the derivative of the function w.r.t. to each parameter + in "params" and return those derivatives in this psVector. + *****************************************************************************/ +void p_psMinFuncDeriv(const gsl_vector * params, void *funcData, gsl_vector * df) +{ + int i; // Loop index variable. + int j; // Loop index variable. + float tmpf; // Temporary floating point variable. + const psVector* restrict coord = ((psMinimizeData* ) funcData)->coord; + const psVector* restrict mask = ((psMinimizeData* ) funcData)->paramMask; + psVector* restrict initialGuess = ((psMinimizeData* ) funcData)->initialGuess; + psMinimizeFunctionDeriv d_evalModel = ((psMinimizeData* ) funcData)->d_evalModel; + psVector* inputParameterList = NULL; + + // The GSL routines will call this function with the masked parameters + // removed. However, the user-supplied function (to be modified) does not + // have those parameters removed. Here will create a new parameter list + // with the masked parameters added (we expand initialGuess). + inputParameterList = psVectorAlloc(initialGuess->n, PS_TYPE_F32); + if (mask != NULL) { + j = 0; + for (i = 0; i < mask->n; i++) { + if (mask->data.U8[i] != 0) { + inputParameterList->data.F32[i] = initialGuess->data.F32[i]; + } else { + inputParameterList->data.F32[i] = gsl_vector_get(params, j++); + } + } + } else { + for (i = 0; i < initialGuess->n; i++) { + inputParameterList->data.F32[i] = gsl_vector_get(params, i); + } + } + + // Evaluate the derivative w.r.t. each parameter. + // NOTE: we can probably remove the calls for masked parameters. + for (i = 0; i < initialGuess->n; i++) { + tmpf = d_evalModel(inputParameterList, coord, i); + gsl_vector_set(df, i, tmpf); + } + + // Free allocated memory. + psFree(inputParameterList); +} + +/****************************************************************************** + Compute both p_psMinFunc and p_psMinFuncDeriv together. + *****************************************************************************/ +void p_psMinFuncFuncDeriv(const gsl_vector * params, void *funcData, double *f, gsl_vector * df) +{ + *f = p_psMinFunc(params, funcData); + p_psMinFuncDeriv(params, funcData, df); +} + +// The first argument to evalModel() and d_evalModel() specifies the data +// point. It must have the same size as the second dimension of *domain. +// The second argument must have the same size as *initialGuess and +// *paramMask. + +/****************************************************************************** +p_psMinChi2Func(*x, *funcData, *outdata): We use the GSL procedure +gsl_multifit_fdfsolver_iterate() to fit an arbitrary function, supplied by +the user, to a set of data points. That GSL procedure requires the function +to be fit to be in a different format than the psLib format. The purpose of +this procedure is to serve as a GSL-format wrapper for the user-supplied +procedure which is to be fit to the data. + + params: These are the parameters which are to be varied by GSL in order + to minimize chi2 over the data set. + + funcData: this data structure contains the input values over which the + function will be evaluated, the expected value of the function at + those points, the amount of error tolerable at those points, a mask + vector which specifies which parameters to the function are to be + constant, and an initial guess at the parameters. + + outData: The function is evaluated at each point, then subtract the + expected value and divide by the error. + *****************************************************************************/ +int p_psMinChi2Func(const gsl_vector * params, void *funcData, gsl_vector * outData) +{ + int i; // Loop index variable. + int j; // Loop index variable. + float tmpf; // Temporary floating point variable. + const psImage* restrict domain = ((psMinChi2Data* ) funcData)->domain; + const psVector* restrict data = ((psMinChi2Data* ) funcData)->data; + const psVector* restrict errors = ((psMinChi2Data* ) funcData)->errors; + const psVector* restrict mask = ((psMinChi2Data* ) funcData)->paramMask; + psVector* restrict initialGuess = ((psMinChi2Data* ) funcData)->initialGuess; + psMinimizeFunction evalModel = ((psMinChi2Data* ) funcData)->evalModel; + psVector* inputParameterList = NULL; + psVector* tmpVecPtr = NULL; + + tmpVecPtr = psVectorAlloc(domain->numCols, PS_TYPE_F32); + + // The GSL routines will call this function with the masked parameters + // removed. However, the user-supplied function (to be modified) does not + // have those parameters removed. Here will create a new parameter list + // with the masked parameters added (we expand initialGuess). + + inputParameterList = psVectorAlloc(initialGuess->n, PS_TYPE_F32); + if (mask != NULL) { + j = 0; + for (i = 0; i < mask->n; i++) { + if (mask->data.U8[i] != 0) { + inputParameterList->data.F32[i] = initialGuess->data.F32[i]; + } else { + inputParameterList->data.F32[i] = gsl_vector_get(params, j++); + } + } + } else { + for (i = 0; i < initialGuess->n; i++) { + inputParameterList->data.F32[i] = gsl_vector_get(params, i); + } + } + + // Evaluate the function at each data point. + for (i = 0; i < domain->numRows; i++) { + for (j = 0; j < domain->numCols; j++) { + tmpVecPtr->data.F32[j] = domain->data.F32[i][j]; + } + tmpf = evalModel(tmpVecPtr, inputParameterList); + + gsl_vector_set(outData, i, (tmpf - data->data.F32[i]) / errors->data.F32[i]); + } + + // Free allocated memory. + psFree(inputParameterList); + psFree(tmpVecPtr); + + return GSL_SUCCESS; +} + +/****************************************************************************** +p_psMinChi2FuncDeriv(*x, *funcData, *outdata): a GSL-like wrapper for the +user-supplied procedure which calculates the derviative of the function to be +minimized. + params: These are the parameters which are to be varied by GSL in order + to minimize chi2 over the data set. + + funcData: this data structure contains the input values over which the + function will be evaluated, the expected value of the function at + those points, the amount of error tolerable at those points, a mask + vector which specifies which parameters to the function are to be + constant, and an initial guess at the parameters. + + J: The derivative is evaluated at each point and w.r.t. each parameter + and returned in this data structure. + *****************************************************************************/ +int p_psMinChi2FuncDeriv(const gsl_vector * params, void *funcData, gsl_matrix * J) +{ + const psImage* restrict domain = ((psMinChi2Data* ) funcData)->domain; + const psVector* restrict errors = ((psMinChi2Data* ) funcData)->errors; + const psVector* restrict mask = ((psMinChi2Data* ) funcData)->paramMask; + psVector* restrict initialGuess = ((psMinChi2Data* ) funcData)->initialGuess; + psVector* inputParameterList = NULL; + psVector* tmpVecPtr = NULL; + psMinimizeFunctionDeriv d_evalModel = ((psMinChi2Data* ) funcData)->d_evalModel; + + size_t i; + int j; + float tmpf; + + tmpVecPtr = psVectorAlloc(domain->numCols, PS_TYPE_F32); + + // The GSL routines will call this functions with the masked parameters + // removed. However, the user-supplied function (to be modified) does not + // have those parameters removed. Here will create a new parameter list + // with the masked parameters added (we expand initialGuess). + + inputParameterList = psVectorAlloc(initialGuess->n, PS_TYPE_F32); + if (mask != NULL) { + j = 0; + for (i = 0; i < mask->n; i++) { + if (mask->data.U8[i] != 0) { + inputParameterList->data.F32[i] = initialGuess->data.F32[i]; + } else { + inputParameterList->data.F32[i] = gsl_vector_get(params, j++); + } + } + } else { + for (i = 0; i < initialGuess->n; i++) { + inputParameterList->data.F32[i] = gsl_vector_get(params, i); + } + } + + // Evaluate the derivtaive at each data point, and w.r.t. each parameter. + for (i = 0; i < domain->numRows; i++) { + for (j = 0; j < tmpVecPtr->n; j++) { + tmpVecPtr->data.F32[j] = domain->data.F32[i][j]; + } + + for (j = 0; j < inputParameterList->n; j++) { + tmpf = d_evalModel(tmpVecPtr, inputParameterList, j); + gsl_matrix_set(J, i, j, (tmpf / errors->data.F32[i])); + } + } + + psFree(inputParameterList); + psFree(tmpVecPtr); + return GSL_SUCCESS; +} + +int p_psMinChi2FuncFuncDeriv(const gsl_vector * params, void *funcData, gsl_vector * f, gsl_matrix * J) +{ + p_psMinChi2Func(params, funcData, f); + p_psMinChi2FuncDeriv(params, funcData, J); + + return GSL_SUCCESS; +} + +/****************************************************************************** +p_psBuildSums1D(x, polyOrder, sums): this routine calculates the powers of +input parameter "x" between 0 and input parameter polyOrder. The result is +returned as a psVector sums. + *****************************************************************************/ +void p_psBuildSums1D(double x, int polyOrder, psVector* sums) +{ + int i = 0; + double xSum = 0.0; + + xSum = 1.0; + for (i = 0; i <= polyOrder; i++) { + sums->data.F64[i] = xSum; + xSum *= x; + } +} + +/****************************************************************************** +p_psBuildSums1D(x): this routine returns a psVector with "x" elements. The +values of the vector will be scaled uniformly between -1.0 and 1.0. + *****************************************************************************/ +psVector* psBuildImageScalingFactors(int x) +{ + int i = 0; // loop index variable. + psVector* imageScalingFactors = NULL; + + imageScalingFactors = psVectorAlloc(x, PS_TYPE_F32); + + for (i = 0; i < x; i++) { + imageScalingFactors->data.F32[i] = (((float)2 * i) / ((float)x)) - 1.0; + } + + return (imageScalingFactors); +} + +/****************************************************************************** +CURRENTLY NOT IN USE. + +p_psPolyOrderCheck(A, N, *indx, *B, polyOrder,*flag) This routine checks if +all polyOrder-th terms in the polyOrder-th order sky background polynomial +defined by the coefficients in the array B[] are consistent with zero. If +true, then *flag is set to 1. Otherwise, *flag is set to 0. The matrix +inversion code in the middle of this procedure draws from Numerical Recipes +in C page 48. +Input: + A This is the LUD decomposition of the original matrix A. + N The size of the matrix (plus 1, actually, since offset 1). + indx misc Numerical Recipes data structure. + B The coefficients of the sky polynomial. + polyOrder The degree of the sky polynomial. +Output: + *flag Set this to 1 if we must recalculate the coefficients. + *****************************************************************************/ +void p_psPolyOrderCheck(float **A, int N, int *indx, float *B, int polyOrder, int *flag) +{ + float **y = NULL; // This 2-D matrix will hold A^-1 + float *col = NULL; // misc NumerRecipes data structure + float *error = NULL; // will hold the sqrt() of the + + // diagonal of y[][]. + int i = 0; // loop-index variable + int j = 0; // loop-index variable + int numPolyTerms = 0; // The number of terms in the + + // polynomial. + int lastTerm = 0; // The index location of the first + + // n-th order term in array B[]. + int firstTerm = 0; // Index location of last such term. + + // Allocate the necessary data structures for this procedure... + error = (float *)psAlloc((N + 1) * sizeof(float)); + col = (float *)psAlloc((N + 1) * sizeof(float)); + y = (float **)psAlloc((N + 1) * sizeof(float *)); + for (i = 1; i <= N; i++) { + y[i] = (float *)psAlloc((N + 1) * sizeof(float)); + } + + // Invert the matrix A and put the result in y[][]. This code is taken + // from Numerical Recipes in C page 48. + for (j = 1; j <= N; j++) { + for (i = 1; i <= N; i++) { + col[i] = 0.0; + } + col[j] = 1.0; + // NOTE: substitue the LUD rotine + // lubksb(A, N, indx, col); + for (i = 1; i <= N; i++) { + y[i][j] = col[i]; + } + } + + // Determine where the first n-th order (in this comment, n equals + // polyOrder) polynomial term is stored in the matrix B[], and also were + // the last n-order term is stored. Then we loop over all the n-order + // terms and check if they are consistent with zero. + + numPolyTerms = (((polyOrder + 1) * (polyOrder + 2)) / 2); + lastTerm = numPolyTerms + 1; + firstTerm = lastTerm - polyOrder; + *flag = 1; + for (i = firstTerm; i <= lastTerm; i++) { + #ifdef DARWIN + error[i] = (float)sqrt(y[i][i]); + #else + + error[i] = sqrtf(y[i][i]); + #endif + + if (!((B[i] <= (2.0f * error[i])) && ((-2.0f * error[i]) <= B[i]))) { + *flag = 0; + } + } + + // Free all memory allocated in this routine. + psFree(error); + psFree(col); + for (j = 1; j <= N; j++) { + psFree(y[j]); + } + psFree(y); +} + +/*****************************************************************************/ + +/* FUNCTION IMPLEMENTATION - PUBLIC */ + +/*****************************************************************************/ + +/****************************************************************************** +psMinimize(initialGuess, myFunction, myFunctionDeriv, coord, paramMask): + +This routine must minimize an arbitrary function; it determines the set of +parameters of that function such that the ... + *****************************************************************************/ +psVector* psMinimize(psVector* restrict initialGuess, + psMinimizeFunction myFunction, + psMinimizeFunctionDeriv myFunctionDeriv, + const psVector* restrict coord, + const psVector* restrict paramMask) +{ + int status; + int i = 0; + int j = 0; + int iter = 0; + gsl_multimin_function_fdf f; + const gsl_multimin_fdfminimizer_type *T; + gsl_multimin_fdfminimizer *s; + psMinimizeData inputData; + gsl_vector *x; + + PS_CHECK_NULL_VECTOR(initialGuess); + PS_CHECK_EMPTY_VECTOR(initialGuess); + PS_CHECK_NULL_VECTOR(coord); + PS_CHECK_EMPTY_VECTOR(coord); + if (paramMask != NULL) { + PS_CHECK_NULL_VECTOR(paramMask); + PS_CHECK_EMPTY_VECTOR(paramMask); + PS_CHECK_VECTOR_SIZE_EQUAL(initialGuess, paramMask); + } + + inputData.initialGuess = initialGuess; + inputData.coord = coord; + inputData.paramMask = paramMask; + inputData.evalModel = myFunction; + inputData.d_evalModel = myFunctionDeriv; + inputData.paramCount = 0; + + // If the user supplied a parameter mask, then count the number of + // non-masked elements. This will be used later in allocating a vector + // for the parameters. + if (paramMask != NULL) { + for (i = 0; i < paramMask->n; i++) { + if (paramMask->data.U8[i] != 0) { + inputData.paramCount++; + } + } + } else { + inputData.paramCount = initialGuess->n; + } + + // The initial guess at the parameters for the function are written into + // the vector inputParameterList. If the paramMask is not NULL, then + // masked parameters are masked out. + x = gsl_vector_alloc(inputData.paramCount); + if (paramMask != NULL) { + j = 0; + for (i = 0; i < initialGuess->n; i++) { + if (paramMask->data.U8[i] == 0) { + gsl_vector_set(x, j++, initialGuess->data.F32[i]); + } + } + } else { + for (i = 0; i < initialGuess->n; i++) { + gsl_vector_set(x, i, initialGuess->data.F32[i]); + } + } + f.f = &p_psMinFunc; + f.df = &p_psMinFuncDeriv; + f.fdf = &p_psMinFuncFuncDeriv; + f.n = inputData.paramCount; + f.params = &inputData; + + T = gsl_multimin_fdfminimizer_conjugate_fr; + s = gsl_multimin_fdfminimizer_alloc(T, inputData.paramCount); + gsl_multimin_fdfminimizer_set(s, &f, x, 0.01, 1e-4); + do { + iter++; + status = gsl_multimin_fdfminimizer_iterate(s); + + if (status) + break; + + status = gsl_multimin_test_gradient(s->gradient, 1e-3); + + if (status == GSL_SUCCESS) + printf("Minimum found at:\n"); + + } while (status == GSL_CONTINUE && iter < MAX_MINIMIZE_ITERATIONS); + + // In the above steps we had removed the masked elements from the + // the solver. This next code blocks puts those masked elements + // into the solution. + if (paramMask != NULL) { + j = 0; + for (i = 0; i < initialGuess->n; i++) { + if (paramMask->data.U8[i] == 0) { + initialGuess->data.F32[i] = gsl_vector_get(s->x, j++); + } else { + initialGuess->data.F32[i] = initialGuess->data.F32[i]; + } + } + } else { + for (i = 0; i < initialGuess->n; i++) { + initialGuess->data.F32[i] = gsl_vector_get(s->x, i); + } + } + return (initialGuess); +} + +/****************************************************************************** + This routine must determine the parameters of an arbitrary function + such that they best fit the supplied data points. + *****************************************************************************/ +psVector* psMinimizeChi2(psMinimizeFunction evalModel, + psMinimizeFunctionDeriv DevalModel, + const psImage* restrict domain, + const psVector* restrict data, + const psVector* restrict errors, + psVector* restrict initialGuess, + const psVector* restrict paramMask, + float *chiSq) +{ + int numData = domain->numRows; // Number of data points + int status; // Return status for the GSL solver. + int i = 0; // Loop index variable. + int j = 0; // Loop index variable. + int iter = 0; // Iteration counter. + gsl_multifit_function_fdf f; // GSL structure that contains the + + // functions/derivative to be solved. + double *xInit = NULL; // The initial guess at the parameters + + // with masked parameters removed. + const gsl_multifit_fdfsolver_type *T; + + // This tells GSL to use the Levenberg- + // Marquardt algorithm for chi2 + // minimization. + gsl_multifit_fdfsolver *s; // GSL data structure. + psMinChi2Data inputData; + float chiSqOld = 0.0; + + PS_CHECK_NULL_IMAGE(domain); + PS_CHECK_EMPTY_IMAGE(domain); + PS_CHECK_NULL_VECTOR(data); + PS_CHECK_EMPTY_VECTOR(data); + PS_CHECK_NULL_VECTOR(errors); + PS_CHECK_EMPTY_VECTOR(errors); + PS_CHECK_NULL_VECTOR(initialGuess); + PS_CHECK_EMPTY_VECTOR(initialGuess); + PS_CHECK_VECTOR_SIZE_EQUAL(data, errors); + if (domain->numRows != data->n) { + psAbort(__func__, "Number of data points and data values not equal."); + } + if (paramMask != NULL) { + PS_CHECK_NULL_VECTOR(paramMask); + PS_CHECK_EMPTY_VECTOR(paramMask); + PS_CHECK_VECTOR_SIZE_EQUAL(initialGuess, paramMask); + } + + inputData.n = numData; + inputData.paramCount = 0; + inputData.initialGuess = initialGuess; + inputData.domain = domain; + inputData.data = data; + inputData.errors = errors; + inputData.paramMask = paramMask; + inputData.evalModel = evalModel; + inputData.d_evalModel = DevalModel; + + // If the user supplied a parameter mask, then count the number of + // non-masked elements. This will be used later in allocating a vector + // for the parameters. + if (paramMask != NULL) { + for (i = 0; i < paramMask->n; i++) { + if (paramMask->data.U8[i] != 0) { + inputData.paramCount++; + } + } + } else { + inputData.paramCount = initialGuess->n; + } + + // The initial guess at the parameters for the function are written into + // the vector inputParameterList. If the paramMask is not NULL, then those + // parameters are masked out. + xInit = (double *)psAlloc(inputData.paramCount * sizeof(double)); + if (paramMask != NULL) { + j = 0; + for (i = 0; i < initialGuess->n; i++) { + if (paramMask->data.U8[i] == 0) { + xInit[j++] = initialGuess->data.F32[i]; + } + } + } else { + for (i = 0; i < initialGuess->n; i++) { + xInit[i] = initialGuess->data.F32[i]; + } + } + + const gsl_rng_type *type; + gsl_rng *r; + + gsl_rng_env_setup(); + + type = gsl_rng_default; + r = gsl_rng_alloc(type); + + // Initialize the main data structure used by the GSL solver. This will + // contain pointers to the function to be minimized, it's derivative + // function, the number of data points, the number of free parameters, + // and the data structures those functions use. + + f.f = &p_psMinChi2Func; + f.df = &p_psMinChi2FuncDeriv; + f.fdf = &p_psMinChi2FuncFuncDeriv; + f.n = numData; + f.p = inputData.paramCount; + f.params = &inputData; + + gsl_vector_view x = gsl_vector_view_array(xInit, inputData.paramCount); + + T = gsl_multifit_fdfsolver_lmsder; + s = gsl_multifit_fdfsolver_alloc(T, numData, inputData.paramCount); + gsl_multifit_fdfsolver_set(s, &f, &x.vector); + *chiSq = 0.0; + chiSqOld = 0.0; + do { + iter++; + for (i = 0; i < initialGuess->n; i++) { + printf("Iteration %d: parameter %d is %.3f\n", iter, i, gsl_vector_get(s->x, i)); + } + // Perform an iteration of the GSL solver. + status = gsl_multifit_fdfsolver_iterate(s); + printf("gsl_multifit_fdfsolver_iterate() status is %s\n", gsl_strerror(status)); + for (i = 0; i < initialGuess->n; i++) { + printf("Iteration %d: parameter %d is %.3f\n", iter, i, gsl_vector_get(s->x, i)); + } + + // If there was a problem, abort. + if (status) { + psAbort(__func__, "gsl_multifit_fdfsolver_iterate(%s)\n", gsl_strerror(status)); + } + // Test if the parameters changed by a small enough amount. + // NOTE: This wasn't working right when the parameters fit exactly. + // Figure out why. + // status = gsl_multifit_test_delta(s->dx, s->x, 1e-4, 1e-4); + + // We test for convergence if chiSquared changes by less than 1.0 + // as specified in the ADD. + *chiSq = gsl_blas_dnrm2(s->f); + printf("psMinimize.c: chiSq is %.3f\n", *chiSq); + if (fabs(*chiSq - chiSqOld) < 1.0) { + status = GSL_SUCCESS; + } else { + status = GSL_CONTINUE; + } + chiSqOld = *chiSq; + + } while (status == GSL_CONTINUE && iter < MAX_LMM_ITERATIONS); + + // In the above steps we had removed the masked elements from the + // the solver. This next code blocks puts those masked elements + // into the solution. + if (paramMask != NULL) { + j = 0; + for (i = 0; i < initialGuess->n; i++) { + if (paramMask->data.U8[i] == 0) { + initialGuess->data.F32[i] = gsl_vector_get(s->x, j++); + } else { + initialGuess->data.F32[i] = initialGuess->data.F32[i]; + } + } + } else { + for (i = 0; i < initialGuess->n; i++) { + initialGuess->data.F32[i] = gsl_vector_get(s->x, i); + } + } + + // Calculate the chi-squared for the derived solution. + *chiSq = gsl_blas_dnrm2(s->f); + + // Free all allocated memory + // NOTE: Free x. + gsl_multifit_fdfsolver_free(s); + psFree(xInit); + + // Bye bye. + return (initialGuess); +} + +/****************************************************************************** + This routine must fit a polynomial of degree myPoly to the data points + (x, y) and return the coefficients of that polynomial, as well as the + error for each data point (yErr). + +NOTE: yErr is currently ignored. + *****************************************************************************/ +psPolynomial1D* psVectorFitPolynomial1D(psPolynomial1D* myPoly, + const psVector* restrict x, + const psVector* restrict y, const psVector* restrict yErr) +{ + int polyOrder = myPoly->n; + psImage* A = NULL; + psImage* ALUD = NULL; + psVector* B = NULL; + psVector* outPerm = NULL; + psVector* X = NULL; // NOTE: do we need this? + psVector* coeffs = NULL; + int i = 0; + int j = 0; + int k = 0; + psVector* xSums = NULL; + + // printf("psVectorFitPolynomial1D()\n"); + // for (i=0;in;i++) { + // printf("(x, y, yErr) is (%f, %f, %f)\n", x->data.F64[i], y->data.F64[i], yErr->data.F64[i]); + // } + + PS_CHECK_NULL_1DPOLY(myPoly); + PS_CHECK_NULL_VECTOR(x); + PS_CHECK_EMPTY_VECTOR(x); + PS_CHECK_NULL_VECTOR(y); + PS_CHECK_EMPTY_VECTOR(y); + PS_CHECK_NULL_VECTOR(yErr); + PS_CHECK_EMPTY_VECTOR(yErr); + PS_CHECK_VECTOR_SIZE_EQUAL(x, y); + PS_CHECK_VECTOR_SIZE_EQUAL(y, yErr); + + A = psImageAlloc(polyOrder, polyOrder, PS_TYPE_F64); + ALUD = psImageAlloc(polyOrder, polyOrder, PS_TYPE_F64); + B = psVectorAlloc(polyOrder, PS_TYPE_F64); + coeffs = psVectorAlloc(polyOrder, PS_TYPE_F64); + X = psVectorAlloc(x->n, PS_TYPE_F64); + outPerm = psVectorAlloc(polyOrder, PS_TYPE_F64); + xSums = psVectorAlloc(1 + 2 * polyOrder, PS_TYPE_F64); + + // Initialize data structures. + for (i = 0; i < (polyOrder); i++) { + B->data.F64[i] = 0.0; + coeffs->data.F64[i] = 0.0; + outPerm->data.F64[i] = 0.0; + for (j = 0; j < (polyOrder); j++) { + A->data.F64[i][j] = 0.0; + ALUD->data.F64[i][j] = 0.0; + } + } + for (i = 0; i < X->n; i++) { + X->data.F64[i] = x->data.F64[i]; + } + + // Build the B and A data structs. + for (i = 0; i < X->n; i++) { + p_psBuildSums1D(X->data.F64[i], 2 * polyOrder, xSums); + + for (k = 0; k < (polyOrder); k++) { + B->data.F64[k] += y->data.F64[i] * xSums->data.F64[k]; + } + + for (k = 0; k < (polyOrder); k++) { + for (j = 0; j < (polyOrder); j++) { + A->data.F64[k][j] += xSums->data.F64[k + j]; + } + } + } + + ALUD = psMatrixLUD(ALUD, outPerm, A); + coeffs = psMatrixLUSolve(coeffs, ALUD, B, outPerm); + + for (k = 0; k < (polyOrder); k++) { + myPoly->coeff[k] = coeffs->data.F64[k]; + // printf("myPoly->coeff[%d] is %f\n", k, myPoly->coeff[k]); + } + + // for (i=0;in;i++) { + // printf("HMMM: psEvalPolynomial1D(%f) is %f\n", x->data.F64[i], psEvalPolynomial1D(x->data.F64[i], + // myPoly)); + // } + + psFree(A); + psFree(ALUD); + psFree(B); + psFree(coeffs); + psFree(X); + psFree(outPerm); + psFree(xSums); + + return (myPoly); +} Index: /tags/rel2_1/psLib/src/dataManip/psMinimize.h =================================================================== --- /tags/rel2_1/psLib/src/dataManip/psMinimize.h (revision 1553) +++ /tags/rel2_1/psLib/src/dataManip/psMinimize.h (revision 1553) @@ -0,0 +1,105 @@ +#if !defined(PS_MINIMIZE_H) +#define PS_MINIMIZE_H + +#include "psFunctions.h" + +/** \file psMinimize.h + * \brief minimization operations + * \ingroup Stats + */ + +/** Functions **************************************************************/ + +/** \addtogroup Stats + * \{ + */ + +/** function of a collection of parameters and coordinate vector. + * + * @return float value to minimize + */ +typedef float (*psMinimizeFunction)( + const psVector* restrict params, ///< collection of parameters + const psVector* restrict coord ///< coordinates +); + +/** derivative function of psMinimizeFunction + * + * @return float the derivative in respect to params[derivParam] + */ +typedef float (*psMinimizeFunctionDeriv) ( + const psVector* restrict params, ///< collection of parameters + const psVector* restrict coord, ///< coordinates + int derivParam ///< index of parameter to calculate derivative of +); + +/** Minimizes a non-linear function. + * + * psMinimize determines and returns the vector that minimizes the specified + * function. It takes as input a function, myFunction, an initial guess for + * the vector that minimizes the function, initialGuess, the current + * coordiate coord, and an optional mask for the vector elements (function + * parameters) to minimize, paramMask (all parameters are fit if PSLib SDRS + * 25 July 13, 2004 Pan-STARRS Image Processing Pipeline PSDC-430-007-04 + * NULL). Note that paramMask must be of type psU8, while params must be of + * type psF32. The optional function, myFuncDeriv returns the derivative of + * the function. This function must be valid only for types psF32, psF64. + * + * @return psVector* minimized vector + */ +psVector* psMinimize( + psVector* restrict initialGuess, + psMinimizeFunction myFunction, + psMinimizeFunctionDeriv myFunctionDeriv, + const psVector* restrict coord, + const psVector* restrict paramMask +); + +/** Minimize chi^2 for input data. + * + * psMinimizeChi2 fits a model to observations by minimizing chi^2, returning + * the best-fit parameters. The input parameters are a function that + * evaluates the model for a specified domain, given the parameters, + * evalModel; a list of observations, (domain, data, and errors); an initial + * guess at the best-fit parameters, initialGuess which is returned with the + * best-fit parameters, and an optional mask specifying which parameters are + * to be fit, paramMask, which must be of type psU8. All parameters are fit + * if this vector is NULL. This function must be valid only for types psF32, + * psF64. + * + * @return psVector* minimized vector + */ +psVector* psMinimizeChi2( + psMinimizeFunction evalModel, ///< Model to fit; (domain and params) + psMinimizeFunctionDeriv DevalModel,///< Derivative of model to fit; (domain and params) + const psImage* restrict domain, ///< The domain values for the corresponding measurements + const psVector* restrict data, ///< Data to fit + const psVector* restrict errors, ///< Errors in the data + psVector* restrict initialGuess, ///< Initial guess + const psVector* restrict paramMask,///< 1 = fit for parameter, 0 = hold parameter constant + float *chiSq ///< chi squared +); + +/** Derive a polynomial fit by chi^2 minimisation (analytically) + * + * psVectorFitPolynomial1d returns the polynomial that best fits the + * observations. The input parameters are a polynomial that specifies the + * fit order, myPoly, which will be altered and returned with the best-fit + * coefficients; and the observations, x, y and yErr. The independent + * variable list, x may be NULL, in which case the vector index is used. + * The dependent variable error, yErr may be null, in which case the solution + * is determined in the assumption that all data errors are equal. This + * function must be valid only for types psF32, psF64. + * + * @return psPolynomial1D* polynomial fit + */ +psPolynomial1D* psVectorFitPolynomial1D( + psPolynomial1D* myPoly, ///< Polynomial to fit + const psVector* restrict x, ///< Ordinates (or NULL to just use the indices) + const psVector* restrict y, ///< Coordinates + const psVector* restrict yErr ///< Errors in coordinates, or NULL +); + +/* \} */// End of MathGroup Functions + +#endif Index: /tags/rel2_1/psLib/src/dataManip/psStats.c =================================================================== --- /tags/rel2_1/psLib/src/dataManip/psStats.c (revision 1553) +++ /tags/rel2_1/psLib/src/dataManip/psStats.c (revision 1553) @@ -0,0 +1,1888 @@ + +/** @file psStats.c + * \brief basic statistical operations + * @ingroup Stats + * + * This file will hold the definition of the histogram and stats data + * structures. It also contains prototypes for procedures which operate + * on those data structures. + * + * @author George Gusciora, MHPCC + * + * @version $Revision: 1.53 $ $Name: not supported by cvs2svn $ + * @date $Date: 2004-08-09 23:34:57 $ + * + * Copyright 2004 Maui High Performance Computing Center, University of Hawaii + */ + +#include +#include +#include +#include +#include +#include + +/*****************************************************************************/ + +/* INCLUDE FILES */ + +/*****************************************************************************/ +#include "psMemory.h" +#include "psImage.h" +#include "psVector.h" +#include "psTrace.h" +#include "psError.h" +#include "psAbort.h" +#include "psStats.h" +#include "psMinimize.h" +#include "psFunctions.h" + +/*****************************************************************************/ + +/* DEFINE STATEMENTS */ + +/*****************************************************************************/ +// will use robust statistical methods. +#define GAUSS_WIDTH 20 // The width of the Gaussian or boxcar smoothing. +#define CLIPPED_NUM_ITER_LB 1 +#define CLIPPED_NUM_ITER_UB 10 +#define CLIPPED_SIGMA_LB 1.0 +#define CLIPPED_SIGMA_UB 10.0 +#define true 1 +#define false 0 +#define MY_MAX_FLOAT HUGE +#define MAX_ITERATIONS 10 + +void p_psVectorRobustStats(const psVector* restrict myVector, + const psVector* restrict maskVector, unsigned int maskVal, psStats* stats); + +/** Preprocessor macro to generate error on an incorrect type */ +#define PS_CHECK_VECTOR_TYPE(NAME, TYPE) \ +if (NAME->type.type != TYPE) { \ + psError(__func__,"Invalid operation: %s has incorrect type.", #NAME); \ +} + +/** Preprocessor macro to generate error on a NULL vector */ +#define PS_CHECK_NULL_VECTOR(NAME) \ +if (NAME == NULL || NAME->data.V == NULL) { \ + psError(__func__,"Invalid operation: %s or its data is NULL.", #NAME); \ +} + +/** Preprocessor macro to generate error for zero length vector */ +#define PS_CHECK_EMPTY_VECTOR(NAME) \ +if (NAME->n < 1) { \ + psError(__func__,"Invalid operation: %s has zero n value.", #NAME); \ +} + +/** Preprocessor macro to generate error on differing size vectors */ +#define PS_CHECK_VECTOR_SIZE_EQUAL(VEC1, VEC2) \ +if (VEC1->n != VEC2->n) { \ + psError(__func__,"Vector %s has size %d, Vector %s has size %d.", #VEC1, VEC1->n, #VEC2, VEC2->n); \ +} + +#define PS_PRINT_VECTOR(NAME) \ +for (int my_i=0;my_in;my_i++) { \ + printf("%s->data.F32[%d] is %f\n", #NAME, my_i, NAME->data.F32[my_i]); \ +} \ +printf("\n"); \ + + +/*****************************************************************************/ + +/* TYPE DEFINITIONS */ + +/*****************************************************************************/ + +/*****************************************************************************/ + +/* GLOBAL VARIABLES */ + +/*****************************************************************************/ + +// None + +/*****************************************************************************/ + +/* FILE STATIC VARIABLES */ + +/*****************************************************************************/ + +// None + +/*****************************************************************************/ + +/* FUNCTION IMPLEMENTATION - LOCAL */ + +/*****************************************************************************/ + +bool p_psGetStatValue(const psStats* stats, double *value) +{ + + switch (stats->options & ~(PS_STAT_USE_RANGE | PS_STAT_USE_BINSIZE | PS_STAT_ROBUST_FOR_SAMPLE)) { + case PS_STAT_SAMPLE_MEAN: + *value = stats->sampleMean; + return true; + + case PS_STAT_SAMPLE_MEDIAN: + *value = stats->sampleMedian; + return true; + + case PS_STAT_SAMPLE_STDEV: + *value = stats->sampleStdev; + return true; + + case PS_STAT_ROBUST_MEAN: + *value = stats->robustMean; + return true; + + case PS_STAT_ROBUST_MEDIAN: + *value = stats->robustMedian; + return true; + + case PS_STAT_ROBUST_MODE: + *value = stats->robustMode; + return true; + + case PS_STAT_ROBUST_STDEV: + *value = stats->robustStdev; + return true; + + case PS_STAT_CLIPPED_MEAN: + *value = stats->clippedMean; + return true; + + case PS_STAT_CLIPPED_STDEV: + *value = stats->clippedStdev; + return true; + + case PS_STAT_MAX: + *value = stats->max; + return true; + + case PS_STAT_MIN: + *value = stats->min; + return true; + + default: + return false; + } +} + +/***************************************************************************** +p_psVectorPrint(myVector, maskVector, maskVal, stats): a private internal +function that simply prints a vector to STDOUT. Used primarily for +debugging. + *****************************************************************************/ + +void p_psVectorPrint(psVector* myVector, psVector* maskVector, unsigned int maskVal, psStats* stats) +{ + int i = 0; // Loop index variable. + + for (i = 0; i < myVector->n; i++) { + if (maskVector != NULL) + printf("Element %d is %f (mask is %d)\n", i, myVector->data.F32[i], maskVector->data.U8[i]); + else + printf("Element %d is %f\n", i, myVector->data.F32[i]); + } +} + +/****************************************************************************** + ****************************************************************************** + ****************************************************************************** + MISC PRIVATE STATISTICAL FUNCTIONS + + NOTE: it is assumed that any call to these statistical functions will + have been preceded by a call to the psVectorStats() function. Various + sanity tests will only be performed in psVectorStats(). + Is the mask vector the same length as the data vector? + Is the mask vector of type PS_TYPE_U8? + Is the stats data structure NULL? + Is the in data structure NULL? + Is the in data structure of type PS_TYPE_F32? + ****************************************************************************** + ****************************************************************************** + *****************************************************************************/ + +/****************************************************************************** +p_psVectorSampleMean(myVector, maskVector, maskVal, stats): calculates the +mean of the input vector. +Inputs + myVector + maskVector + maskVal + stats +Returns + NULL +ASSUMPTION: the mean is always calculated exactly. Robust means are never +calculated in this routine. + *****************************************************************************/ + +void p_psVectorSampleMean(const psVector* restrict myVector, + const psVector* restrict maskVector, unsigned int maskVal, psStats* stats) +{ + int i = 0; // Loop index variable + float mean = 0.0; // The mean + int count = 0; // # of points in this mean? + float rangeMin = 0.0; // Exclude data below this + float rangeMax = 0.0; // Exclude date above this + + // If PS_STAT_USE_RANGE is requested, then we enter a slightly different + // loop. + if (stats->options & PS_STAT_USE_RANGE) { + rangeMin = stats->min; + rangeMax = stats->max; + if (maskVector != NULL) { + for (i = 0; i < myVector->n; i++) { + // Check if the data is with the specified range + if (!(maskVal & maskVector->data.U8[i]) && + (rangeMin <= myVector->data.F32[i]) && (myVector->data.F32[i] <= rangeMax)) { + mean += myVector->data.F32[i]; + count++; + } + } + mean /= (float)count; + } else { + for (i = 0; i < myVector->n; i++) { + if ((rangeMin <= myVector->data.F32[i]) && (myVector->data.F32[i] <= rangeMax)) { + mean += myVector->data.F32[i]; + count++; + } + } + mean /= (float)count; + } + } else { + if (maskVector != NULL) { + for (i = 0; i < myVector->n; i++) { + if (!(maskVal & maskVector->data.U8[i])) { + mean += myVector->data.F32[i]; + count++; + } + } + mean /= (float)count; + } else { + for (i = 0; i < myVector->n; i++) { + mean += myVector->data.F32[i]; + } + mean /= (float)myVector->n; + } + } + + stats->sampleMean = mean; +} + +/****************************************************************************** +p_psVectorSampleMax(myVector, maskVector, maskVal, stats): calculates the +max of the input vector. +Inputs + myVector + maskVector + maskVal + stats +Returns + NULL + *****************************************************************************/ +void p_psVectorMax(const psVector* restrict myVector, + const psVector* restrict maskVector, unsigned int maskVal, psStats* stats) +{ + int i = 0; // Loop index variable + float max = -MY_MAX_FLOAT; // The calculated maximum + float rangeMin = 0.0; // Exclude data below this + float rangeMax = 0.0; // Exclude date above this + + // If PS_STAT_USE_RANGE is requested, then we enter a different loop. + if (stats->options & PS_STAT_USE_RANGE) { + rangeMin = stats->min; + rangeMax = stats->max; + if (maskVector != NULL) { + for (i = 0; i < myVector->n; i++) { + if (!(maskVal & maskVector->data.U8[i])) { + if ((myVector->data.F32[i] > max) && + (rangeMin <= myVector->data.F32[i]) && (myVector->data.F32[i] <= rangeMax)) { + max = myVector->data.F32[i]; + } + } + } + } else { + for (i = 0; i < myVector->n; i++) { + if ((myVector->data.F32[i] > max) && + (rangeMin <= myVector->data.F32[i]) && (myVector->data.F32[i] <= rangeMax)) { + max = myVector->data.F32[i]; + } + } + } + } else { + if (maskVector != NULL) { + for (i = 0; i < myVector->n; i++) { + if (!(maskVal & maskVector->data.U8[i])) { + if (myVector->data.F32[i] > max) { + max = myVector->data.F32[i]; + } + } + } + } else { + for (i = 0; i < myVector->n; i++) { + if (myVector->data.F32[i] > max) { + max = myVector->data.F32[i]; + } + } + } + } + + stats->max = max; +} + +/****************************************************************************** +p_psVectorSampleMin(myVector, maskVector, maskVal, stats): calculates the +minimum of the input vector. +Inputs + myVector + maskVector + maskVal + stats +Returns + NULL + *****************************************************************************/ +void p_psVectorMin(const psVector* restrict myVector, + const psVector* restrict maskVector, unsigned int maskVal, psStats* stats) +{ + int i = 0; // Loop index variable + float min = MY_MAX_FLOAT; // The calculated maximum + float rangeMin = 0.0; // Exclude data below this + float rangeMax = 0.0; // Exclude date above this + + if (stats->options & PS_STAT_USE_RANGE) { + rangeMin = stats->min; + rangeMax = stats->max; + if (maskVector != NULL) { + for (i = 0; i < myVector->n; i++) { + if (!(maskVal & maskVector->data.U8[i])) { + if ((myVector->data.F32[i] < min) && + (rangeMin <= myVector->data.F32[i]) && (myVector->data.F32[i] <= rangeMax)) { + min = myVector->data.F32[i]; + } + } + } + } else { + for (i = 0; i < myVector->n; i++) { + if ((myVector->data.F32[i] < min) && + (rangeMin <= myVector->data.F32[i]) && (myVector->data.F32[i] <= rangeMax)) { + min = myVector->data.F32[i]; + } + } + } + } else { + if (maskVector != NULL) { + for (i = 0; i < myVector->n; i++) { + if (!(maskVal & maskVector->data.U8[i])) { + if (myVector->data.F32[i] < min) { + min = myVector->data.F32[i]; + } + } + } + } else { + for (i = 0; i < myVector->n; i++) { + if (myVector->data.F32[i] < min) { + min = myVector->data.F32[i]; + } + } + } + } + + stats->min = min; +} + +/****************************************************************************** +p_psVectorNValues(myVector, maskVector, maskVal, stats): calculates the +number of non-masked pixels in the vector that fall within the min/max +range, if given. +Inputs + myVector + maskVector + maskVal + stats +Returns + NULL + *****************************************************************************/ +int p_psVectorNValues(const psVector* restrict myVector, + const psVector* restrict maskVector, unsigned int maskVal, psStats* stats) +{ + int i = 0; // Loop index variable + int numData = 0; // The number of data points + float rangeMin = 0.0; // Exclude data below this + float rangeMax = 0.0; // Exclude date above this + + if (stats->options & PS_STAT_USE_RANGE) { + rangeMin = stats->min; + rangeMax = stats->max; + if (maskVector != NULL) { + for (i = 0; i < myVector->n; i++) { + if (!(maskVal & maskVector->data.U8[i]) && + (rangeMin <= myVector->data.F32[i]) && (myVector->data.F32[i] <= rangeMax)) { + numData++; + } + } + } else { + for (i = 0; i < myVector->n; i++) { + if ((rangeMin <= myVector->data.F32[i]) && (myVector->data.F32[i] <= rangeMax)) { + numData++; + } + } + } + } else { + rangeMin = stats->min; + rangeMax = stats->max; + if (maskVector != NULL) { + for (i = 0; i < myVector->n; i++) { + if (!(maskVal & maskVector->data.U8[i])) { + numData++; + } + } + } else { + numData = myVector->n; + } + } + return (numData); +} + +/****************************************************************************** +p_psVectorSampleMedian(myVector, maskVector, maskVal, stats): calculates the +median of the input vector. +Inputs + myVector + maskVector + maskVal + stats +Returns + NULL + *****************************************************************************/ +void p_psVectorSampleMedian(const psVector* restrict myVector, + const psVector* restrict maskVector, unsigned int maskVal, psStats* stats) +{ + psVector* unsortedVector = NULL; // Temporary vector + psVector* sortedVector = NULL; // Temporary vector + int i = 0; // Loop index variable + int count = 0; // # of points in this mean? + int nValues = 0; // # of points in vector + float rangeMin = 0.0; // Exclude data below this + float rangeMax = 0.0; // Exclude date above this + + // Determine if the number of data points exceed a threshold which will + // cause to generate robust stats, as opposed to exact stats. + // XXX: This code is no longer used. We now calculate the median exactly + // regardless of the vector size. + /* + * if (myVector->n > stats->sampleLimit) { psAbort(__func__, "Robust Statistic Algorithms have not yet + * been defined or implemented."); + * + * // Calculate the robust quartiles. stats2 = psStatsAlloc(PS_STAT_ROBUST_MEDIAN); + * p_psVectorRobustStats(myVector, maskVector, maskVal, stats2); + * + * // Store the robust quartiles into the sample quartile members. stats->sampleMedian = + * stats2->robustMedian; + * + * // Free temporary data buffers. psFree(stats2); + * + * // Set the PS_STAT_ROBUST_FOR_SAMPLE bit in the stats structure. stats->options = stats->options | + * PS_STAT_ROBUST_FOR_SAMPLE; + * + * return; } */ + + // Determine how many data points fit inside this min/max range + // and are not masked, IF the maskVector is not NULL> + nValues = p_psVectorNValues(myVector, maskVector, maskVal, stats); + + // Allocate temporary vectors for the data. + unsortedVector = psVectorAlloc(nValues, PS_TYPE_F32); + unsortedVector->n = unsortedVector->nalloc; + + sortedVector = psVectorAlloc(nValues, PS_TYPE_F32); + sortedVector->n = sortedVector->nalloc; + + // Determine if we must only use data points within a min/max range. + if (stats->options & PS_STAT_USE_RANGE) { + rangeMin = stats->min; + rangeMax = stats->max; + + // Store all non-masked data points within the min/max range + // into the temporary vectors. + count = 0; + if (maskVector != NULL) { + for (i = 0; i < myVector->n; i++) { + if (!(maskVal & maskVector->data.U8[i]) && + (rangeMin <= myVector->data.F32[i]) && (myVector->data.F32[i] <= rangeMax)) { + unsortedVector->data.F32[count++] = maskVector->data.F32[i]; + } + } + } else { + for (i = 0; i < myVector->n; i++) { + if ((rangeMin <= myVector->data.F32[i]) && (myVector->data.F32[i] <= rangeMax)) { + unsortedVector->data.F32[count++] = myVector->data.F32[i]; + } + } + } + } else { + // Store all non-masked data points into the temporary vectors. + count = 0; + if (maskVector != NULL) { + for (i = 0; i < myVector->n; i++) { + if (!(maskVal & maskVector->data.U8[i])) { + unsortedVector->data.F32[count++] = myVector->data.F32[i]; + } + } + } else { + for (i = 0; i < myVector->n; i++) { + unsortedVector->data.F32[i] = myVector->data.F32[i]; + } + } + } + // Sort the temporary vectors. + psVectorSort(sortedVector, unsortedVector); + + // Calculate the median exactly. + // XXX: Is this the correct action? + if (0 == (nValues % 2)) { + stats->sampleMedian = 0.5 * (sortedVector->data.F32[(nValues / 2) - 1] + + sortedVector->data.F32[nValues / 2]); + } else { + stats->sampleMedian = sortedVector->data.F32[nValues / 2]; + } + + // Free the temporary data structures. + psFree(unsortedVector); + psFree(sortedVector); +} + +/****************************************************************************** + This routine smoothes the data in the input robustHistogram with a + Gaussian of width sigma. + + XXX: Must consult with IfA on the proper values for the Gaussian + smoothing. Currently, the Gaussian coefficients are such that only + the center coefficient is non-zero. This is because "e" is being + raised to a very large negative number for all points except the + center point. + + XXX: use a static variable for gaussianCoefs[] and compute them once. + *****************************************************************************/ +psVector* p_psVectorsmoothHistGaussian(psHistogram* robustHistogram, float sigma) +{ + int i = 0; // Loop index variable + int j = 0; // Loop index variable + float denom = 0.0; // Temporary variable + float expo = 0.0; // Temporary variable + float gaussianCoefs[1 + (2 * GAUSS_WIDTH)]; // The Gaussian Coefficients + psVector* smooth = psVectorAlloc(robustHistogram->nums->n, PS_TYPE_F32); + + for (i = 0; i < (1 + (2 * GAUSS_WIDTH)); i++) { + if (fabs(sigma) >= FLT_EPSILON) { + // If sigma does not equal zero, then we use Gaussian smoothing. + #ifdef DARWIN + denom = (float)sqrt(2.0 * M_PI * sigma * sigma); + #else + + denom = sqrtf(2.0 * M_PI * sigma * sigma); + #endif + + expo = -(float)((i - GAUSS_WIDTH) * (i - GAUSS_WIDTH)); + expo /= (2.0 * sigma * sigma); + gaussianCoefs[i] = exp(expo / denom); + + // NOTE: Gaussian smoothing just isn't working with low sigma + // values. The problem is that the Gaussian coefficients are + // all zero, except for the middle coefficient, which is exactly + // one. Therefore, I'm using boxcar smoothing. + gaussianCoefs[i] = 1.0 / (1.0 + (2.0 * (float)GAUSS_WIDTH)); + // printf("gaussianCoefs[%d] is %f\n", i, gaussianCoefs[i]); + } else { + /* If sigma equals zero (all pixels have the same value) the above code will divide by zero. + * Therefore, we don't need to smooth the data. */ + for (i = 0; i < robustHistogram->nums->n; i++) { + smooth->data.F32[i] = (float)robustHistogram->nums->data.S32[i]; + } + return (smooth); + } + } + + // Perform the actual smoothing. + for (i = 0; i < robustHistogram->nums->n; i++) { + smooth->data.F32[i] = 0.0; + for (j = -GAUSS_WIDTH; j <= +GAUSS_WIDTH; j++) { + if (((j + i) >= 0) && ((j + i) < smooth->n)) { + smooth->data.F32[i] += (gaussianCoefs[j + GAUSS_WIDTH] * + (float)robustHistogram->nums->data.S32[j + i]); + } + } + } + return (smooth); +} + +/****************************************************************************** +p_psVectorSampleQuartiles(myVector, maskVector, maskVal, stats): calculates +the upper and/or lower quartiles of the input vector. +Inputs + myVector + maskVector + maskVal + stats +Returns + NULL + *****************************************************************************/ +void p_psVectorSampleQuartiles(const psVector* restrict myVector, + const psVector* restrict maskVector, unsigned int maskVal, psStats* stats) +{ + psVector* unsortedVector = NULL; // Temporary vector + psVector* sortedVector = NULL; // Temporary vector + int i = 0; // Loop index variable + int count = 0; // # of points in this mean? + int nValues = 0; // # data points + float rangeMin = 0.0; // Exclude data below this + float rangeMax = 0.0; // Exclude date above this + + // Determine how many data points fit inside this min/max range + // and are not maxed, IF the maskVector is not NULL> + nValues = p_psVectorNValues(myVector, maskVector, maskVal, stats); + + // Allocate temporary vectors for the data. + unsortedVector = psVectorAlloc(nValues, PS_TYPE_F32); + unsortedVector->n = unsortedVector->nalloc; + sortedVector = psVectorAlloc(nValues, PS_TYPE_F32); + sortedVector->n = sortedVector->nalloc; + + // Determine if we must only use data points within a min/max range. + if (stats->options & PS_STAT_USE_RANGE) { + rangeMin = stats->min; + rangeMax = stats->max; + // Store all non-masked data points within the min/max range + // into the temporary vectors. + count = 0; + if (maskVector != NULL) { + for (i = 0; i < myVector->n; i++) { + if (!(maskVal & maskVector->data.U8[i]) && + (rangeMin <= myVector->data.F32[i]) && (myVector->data.F32[i] <= rangeMax)) { + unsortedVector->data.F32[count++] = myVector->data.F32[i]; + } + } + } else { + for (i = 0; i < myVector->n; i++) { + if ((rangeMin <= myVector->data.F32[i]) && (myVector->data.F32[i] <= rangeMax)) { + unsortedVector->data.F32[count++] = myVector->data.F32[i]; + } + } + } + } else { + // Store all non-masked data points into the temporary vectors. + count = 0; + if (maskVector != NULL) { + for (i = 0; i < myVector->n; i++) { + if (!(maskVal & maskVector->data.U8[i])) { + unsortedVector->data.F32[count++] = myVector->data.F32[i]; + } + } + } else { + for (i = 0; i < myVector->n; i++) { + unsortedVector->data.F32[i] = myVector->data.F32[i]; + } + } + } + + // Sort the temporary vectors. + psVectorSort(sortedVector, unsortedVector); + + // Calculate the quartile points exactly. + stats->sampleUQ = sortedVector->data.F32[3 * (nValues / 4)]; + stats->sampleLQ = sortedVector->data.F32[nValues / 4]; + + // Free the temporary data structures. + psFree(unsortedVector); + psFree(sortedVector); +} + +/****************************************************************************** +p_psVectorSampleStdev(myVector, maskVector, maskVal, stats): calculates the +stdev of the input vector. +Inputs + myVector + maskVector + maskVal + stats +Returns + NULL + + *****************************************************************************/ +void p_psVectorSampleStdev(const psVector* restrict myVector, + const psVector* restrict maskVector, unsigned int maskVal, psStats* stats) +{ + int i = 0; // Loop index variable + int countInt = 0; // # of data points being used + float countFloat = 0.0; // # of data points being used + float mean = 0.0; // The mean + float diff = 0.0; // Used in calculating stdev + float sumSquares = 0.0; // temporary variable + float sumDiffs = 0.0; // temporary variable + float rangeMin = 0.0; // Exclude data below this + float rangeMax = 0.0; // Exclude date above this + + // This procedure requires the mean. If it has not been already + // calculated, then call p_psVectorSampleMean() + if (0 != isnan(stats->sampleMean)) { + p_psVectorSampleMean(myVector, maskVector, maskVal, stats); + } + mean = stats->sampleMean; + + if (stats->options & PS_STAT_USE_RANGE) { + if (maskVector != NULL) { + for (i = 0; i < myVector->n; i++) { + if (!(maskVal & maskVector->data.U8[i]) && + (rangeMin <= myVector->data.F32[i]) && (myVector->data.F32[i] <= rangeMax)) { + diff = myVector->data.F32[i] - mean; + sumSquares += (diff * diff); + sumDiffs += diff; + countInt++; + } + } + } else { + for (i = 0; i < myVector->n; i++) { + if ((rangeMin <= myVector->data.F32[i]) && (myVector->data.F32[i] <= rangeMax)) { + diff = myVector->data.F32[i] - mean; + sumSquares += (diff * diff); + sumDiffs += diff; + countInt++; + } + } + countInt = myVector->n; + } + } else { + if (maskVector != NULL) { + for (i = 0; i < myVector->n; i++) { + if (!(maskVal & maskVector->data.U8[i])) { + diff = myVector->data.F32[i] - mean; + sumSquares += (diff * diff); + sumDiffs += diff; + countInt++; + } + } + } else { + for (i = 0; i < myVector->n; i++) { + diff = myVector->data.F32[i] - mean; + sumSquares += (diff * diff); + sumDiffs += diff; + countInt++; + } + countInt = myVector->n; + } + } + countFloat = (float)countInt; + + #ifdef DARWIN + + stats->sampleStdev = (float)sqrt((sumSquares - (sumDiffs * sumDiffs / countFloat)) / (countFloat - 1)); + #else + + stats->sampleStdev = sqrtf((sumSquares - (sumDiffs * sumDiffs / countFloat)) / (countFloat - 1)); + #endif +} + +/****************************************************************************** +p_psVectorClippedStats(myVector, maskVector, maskVal, stats): calculates the +clipped stats (mean or stdev) of the input vector. + +Inputs + myVector + maskVector + maskVal + stats +Returns + NULL + *****************************************************************************/ +void p_psVectorClippedStats(const psVector* restrict myVector, + const psVector* restrict maskVector, unsigned int maskVal, psStats* stats) +{ + int i = 0; // Loop index variable + int j = 0; // Loop index variable + float clippedMean = 0.0; // self-explanatory + float clippedStdev = 0.0; // self-explanatory + float oldStanMean = 0.0; // Temporary variable + float oldStanStdev = 0.0; // Temporary variable + psVector* tmpMask = NULL; // Temporary vector + + // Endure that stats->clipIter is within the proper range. + if (!((CLIPPED_NUM_ITER_LB <= stats->clipIter) && (stats->clipIter <= CLIPPED_NUM_ITER_UB))) { + psAbort(__func__, "Unallowed value for clipIter (%d).\n", stats->clipIter); + } + // Endure that stats->clipSigma is within the proper range. + if (!((CLIPPED_SIGMA_LB <= stats->clipSigma) && (stats->clipSigma <= CLIPPED_SIGMA_UB))) { + psAbort(__func__, "Unallowed value for clipSigma (%f).\n", stats->clipSigma); + } + // We allocate a temporary mask vector since during the iterative + // steps that follow, we will be masking off additional data points. + // However, we do no want to modify the original mask vector. + tmpMask = psVectorAlloc(myVector->n, PS_TYPE_U8); + tmpMask->n = myVector->n; + + // If we were called with a mask vector, then initialize the temporary + // mask vector with those values. + if (maskVector != NULL) { + for (i = 0; i < tmpMask->n; i++) { + tmpMask->data.U8[i] = maskVector->data.U8[i]; + } + } + // 1. Compute the sample median. + // NOTE: This seems odd. Verify with IfA that we want to calculate the + // median here, not the mean. + p_psVectorSampleMedian(myVector, maskVector, maskVal, stats); + + // 2. Compute the sample standard deviation. + p_psVectorSampleStdev(myVector, maskVector, maskVal, stats); + + // 3. Use the sample median as the first estimator of the mean X. + clippedMean = stats->sampleMean; + + // 4. Use the sample stdev as the first estimator of the mean stdev. + clippedStdev = stats->sampleStdev; + + // Must save the old sampleMean and sampleStdev since the following code + // block overwrites them. + oldStanMean = stats->sampleMean; + oldStanStdev = stats->sampleStdev; + + // 5. Repeat N times: + for (i = 0; i < stats->clipIter; i++) { + for (j = 0; j < myVector->n; j++) { + // a) Exclude all values x_i for which |x_i - x| > K * stdev + if (fabs(myVector->data.F32[j] - clippedMean) > (stats->clipSigma * clippedStdev)) { + tmpMask->data.U8[i] = 0xff; + } + // b) compute new mean and stdev + p_psVectorSampleMedian(myVector, tmpMask, maskVal, stats); + p_psVectorSampleStdev(myVector, tmpMask, maskVal, stats); + + // c) Use the new mean for x + clippedMean = stats->sampleMean; + + // d) Use the new stdev for stdev + clippedStdev = stats->sampleStdev; + } + + } + stats->sampleMean = oldStanMean; + stats->sampleStdev = oldStanStdev; + + // 7. The last calcuated value of x is the cliped mean. + if (stats->options & PS_STAT_CLIPPED_MEAN) { + stats->clippedMean = clippedMean; + } + // 8. The last calcuated value of stdev is the cliped stdev. + if (stats->options & PS_STAT_CLIPPED_STDEV) { + stats->clippedStdev = clippedStdev; + } + + psFree(tmpMask); +} + +/***************************************************************************** +p_psNormalizeVector(myData): this is a private function which normalizes the +elements of a vector to a range between 0.0 and 1.0. + *****************************************************************************/ +void p_psNormalizeVector(psVector* myData) +{ + float min = (float)HUGE; + float max = (float)-HUGE; + float range = 0.0; + int i = 0; + + for (i = 0; i < myData->n; i++) { + if (myData->data.F32[i] < min) { + min = myData->data.F32[i]; + } + if (myData->data.F32[i] > max) { + max = myData->data.F32[i]; + } + } + + range = max - min; + for (i = 0; i < myData->n; i++) { + myData->data.F32[i] = (myData->data.F32[i] - min) / range; + } +} + +/***************************************************************************** +p_psGaussian(myData, myParams): an internal function, used by robust stats, +intended to compute the Gaussian with a specified sigma/mean, at the +specified data point. + *****************************************************************************/ +float p_psGaussian(const psVector* restrict myData, const psVector* restrict myParams) +{ + float x = myData->data.F32[0]; + float mean = myParams->data.F32[0]; + float stdev = myParams->data.F32[1]; + float tmp = exp(-((x - mean) * (x - mean)) / (2.0 * stdev * stdev)); + + tmp /= ((float)sqrt(2.0 * M_PI * (stdev * stdev))); + + // printf("p_psGaussian((%.2f), %.2f, %.2f) is %.2f\n", x, mean, stdev, tmp); + return (tmp); +} + +/***************************************************************************** +p_psGaussianDeriv(myData, myParams, whichParam): an internal function, which +calculates the specified partial derivative of the above Gaussian function. + *****************************************************************************/ +float p_psGaussianDeriv(const psVector* restrict myData, const psVector* restrict myParams, int whichParam) +{ + float x = myData->data.F32[0]; + float mean = myParams->data.F32[0]; + float stdev = myParams->data.F32[1]; + float tmp = 0.0; + + if (whichParam == 0) { + // Return the derivative w.r.t. the mean. + tmp = (x - mean) * p_psGaussian(myData, myParams); + tmp /= (stdev * stdev); + } else if (whichParam == 1) { + // Return the derivative w.r.t. the stdev. + tmp = (x - mean) * (x - mean) * p_psGaussian(myData, myParams); + tmp /= (stdev * stdev * stdev); + } + printf("p_psGaussianDeriv((%.2f), %.2f, %.2f, (%d)) is %.2f\n", x, mean, stdev, whichParam, tmp); + + return (tmp); +} + +/***************************************************************************** +p_psQuadratic(myData, myParams): an internal function, used by robust stats, +intended to compute a quadratic, with the specified parameters, at the +specified data point. + *****************************************************************************/ +float p_psQuadratic(const psVector* restrict myParams, const psVector* restrict myCoords) +{ + float x = myCoords->data.F32[0]; + float A = myParams->data.F32[0]; + float B = myParams->data.F32[1]; + float C = myParams->data.F32[2]; + float tmp = 0.0; + + tmp = (A * x * x) + (B * x) + C; + return (tmp); +} + +/***************************************************************************** +p_psQuadraticDeriv(myData, myParams, whichParam): an internal function, which +calculates the specified partial derivative of the above quadratic function. + *****************************************************************************/ +float p_psQuadraticDeriv(const psVector* restrict myParams, + const psVector* restrict myCoords, int whichParamDeriv) +{ + float x = myCoords->data.F32[0]; + float tmp = 0.0; + + if (whichParamDeriv == 0) { + tmp = x * x; + } else if (whichParamDeriv == 1) { + tmp = x; + } else if (whichParamDeriv == 2) { + tmp = 1.0; + } + + return (tmp); +} + +/****************************************************************************** +p_ps1DPolyMedian(myPoly, rangeLow, rangeHigh, midpoint): This routine takes +as input a 1-D polynomial of arbitrary order (though we are using 2nd-order +polynomials here) and a range of x-values for which it is defined: +[rangeLow, rangeHigh]. It determines the x-value of that polynomial such +that f(x) == midpoint. This functions uses a binary-search algorithm on the +range and assumes that the polynomial is monotonically increasing or +decreasing within that range. + *****************************************************************************/ +float p_ps1DPolyMedian(psPolynomial1D* myPoly, float rangeLow, float rangeHigh, float getThisValue) +{ + int numIterations = 0; + float midpoint = 0.0; + float oldMidpoint = 1.0; + float f = 0.0; + + // printf("p_ps1DPolyMedian(%f, %f, %f) \n", rangeLow, rangeHigh, getThisValue); + + while (numIterations < MAX_ITERATIONS) { + midpoint = (rangeHigh + rangeLow) / 2.0; + if (fabs(midpoint - oldMidpoint) <= FLT_EPSILON) { + return (midpoint); + } + oldMidpoint = midpoint; + + f = psPolynomial1DEval(midpoint, myPoly); + // printf("p_ps1DPolyMedian() iteration %d. f(%f) is %f\n", numIterations, midpoint, f); + if (fabs(f - getThisValue) <= FLT_EPSILON) { + return (midpoint); + } + + if (f > getThisValue) { + rangeHigh = midpoint; + } else { + rangeLow = midpoint; + } + numIterations++; + } + return (midpoint); +} + +/****************************************************************************** +p_psFitQuadratic(robustHistogram. cumulativeSums, binNum, fitFloat): given +the specified histogram, with the specified pre-calculated cumulativeSums, +this routine fits a quadratic f(x) to the 3 bins surrounding bin "binNum", +and then finds the point x such that f(x) == fitFloat. + +XXX: This function is currently not being used. + *****************************************************************************/ +float p_psFitQuadratic(psHistogram* histogram, psVector* cumulativeSums, int binNum, float fitFloat) +{ + psVector* x = psVectorAlloc(3, PS_TYPE_F64); + psVector* y = psVectorAlloc(3, PS_TYPE_F64); + psVector* yErr = psVectorAlloc(3, PS_TYPE_F64); + psPolynomial1D* myPoly = psPolynomial1DAlloc(2); + + if ((binNum > 0) && (binNum < (histogram->nums->n + 1))) { + x->data.F64[0] = (double)0.5 * + (histogram->bounds->data.F32[binNum - 1] + histogram->bounds->data.F32[binNum]); + x->data.F64[1] = (double)0.5 * + (histogram->bounds->data.F32[binNum] + histogram->bounds->data.F32[binNum + 1]); + x->data.F64[2] = (double)0.5 * + (histogram->bounds->data.F32[binNum + 1] + histogram->bounds->data.F32[binNum + 2]); + + y->data.F64[0] = cumulativeSums->data.F32[binNum - 1]; + y->data.F64[1] = cumulativeSums->data.F32[binNum]; + y->data.F64[2] = cumulativeSums->data.F32[binNum + 1]; + + if (!((y->data.F64[0] <= fitFloat) && (fitFloat <= y->data.F64[2]))) { + psAbort(__func__, "p_psVectorRobustStats(0): midpoint not within y-range\n"); + } + + yErr->data.F64[0] = 1.0; + yErr->data.F64[1] = 1.0; + yErr->data.F64[2] = 1.0; + + myPoly = psVectorFitPolynomial1D(myPoly, x, y, yErr); + return (p_ps1DPolyMedian(myPoly, x->data.F64[0], x->data.F64[2], fitFloat)); + } else { + return (0.5 * (histogram->bounds->data.F32[binNum + 1] + histogram->bounds->data.F32[binNum])); + } + + psFree(x); + psFree(y); + psFree(yErr); + psFree(myPoly); + return (0.0); +} + +/****************************************************************************** +p_psVectorRobustStats(myVector, maskVector, maskVal, stats): this procedure +calculates a variety of robust stat measures: + PS_STAT_ROBUST_MEAN + PS_STAT_ROBUST_MEDIAN + PS_STAT_ROBUST_MODE + PS_STAT_ROBUST_STDEV + PS_STAT_ROBUST_QUARTILE +I have included all that computation in a single function, as opposed to +breaking it across several functions for one primary reason: they all +require the same basic initial processing steps (calculate the histogram, +etc.) however there is no currently defined means, in the SDRS, to specify +this computation as a separate step. If the above robust stat measures were +calcualted in separate functiosn, then much of the initial processing would +be duplicated. + +Inputs + myVector + maskVector + maskVal + stats +Returns + NULL +*****************************************************************************/ +void p_psVectorRobustStats(const psVector* restrict myVector, + const psVector* restrict maskVector, unsigned int maskVal, psStats* stats) +{ + psHistogram* robustHistogram = NULL; + psVector* robustHistogramVector = NULL; + float binSize = 0.0; // Size of the histogram bins + int LQBinNum = -1; // Bin num for lower quartile + int UQBinNum = -1; // Bin num for upper quartile + int i = 0; // Loop index variable + int maxBinNum = 0; + float maxBinCount = 0.0; + float dL = 0.0; + int numBins = 0; + psStats* tmpStats = psStatsAlloc(PS_STAT_CLIPPED_STDEV | PS_STAT_CLIPPED_MEAN); + + // psImage* domain; + // psVector* errors; + // psVector* data; + // psVector* initialGuess; + // psVector* theParams; + // float chiSq=0.0; + // float max = -HUGE; + // float max_pos; + float myMean = 0.0; + float myStdev = 0.0; + float countFloat = 0.0; + float diff = 0.0; + float sumSquares = 0.0; + float sumDiffs = 0.0; + psVector* x = psVectorAlloc(3, PS_TYPE_F64); + psVector* y = psVectorAlloc(3, PS_TYPE_F64); + psVector* yErr = psVectorAlloc(3, PS_TYPE_F64); + psPolynomial1D* myPoly = psPolynomial1DAlloc(2); + psVector* cumulativeRobustSumsFullRange = NULL; + psVector* cumulativeRobustSumsDlRange = NULL; + float sumRobust = 0.0; + float sumN50 = 0.0; + float sumNfit = 0.0; + float cumulativeMedian = 0.0; + + // Compute the initial bin size of the robust histogram. This is done + // by computing the clipped standard deviation of the vector, and dividing + // that by 10.0; + p_psVectorClippedStats(myVector, maskVector, maskVal, tmpStats); + binSize = tmpStats->clippedStdev / 10.0f; + + // If stats->clippedStdev == 0.0, then all data elements have the same + // value. Therefore, we can set the appropiate results and return. + if (fabs(binSize) <= FLT_EPSILON) { + if (stats->options & PS_STAT_ROBUST_MEAN) { + stats->robustMean = stats->clippedMean; + } + if (stats->options & PS_STAT_ROBUST_MEDIAN) { + stats->robustMedian = stats->clippedMean; + } + if (stats->options & PS_STAT_ROBUST_MODE) { + stats->robustMode = stats->clippedMean; + } + if (stats->options & PS_STAT_ROBUST_STDEV) { + stats->robustStdev = 0.0; + } + if (stats->options & PS_STAT_ROBUST_QUARTILE) { + stats->robustUQ = stats->clippedMean; + stats->robustLQ = stats->clippedMean; + } + // XXX: Set these to the number of unmasked data points? + stats->robustNfit = 0.0; + stats->robustN50 = 0.0; + psFree(tmpStats); + return; + } + // Determine minimum and maximum values in the data vector. + if (isnan(stats->min)) { + p_psVectorMin(myVector, maskVector, maskVal, stats); + } + if (isnan(stats->max)) { + p_psVectorMax(myVector, maskVector, maskVal, stats); + } + // Create the histogram structure. NOTE: we can not specify the bin size + // precisely since the argument to psHistogramAlloc() is the number of + // bins, not the binSize. Also, if we get here, we know that + // binSize != 0.0. + numBins = (int)((stats->max - stats->min) / binSize); + robustHistogram = psHistogramAlloc(stats->min, stats->max, numBins); + + // Populate the histogram array. + psVectorHistogram(robustHistogram, myVector, maskVector, maskVal); + + // Smooth the histogram. + // XXX: is that the right stdev? + robustHistogramVector = p_psVectorsmoothHistGaussian(robustHistogram, tmpStats->clippedStdev / 4.0f); + + // The following was necessary to fit a gaussian to the data, since + // gaussian functions produce data between 0.0 and 1.0. + // p_psNormalizeVector(robustHistogramVector); + + /************************************************************************** + Determine the lower/upper quartiles. + **************************************************************************/ + // We define a vector called "cumulativeRobustSums..." where the value at + // index position i is equal to the sum of bins 0:i. This will be used + // now and later in determining the lower/upper quartiles. + cumulativeRobustSumsFullRange = psVectorAlloc(robustHistogramVector->n, PS_TYPE_F32); + cumulativeRobustSumsFullRange->data.F32[0] = robustHistogramVector->data.F32[0]; + for (i = 1; i < robustHistogramVector->n; i++) { + cumulativeRobustSumsFullRange->data.F32[i] = + cumulativeRobustSumsFullRange->data.F32[i - 1] + robustHistogramVector->data.F32[i]; + } + sumRobust = cumulativeRobustSumsFullRange->data.F32[robustHistogramVector->n - 1]; + + // Determine the bin number containing the lower quartile point. + LQBinNum = -1; + for (i = 0; i < cumulativeRobustSumsFullRange->n; i++) { + if (cumulativeRobustSumsFullRange->data.F32[i] >= (sumRobust / 4.0)) { + LQBinNum = i; + break; + } + } + + // Determine the bin number containing the upper quartile point. + UQBinNum = -1; + for (i = cumulativeRobustSumsFullRange->n - 1; i >= 0; i--) { + if (cumulativeRobustSumsFullRange->data.F32[i] <= (3.0 * sumRobust / 4.0)) { + UQBinNum = i; + break; + } + } + + if ((LQBinNum == -1) || (UQBinNum == -1)) { + psAbort(__func__, "Could not determine the robust lower/upper quartiles."); + } + + /************************************************************************** + Determine the mode in the range LQ:UQ. + **************************************************************************/ + // Determine the bin with the peak value in the range LQ to UQ. + maxBinNum = LQBinNum; + maxBinCount = robustHistogramVector->data.F32[LQBinNum]; + sumN50 = (float)robustHistogram->nums->data.S32[LQBinNum]; + for (i = LQBinNum + 1; i <= UQBinNum; i++) { + if (robustHistogramVector->data.F32[i] > maxBinCount) { + maxBinNum = i; + maxBinCount = robustHistogramVector->data.F32[i]; + } + sumN50 += (float)robustHistogram->nums->data.S32[i]; + } + + // XXX: is dL defined as the value at the LQ/UQ, or the bin number? + dL = (UQBinNum - LQBinNum) / 4; + + printf("(LQBinNum, UQBinNum, maxBinNum) is (%d, %d, %d)\n", LQBinNum, UQBinNum, maxBinNum); + + /************************************************************************** + Determine the mean/stdev for the bins in the range mode-dL to mode+dL + **************************************************************************/ + cumulativeRobustSumsDlRange = psVectorAlloc(robustHistogramVector->n, PS_TYPE_F32); + for (i = 0; i < robustHistogramVector->n; i++) { + cumulativeRobustSumsDlRange->data.F32[i] = 0.0; + } + sumNfit = 0.0; + cumulativeMedian = 0.0; + for (i = maxBinNum - dL; i <= maxBinNum + dL; i++) { + if ((0 <= i) && (i < robustHistogramVector->n)) { + cumulativeRobustSumsDlRange->data.F32[i] = + cumulativeRobustSumsDlRange->data.F32[i - 1] + robustHistogramVector->data.F32[i]; + cumulativeMedian += robustHistogramVector->data.F32[i]; + sumNfit += (float)robustHistogram->nums->data.S32[i]; + } + } + + // Calculate the mean of the smoothed robust histogram in the range + // mode-dL to mode+dL. We use the midpoint of each bin as the mean for + // that bin (this is a non-exact approximation). + myMean = 0.0; + for (i = maxBinNum - dL; i <= maxBinNum + dL; i++) { + if ((0 <= i) && (i < robustHistogramVector->n)) { + myMean += (robustHistogramVector->data.F32[i]) * 0.5 * + (robustHistogram->bounds->data.F32[i + 1] + robustHistogram->bounds->data.F32[i]); + countFloat += robustHistogramVector->data.F32[i]; + } + } + myMean /= countFloat; + + // Calculate the stdev of the smoothed robust histogram in the range + // mode-dL to mode+dL. We use the midpoint of each bin as the mean for + // that bin. + for (i = maxBinNum - dL; i <= maxBinNum + dL; i++) { + if ((0 <= i) && (i < robustHistogramVector->n)) { + diff = (0.5 * (robustHistogram->bounds->data.F32[i + 1] + + robustHistogram->bounds->data.F32[i])) - myMean; + sumSquares += diff * diff * robustHistogramVector->data.F32[i]; + sumDiffs += diff * robustHistogramVector->data.F32[i]; + } + } + myStdev = sqrt((sumSquares - (sumDiffs * sumDiffs / countFloat)) / (countFloat - 1)); + + /************************************************************************** + Set the appropriate members in the output stats struct. + **************************************************************************/ + if (stats->options & PS_STAT_ROBUST_MEAN) { + stats->robustMean = myMean; + } + + if (stats->options & PS_STAT_ROBUST_MODE) { + stats->robustMode = 0.5 * + (robustHistogram->bounds->data.F32[maxBinNum] + robustHistogram->bounds->data.F32[maxBinNum + 1]); + } + + if (stats->options & PS_STAT_ROBUST_STDEV) { + stats->robustStdev = myStdev; + } + // To determine the median (and later, the lower/upper quartile), we fit + // a quadratic to the three bins surrounding the bin containing the median. + // The quadratic y=f(x) with x being the midpoint of each bin, and y being + // the cumulative number of data points in all bins up to, and including, + // this bin. We then solve the quadratic for + + if (stats->options & PS_STAT_ROBUST_MEDIAN) { + if ((maxBinNum > 0) && (maxBinNum < (robustHistogram->nums->n - 1))) { + x->data.F64[0] = (double)0.5 * + (robustHistogram->bounds->data.F32[maxBinNum - 1] + + robustHistogram->bounds->data.F32[maxBinNum]); + x->data.F64[1] = (double)0.5 * + (robustHistogram->bounds->data.F32[maxBinNum] + + robustHistogram->bounds->data.F32[maxBinNum + 1]); + x->data.F64[2] = (double)0.5 * + (robustHistogram->bounds->data.F32[maxBinNum + 1] + + robustHistogram->bounds->data.F32[maxBinNum + 2]); + + y->data.F64[0] = cumulativeRobustSumsDlRange->data.F32[maxBinNum - 1]; + y->data.F64[1] = cumulativeRobustSumsDlRange->data.F32[maxBinNum]; + y->data.F64[2] = cumulativeRobustSumsDlRange->data.F32[maxBinNum + 1]; + + // Ensure that cumulativeMedian/2 is actually within the range of the bins + // we are using. + cumulativeMedian *= 0.5; + if (!((y->data.F64[0] <= cumulativeMedian) && (cumulativeMedian <= y->data.F64[2]))) { + printf("((%f), %f, %f)\n", cumulativeMedian, y->data.F64[0], y->data.F64[2]); + psAbort(__func__, "p_psVectorRobustStats(1): midpoint not within y-range\n"); + } + // XXX: yErr is not currently used by psVectorFitPolynomial1D(). We + // may have to set this meaningfully later. + yErr->data.F64[0] = 1.0; + yErr->data.F64[1] = 1.0; + yErr->data.F64[2] = 1.0; + + // Determine the coefficients of the polynomial. + myPoly = psVectorFitPolynomial1D(myPoly, x, y, yErr); + // Call p_ps1DPolyMedian(), which does a binary search on the + // polynomial, looking for the value x such that + // f(x) = cumulativeMedian. + stats->robustMedian = p_ps1DPolyMedian(myPoly, x->data.F64[0], x->data.F64[2], cumulativeMedian); + } else { + // If the mode is the first/last histogram bin, then simply use + // the midpoint of that bin. + stats->robustMedian = 0.5 * (robustHistogram->bounds->data.F32[maxBinNum + 1] + + robustHistogram->bounds->data.F32[maxBinNum]); + } + } + // The lower/upper quartile calculations are very similar to the median + // calculations. We fit a quadratic to the array containing the + // cumulative data points in each bin, then search for x such that + // f(x) equals the lower/upper quartile exactly. + // + if (stats->options & PS_STAT_ROBUST_QUARTILE) { + countFloat = cumulativeRobustSumsFullRange->data.F32[robustHistogramVector->n - 1]; + + if ((LQBinNum > 0) && (LQBinNum < (robustHistogram->nums->n - 1))) { + x->data.F64[0] = (double)0.5 * + (robustHistogram->bounds->data.F32[LQBinNum - 1] + + robustHistogram->bounds->data.F32[LQBinNum]); + x->data.F64[1] = (double)0.5 * + (robustHistogram->bounds->data.F32[LQBinNum] + + robustHistogram->bounds->data.F32[LQBinNum + 1]); + x->data.F64[2] = (double)0.5 * + (robustHistogram->bounds->data.F32[LQBinNum + 1] + + robustHistogram->bounds->data.F32[LQBinNum + 2]); + + y->data.F64[0] = cumulativeRobustSumsFullRange->data.F32[LQBinNum - 1]; + y->data.F64[1] = cumulativeRobustSumsFullRange->data.F32[LQBinNum]; + y->data.F64[2] = cumulativeRobustSumsFullRange->data.F32[LQBinNum + 1]; + + if (!((y->data.F64[0] <= (countFloat / 4.0)) && ((countFloat / 4.0) <= y->data.F64[2]))) { + psAbort(__func__, "p_psVectorRobustStats(2): midpoint not within y-range\n"); + } + + yErr->data.F64[0] = 1.0; + yErr->data.F64[1] = 1.0; + yErr->data.F64[2] = 1.0; + + myPoly = psVectorFitPolynomial1D(myPoly, x, y, yErr); + stats->robustLQ = p_ps1DPolyMedian(myPoly, x->data.F64[0], x->data.F64[2], countFloat / 4.0); + + } else { + // If the LQ is the first/last histogram bin, then simply use + // the midpoint of that bin. + stats->robustLQ = 0.5 * (robustHistogram->bounds->data.F32[LQBinNum + 1] + + robustHistogram->bounds->data.F32[LQBinNum]); + } + + if ((UQBinNum > 0) && (UQBinNum < (robustHistogram->nums->n - 1))) { + x->data.F64[0] = (double)0.5 * + (robustHistogram->bounds->data.F32[UQBinNum - 1] + + robustHistogram->bounds->data.F32[UQBinNum]); + x->data.F64[1] = (double)0.5 * + (robustHistogram->bounds->data.F32[UQBinNum] + + robustHistogram->bounds->data.F32[UQBinNum + 1]); + x->data.F64[2] = (double)0.5 * + (robustHistogram->bounds->data.F32[UQBinNum + 1] + + robustHistogram->bounds->data.F32[UQBinNum + 2]); + + y->data.F64[0] = cumulativeRobustSumsFullRange->data.F32[UQBinNum - 1]; + y->data.F64[1] = cumulativeRobustSumsFullRange->data.F32[UQBinNum]; + y->data.F64[2] = cumulativeRobustSumsFullRange->data.F32[UQBinNum + 1]; + + if (!((y->data.F64[0] <= (3.0 * countFloat / 4.0)) && + ((3.0 * countFloat / 4.0) <= y->data.F64[2]))) { + psAbort(__func__, "p_psVectorRobustStats(3): midpoint not within y-range\n"); + } + + yErr->data.F64[0] = 1.0; + yErr->data.F64[1] = 1.0; + yErr->data.F64[2] = 1.0; + + myPoly = psVectorFitPolynomial1D(myPoly, x, y, yErr); + stats->robustUQ = p_ps1DPolyMedian(myPoly, + x->data.F64[0], x->data.F64[2], 3.0 * countFloat / 4.0); + } else { + // If the UQ is the first/last histogram bin, then simply use + // the midpoint of that bin. + stats->robustUQ = 0.5 * (robustHistogram->bounds->data.F32[UQBinNum + 1] + + robustHistogram->bounds->data.F32[UQBinNum]); + } + } + stats->robustNfit = sumNfit; + stats->robustN50 = sumN50; + + psFree(x); + psFree(y); + psFree(yErr); + psFree(tmpStats); + psFree(robustHistogram); + psFree(myPoly); + psFree(cumulativeRobustSumsFullRange); + psFree(cumulativeRobustSumsDlRange); +} + +/* +void p_ps_FitTheGaussian() +{ + + // Fit a Gaussian to the bins in the range MODE-dL to Mode+dL + // NOTE: This code uses the psMinimize.c functions to perform + // the fit. It doesn't quite work, 100% of the time. For the time being + // I am commenting this code out, and replacing it with code which + // calculates the mean directly on the robustHistogram. + + domain = psImageAlloc(1, robustHistogramVector->n, PS_TYPE_F32); + errors = psVectorAlloc(robustHistogramVector->n, PS_TYPE_F32); + data = psVectorAlloc(robustHistogramVector->n, PS_TYPE_F32); + initialGuess = psVectorAlloc(2, PS_TYPE_F32); + + max = -HUGE; + max_pos = -1; + for (i=0;in;i++) { + domain->data.F32[i][0] = 0.5 * (robustHistogram->bounds->data.F32[i+1] + + robustHistogram->bounds->data.F32[i]); + data->data.F32[i] = (float) robustHistogramVector->data.F32[i]; + errors->data.F32[i] = 1.0; + //printf("DATA (%.2f, %.2f)\n", domain->data.F32[i][0], data->data.F32[i]); + if (data->data.F32[i] > max) { + max = data->data.F32[i]; + max_pos = domain->data.F32[i][0]; + } + } + + initialGuess->data.F32[0] = max_pos; + initialGuess->data.F32[1] = 1.0; + printf("Initial (mean. stdev) is (%.3f, %.3f)\n", initialGuess->data.F32[0], initialGuess->data.F32[1]); + + printf("Calling psMinimizeChi2()\n"); + theParams = psMinimizeChi2(p_psGaussian, + p_psGaussianDeriv, + domain, + data, + errors, + initialGuess, + NULL, + &chiSq); + printf("Called psMinimizeChi2()\n"); + printf("p_psVectorRobustStats() is (%f, %f)\n", theParams->data.F32[0], theParams->data.F32[1]); +} +*/ + +/*****************************************************************************/ + +/* FUNCTION IMPLEMENTATION - PUBLIC */ + +/*****************************************************************************/ + +static void histogramFree(psHistogram* myHist); + +/****************************************************************************** + psStatsAlloc(): This routine must create a new psStats data structure. + *****************************************************************************/ +psStats* psStatsAlloc(psStatsOptions options) +{ + psStats* newStruct = NULL; + + newStruct = (psStats* ) psAlloc(sizeof(psStats)); + newStruct->sampleMean = NAN; + newStruct->sampleMedian = NAN; + newStruct->sampleStdev = NAN; + newStruct->sampleUQ = NAN; + newStruct->sampleLQ = NAN; + newStruct->sampleLimit = 30000; + newStruct->robustMean = NAN; + newStruct->robustMedian = NAN; + newStruct->robustMode = NAN; + newStruct->robustStdev = NAN; + newStruct->robustUQ = NAN; + newStruct->robustLQ = NAN; + newStruct->robustN50 = NAN; + newStruct->robustNfit = NAN; + newStruct->clippedMean = NAN; + newStruct->clippedStdev = NAN; + newStruct->clipSigma = 3.0; + newStruct->clipIter = 3.0; + newStruct->min = NAN; + newStruct->max = NAN; + newStruct->binsize = NAN; + newStruct->options = options; + + return (newStruct); +} + +/****************************************************************************** +psHistogramAlloc(lower, upper, n): allocate a uniform histogram structure +with the specifed upper and lower limits, and the specifed number of bins. +This routine will also set the bounds for each of the bins. + +Input: + lower + upper + n +Returns: + The histogram structure + *****************************************************************************/ +psHistogram* psHistogramAlloc(float lower, float upper, int n) +{ + int i = 0; // Loop index variable + psHistogram* newHist = NULL; // The new histogram structure + float binSize = 0.0; // The histogram bin size + + // NOTE: Verify that this is the correct action. + if (n == 0) { + return (NULL); + } + if (n < 0) { + psAbort(__func__, "psHistogramAlloc() called with bin size %d.\n", n); + } + // NOTE: Verify that this is the correct action. + if (lower > upper) { + return (NULL); + } + // Allocate memory for the new histogram structure. If there are N + // bins, then there are N+1 bounds to those bins. + newHist = (psHistogram* ) psAlloc(sizeof(psHistogram)); + p_psMemSetDeallocator(newHist, (psFreeFcn) histogramFree); + newHist->bounds = psVectorAlloc(n + 1, PS_TYPE_F32); + newHist->bounds->n = newHist->bounds->nalloc; + + // Calculate the bounds for each bin. + binSize = (upper - lower) / (float)n; + // NOTE: Is the following necessary? It prevents the max data point + // from being in a non-existant bin. + binSize += FLT_EPSILON; + for (i = 0; i < n + 1; i++) { + newHist->bounds->data.F32[i] = lower + (binSize * (float)i); + } + + // Allocate the bins, and initialize them to zero. + newHist->nums = psVectorAlloc(n, PS_TYPE_U32); + newHist->nums->n = newHist->nums->nalloc; + for (i = 0; i < newHist->nums->n; i++) { + newHist->nums->data.U32[i] = 0; + } + + // Initialize the other members. + newHist->minNum = 0; + newHist->maxNum = 0; + newHist->uniform = true; + + return (newHist); +} + +/****************************************************************************** +psHistogramAllocGenric(bounds): allocate a non-uniform histogram structure +with the specifed bounds. + +Input: + bounds +Returns: + The histogram structure + *****************************************************************************/ +psHistogram* psHistogramAllocGeneric(const psVector* restrict bounds) +{ + psHistogram* newHist = NULL; // The new histogram structure + int i; // Loop index variable + + // NOTE: Verify that this is the correct action. + if (bounds == NULL) { + // psAbort(__func__, "psHistogram requested with NULL bounds"); + return (NULL); + } + // NOTE: Verify that this is the correct action. + if (bounds->n <= 1) { + // psAbort(__func__, "psHistogram requested with NULL bounds"); + return (NULL); + } + + if (bounds->type.type != PS_TYPE_F32) { + // psAbort(__func__, "psHistogram request a bound which is not type F32"); + return (NULL); + } + // Allocate memory for the new histogram structure. + newHist = (psHistogram* ) psAlloc(sizeof(psHistogram)); + p_psMemSetDeallocator(newHist, (psFreeFcn) histogramFree); + newHist->bounds = psVectorAlloc(bounds->n, PS_TYPE_F32); + newHist->bounds->n = newHist->bounds->nalloc; + for (i = 0; i < bounds->n; i++) { + newHist->bounds->data.F32[i] = bounds->data.F32[i]; + } + + // Allocate the bins, and initialize them to zero. If there are N bounds, + // then there are N-1 bins. + newHist->nums = psVectorAlloc((bounds->n) - 1, PS_TYPE_U32); + newHist->nums->n = newHist->nums->nalloc; + for (i = 0; i < newHist->nums->n; i++) { + newHist->nums->data.U32[i] = 0; + } + + // Initialize the other members. + newHist->minNum = 0; + newHist->maxNum = 0; + newHist->uniform = false; + + return (newHist); +} + +static void histogramFree(psHistogram* myHist) +{ + psFree(myHist->bounds); + psFree(myHist->nums); +} + +/***************************************************************************** +psVectorHistogram(out, in, mask, maskVal): this procedure takes as input a +preallocated and initialized histogram structure. It fills the bins in that +histogram structure in accordance with the input data "in" and the, possibly +NULL, mask vector. + +Inputs: + out + in + mask + maskVal +Returns: + The histogram structure "out". + *****************************************************************************/ +psHistogram* psVectorHistogram(psHistogram* out, + const psVector* restrict in, + const psVector* restrict mask, unsigned int maskVal) +{ + int i = 0; // Loop index variable + int j = 0; // Loop index variable + float binSize = 0.0; // Histogram bin size + int binNum = 0; // A temporary bin number + int numBins = 0; // The total number of bins + + // NOTE: Verify that this is the correct action. + if (out == NULL) { + return (NULL); + } + // Check the specified output histogram for type psF32 + if (out->bounds->type.type != PS_TYPE_F32) { + psAbort(__func__, "Only data type PS_TYPE_F32 for the output.bounds member."); + } + + if (out->nums->type.type != PS_TYPE_U32) { + psAbort(__func__, "Only data type PS_TYPE_U32 for output.nums member."); + } + // NOTE: Verify that this is the correct action. + if (in == NULL) { + return (out); + } + + if (in->type.type != PS_TYPE_F32) { + psAbort(__func__, "Only data type PS_TYPE_F32 is currently supported (0x%x).", in->type.type); + } + + if (mask != NULL) { + if (in->n != mask->n) { + psAbort(__func__, "Vector data and vector mask are of different sizes."); + } + if (mask->type.type != PS_TYPE_U8) { + psAbort(__func__, "Vector mask must be type PS_TYPE_U8"); + } + } + // NOTE: determine the correct action for a variety of other cases: + // in vector has 0 elements, and histogram structure has zero bins. + + numBins = out->nums->n; + for (i = 0; i < in->n; i++) { + // Check if this pixel is masked, and if so, skip it. + if ((mask == NULL) || ((mask != NULL) && (!(mask->data.U8[i] & maskVal)))) { + // Check if this pixel is below the minimum value, and if so + // count it, then skip it. + if (in->data.F32[i] < out->bounds->data.F32[0]) { + out->minNum++; + // Check if this pixel is above the maximum value, and if so + // count it, then skip it. + } else if (in->data.F32[i] > out->bounds->data.F32[numBins]) { + out->maxNum++; + } else { + // If this is a uniform histogram, determining the correct + // number is trivial. + if (out->uniform == true) { + binSize = out->bounds->data.F32[1] - out->bounds->data.F32[0]; + binNum = (int)((in->data.F32[i] - out->bounds->data.F32[0]) / binSize); + + // NOTE: This next if-statement really shouldn't be necessary. + // However, do to numerical lack of precision, we occasionally + // produce a binNum outside the range of bins. + if (binNum >= out->nums->n) { + binNum = out->nums->n - 1; + } + + (out->nums->data.S32[binNum])++; + + // If this is a non-uniform histogram, determining the correct + // bin number requires a bit more work. + } else { + // NOTE: This is slow. Put a smarter algorithm here to + // find the correct bin number (bin search, probably) + for (j = 0; j < (out->bounds->n) - 1; j++) { + if ((out->bounds->data.S32[j] <= in->data.F32[i]) && + (in->data.F32[i] <= out->bounds->data.S32[j + 1])) { + (out->nums->data.S32[j])++; + } + } + } + } + } + } + return (out); +} + +/****************************************************************************** +p_psConvertToF32(myVector, maskVector, maskVal, stats): this is the cheap +way to support a variety of vector data types: we simply convert the input +vector to F32 at the beginning, and write all of our functions in F32. If +the vast majority of all vector stat operations are F32 (or any other single +type), then this is probably the best way to go. Otherwise, when the +algorithms stablize, we will then macro everything and put type support in +the various stat functions. + *****************************************************************************/ +psVector* p_psConvertToF32(psStats* stats, psVector* in, psVector* mask, unsigned int maskVal) +{ + int i = 0; + psVector* tmp = NULL; + + if (in->type.type == PS_TYPE_S32) { + tmp = psVectorAlloc(in->n, PS_TYPE_F32); + for (i = 0; i < in->n; i++) { + tmp->data.F32[i] = (float)in->data.S32[i]; + } + } else if (in->type.type == PS_TYPE_U32) { + tmp = psVectorAlloc(in->n, PS_TYPE_F32); + for (i = 0; i < in->n; i++) { + tmp->data.F32[i] = (float)in->data.U32[i]; + } + } else if (in->type.type == PS_TYPE_F64) { + tmp = psVectorAlloc(in->n, PS_TYPE_F32); + for (i = 0; i < in->n; i++) { + tmp->data.F32[i] = (float)in->data.F64[i]; + } + } else if (in->type.type == PS_TYPE_F32) { + // do nothing + } else { + psAbort(__func__, "unsupported vector type 0x%x\n", in->type.type); + } + return (tmp); +} + +/****************************************************************************** +psVectorStats(myVector, maskVector, maskVal, stats): this is the public API +function which calls the above private stats functions based on what bits +were set in stats->options. + +Inputs + myVector + maskVector + maskVal + stats +Returns + The stats structure. + +NOTE: The current strategy is to implement everything assuming that all +input data is of type PS_TYPE_F32. Once the basic code is in place, we will +macro-ize everything and add PS_TYPE_U16 and PS_TYPE_F64. + *****************************************************************************/ +psStats* psVectorStats(psStats* stats, psVector* in, psVector* mask, unsigned int maskVal) +{ + psVector* inF32; + int mustFreeTmp = 1; + + // NOTE: Verify that this is the correct action. + if (in == NULL) { + return (stats); + } + if (stats == NULL) { + return (NULL); + } + + inF32 = p_psConvertToF32(stats, in, mask, maskVal); + if (inF32 == NULL) { + inF32 = in; + mustFreeTmp = 0; + } + // XXX: Should we abort if (stats->min == stats->max)? + if ((stats->options & PS_STAT_USE_RANGE) && (stats->min >= stats->max)) { + psAbort(__func__, "psVectorStats() called with range: %f to %f\n", stats->min, stats->max); + } + // PS_CHECK_VECTOR_TYPE(in, PS_TYPE_F32); + if (mask != NULL) { + PS_CHECK_NULL_VECTOR(mask); + PS_CHECK_EMPTY_VECTOR(mask); + PS_CHECK_VECTOR_SIZE_EQUAL(mask, in); + PS_CHECK_VECTOR_TYPE(mask, PS_TYPE_U8); + } + // ************************************************************************ + if (stats->options & PS_STAT_SAMPLE_MEAN) { + p_psVectorSampleMean(in, mask, maskVal, stats); + } + // ************************************************************************ + if (stats->options & PS_STAT_SAMPLE_MEDIAN) { + p_psVectorSampleMedian(in, mask, maskVal, stats); + } + // ************************************************************************ + // NOTE: The Stdev calculation requires the mean. Should we assume the + // mean has already been calculated? Or should we always calculate it? + if (stats->options & PS_STAT_SAMPLE_STDEV) { + p_psVectorSampleMean(in, mask, maskVal, stats); + p_psVectorSampleStdev(in, mask, maskVal, stats); + } + // ************************************************************************ + if (stats->options & PS_STAT_SAMPLE_QUARTILE) { + p_psVectorSampleQuartiles(in, mask, maskVal, stats); + } + // Since the various robust stats quantities share much computation, they + // are grouped together in a single private function: + // p_psVectorRobustStats() + if ((stats->options & PS_STAT_ROBUST_MEAN) || + (stats->options & PS_STAT_ROBUST_MEDIAN) || + (stats->options & PS_STAT_ROBUST_MODE) || + (stats->options & PS_STAT_ROBUST_STDEV) || (stats->options & PS_STAT_ROBUST_QUARTILE)) { + p_psVectorRobustStats(in, mask, maskVal, stats); + } + + if ((stats->options & PS_STAT_CLIPPED_MEAN) || (stats->options & PS_STAT_CLIPPED_STDEV)) { + p_psVectorClippedStats(in, mask, maskVal, stats); + } + // ************************************************************************ + if (stats->options & PS_STAT_MAX) { + p_psVectorMax(in, mask, maskVal, stats); + } + // ************************************************************************ + if (stats->options & PS_STAT_MIN) { + p_psVectorMin(in, mask, maskVal, stats); + } + + if (mustFreeTmp == 1) { + psFree(inF32); + } + return (stats); +} Index: /tags/rel2_1/psLib/src/dataManip/psStats.h =================================================================== --- /tags/rel2_1/psLib/src/dataManip/psStats.h (revision 1553) +++ /tags/rel2_1/psLib/src/dataManip/psStats.h (revision 1553) @@ -0,0 +1,185 @@ + +/** @file psStats.h + * \brief basic statistical operations + * @ingroup Stats + * + * This file will hold the definition of the histogram and stats data + * structures. It also contains prototypes for procedures which operate + * on those data structures. + * + * @author George Gusciora, MHPCC + * + * @version $Revision: 1.25 $ $Name: not supported by cvs2svn $ + * @date $Date: 2004-08-11 19:16:04 $ + * + * Copyright 2004 Maui High Performance Computing Center, University of Hawaii + */ +#if !defined(PS_STATS_H) +#define PS_STATS_H + +#include "psVector.h" + +/// @addtogroup Stats +/// @{ + +/****************************************************************************** + Statistical functions and data structures. + *****************************************************************************/ + +/** enumeration of statistical calculation options + * + * @see psStats, psVectorStats, psImageStats + */ +typedef enum { + PS_STAT_SAMPLE_MEAN = 0x000001, + PS_STAT_SAMPLE_MEDIAN = 0x000002, + PS_STAT_SAMPLE_STDEV = 0x000004, + PS_STAT_SAMPLE_QUARTILE = 0x000008, + PS_STAT_ROBUST_MEAN = 0x000010, + PS_STAT_ROBUST_MEDIAN = 0x000020, + PS_STAT_ROBUST_MODE = 0x000040, + PS_STAT_ROBUST_STDEV = 0x000080, + PS_STAT_ROBUST_QUARTILE = 0x000100, + PS_STAT_CLIPPED_MEAN = 0x000200, + PS_STAT_CLIPPED_STDEV = 0x000400, + PS_STAT_MAX = 0x000800, + PS_STAT_MIN = 0x001000, + PS_STAT_USE_RANGE = 0x002000, + PS_STAT_USE_BINSIZE = 0x004000, + PS_STAT_ROBUST_FOR_SAMPLE = 0x008000 +} psStatsOptions; + +/** This is the generic statistics structure. It contails the data members + for the various statistic values. It also contains the options member to + specifiy which statistics should be calculated. */ +typedef struct +{ + double sampleMean; ///< formal mean of sample + double sampleMedian; ///< formal median of sample + double sampleStdev; ///< standard deviation of sample + double sampleUQ; ///< upper quartile of sample + double sampleLQ; ///< lower quartile of sample + double sampleLimit; ///< + double robustMean; ///< robust mean of array + double robustMedian; ///< robust median of array + double robustMode; ///< Robust mode of array + double robustStdev; ///< robust standard deviation of array + double robustUQ; ///< robust upper quartile + double robustLQ; ///< robust lower quartile + double XXX; + double robustN50; ///< + double robustNfit; ///< + double clippedMean; ///< Nsigma clipped mean + double clippedStdev; ///< standard deviation after clipping + double clipSigma; ///< Nsigma used for clipping; user input + int clipIter; ///< Number of clipping iterations; user input + double min; ///< minimum data value in array + double max; ///< maximum data value in array + double binsize; ///< + psStatsOptions options; ///< bitmask of calculated values +} +psStats; + +/** Performs statistical calculations on a vector. + * + * @return psStats* the statistical results as specified by stats->options + */ +psStats* psVectorStats( + psStats* stats, + ///< stats structure defines stats to be calculated and how + + psVector* in, + ///< Vector to be analysed: must be F32 + + psVector* mask, + ///< Ignore elements where (maskVector & maskVal) != 0: must be INT or NULL + + unsigned int maskVal + ///< Only mask elements with one of these bits set in maskVector +); + +/** Allocator of the psStats structure. + * + * @return psStats* A new psStats struct with the options member set to the + * value given. + */ +psStats* psStatsAlloc( + psStatsOptions options ///< Statistics to calculate +); + +/****************************************************************************** + Histogram functions and data structures. + *****************************************************************************/ + +/** The basic histogram structure which contains bounds and bins. + * + * In this structure, the vector bounds specifies the boundaries of the + * histogram bins, and must of type psF32, while nums specifies the number + * of entries in the bin, and must of type psU32. The value of bounds.n must + * therefore be 1 greater than than nums.n. The two values minNum and maxNum + * are the number of data values which fell below the lower limit bound or + * above the upper limit bound, respectively. + */ +typedef struct +{ + psVector* bounds; ///< Bounds for the bins (type F32) + psVector* nums; ///< Number in each of the bins (INT) + int minNum; ///< Number below the minimum + int maxNum; ///< Number above the maximum + bool uniform; ///< Is it a uniform distribution? +} +psHistogram; + +/** Allocator for psHistogram where the bounds of the bins are implicitly + * specified through simply specifying an upper and lower limit along with + * the size of the bins. + * + * @return psHistogram* Newly allocated psHistogram + */ +psHistogram* psHistogramAlloc( + float lower, ///< Lower limit for the bins + float upper, ///< Upper limit for the bins + int n ///< Number of bins +); + +/** Allocator for psHistogram where the bounds of the bins are explicitly + * specified. + * + * @return psHistogram* Newly allocated psHistogram + */ +psHistogram* psHistogramAllocGeneric( + const psVector* restrict bounds ///< Bounds for the bins +); + +/** Calculate a histogram + * + * The following function populates the histogram bins from the specified + * vector (in). It alters and returns the histogram out structure. The input + * vector may be of types psU8, psU16, psF32, psF64. + * + * @return psHistogram* histogram result + */ +psHistogram* psVectorHistogram( + psHistogram* out, ///< Histogram data + const psVector* restrict in, ///< Vector to analyse + const psVector* restrict mask, ///< Mask dat for input vector + unsigned int maskVal ///< Mask value +); + +/** Extracts the statistic value specified by stats->options. + * + * @return bool If more than one statistic result is set in stats->options, + * false is returned and the value parameter is not set, + * otherwise true is returned. + */ +bool p_psGetStatValue( + const psStats* stats, + ///< the statistic struct to operate on + + double *value + ///< if return is true, this is set to the specified statistic value by stats->options +); + +/// @} + +#endif Index: /tags/rel2_1/psLib/src/dataManip/psVectorFFT.c =================================================================== --- /tags/rel2_1/psLib/src/dataManip/psVectorFFT.c (revision 1553) +++ /tags/rel2_1/psLib/src/dataManip/psVectorFFT.c (revision 1553) @@ -0,0 +1,741 @@ + +/** @file psFFT.c +* +* @brief Contains FFT transforms functions +* +* @author Robert DeSonia, MHPCC +* +* @version $Revision: 1.21 $ $Name: not supported by cvs2svn $ +* @date $Date: 2004-08-10 18:54:38 $ +* +* Copyright 2004 Maui High Performance Computing Center, University of Hawaii +*/ + +#include +#include +#include +#include +#include + +#include "psFFT.h" +#include "psError.h" +#include "psMemory.h" +#include "psLogMsg.h" +#include "psImageExtraction.h" + +#define P_FFTW_PLAN_RIGOR FFTW_ESTIMATE + +static bool p_fftwWisdomImported = false; + +psImage* psImageFFT(psImage* out, const psImage* in, psFftDirection direction) +{ + unsigned int numCols; + unsigned int numRows; + psElemType type; + fftwf_plan plan; + + /* got good image data? */ + if (in == NULL) { + psFree(out); + return NULL; + } + + type = in->type.type; + + if ((type != PS_TYPE_F32) && (type != PS_TYPE_C32)) { + psError(__func__, "Input image must be a 32-bit float or complex image (type=%d)", type); + psFree(out); + return NULL; + } + + if (type != PS_TYPE_C32 && direction == PS_FFT_REVERSE) { + psError(__func__, "Input image must be complex image for reverse FFT (type=%d).", type); + psFree(out); + return NULL; + + } + + if (type != PS_TYPE_F32 && direction == PS_FFT_FORWARD) { + psError(__func__, "Input image must be real image for forward FFT (type=%d).", type); + psFree(out); + return NULL; + } + + /* make sure the system-level wisdom information is imported. */ + if (!p_fftwWisdomImported) { + fftwf_import_system_wisdom(); + p_fftwWisdomImported = true; + } + + numRows = in->numRows; + numCols = in->numCols; + + out = psImageCopy(out, in, PS_TYPE_C32); + + plan = fftwf_plan_dft_2d(numCols, numRows, + (fftwf_complex *) out->data.C32[0], + (fftwf_complex *) out->data.C32[0], direction, P_FFTW_PLAN_RIGOR); + + /* check if a plan exists now */ + if (plan == NULL) { + psError(__func__, "Failed to create FFTW plan."); + psFree(out); + return NULL; + } + + /* finally, call FFTW with the plan made above */ + fftwf_execute(plan); + + fftwf_destroy_plan(plan); + + return out; + +} + +psImage* psImageReal(psImage* out, const psImage* in) +{ + psElemType type; + unsigned int numCols; + unsigned int numRows; + + if (in == NULL) { + psFree(out); + return NULL; + } + + type = in->type.type; + numCols = in->numCols; + numRows = in->numRows; + + /* if not a complex number, this is logically just a copy */ + if (!PS_IS_PSELEMTYPE_COMPLEX(type)) { + // Warn user, as this is probably not expected + psLogMsg(__func__, PS_LOG_WARN, "Real portion of a non-Complex type called called for. " + "Just an image copy was performed."); + return psImageCopy(out, in, type); + } + + if (type == PS_TYPE_C32) { + psF32* outRow; + psC32* inRow; + + out = psImageRecycle(out, numCols, numRows, PS_TYPE_F32); + for (unsigned int row = 0; row < numRows; row++) { + outRow = out->data.F32[row]; + inRow = in->data.C32[row]; + + for (unsigned int col = 0; col < numCols; col++) { + outRow[col] = crealf(inRow[col]); + } + } + } else if (type == PS_TYPE_C64) { + psF64* outRow; + psC64* inRow; + + out = psImageRecycle(out, numCols, numRows, PS_TYPE_F64); + for (unsigned int row = 0; row < numRows; row++) { + outRow = out->data.F64[row]; + inRow = in->data.C64[row]; + + for (unsigned int col = 0; col < numCols; col++) { + outRow[col] = creal(inRow[col]); + } + } + } else { + psError(__func__, "Can not extract real component from given image type (%d).", type); + psFree(out); + return NULL; + } + + return out; +} + +psImage* psImageImaginary(psImage* out, const psImage* in) +{ + psElemType type; + unsigned int numCols; + unsigned int numRows; + + if (in == NULL) { + psFree(out); + return NULL; + } + + type = in->type.type; + numCols = in->numCols; + numRows = in->numRows; + + /* if not a complex number, this is logically just zeroed image of same size */ + if (!PS_IS_PSELEMTYPE_COMPLEX(type)) { + // Warn user, as this is probably not expected + psLogMsg(__func__, PS_LOG_WARN, "Imaginary portion of a non-Complex type called for. " + "A zero image was returned."); + out = psImageRecycle(out, numCols, numRows, type); + memset(out->data.V[0], 0, PSELEMTYPE_SIZEOF(type) * numCols * numRows); + return out; + } + + if (type == PS_TYPE_C32) { + psF32* outRow; + psC32* inRow; + + out = psImageRecycle(out, numCols, numRows, PS_TYPE_F32); + for (unsigned int row = 0; row < numRows; row++) { + outRow = out->data.F32[row]; + inRow = in->data.C32[row]; + + for (unsigned int col = 0; col < numCols; col++) { + outRow[col] = cimagf(inRow[col]); + } + } + } else if (type == PS_TYPE_C64) { + psF64* outRow; + psC64* inRow; + + out = psImageRecycle(out, numCols, numRows, PS_TYPE_F64); + for (unsigned int row = 0; row < numRows; row++) { + outRow = out->data.F64[row]; + inRow = in->data.C64[row]; + + for (unsigned int col = 0; col < numCols; col++) { + outRow[col] = cimag(inRow[col]); + } + } + } else { + psError(__func__, "Can not extract imaginary component from given image type (%d).", type); + psFree(out); + return NULL; + } + + return out; +} + +psImage* psImageComplex(psImage* out, const psImage* real, const psImage* imag) +{ + psElemType type; + unsigned int numCols; + unsigned int numRows; + + if (real == NULL || imag == NULL) { + psFree(out); + return NULL; + } + + type = real->type.type; + numCols = real->numCols; + numRows = real->numRows; + + if (imag->type.type != type) { + psError(__func__, "The inputs to psImageComplex must be the same type."); + psFree(out); + return NULL; + } + + if (imag->numCols != numCols || imag->numRows != numRows) { + psError(__func__, "The inputs to psImageComplex must be the same dimensions."); + psFree(out); + return NULL; + } + + if (PS_IS_PSELEMTYPE_COMPLEX(type)) { + psError(__func__, "The inputs to psImageComplex can not be complex."); + psFree(out); + return NULL; + } + + if (type != PS_TYPE_F32 && type != PS_TYPE_F64) { + psError(__func__, "The input type to psImageComplex must be a floating point."); + psFree(out); + return NULL; + } + + if (type == PS_TYPE_F32) { + psC32* outRow; + psF32* realRow; + psF32* imagRow; + + out = psImageRecycle(out, numCols, numRows, PS_TYPE_C32); + + for (unsigned int row = 0; row < numRows; row++) { + outRow = out->data.C32[row]; + realRow = real->data.F32[row]; + imagRow = imag->data.F32[row]; + + for (unsigned int col = 0; col < numCols; col++) { + outRow[col] = realRow[col] + I * imagRow[col]; + } + } + } else if (type == PS_TYPE_F64) { + psC64* outRow; + psF64* realRow; + psF64* imagRow; + + out = psImageRecycle(out, numCols, numRows, PS_TYPE_C64); + for (unsigned int row = 0; row < numRows; row++) { + outRow = out->data.C64[row]; + realRow = real->data.F64[row]; + imagRow = imag->data.F64[row]; + + for (unsigned int col = 0; col < numCols; col++) { + outRow[col] = realRow[col] + I * imagRow[col]; + } + } + } else { + psError(__func__, "Can not merge real and imaginary portions for given image type (%d).", type); + psFree(out); + return NULL; + } + + return out; +} + +psImage* psImageConjugate(psImage* out, const psImage* in) +{ + psElemType type; + unsigned int numCols; + unsigned int numRows; + + if (in == NULL) { + psFree(out); + return NULL; + } + + type = in->type.type; + numCols = in->numCols; + numRows = in->numRows; + + /* if not a complex number, this is logically just a image copy */ + if (!PS_IS_PSELEMTYPE_COMPLEX(type)) { + // Warn user, as this is probably not expected + psLogMsg(__func__, PS_LOG_WARN, "Complex Conjugate of a non-Complex type called for. " + "Image copy was performed instead."); + return psImageCopy(out, in, type); + } + + if (type == PS_TYPE_C32) { + psC32* outRow; + psC32* inRow; + + out = psImageRecycle(out, numCols, numRows, PS_TYPE_C32); + for (unsigned int row = 0; row < numRows; row++) { + outRow = out->data.C32[row]; + inRow = in->data.C32[row]; + + for (unsigned int col = 0; col < numCols; col++) { + outRow[col] = crealf(inRow[col]) - I * cimagf(inRow[col]); + } + } + } else if (type == PS_TYPE_C64) { + psC64* outRow; + psC64* inRow; + + out = psImageRecycle(out, numCols, numRows, PS_TYPE_C64); + for (unsigned int row = 0; row < numRows; row++) { + outRow = out->data.C64[row]; + inRow = in->data.C64[row]; + + for (unsigned int col = 0; col < numCols; col++) { + outRow[col] = creal(inRow[col]) - I * cimag(inRow[col]); + } + } + } else { + psError(__func__, "Can not compute complex conjugate for given image type (%d).", type); + psFree(out); + return NULL; + } + + return out; +} + +psImage* psImagePowerSpectrum(psImage* out, const psImage* in) +{ + psElemType type; + unsigned int numCols; + unsigned int numRows; + int numElementsSquared; + + if (in == NULL) { + psFree(out); + return NULL; + } + + type = in->type.type; + numCols = in->numCols; + numRows = in->numRows; + numElementsSquared = numCols * numCols * numRows * numRows; + + /* if not a complex number, this is not implemented */ + if (!PS_IS_PSELEMTYPE_COMPLEX(type)) { + psError(__func__, "Power Spectrum for non-complex inputs is not implemented."); + psFree(out); + return NULL; + } + + if (type == PS_TYPE_C32) { + psF32* outRow; + psC32* inRow; + psF32 real; + psF32 imag; + + out = psImageRecycle(out, numCols, numRows, PS_TYPE_F32); + for (unsigned int row = 0; row < numRows; row++) { + outRow = out->data.F32[row]; + inRow = in->data.C32[row]; + + for (unsigned int col = 0; col < numCols; col++) { + real = crealf(inRow[col]); + imag = cimagf(inRow[col]); + outRow[col] = (real * real + imag * imag) / numElementsSquared; + } + } + } else if (type == PS_TYPE_C64) { + psF64* outRow; + psC64* inRow; + psF64 real; + psF64 imag; + + out = psImageRecycle(out, numCols, numRows, PS_TYPE_F64); + for (unsigned int row = 0; row < numRows; row++) { + outRow = out->data.F64[row]; + inRow = in->data.C64[row]; + + for (unsigned int col = 0; col < numCols; col++) { + real = crealf(inRow[col]); + imag = cimagf(inRow[col]); + outRow[col] = real * real + imag * imag / numElementsSquared; + } + } + } else { + psError(__func__, "Can not power spectrum for given image type (%d).", type); + psFree(out); + return NULL; + } + + return out; + +} + +/************************************** Vector Functions ***************************************/ + +psVector* psVectorFFT(psVector* out, const psVector* in, psFftDirection direction) +{ + unsigned int numElements; + psElemType type; + fftwf_plan plan; + + /* got good image data? */ + if (in == NULL) { + psFree(out); + return NULL; + } + + type = in->type.type; + + if ((type != PS_TYPE_F32) && (type != PS_TYPE_C32)) { + psError(__func__, "Input image must be a 32-bit float or complex image (type=%d)", type); + psFree(out); + return NULL; + } + + if ((type != PS_TYPE_C32) && (direction == PS_FFT_REVERSE)) { + psError(__func__, "Input image must be complex image for reverse FFT (type=%d).", type); + psFree(out); + return NULL; + + } + + if ((type != PS_TYPE_F32) && (direction == PS_FFT_FORWARD)) { + psError(__func__, "Input image must be real image for forward FFT (type=%d).", type); + psFree(out); + return NULL; + } + + /* make sure the system-level wisdom information is imported. */ + if (!p_fftwWisdomImported) { + fftwf_import_system_wisdom(); + p_fftwWisdomImported = true; + } + + numElements = in->n; + + out = psVectorRecycle(out, numElements, PS_TYPE_C32); + out->n = numElements; + + if (type == PS_TYPE_F32) { + // need to convert to complex + psC32* outVec = out->data.C32; + psF32* inVec = in->data.F32; + + for (unsigned int i = 0; i < numElements; i++) { + outVec[i] = inVec[i]; + } + } else { + psC32* outVec = out->data.C32; + psC32* inVec = in->data.C32; + + for (unsigned int i = 0; i < numElements; i++) { + outVec[i] = inVec[i]; + } + } + + plan = fftwf_plan_dft_1d(numElements, + (fftwf_complex *) out->data.C32, + (fftwf_complex *) out->data.C32, direction, P_FFTW_PLAN_RIGOR); + + /* check if a plan exists now */ + if (plan == NULL) { + psError(__func__, "Failed to create FFTW plan."); + psFree(out); + return NULL; + } + + /* finally, call FFTW with the plan made above */ + fftwf_execute(plan); + + fftwf_destroy_plan(plan); + + return out; +} + +psVector* psVectorReal(psVector* out, const psVector* in) +{ + psElemType type; + unsigned int numElements; + + if (in == NULL) { + psFree(out); + return NULL; + } + + type = in->type.type; + numElements = in->n; + + /* if not a complex number, this is logically just a copy */ + if (!PS_IS_PSELEMTYPE_COMPLEX(type)) { + // Warn user, as this is probably not expected + psLogMsg(__func__, PS_LOG_WARN, "Real portion of a non-Complex type called called for. " + "Just a vector copy was performed."); + out = psVectorRecycle(out, numElements, type); + out->n = numElements; + memcpy(out->data.V, in->data.V, numElements * PSELEMTYPE_SIZEOF(type)); + return out; + } + + if (type == PS_TYPE_C32) { + psF32* outVec; + psC32* inVec = in->data.C32; + + out = psVectorRecycle(out, numElements, PS_TYPE_F32); + out->n = numElements; + outVec = out->data.F32; + + for (unsigned int i = 0; i < numElements; i++) { + outVec[i] = crealf(inVec[i]); + } + } else { + psError(__func__, "Can not extract real component from given vector type (%d).", type); + psFree(out); + return NULL; + } + + return out; +} + +psVector* psVectorImaginary(psVector* out, const psVector* in) +{ + psElemType type; + unsigned int numElements; + + if (in == NULL) { + psFree(out); + return NULL; + } + + type = in->type.type; + numElements = in->n; + + /* if not a complex number, this is logically just zeroed image of same size */ + if (!PS_IS_PSELEMTYPE_COMPLEX(type)) { + // Warn user, as this is probably not expected + psLogMsg(__func__, PS_LOG_WARN, "Imaginary portion of a non-Complex type called for. " + "A zeroed vector was returned."); + out = psVectorRecycle(out, numElements, type); + out->n = numElements; + memset(out->data.V, 0, PSELEMTYPE_SIZEOF(type) * numElements); + return out; + } + + if (type == PS_TYPE_C32) { + psF32* outVec; + psC32* inVec = in->data.C32; + + out = psVectorRecycle(out, numElements, PS_TYPE_F32); + out->n = numElements; + outVec = out->data.F32; + + for (unsigned int i = 0; i < numElements; i++) { + outVec[i] = cimagf(inVec[i]); + } + } else { + psError(__func__, "Can not extract imaginary component from given vector type (%d).", type); + psFree(out); + return NULL; + } + + return out; +} + +psVector* psVectorComplex(psVector* out, const psVector* real, const psVector* imag) +{ + psElemType type; + unsigned int numElements; + + if (real == NULL || imag == NULL) { + psFree(out); + return NULL; + } + + type = real->type.type; + if (real->n < imag->n) { + numElements = real->n; + } else { + numElements = imag->n; + } + + if (imag->type.type != type) { + psError(__func__, "The inputs to psVectorComplex must be the same type."); + psFree(out); + return NULL; + } + + if (PS_IS_PSELEMTYPE_COMPLEX(type)) { + psError(__func__, "The inputs to psVectorComplex can not be complex."); + psFree(out); + return NULL; + } + + if (type == PS_TYPE_F32) { + psC32* outVec; + psF32* realVec = real->data.F32; + psF32* imagVec = imag->data.F32; + + out = psVectorRecycle(out, numElements, PS_TYPE_C32); + out->n = numElements; + outVec = out->data.C32; + + for (unsigned int i = 0; i < numElements; i++) { + outVec[i] = realVec[i] + I * imagVec[i]; + } + } else { + psError(__func__, "Can not merge real and imaginary portions for given vector type (%d).", type); + psFree(out); + return NULL; + } + + return out; +} + +psVector* psVectorConjugate(psVector* out, const psVector* in) +{ + psElemType type; + unsigned int numElements; + + if (in == NULL) { + psFree(out); + return NULL; + } + + type = in->type.type; + numElements = in->n; + + /* if not a complex number, this is logically just a image copy */ + if (!PS_IS_PSELEMTYPE_COMPLEX(type)) { + // Warn user, as this is probably not expected + psLogMsg(__func__, PS_LOG_WARN, "Complex Conjugate of a non-Complex type called for. " + "Vector copy was performed instead."); + + out = psVectorRecycle(out, numElements, type); + out->n = numElements; + memcpy(out->data.V, in->data.V, PSELEMTYPE_SIZEOF(type) * numElements); + return out; + } + + if (type == PS_TYPE_C32) { + psC32* outVec; + psC32* inVec = in->data.C32; + + out = psVectorRecycle(out, numElements, PS_TYPE_C32); + out->n = numElements; + outVec = out->data.C32; + + for (unsigned int i = 0; i < numElements; i++) { + outVec[i] = crealf(inVec[i]) - I * cimagf(inVec[i]); + } + } else { + psError(__func__, "Can not compute complex conjugate for given vector type (%d).", type); + psFree(out); + return NULL; + } + + return out; +} + +psVector* psVectorPowerSpectrum(psVector* out, const psVector* in) +{ + psElemType type; + unsigned int outNumElements; + unsigned int inNumElements; + unsigned int inHalfNumElements; + unsigned int inNumElementsSquared; + + if (in == NULL) { + psFree(out); + return NULL; + } + + type = in->type.type; + inNumElements = in->n; + inNumElementsSquared = inNumElements * inNumElements; + inHalfNumElements = inNumElements / 2; + outNumElements = inHalfNumElements + 1; + + /* if not a complex number, this is not implemented */ + if (!PS_IS_PSELEMTYPE_COMPLEX(type)) { + psError(__func__, "Power Spectrum for non-complex inputs is not implemented."); + psFree(out); + return NULL; + } + + if (type == PS_TYPE_C32) { + psF32* outVec; + psC32* inVec = in->data.C32; + psF32 inAbs1; + psF32 inAbs2; + + out = psVectorRecycle(out, outNumElements, PS_TYPE_F32); + out->n = outNumElements; + outVec = out->data.F32; + + // from ADD: P_0 = |C_0|^2/N^2 + inAbs1 = cabsf(inVec[0]); + outVec[0] = inAbs1 * inAbs1 / inNumElementsSquared; + + // from ADD: P_j = (|C_j|^2+|C_N-j|^2)/N^2, where j = 1,2,...,(N/2-1) + for (unsigned int i = 1; i < inHalfNumElements; i++) { + inAbs1 = cabsf(inVec[i]); + inAbs2 = cabsf(inVec[inNumElements - i]); + outVec[i] = (inAbs1 * inAbs1 + inAbs2 * inAbs2) / inNumElementsSquared; + } + + // from ADD: P_N/2 = |C_N/2|^2/N^2 + inAbs1 = cabsf(inVec[inHalfNumElements]); + outVec[inHalfNumElements] = inAbs1 * inAbs1 / inNumElementsSquared; + } else { + psError(__func__, "Can not power spectrum for given vector type (%d).", type); + psFree(out); + return NULL; + } + + return out; + +} Index: /tags/rel2_1/psLib/src/dataManip/psVectorFFT.h =================================================================== --- /tags/rel2_1/psLib/src/dataManip/psVectorFFT.h (revision 1553) +++ /tags/rel2_1/psLib/src/dataManip/psVectorFFT.h (revision 1553) @@ -0,0 +1,158 @@ + +/** @file psFFT.h + * + * @brief Contains FFT transforms functions + * + * @ingroup Transform + * + * @author Robert DeSonia, MHPCC + * + * @version $Revision: 1.13 $ $Name: not supported by cvs2svn $ + * @date $Date: 2004-08-10 18:54:38 $ + * + * Copyright 2004 Maui High Performance Computing Center, University of Hawaii + */ + +#ifndef PS_FFT_H +#define PS_FFT_H + +#include "psImage.h" +#include "psVector.h" + +/// @addtogroup Transform +/// @{ + +/** Specify direction of FFT */ +typedef enum { + /// psImageFFT/psVectorFFT should perform a forward FFT. + PS_FFT_FORWARD = (-1), + + /// psImageFFT/psVectorFFT should perform a reverse FFT. + PS_FFT_REVERSE = (+1) +} psFftDirection; + +/** Forward and reverse FFT calculations. + * + * This takes as input the image of interest (in) and the direction + * (direction), which is specified by an enumerated type psFftDirection. + * The input image may be of type psF32 or psC32, the result is always + * psC32. If the input vector is psF32, the direction must be forward. + * + * @return psImage* the FFT transformation result + */ +psImage* psImageFFT( + psImage* out, ///< a psImage to recycle. If NULL, a new psImage is made. + const psImage* in, ///< the psImage to apply transform to + psFftDirection direction ///< the direction of the transform +); + +/** extract the real portion of a complex image + * + * @return psImage* real portion of the input image. + */ +psImage* psImageReal( + psImage* out, ///< a psImage to recycle. If NULL, a new psImage is made. + const psImage* in ///< the psImage to extract real portion from +); + +/** extract the imaginary portion of a complex image + * + * @return psImage* imaginary portion of the input image. + */ +psImage* psImageImaginary( + psImage* out, ///< a psImage to recycle. If NULL, a new psImage is made. + const psImage* in ///< the psImage to extract imaginary portion from +); + +/** creates a complex image from separate real and imaginary plane images + * + * @return psImage* resulting complex image + */ +psImage* psImageComplex( + psImage* out, ///< a psImage to recycle. If NULL, a new psImage is made. + const psImage* real, ///< the real plane image + const psImage* imag ///< the imaginary plane image +); + +/** computes the complex conjugate of an image + * + * @return psImage* the complex conjugate of the 'in' image + */ +psImage* psImageConjugate( + psImage* out, ///< a psImage to recycle. If NULL, a new psImage is made. + const psImage* in ///< the psImage to compute conjugate of +); + +/** computes the power spectrum of an image + * + * @return psImage* the power spectrum of the 'in' image + */ +psImage* psImagePowerSpectrum( + psImage* out, ///< a psImage to recycle. If NULL, a new psImage is made. + const psImage* in ///< the psImage to power spectrum of +); + +/** Forward and reverse FFT calculations. + * + * This takes as input the vector of interest (in) and the direction + * (direction), which is specified by an enumerated type psFftDirection. + * The input vector may be of type psF32 or psC32, the result is always + * psC32. If the input vector is psF32, the direction must be forward. + * + * @return psVector* the FFT transformation result + */ +psVector* psVectorFFT( + psVector* out, ///< a psVector to recycle. If NULL, a new psVector is made. + const psVector* in, ///< the vector to apply transform to + psFftDirection direction ///< the direction of the transform +); + +/** extract the real portion of a complex vector + * + * @return psVector* real portion of the input vector. + */ +psVector* psVectorReal( + psVector* out, ///< a psVector to recycle. If NULL, a new psVector is made. + const psVector* in ///< the psVector to extract real portion from +); + +/** extract the imaginary portion of a complex vector + * + * @return psVector* imaginary portion of the input vector. + */ +psVector* psVectorImaginary( + psVector* out, ///< a psVector to recycle. If NULL, a new psVector is made. + const psVector* in ///< the psVector to extract imaginary portion from +); + +/** creates a complex vector from separate real and imaginary vectors + * + * @return psVector* resulting complex vector + */ +psVector* psVectorComplex( + psVector* out, ///< a psVector to recycle. If NULL, a new psVector is made. + const psVector* real, ///< the real vector + const psVector* imag ///< the imaginary vector +); + +/** computes the complex conjugate of a vector + * + * @return psVector* the complex conjugate of the 'in' vector + */ +psVector* psVectorConjugate( + psVector* out, ///< a psVector to recycle. If NULL, a new psVector is made. + const psVector* in ///< the psVector to compute conjugate of +); + +/** computes the power spectrum of a vector + * + * @return psVector* the power spectrum of the 'in' vector + */ +psVector* psVectorPowerSpectrum( + psVector* out, ///< a psVector to recycle. If NULL, a new psVector is made. + const psVector* in ///< the psVector to power spectrum of +); + +/// @} + +#endif Index: /tags/rel2_1/psLib/src/fft/psVectorFFT.c =================================================================== --- /tags/rel2_1/psLib/src/fft/psVectorFFT.c (revision 1553) +++ /tags/rel2_1/psLib/src/fft/psVectorFFT.c (revision 1553) @@ -0,0 +1,741 @@ + +/** @file psFFT.c +* +* @brief Contains FFT transforms functions +* +* @author Robert DeSonia, MHPCC +* +* @version $Revision: 1.21 $ $Name: not supported by cvs2svn $ +* @date $Date: 2004-08-10 18:54:38 $ +* +* Copyright 2004 Maui High Performance Computing Center, University of Hawaii +*/ + +#include +#include +#include +#include +#include + +#include "psFFT.h" +#include "psError.h" +#include "psMemory.h" +#include "psLogMsg.h" +#include "psImageExtraction.h" + +#define P_FFTW_PLAN_RIGOR FFTW_ESTIMATE + +static bool p_fftwWisdomImported = false; + +psImage* psImageFFT(psImage* out, const psImage* in, psFftDirection direction) +{ + unsigned int numCols; + unsigned int numRows; + psElemType type; + fftwf_plan plan; + + /* got good image data? */ + if (in == NULL) { + psFree(out); + return NULL; + } + + type = in->type.type; + + if ((type != PS_TYPE_F32) && (type != PS_TYPE_C32)) { + psError(__func__, "Input image must be a 32-bit float or complex image (type=%d)", type); + psFree(out); + return NULL; + } + + if (type != PS_TYPE_C32 && direction == PS_FFT_REVERSE) { + psError(__func__, "Input image must be complex image for reverse FFT (type=%d).", type); + psFree(out); + return NULL; + + } + + if (type != PS_TYPE_F32 && direction == PS_FFT_FORWARD) { + psError(__func__, "Input image must be real image for forward FFT (type=%d).", type); + psFree(out); + return NULL; + } + + /* make sure the system-level wisdom information is imported. */ + if (!p_fftwWisdomImported) { + fftwf_import_system_wisdom(); + p_fftwWisdomImported = true; + } + + numRows = in->numRows; + numCols = in->numCols; + + out = psImageCopy(out, in, PS_TYPE_C32); + + plan = fftwf_plan_dft_2d(numCols, numRows, + (fftwf_complex *) out->data.C32[0], + (fftwf_complex *) out->data.C32[0], direction, P_FFTW_PLAN_RIGOR); + + /* check if a plan exists now */ + if (plan == NULL) { + psError(__func__, "Failed to create FFTW plan."); + psFree(out); + return NULL; + } + + /* finally, call FFTW with the plan made above */ + fftwf_execute(plan); + + fftwf_destroy_plan(plan); + + return out; + +} + +psImage* psImageReal(psImage* out, const psImage* in) +{ + psElemType type; + unsigned int numCols; + unsigned int numRows; + + if (in == NULL) { + psFree(out); + return NULL; + } + + type = in->type.type; + numCols = in->numCols; + numRows = in->numRows; + + /* if not a complex number, this is logically just a copy */ + if (!PS_IS_PSELEMTYPE_COMPLEX(type)) { + // Warn user, as this is probably not expected + psLogMsg(__func__, PS_LOG_WARN, "Real portion of a non-Complex type called called for. " + "Just an image copy was performed."); + return psImageCopy(out, in, type); + } + + if (type == PS_TYPE_C32) { + psF32* outRow; + psC32* inRow; + + out = psImageRecycle(out, numCols, numRows, PS_TYPE_F32); + for (unsigned int row = 0; row < numRows; row++) { + outRow = out->data.F32[row]; + inRow = in->data.C32[row]; + + for (unsigned int col = 0; col < numCols; col++) { + outRow[col] = crealf(inRow[col]); + } + } + } else if (type == PS_TYPE_C64) { + psF64* outRow; + psC64* inRow; + + out = psImageRecycle(out, numCols, numRows, PS_TYPE_F64); + for (unsigned int row = 0; row < numRows; row++) { + outRow = out->data.F64[row]; + inRow = in->data.C64[row]; + + for (unsigned int col = 0; col < numCols; col++) { + outRow[col] = creal(inRow[col]); + } + } + } else { + psError(__func__, "Can not extract real component from given image type (%d).", type); + psFree(out); + return NULL; + } + + return out; +} + +psImage* psImageImaginary(psImage* out, const psImage* in) +{ + psElemType type; + unsigned int numCols; + unsigned int numRows; + + if (in == NULL) { + psFree(out); + return NULL; + } + + type = in->type.type; + numCols = in->numCols; + numRows = in->numRows; + + /* if not a complex number, this is logically just zeroed image of same size */ + if (!PS_IS_PSELEMTYPE_COMPLEX(type)) { + // Warn user, as this is probably not expected + psLogMsg(__func__, PS_LOG_WARN, "Imaginary portion of a non-Complex type called for. " + "A zero image was returned."); + out = psImageRecycle(out, numCols, numRows, type); + memset(out->data.V[0], 0, PSELEMTYPE_SIZEOF(type) * numCols * numRows); + return out; + } + + if (type == PS_TYPE_C32) { + psF32* outRow; + psC32* inRow; + + out = psImageRecycle(out, numCols, numRows, PS_TYPE_F32); + for (unsigned int row = 0; row < numRows; row++) { + outRow = out->data.F32[row]; + inRow = in->data.C32[row]; + + for (unsigned int col = 0; col < numCols; col++) { + outRow[col] = cimagf(inRow[col]); + } + } + } else if (type == PS_TYPE_C64) { + psF64* outRow; + psC64* inRow; + + out = psImageRecycle(out, numCols, numRows, PS_TYPE_F64); + for (unsigned int row = 0; row < numRows; row++) { + outRow = out->data.F64[row]; + inRow = in->data.C64[row]; + + for (unsigned int col = 0; col < numCols; col++) { + outRow[col] = cimag(inRow[col]); + } + } + } else { + psError(__func__, "Can not extract imaginary component from given image type (%d).", type); + psFree(out); + return NULL; + } + + return out; +} + +psImage* psImageComplex(psImage* out, const psImage* real, const psImage* imag) +{ + psElemType type; + unsigned int numCols; + unsigned int numRows; + + if (real == NULL || imag == NULL) { + psFree(out); + return NULL; + } + + type = real->type.type; + numCols = real->numCols; + numRows = real->numRows; + + if (imag->type.type != type) { + psError(__func__, "The inputs to psImageComplex must be the same type."); + psFree(out); + return NULL; + } + + if (imag->numCols != numCols || imag->numRows != numRows) { + psError(__func__, "The inputs to psImageComplex must be the same dimensions."); + psFree(out); + return NULL; + } + + if (PS_IS_PSELEMTYPE_COMPLEX(type)) { + psError(__func__, "The inputs to psImageComplex can not be complex."); + psFree(out); + return NULL; + } + + if (type != PS_TYPE_F32 && type != PS_TYPE_F64) { + psError(__func__, "The input type to psImageComplex must be a floating point."); + psFree(out); + return NULL; + } + + if (type == PS_TYPE_F32) { + psC32* outRow; + psF32* realRow; + psF32* imagRow; + + out = psImageRecycle(out, numCols, numRows, PS_TYPE_C32); + + for (unsigned int row = 0; row < numRows; row++) { + outRow = out->data.C32[row]; + realRow = real->data.F32[row]; + imagRow = imag->data.F32[row]; + + for (unsigned int col = 0; col < numCols; col++) { + outRow[col] = realRow[col] + I * imagRow[col]; + } + } + } else if (type == PS_TYPE_F64) { + psC64* outRow; + psF64* realRow; + psF64* imagRow; + + out = psImageRecycle(out, numCols, numRows, PS_TYPE_C64); + for (unsigned int row = 0; row < numRows; row++) { + outRow = out->data.C64[row]; + realRow = real->data.F64[row]; + imagRow = imag->data.F64[row]; + + for (unsigned int col = 0; col < numCols; col++) { + outRow[col] = realRow[col] + I * imagRow[col]; + } + } + } else { + psError(__func__, "Can not merge real and imaginary portions for given image type (%d).", type); + psFree(out); + return NULL; + } + + return out; +} + +psImage* psImageConjugate(psImage* out, const psImage* in) +{ + psElemType type; + unsigned int numCols; + unsigned int numRows; + + if (in == NULL) { + psFree(out); + return NULL; + } + + type = in->type.type; + numCols = in->numCols; + numRows = in->numRows; + + /* if not a complex number, this is logically just a image copy */ + if (!PS_IS_PSELEMTYPE_COMPLEX(type)) { + // Warn user, as this is probably not expected + psLogMsg(__func__, PS_LOG_WARN, "Complex Conjugate of a non-Complex type called for. " + "Image copy was performed instead."); + return psImageCopy(out, in, type); + } + + if (type == PS_TYPE_C32) { + psC32* outRow; + psC32* inRow; + + out = psImageRecycle(out, numCols, numRows, PS_TYPE_C32); + for (unsigned int row = 0; row < numRows; row++) { + outRow = out->data.C32[row]; + inRow = in->data.C32[row]; + + for (unsigned int col = 0; col < numCols; col++) { + outRow[col] = crealf(inRow[col]) - I * cimagf(inRow[col]); + } + } + } else if (type == PS_TYPE_C64) { + psC64* outRow; + psC64* inRow; + + out = psImageRecycle(out, numCols, numRows, PS_TYPE_C64); + for (unsigned int row = 0; row < numRows; row++) { + outRow = out->data.C64[row]; + inRow = in->data.C64[row]; + + for (unsigned int col = 0; col < numCols; col++) { + outRow[col] = creal(inRow[col]) - I * cimag(inRow[col]); + } + } + } else { + psError(__func__, "Can not compute complex conjugate for given image type (%d).", type); + psFree(out); + return NULL; + } + + return out; +} + +psImage* psImagePowerSpectrum(psImage* out, const psImage* in) +{ + psElemType type; + unsigned int numCols; + unsigned int numRows; + int numElementsSquared; + + if (in == NULL) { + psFree(out); + return NULL; + } + + type = in->type.type; + numCols = in->numCols; + numRows = in->numRows; + numElementsSquared = numCols * numCols * numRows * numRows; + + /* if not a complex number, this is not implemented */ + if (!PS_IS_PSELEMTYPE_COMPLEX(type)) { + psError(__func__, "Power Spectrum for non-complex inputs is not implemented."); + psFree(out); + return NULL; + } + + if (type == PS_TYPE_C32) { + psF32* outRow; + psC32* inRow; + psF32 real; + psF32 imag; + + out = psImageRecycle(out, numCols, numRows, PS_TYPE_F32); + for (unsigned int row = 0; row < numRows; row++) { + outRow = out->data.F32[row]; + inRow = in->data.C32[row]; + + for (unsigned int col = 0; col < numCols; col++) { + real = crealf(inRow[col]); + imag = cimagf(inRow[col]); + outRow[col] = (real * real + imag * imag) / numElementsSquared; + } + } + } else if (type == PS_TYPE_C64) { + psF64* outRow; + psC64* inRow; + psF64 real; + psF64 imag; + + out = psImageRecycle(out, numCols, numRows, PS_TYPE_F64); + for (unsigned int row = 0; row < numRows; row++) { + outRow = out->data.F64[row]; + inRow = in->data.C64[row]; + + for (unsigned int col = 0; col < numCols; col++) { + real = crealf(inRow[col]); + imag = cimagf(inRow[col]); + outRow[col] = real * real + imag * imag / numElementsSquared; + } + } + } else { + psError(__func__, "Can not power spectrum for given image type (%d).", type); + psFree(out); + return NULL; + } + + return out; + +} + +/************************************** Vector Functions ***************************************/ + +psVector* psVectorFFT(psVector* out, const psVector* in, psFftDirection direction) +{ + unsigned int numElements; + psElemType type; + fftwf_plan plan; + + /* got good image data? */ + if (in == NULL) { + psFree(out); + return NULL; + } + + type = in->type.type; + + if ((type != PS_TYPE_F32) && (type != PS_TYPE_C32)) { + psError(__func__, "Input image must be a 32-bit float or complex image (type=%d)", type); + psFree(out); + return NULL; + } + + if ((type != PS_TYPE_C32) && (direction == PS_FFT_REVERSE)) { + psError(__func__, "Input image must be complex image for reverse FFT (type=%d).", type); + psFree(out); + return NULL; + + } + + if ((type != PS_TYPE_F32) && (direction == PS_FFT_FORWARD)) { + psError(__func__, "Input image must be real image for forward FFT (type=%d).", type); + psFree(out); + return NULL; + } + + /* make sure the system-level wisdom information is imported. */ + if (!p_fftwWisdomImported) { + fftwf_import_system_wisdom(); + p_fftwWisdomImported = true; + } + + numElements = in->n; + + out = psVectorRecycle(out, numElements, PS_TYPE_C32); + out->n = numElements; + + if (type == PS_TYPE_F32) { + // need to convert to complex + psC32* outVec = out->data.C32; + psF32* inVec = in->data.F32; + + for (unsigned int i = 0; i < numElements; i++) { + outVec[i] = inVec[i]; + } + } else { + psC32* outVec = out->data.C32; + psC32* inVec = in->data.C32; + + for (unsigned int i = 0; i < numElements; i++) { + outVec[i] = inVec[i]; + } + } + + plan = fftwf_plan_dft_1d(numElements, + (fftwf_complex *) out->data.C32, + (fftwf_complex *) out->data.C32, direction, P_FFTW_PLAN_RIGOR); + + /* check if a plan exists now */ + if (plan == NULL) { + psError(__func__, "Failed to create FFTW plan."); + psFree(out); + return NULL; + } + + /* finally, call FFTW with the plan made above */ + fftwf_execute(plan); + + fftwf_destroy_plan(plan); + + return out; +} + +psVector* psVectorReal(psVector* out, const psVector* in) +{ + psElemType type; + unsigned int numElements; + + if (in == NULL) { + psFree(out); + return NULL; + } + + type = in->type.type; + numElements = in->n; + + /* if not a complex number, this is logically just a copy */ + if (!PS_IS_PSELEMTYPE_COMPLEX(type)) { + // Warn user, as this is probably not expected + psLogMsg(__func__, PS_LOG_WARN, "Real portion of a non-Complex type called called for. " + "Just a vector copy was performed."); + out = psVectorRecycle(out, numElements, type); + out->n = numElements; + memcpy(out->data.V, in->data.V, numElements * PSELEMTYPE_SIZEOF(type)); + return out; + } + + if (type == PS_TYPE_C32) { + psF32* outVec; + psC32* inVec = in->data.C32; + + out = psVectorRecycle(out, numElements, PS_TYPE_F32); + out->n = numElements; + outVec = out->data.F32; + + for (unsigned int i = 0; i < numElements; i++) { + outVec[i] = crealf(inVec[i]); + } + } else { + psError(__func__, "Can not extract real component from given vector type (%d).", type); + psFree(out); + return NULL; + } + + return out; +} + +psVector* psVectorImaginary(psVector* out, const psVector* in) +{ + psElemType type; + unsigned int numElements; + + if (in == NULL) { + psFree(out); + return NULL; + } + + type = in->type.type; + numElements = in->n; + + /* if not a complex number, this is logically just zeroed image of same size */ + if (!PS_IS_PSELEMTYPE_COMPLEX(type)) { + // Warn user, as this is probably not expected + psLogMsg(__func__, PS_LOG_WARN, "Imaginary portion of a non-Complex type called for. " + "A zeroed vector was returned."); + out = psVectorRecycle(out, numElements, type); + out->n = numElements; + memset(out->data.V, 0, PSELEMTYPE_SIZEOF(type) * numElements); + return out; + } + + if (type == PS_TYPE_C32) { + psF32* outVec; + psC32* inVec = in->data.C32; + + out = psVectorRecycle(out, numElements, PS_TYPE_F32); + out->n = numElements; + outVec = out->data.F32; + + for (unsigned int i = 0; i < numElements; i++) { + outVec[i] = cimagf(inVec[i]); + } + } else { + psError(__func__, "Can not extract imaginary component from given vector type (%d).", type); + psFree(out); + return NULL; + } + + return out; +} + +psVector* psVectorComplex(psVector* out, const psVector* real, const psVector* imag) +{ + psElemType type; + unsigned int numElements; + + if (real == NULL || imag == NULL) { + psFree(out); + return NULL; + } + + type = real->type.type; + if (real->n < imag->n) { + numElements = real->n; + } else { + numElements = imag->n; + } + + if (imag->type.type != type) { + psError(__func__, "The inputs to psVectorComplex must be the same type."); + psFree(out); + return NULL; + } + + if (PS_IS_PSELEMTYPE_COMPLEX(type)) { + psError(__func__, "The inputs to psVectorComplex can not be complex."); + psFree(out); + return NULL; + } + + if (type == PS_TYPE_F32) { + psC32* outVec; + psF32* realVec = real->data.F32; + psF32* imagVec = imag->data.F32; + + out = psVectorRecycle(out, numElements, PS_TYPE_C32); + out->n = numElements; + outVec = out->data.C32; + + for (unsigned int i = 0; i < numElements; i++) { + outVec[i] = realVec[i] + I * imagVec[i]; + } + } else { + psError(__func__, "Can not merge real and imaginary portions for given vector type (%d).", type); + psFree(out); + return NULL; + } + + return out; +} + +psVector* psVectorConjugate(psVector* out, const psVector* in) +{ + psElemType type; + unsigned int numElements; + + if (in == NULL) { + psFree(out); + return NULL; + } + + type = in->type.type; + numElements = in->n; + + /* if not a complex number, this is logically just a image copy */ + if (!PS_IS_PSELEMTYPE_COMPLEX(type)) { + // Warn user, as this is probably not expected + psLogMsg(__func__, PS_LOG_WARN, "Complex Conjugate of a non-Complex type called for. " + "Vector copy was performed instead."); + + out = psVectorRecycle(out, numElements, type); + out->n = numElements; + memcpy(out->data.V, in->data.V, PSELEMTYPE_SIZEOF(type) * numElements); + return out; + } + + if (type == PS_TYPE_C32) { + psC32* outVec; + psC32* inVec = in->data.C32; + + out = psVectorRecycle(out, numElements, PS_TYPE_C32); + out->n = numElements; + outVec = out->data.C32; + + for (unsigned int i = 0; i < numElements; i++) { + outVec[i] = crealf(inVec[i]) - I * cimagf(inVec[i]); + } + } else { + psError(__func__, "Can not compute complex conjugate for given vector type (%d).", type); + psFree(out); + return NULL; + } + + return out; +} + +psVector* psVectorPowerSpectrum(psVector* out, const psVector* in) +{ + psElemType type; + unsigned int outNumElements; + unsigned int inNumElements; + unsigned int inHalfNumElements; + unsigned int inNumElementsSquared; + + if (in == NULL) { + psFree(out); + return NULL; + } + + type = in->type.type; + inNumElements = in->n; + inNumElementsSquared = inNumElements * inNumElements; + inHalfNumElements = inNumElements / 2; + outNumElements = inHalfNumElements + 1; + + /* if not a complex number, this is not implemented */ + if (!PS_IS_PSELEMTYPE_COMPLEX(type)) { + psError(__func__, "Power Spectrum for non-complex inputs is not implemented."); + psFree(out); + return NULL; + } + + if (type == PS_TYPE_C32) { + psF32* outVec; + psC32* inVec = in->data.C32; + psF32 inAbs1; + psF32 inAbs2; + + out = psVectorRecycle(out, outNumElements, PS_TYPE_F32); + out->n = outNumElements; + outVec = out->data.F32; + + // from ADD: P_0 = |C_0|^2/N^2 + inAbs1 = cabsf(inVec[0]); + outVec[0] = inAbs1 * inAbs1 / inNumElementsSquared; + + // from ADD: P_j = (|C_j|^2+|C_N-j|^2)/N^2, where j = 1,2,...,(N/2-1) + for (unsigned int i = 1; i < inHalfNumElements; i++) { + inAbs1 = cabsf(inVec[i]); + inAbs2 = cabsf(inVec[inNumElements - i]); + outVec[i] = (inAbs1 * inAbs1 + inAbs2 * inAbs2) / inNumElementsSquared; + } + + // from ADD: P_N/2 = |C_N/2|^2/N^2 + inAbs1 = cabsf(inVec[inHalfNumElements]); + outVec[inHalfNumElements] = inAbs1 * inAbs1 / inNumElementsSquared; + } else { + psError(__func__, "Can not power spectrum for given vector type (%d).", type); + psFree(out); + return NULL; + } + + return out; + +} Index: /tags/rel2_1/psLib/src/fft/psVectorFFT.h =================================================================== --- /tags/rel2_1/psLib/src/fft/psVectorFFT.h (revision 1553) +++ /tags/rel2_1/psLib/src/fft/psVectorFFT.h (revision 1553) @@ -0,0 +1,158 @@ + +/** @file psFFT.h + * + * @brief Contains FFT transforms functions + * + * @ingroup Transform + * + * @author Robert DeSonia, MHPCC + * + * @version $Revision: 1.13 $ $Name: not supported by cvs2svn $ + * @date $Date: 2004-08-10 18:54:38 $ + * + * Copyright 2004 Maui High Performance Computing Center, University of Hawaii + */ + +#ifndef PS_FFT_H +#define PS_FFT_H + +#include "psImage.h" +#include "psVector.h" + +/// @addtogroup Transform +/// @{ + +/** Specify direction of FFT */ +typedef enum { + /// psImageFFT/psVectorFFT should perform a forward FFT. + PS_FFT_FORWARD = (-1), + + /// psImageFFT/psVectorFFT should perform a reverse FFT. + PS_FFT_REVERSE = (+1) +} psFftDirection; + +/** Forward and reverse FFT calculations. + * + * This takes as input the image of interest (in) and the direction + * (direction), which is specified by an enumerated type psFftDirection. + * The input image may be of type psF32 or psC32, the result is always + * psC32. If the input vector is psF32, the direction must be forward. + * + * @return psImage* the FFT transformation result + */ +psImage* psImageFFT( + psImage* out, ///< a psImage to recycle. If NULL, a new psImage is made. + const psImage* in, ///< the psImage to apply transform to + psFftDirection direction ///< the direction of the transform +); + +/** extract the real portion of a complex image + * + * @return psImage* real portion of the input image. + */ +psImage* psImageReal( + psImage* out, ///< a psImage to recycle. If NULL, a new psImage is made. + const psImage* in ///< the psImage to extract real portion from +); + +/** extract the imaginary portion of a complex image + * + * @return psImage* imaginary portion of the input image. + */ +psImage* psImageImaginary( + psImage* out, ///< a psImage to recycle. If NULL, a new psImage is made. + const psImage* in ///< the psImage to extract imaginary portion from +); + +/** creates a complex image from separate real and imaginary plane images + * + * @return psImage* resulting complex image + */ +psImage* psImageComplex( + psImage* out, ///< a psImage to recycle. If NULL, a new psImage is made. + const psImage* real, ///< the real plane image + const psImage* imag ///< the imaginary plane image +); + +/** computes the complex conjugate of an image + * + * @return psImage* the complex conjugate of the 'in' image + */ +psImage* psImageConjugate( + psImage* out, ///< a psImage to recycle. If NULL, a new psImage is made. + const psImage* in ///< the psImage to compute conjugate of +); + +/** computes the power spectrum of an image + * + * @return psImage* the power spectrum of the 'in' image + */ +psImage* psImagePowerSpectrum( + psImage* out, ///< a psImage to recycle. If NULL, a new psImage is made. + const psImage* in ///< the psImage to power spectrum of +); + +/** Forward and reverse FFT calculations. + * + * This takes as input the vector of interest (in) and the direction + * (direction), which is specified by an enumerated type psFftDirection. + * The input vector may be of type psF32 or psC32, the result is always + * psC32. If the input vector is psF32, the direction must be forward. + * + * @return psVector* the FFT transformation result + */ +psVector* psVectorFFT( + psVector* out, ///< a psVector to recycle. If NULL, a new psVector is made. + const psVector* in, ///< the vector to apply transform to + psFftDirection direction ///< the direction of the transform +); + +/** extract the real portion of a complex vector + * + * @return psVector* real portion of the input vector. + */ +psVector* psVectorReal( + psVector* out, ///< a psVector to recycle. If NULL, a new psVector is made. + const psVector* in ///< the psVector to extract real portion from +); + +/** extract the imaginary portion of a complex vector + * + * @return psVector* imaginary portion of the input vector. + */ +psVector* psVectorImaginary( + psVector* out, ///< a psVector to recycle. If NULL, a new psVector is made. + const psVector* in ///< the psVector to extract imaginary portion from +); + +/** creates a complex vector from separate real and imaginary vectors + * + * @return psVector* resulting complex vector + */ +psVector* psVectorComplex( + psVector* out, ///< a psVector to recycle. If NULL, a new psVector is made. + const psVector* real, ///< the real vector + const psVector* imag ///< the imaginary vector +); + +/** computes the complex conjugate of a vector + * + * @return psVector* the complex conjugate of the 'in' vector + */ +psVector* psVectorConjugate( + psVector* out, ///< a psVector to recycle. If NULL, a new psVector is made. + const psVector* in ///< the psVector to compute conjugate of +); + +/** computes the power spectrum of a vector + * + * @return psVector* the power spectrum of the 'in' vector + */ +psVector* psVectorPowerSpectrum( + psVector* out, ///< a psVector to recycle. If NULL, a new psVector is made. + const psVector* in ///< the psVector to power spectrum of +); + +/// @} + +#endif Index: /tags/rel2_1/psLib/src/image/Makefile =================================================================== --- /tags/rel2_1/psLib/src/image/Makefile (revision 1553) +++ /tags/rel2_1/psLib/src/image/Makefile (revision 1553) @@ -0,0 +1,84 @@ +############################################################################### +## +## Makefile: collections +## +## $Revision: 1.2 $ $Name: not supported by cvs2svn $ +## $Date: 2004-07-29 21:43:11 $ +## +## Copyright 2004 Maui High Performance Computing Center, University of Hawaii +############################################################################### + +# Define variable prefix to the top level project - psLib +# This is necessary for definition is Makefile.Globals uses prefix + +ifndef prefix + export prefix=$(shell cd ../..;pwd) +endif + +# Define the two targets to be built + +TARGET_STATIC = libpslib.a + +# Include the make global definitions for the project + +include ../Makefile.Globals + +# Set CFLAGS used by the implicit rule to compile .c + +CFLAGS := $(CFLAGS_RELOC) -I../sysUtils -I../dataManip -I../collections + +# Define the source objects + +SRC_OBJS = psImage.o \ + psImageExtraction.o \ + psImageIO.o \ + psImageManip.o \ + psImageStats.o + +OBJS = $(addprefix makedir/,$(SRC_OBJS)) + +# Define PHONY target "all" which will make all the necessary items + +all: $(TARGET_STATIC) + +# Rule to make static library + +libpslib.a: $(OBJS) +# The ar option -r is to add/replace object and -s is to create +# a symbol table in the archive + $(AR) rcs ../$@ $(OBJS) + +# Define PHONY target "install" which will install necessary files + +install: $(TARGET_STATIC) + install *.h $(includedir) + +# Define PHONY target "distclean" which will cleanup the distribution + +distclean: clean + $(RM) ../$(TARGET_STATIC) + +# Define PHONY target "clean" which will cleanup the development area + +clean: + @echo " Deleting intermediate files for 'collections'" + $(RM) $(OBJS) *.lint $(SRC_OBJS:.o=.i) + +cleandep: + $(RM) $(OBJS:.o=.d) + +%.lint: %.c + splint +posixlib -exportlocal -realcompare $(INCLUDE_GLOBAL) $? > $@; cat $@ + +%.i: %.c + $(CC) -E $(CFLAGS) -o $@ $< + +makedir/%.o: %.c + $(CC) -c $(CFLAGS) -o $@ $< + +makedir/%.d: %.c + $(CC) -MM $(CFLAGS) $< > $@.tmp + sed 's|\($*\)\.o[ :]*|\1.o $@ : |g' $@.tmp > $@ + $(RM) -f $@.tmp + +include $(OBJS:.o=.d) Index: /tags/rel2_1/psLib/src/image/psImage.c =================================================================== --- /tags/rel2_1/psLib/src/image/psImage.c (revision 1553) +++ /tags/rel2_1/psLib/src/image/psImage.c (revision 1553) @@ -0,0 +1,436 @@ + +/** @file psImage.c + * + * @brief Contains basic image definitions and operations. + * + * This file defines the basic type for an image struct and functions useful + * in manupulating images. + * + * @author Robert DeSonia, MHPCC + * @author Ross Harman, MHPCC + * + * @version $Revision: 1.39 $ $Name: not supported by cvs2svn $ + * @date $Date: 2004-08-09 23:34:58 $ + * + * Copyright 2004 Maui High Performance Computing Center, University of Hawaii + * + * That is the routine used to generate matrices. + */ + +/******************************************************************************/ + +/* INCLUDE FILES */ + +/******************************************************************************/ + +#include +#include + +#include "psMemory.h" +#include "psAbort.h" +#include "psError.h" +#include "psImage.h" + +static void imageFree(psImage* image); + +/*****************************************************************************/ + +/* FUNCTION IMPLEMENTATION - PUBLIC */ + +/*****************************************************************************/ + +psImage* psImageAlloc(unsigned int numCols, unsigned int numRows, const psElemType type) +{ + int area = 0; + int elementSize = PSELEMTYPE_SIZEOF(type); // element + + // size in + // bytes + int rowSize = numCols * elementSize; // row + + // size + + // in bytes. + + area = numCols * numRows; + + if (area < 1) { + psError(__func__, + "Invalid value for number of rows or columns " "(numRows=%d, numCols=%d).", numRows, numCols); + return NULL; + } + + psImage* image = (psImage* ) psAlloc(sizeof(psImage)); + + if (image == NULL) { + psAbort(__func__, " : Line %d - Failed to allocate memory", __LINE__); + } + + p_psMemSetDeallocator(image, (psFreeFcn) imageFree); + + image->data.V = psAlloc(sizeof(void *) * numRows); + if (image->data.V == NULL) { + psAbort(__func__, " : Line %d - Failed to allocate memory", __LINE__); + } + + image->data.V[0] = psAlloc(area * elementSize); + if (image->data.V[0] == NULL) { + psAbort(__func__, " : Line %d - Failed to allocate memory", __LINE__); + } + + for (int i = 1; i < numRows; i++) { + image->data.V[i] = (void *)((int8_t *) image->data.V[i - 1] + rowSize); + } + + *(int *)&image->col0 = 0; + *(int *)&image->row0 = 0; + *(unsigned int *)&image->numCols = numCols; + *(unsigned int *)&image->numRows = numRows; + *(psDimen* ) & image->type.dimen = PS_DIMEN_IMAGE; + *(psElemType* ) & image->type.type = type; + image->parent = NULL; + image->nChildren = 0; + image->children = NULL; + + return image; +} + +static void imageFree(psImage* image) +{ + if (image == NULL) { + return; + } + + if (image->type.type == PS_TYPE_PTR) { + // 2-D array of pointers -- must + // dereference + unsigned int oldNumRows = image->numRows; + unsigned int oldNumCols = image->numCols; + psPTR* rowPtr; + + for (unsigned int row = 0; row < oldNumRows; row++) { + rowPtr = image->data.PTR[row]; + for (unsigned int col = 0; col < oldNumCols; col++) { + psMemDecrRefCounter(rowPtr[col]); + } + } + } + + psImageFreeChildren(image); + + psFree(image->data.V[0]); + psFree(image->data.V); + image->data.V = NULL; +} + +psImage* psImageRecycle(psImage* old, unsigned int numCols, unsigned int numRows, const psElemType type) +{ + int elementSize = PSELEMTYPE_SIZEOF(type); // element + + // size in + // bytes + int rowSize = numCols * elementSize; // row + + // size + + // in bytes. + + if (old == NULL) { + old = psImageAlloc(numCols, numRows, type); + return old; + } + + if (old->type.dimen != PS_DIMEN_IMAGE) { + psError(__func__, "Can not realloc image because input is not an image."); + return NULL; + } + + if (old->type.type == PS_TYPE_PTR) { + // 2-D array of pointers -- must + // dereference + unsigned int oldNumRows = old->numRows; + unsigned int oldNumCols = old->numCols; + psPTR* rowPtr; + + for (unsigned int row = 0; row < oldNumRows; row++) { + rowPtr = old->data.PTR[row]; + for (unsigned int col = 0; col < oldNumCols; col++) { + psMemDecrRefCounter(rowPtr[col]); + rowPtr[col] = NULL; + } + } + } + + /* image already the right size/type? */ + if (numCols == old->numCols && numRows == old->numRows && type == old->type.type) { + return old; + } + // Resize the image buffer + old->data.V[0] = psRealloc(old->data.V[0], numCols * numRows * elementSize); + old->data.V = (void **)psRealloc(old->data.V, numRows * sizeof(void *)); + + // recreate the row pointers + for (int i = 1; i < numRows; i++) { + old->data.V[i] = (void *)((int8_t *) old->data.V[i - 1] + rowSize); + } + + *(unsigned int *)&old->numCols = numCols; + *(unsigned int *)&old->numRows = numRows; + *(psElemType* ) & old->type.type = type; + + return old; +} + +int psImageFreeChildren(psImage* image) +{ + int i = 0; + int nChildren = 0; + psImage* *children = NULL; + int numFreed = 0; + + if (image == NULL) { + return numFreed; + } + + nChildren = image->nChildren; + children = image->children; + + for (i = 0; i < nChildren; i++) { + if (children[i] != NULL) { + numFreed++; + psFree(children[i]); + } + } + psFree(children); + + image->nChildren = 0; + image->children = NULL; + + return numFreed; +} + +/***************************************************************************** +p_psImagePixelInterpolation(image, x, y): this routine takes as input an +image and coordinates (x, y) and produces as output the corresponding pixel +value at the those coordinates. For fractional corrdinates (x, y), 2-D +linear interpolation is performed on the image. + *****************************************************************************/ +psF32 psImagePixelInterpolate(const psImage* input, + float x, float y, psF32 unexposedValue, psImageInterpolateMode mode) +{ + + if (input == NULL) { + psError(__func__, "Image can not be NULL."); + return unexposedValue; + } + #define PSIMAGE_PIXEL_INTERPOLATE_CASE(TYPE) \ +case PS_TYPE_##TYPE: \ + switch (mode) { \ + case PS_INTERPOLATE_FLAT: \ + return p_psImagePixelInterpolateFLAT_##TYPE(input,x,y,unexposedValue); \ + break; \ + case PS_INTERPOLATE_BILINEAR: \ + return p_psImagePixelInterpolateBILINEAR_##TYPE(input,x,y,unexposedValue); \ + break; \ + default: \ + psError(__func__,"Unsupported interpolation mode (#%d)",mode); \ + } \ + break + + switch (input->type.type) { + PSIMAGE_PIXEL_INTERPOLATE_CASE(U8); + PSIMAGE_PIXEL_INTERPOLATE_CASE(U16); + PSIMAGE_PIXEL_INTERPOLATE_CASE(U32); + PSIMAGE_PIXEL_INTERPOLATE_CASE(U64); + PSIMAGE_PIXEL_INTERPOLATE_CASE(S8); + PSIMAGE_PIXEL_INTERPOLATE_CASE(S16); + PSIMAGE_PIXEL_INTERPOLATE_CASE(S32); + PSIMAGE_PIXEL_INTERPOLATE_CASE(S64); + PSIMAGE_PIXEL_INTERPOLATE_CASE(F32); + PSIMAGE_PIXEL_INTERPOLATE_CASE(F64); + PSIMAGE_PIXEL_INTERPOLATE_CASE(C32); + PSIMAGE_PIXEL_INTERPOLATE_CASE(C64); + default: + psError(__func__, "Unsupported image datatype (%d)", input->type.type); + } + + return unexposedValue; +} + +#define PSIMAGE_PIXEL_INTERPOLATE_FLAT(TYPE) \ +inline psF64 p_psImagePixelInterpolateFLAT_##TYPE(const psImage* input, \ + float x, \ + float y, \ + psF64 unexposedValue) \ +{ \ + int intX = (int) round((psF64)(x) - 0.5); \ + int intY = (int) round((psF64)(y) - 0.5); \ + int lastX = input->numCols - 1; \ + int lastY = input->numRows - 1; \ + \ + if ((intX < 0) || \ + (intX > lastX) || \ + (intY < 0) || \ + (intY > lastY)) { \ + return unexposedValue; \ + } \ + \ + return input->data.TYPE[intY][intX]; \ +} + +#define PSIMAGE_PIXEL_INTERPOLATE_FLAT_COMPLEX(TYPE) \ +inline psC64 p_psImagePixelInterpolateFLAT_##TYPE(const psImage* input, \ + float x, \ + float y, \ + psC64 unexposedValue) \ +{ \ + int intX = (int) round((psF64)(x) - 0.5); \ + int intY = (int) round((psF64)(y) - 0.5); \ + int lastX = input->numCols - 1; \ + int lastY = input->numRows - 1; \ + \ + if ((intX < 0) || \ + (intX > lastX) || \ + (intY < 0) || \ + (intY > lastY)) { \ + return unexposedValue; \ + } \ + \ + return input->data.TYPE[intY][intX]; \ +} + +PSIMAGE_PIXEL_INTERPOLATE_FLAT(U8) +PSIMAGE_PIXEL_INTERPOLATE_FLAT(U16) +PSIMAGE_PIXEL_INTERPOLATE_FLAT(U32) +PSIMAGE_PIXEL_INTERPOLATE_FLAT(U64) +PSIMAGE_PIXEL_INTERPOLATE_FLAT(S8) +PSIMAGE_PIXEL_INTERPOLATE_FLAT(S16) +PSIMAGE_PIXEL_INTERPOLATE_FLAT(S32) +PSIMAGE_PIXEL_INTERPOLATE_FLAT(S64) +PSIMAGE_PIXEL_INTERPOLATE_FLAT(F32) +PSIMAGE_PIXEL_INTERPOLATE_FLAT(F64) +PSIMAGE_PIXEL_INTERPOLATE_FLAT_COMPLEX(C32) +PSIMAGE_PIXEL_INTERPOLATE_FLAT_COMPLEX(C64) +#define PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(TYPE) \ +inline psF64 p_psImagePixelInterpolateBILINEAR_##TYPE(const psImage* input, \ + float x, \ + float y, \ + psF64 unexposedValue) \ +{ \ + double floorX = floor((psF64)(x) - 0.5); \ + double floorY = floor((psF64)(y) - 0.5); \ + double fracX = x - 0.5 - floorX; \ + double fracY = y - 0.5 - floorY; \ + int intFloorX = (int) floorX; \ + int intFloorY = (int) floorY; \ + int lastX = input->numCols - 1; \ + int lastY = input->numRows - 1; \ + double rx = 0.0; \ + psF64 pixel = 0.0; \ + ps##TYPE* currentRow; \ + ps##TYPE* nextRow; \ + \ + if ((intFloorX < 0) || \ + (intFloorX > lastX) || \ + (intFloorY < 0) || \ + (intFloorY > lastY)) { \ + return unexposedValue; \ + } \ + \ + currentRow = input->data.TYPE[intFloorY]; \ + if (intFloorY == lastY) { \ + pixel = currentRow[intFloorX]; \ + if (intFloorX < lastX) { \ + pixel+= fracY * ((psF64)currentRow[intFloorX+1] - \ + (psF64)currentRow[intFloorX]); \ + } \ + return(pixel); \ + } \ + nextRow = input->data.TYPE[intFloorY+1]; \ + if (intFloorX == lastX) { \ + pixel = currentRow[intFloorX]; \ + if (intFloorY < lastY) { \ + pixel+= fracX * ((psF64)nextRow[intFloorX] - \ + (psF64)currentRow[intFloorX]); \ + } \ + return(pixel); \ + } \ + \ + rx = currentRow[intFloorX] + \ + fracX * ((psF64)currentRow[intFloorX+1] - \ + (psF64)currentRow[intFloorX]); \ + \ + pixel = rx + fracY * ((psF64)nextRow[intFloorX] + \ + fracX * ((psF64)nextRow[intFloorX+1] - \ + (psF64)nextRow[intFloorX]) - rx); \ + \ + return(pixel); \ +} +#define PSIMAGE_PIXEL_INTERPOLATE_BILINEAR_COMPLEX(TYPE) \ +inline psC64 p_psImagePixelInterpolateBILINEAR_##TYPE(const psImage* input, \ + float x, \ + float y, \ + psC64 unexposedValue) \ +{ \ + double floorX = floor((psF64)(x) - 0.5); \ + double floorY = floor((psF64)(y) - 0.5); \ + double fracX = x - 0.5 - floorX; \ + double fracY = y - 0.5 - floorY; \ + int intFloorX = (int) floorX; \ + int intFloorY = (int) floorY; \ + int lastX = input->numCols - 1; \ + int lastY = input->numRows - 1; \ + double rx = 0.0; \ + psC64 pixel = 0.0; \ + ps##TYPE* currentRow; \ + ps##TYPE* nextRow; \ + \ + if ((intFloorX < 0) || \ + (intFloorX > lastX) || \ + (intFloorY < 0) || \ + (intFloorY > lastY)) { \ + return unexposedValue; \ + } \ + \ + currentRow = input->data.TYPE[intFloorY]; \ + if (intFloorY == lastY) { \ + pixel = currentRow[intFloorX]; \ + if (intFloorX < lastX) { \ + pixel+= fracY * (currentRow[intFloorX+1] - \ + currentRow[intFloorX]); \ + } \ + return(pixel); \ + } \ + nextRow = input->data.TYPE[intFloorY+1]; \ + if (intFloorX == lastX) { \ + pixel = currentRow[intFloorX]; \ + if (intFloorY < lastY) { \ + pixel+= fracX * (nextRow[intFloorX] - \ + currentRow[intFloorX]); \ + } \ + return(pixel); \ + } \ + \ + rx = currentRow[intFloorX] + \ + fracX * (currentRow[intFloorX+1] - \ + currentRow[intFloorX]); \ + \ + pixel = rx + fracY * ((psF64)nextRow[intFloorX] + \ + fracX * (nextRow[intFloorX+1] - \ + nextRow[intFloorX]) - rx); \ + \ + return(pixel); \ +} + +PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(U8) +PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(U16) +PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(U32) +PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(U64) +PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(S8) +PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(S16) +PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(S32) +PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(S64) +PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(F32) +PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(F64) +PSIMAGE_PIXEL_INTERPOLATE_BILINEAR_COMPLEX(C32) +PSIMAGE_PIXEL_INTERPOLATE_BILINEAR_COMPLEX(C64) Index: /tags/rel2_1/psLib/src/image/psImage.h =================================================================== --- /tags/rel2_1/psLib/src/image/psImage.h (revision 1553) +++ /tags/rel2_1/psLib/src/image/psImage.h (revision 1553) @@ -0,0 +1,162 @@ + +/** @file psImage.h + * + * @brief Contains basic image definitions and operations + * + * This file defines the basic type for an image struct and functions useful + * in manupulating images. + * + * @ingroup Image + * + * @author Robert DeSonia, MHPCC + * @author Ross Harman, MHPCC + * + * @version $Revision: 1.32 $ $Name: not supported by cvs2svn $ + * @date $Date: 2004-08-10 01:05:53 $ + * + * Copyright 2004 Maui High Performance Computing Center, University of Hawaii + */ +#ifndef PS_IMAGE_H +#define PS_IMAGE_H + +#include + +#include "psType.h" + +/// @addtogroup Image +/// @{ + +/** enumeration of options in interpolation + * + */ +typedef enum { + PS_INTERPOLATE_FLAT, ///< 'flat' interpolation (nearest pixel) + PS_INTERPOLATE_BILINEAR ///< bi-linear interpolation +} psImageInterpolateMode; + +/** Basic image data structure. + * + * Struct for maintaining image data of varying types. It also contains + * information about image size, parent images and children images. + * + */ +typedef struct psImage +{ + const psType type; ///< Image data type and dimension. + const unsigned int numCols; ///< Number of columns in image + const unsigned int numRows; ///< Number of rows in image. + const int col0; ///< Column position relative to parent. + const int row0; ///< Row position relative to parent. + + union { + psU8* *U8; ///< Unsigned 8-bit integer data. + psU16* *U16; ///< Unsigned 16-bit integer data. + psU32* *U32; ///< Unsigned 32-bit integer data. + psU64* *U64; ///< Unsigned 64-bit integer data. + psS8* *S8; ///< Signed 8-bit integer data. + psS16* *S16; ///< Signed 16-bit integer data. + psS32* *S32; ///< Signed 32-bit integer data. + psS64* *S64; ///< Signed 64-bit integer data. + psF32* *F32; ///< Single-precision float data. + psF64* *F64; ///< Double-precision float data. + psC32* *C32; ///< Single-precision complex data. + psC64* *C64; ///< Double-precision complex data. + psPTR* *PTR; ///< Void pointers. + psPTR* V; ///< Pointer to data. + } data; ///< Union for data types. + const struct psImage* parent; ///< Parent, if a subimage. + int nChildren; ///< Number of subimages. + struct psImage* *children; ///< Children of this region. +} +psImage; + +/** Create an image of the specified size and type. + * + * Uses psLib memory allocation functions to create an image struct of the + * specified size and type. + * + * @return psImage* : Pointer to psImage. + * + */ +psImage* psImageAlloc( + unsigned int numCols, ///< Number of rows in image. + unsigned int numRows, ///< Number of columns in image. + const psElemType type ///< Type of data for image. +); + +/** Resize a given image to the given size/type. + * + * @return psImage* Resized psImage. + * + */ +psImage* psImageRecycle( + psImage* old, ///< the psImage to recycle by resizing image buffer + unsigned int numCols, ///< the desired number of columns in image + unsigned int numRows, ///< the desired number of rows in image + const psElemType type ///< the desired datatype of the image +); + +/** Frees all children of a psImage. + * + * @return int Number of children freed. + * + */ +int psImageFreeChildren( + psImage* image ///< psImage in which all children shall be deallocated +); + +/** Interpolate image pixel value given floating point coordinates. + * + * @return psF32 Pixel value interpolated from image or unexposedValue if + * given x,y doesn't coorespond to a valid image location + */ +psF32 psImagePixelInterpolate( + const psImage* input, ///< input image for interpolation + float x, ///< column location to derive value of + float y, ///< row location ot derive value of + psF32 unexposedValue, ///< return value if x,y location is not in image. + psImageInterpolateMode mode ///< interpolation mode +); + +#define p_psImagePixelInterpolateFcns(TYPE) \ +inline psF64 p_psImagePixelInterpolateFLAT_##TYPE( \ + const psImage* input, \ + float x, \ + float y, \ + psF64 unexposedValue \ + ); \ +inline psF64 p_psImagePixelInterpolateBILINEAR_##TYPE( \ + const psImage* input, \ + float x, \ + float y, \ + psF64 unexposedValue \ + ); + +#define p_psImagePixelInterpolateComplexFcns(TYPE) \ +inline psC64 p_psImagePixelInterpolateFLAT_##TYPE( \ + const psImage* input, \ + float x, \ + float y, \ + psC64 unexposedValue \ + ); \ +inline psC64 p_psImagePixelInterpolateBILINEAR_##TYPE( \ + const psImage* input, \ + float x, \ + float y, \ + psC64 unexposedValue \ + ); + +p_psImagePixelInterpolateFcns(U8) +p_psImagePixelInterpolateFcns(U16) +p_psImagePixelInterpolateFcns(U32) +p_psImagePixelInterpolateFcns(U64) +p_psImagePixelInterpolateFcns(S8) +p_psImagePixelInterpolateFcns(S16) +p_psImagePixelInterpolateFcns(S32) +p_psImagePixelInterpolateFcns(S64) +p_psImagePixelInterpolateFcns(F32) +p_psImagePixelInterpolateFcns(F64) +p_psImagePixelInterpolateComplexFcns(C32) +p_psImagePixelInterpolateComplexFcns(C64) +/// @} +#endif Index: /tags/rel2_1/psLib/src/image/psImageExtraction.c =================================================================== --- /tags/rel2_1/psLib/src/image/psImageExtraction.c (revision 1553) +++ /tags/rel2_1/psLib/src/image/psImageExtraction.c (revision 1553) @@ -0,0 +1,491 @@ + +/** @file psImageExtraction.c +* +* @brief Contains basic image extraction operations, as specified in the +* PSLIB SDRS sections "Image Pixel Extractions" and "Image Structure +* Manipulation". +* +* @ingroup Image +* +* @author Robert DeSonia, MHPCC +* +* @version $Revision: 1.9 $ $Name: not supported by cvs2svn $ +* @date $Date: 2004-08-09 23:34:58 $ +* +* Copyright 2004 Maui High Performance Computing Center, University of Hawaii +* +*/ + +#include + +#include "psMemory.h" +#include "psImageExtraction.h" +#include "psError.h" + +psImage* psImageSubset(psImage* out, + psImage* image, + unsigned int numCols, unsigned int numRows, unsigned int col0, unsigned int row0) +{ + unsigned int elementSize; // size of image + + // element in + // bytes + unsigned int outputRowSize; // output row + + // size in bytes + unsigned int inputColOffset; // offset + + // in + // bytes + // to + // first + // subset + + // pixel in input row + + if (image == NULL || image->data.V == NULL) { + psError(__func__, "Can not subset image because input image or its pixel buffer is NULL."); + return NULL; + } + + if (image->type.dimen != PS_DIMEN_IMAGE) { + psError(__func__, "Can not subset image because input image is not an image."); + return NULL; + } + + if (numCols < 1 || numRows < 1) { + psError(__func__, + "Can not subset image because number of rows or columns are zero (%dx%d).", numCols, numRows); + return NULL; + } + + if (col0 >= image->numCols || row0 >= image->numRows) { + psError(__func__, + "Can not subset image because col0,row0 (%d,%d) is not a valid pixel location.", col0, row0); + return NULL; + } + + /* validate subimage size */ + if (col0 + numCols >= image->numCols || row0 + numRows >= image->numRows) { + psError(__func__, + "Can not subset image outside of image boundaries (size=%dx%d, " + "subset=[%d:%d,%d:%d]).", + image->numCols, image->numRows, col0, col0 + numCols, row0, row0 + numRows); + return NULL; + } + + elementSize = PSELEMTYPE_SIZEOF(image->type.type); + + out = psImageRecycle(out, numCols, numRows, image->type.type); + + // set the parent information into the child + // output image + *(int *)&out->row0 = row0; + *(int *)&out->col0 = col0; + *(psImage* *) & out->parent = (psImage* ) image; + + // add output image as a child of the input + // image. + image->nChildren++; + image->children = (psImage* *) psRealloc(image->children, image->nChildren * sizeof(psImage* )); + image->children[image->nChildren - 1] = out; + + inputColOffset = elementSize * col0; + outputRowSize = elementSize * numCols; + + for (int row = 0; row < numRows; row++) { + memcpy(out->data.V[row], image->data.U8[row0 + row] + inputColOffset, outputRowSize); + } + + return (out); +} + +psImage* psImageCopy(psImage* restrict output, const psImage* input, psElemType type) +{ + psElemType inDatatype; + int elementSize; + int elements; + int numRows; + int numCols; + + if (input == NULL || input->data.V == NULL) { + psError(__func__, "Can not copy image because input image or its pixel buffer is NULL."); + psFree(output); + return NULL; + } + + if (input == output) { + psError(__func__, + "Can not copy image because given input and output " + "parameter reference the same psImage struct."); + psFree(output); + return NULL; + } + + if (input->type.dimen != PS_DIMEN_IMAGE) { + psError(__func__, "Can not copy image because input image is not actually an image."); + psFree(output); + return NULL; + } + + inDatatype = input->type.type; + numRows = input->numRows; + numCols = input->numCols; + elements = numRows * numCols; + elementSize = PSELEMTYPE_SIZEOF(inDatatype); + + if (inDatatype == PS_TYPE_PTR || type == PS_TYPE_PTR) { + psError(__func__, "Can not copy image to/from a void* matrix"); + psFree(output); + return NULL; + } + + output = psImageRecycle(output, numCols, numRows, type); + + // cover the trival case of copy of the same + // datatype. + if (type == inDatatype) { + memcpy(output->data.V[0], input->data.V[0], elementSize * elements); + return output; + } + #define PSIMAGE_ELEMENT_COPY(IN,INTYPE,OUT,OUTTYPE,ELEMENTS) { \ + ps##INTYPE *in = IN->data.INTYPE[0]; \ + ps##OUTTYPE *out = OUT->data.OUTTYPE[0]; \ + for (int e=0;edata.V == NULL) { + psError(__func__, "Input image can not be NULL."); + psFree(out); + return NULL; + } + + if (numRows == 0 || numCols == 0) { + psError(__func__, "The specified region contains no data (%dx%d)", numCols, numRows); + psFree(out); + return NULL; + } + + type = in->type.type; + inRows = in->numRows; + inCols = in->numCols; + + if (direction == PS_CUT_X_NEG || direction == PS_CUT_Y_NEG) { + delta = -1; + } + // if numRows/numCols is negative, invert the + // problem to give positive + // numRows/numCols (and cut in opposite + // direction). + if (numRows < 0) { + numRows = -numRows; + row -= (numRows - 1); + delta = -delta; + } + + if (numCols < 0) { + numCols = -numCols; + col -= (numCols - 1); + delta = -delta; + } + + if (mask != NULL) { + if (inRows != mask->numRows || inCols != mask->numCols) { + psError(__func__, + "The mask and image dimensions did not match (%dx%d vs %dx%d)", + mask->numCols, mask->numRows, in->numCols, in->numRows); + psFree(out); + } + if (mask->type.type != PS_TYPE_MASK) { + psError(__func__, "The mask datatype (%d) must be %s.", mask->type.type, PS_TYPE_MASK_NAME); + psFree(out); + } + } + + if (row >= inRows || col >= inCols || col + numCols > in->numCols || row + numRows > in->numRows) { + psError(__func__, + "The specified image region (%d,%d to %d,%d) is outside of image area (0,0 to %d,%d).", + col, row, col + numCols - 1, row + numRows - 1, in->numCols - 1, in->numRows - 1); + psFree(out); + return NULL; + } + // verify that the stats struct specifies a + // single stats operation + if (stats == NULL || p_psGetStatValue(stats, &statVal) == false) { + psError(__func__, "The stat options didn't specify a single supported statistic type."); + psFree(out); + return NULL; + } + // since stats input is const, I need to + // create a 'scratch' stats struct + myStats = psAlloc(sizeof(psStats)); + *myStats = *stats; + + if (direction == PS_CUT_X_POS || direction == PS_CUT_X_NEG) { + psVector* imgVec = psVectorAlloc(numRows, type); + psVector* maskVec = NULL; + psMaskType* maskData = NULL; + psU32* outPosition = NULL; + + // recycle output to make a proper + // sized/type output structure + // n.b. type is double as that is the + // type given for all stats in + // psStats. + out = psVectorRecycle(out, numCols, PS_TYPE_F64); + if (slicePositions != NULL) { + slicePositions = psVectorRecycle(slicePositions, numCols, PS_TYPE_U32); + outPosition = slicePositions->data.U32; + } + outData = out->data.F64; + if (delta < 0) { + outData += numCols - 1; + if (outPosition != NULL) { + outPosition += numCols - 1; + } + } + + if (mask != NULL) { + maskVec = psVectorAlloc(numRows, mask->type.type); + } + #define PSIMAGE_CUT_VERTICAL(TYPE) \ + case PS_TYPE_##TYPE: { \ + psMaskType* maskVecData = NULL; \ + for (int c=0;cdata.TYPE[row] + col + c; \ + ps##TYPE *imgVecData = imgVec->data.TYPE; \ + if (maskVec != NULL) { \ + maskVecData = maskVec->data.V; \ + maskData = (psMaskType* )(mask->data.V[row]) + col + c; \ + } \ + for (int r=0;rtype = in->type; + imgVec->n = imgVec->nalloc = numCols; + if (mask != NULL) { + maskVec = psAlloc(sizeof(psVector)); + maskVec->type = mask->type; + maskVec->n = maskVec->nalloc = numCols; + } + // recycle output to make a proper + // sized/type output structure + // n.b. type is double as that is the + // type given for all stats in + // psStats. + out = psVectorRecycle(out, numRows, PS_TYPE_F64); + if (slicePositions != NULL) { + slicePositions = psVectorRecycle(slicePositions, numRows, PS_TYPE_U32); + outPosition = slicePositions->data.U32; + } + outData = out->data.F64; + if (delta < 0) { + outData += numRows - 1; + if (outPosition != NULL) { + outPosition += numRows - 1; + } + } + + for (int r = 0; r < numRows; r++) { + // point the vector struct to the + // data to calculate the stats + imgVec->data.V = (void *)(in->data.U8[row + r] + col * elementSize); + if (maskVec != NULL) { + maskVec->data.V = (void *)(mask->data.U8[row + r] + col * sizeof(psMaskType)); + } + myStats = psVectorStats(myStats, imgVec, maskVec, maskVal); + (void)p_psGetStatValue(myStats, &statVal); // we + // know + // it + // works + // cause we tested it + // above + *outData = statVal; + if (outPosition != NULL) { + *outPosition = row + r; + outPosition += delta; + + } + outData += delta; + } + psFree(imgVec); + psFree(maskVec); + } else { // don't + // know + // what + // the + // direction + // flag + // is + psError(__func__, "Invalid direction flag (%d)", direction); + psFree(out); + out = NULL; + } + + psFree(myStats); + + return out; +} Index: /tags/rel2_1/psLib/src/image/psImageExtraction.h =================================================================== --- /tags/rel2_1/psLib/src/image/psImageExtraction.h (revision 1553) +++ /tags/rel2_1/psLib/src/image/psImageExtraction.h (revision 1553) @@ -0,0 +1,152 @@ + +/** @file psImageExtraction.h +* +* @brief Contains basic image extraction operations, as specified in the +* PSLIB SDRS sections "Image Pixel Extractions" and "Image Structure +* Manipulation". +* +* @ingroup Image +* +* @author Robert DeSonia, MHPCC +* +* @version $Revision: 1.9 $ $Name: not supported by cvs2svn $ +* @date $Date: 2004-08-09 23:40:55 $ +* +* Copyright 2004 Maui High Performance Computing Center, University of Hawaii +*/ + +#ifndef PSIMAGEEXTRACTION_H +#define PSIMAGEEXTRACTION_H + +#include "psImage.h" +#include "psVector.h" +#include "psStats.h" + +/// @addtogroup Image +/// @{ + +/* Cut direction flag. Used with psImageCut function. + */ +typedef enum { + PS_CUT_X_POS, ///< Cut in the x dimension from left to right + PS_CUT_X_NEG, ///< Cut in the x dimension from rigth to left + PS_CUT_Y_POS, ///< Cut in the y dimension from bottom up + PS_CUT_Y_NEG, ///< Cut in the y dimension from top down. +} psImageCutDirection; + +/** Create a subimage of the specified area. + * + * Uses psLib memory allocation functions to create an image based on a larger + * one. + * + * @return psImage* : Pointer to psImage. + * + */ +psImage* psImageSubset( + psImage* out, ///< image to recycle, or NULL. + psImage* image, ///< Parent image. + unsigned int numCols, ///< Subimage width (<= image.nCols - col0). + unsigned int numRows, ///< Subimage height (<= image.nRows - row0). + unsigned int col0, ///< Subimage col-offset (0 <= col0 < nCol). + unsigned int row0 ///< Subimage row-offset (0 <= row0 < nCol). +); + +/** Makes a copy of a psImage + * + * @return psImage* Copy of the input psImage. This may not be equal to the + * output parameter + * + */ +psImage* psImageCopy( + psImage* restrict output, ///< if not NULL, a psImage that could be recycled. + const psImage* input, ///< the psImage to copy + psElemType type ///< the desired datatype of the returned copy +); + + +/** Extract pixels from rectlinear region to a vector (array of floats). + * + * The output vector contains either nx or ny elements, based on the value of + * the direction: e.g., if direction is PS_CUT_X_POS, there are nx elements. + * The input region is collapsed in the perpendicular direction, and each + * element of the output vectors is derived from the statistics of the pixels + * at that direction coordinate. The statistic used to derive the output + * vector value is specified by stats. Only one of the statistics choices may + * be specified, otherwise the function must return an error. This function + * must be defined for the following types: psS8, psU16, psF32, psF64. + * + * @return psVector the resulting vector + */ +psVector* psImageSlice( + psVector* out, ///< psVector to recycle, or NULL. + psVector* slicePositions, + ///< If not NULL, it is populated with the coordinate in the slice dimension + ///< coorsponding to the output vector's value of the same position in the + ///< vector. This vector maybe resized and retyped as appropriate. + const psImage* restrict input, ///< the input image in which to perform the slice + const psImage* restrict mask, ///< the mask for the input image. + unsigned int maskVal, ///< the mask value to apply to the mask + unsigned int col, ///< the leftmost column of the slice region + unsigned int row, ///< the bottommost row of the slice region + unsigned int numCols, ///< the number of columns in the slice region + unsigned int numRows, ///< the number of rows in the slice region + psImageCutDirection direction, ///< the slice dimension and direction + const psStats* stats ///< the statistic to perform in slice operation +); + +/** Extract pixels from an image along a line to a vector (array of floats). + * + * The vector (xs,ys) - (xe,ye) forms the basis of the output vector. Pixels + * are considered in a rectangular region of width dw about this vector. The + * input region is collapsed in the perpendicular direction, and each element + * of the output vector represents pixel-sized boxes, where the value is + * derived from the statistics of the pixels interpolated along the + * perpendicular direction. The specific algorithm which must be used is + * described in the PSLib ADD (PSDC-430-006). The statistic used to derive + * the output vector value is specified by stats. Only one of the statistics + * choices may be specified, otherwise the function must return an error. + * This function must be defined for the following types: psS8, psU16, psF32, + * psF64. + * + * @return psVector resulting vector + */ +psVector* psImageCut( + psVector* out, ///< psVector to recycle, or NULL. + const psImage* input, ///< the input image in which to perform the cut + const psImage* restrict mask, ///< the mask for the input image. + unsigned int maskVal, ///< the mask value to apply to the mask + float startCol, ///< the column of the start of the cut line + float startRow, ///< the row of the start of the cut line + float endCol, ///< the column of the end of the cut line + float endRow, ///< the row of the end of the cut line + float width, ///< the distance about the line to perform the statistics + const psStats* stats ///< the statistic to perform in operation +); + +/** Extract radial region data to a vector. A vector is constructed where each + * vector elements is derived from the statistics of the pixels which land + * within one of a sequence of radii. The radii are centered on the image + * pixel coordinate x,y, and are defined by the sequence of values in the + * vector radii. The specific algorithm which must be used is described in + * the PSLib ADD (PSDC-430-006). The statistic used to derive the output + * vector value is specified by stats. Only one of the statistics choices + * may be specified, otherwise the function must return an error. This + * function must be defined for the following types: psS8, psU16, psF32, + * psF64. + * + * @return psVector resulting vector + */ +psVector* psImageRadialCut( + psVector* out, ///< psVector to recycle, or NULL. + const psImage* input, ///< the input image in which to perform the cut + const psImage* restrict mask, ///< the mask for the input image. + unsigned int maskVal, ///< the mask value to apply to the mask + float centerCol, ///< the column of the center of the cut circle + float centerRow, ///< the row of the center of the cut circle + const psVector* radii, ///< the radii of the cut circle + const psStats* stats ///< the statistic to perform in operation +); + +/// @} + +#endif Index: /tags/rel2_1/psLib/src/image/psImageIO.c =================================================================== --- /tags/rel2_1/psLib/src/image/psImageIO.c (revision 1553) +++ /tags/rel2_1/psLib/src/image/psImageIO.c (revision 1553) @@ -0,0 +1,376 @@ + +/** @file psImageIO.c + * + * @brief Contains image I/O routines. + * + * This file defines the file input/output functions for the psImage structure. + * + * @author Robert DeSonia, MHPCC + * + * @version $Revision: 1.10 $ $Name: not supported by cvs2svn $ + * @date $Date: 2004-08-09 23:34:58 $ + * + * Copyright 2004 Maui High Performance Computing Center, University of Hawaii + */ + +#include +#include +#include + +#include "psImageIO.h" +#include "psError.h" +#include "psMemory.h" + +psImage* psImageReadSection(psImage* output, + int col, + int row, + int numCols, int numRows, int z, char *extname, int extnum, char *filename) +{ + fitsfile *fptr = NULL; /* Pointer to the FITS file */ + int status = 0; /* CFITSIO file vars */ + int nAxis = 0; + int anynull = 0; + int bitPix = 0; /* Pixel type */ + long nAxes[3]; + long firstPixel[3]; /* lower-left corner of image subset */ + long lastPixel[3]; /* upper-right corner of image subset */ + long increment[3]; /* increment for image subset */ + char fitsErr[80] = ""; /* CFITSIO error message string */ + int hduType = IMAGE_HDU; + int fitsDatatype = 0; + int datatype = 0; + + if (filename == NULL) { + psError(__func__, "Must specify filename; it can not be NULL."); + psFree(output); + return NULL; + } + + /* Open the FITS file */ + (void)fits_open_file(&fptr, filename, READONLY, &status); + if (fptr == NULL || status != 0) { + fits_get_errstatus(status, fitsErr); + psError(__func__, "Could not open file '%s'. (%s)", filename, fitsErr); + psFree(output); + return NULL; + } + + /* find the specified extension */ + if (extname != NULL) { + if (fits_movnam_hdu(fptr, hduType, extname, 0, &status) != 0) { + fits_get_errstatus(status, fitsErr); + status = 0; + (void)fits_close_file(fptr, &status); + psError(__func__, "Could not index to '%s' HDU for file %s. (%s)", extname, filename, fitsErr); + psFree(output); + return NULL; + } + } else { + if (fits_movabs_hdu(fptr, extnum + 1, &hduType, &status) != 0) { + fits_get_errstatus(status, fitsErr); + status = 0; + (void)fits_close_file(fptr, &status); + psError(__func__, "Could not index to HDU #%d for file %s. (%s)", extnum, filename, fitsErr); + psFree(output); + return NULL; + } + } + + /* Get the data type 'bitPix' from the FITS image */ + if (fits_get_img_equivtype(fptr, &bitPix, &status) != 0) { + fits_get_errstatus(status, fitsErr); + status = 0; + (void)fits_close_file(fptr, &status); + psError("Could not determine image data type of '%s'. (%s)", filename, fitsErr); + psFree(output); + return NULL; + } + + /* Get the dimensions 'nAxis' from the FITS image */ + if (fits_get_img_dim(fptr, &nAxis, &status) != 0) { + (void)fits_get_errstatus(status, fitsErr); + status = 0; + (void)fits_close_file(fptr, &status); + psError("Could not determine dimensions of '%s'. (%s)", filename, fitsErr); + psFree(output); + return NULL; + } + + /* Validate the number of axis */ + if ((nAxis < 2) || (nAxis > 3)) { + status = 0; + (void)fits_close_file(fptr, &status); + psError("Dimensions of '%s' are not supported (NAXIS=%i).", filename, nAxis); + psFree(output); + return NULL; + } + + /* Get the Image size from the FITS file */ + if (fits_get_img_size(fptr, nAxis, nAxes, &status) != 0) { + (void)fits_get_errstatus(status, fitsErr); + status = 0; + (void)fits_close_file(fptr, &status); + psError("Could not determine image size of '%s'. (%s)", filename, fitsErr); + psFree(output); + return NULL; + } + + if (numCols < 1) { + numCols += nAxes[0] - col; + } + if (numRows < 1) { + numRows += nAxes[1] - row; + } + + firstPixel[0] = col + 1; + firstPixel[1] = row + 1; + firstPixel[2] = z + 1; + + lastPixel[0] = firstPixel[0] + numCols - 1; + lastPixel[1] = firstPixel[1] + numRows - 1; + lastPixel[2] = z + 1; + + increment[0] = 1; + increment[1] = 1; + increment[2] = 1; + + // turn off the BSCALE/BZERO processing in + // CFITSIO + // (void)fits_set_bscale(fptr, + // 1.0,0.0,&status); + + switch (bitPix) { + case BYTE_IMG: + datatype = PS_TYPE_U8; + fitsDatatype = TBYTE; + break; + case SBYTE_IMG: + datatype = PS_TYPE_S8; + fitsDatatype = TSBYTE; + break; + case USHORT_IMG: + datatype = PS_TYPE_U16; + fitsDatatype = TUSHORT; + break; + case SHORT_IMG: + datatype = PS_TYPE_S16; + fitsDatatype = TSHORT; + break; + case ULONG_IMG: + datatype = PS_TYPE_U32; + fitsDatatype = TUINT; + break; + case LONG_IMG: + datatype = PS_TYPE_S32; + fitsDatatype = TINT; + break; + case LONGLONG_IMG: + datatype = PS_TYPE_S64; + fitsDatatype = TLONGLONG; + break; + case FLOAT_IMG: + datatype = PS_TYPE_F32; + fitsDatatype = TFLOAT; + break; + case DOUBLE_IMG: + datatype = PS_TYPE_F64; + fitsDatatype = TDOUBLE; + break; + default: + psError(__func__, "Unsupported bitpix value (%d) in FITS file %s.", bitPix, filename); + psFree(output); + return NULL; + } + output = psImageRecycle(output, numCols, numRows, datatype); + if (fits_read_subset + (fptr, fitsDatatype, firstPixel, + lastPixel, increment, NULL, output->data.V[0], &anynull, &status) != 0) { + psFree(output); + (void)fits_get_errstatus(status, fitsErr); + status = 0; + (void)fits_close_file(fptr, &status); + psError(__func__, "Failed to read image [%s]", filename, fitsErr); + return NULL; + } + + (void)fits_close_file(fptr, &status); + + return output; +} + +bool psImageWriteSection(psImage* input, int col0, int row0, int z, char *extname, int extnum, + char *filename) +{ + int numCols = 0; + int numRows = 0; + + int status = 0; /* CFITSIO status */ + fitsfile *fptr = NULL; /* pointer to the FITS file */ + long nAxes[3]; /* Image axis vars */ + long firstPixel[3]; /* First Pixel to read */ + long lastPixel[3]; /* Last Pixel to read */ + char fitsErr[80]; /* FITSIO message string */ + int datatype = 0; /* the datatype of the image */ + int bitPix = 0; /* FITS bitPix value */ + int hduType = IMAGE_HDU; /* the HDU type (image,table, etc.) */ + double bscale = 1.0; + double bzero = 0.0; + bool createNewHDU = false; + + /* need a valid image to write */ + if (input == NULL) { + psError(__func__, "Can not write %s. Input psImage is NULL.", filename); + return false; + } + + numRows = input->numRows; + numCols = input->numCols; + + switch (input->type.type) { + case PS_TYPE_U8: + bitPix = BYTE_IMG; + datatype = TBYTE; + break; + case PS_TYPE_S8: + bitPix = BYTE_IMG; + bzero = INT8_MIN; + datatype = TSBYTE; + break; + case PS_TYPE_U16: + bitPix = SHORT_IMG; + bzero = -1.0f * INT16_MIN; + datatype = TUSHORT; + break; + case PS_TYPE_S16: + bitPix = SHORT_IMG; + datatype = TSHORT; + break; + case PS_TYPE_U32: + bitPix = LONG_IMG; + bzero = -1.0f * INT32_MIN; + datatype = TUINT; + break; + case PS_TYPE_S32: + bitPix = LONG_IMG; + datatype = TINT; + break; + case PS_TYPE_F32: + bitPix = FLOAT_IMG; + datatype = TFLOAT; + break; + case PS_TYPE_F64: + bitPix = DOUBLE_IMG; + datatype = TDOUBLE; + break; + default: + psError(__func__, + "psImage datatype (%d) not supported. File %s not written.", input->type.type, filename); + return false; + } + + /* Open the FITS file */ + if (access(filename, F_OK) == 0) { // file + // exists + (void)fits_open_file(&fptr, filename, READWRITE, &status); + if (fptr == NULL || status != 0) { + fits_get_errstatus(status, fitsErr); + psError(__func__, "Could not open file '%s'. FITS error:%s", filename, fitsErr); + return false; + } + + /* find the specified extension */ + if (extname != NULL) { + if (fits_movnam_hdu(fptr, hduType, extname, 0, &status) != 0) { + fits_get_errstatus(status, fitsErr); + status = 0; + (void)fits_close_file(fptr, &status); + psError(__func__, + "Could not index to '%s' HDU for file %s. (%s)", extname, filename, fitsErr); + return false; + } + } else { + int numHDUs = 0; + + fits_get_num_hdus(fptr, &numHDUs, &status); + if (numHDUs < extnum) { + status = 0; + (void)fits_close_file(fptr, &status); + psError(__func__, + "extnum (%d) must not exceed number of HDUs (%d) by more than one.", extnum, numHDUs); + return false; + } else if (numHDUs == extnum) { + createNewHDU = true; + } else if (fits_movabs_hdu(fptr, extnum + 1, &hduType, &status) != 0) { + fits_get_errstatus(status, fitsErr); + status = 0; + (void)fits_close_file(fptr, &status); + psError(__func__, "Could not index to HDU #%d for file %s. (%s)", extnum, filename, fitsErr); + return false; + } + } + + } else { // file + // does + // not + // exist + + (void)fits_create_file(&fptr, filename, &status); + if (fptr == NULL || status != 0) { + fits_get_errstatus(status, fitsErr); + psError(__func__, "Could not create file '%s'. (%s)", filename, fitsErr); + return false; + } + createNewHDU = true; + } + + if (createNewHDU) { + /* create the mandatory image keywords */ + nAxes[0] = col0 + numCols; + nAxes[1] = row0 + numRows; + nAxes[2] = z + 1; + if (fits_create_img(fptr, bitPix, 3, nAxes, &status) != 0) { + (void)fits_get_errstatus(status, fitsErr); + status = 0; + (void)fits_close_file(fptr, &status); + psError(__func__, "Could not create image HDU in FITS file '%s'. %s", filename, fitsErr); + return false; + } + // set the bscale/bzero + fits_write_key_dbl(fptr, "BZERO", bzero, 12, "Pixel Value Offset", &status); + fits_write_key_dbl(fptr, "BSCALE", bscale, 12, "Pixel Value Scale", &status); + fits_set_bscale(fptr, bscale, bzero, &status); + + if (extname != NULL) { + /* create the extension for the Primary HDU */ + if (fits_write_key_str(fptr, "EXTNAME", extname, "Extension Name", &status) != 0) { + (void)fits_get_errstatus(status, fitsErr); + status = 0; + (void)fits_close_file(fptr, &status); + psError(__func__, + "Could not create EXTNAME keyword in FITS file '%s'. (%s)", filename, fitsErr); + return false; + } + } + } + + firstPixel[0] = col0 + 1; + firstPixel[1] = row0 + 1; + firstPixel[2] = z + 1; + + lastPixel[0] = firstPixel[0] + numCols - 1; + lastPixel[1] = firstPixel[1] + numRows - 1; + lastPixel[2] = z + 1; + + if (fits_write_subset(fptr, datatype, firstPixel, lastPixel, input->data.V[0], &status) != 0) { + (void)fits_get_errstatus(status, fitsErr); + status = 0; + (void)fits_close_file(fptr, &status); + psError(__func__, "Could not write image data to '%s'. (%s)", filename, fitsErr); + return false; + } + + status = 0; + (void)fits_close_file(fptr, &status); + + return true; +} Index: /tags/rel2_1/psLib/src/image/psImageIO.h =================================================================== --- /tags/rel2_1/psLib/src/image/psImageIO.h (revision 1553) +++ /tags/rel2_1/psLib/src/image/psImageIO.h (revision 1553) @@ -0,0 +1,98 @@ + +/** @file psImageIO.h + * + * @brief Contains image input/output routines + * + * This file defines the file input/output functions for the psImage structure. + * + * @ingroup ImageIO + * + * @author Robert DeSonia, MHPCC + * + * @version $Revision: 1.7 $ $Name: not supported by cvs2svn $ + * @date $Date: 2004-08-10 01:05:53 $ + * + * Copyright 2004 Maui High Performance Computing Center, University of Hawaii + */ +#ifndef PS_IMAGEIO_H +#define PS_IMAGEIO_H + +#include + +#include "psImage.h" + +/// @addtogroup ImageIO +/// @{ + +/** Read an image or subimage from a FITS file specified by a filename. + * + * return psImage* The image read from the specified file. NULL + * signifies that a problem had occured. + */ +psImage* psImageReadSection( + psImage* output, + /**< the output psImage to recycle, or NULL if new psImage desired */ + + int col0, + /**< the column index of the origin to start reading */ + + int row0, + /**< the row index of the origin to start reading */ + + int numCols, + /**< the number of desired columns to read */ + + int numRows, + /**< the number of desired rows to read */ + + int z, + /**< the z index to read if file is organized as a 3D image cube. */ + + char *extname, + /**< the image extension to read (this should match the EXTNAME keyword in + * the extension If NULL, the extnum parameter is to be used instead + */ + + int extnum, + /**< the image extension to read (0=PHU, 1=first extension, etc.) This is + * only used if extname is NULL + */ + + char *filename + /**< the filename of the FITS image file to read */ +); + +/** Read an image or subimage from a FITS file specified by a filename. + * + * return bool TRUE is successful, otherwise FALSE. + */ +bool psImageWriteSection( + psImage* input, + /**< the psImage to write */ + + int col0, + /**< the column index of the origin to start writing */ + + int row0, + /**< the row index of the origin to start writing */ + + int z, + /**< the z index to start writing */ + + char *extname, + /**< the image extension to write (this should match the EXTNAME keyword in + * the extension If NULL, the extnum parameter is to be used instead + */ + + int extnum, + /**< the image extension to write (0=PHU, 1=first extension, etc.) This is + * only used if extname is NULL. + */ + + char *filename + /**< the filename of the FITS image file to write */ +); + +/// @} + +#endif Index: /tags/rel2_1/psLib/src/image/psImageManip.c =================================================================== --- /tags/rel2_1/psLib/src/image/psImageManip.c (revision 1553) +++ /tags/rel2_1/psLib/src/image/psImageManip.c (revision 1553) @@ -0,0 +1,867 @@ + +/** @file psImageManip.c + * + * @brief Contains basic image pixel and geometry manipulation operations, as + * specified in the PSLIB SDRS sections "Image Pixel Manipulations" and + * "Image Geometry Manipulations". + * + * @ingroup Image + * + * @author Robert DeSonia, MHPCC + * @author Ross Harman, MHPCC + * + * @version $Revision: 1.15 $ $Name: not supported by cvs2svn $ + * @date $Date: 2004-08-13 00:02:03 $ + * + * Copyright 2004 Maui High Performance Computing Center, University of Hawaii + */ +#include // for +// isfinite(), +// etc. +#include +#include +#include // for +// memcpy, +// etc. + +#include "psError.h" +#include "psImage.h" +#include "psStats.h" +#include "psMemory.h" +#include "psImageExtraction.h" + +int psImageClip(psImage* input, psF64 min, psF64 vmin, psF64 max, psF64 vmax) +{ + int numClipped = 0; + unsigned int numRows; + unsigned int numCols; + + if (input == NULL) { + return 0; + } + + if (max < min) { + psError(__func__, "psImageClip can not be invoked with max < min."); + return 0; + } + + numRows = input->numRows; + numCols = input->numCols; + + switch (input->type.type) { + + #define psImageClipCase(type,typename) \ + case PS_TYPE_##type: { \ + if (vmin < PS_MIN_##type || vmin > PS_MAX_##type) { \ + psError(__func__, "Specified vmin (%g) is outside of image's " \ + typename " pixel range (%g to %g)", \ + vmin,(psF64)PS_MIN_##type,(psF64)PS_MAX_##type); \ + } \ + if (vmax > PS_MAX_##type || vmax < PS_MIN_##type) { \ + psError(__func__, "Specified vmax (%g) is outside of image's " \ + typename " pixel range (%g to %g)", \ + vmax,(psF64)PS_MIN_##type,(psF64)PS_MAX_##type); \ + } \ + for (unsigned int row = 0;rowdata.type[row]; \ + for (unsigned int col = 0; col < numCols; col++) { \ + if ((psF64)inputRow[col] < min) { \ + inputRow[col] = (ps##type)vmin; \ + numClipped++; \ + } else if ((psF64)inputRow[col] > max) { \ + inputRow[col] = (ps##type)vmax; \ + numClipped++; \ + } \ + } \ + } \ + } \ + break; + + #define psImageClipCaseComplex(type,typename,absfcn)\ + case PS_TYPE_##type: { \ + if (vmin < PS_MIN_##type || vmin > PS_MAX_##type) { \ + psError(__func__, "Specified vmin (%g) is outside of image's " \ + typename " pixel range", \ + vmin); \ + } \ + if (vmax > PS_MAX_##type || vmax < PS_MIN_##type) { \ + psError(__func__, "Specified vmax (%g) is outside of image's " \ + typename " pixel range", \ + vmax); \ + } \ + for (unsigned int row = 0;rowdata.type[row]; \ + for (unsigned int col = 0; col < numCols; col++) { \ + if (absfcn(inputRow[col]) < min) { \ + inputRow[col] = (ps##type)vmin; \ + numClipped++; \ + } else if (absfcn(inputRow[col]) > max) { \ + inputRow[col] = (ps##type)vmax; \ + numClipped++; \ + } \ + } \ + } \ + } \ + break; + + psImageClipCase(S8, "psS8") + psImageClipCase(S16, "psS16") + psImageClipCase(S32, "psS32") + psImageClipCase(S64, "psS64") + psImageClipCase(U8, "psU8") + psImageClipCase(U16, "psU16") + psImageClipCase(U32, "psU32") + psImageClipCase(U64, "psU64") + psImageClipCase(F32, "psF32") + psImageClipCase(F64, "psF64") + psImageClipCaseComplex(C32, "psC32", cabsf) + psImageClipCaseComplex(C64, "psC64", cabs) + + default: + psError(__func__, "psImageClip does not support the given datatype (%d)", input->type.type); + } + + return numClipped; +} + +int psImageClipNaN(psImage* input, psF64 value) +{ + int numClipped = 0; + unsigned int numRows; + unsigned int numCols; + + if (input == NULL) { + return 0; + } + numRows = input->numRows; + numCols = input->numCols; + + switch (input->type.type) { + + #define psImageClipNaNCase(type) \ + case PS_TYPE_##type: \ + for (unsigned int row = 0;rowdata.type[row]; \ + for (unsigned int col = 0; col < numCols; col++) { \ + if (! isfinite(inputRow[col])) { \ + inputRow[col] = (ps##type)value; \ + numClipped++; \ + } \ + } \ + } \ + break; + + psImageClipNaNCase(F32) + psImageClipNaNCase(F64) + psImageClipNaNCase(C32) + psImageClipNaNCase(C64) + + default: + psError(__func__, "psImageClip does not support the given datatype (%d)", input->type.type); + } + + return numClipped; +} + +int psImageOverlaySection(psImage* image, const psImage* overlay, int col0, int row0, const char *op) +{ + unsigned int imageNumRows; + unsigned int imageNumCols; + unsigned int overlayNumRows; + unsigned int overlayNumCols; + unsigned int imageRowLimit; + unsigned int imageColLimit; + psElemType type; + + if (image == NULL || overlay == NULL) { + psError(__func__, "one of the input images was NULL."); + return 1; + } + + if (op == NULL) { + psError(__func__, "Operation can not be NULL."); + return 1; + } + + type = image->type.type; + + if (type != overlay->type.type) { + psError(__func__, "Image and overlay datatypes must match. (%d vs %d)", type, overlay->type.type); + return 2; + } + + imageNumRows = image->numRows; + imageNumCols = image->numCols; + overlayNumRows = overlay->numRows; + overlayNumCols = overlay->numCols; + + /* check row0/col0 to see if it is within the image size */ + if (row0 < 0 || col0 < 0 || row0 >= imageNumRows || col0 >= imageNumCols) { + psError(__func__, + "Overlay origin of (%d,%d) is outside of the image dimensions (%d x %d).", + col0, row0, imageNumCols, imageNumRows); + return 3; + } + + /* check if overlay is totally withing input image */ + imageRowLimit = row0 + overlayNumRows; + imageColLimit = col0 + overlayNumCols; + if (imageRowLimit > imageNumRows || imageColLimit > imageNumCols) { + psError(__func__, + "Overlay image (%d,%d -> %d,%d) is partially outside" + " of the input image (%d x %d).", + col0, row0, col0 + overlayNumCols - 1, row0 + overlayNumRows - 1, imageNumCols, imageNumRows); + return 4; + } + + switch (type) { + + #define psImageOverlayCase(DATATYPE) \ + case PS_TYPE_##DATATYPE: \ + for (unsigned int row=row0;rowdata.DATATYPE[row]; \ + ps##DATATYPE* overlayRow = overlay->data.DATATYPE[row-row0]; \ + for (unsigned int col=col0;col PS_MAX_##type || imagfcn(vmax) > PS_MAX_##type || \ + realfcn(vmax) < PS_MIN_##type || imagfcn(vmax) < PS_MIN_##type ) { \ + psError(__func__, "Specified vmax (%g%+gi) is outside of image's " \ + typename " pixel range", \ + creal(vmax),cimag(vmax)); \ + break; \ + } \ + for (unsigned int row = 0;rowdata.type[row]; \ + for (unsigned int col = 0; col < numCols; col++) { \ + if ( (realfcn(inputRow[col]) > realMax) || (imagfcn(inputRow[col]) > imagMax) ) { \ + inputRow[col] = (ps##type)vmax; \ + numClipped++; \ + } else if ( (realfcn(inputRow[col]) < realMin) || (imagfcn(inputRow[col]) < imagMin) ){ \ + inputRow[col] = (ps##type)vmin; \ + numClipped++; \ + } \ + } \ + } \ + } \ + break; + + switch (input->type.type) { + + psImageClipComplexRegionCase(C32, "psC32", crealf, cimagf) + psImageClipComplexRegionCase(C64, "psC64", creal, cimag) + + default: + psError(__func__, "psImageClip does not support the given datatype (%d)", input->type.type); + } + + return numClipped; +} + +psImage* psImageRebin(psImage* out, const psImage* in, unsigned int scale, const psStats* stats) +{ + int inRows; + int inCols; + int outRows; + int outCols; + psVector* vec; // vector to hold + + // the values of + // a single bin. + psStats* myStats; + double statVal; + + if (in == NULL) { + psError(__func__, "Input image is NULL."); + psFree(out); + return NULL; + } + + if (scale < 1) { + psError(__func__, "The scale must be positive."); + psFree(out); + return NULL; + } + + if (stats == NULL) { + psError(__func__, "The stats input can not be NULL."); + psFree(out); + return NULL; + } + + if (p_psGetStatValue(stats, &statVal) == false) { + psError(__func__, "The stat options didn't specify a single supported statistic type."); + psFree(out); + return NULL; + } + + myStats = psAlloc(sizeof(psStats)); + *myStats = *stats; + + vec = psVectorAlloc(scale * scale, in->type.type); + + // create output image. + inRows = in->numRows; + inCols = in->numCols; + outRows = (inRows + scale - 1) / scale; // round-up + // for + // remainders + outCols = (inCols + scale - 1) / scale; // round-up + // for + // remainders + out = psImageRecycle(out, outCols, outRows, in->type.type); + + #define PS_IMAGE_REBIN_CASE(type) \ +case PS_TYPE_##type: { \ + ps##type* vecData = vec->data.type; \ + for (int row = 0; row < outRows; row++) { \ + ps##type* outRowData = out->data.type[row]; \ + int inCurrentRow = row*scale; \ + int inNextRow = (row+1)*scale; \ + for (int col = 0; col < outCols; col++) { \ + int inCurrentCol = col*scale; \ + int inNextCol = (col+1)*scale; \ + int n = 0; \ + for (int inRow = inCurrentRow; inRow < inNextRow && inRow < inRows; inRow++) { \ + ps##type* inRowData = in->data.type[inRow]; \ + for (int inCol = inCurrentCol; inCol < inNextCol && inCol < inCols; inCol++) { \ + vecData[n++] = inRowData[inCol]; \ + } \ + } \ + vec->n = n; \ + myStats = psVectorStats(myStats,vec,NULL,0); \ + p_psGetStatValue(myStats,&statVal); \ + outRowData[col] = (ps##type)statVal; \ + } \ + } \ + } \ + break; + + switch (in->type.type) { + PS_IMAGE_REBIN_CASE(U8); + PS_IMAGE_REBIN_CASE(U16); + PS_IMAGE_REBIN_CASE(U32); + PS_IMAGE_REBIN_CASE(U64); + PS_IMAGE_REBIN_CASE(S8); + PS_IMAGE_REBIN_CASE(S16); + PS_IMAGE_REBIN_CASE(S32); + PS_IMAGE_REBIN_CASE(S64); + PS_IMAGE_REBIN_CASE(F32); + PS_IMAGE_REBIN_CASE(F64); + PS_IMAGE_REBIN_CASE(C32); + PS_IMAGE_REBIN_CASE(C64); + default: + psError(__func__, "Input image type not supported."); + psFree(out); + out = NULL; + } + + psFree(vec); + psFree(myStats); + + return out; +} + +psImage* psImageResample(psImage* out, const psImage* in, int scale, psImageInterpolateMode mode) +{ + int outRows; + int outCols; + float invScale; + + if (in == NULL) { + psError(__func__, "Input image can not be NULL."); + psFree(out); + return NULL; + } + // create an output image of the same size + // and type + outRows = in->numRows * scale; + outCols = in->numCols * scale; + invScale = 1.0f / (float)scale; + + #define PSIMAGE_RESAMPLE_CASE(TYPE) \ +case PS_TYPE_##TYPE: { \ + out = psImageRecycle(out,outCols, outRows, PS_TYPE_##TYPE); \ + for (int row=0;rowdata.TYPE[row]; \ + float inRow = (float)row * invScale; \ + for (int col=0;coltype.type) { + PSIMAGE_RESAMPLE_CASE(U8) + PSIMAGE_RESAMPLE_CASE(U16) + PSIMAGE_RESAMPLE_CASE(U32) + PSIMAGE_RESAMPLE_CASE(U64) + PSIMAGE_RESAMPLE_CASE(S8) + PSIMAGE_RESAMPLE_CASE(S16) + PSIMAGE_RESAMPLE_CASE(S32) + PSIMAGE_RESAMPLE_CASE(S64) + PSIMAGE_RESAMPLE_CASE(F32) + PSIMAGE_RESAMPLE_CASE(F64) + PSIMAGE_RESAMPLE_CASE(C32) + PSIMAGE_RESAMPLE_CASE(C64) + default: + psError(__func__, "Unsupported type (%d)", in->type.type); + psFree(out); + return NULL; + } + + return out; +} + +psImage* psImageRoll(psImage* out, const psImage* in, int dx, int dy) +{ + int outRows; + int outCols; + int elementSize; + + if (in == NULL) { + psError(__func__, "Input image can not be NULL."); + psFree(out); + return NULL; + } + // create an output image of the same size + // and type + outRows = in->numRows; + outCols = in->numCols; + elementSize = PSELEMTYPE_SIZEOF(in->type.type); + out = psImageRecycle(out, outCols, outRows, in->type.type); + + // make dx and dy between 0 and outCols or + // outRows, respectively + dx = dx % outCols; + dy = dy % outRows; + if (dx < 0) { + dx += outCols; + } + if (dy < 0) { + dy += outRows; + } + + int segment1Size = elementSize * (outCols - dx); + int segment2Size = elementSize * dx; + + for (int row = 0; row < outRows; row++) { + int inRowNumber = row + dy; + + if (inRowNumber >= outRows) { + inRowNumber -= outRows; + } + psU8* inRow = in->data.U8[inRowNumber]; // to + + // allow + + // byte + // arithmetic, + + // but for all types + psU8* outRow = out->data.U8[row]; + + memcpy(outRow, inRow + segment2Size, segment1Size); + memcpy(outRow + segment1Size, inRow, segment2Size); + } + + return out; +} + +psImage* psImageRotate(psImage* out, + const psImage* in, + float angle, + float unexposedValue, + psImageInterpolateMode mode) +{ + if (in == NULL) { + psError(__func__, "The input image was NULL."); + psFree(out); + return NULL; + } + // put the angle in the range of 0...360. + angle = angle - 360.0f * floor(angle / 360.0f); + + if (fabsf(angle - 90.0f) < FLT_EPSILON) { + // perform 1/4 rotate counter-clockwise + int numRows = in->numCols; + int numCols = in->numRows; + int lastCol = numCols - 1; + psElemType type = in->type.type; + + out = psImageRecycle(out, numCols, numRows, type); + + #define PSIMAGE_ROTATE_LEFT_90(TYPE) \ + case PS_TYPE_##TYPE: { \ + ps##TYPE** inData = in->data.TYPE; \ + for (int row=0;rowdata.TYPE[row]; \ + for (int col=0;colnumRows; + int lastRow = numRows - 1; + int numCols = in->numCols; + int lastCol = numCols - 1; + psElemType type = in->type.type; + + out = psImageRecycle(out, numCols, numRows, type); + + #define PSIMAGE_ROTATE_180_CASE(TYPE) \ + case PS_TYPE_##TYPE: { \ + for (int row=0;rowdata.TYPE[row]; \ + ps##TYPE* inRow = in->data.TYPE[lastRow-row]; \ + for (int col=0;colnumCols; + int lastRow = numRows - 1; + int numCols = in->numRows; + psElemType type = in->type.type; + + out = psImageRecycle(out, numCols, numRows, type); + + #define PSIMAGE_ROTATE_RIGHT_90(TYPE) \ + case PS_TYPE_##TYPE: { \ + ps##TYPE** inData = in->data.TYPE; \ + for (int row=0;rowdata.TYPE[row]; \ + for (int col=0;coltype.type); + } else { + psElemType type = in->type.type; + int numRows = in->numRows; + int numCols = in->numCols; + double centerX = (float)(numCols) / 2.0f; + float centerY = (float)(numRows) / 2.0f; + float t = angle * (3.14159265358f / 180.0f); + double cosT = cosf(t); + double sinT = sinf(t); + + // calculate the corners of the rotated + // image so we know the proper + // output image size. + // x' = x cos(t) + y sin(t); i.e, x' = + // (x-centerX)*cosT + + // (y-centerY)*sinT; + // y' = y cos(t) - x sin(t); i.e. y' = + // (y-centerY)*cosT - + // (x-centerX)*sinT; + + int outCols = ceil(abs(numCols * cosT) + abs(numRows * sinT)) + 1; + int outRows = ceil(abs(numCols * sinT) + abs(numRows * cosT)) + 1; + float minX = (float)outCols / -2.0f; + int intMinY = outRows / -2; + + out = psImageRecycle(out, outCols, outRows, type); + + /* optimized public domain rotation routine by Karl Lager float cosT,sinT; cosT = cos(t); sinT = + * sin(t); for (y = min_y; y <= max_y; y++) { x' = min_x * cosT + y * sinT + x1'; y' = y * cosT - + * min_x * sinT + y1'; for (x = min_x; x <= max_x; x++) { if (x', y') * * * * * * * * is in the + * bounds of the bitmap, get pixel(x', y') and plot the pixel to (x, y) on screen. x' += cosT; y' -= + * sinT; } } */ + + // precalculate some figures that are + // used within loop + float minXTimesCosTPlusCenterX = minX * cosT + centerX; + float CenterYMinusminXTimesSinT = centerY - minX * sinT; + + #define PSIMAGE_ROTATE_ARBITRARY_LOOP(TYPE,MODE) { \ + if (unexposedValue < PS_MIN_##TYPE || unexposedValue > PS_MAX_##TYPE) { \ + psError(__func__,"The given unexposedValue (%g) is outside of the " \ + "image type's range (%g->%g).", \ + unexposedValue, (double)PS_MIN_##TYPE,(double)PS_MAX_##TYPE); \ + psFree(out); \ + out = NULL; \ + break; \ + } \ + float inX; \ + float inY; \ + ps##TYPE* outRow; \ + for (int y = 0; y < outRows; y++) { \ + inX = minXTimesCosTPlusCenterX + (y+intMinY) * sinT; \ + inY = CenterYMinusminXTimesSinT + (y+intMinY) * cosT; \ + outRow = out->data.TYPE[y]; \ + for (int x = 0; x < outCols; x++) { \ + outRow[x] = p_psImagePixelInterpolate##MODE##_##TYPE(in,inX,inY,unexposedValue); \ + inX += cosT; \ + inY -= sinT; \ + } \ + } \ + } + + #define PSIMAGE_ROTATE_ARBITRARY_CASE(MODE) \ + case PS_INTERPOLATE_##MODE: \ + switch (type) { \ + case PS_TYPE_U8: \ + PSIMAGE_ROTATE_ARBITRARY_LOOP(U8,MODE); \ + break; \ + case PS_TYPE_U16: \ + PSIMAGE_ROTATE_ARBITRARY_LOOP(U16,MODE); \ + break; \ + case PS_TYPE_U32: \ + PSIMAGE_ROTATE_ARBITRARY_LOOP(U32,MODE); \ + break; \ + case PS_TYPE_U64: \ + PSIMAGE_ROTATE_ARBITRARY_LOOP(U64,MODE); \ + break; \ + case PS_TYPE_S8: \ + PSIMAGE_ROTATE_ARBITRARY_LOOP(S8,MODE); \ + break; \ + case PS_TYPE_S16: \ + PSIMAGE_ROTATE_ARBITRARY_LOOP(S16,MODE); \ + break; \ + case PS_TYPE_S32: \ + PSIMAGE_ROTATE_ARBITRARY_LOOP(S32,MODE); \ + break; \ + case PS_TYPE_S64: \ + PSIMAGE_ROTATE_ARBITRARY_LOOP(S64,MODE); \ + break; \ + case PS_TYPE_F32: \ + PSIMAGE_ROTATE_ARBITRARY_LOOP(F32,MODE); \ + break; \ + case PS_TYPE_F64: \ + PSIMAGE_ROTATE_ARBITRARY_LOOP(F64,MODE); \ + break; \ + case PS_TYPE_C32: \ + PSIMAGE_ROTATE_ARBITRARY_LOOP(C32,MODE); \ + break; \ + case PS_TYPE_C64: \ + PSIMAGE_ROTATE_ARBITRARY_LOOP(C64,MODE); \ + break; \ + default: \ + psError(__func__,"Image type (%d) not supported",type); \ + psFree(out); \ + out = NULL; \ + } \ + break; + + switch (mode) { + PSIMAGE_ROTATE_ARBITRARY_CASE(FLAT); + PSIMAGE_ROTATE_ARBITRARY_CASE(BILINEAR); + default: + psError(__func__, "Unsupported interpolation mode (%d)", mode); + psFree(out); + out = NULL; + } + } + + return out; +} + +psImage* psImageShift(psImage* out, + const psImage* in, + float dx, float dy, psF64 unexposedValue, psImageInterpolateMode mode) +{ + int outRows; + int outCols; + int elementSize; + psElemType type; + + if (in == NULL) { + psError(__func__, "Input image can not be NULL."); + return NULL; + } + // create an output image of the same size + // and type + outRows = in->numRows; + outCols = in->numCols; + type = in->type.type; + elementSize = PSELEMTYPE_SIZEOF(type); + out = psImageRecycle(out, outCols, outRows, type); + + #define PSIMAGE_SHIFT_CASE(TYPE) \ +case PS_TYPE_##TYPE: \ + if (unexposedValue < PS_MIN_##TYPE || unexposedValue > PS_MAX_##TYPE) { \ + psError(__func__,"The given unexposedValue (%g) is outside of the " \ + "image type's range (%g->%g).", \ + unexposedValue, (double)PS_MIN_##TYPE,(double)PS_MAX_##TYPE); \ + psFree(out); \ + out = NULL; \ + break; \ + } \ + for (int row=0;rowdata.TYPE[row]; \ + float y = dy+(float)row; \ + for (int col=0;coltype.type) { + PSIMAGE_SHIFT_CASE(U8); + PSIMAGE_SHIFT_CASE(U16); + PSIMAGE_SHIFT_CASE(U32); + PSIMAGE_SHIFT_CASE(U64); + PSIMAGE_SHIFT_CASE(S8); + PSIMAGE_SHIFT_CASE(S16); + PSIMAGE_SHIFT_CASE(S32); + PSIMAGE_SHIFT_CASE(S64); + PSIMAGE_SHIFT_CASE(F32); + PSIMAGE_SHIFT_CASE(F64); + PSIMAGE_SHIFT_CASE(C32); + PSIMAGE_SHIFT_CASE(C64); + default: + psError(__func__, "Image type (%d) not supported.", type); + psFree(out); + out = NULL; + } + return out; +} Index: /tags/rel2_1/psLib/src/image/psImageManip.h =================================================================== --- /tags/rel2_1/psLib/src/image/psImageManip.h (revision 1553) +++ /tags/rel2_1/psLib/src/image/psImageManip.h (revision 1553) @@ -0,0 +1,180 @@ + +/** @file psImageManip.h + * + * @brief Contains basic image pixel and geometry manipulation operations, as + * specified in the PSLIB SDRS sections "Image Pixel Manipulations" and + * "Image Geometry Manipulations". + * + * @ingroup Image + * + * @author Robert DeSonia, MHPCC + * @author Ross Harman, MHPCC + * + * @version $Revision: 1.11 $ $Name: not supported by cvs2svn $ + * @date $Date: 2004-08-10 01:05:53 $ + * + * Copyright 2004 Maui High Performance Computing Center, University of Hawaii + */ +#ifndef PS_IMAGE_MANIP_H +#define PS_IMAGE_MANIP_H + +#include "psImage.h" + +/// @addtogroup Image +/// @{ + +/** Clip image values outside of range to given values + * + * All pixels with values less than min are set to the value vmin. all pixels + * with values greater than max are set to the value vmax. This function is + * defined for psU8, psU16, psS8, psS16, psF32, psF64, psC32, and psC64. + * + * @return int The number of clipped pixels + */ +int psImageClip( + psImage* input, ///< the image to clip + psF64 min, ///< the minimum image value allowed + psF64 vmin, ///< the value pixels < min are set to + psF64 max, ///< the maximum image value allowed + psF64 vmax ///< the value pixels > max are set to +); + +/** Clip image values outside of a specified complex region + * + * All pixels outside of the rectangular region in complex space formed by + * the min and max input parameters are set to the value vmax (if either + * the real or imaginary portion exceeds the respective max values), or vmin. + * This function is defined for psC32, and psC64 imagery only. + * + * @return int The number of clipped pixels + */ +int psImageClipComplexRegion( + psImage* input, ///< the image to clip + psC64 min, ///< the minimum image value allowed + psC64 vmin, ///< the value pixels < min are set to + psC64 max, ///< the maximum image value allowed + psC64 vmax ///< the value pixels > max are set to +); + +/** Clip NaN image pixels to given value. + * + * Pixels with NaN, +Inf, or -Inf values are set to the specified value. This + * function is defined for psF32, psF64, psC32, and psC64. + * + * @return int The number of clipped pixels + */ +int psImageClipNaN( + psImage* input, ///< the image to clip + psF64 value ///< the value to set all NaN/Inf values to +); + +/** Overlay subregion of image with another image + * + * Replace the pixels in the image which correspond to the pixels in OVERLAY + * with values derived from the IMAGE and OVERLAY based on the given operator + * OP. Valid operators are "=" (set image value to OVERLAY value), "+" (add + * OVERLAY value to image value), "-" (subtract OVERLAY from image), "*" + * (multiply OVERLAY times image), "/" (divide image by OVERLAY). This + * function is defined for psU8, psS8, psS16, psF32, psF64, psC32, and psC64. + * + * @return int 0 if success, non-zero if failed. + */ +int psImageOverlaySection( + psImage* image, ///< target image + const psImage* overlay, ///< the overlay image + int col0, ///< the column to start overlay + int row0, ///< the row to start overlay + const char *op ///< the operation to perform for overlay +); + +/** Rebin image to new scale. + * + * A new image is constructed in which the dimensions are reduced by a factor of + * 1/scale. The scale, always a positive number, is equal in each dimension and + * specified the number of pixels used to define a new pixel in the output image. + * The output image is generated from all input image pixels. This function is + * defined for psU8, psS8, psS16, psF32, psF64, psC32, and psC64. + * + * @return psImage new image formed by rebinning input image. + */ +psImage* psImageRebin( + psImage* out, ///< an psImage to recycle. If NULL, a new image is created + const psImage* in, ///< input image + unsigned int scale, ///< the scale to rebin for each dimension + const psStats* stats + ///< the statistic to perform when rebinning. Only one method should be set. +); + +/** Resample image to new scale. + * + * A new image is constructed in which the dimensions are increased by a + * factor of scale. The scale, always a positive number, is equal in each + * dimension. The output image is generated from all input image pixels. + * Each pixel in the output image is derived by interpolating between + * neighboring pixels using the specified interpolation method (mode). + * + * @return psImage* resampled image result + */ +psImage* psImageResample( + psImage* out, ///< an psImage to recycle. If NULL, a new image is created + const psImage* in, ///< input image + int scale, ///< resample scaling factor + psImageInterpolateMode mode ///< the interpolation mode used in resampling +); + +/** Rotate the input image by given angle, specified in degrees. + * + * The output image must contain all of the pixels from the input image in + * their new frame. Pixels in the output image which do not map to input + * pixels should be set to exposed. The center of rotation is always the + * center pixel of the image. The rotation is specified in the sense that a + * positive angle is an anti-clockwise rotation. This function must be + * defined for the following types: psU8, psU16, psS8, psS16, psF32, psF64, + * psC32, psC64. + * + * @return psImage* the rotated image result. + */ +psImage* psImageRotate( + psImage* out, ///< an psImage to recycle. If NULL, a new image is created + const psImage* in, ///< input image + float angle, ///< the rotation angle in degrees. + float unexposedValue, ///< the output image pixel values for non-imagery areas + psImageInterpolateMode mode ///< the interpolation mode used +); + +/** Shift image by an arbitrary number of pixels (dx,dy) in either direction. + * + * If the shift values are fractional, the output pixel values should + * interpolate between the input pixel values. The output image has the same + * dimensions as the input image. Pixels which fall off the edge of the + * output image are lost. Newly exposed pixels are set to the value given by + * exposed. This function must be defined for the following types: psU8, + * psU16, psS8, psS16, psF32, psF64, psC32, psC64. + * + * @return psImage* the shifted image result. + */ +psImage* psImageShift( + psImage* out, ///< an psImage to recycle. If NULL, a new image is created + const psImage* in, ///< input image + float dx, ///< the shift in x direction. + float dy, ///< the shift in y direction. + float unexposedValue, ///< the output image pixel values for non-imagery areas + psImageInterpolateMode mode ///< the interpolation mode to use +); + +/** Roll image by an integer number of pixels in either direction. + * + * The output image is the same dimensions as the input image. Edge pixels + * wrap to the other side (no values are lost). This function is + * defined for psU8, psS8, psS16, psF32, psF64, psC32, and psC64. + * + * @return psImage* the rolled version of the input image. + */ +psImage* psImageRoll( + psImage* out, ///< an psImage to recycle. If NULL, a new image is created + const psImage* in, ///< input image + int dx, ///< number of pixels to roll in the x-dimension + int dy ///< number of pixels to roll in the y-dimension +); + +#endif Index: /tags/rel2_1/psLib/src/image/psImageStats.c =================================================================== --- /tags/rel2_1/psLib/src/image/psImageStats.c (revision 1553) +++ /tags/rel2_1/psLib/src/image/psImageStats.c (revision 1553) @@ -0,0 +1,404 @@ + +/** @file psImageStats.c +* \brief Routines for calculating statistics on images. +* @ingroup ImageStats +* +* This file will hold the prototypes for procedures which calculate +* statistic on images, histograms on images, and fit/evaluate Chebyshev +* polynomials to images. +* +* @author George Gusciora, MHPCC +* +* @version $Revision: 1.33 $ $Name: not supported by cvs2svn $ +* @date $Date: 2004-08-10 01:55:34 $ +* +* Copyright 2004 Maui High Performance Computing Center, University of Hawaii +*/ + +#include +#include +#include +#include +#include +#include +#include "psMemory.h" +#include "psVector.h" +#include "psTrace.h" +#include "psError.h" +#include "psAbort.h" +#include "psStats.h" +#include "psImage.h" +#include "psFunctions.h" +#include "psImageStats.h" + +/// This routine must determine the various statistics for the image. + +/***************************************************************************** + NOTE: verify that image/mask have the correct types, and sizes. + *****************************************************************************/ +psStats* psImageStats(psStats* stats, psImage* in, psImage* mask, int maskVal) +{ + psVector* junkData = NULL; + psVector* junkMask = NULL; + + if (stats == NULL) { + psError(__func__, "The input psStats struct can not be NULL."); + return NULL; + } + + if (in == NULL) { + psError(__func__, "The input image can not be NULL."); + return NULL; + } + + if (stats->options == 0) { + psError(__func__, "No statistic option/operation was specified."); + return stats; + } + // stuff the image data into a psVector + // struct. + junkData = psAlloc(sizeof(psVector)); + junkData->type = in->type; + junkData->nalloc = in->numRows * in->numCols; + junkData->n = junkData->nalloc; + junkData->data.V = in->data.V[0]; // since + // psImage + // data + // is + // contiguous... + + if (mask != NULL) { + if (mask->type.type != PS_TYPE_MASK) { + psError(__func__, "Expected the mask image type not found (type=%x)", mask->type.type); + psFree(junkData); + return NULL; + } + // stuff the mask data into a psVector + // struct. + junkMask = psAlloc(sizeof(psVector)); + junkMask->type = mask->type; + junkMask->nalloc = mask->numRows * mask->numCols; + junkMask->n = junkMask->nalloc; + junkMask->data.V = mask->data.V[0]; + } + + stats = psVectorStats(stats, junkData, junkMask, maskVal); + + psFree(junkMask); + psFree(junkData); + return (stats); +} + +/***************************************************************************** + NOTE: We assume that the psHistogram structure out has already been + allocated and initialized. + NOTE: verify that image/mask have the, correct types and sizes. + *****************************************************************************/ +psHistogram* psImageHistogram(psHistogram* out, psImage* in, psImage* mask, unsigned int maskVal) +{ + psVector* junkData = NULL; + psVector* junkMask = NULL; + + // NOTE: Verify this action. + if ((out == NULL) || (in == NULL)) { + return (NULL); + } + + junkData = psAlloc(sizeof(psVector)); + junkData->type = in->type; + junkData->nalloc = in->numRows * in->numCols; + junkData->n = junkData->nalloc; + junkData->data.V = in->data.V[0]; // since + // psImage + // data + // is + // contiguous... + + if (mask != NULL) { + if (mask->type.type != PS_TYPE_MASK) { + psError(__func__, "Expected the mask image type not found (type=%x)", mask->type.type); + psFree(junkData); + return NULL; + } + // stuff the mask data into a psVector + // struct. + junkMask = psAlloc(sizeof(psVector)); + junkMask->type = mask->type; + junkMask->nalloc = mask->numRows * mask->numCols; + junkMask->n = junkMask->nalloc; + junkMask->data.V = mask->data.V[0]; + } + + out = psVectorHistogram(out, junkData, junkMask, maskVal); + + psFree(junkMask); + psFree(junkData); + + return (out); +} + +float *p_psCalcScaleFactorsFit(int n) +{ + int i = 0; + float tmp = 0.0; + float *scalingFactors = (float *)psAlloc(n * sizeof(float)); + + for (i = 0; i < n; i++) { + // ((2.0 * (float) i) / ((float) (n-1))) + // - 1.0; + // tmp = (float) (i + 1); + tmp = (float)(n - i); + tmp = (M_PI * (tmp - 0.5)) / ((float)n); + scalingFactors[i] = cos(tmp); + } + + return (scalingFactors); +} + +/***************************************************************************** +p_psCalcScaleFactorsEval(n): The Chebyshev polynomials are defined over the +interval [-1.0 : 1.0]. Images typically have sizes of 512x512 or more. In +order to use Chebyshev polynomials, we must scales the coordinates from +0:512 to -1:1. This routine takes as input an integer N and produces as +output a vector of evenly spaced floating point values between -1.0:1.0. + *****************************************************************************/ +float *p_psCalcScaleFactorsEval(int n) +{ + int i = 0; + float tmp = 0.0; + + return p_psCalcScaleFactorsFit(n); + + printf("Should not get here\n"); + float *scalingFactors = (float *)psAlloc(n * sizeof(float)); + + for (i = 0; i < n; i++) { + // scalingFactors[i] = ((2.0 * (float) i) + // / ((float) (n-1))) - 1.0; + tmp = (float)(n - i); + tmp = (M_PI * (tmp - 0.5)) / ((float)n); + scalingFactors[i] = cos(tmp); + } + return (scalingFactors); +} + +psPolynomial1D* *p_psCreateChebyshevPolys(int maxChebyPoly) +{ + psPolynomial1D* *chebPolys = NULL; + int i = 0; + int j = 0; + + chebPolys = (psPolynomial1D* *) psAlloc(maxChebyPoly * sizeof(psPolynomial1D* )); + for (i = 0; i < maxChebyPoly; i++) { + chebPolys[i] = psPolynomial1DAlloc(i + 1); + } + + // Create the Chebyshev polynomials. + // Polynomial i has i-th order. + chebPolys[0]->coeff[0] = 1; + chebPolys[1]->coeff[1] = 1; + for (i = 2; i < maxChebyPoly; i++) { + for (j = 0; j < chebPolys[i - 1]->n; j++) { + chebPolys[i]->coeff[j + 1] = 2 * chebPolys[i - 1]->coeff[j]; + } + for (j = 0; j < chebPolys[i - 2]->n; j++) { + chebPolys[i]->coeff[j] -= chebPolys[i - 2]->coeff[j]; + } + } + + return (chebPolys); +} + +/***************************************************************************** +psImageFitPolynomial(): This routine takes as input a 2-D image and produces +as output the coefficients of the Chebyshev polynomials which match that +input image. + Input: + Output: + Internal Data Structures: + chebPolys[i][j] + sums[i][j]: This will contain the sum of + input->data.F32[x][y] * + psPolynomial1DEval((float) x, chebPolys[i]) * + psPolynomial1DEval((float) y, chebPolys[j]); + over all pixels (x,y) in the image. + *****************************************************************************/ +psPolynomial2D* psImageFitPolynomial(const psImage* input, psPolynomial2D* coeffs) +{ + int x = 0; + int y = 0; + int i = 0; + int j = 0; + float **sums = NULL; + psPolynomial1D* *chebPolys = NULL; + int maxChebyPoly = 0; + float *cScalingFactors = NULL; + float *rScalingFactors = NULL; + float tmp = 0.0; + + // Create the sums[][] data structure. This + // will hold the LHS of + // equation + // 29 in the ADD: sums[k][l] = SUM { + // image(x,y) * Tk(x) * Tl(y) } + sums = (float **)psAlloc(coeffs->nX * sizeof(float *)); + for (i = 0; i < coeffs->nX; i++) { + sums[i] = (float *)psAlloc(coeffs->nY * sizeof(float)); + } + + // We scale the pixel positions to values + // between -1.0 and 1.0 + rScalingFactors = p_psCalcScaleFactorsFit(input->numRows); + cScalingFactors = p_psCalcScaleFactorsFit(input->numCols); + + // Determine how many Chebyshev polynomials + // are needed, then create them. + maxChebyPoly = coeffs->nX; + if (coeffs->nY > coeffs->nX) { + maxChebyPoly = coeffs->nY; + } + chebPolys = p_psCreateChebyshevPolys(maxChebyPoly); + + // Sanity check for the Chebyshevs. + for (i = 0; i < coeffs->nX; i++) { + for (j = 0; j < coeffs->nY; j++) { + tmp = 0.0; + for (x = 0; x < input->numRows; x++) { + tmp += + psPolynomial1DEval + (rScalingFactors[x], chebPolys[i]) * psPolynomial1DEval(rScalingFactors[x], chebPolys[j]); + + } + // printf("SUM(Cheby(%d) * Cheby(%d)) + // is %f\n", i, j, tmp); + } + } + + // Compute the sums[][] data structure. + for (i = 0; i < coeffs->nX; i++) { + for (j = 0; j < coeffs->nY; j++) { + sums[i][j] = 0.0; + for (x = 0; x < input->numRows; x++) { + for (y = 0; y < input->numCols; y++) { + sums[i][j] += + input->data.F32[x][y] * + psPolynomial1DEval + (rScalingFactors[x], + chebPolys[i]) * psPolynomial1DEval(cScalingFactors[y], chebPolys[j]); + } + } + } + } + + for (i = 0; i < coeffs->nX; i++) { + for (j = 0; j < coeffs->nY; j++) { + coeffs->coeff[i][j] = sums[i][j]; + coeffs->coeff[i][j] /= (float)(input->numRows * input->numCols); + + if ((i != 0) && (j != 0)) { + coeffs->coeff[i][j] *= 4.0; + } else if ((i == 0) && (j == 0)) { + coeffs->coeff[i][j] *= 1.0; + } else { + coeffs->coeff[i][j] *= 2.0; + } + } + } + + // Free the Chebyshev polynomials that were + // created in this routine. + for (i = 0; i < maxChebyPoly; i++) { + psFree(chebPolys[i]); + } + psFree(chebPolys); + + // Free some data + for (i = 0; i < coeffs->nX; i++) { + psFree(sums[i]); + } + psFree(sums); + psFree(cScalingFactors); + psFree(rScalingFactors); + + return (coeffs); +} + +/***************************************************************************** + + *****************************************************************************/ +psImage* psImageEvalPolynomial(psImage* input, const psPolynomial2D* coeffs) +{ + int x = 0; + int y = 0; + int i = 0; + int j = 0; + float **sums = NULL; + psPolynomial1D* *chebPolys = NULL; + int maxChebyPoly = 0; + float *cScalingFactors = NULL; + float *rScalingFactors = NULL; + float polySum = 0.0; + + // Create the sums[][] data structure. This + // will hold the LHS of + // equation + // 29 in the ADD: sums[k][l] = SUM { + // image(x,y) * Tk(x) * Tl(y) } + sums = (float **)psAlloc(coeffs->nX * sizeof(float *)); + for (i = 0; i < coeffs->nX; i++) { + sums[i] = (float *)psAlloc(coeffs->nY * sizeof(float)); + } + for (i = 0; i < coeffs->nX; i++) { + for (j = 0; j < coeffs->nY; j++) { + sums[i][j] = 0.0; + } + } + + // We scale the pixel positions to values + // between -1.0 and 1.0 + rScalingFactors = p_psCalcScaleFactorsEval(input->numRows); + cScalingFactors = p_psCalcScaleFactorsEval(input->numCols); + + // Determine how many Chebyshev polynomials + // are needed, then create them. + maxChebyPoly = coeffs->nX; + if (coeffs->nY > coeffs->nX) { + maxChebyPoly = coeffs->nY; + } + + chebPolys = p_psCreateChebyshevPolys(maxChebyPoly); + + for (x = 0; x < input->numRows; x++) { + for (y = 0; y < input->numCols; y++) { + polySum = 0.0; + for (i = 0; i < coeffs->nX; i++) { + for (j = 0; j < coeffs->nY; j++) { + polySum += + psPolynomial1DEval + (rScalingFactors[x], + chebPolys[i]) * + psPolynomial1DEval(cScalingFactors[y], chebPolys[j]) * coeffs->coeff[i][j]; + + } + } + input->data.F32[x][y] = polySum; + } + } + + // Free the Chebyshev polynomials that were + // created in this routine. + for (i = 0; i < maxChebyPoly; i++) { + psFree(chebPolys[i]); + } + psFree(chebPolys); + + // Free some data + for (i = 0; i < coeffs->nX; i++) { + psFree(sums[i]); + } + psFree(sums); + psFree(cScalingFactors); + psFree(rScalingFactors); + + return input; +} Index: /tags/rel2_1/psLib/src/image/psImageStats.h =================================================================== --- /tags/rel2_1/psLib/src/image/psImageStats.h (revision 1553) +++ /tags/rel2_1/psLib/src/image/psImageStats.h (revision 1553) @@ -0,0 +1,89 @@ +/** @file psImageStats.h +* \brief Routines for calculating statistics on images. +* @ingroup ImageStats +* +* This file will hold the prototypes for procedures which calculate +* statistic on images, histograms on images, and fit/evaluate Chebyshev +* polynomials to images. +* +* @author George Gusciora, MHPCC +* +* @version $Revision: 1.16 $ $Name: not supported by cvs2svn $ +* @date $Date: 2004-08-10 01:55:34 $ +* +* Copyright 2004 Maui High Performance Computing Center, University of Hawaii +*/ +#if !defined(PS_IMAGE_STATS_H) +#define PS_IMAGE_STATS_H + +#include "psType.h" +#include "psVector.h" +#include "psImage.h" +#include "psStats.h" +#include "psFunctions.h" + +/// @addtogroup ImageStats +/// @{ + +/** This routine must determine the various statistics for the image. + * + * Determine statistics for image (or subimage). The statistics to be + * determined are specified by stats. The mask allows pixels to be excluded + * if their corresponding mask pixel value matches the value of maskVal. + * This function must be defined for the following types: psS8, psU16, psF32, + * psF64. + * + * @return psStats* the resulting statistics result(s) + */ +psStats* psImageStats( + psStats* stats, ///< defines statistics to be calculated + psImage* in, ///< image (or subimage) to calculate stats + psImage* mask, ///< mask data for image (NULL ok) + int maskVal ///< mask Mask for mask +); + +/** Construct a histogram from an image (or subimage). + * + * The histogram to generate is specified by psHistogram hist (see section + * 4.3.2 in SDRS). This function must be defined for the following types: + * psS8, psU16, psF32, psF64. + * + * @return psHistogram* the resulting histogram + */ +psHistogram* psImageHistogram( + psHistogram* out, ///< input histogram description & target + psImage* in, ///< Image data to be histogramed. + psImage* mask, ///< mask data for image (NULL ok) + unsigned int maskVal ///< mask Mask for mask +); + +/** Fit a 2-D polynomial surface to an image. + * + * The input structure coeffs contains the desired order and terms of + * interest. This function must be defined for the following types: psS8, + * psU16, psF32, psF64. + * + * @return psPolynomial2D* fitted polynomial result + * + */ +psPolynomial2D* psImageFitPolynomial( + const psImage* input, ///< image to fit + psPolynomial2D* coeffs ///< coefficient structure carries in desired terms & target +); + +/** Evaluate a 2-D polynomial surface for the image pixels. + * + * Given the input polynomial coefficients, set the image pixel values on the + * basis of the polynomial function. This function must be defined for the + * following types: psS8, psU16, psF32, psF64. + * + * @return psImage* the resulting image + */ +psImage* psImageEvalPolynomial( + psImage* input, ///< input image + const psPolynomial2D* coeffs ///< coefficient structure carries in desired terms +); + +/// @} + +#endif Index: /tags/rel2_1/psLib/src/imageops/psImageStats.c =================================================================== --- /tags/rel2_1/psLib/src/imageops/psImageStats.c (revision 1553) +++ /tags/rel2_1/psLib/src/imageops/psImageStats.c (revision 1553) @@ -0,0 +1,404 @@ + +/** @file psImageStats.c +* \brief Routines for calculating statistics on images. +* @ingroup ImageStats +* +* This file will hold the prototypes for procedures which calculate +* statistic on images, histograms on images, and fit/evaluate Chebyshev +* polynomials to images. +* +* @author George Gusciora, MHPCC +* +* @version $Revision: 1.33 $ $Name: not supported by cvs2svn $ +* @date $Date: 2004-08-10 01:55:34 $ +* +* Copyright 2004 Maui High Performance Computing Center, University of Hawaii +*/ + +#include +#include +#include +#include +#include +#include +#include "psMemory.h" +#include "psVector.h" +#include "psTrace.h" +#include "psError.h" +#include "psAbort.h" +#include "psStats.h" +#include "psImage.h" +#include "psFunctions.h" +#include "psImageStats.h" + +/// This routine must determine the various statistics for the image. + +/***************************************************************************** + NOTE: verify that image/mask have the correct types, and sizes. + *****************************************************************************/ +psStats* psImageStats(psStats* stats, psImage* in, psImage* mask, int maskVal) +{ + psVector* junkData = NULL; + psVector* junkMask = NULL; + + if (stats == NULL) { + psError(__func__, "The input psStats struct can not be NULL."); + return NULL; + } + + if (in == NULL) { + psError(__func__, "The input image can not be NULL."); + return NULL; + } + + if (stats->options == 0) { + psError(__func__, "No statistic option/operation was specified."); + return stats; + } + // stuff the image data into a psVector + // struct. + junkData = psAlloc(sizeof(psVector)); + junkData->type = in->type; + junkData->nalloc = in->numRows * in->numCols; + junkData->n = junkData->nalloc; + junkData->data.V = in->data.V[0]; // since + // psImage + // data + // is + // contiguous... + + if (mask != NULL) { + if (mask->type.type != PS_TYPE_MASK) { + psError(__func__, "Expected the mask image type not found (type=%x)", mask->type.type); + psFree(junkData); + return NULL; + } + // stuff the mask data into a psVector + // struct. + junkMask = psAlloc(sizeof(psVector)); + junkMask->type = mask->type; + junkMask->nalloc = mask->numRows * mask->numCols; + junkMask->n = junkMask->nalloc; + junkMask->data.V = mask->data.V[0]; + } + + stats = psVectorStats(stats, junkData, junkMask, maskVal); + + psFree(junkMask); + psFree(junkData); + return (stats); +} + +/***************************************************************************** + NOTE: We assume that the psHistogram structure out has already been + allocated and initialized. + NOTE: verify that image/mask have the, correct types and sizes. + *****************************************************************************/ +psHistogram* psImageHistogram(psHistogram* out, psImage* in, psImage* mask, unsigned int maskVal) +{ + psVector* junkData = NULL; + psVector* junkMask = NULL; + + // NOTE: Verify this action. + if ((out == NULL) || (in == NULL)) { + return (NULL); + } + + junkData = psAlloc(sizeof(psVector)); + junkData->type = in->type; + junkData->nalloc = in->numRows * in->numCols; + junkData->n = junkData->nalloc; + junkData->data.V = in->data.V[0]; // since + // psImage + // data + // is + // contiguous... + + if (mask != NULL) { + if (mask->type.type != PS_TYPE_MASK) { + psError(__func__, "Expected the mask image type not found (type=%x)", mask->type.type); + psFree(junkData); + return NULL; + } + // stuff the mask data into a psVector + // struct. + junkMask = psAlloc(sizeof(psVector)); + junkMask->type = mask->type; + junkMask->nalloc = mask->numRows * mask->numCols; + junkMask->n = junkMask->nalloc; + junkMask->data.V = mask->data.V[0]; + } + + out = psVectorHistogram(out, junkData, junkMask, maskVal); + + psFree(junkMask); + psFree(junkData); + + return (out); +} + +float *p_psCalcScaleFactorsFit(int n) +{ + int i = 0; + float tmp = 0.0; + float *scalingFactors = (float *)psAlloc(n * sizeof(float)); + + for (i = 0; i < n; i++) { + // ((2.0 * (float) i) / ((float) (n-1))) + // - 1.0; + // tmp = (float) (i + 1); + tmp = (float)(n - i); + tmp = (M_PI * (tmp - 0.5)) / ((float)n); + scalingFactors[i] = cos(tmp); + } + + return (scalingFactors); +} + +/***************************************************************************** +p_psCalcScaleFactorsEval(n): The Chebyshev polynomials are defined over the +interval [-1.0 : 1.0]. Images typically have sizes of 512x512 or more. In +order to use Chebyshev polynomials, we must scales the coordinates from +0:512 to -1:1. This routine takes as input an integer N and produces as +output a vector of evenly spaced floating point values between -1.0:1.0. + *****************************************************************************/ +float *p_psCalcScaleFactorsEval(int n) +{ + int i = 0; + float tmp = 0.0; + + return p_psCalcScaleFactorsFit(n); + + printf("Should not get here\n"); + float *scalingFactors = (float *)psAlloc(n * sizeof(float)); + + for (i = 0; i < n; i++) { + // scalingFactors[i] = ((2.0 * (float) i) + // / ((float) (n-1))) - 1.0; + tmp = (float)(n - i); + tmp = (M_PI * (tmp - 0.5)) / ((float)n); + scalingFactors[i] = cos(tmp); + } + return (scalingFactors); +} + +psPolynomial1D* *p_psCreateChebyshevPolys(int maxChebyPoly) +{ + psPolynomial1D* *chebPolys = NULL; + int i = 0; + int j = 0; + + chebPolys = (psPolynomial1D* *) psAlloc(maxChebyPoly * sizeof(psPolynomial1D* )); + for (i = 0; i < maxChebyPoly; i++) { + chebPolys[i] = psPolynomial1DAlloc(i + 1); + } + + // Create the Chebyshev polynomials. + // Polynomial i has i-th order. + chebPolys[0]->coeff[0] = 1; + chebPolys[1]->coeff[1] = 1; + for (i = 2; i < maxChebyPoly; i++) { + for (j = 0; j < chebPolys[i - 1]->n; j++) { + chebPolys[i]->coeff[j + 1] = 2 * chebPolys[i - 1]->coeff[j]; + } + for (j = 0; j < chebPolys[i - 2]->n; j++) { + chebPolys[i]->coeff[j] -= chebPolys[i - 2]->coeff[j]; + } + } + + return (chebPolys); +} + +/***************************************************************************** +psImageFitPolynomial(): This routine takes as input a 2-D image and produces +as output the coefficients of the Chebyshev polynomials which match that +input image. + Input: + Output: + Internal Data Structures: + chebPolys[i][j] + sums[i][j]: This will contain the sum of + input->data.F32[x][y] * + psPolynomial1DEval((float) x, chebPolys[i]) * + psPolynomial1DEval((float) y, chebPolys[j]); + over all pixels (x,y) in the image. + *****************************************************************************/ +psPolynomial2D* psImageFitPolynomial(const psImage* input, psPolynomial2D* coeffs) +{ + int x = 0; + int y = 0; + int i = 0; + int j = 0; + float **sums = NULL; + psPolynomial1D* *chebPolys = NULL; + int maxChebyPoly = 0; + float *cScalingFactors = NULL; + float *rScalingFactors = NULL; + float tmp = 0.0; + + // Create the sums[][] data structure. This + // will hold the LHS of + // equation + // 29 in the ADD: sums[k][l] = SUM { + // image(x,y) * Tk(x) * Tl(y) } + sums = (float **)psAlloc(coeffs->nX * sizeof(float *)); + for (i = 0; i < coeffs->nX; i++) { + sums[i] = (float *)psAlloc(coeffs->nY * sizeof(float)); + } + + // We scale the pixel positions to values + // between -1.0 and 1.0 + rScalingFactors = p_psCalcScaleFactorsFit(input->numRows); + cScalingFactors = p_psCalcScaleFactorsFit(input->numCols); + + // Determine how many Chebyshev polynomials + // are needed, then create them. + maxChebyPoly = coeffs->nX; + if (coeffs->nY > coeffs->nX) { + maxChebyPoly = coeffs->nY; + } + chebPolys = p_psCreateChebyshevPolys(maxChebyPoly); + + // Sanity check for the Chebyshevs. + for (i = 0; i < coeffs->nX; i++) { + for (j = 0; j < coeffs->nY; j++) { + tmp = 0.0; + for (x = 0; x < input->numRows; x++) { + tmp += + psPolynomial1DEval + (rScalingFactors[x], chebPolys[i]) * psPolynomial1DEval(rScalingFactors[x], chebPolys[j]); + + } + // printf("SUM(Cheby(%d) * Cheby(%d)) + // is %f\n", i, j, tmp); + } + } + + // Compute the sums[][] data structure. + for (i = 0; i < coeffs->nX; i++) { + for (j = 0; j < coeffs->nY; j++) { + sums[i][j] = 0.0; + for (x = 0; x < input->numRows; x++) { + for (y = 0; y < input->numCols; y++) { + sums[i][j] += + input->data.F32[x][y] * + psPolynomial1DEval + (rScalingFactors[x], + chebPolys[i]) * psPolynomial1DEval(cScalingFactors[y], chebPolys[j]); + } + } + } + } + + for (i = 0; i < coeffs->nX; i++) { + for (j = 0; j < coeffs->nY; j++) { + coeffs->coeff[i][j] = sums[i][j]; + coeffs->coeff[i][j] /= (float)(input->numRows * input->numCols); + + if ((i != 0) && (j != 0)) { + coeffs->coeff[i][j] *= 4.0; + } else if ((i == 0) && (j == 0)) { + coeffs->coeff[i][j] *= 1.0; + } else { + coeffs->coeff[i][j] *= 2.0; + } + } + } + + // Free the Chebyshev polynomials that were + // created in this routine. + for (i = 0; i < maxChebyPoly; i++) { + psFree(chebPolys[i]); + } + psFree(chebPolys); + + // Free some data + for (i = 0; i < coeffs->nX; i++) { + psFree(sums[i]); + } + psFree(sums); + psFree(cScalingFactors); + psFree(rScalingFactors); + + return (coeffs); +} + +/***************************************************************************** + + *****************************************************************************/ +psImage* psImageEvalPolynomial(psImage* input, const psPolynomial2D* coeffs) +{ + int x = 0; + int y = 0; + int i = 0; + int j = 0; + float **sums = NULL; + psPolynomial1D* *chebPolys = NULL; + int maxChebyPoly = 0; + float *cScalingFactors = NULL; + float *rScalingFactors = NULL; + float polySum = 0.0; + + // Create the sums[][] data structure. This + // will hold the LHS of + // equation + // 29 in the ADD: sums[k][l] = SUM { + // image(x,y) * Tk(x) * Tl(y) } + sums = (float **)psAlloc(coeffs->nX * sizeof(float *)); + for (i = 0; i < coeffs->nX; i++) { + sums[i] = (float *)psAlloc(coeffs->nY * sizeof(float)); + } + for (i = 0; i < coeffs->nX; i++) { + for (j = 0; j < coeffs->nY; j++) { + sums[i][j] = 0.0; + } + } + + // We scale the pixel positions to values + // between -1.0 and 1.0 + rScalingFactors = p_psCalcScaleFactorsEval(input->numRows); + cScalingFactors = p_psCalcScaleFactorsEval(input->numCols); + + // Determine how many Chebyshev polynomials + // are needed, then create them. + maxChebyPoly = coeffs->nX; + if (coeffs->nY > coeffs->nX) { + maxChebyPoly = coeffs->nY; + } + + chebPolys = p_psCreateChebyshevPolys(maxChebyPoly); + + for (x = 0; x < input->numRows; x++) { + for (y = 0; y < input->numCols; y++) { + polySum = 0.0; + for (i = 0; i < coeffs->nX; i++) { + for (j = 0; j < coeffs->nY; j++) { + polySum += + psPolynomial1DEval + (rScalingFactors[x], + chebPolys[i]) * + psPolynomial1DEval(cScalingFactors[y], chebPolys[j]) * coeffs->coeff[i][j]; + + } + } + input->data.F32[x][y] = polySum; + } + } + + // Free the Chebyshev polynomials that were + // created in this routine. + for (i = 0; i < maxChebyPoly; i++) { + psFree(chebPolys[i]); + } + psFree(chebPolys); + + // Free some data + for (i = 0; i < coeffs->nX; i++) { + psFree(sums[i]); + } + psFree(sums); + psFree(cScalingFactors); + psFree(rScalingFactors); + + return input; +} Index: /tags/rel2_1/psLib/src/imageops/psImageStats.h =================================================================== --- /tags/rel2_1/psLib/src/imageops/psImageStats.h (revision 1553) +++ /tags/rel2_1/psLib/src/imageops/psImageStats.h (revision 1553) @@ -0,0 +1,89 @@ +/** @file psImageStats.h +* \brief Routines for calculating statistics on images. +* @ingroup ImageStats +* +* This file will hold the prototypes for procedures which calculate +* statistic on images, histograms on images, and fit/evaluate Chebyshev +* polynomials to images. +* +* @author George Gusciora, MHPCC +* +* @version $Revision: 1.16 $ $Name: not supported by cvs2svn $ +* @date $Date: 2004-08-10 01:55:34 $ +* +* Copyright 2004 Maui High Performance Computing Center, University of Hawaii +*/ +#if !defined(PS_IMAGE_STATS_H) +#define PS_IMAGE_STATS_H + +#include "psType.h" +#include "psVector.h" +#include "psImage.h" +#include "psStats.h" +#include "psFunctions.h" + +/// @addtogroup ImageStats +/// @{ + +/** This routine must determine the various statistics for the image. + * + * Determine statistics for image (or subimage). The statistics to be + * determined are specified by stats. The mask allows pixels to be excluded + * if their corresponding mask pixel value matches the value of maskVal. + * This function must be defined for the following types: psS8, psU16, psF32, + * psF64. + * + * @return psStats* the resulting statistics result(s) + */ +psStats* psImageStats( + psStats* stats, ///< defines statistics to be calculated + psImage* in, ///< image (or subimage) to calculate stats + psImage* mask, ///< mask data for image (NULL ok) + int maskVal ///< mask Mask for mask +); + +/** Construct a histogram from an image (or subimage). + * + * The histogram to generate is specified by psHistogram hist (see section + * 4.3.2 in SDRS). This function must be defined for the following types: + * psS8, psU16, psF32, psF64. + * + * @return psHistogram* the resulting histogram + */ +psHistogram* psImageHistogram( + psHistogram* out, ///< input histogram description & target + psImage* in, ///< Image data to be histogramed. + psImage* mask, ///< mask data for image (NULL ok) + unsigned int maskVal ///< mask Mask for mask +); + +/** Fit a 2-D polynomial surface to an image. + * + * The input structure coeffs contains the desired order and terms of + * interest. This function must be defined for the following types: psS8, + * psU16, psF32, psF64. + * + * @return psPolynomial2D* fitted polynomial result + * + */ +psPolynomial2D* psImageFitPolynomial( + const psImage* input, ///< image to fit + psPolynomial2D* coeffs ///< coefficient structure carries in desired terms & target +); + +/** Evaluate a 2-D polynomial surface for the image pixels. + * + * Given the input polynomial coefficients, set the image pixel values on the + * basis of the polynomial function. This function must be defined for the + * following types: psS8, psU16, psF32, psF64. + * + * @return psImage* the resulting image + */ +psImage* psImageEvalPolynomial( + psImage* input, ///< input image + const psPolynomial2D* coeffs ///< coefficient structure carries in desired terms +); + +/// @} + +#endif Index: /tags/rel2_1/psLib/src/mainpage.dox =================================================================== --- /tags/rel2_1/psLib/src/mainpage.dox (revision 1553) +++ /tags/rel2_1/psLib/src/mainpage.dox (revision 1553) @@ -0,0 +1,154 @@ +/** @mainpage psLib Image Processing Library + + +@section intro Introduction + +This library contains the Pan-STARRS Image Processing Pipeline (IPP) common library, +psLib. The intended use is to provide a set of basic software functions in which +can be used throughout the Pan-STARRS project to simplify programming tasks. Among +the benefits are: + - reuse of code, + - simplification of testing, + - streamlining of code, and + - isolation of functionality that may be subject to change. + +The capabilities provided by psLib are grouped into the following areas which are +also reflected in the file system directory structure: + - System Utilities + - Data Collections + - Image Operations + - Data Manipulation + - Astronomy + +This list is sorted in hierarchical order: The later entries depend on the functions and +data types of the earlier entries. + +The installed code for psLib consists of header files and binary libraries in +the form of static (libpslib.a) and shared (libpslib.so or libpslib.dylib, +depending on operating system.) Assuming these components have been built and +installed in the standard library path, psLib may be used within a program by +including the line #include and linking using the '-lpslib' option +while linking. + + +@section extinstall Required 3rd Party Libraries + +Before building psLib from source, several 3rd party software libraries must +be installed. These include: + - GNU Scientific Library (GSL) + - Available at http://www.gnu.org/software/gsl + - Compatibility tested with version is 1.4 + - Fastest Fourier Transform in the West (FFTW), version 3 + - Available at http://www.fftw.org + - Compatibility tested with version is 3.0.1 + - C Flexible Image Transport System Input output (CFITSIO), version 2.480 or later + - Available at http://heasarc.gsfc.nasa.gov/docs/software/fitsio + - Compatibility tested with version is 2.490 + - Versions earlier than 2.480 will not work as new functionality introduced in 2.480 is exercised + - Doxygen Documentation System + - Available at http://www.doxygen.org + - Compatibility tested with version 1.3.6 + - The optional companion package, GraphViz (a.k.a., the 'dot' command), is recommended to enable header-file dependency diagrams + - SLALIB + - We tested with the Fortran version of the library; this may cause an additional step to get things to link on untested systems/compilers, as there is no one standard for how the function-names appear in the library to C code. The default way that psLib uses is all-lower case with a trailing '_', but one may need to add to CFLAGS in src/Makefile.Globals the following: + - '-DFORTRAN_UNDERSCORE_PREFIX' if a '_' needs to be prefixed to the function names, + - '-DFORTRAN_DOUBLE_UNDERSCORE_SUFFIX' if two the names needs two trailing '_'s., and/or + - '-DFORTRAN_UPPERCASE' if the names appear as uppercase. + - Available at http://star-www.rl.ac.uk/ + - Compatibility tested with package version number 2.4-12 + +We recommend using the particular versions listed as compatibility tested, as +that is the only versions of the external libraries tested to work well with psLib. +Though it is quite possible that later versions of the libraries listed will also +work as well, care must be taken when upgrading these libraries to verify that its +functionality is compatible with the tested version. + +@section install How to Build from Source + +Tested versions of psLib are put into a tar file and can be downloaded from: + +https://mhpcc.pan-starrs.org/code/releases + +Though MHPCC recommends using the released packaged tar files descibed above, +both daily development snapshots and direct CVS access is available. The daily +snapshots are available at + +https://mhpcc.pan-starrs.org/code/snapshots + +These snapshots represents development code as found in CVS on the day +specified in the filename. This code set may not be functional, vary in +testing, etc. Reasonable efforts are made to ensure that the code does +actually compile, but given the nature of code development, even that is not +always the case. Use snapshots with great caution. + +If one has a login account on mhpcc.pan-starrs.org, direct CVS access is +possible. Example of the commands required for direct CVS retrieval are +as follows: +
+$ cvs -d:ext:USERNAME@mhpcc.pan-starrs.org:/data/panstarrs/cvsroot co -r RELEASEBRANCH psLib
+
+where: + - USERNAME is your login name on the server + - RELEASEBRANCH is the desired release branch, e.g. rel1, rel2, etc. + + +@section build How to Build the psLib library. + +The source should build using the Makefile in the psLib/src directory. The +recommended steps are: +
+$ cd psLib/src
+$ make
+$ make install
+
+This builds and installs files to psLib/lib and psLib/include. + + +@section run How to Build and Run Tests + +Since psLib is a library, there is no executable, per se. However, to test the +installation, users may execute the unit test suite. To build the unit test +suite, do the following: +
+$ cd psLib/test
+$ make
+$ make install
+$ make installtests
+
+This builds and installs the unit test files to the psLib/testbin directory. + +To run the unit test suite, do the following: +
+$ cd psLib/testbin
+$ ./FullUnitTest
+
+or to run a particular test +
+$ ./runTest testfilename
+
+ +Note: one can also fun the FullUnitTest from anywhere within psLib/test +without performing the above 'make installtests' command first. To do this, +one needs to first set the PSLIB_ROOT environment variable to the top psLib +directory 'psLib'. FullUnitTest will search for tests in the subdirectories +the the execution directory, perform a build of them (via 'make'), and run them. +This can be useful if one wants to tweak the test code and doesn't desire to +perform an install of all the tests each time the test file is touched. + + +@section doc How to Create Code Documentation + +Both HTML and man page documentation may be generated from the inline +documentation embedded in the code using the following commands: +
+$ cd psLib/src
+$ make docs
+
+This places documentation in psLib/docs. + +Also, a prebuilt set of code documentation for both the releases and last +CVS snapshot can be found at: + +https://mhpcc.pan-starrs.org/docs/ + +*/ Index: /tags/rel2_1/psLib/src/math/psCompare.c =================================================================== --- /tags/rel2_1/psLib/src/math/psCompare.c (revision 1553) +++ /tags/rel2_1/psLib/src/math/psCompare.c (revision 1553) @@ -0,0 +1,80 @@ + +/** @file psCompare.c + * @brief Comparison functions for sorting routines + * @ingroup Compare + * + * @author Robert Lupton, Princeton University + * @author Robert Daniel DeSonia, MHPCC + * + * @version $Revision: 1.4 $ $Name: not supported by cvs2svn $ + * @date $Date: 2004-08-07 00:06:06 $ + * + * Copyright 2004 Maui High Performance Computing Center, University of Hawaii + */ + +#include "psType.h" +#include "psCompare.h" + +#define COMPARE_NUMERIC_PTR(TYPE) \ +int psCompare##TYPE##Ptr(const void** a, const void** b) { \ + return **((ps##TYPE**)a) - **((ps##TYPE**)b); \ +} + +#define COMPARE_NUMERIC_PTR_DESCENDING(TYPE) \ +int psCompareDescending##TYPE##Ptr(const void** a, const void** b) { \ + return **((ps##TYPE**)b) - **((ps##TYPE**)a); \ +} + +#define COMPARE_NUMERIC(TYPE) \ +int psCompare##TYPE(const void* a, const void* b) { \ + return *((ps##TYPE*)a) - *((ps##TYPE*)b); \ +} + +#define COMPARE_NUMERIC_DESCENDING(TYPE) \ +int psCompare##TYPE##Descending(const void* a, const void* b) { \ + return *((ps##TYPE*)b) - *((ps##TYPE*)a); \ +} + +COMPARE_NUMERIC_PTR(S8) +COMPARE_NUMERIC_PTR(S16) +COMPARE_NUMERIC_PTR(S32) +COMPARE_NUMERIC_PTR(S64) +COMPARE_NUMERIC_PTR(U8) +COMPARE_NUMERIC_PTR(U16) +COMPARE_NUMERIC_PTR(U32) +COMPARE_NUMERIC_PTR(U64) +COMPARE_NUMERIC_PTR(F32) +COMPARE_NUMERIC_PTR(F64) + +COMPARE_NUMERIC_PTR_DESCENDING(S8) +COMPARE_NUMERIC_PTR_DESCENDING(S16) +COMPARE_NUMERIC_PTR_DESCENDING(S32) +COMPARE_NUMERIC_PTR_DESCENDING(S64) +COMPARE_NUMERIC_PTR_DESCENDING(U8) +COMPARE_NUMERIC_PTR_DESCENDING(U16) +COMPARE_NUMERIC_PTR_DESCENDING(U32) +COMPARE_NUMERIC_PTR_DESCENDING(U64) +COMPARE_NUMERIC_PTR_DESCENDING(F32) +COMPARE_NUMERIC_PTR_DESCENDING(F64) + +COMPARE_NUMERIC(S8) +COMPARE_NUMERIC(S16) +COMPARE_NUMERIC(S32) +COMPARE_NUMERIC(S64) +COMPARE_NUMERIC(U8) +COMPARE_NUMERIC(U16) +COMPARE_NUMERIC(U32) +COMPARE_NUMERIC(U64) +COMPARE_NUMERIC(F32) +COMPARE_NUMERIC(F64) + +COMPARE_NUMERIC_DESCENDING(S8) +COMPARE_NUMERIC_DESCENDING(S16) +COMPARE_NUMERIC_DESCENDING(S32) +COMPARE_NUMERIC_DESCENDING(S64) +COMPARE_NUMERIC_DESCENDING(U8) +COMPARE_NUMERIC_DESCENDING(U16) +COMPARE_NUMERIC_DESCENDING(U32) +COMPARE_NUMERIC_DESCENDING(U64) +COMPARE_NUMERIC_DESCENDING(F32) +COMPARE_NUMERIC_DESCENDING(F64) Index: /tags/rel2_1/psLib/src/math/psCompare.h =================================================================== --- /tags/rel2_1/psLib/src/math/psCompare.h (revision 1553) +++ /tags/rel2_1/psLib/src/math/psCompare.h (revision 1553) @@ -0,0 +1,506 @@ +#if !defined(PS_COMPARE_H) +#define PS_COMPARE_H + +/** @file psCompare.h + * @brief Comparison functions for sorting routines + * + * @author Robert Daniel DeSonia, MHPCC + * + * @ingroup Compare + * + * @version $Revision: 1.4 $ $Name: not supported by cvs2svn $ + * @date $Date: 2004-08-11 19:58:11 $ + * + * Copyright 2004 Maui High Performance Computing Center, University of Hawaii + */ + +/** @addtogroup Compare +* @{ +*/ + +/** A comparison function for sorting elements that are pointers to data, + * e.g., for psList of pointers to numeric values. + * + * @return int an integer less than, equal to, or greater than zero if + * the first argument is considered to be respectively less + * than, equal to, or greater than the second. + */ +typedef int (*psComparePtrFcn) ( + const void **a, ///< first comparison target + const void **b ///< second comparison target +); + +/** A comparison function for sorting. + * + * @return int an integer less than, equal to, or greater than zero if + * the first argument is considered to be respectively less + * than, equal to, or greater than the second. + */ +typedef int (*psCompareFcn) ( + const void *a, ///< first comparison target + const void *b ///< second comparison target +); + +/** Compare function of psS8 data. For use with psListSort. + * + * @return int an integer less than, equal to, or greater than zero if + * the first argument is considered to be respectively less + * than, equal to, or greater than the second. + */ +int psCompareS8Ptr( + const void **a, ///< first comparison target + const void **b ///< second comparison target +); + +/** Compare function of psS16 data. For use with psListSort. + * + * @return int an integer less than, equal to, or greater than zero if + * the first argument is considered to be respectively less + * than, equal to, or greater than the second. + */ +int psCompareS16Ptr( + const void **a, ///< first comparison target + const void **b ///< second comparison target +); + +/** Compare function of psS32 data. For use with psListSort. + * + * @return int an integer less than, equal to, or greater than zero if + * the first argument is considered to be respectively less + * than, equal to, or greater than the second. + */ +int psCompareS32Ptr( + const void **a, ///< first comparison target + const void **b ///< second comparison target +); + +/** Compare function of psS64 data. For use with psListSort. + * + * @return int an integer less than, equal to, or greater than zero if + * the first argument is considered to be respectively less + * than, equal to, or greater than the second. + */ +int psCompareS64Ptr( + const void **a, ///< first comparison target + const void **b ///< second comparison target +); + +/** Compare function of psU8 data. For use with psListSort. + * + * @return int an integer less than, equal to, or greater than zero if + * the first argument is considered to be respectively less + * than, equal to, or greater than the second. + */ +int psCompareU8Ptr( + const void **a, ///< first comparison target + const void **b ///< second comparison target +); + +/** Compare function of psU16 data. For use with psListSort. + * + * @return int an integer less than, equal to, or greater than zero if + * the first argument is considered to be respectively less + * than, equal to, or greater than the second. + */ +int psCompareU16Ptr( + const void **a, ///< first comparison target + const void **b ///< second comparison target +); + +/** Compare function of psU32 data. For use with psListSort. + * + * @return int an integer less than, equal to, or greater than zero if + * the first argument is considered to be respectively less + * than, equal to, or greater than the second. + */ +int psCompareU32Ptr( + const void **a, ///< first comparison target + const void **b ///< second comparison target +); + +/** Compare function of psU64 data. For use with psListSort. + * + * @return int an integer less than, equal to, or greater than zero if + * the first argument is considered to be respectively less + * than, equal to, or greater than the second. + */ +int psCompareU64Ptr( + const void **a, ///< first comparison target + const void **b ///< second comparison target +); + +/** Compare function of psF32 data. For use with psListSort. + * + * @return int an integer less than, equal to, or greater than zero if + * the first argument is considered to be respectively less + * than, equal to, or greater than the second. + */ +int psCompareF32Ptr( + const void **a, ///< first comparison target + const void **b ///< second comparison target +); + +/** Compare function of psF64 data. For use with psListSort. + * + * @return int an integer less than, equal to, or greater than zero if + * the first argument is considered to be respectively less + * than, equal to, or greater than the second. + */ +int psCompareF64Ptr( + const void **a, ///< first comparison target + const void **b ///< second comparison target +); + +/** Compare function of psS8 data. For use with psListSort for descending ordering. + * + * @return int an integer less than, equal to, or greater than zero if + * the first argument is considered to be respectively greater + * than, equal to, or less than the second. + */ +int psCompareDescendingS8Ptr( + const void **a, ///< first comparison target + const void **b ///< second comparison target +); + +/** Compare function of psS16 data. For use with psListSort for descending ordering. + * + * @return int an integer less than, equal to, or greater than zero if + * the first argument is considered to be respectively greater + * than, equal to, or less than the second. + */ +int psCompareDescendingS16Ptr( + const void **a, ///< first comparison target + const void **b ///< second comparison target +); + +/** Compare function of psS32 data. For use with psListSort for descending ordering. + * + * @return int an integer less than, equal to, or greater than zero if + * the first argument is considered to be respectively greater + * than, equal to, or less than the second. + */ +int psCompareDescendingS32Ptr( + const void **a, ///< first comparison target + const void **b ///< second comparison target +); + +/** Compare function of psS64 data. For use with psListSort for descending ordering. + * + * @return int an integer less than, equal to, or greater than zero if + * the first argument is considered to be respectively greater + * than, equal to, or less than the second. + */ +int psCompareDescendingS64Ptr( + const void **a, ///< first comparison target + const void **b ///< second comparison target +); + +/** Compare function of psU8 data. For use with psListSort for descending ordering. + * + * @return int an integer less than, equal to, or greater than zero if + * the first argument is considered to be respectively greater + * than, equal to, or less than the second. + */ +int psCompareDescendingU8Ptr( + const void **a, ///< first comparison target + const void **b ///< second comparison target +); + +/** Compare function of psU16 data. For use with psListSort for descending ordering. + * + * @return int an integer less than, equal to, or greater than zero if + * the first argument is considered to be respectively greater + * than, equal to, or less than the second. + */ +int psCompareDescendingU16Ptr( + const void **a, ///< first comparison target + const void **b ///< second comparison target +); + +/** Compare function of psU32 data. For use with psListSort for descending ordering. + * + * @return int an integer less than, equal to, or greater than zero if + * the first argument is considered to be respectively greater + * than, equal to, or lessg than the second. + */ +int psCompareDescendingU32Ptr( + const void **a, ///< first comparison target + const void **b ///< second comparison target +); + +/** Compare function of psU64 data. For use with psListSort for descending ordering. + * + * @return int an integer less than, equal to, or greater than zero if + * the first argument is considered to be respectively greater + * than, equal to, or lessg than the second. + */ +int psCompareDescendingU64Ptr( + const void **a, ///< first comparison target + const void **b ///< second comparison target +); + +/** Compare function of psF32 data. For use with psListSort for descending ordering. + * + * @return int an integer less than, equal to, or greater than zero if + * the first argument is considered to be respectively greater + * than, equal to, or lessg than the second. + */ +int psCompareDescendingF32Ptr( + const void **a, ///< first comparison target + const void **b ///< second comparison target +); + +/** Compare function of psF64 data. For use with psListSort for descending ordering. + * + * @return int an integer less than, equal to, or greater than zero if + * the first argument is considered to be respectively greater + * than, equal to, or lessg than the second. + */ +int psCompareDescendingF64Ptr( + const void **a, ///< first comparison target + const void **b ///< second comparison target +); + +/** Compare function of psS8 data. + * + * @return int an integer less than, equal to, or greater than zero if + * the first argument is considered to be respectively less + * than, equal to, or greater than the second. + */ +int psCompareS8( + const void *a, ///< first comparison target + const void *b ///< second comparison target +); + + +/** Compare function of psS16 data. + * + * @return int an integer less than, equal to, or greater than zero if + * the first argument is considered to be respectively less + * than, equal to, or greater than the second. + */ +int psCompareS16( + const void *a, ///< first comparison target + const void *b ///< second comparison target +); + + +/** Compare function of psS32 data. + * + * @return int an integer less than, equal to, or greater than zero if + * the first argument is considered to be respectively less + * than, equal to, or greater than the second. + */ +int psCompareS32( + const void *a, ///< first comparison target + const void *b ///< second comparison target +); + + +/** Compare function of psS64 data. + * + * @return int an integer less than, equal to, or greater than zero if + * the first argument is considered to be respectively less + * than, equal to, or greater than the second. + */ +int psCompareS64( + const void *a, ///< first comparison target + const void *b ///< second comparison target +); + + +/** Compare function of psU8 data. + * + * @return int an integer less than, equal to, or greater than zero if + * the first argument is considered to be respectively less + * than, equal to, or greater than the second. + */ +int psCompareU8( + const void *a, ///< first comparison target + const void *b ///< second comparison target +); + + +/** Compare function of psU16 data. + * + * @return int an integer less than, equal to, or greater than zero if + * the first argument is considered to be respectively less + * than, equal to, or greater than the second. + */ +int psCompareU16( + const void *a, ///< first comparison target + const void *b ///< second comparison target +); + + +/** Compare function of psU32 data. + * + * @return int an integer less than, equal to, or greater than zero if + * the first argument is considered to be respectively less + * than, equal to, or greater than the second. + */ +int psCompareU32( + const void *a, ///< first comparison target + const void *b ///< second comparison target +); + + +/** Compare function of psU64 data. + * + * @return int an integer less than, equal to, or greater than zero if + * the first argument is considered to be respectively less + * than, equal to, or greater than the second. + */ +int psCompareU64( + const void *a, ///< first comparison target + const void *b ///< second comparison target +); + + +/** Compare function of psF32 data. + * + * @return int an integer less than, equal to, or greater than zero if + * the first argument is considered to be respectively less + * than, equal to, or greater than the second. + */ +int psCompareF32( + const void *a, ///< first comparison target + const void *b ///< second comparison target +); + + +/** Compare function of psF64 data. + * + * @return int an integer less than, equal to, or greater than zero if + * the first argument is considered to be respectively less + * than, equal to, or greater than the second. + */ +int psCompareF64( + const void *a, ///< first comparison target + const void *b ///< second comparison target +); + + +/** Compare function of psS8 data. + * + * @return int an integer less than, equal to, or greater than zero if + * the first argument is considered to be respectively greater + * than, equal to, or less than the second. + */ +int psCompareDescendingS8( + const void *a, ///< first comparison target + const void *b ///< second comparison target +); + + +/** Compare function of psS16 data. + * + * @return int an integer less than, equal to, or greater than zero if + * the first argument is considered to be respectively greater + * than, equal to, or less than the second. + */ +int psCompareDescendingS16( + const void *a, ///< first comparison target + const void *b ///< second comparison target +); + + +/** Compare function of psS32 data. + * + * @return int an integer less than, equal to, or greater than zero if + * the first argument is considered to be respectively greater + * than, equal to, or less than the second. + */ +int psCompareDescendingS32( + const void *a, ///< first comparison target + const void *b ///< second comparison target +); + + +/** Compare function of psS64 data. + * + * @return int an integer less than, equal to, or greater than zero if + * the first argument is considered to be respectively greater + * than, equal to, or less than the second. + */ +int psCompareDescendingS64( + const void *a, ///< first comparison target + const void *b ///< second comparison target +); + + +/** Compare function of psU8 data. + * + * @return int an integer less than, equal to, or greater than zero if + * the first argument is considered to be respectively greater + * than, equal to, or less than the second. + */ +int psCompareDescendingU8( + const void *a, ///< first comparison target + const void *b ///< second comparison target +); + + +/** Compare function of psU16 data. + * + * @return int an integer less than, equal to, or greater than zero if + * the first argument is considered to be respectively greater + * than, equal to, or less than the second. + */ +int psCompareDescendingU16( + const void *a, ///< first comparison target + const void *b ///< second comparison target +); + + +/** Compare function of psU32 data. + * + * @return int an integer less than, equal to, or greater than zero if + * the first argument is considered to be respectively greater + * than, equal to, or less than the second. + */ +int psCompareDescendingU32( + const void *a, ///< first comparison target + const void *b ///< second comparison target +); + + +/** Compare function of psU64 data. + * + * @return int an integer less than, equal to, or greater than zero if + * the first argument is considered to be respectively greater + * than, equal to, or less than the second. + */ +int psCompareDescendingU64( + const void *a, ///< first comparison target + const void *b ///< second comparison target +); + + +/** Compare function of psF32 data. + * + * @return int an integer less than, equal to, or greater than zero if + * the first argument is considered to be respectively greater + * than, equal to, or less than the second. + */ +int psCompareDescendingF32( + const void *a, ///< first comparison target + const void *b ///< second comparison target +); + + +/** Compare function of psF64 data. + * + * @return int an integer less than, equal to, or greater than zero if + * the first argument is considered to be respectively greater + * than, equal to, or less than the second. + */ +int psCompareDescendingF64( + const void *a, ///< first comparison target + const void *b ///< second comparison target +); + + +/// @} + +#endif Index: /tags/rel2_1/psLib/src/math/psMatrix.c =================================================================== --- /tags/rel2_1/psLib/src/math/psMatrix.c (revision 1553) +++ /tags/rel2_1/psLib/src/math/psMatrix.c (revision 1553) @@ -0,0 +1,582 @@ + +/** @file psMatrix.c + * + * @brief Provides functions for linear algebra operations on psImages and psVectors. + * + * Functions are provided to: + * Transpose a psImage + * Compute LUD + * Solve LUD + * Matrix inversion + * Calculate determinant + * Matrix addition + * Matrix subtraction + * Matrix multiplication + * Calculate Eigenvectors + * Convert matrix to vector + * Convert vector to matrix + * + * These functions treat psImages as if they were matrices, therefore there is no psMatrix. + * + * @author Ross Harman, MHPCC + * + * @version $Revision: 1.12 $ $Name: not supported by cvs2svn $ + * @date $Date: 2004-08-09 23:34:57 $ + * + * Copyright 2004 Maui High Performance Computing Center, University of Hawaii + */ + +/******************************************************************************/ + +/* INCLUDE FILES */ + +/******************************************************************************/ +#include +#include +#include +#include +#include + +#include "psMemory.h" +#include "psError.h" +#include "psImage.h" +#include "psVector.h" +#include "psMatrix.h" + +/******************************************************************************/ + +/* DEFINE STATEMENTS */ + +/******************************************************************************/ + +// None + +/******************************************************************************/ + +/* TYPE DEFINITIONS */ + +/******************************************************************************/ + +// None + +/*****************************************************************************/ + +/* GLOBAL VARIABLES */ + +/*****************************************************************************/ + +// None + +/*****************************************************************************/ + +/* FILE STATIC VARIABLES */ + +/*****************************************************************************/ + +// None + +/*****************************************************************************/ + +/* FUNCTION IMPLEMENTATION - LOCAL */ + +/*****************************************************************************/ + +/** Preprocessor macro to generate error a NULL image */ +#define PS_CHECK_NULL_VECTOR(NAME, RETURN) \ +if (NAME == NULL || NAME->data.V == NULL) { \ + psError(__func__,"Invalid operation: %s or its data is NULL.", #NAME); \ + return RETURN; \ +} + +/** Preprocessor macro to create vector based on another */ +#define PS_CHECK_ALLOC_VECTOR(NAME, SIZE, PS_TYPE) \ +if(NAME == NULL) { \ + NAME = psVectorAlloc(SIZE, PS_TYPE); \ +} + +/** Preprocessor macro to generate error for zero length vector */ +#define PS_CHECK_SIZE_VECTOR(NAME, RETURN) \ +if (NAME->n < 1) { \ + psError(__func__,"Invalid operation: %s has zero n value.", #NAME); \ + return RETURN; \ +} + +/** Preprocessor macro to generate error a NULL image */ +#define PS_CHECK_NULL_IMAGE(NAME, RETURN) \ +if (NAME == NULL || NAME->data.V == NULL) { \ + psError(__func__,"Invalid operation: %s or its data is NULL.", #NAME); \ + return RETURN; \ +} + +/** Preprocessor macro to create image based on another */ +#define PS_CHECK_ALLOC_IMAGE(NAME, NCOLS, NROWS, PS_TYPE) \ +if(NAME == NULL) { \ + NAME = psImageAlloc(NCOLS, NROWS, PS_TYPE); \ +} + +/** Preprocessor macro to generate error for zero length rows or columns */ +#define PS_CHECK_SIZE_IMAGE(NAME, RETURN) \ +if (NAME->numCols < 1 || NAME->numRows < 1) { \ + psError(__func__,"Invalid operation: %s has zero rows or columns (%dx%d).", #NAME, \ + NAME->numCols, NAME->numRows); \ + return RETURN; \ +} + +/** Preprocessor macro to generate error for image dimensionality not set to PS_DIMEN_IMAGE */ +#define PS_CHECK_DIMEN_AND_TYPE(NAME, PS_DIMEN, RETURN) \ +if (NAME->type.dimen != PS_DIMEN) { \ + psError(__func__,"Invalid operation: %s incorrect dimensionality %d.", #NAME, PS_DIMEN); \ + return RETURN; \ +} else if(NAME->type.type != PS_TYPE_F64) { \ + psError(__func__, "Invalid operation: %s not PS_TYPE_F64.", #NAME); \ + return RETURN; \ +} + +/** Preprocessor macro to check that input is not equal to output */ +#define PS_CHECK_POINTERS(NAME1, NAME2, RETURN) \ +if (NAME1 == NAME2) { \ + psError(__func__,"Invalid operation: Pointer to %s is same as %s.", #NAME1, #NAME2); \ + return RETURN; \ +} + +/** Preprocessor macro to check that an image is square */ +#define PS_CHECK_SQUARE(NAME, RETURN) \ +if (NAME->numCols != NAME->numRows) { \ + psError(__func__,"Invalid operation: %s not square array.", #NAME); \ + return RETURN; \ +} + +/** Preprocessor macro to initalize a GSL matrix. */ +#define PS_GSL_MATRIX_INITIALIZE(LHS_NAME, RHS_NAME) \ +LHS_NAME.size1 = numRows; \ +LHS_NAME.size2 = numCols; \ +LHS_NAME.tda = numCols; \ +LHS_NAME.data = RHS_NAME; + +/*****************************************************************************/ + +/* FUNCTION IMPLEMENTATION - PUBLIC */ + +/*****************************************************************************/ + +psImage* psMatrixLUD(psImage* outImage, psVector* outPerm, psImage* inImage) +{ + int signum = 0; + int arraySize = 0; + int numRows = 0; + int numCols = 0; + gsl_matrix lu; + gsl_permutation perm; + + // Error checks + PS_CHECK_POINTERS(inImage, outImage, outImage); + PS_CHECK_NULL_IMAGE(inImage, outImage); + PS_CHECK_DIMEN_AND_TYPE(inImage, PS_DIMEN_IMAGE, outImage); + PS_CHECK_SIZE_IMAGE(inImage, outImage); + PS_CHECK_ALLOC_IMAGE(outImage, inImage->numCols, inImage->numRows, inImage->type.type); + PS_CHECK_DIMEN_AND_TYPE(outImage, PS_DIMEN_IMAGE, outImage); + PS_CHECK_SIZE_IMAGE(outImage, outImage); + PS_CHECK_ALLOC_VECTOR(outPerm, inImage->numRows, inImage->type.type); + PS_CHECK_NULL_VECTOR(outPerm, outImage); + PS_CHECK_DIMEN_AND_TYPE(outPerm, PS_DIMEN_VECTOR, outImage); + + // Initialize data + numRows = inImage->numRows; + numCols = inImage->numCols; + arraySize = PSELEMTYPE_SIZEOF(inImage->type.type) * numRows * numCols; + + // Initialize GSL data + perm.size = numCols; + outPerm->n = numCols; + perm.data = outPerm->data.V; + PS_GSL_MATRIX_INITIALIZE(lu, outImage->data.V[0]); + + // Non-square matrices not allowed + PS_CHECK_SQUARE(inImage, outImage); + PS_CHECK_SQUARE(outImage, outImage); + + // Copy psImage input data into GSL matrix data to keep input data pristine + memcpy(lu.data, inImage->data.V[0], arraySize); + + // Calculate LU decomposition + gsl_linalg_LU_decomp(&lu, &perm, &signum); + + return outImage; +} + +psVector* psMatrixLUSolve(psVector* outVector, const psImage* inImage, const psVector* inVector, const + psVector* inPerm) +{ + int arraySize = 0; + int numRows = 0; + int numCols = 0; + gsl_matrix lu; + gsl_permutation perm; + gsl_vector b; + gsl_vector x; + + // Error checks + PS_CHECK_POINTERS(outVector, inVector, outVector); + PS_CHECK_POINTERS(inVector, inPerm, outVector); + PS_CHECK_POINTERS(outVector, inPerm, outVector); + PS_CHECK_NULL_IMAGE(inImage, outVector); + PS_CHECK_DIMEN_AND_TYPE(inImage, PS_DIMEN_IMAGE, outVector); + PS_CHECK_SIZE_IMAGE(inImage, outVector); + PS_CHECK_ALLOC_VECTOR(outVector, inImage->numRows, inImage->type.type); + PS_CHECK_NULL_VECTOR(outVector, outVector); + PS_CHECK_DIMEN_AND_TYPE(outVector, PS_DIMEN_VECTOR, outVector); + PS_CHECK_NULL_VECTOR(inVector, outVector); + PS_CHECK_DIMEN_AND_TYPE(inVector, PS_DIMEN_VECTOR, outVector); + PS_CHECK_NULL_VECTOR(inPerm, outVector); + PS_CHECK_DIMEN_AND_TYPE(inPerm, PS_DIMEN_VECTOR, outVector); + + // Initialize data + numRows = inImage->numRows; + numCols = inImage->numCols; + arraySize = PSELEMTYPE_SIZEOF(inImage->type.type) * numRows * numCols; + + // Initialize GSL data + PS_GSL_MATRIX_INITIALIZE(lu, inImage->data.V[0]); + + outVector->n = numCols; + + perm.size = inPerm->n; + perm.data = inPerm->data.V; + + b.size = inVector->n; + b.stride = 1; + b.data = inVector->data.V; + + x.size = numCols; + x.stride = 1; + x.data = outVector->data.V; + + // Solve for {x} in equation: {b} = [A]{x} + gsl_linalg_LU_solve(&lu, &perm, &b, &x); + + return outVector; +} + +psImage* psMatrixInvert(psImage* outImage, const psImage* inImage, float *restrict det) +{ + int signum = 0; + int arraySize = 0; + int numRows = 0; + int numCols = 0; + gsl_matrix inv; + gsl_matrix *lu; + gsl_permutation *perm = NULL; + + // Error checks + if (det == NULL) { + psError(__func__, "Invalid operation: determinant argument is NULL."); + return outImage; + } + PS_CHECK_POINTERS(inImage, outImage, outImage); + PS_CHECK_NULL_IMAGE(inImage, outImage); + PS_CHECK_DIMEN_AND_TYPE(inImage, PS_DIMEN_IMAGE, outImage); + PS_CHECK_SIZE_IMAGE(inImage, outImage); + PS_CHECK_ALLOC_IMAGE(outImage, inImage->numCols, inImage->numRows, inImage->type.type); + PS_CHECK_DIMEN_AND_TYPE(outImage, PS_DIMEN_IMAGE, outImage); + PS_CHECK_SIZE_IMAGE(outImage, outImage); + + // Initialize data + numRows = inImage->numRows; + numCols = inImage->numCols; + arraySize = PSELEMTYPE_SIZEOF(inImage->type.type) * numRows * numCols; + + // Allocate GSL structs + perm = gsl_permutation_alloc(inImage->numRows); + lu = gsl_matrix_alloc(numRows, numCols); + + // Initialize GSL data + PS_GSL_MATRIX_INITIALIZE(inv, outImage->data.V[0]); + + // Non-square matrices not allowed + PS_CHECK_SQUARE(inImage, outImage); + PS_CHECK_SQUARE(outImage, outImage); + + // Copy psImage input data into GSL matrix data to keep input data pristine + memcpy(lu->data, inImage->data.V[0], arraySize); + + // Invert data and calculate determinant + gsl_linalg_LU_decomp(lu, perm, &signum); + gsl_linalg_LU_invert(lu, perm, &inv); + *det = (float)gsl_linalg_LU_det(lu, signum); + + // Free GSL structs + gsl_permutation_free(perm); + gsl_matrix_free(lu); + + return outImage; +} + +float *psMatrixDeterminant(const psImage* restrict inImage) +{ + int signum = 0; + int arraySize = 0; + int numRows = 0; + int numCols = 0; + float *det = NULL; + gsl_matrix *lu = NULL; + gsl_permutation *perm = NULL; + + // Error checks + PS_CHECK_NULL_IMAGE(inImage, NULL); + PS_CHECK_DIMEN_AND_TYPE(inImage, PS_DIMEN_IMAGE, NULL); + PS_CHECK_SIZE_IMAGE(inImage, NULL); + + // Initialize data + numRows = inImage->numRows; + numCols = inImage->numCols; + arraySize = PSELEMTYPE_SIZEOF(inImage->type.type) * numRows * numCols; + + // Allocate GSL structs + perm = gsl_permutation_alloc(numRows); + lu = gsl_matrix_alloc(numRows, numCols); + + // Non-square matrices not allowed + PS_CHECK_SQUARE(inImage, 0); + + // Copy psImage input data into GSL matrix data to keep input data pristine + memcpy(lu->data, inImage->data.V[0], arraySize); + + // Calculate determinant + det = (float *)psAlloc(sizeof(float)); + gsl_linalg_LU_decomp(lu, perm, &signum); + *det = (float)gsl_linalg_LU_det(lu, signum); + + // Free GSL structs + gsl_permutation_free(perm); + gsl_matrix_free(lu); + + return det; +} + +psImage* psMatrixMultiply(psImage* outImage, psImage* inImage1, psImage* inImage2) +{ + int arraySize = 0; + int numRows = 0; + int numCols = 0; + gsl_matrix m1; + gsl_matrix m2; + gsl_matrix m3; + + // Error checks + PS_CHECK_POINTERS(inImage1, outImage, outImage); + PS_CHECK_POINTERS(inImage1, inImage2, outImage); + PS_CHECK_NULL_IMAGE(inImage1, outImage); + PS_CHECK_DIMEN_AND_TYPE(inImage1, PS_DIMEN_IMAGE, outImage); + PS_CHECK_SIZE_IMAGE(inImage1, outImage); + PS_CHECK_NULL_IMAGE(inImage2, outImage); + PS_CHECK_DIMEN_AND_TYPE(inImage2, PS_DIMEN_IMAGE, outImage); + PS_CHECK_SIZE_IMAGE(inImage2, outImage); + PS_CHECK_ALLOC_IMAGE(outImage, inImage2->numCols, inImage2->numRows, inImage2->type.type); + PS_CHECK_DIMEN_AND_TYPE(inImage1, PS_DIMEN_IMAGE, outImage); + PS_CHECK_SIZE_IMAGE(outImage, outImage); + + // Initialize data + numRows = inImage1->numRows; + numCols = inImage1->numCols; + arraySize = PSELEMTYPE_SIZEOF(outImage->type.type) * numRows * numCols; + + // Initialize GSL data + PS_GSL_MATRIX_INITIALIZE(m1, inImage1->data.V[0]); + PS_GSL_MATRIX_INITIALIZE(m2, inImage2->data.V[0]); + PS_GSL_MATRIX_INITIALIZE(m3, outImage->data.V[0]); + + // Non-square matrices not allowed + PS_CHECK_SQUARE(inImage1, outImage); + PS_CHECK_SQUARE(inImage2, outImage); + PS_CHECK_SQUARE(outImage, outImage); + + gsl_linalg_matmult(&m1, &m2, &m3); + + return outImage; +} + +psImage* psMatrixTranspose(psImage* outImage, const psImage* inImage) +{ + int arraySize = 0; + int numRows = 0; + int numCols = 0; + gsl_matrix trans; + + // Error checks + PS_CHECK_POINTERS(inImage, outImage, outImage); + PS_CHECK_NULL_IMAGE(inImage, outImage); + PS_CHECK_DIMEN_AND_TYPE(inImage, PS_DIMEN_IMAGE, outImage); + PS_CHECK_SIZE_IMAGE(inImage, outImage); + PS_CHECK_ALLOC_IMAGE(outImage, inImage->numCols, inImage->numRows, inImage->type.type); + PS_CHECK_DIMEN_AND_TYPE(outImage, PS_DIMEN_IMAGE, outImage); + PS_CHECK_SIZE_IMAGE(outImage, outImage); + + // Initialize data + numRows = inImage->numRows; + numCols = inImage->numCols; + arraySize = PSELEMTYPE_SIZEOF(inImage->type.type) * numRows * numCols; + + // Initialize GSL data + PS_GSL_MATRIX_INITIALIZE(trans, outImage->data.V[0]); + + // Non-square matrices not allowed + PS_CHECK_SQUARE(inImage, outImage); + PS_CHECK_SQUARE(outImage, outImage); + + // Copy psImage input data into psImage output data to keep input data pristine + memcpy(outImage->data.V[0], inImage->data.V[0], arraySize); + + // Transpose data + gsl_matrix_transpose(&trans); + + return outImage; +} + +psImage* psMatrixEigenvectors(psImage* outImage, psImage* inImage) +{ + int numRows = 0; + int numCols = 0; + gsl_vector *eVals = NULL; + gsl_eigen_symmv_workspace *w = NULL; + gsl_matrix out; + gsl_matrix in; + + // Error checks + PS_CHECK_POINTERS(inImage, outImage, outImage); + PS_CHECK_NULL_IMAGE(inImage, outImage); + PS_CHECK_DIMEN_AND_TYPE(inImage, PS_DIMEN_IMAGE, outImage); + PS_CHECK_SIZE_IMAGE(inImage, outImage); + PS_CHECK_ALLOC_IMAGE(outImage, inImage->numCols, inImage->numRows, inImage->type.type); + PS_CHECK_DIMEN_AND_TYPE(outImage, PS_DIMEN_IMAGE, outImage); + PS_CHECK_SIZE_IMAGE(outImage, outImage); + + // Initialize data + numRows = inImage->numRows; + numCols = inImage->numCols; + + // Initialize GSL data + PS_GSL_MATRIX_INITIALIZE(in, inImage->data.V[0]); + PS_GSL_MATRIX_INITIALIZE(out, outImage->data.V[0]); + + // Allocate GSL structs + eVals = gsl_vector_alloc(numRows); + w = gsl_eigen_symmv_alloc(numRows); + + // Non-square matrices not allowed + PS_CHECK_SQUARE(inImage, outImage); + PS_CHECK_SQUARE(outImage, outImage); + + // Calculate Eigenvalues and Eigenvectors...Eigenvalues not currently used + gsl_eigen_symmv(&in, eVals, &out, w); + + // Free GSL structs + gsl_eigen_symmv_free(w); + gsl_vector_free(eVals); + + return outImage; +} + +psVector* psMatrixToVector(psVector* outVector, psImage* inImage) +{ + int size = 0; + + // Error checks + PS_CHECK_NULL_IMAGE(inImage, outVector); + PS_CHECK_DIMEN_AND_TYPE(inImage, PS_DIMEN_IMAGE, outVector); + PS_CHECK_SIZE_IMAGE(inImage, outVector); + + if (inImage->numRows == 1) { + // Create transposed row vector + PS_CHECK_ALLOC_VECTOR(outVector, inImage->numCols, inImage->type.type); + outVector->type.dimen = PS_DIMEN_TRANSV; + } else if (inImage->numCols == 1) { + // Create non-transposed column vector + PS_CHECK_ALLOC_VECTOR(outVector, inImage->numRows, inImage->type.type); + } else { + psError(__func__, "Image does not have dim with 1 col or 1 row: (%d x %d).", inImage->numRows, + inImage->numCols); + return outVector; + } + + PS_CHECK_NULL_VECTOR(outVector, outVector); + + // More checks + if (outVector->type.dimen == PS_DIMEN_VECTOR) { + PS_CHECK_DIMEN_AND_TYPE(outVector, PS_DIMEN_VECTOR, outVector); + + if (outVector->n == 0) { + outVector->n = inImage->numRows; + } + + if (outVector->n != inImage->numRows) { + psError(__func__, "Image and vector sizes differ: (%d vs %d).", inImage->numRows, outVector->n); + return outVector; + } + + size = PSELEMTYPE_SIZEOF(inImage->type.type) * inImage->numRows; + + } else if (outVector->type.dimen == PS_DIMEN_TRANSV) { + PS_CHECK_DIMEN_AND_TYPE(outVector, PS_DIMEN_TRANSV, outVector); + + if (outVector->n == 0) { + outVector->n = inImage->numCols; + } + + if (outVector->n != inImage->numCols) { + psError(__func__, "Image and vector sizes differ: (%d vs %d).", inImage->numCols, outVector->n); + return outVector; + } + + size = PSELEMTYPE_SIZEOF(inImage->type.type) * inImage->numCols; + } + + memcpy(outVector->data.V, inImage->data.V[0], size); + + return outVector; +} + +psImage* psVectorToMatrix(psImage* outImage, psVector* inVector) +{ + int size = 0; + + // Error checks + PS_CHECK_NULL_VECTOR(inVector, outImage); + + if (inVector->type.dimen == PS_DIMEN_VECTOR) { + PS_CHECK_DIMEN_AND_TYPE(inVector, PS_DIMEN_VECTOR, outImage); + PS_CHECK_SIZE_VECTOR(inVector, outImage); + PS_CHECK_ALLOC_IMAGE(outImage, 1, inVector->n, PS_TYPE_F64) + // More checks for PS_DIMEN_VECTOR + if (outImage->numCols > 1) { + psError(__func__, "Image has more than 1 column: numCols = %d.", outImage->numCols); + return outImage; + } else if (outImage->numRows != inVector->n) { + psError(__func__, "Image and vector sizes differ: (%d vs %d).", outImage->numRows, inVector->n); + return outImage; + } + + size = PSELEMTYPE_SIZEOF(outImage->type.type) * outImage->numRows; + + } else if (inVector->type.dimen == PS_DIMEN_TRANSV) { + PS_CHECK_DIMEN_AND_TYPE(inVector, PS_DIMEN_TRANSV, outImage); + PS_CHECK_SIZE_VECTOR(inVector, outImage); + PS_CHECK_ALLOC_IMAGE(outImage, inVector->n, 1, PS_TYPE_F64) + // More checks for PS_DIMEN_TRANSV + if (outImage->numRows > 1) { + psError(__func__, "Image has more than 1 row: numRows = %d.", outImage->numRows); + return outImage; + } else if (outImage->numCols != inVector->n) { + psError(__func__, "Image and vector sizes differ: (%d vs %d).", outImage->numCols, inVector->n); + return outImage; + } + + size = PSELEMTYPE_SIZEOF(outImage->type.type) * outImage->numCols; + } + + PS_CHECK_NULL_IMAGE(outImage, outImage); + PS_CHECK_DIMEN_AND_TYPE(outImage, PS_DIMEN_IMAGE, outImage); + + memcpy(outImage->data.V[0], inVector->data.V, size); + + return outImage; +} Index: /tags/rel2_1/psLib/src/math/psMatrix.h =================================================================== --- /tags/rel2_1/psLib/src/math/psMatrix.h (revision 1553) +++ /tags/rel2_1/psLib/src/math/psMatrix.h (revision 1553) @@ -0,0 +1,166 @@ + +/** @file psMatrix.h + * + * @brief Provides functions for linear algebra operations on psImages and psVectors. + * + * Functions are provided to: + * Transpose a psImage + * Compute LUD + * Solve LUD + * Matrix inversion + * Calculate determinant + * Matrix multiplication + * Calculate Eigenvectors + * Convert matrix to vector + * Convert vector to matrix + * + * These functions treat psImages as if they were matrices, therefore there is no psMatrix. These functions + * operate only with the psF64 data type. + * + * @ingroup Matrix + * + * @author Ross Harman, MHPCC + * + * @version $Revision: 1.11 $ $Name: not supported by cvs2svn $ + * @date $Date: 2004-08-11 02:35:58 $ + * + * Copyright 2004 Maui High Performance Computing Center, University of Hawaii + */ + +#ifndef PSMATRIX_H +#define PSMATRIX_H + +/// @addtogroup Matrix +/// @{ + +/** LU Decomposition of psImage matrix. + * + * Performs a LU decomposition on a psImage matrix and returns the LU matrix. If the user specifies NULL for + * the outImage or outPerm arguments, then they will be automatically created. The input image must + * be square. This function operates only with the psF64 data type. Input and output arguments should not be + * the same. GSL indexes the top row as the zero row, not the bottom. + * + * @return psImage* : Pointer to LU decomposed psImage. + */ +psImage* psMatrixLUD( + psImage* outImage, ///< Image to return, or NULL. + psVector* outPerm, ///< Output permutation vector used by psMatrixLUSolve. + psImage* inImage ///< Image to decompose. +); + +/** LU Solution of psImage matrix. + * + * Solves for and returns the psVector, {x} in the equation [A]{x} = {b}. If the user specifies NULL as the + * outVector argument, then it will automatically be created. The input image must be square. This function + * operates only with the psF64 data type. Input and output arguments should not be the same. GSL indexes + * the top row as the zero row, not the bottom. + * + * @return psVector* : Pointer to psVector solution of matrix equation. + */ +psVector* psMatrixLUSolve( + psVector* outVector, ///< Vector to return, or NULL. + const psImage* luImage, ///< LU-decomposed matrix. + const psVector* inVector, ///< Vector right-hand-side of equation. + const psVector* inPerm ///< Permutation vector resulting from psMatrixLUD function. +); + +/** Invert psImage matrix. + * + * Inverts a psImage matrix and returns the determinant as an option through the argument list. If the user + * specifies NULL as the outImage argument, then it will automatically be created. The input image must be + * square. This function operates only with the psF64 data type. Input and output arguments should not be + * the same. GSL indexes the top row as the zero row, not the bottom. + * + * @return psImage* : Pointer to inverted psImage. + */ +psImage* psMatrixInvert( + psImage* outImage, ///< Image to return, or NULL for in-place substitution. + const psImage* inImage, ///< Image to be inverted + float *restrict det ///< Determinant to return, or NULL +); + +/** Calculate psImage matrix determinant. + * + * Calculates the determinant of a psImage matrix and returns the single precision floating point result. The + * input image must be square. This function operates only with the psF64 data type. GSL indexes the top row + * as the zero row, not the bottom. + * + * @return float: Determinant from psImage. + */ +float *psMatrixDeterminant( + const psImage* restrict inMatrix ///< Image used to calculate determinant. +); + +/** Performs psImage matrix multiplication. + * + * Performs a classical matrix multiplication involving row and column operations. Input images must be square + * and the same size. If the user specifies NULL as the outImage argument, then it will automatically be + * created. This function operates only with the psF64 data type. GSL indexes the top row as the + * zero row, not the bottom. + * + * @return psImage* : Pointer to resulting psImage. + */ +psImage* psMatrixMultiply( + psImage* outImage, ///< Matrix to return, or NULL. + psImage* inImage1, ///< First input image. + psImage* inImage2 ///< Second input image. +); + +/** Transpose matrix. + * + * Performs psImage matrix transpose by substituting existing rows for columns. The input image must be + * square. If the user specifies NULL as the outImage argument, then it will automaticallty be created. + * This function operates only with the psF64 data type. GSL indexes the top row as the zero + * row, not the bottom. + * + * @return psImage* : Pointer to transposed psImage. + */ +psImage* psMatrixTranspose( + psImage* outImage, ///< Image to return, or NULL + const psImage* inImage ///< Image to transpose +); + +/** Calculate matrix eigenvectors. + * + * Calculates the eigenvectors for a matrix. The input image must be symmetric and square. If the user + * specifies NULL as the outImage argument, then it will automatically be created. This function operates + * only with the psF64 data type. GSL indexes the top row as the zero row, not the bottom. + * + * @return psImage* : Pointer to matrix of Eigenvectors. + */ +psImage* psMatrixEigenvectors( + psImage* outImage, ///< Eigenvectors to return, or NULL. + psImage* inImage ///< Input image. +); + +/** Convert matrix to vector. + * + * Converts a 1-d psImage matrix into a vector. If the user specifies NULL as the outVector argument, then it + * will automatically be created based on the input image (PS_DIMEN_VECTOR for an input image with 1 col or + * PS_DIMENT_TRANSV for an input image with 1 row). Either the number of rows or the number of colums of the + * input matrix must be 1. This function operates only with the psF64 data type. + * + * @return psVector* : Pointer to psVector. + */ +psVector* psMatrixToVector( + psVector* outVector, ///< Vector to return, or NULL. + psImage* inImage ///< Image to convert. +); + +/** Convert vector to matrix. + * + * Converts a vector into a psImage matrix. If the dimensionality of the vector is PS_DIMEN_VECTOR, then the + * resulting psImage is a 1d column. If the dimensionality of the vector is PS_DIMEN_TRANSV, then the + * resulting psImage is a 1d row. If the user specifies NULL as the outImage argument, then it will + * automatically be created. This function operates only with the psF64 data type. + * + * @return psVector* : Pointer to psIamge. + */ +psImage* psVectorToMatrix( + psImage* outImage, ///< Matrix to return, or NULL. + psVector* inVector ///< Vector to convert. +); + +/// @} + +#endif Index: /tags/rel2_1/psLib/src/math/psMinimize.c =================================================================== --- /tags/rel2_1/psLib/src/math/psMinimize.c (revision 1553) +++ /tags/rel2_1/psLib/src/math/psMinimize.c (revision 1553) @@ -0,0 +1,940 @@ + +/** @file psMinimize.c + * \brief basic minimization functions + * @ingroup Math + * + * This file will contain functions to minimize an arbitrary function at + * a data point, fit an arbitrary function to a set of data points, and + * fit a 1-D polynomial to a set of data points. + * + * @author George Gusciora, MHPCC + * + * @version $Revision: 1.30 $ $Name: not supported by cvs2svn $ + * @date $Date: 2004-08-11 03:17:03 $ + * + * Copyright 2004 Maui High Performance Computing Center, University of Hawaii + */ + +/*****************************************************************************/ + +/* INCLUDE FILES */ + +/*****************************************************************************/ +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include + +#include "psMemory.h" +#include "psVector.h" +#include "psImage.h" +#include "psTrace.h" +#include "psError.h" +#include "psAbort.h" +#include "psFunctions.h" +#include "psMinimize.h" +#include "psMatrix.h" + +/*****************************************************************************/ + +/* DEFINE STATEMENTS */ + +/*****************************************************************************/ +#define MAX_LMM_ITERATIONS 100 +#define MAX_MINIMIZE_ITERATIONS 100 + +/** Preprocessor macro to generate error on a NULL 1DPolynomial */ +#define PS_CHECK_NULL_1DPOLY(NAME) \ +if (NAME == NULL || NAME->coeff == NULL) { \ + psError(__func__,"Invalid operation: %s or its data is NULL.", #NAME); \ +} + +/** Preprocessor macro to generate error on a NULL vector */ +#define PS_CHECK_NULL_VECTOR(NAME) \ +if (NAME == NULL || NAME->data.V == NULL) { \ + psError(__func__,"Invalid operation: %s or its data is NULL.", #NAME); \ +} + +/** Preprocessor macro to generate error for zero length vector */ +#define PS_CHECK_EMPTY_VECTOR(NAME) \ +if (NAME->n < 1) { \ + psError(__func__,"Invalid operation: %s has zero n value.", #NAME); \ +} + +/** Preprocessor macro to generate error on differing size vectors */ +#define PS_CHECK_VECTOR_SIZE_EQUAL(VEC1, VEC2) \ +if (VEC1->n != VEC2->n) { \ + psError(__func__,"Vector %s has size %d, Vector %s has size %d.", #VEC1, VEC1->n, #VEC2, VEC2->n); \ +} + +/** Preprocessor macro to generate error on a NULL image */ +#define PS_CHECK_NULL_IMAGE(NAME) \ +if (NAME == NULL || NAME->data.V == NULL) { \ + psError(__func__,"Invalid operation: %s or its data is NULL.", #NAME); \ +} + +/** Preprocessor macro to generate error for zero length rows or columns */ +#define PS_CHECK_EMPTY_IMAGE(NAME) \ +if (NAME->numCols < 1 || NAME->numRows < 1) { \ + psError(__func__,"Invalid operation: %s has zero rows or columns (%dx%d).", #NAME, \ + NAME->numCols, NAME->numRows); \ +} + +/*****************************************************************************/ + +/* TYPE DEFINITIONS */ + +/*****************************************************************************/ +typedef struct +{ + size_t n; // Number of data points points in domain. + int paramCount; // Number of non-masked parameters. + psVector* restrict initialGuess; + const psImage* restrict domain; + const psVector* restrict data; + const psVector* restrict errors; + const psVector* restrict paramMask; + psMinimizeFunction evalModel; + psMinimizeFunctionDeriv d_evalModel; +} +psMinChi2Data; + +typedef struct +{ + int paramCount; // Number of non-masked parameters. + psVector* restrict initialGuess; + const psVector* restrict coord; + const psVector* restrict paramMask; + psMinimizeFunction evalModel; + psMinimizeFunctionDeriv d_evalModel; +} +psMinimizeData; + +/*****************************************************************************/ + +/* GLOBAL VARIABLES */ + +/*****************************************************************************/ + +// None + +/*****************************************************************************/ + +/* FILE STATIC VARIABLES */ + +/*****************************************************************************/ + +// None + +/*****************************************************************************/ + +/* FUNCTION IMPLEMENTATION - LOCAL */ + +/*****************************************************************************/ + +/****************************************************************************** +p_psMinFunc(*params, *funcData): We use the GSL procedure +gsl_multimin_fdfminimizer_iterate() to minimize an arbitary function supplied +by the user. That GSL procedure requires the function to be minimized to be +in a different format than the psLib format. The purpose of this procedure +is to serve as a GSL-format wrapper for the user-supplied procedure which is +to be minimized. + + params: The parameters of the function to be minimized. These will be + varied by GSL in order to minimize the function. + + funcData: a private psLib struct which contains the data point to be + minimized, the function and derivative function pointers, an initial + guess at the parameters, an option parameter mask, etc. + *****************************************************************************/ +double p_psMinFunc(const gsl_vector * params, void *funcData) +{ + int i; // Loop index variable. + int j; // Loop index variable. + float tmpf; // Temporary floating point variable. + const psVector* restrict coord = ((psMinimizeData* ) funcData)->coord; + const psVector* restrict mask = ((psMinimizeData* ) funcData)->paramMask; + psVector* restrict initialGuess = ((psMinimizeData* ) funcData)->initialGuess; + psMinimizeFunction evalModel = ((psMinimizeData* ) funcData)->evalModel; + psVector* inputParameterList = NULL; + + // The GSL routines will call this function with the masked parameters + // removed. However, the user-supplied function (to be modified) does not + // have those parameters removed. Here will create a new parameter list + // with the masked parameters added (we expand initialGuess). + inputParameterList = psVectorAlloc(initialGuess->n, PS_TYPE_F32); + if (mask != NULL) { + j = 0; + for (i = 0; i < mask->n; i++) { + if (mask->data.U8[i] != 0) { + inputParameterList->data.F32[i] = initialGuess->data.F32[i]; + } else { + inputParameterList->data.F32[i] = gsl_vector_get(params, j++); + } + } + } else { + for (i = 0; i < initialGuess->n; i++) { + inputParameterList->data.F32[i] = gsl_vector_get(params, i); + } + } + + // Call the user-supplied function. + tmpf = evalModel(inputParameterList, coord); + + // Free allocated memory and return the value of the function. + psFree(inputParameterList); + return (tmpf); +} + +/****************************************************************************** +p_psMinFuncDeriv(*params, *funcData): a GSL-like wrapper for the +user-supplied procedure which calculates the derviative of the function to be +minimized. + + params: The parameters of the function to be minimized. These will be + varied by GSL in order to minimize the function. + + funcData: a private psLib struct which contains the data point to be + minimized, the function and derivative function pointers, an initial + guess at the parameters, an option parameter mask, etc. + + df: we calculate the derivative of the function w.r.t. to each parameter + in "params" and return those derivatives in this psVector. + *****************************************************************************/ +void p_psMinFuncDeriv(const gsl_vector * params, void *funcData, gsl_vector * df) +{ + int i; // Loop index variable. + int j; // Loop index variable. + float tmpf; // Temporary floating point variable. + const psVector* restrict coord = ((psMinimizeData* ) funcData)->coord; + const psVector* restrict mask = ((psMinimizeData* ) funcData)->paramMask; + psVector* restrict initialGuess = ((psMinimizeData* ) funcData)->initialGuess; + psMinimizeFunctionDeriv d_evalModel = ((psMinimizeData* ) funcData)->d_evalModel; + psVector* inputParameterList = NULL; + + // The GSL routines will call this function with the masked parameters + // removed. However, the user-supplied function (to be modified) does not + // have those parameters removed. Here will create a new parameter list + // with the masked parameters added (we expand initialGuess). + inputParameterList = psVectorAlloc(initialGuess->n, PS_TYPE_F32); + if (mask != NULL) { + j = 0; + for (i = 0; i < mask->n; i++) { + if (mask->data.U8[i] != 0) { + inputParameterList->data.F32[i] = initialGuess->data.F32[i]; + } else { + inputParameterList->data.F32[i] = gsl_vector_get(params, j++); + } + } + } else { + for (i = 0; i < initialGuess->n; i++) { + inputParameterList->data.F32[i] = gsl_vector_get(params, i); + } + } + + // Evaluate the derivative w.r.t. each parameter. + // NOTE: we can probably remove the calls for masked parameters. + for (i = 0; i < initialGuess->n; i++) { + tmpf = d_evalModel(inputParameterList, coord, i); + gsl_vector_set(df, i, tmpf); + } + + // Free allocated memory. + psFree(inputParameterList); +} + +/****************************************************************************** + Compute both p_psMinFunc and p_psMinFuncDeriv together. + *****************************************************************************/ +void p_psMinFuncFuncDeriv(const gsl_vector * params, void *funcData, double *f, gsl_vector * df) +{ + *f = p_psMinFunc(params, funcData); + p_psMinFuncDeriv(params, funcData, df); +} + +// The first argument to evalModel() and d_evalModel() specifies the data +// point. It must have the same size as the second dimension of *domain. +// The second argument must have the same size as *initialGuess and +// *paramMask. + +/****************************************************************************** +p_psMinChi2Func(*x, *funcData, *outdata): We use the GSL procedure +gsl_multifit_fdfsolver_iterate() to fit an arbitrary function, supplied by +the user, to a set of data points. That GSL procedure requires the function +to be fit to be in a different format than the psLib format. The purpose of +this procedure is to serve as a GSL-format wrapper for the user-supplied +procedure which is to be fit to the data. + + params: These are the parameters which are to be varied by GSL in order + to minimize chi2 over the data set. + + funcData: this data structure contains the input values over which the + function will be evaluated, the expected value of the function at + those points, the amount of error tolerable at those points, a mask + vector which specifies which parameters to the function are to be + constant, and an initial guess at the parameters. + + outData: The function is evaluated at each point, then subtract the + expected value and divide by the error. + *****************************************************************************/ +int p_psMinChi2Func(const gsl_vector * params, void *funcData, gsl_vector * outData) +{ + int i; // Loop index variable. + int j; // Loop index variable. + float tmpf; // Temporary floating point variable. + const psImage* restrict domain = ((psMinChi2Data* ) funcData)->domain; + const psVector* restrict data = ((psMinChi2Data* ) funcData)->data; + const psVector* restrict errors = ((psMinChi2Data* ) funcData)->errors; + const psVector* restrict mask = ((psMinChi2Data* ) funcData)->paramMask; + psVector* restrict initialGuess = ((psMinChi2Data* ) funcData)->initialGuess; + psMinimizeFunction evalModel = ((psMinChi2Data* ) funcData)->evalModel; + psVector* inputParameterList = NULL; + psVector* tmpVecPtr = NULL; + + tmpVecPtr = psVectorAlloc(domain->numCols, PS_TYPE_F32); + + // The GSL routines will call this function with the masked parameters + // removed. However, the user-supplied function (to be modified) does not + // have those parameters removed. Here will create a new parameter list + // with the masked parameters added (we expand initialGuess). + + inputParameterList = psVectorAlloc(initialGuess->n, PS_TYPE_F32); + if (mask != NULL) { + j = 0; + for (i = 0; i < mask->n; i++) { + if (mask->data.U8[i] != 0) { + inputParameterList->data.F32[i] = initialGuess->data.F32[i]; + } else { + inputParameterList->data.F32[i] = gsl_vector_get(params, j++); + } + } + } else { + for (i = 0; i < initialGuess->n; i++) { + inputParameterList->data.F32[i] = gsl_vector_get(params, i); + } + } + + // Evaluate the function at each data point. + for (i = 0; i < domain->numRows; i++) { + for (j = 0; j < domain->numCols; j++) { + tmpVecPtr->data.F32[j] = domain->data.F32[i][j]; + } + tmpf = evalModel(tmpVecPtr, inputParameterList); + + gsl_vector_set(outData, i, (tmpf - data->data.F32[i]) / errors->data.F32[i]); + } + + // Free allocated memory. + psFree(inputParameterList); + psFree(tmpVecPtr); + + return GSL_SUCCESS; +} + +/****************************************************************************** +p_psMinChi2FuncDeriv(*x, *funcData, *outdata): a GSL-like wrapper for the +user-supplied procedure which calculates the derviative of the function to be +minimized. + params: These are the parameters which are to be varied by GSL in order + to minimize chi2 over the data set. + + funcData: this data structure contains the input values over which the + function will be evaluated, the expected value of the function at + those points, the amount of error tolerable at those points, a mask + vector which specifies which parameters to the function are to be + constant, and an initial guess at the parameters. + + J: The derivative is evaluated at each point and w.r.t. each parameter + and returned in this data structure. + *****************************************************************************/ +int p_psMinChi2FuncDeriv(const gsl_vector * params, void *funcData, gsl_matrix * J) +{ + const psImage* restrict domain = ((psMinChi2Data* ) funcData)->domain; + const psVector* restrict errors = ((psMinChi2Data* ) funcData)->errors; + const psVector* restrict mask = ((psMinChi2Data* ) funcData)->paramMask; + psVector* restrict initialGuess = ((psMinChi2Data* ) funcData)->initialGuess; + psVector* inputParameterList = NULL; + psVector* tmpVecPtr = NULL; + psMinimizeFunctionDeriv d_evalModel = ((psMinChi2Data* ) funcData)->d_evalModel; + + size_t i; + int j; + float tmpf; + + tmpVecPtr = psVectorAlloc(domain->numCols, PS_TYPE_F32); + + // The GSL routines will call this functions with the masked parameters + // removed. However, the user-supplied function (to be modified) does not + // have those parameters removed. Here will create a new parameter list + // with the masked parameters added (we expand initialGuess). + + inputParameterList = psVectorAlloc(initialGuess->n, PS_TYPE_F32); + if (mask != NULL) { + j = 0; + for (i = 0; i < mask->n; i++) { + if (mask->data.U8[i] != 0) { + inputParameterList->data.F32[i] = initialGuess->data.F32[i]; + } else { + inputParameterList->data.F32[i] = gsl_vector_get(params, j++); + } + } + } else { + for (i = 0; i < initialGuess->n; i++) { + inputParameterList->data.F32[i] = gsl_vector_get(params, i); + } + } + + // Evaluate the derivtaive at each data point, and w.r.t. each parameter. + for (i = 0; i < domain->numRows; i++) { + for (j = 0; j < tmpVecPtr->n; j++) { + tmpVecPtr->data.F32[j] = domain->data.F32[i][j]; + } + + for (j = 0; j < inputParameterList->n; j++) { + tmpf = d_evalModel(tmpVecPtr, inputParameterList, j); + gsl_matrix_set(J, i, j, (tmpf / errors->data.F32[i])); + } + } + + psFree(inputParameterList); + psFree(tmpVecPtr); + return GSL_SUCCESS; +} + +int p_psMinChi2FuncFuncDeriv(const gsl_vector * params, void *funcData, gsl_vector * f, gsl_matrix * J) +{ + p_psMinChi2Func(params, funcData, f); + p_psMinChi2FuncDeriv(params, funcData, J); + + return GSL_SUCCESS; +} + +/****************************************************************************** +p_psBuildSums1D(x, polyOrder, sums): this routine calculates the powers of +input parameter "x" between 0 and input parameter polyOrder. The result is +returned as a psVector sums. + *****************************************************************************/ +void p_psBuildSums1D(double x, int polyOrder, psVector* sums) +{ + int i = 0; + double xSum = 0.0; + + xSum = 1.0; + for (i = 0; i <= polyOrder; i++) { + sums->data.F64[i] = xSum; + xSum *= x; + } +} + +/****************************************************************************** +p_psBuildSums1D(x): this routine returns a psVector with "x" elements. The +values of the vector will be scaled uniformly between -1.0 and 1.0. + *****************************************************************************/ +psVector* psBuildImageScalingFactors(int x) +{ + int i = 0; // loop index variable. + psVector* imageScalingFactors = NULL; + + imageScalingFactors = psVectorAlloc(x, PS_TYPE_F32); + + for (i = 0; i < x; i++) { + imageScalingFactors->data.F32[i] = (((float)2 * i) / ((float)x)) - 1.0; + } + + return (imageScalingFactors); +} + +/****************************************************************************** +CURRENTLY NOT IN USE. + +p_psPolyOrderCheck(A, N, *indx, *B, polyOrder,*flag) This routine checks if +all polyOrder-th terms in the polyOrder-th order sky background polynomial +defined by the coefficients in the array B[] are consistent with zero. If +true, then *flag is set to 1. Otherwise, *flag is set to 0. The matrix +inversion code in the middle of this procedure draws from Numerical Recipes +in C page 48. +Input: + A This is the LUD decomposition of the original matrix A. + N The size of the matrix (plus 1, actually, since offset 1). + indx misc Numerical Recipes data structure. + B The coefficients of the sky polynomial. + polyOrder The degree of the sky polynomial. +Output: + *flag Set this to 1 if we must recalculate the coefficients. + *****************************************************************************/ +void p_psPolyOrderCheck(float **A, int N, int *indx, float *B, int polyOrder, int *flag) +{ + float **y = NULL; // This 2-D matrix will hold A^-1 + float *col = NULL; // misc NumerRecipes data structure + float *error = NULL; // will hold the sqrt() of the + + // diagonal of y[][]. + int i = 0; // loop-index variable + int j = 0; // loop-index variable + int numPolyTerms = 0; // The number of terms in the + + // polynomial. + int lastTerm = 0; // The index location of the first + + // n-th order term in array B[]. + int firstTerm = 0; // Index location of last such term. + + // Allocate the necessary data structures for this procedure... + error = (float *)psAlloc((N + 1) * sizeof(float)); + col = (float *)psAlloc((N + 1) * sizeof(float)); + y = (float **)psAlloc((N + 1) * sizeof(float *)); + for (i = 1; i <= N; i++) { + y[i] = (float *)psAlloc((N + 1) * sizeof(float)); + } + + // Invert the matrix A and put the result in y[][]. This code is taken + // from Numerical Recipes in C page 48. + for (j = 1; j <= N; j++) { + for (i = 1; i <= N; i++) { + col[i] = 0.0; + } + col[j] = 1.0; + // NOTE: substitue the LUD rotine + // lubksb(A, N, indx, col); + for (i = 1; i <= N; i++) { + y[i][j] = col[i]; + } + } + + // Determine where the first n-th order (in this comment, n equals + // polyOrder) polynomial term is stored in the matrix B[], and also were + // the last n-order term is stored. Then we loop over all the n-order + // terms and check if they are consistent with zero. + + numPolyTerms = (((polyOrder + 1) * (polyOrder + 2)) / 2); + lastTerm = numPolyTerms + 1; + firstTerm = lastTerm - polyOrder; + *flag = 1; + for (i = firstTerm; i <= lastTerm; i++) { + #ifdef DARWIN + error[i] = (float)sqrt(y[i][i]); + #else + + error[i] = sqrtf(y[i][i]); + #endif + + if (!((B[i] <= (2.0f * error[i])) && ((-2.0f * error[i]) <= B[i]))) { + *flag = 0; + } + } + + // Free all memory allocated in this routine. + psFree(error); + psFree(col); + for (j = 1; j <= N; j++) { + psFree(y[j]); + } + psFree(y); +} + +/*****************************************************************************/ + +/* FUNCTION IMPLEMENTATION - PUBLIC */ + +/*****************************************************************************/ + +/****************************************************************************** +psMinimize(initialGuess, myFunction, myFunctionDeriv, coord, paramMask): + +This routine must minimize an arbitrary function; it determines the set of +parameters of that function such that the ... + *****************************************************************************/ +psVector* psMinimize(psVector* restrict initialGuess, + psMinimizeFunction myFunction, + psMinimizeFunctionDeriv myFunctionDeriv, + const psVector* restrict coord, + const psVector* restrict paramMask) +{ + int status; + int i = 0; + int j = 0; + int iter = 0; + gsl_multimin_function_fdf f; + const gsl_multimin_fdfminimizer_type *T; + gsl_multimin_fdfminimizer *s; + psMinimizeData inputData; + gsl_vector *x; + + PS_CHECK_NULL_VECTOR(initialGuess); + PS_CHECK_EMPTY_VECTOR(initialGuess); + PS_CHECK_NULL_VECTOR(coord); + PS_CHECK_EMPTY_VECTOR(coord); + if (paramMask != NULL) { + PS_CHECK_NULL_VECTOR(paramMask); + PS_CHECK_EMPTY_VECTOR(paramMask); + PS_CHECK_VECTOR_SIZE_EQUAL(initialGuess, paramMask); + } + + inputData.initialGuess = initialGuess; + inputData.coord = coord; + inputData.paramMask = paramMask; + inputData.evalModel = myFunction; + inputData.d_evalModel = myFunctionDeriv; + inputData.paramCount = 0; + + // If the user supplied a parameter mask, then count the number of + // non-masked elements. This will be used later in allocating a vector + // for the parameters. + if (paramMask != NULL) { + for (i = 0; i < paramMask->n; i++) { + if (paramMask->data.U8[i] != 0) { + inputData.paramCount++; + } + } + } else { + inputData.paramCount = initialGuess->n; + } + + // The initial guess at the parameters for the function are written into + // the vector inputParameterList. If the paramMask is not NULL, then + // masked parameters are masked out. + x = gsl_vector_alloc(inputData.paramCount); + if (paramMask != NULL) { + j = 0; + for (i = 0; i < initialGuess->n; i++) { + if (paramMask->data.U8[i] == 0) { + gsl_vector_set(x, j++, initialGuess->data.F32[i]); + } + } + } else { + for (i = 0; i < initialGuess->n; i++) { + gsl_vector_set(x, i, initialGuess->data.F32[i]); + } + } + f.f = &p_psMinFunc; + f.df = &p_psMinFuncDeriv; + f.fdf = &p_psMinFuncFuncDeriv; + f.n = inputData.paramCount; + f.params = &inputData; + + T = gsl_multimin_fdfminimizer_conjugate_fr; + s = gsl_multimin_fdfminimizer_alloc(T, inputData.paramCount); + gsl_multimin_fdfminimizer_set(s, &f, x, 0.01, 1e-4); + do { + iter++; + status = gsl_multimin_fdfminimizer_iterate(s); + + if (status) + break; + + status = gsl_multimin_test_gradient(s->gradient, 1e-3); + + if (status == GSL_SUCCESS) + printf("Minimum found at:\n"); + + } while (status == GSL_CONTINUE && iter < MAX_MINIMIZE_ITERATIONS); + + // In the above steps we had removed the masked elements from the + // the solver. This next code blocks puts those masked elements + // into the solution. + if (paramMask != NULL) { + j = 0; + for (i = 0; i < initialGuess->n; i++) { + if (paramMask->data.U8[i] == 0) { + initialGuess->data.F32[i] = gsl_vector_get(s->x, j++); + } else { + initialGuess->data.F32[i] = initialGuess->data.F32[i]; + } + } + } else { + for (i = 0; i < initialGuess->n; i++) { + initialGuess->data.F32[i] = gsl_vector_get(s->x, i); + } + } + return (initialGuess); +} + +/****************************************************************************** + This routine must determine the parameters of an arbitrary function + such that they best fit the supplied data points. + *****************************************************************************/ +psVector* psMinimizeChi2(psMinimizeFunction evalModel, + psMinimizeFunctionDeriv DevalModel, + const psImage* restrict domain, + const psVector* restrict data, + const psVector* restrict errors, + psVector* restrict initialGuess, + const psVector* restrict paramMask, + float *chiSq) +{ + int numData = domain->numRows; // Number of data points + int status; // Return status for the GSL solver. + int i = 0; // Loop index variable. + int j = 0; // Loop index variable. + int iter = 0; // Iteration counter. + gsl_multifit_function_fdf f; // GSL structure that contains the + + // functions/derivative to be solved. + double *xInit = NULL; // The initial guess at the parameters + + // with masked parameters removed. + const gsl_multifit_fdfsolver_type *T; + + // This tells GSL to use the Levenberg- + // Marquardt algorithm for chi2 + // minimization. + gsl_multifit_fdfsolver *s; // GSL data structure. + psMinChi2Data inputData; + float chiSqOld = 0.0; + + PS_CHECK_NULL_IMAGE(domain); + PS_CHECK_EMPTY_IMAGE(domain); + PS_CHECK_NULL_VECTOR(data); + PS_CHECK_EMPTY_VECTOR(data); + PS_CHECK_NULL_VECTOR(errors); + PS_CHECK_EMPTY_VECTOR(errors); + PS_CHECK_NULL_VECTOR(initialGuess); + PS_CHECK_EMPTY_VECTOR(initialGuess); + PS_CHECK_VECTOR_SIZE_EQUAL(data, errors); + if (domain->numRows != data->n) { + psAbort(__func__, "Number of data points and data values not equal."); + } + if (paramMask != NULL) { + PS_CHECK_NULL_VECTOR(paramMask); + PS_CHECK_EMPTY_VECTOR(paramMask); + PS_CHECK_VECTOR_SIZE_EQUAL(initialGuess, paramMask); + } + + inputData.n = numData; + inputData.paramCount = 0; + inputData.initialGuess = initialGuess; + inputData.domain = domain; + inputData.data = data; + inputData.errors = errors; + inputData.paramMask = paramMask; + inputData.evalModel = evalModel; + inputData.d_evalModel = DevalModel; + + // If the user supplied a parameter mask, then count the number of + // non-masked elements. This will be used later in allocating a vector + // for the parameters. + if (paramMask != NULL) { + for (i = 0; i < paramMask->n; i++) { + if (paramMask->data.U8[i] != 0) { + inputData.paramCount++; + } + } + } else { + inputData.paramCount = initialGuess->n; + } + + // The initial guess at the parameters for the function are written into + // the vector inputParameterList. If the paramMask is not NULL, then those + // parameters are masked out. + xInit = (double *)psAlloc(inputData.paramCount * sizeof(double)); + if (paramMask != NULL) { + j = 0; + for (i = 0; i < initialGuess->n; i++) { + if (paramMask->data.U8[i] == 0) { + xInit[j++] = initialGuess->data.F32[i]; + } + } + } else { + for (i = 0; i < initialGuess->n; i++) { + xInit[i] = initialGuess->data.F32[i]; + } + } + + const gsl_rng_type *type; + gsl_rng *r; + + gsl_rng_env_setup(); + + type = gsl_rng_default; + r = gsl_rng_alloc(type); + + // Initialize the main data structure used by the GSL solver. This will + // contain pointers to the function to be minimized, it's derivative + // function, the number of data points, the number of free parameters, + // and the data structures those functions use. + + f.f = &p_psMinChi2Func; + f.df = &p_psMinChi2FuncDeriv; + f.fdf = &p_psMinChi2FuncFuncDeriv; + f.n = numData; + f.p = inputData.paramCount; + f.params = &inputData; + + gsl_vector_view x = gsl_vector_view_array(xInit, inputData.paramCount); + + T = gsl_multifit_fdfsolver_lmsder; + s = gsl_multifit_fdfsolver_alloc(T, numData, inputData.paramCount); + gsl_multifit_fdfsolver_set(s, &f, &x.vector); + *chiSq = 0.0; + chiSqOld = 0.0; + do { + iter++; + for (i = 0; i < initialGuess->n; i++) { + printf("Iteration %d: parameter %d is %.3f\n", iter, i, gsl_vector_get(s->x, i)); + } + // Perform an iteration of the GSL solver. + status = gsl_multifit_fdfsolver_iterate(s); + printf("gsl_multifit_fdfsolver_iterate() status is %s\n", gsl_strerror(status)); + for (i = 0; i < initialGuess->n; i++) { + printf("Iteration %d: parameter %d is %.3f\n", iter, i, gsl_vector_get(s->x, i)); + } + + // If there was a problem, abort. + if (status) { + psAbort(__func__, "gsl_multifit_fdfsolver_iterate(%s)\n", gsl_strerror(status)); + } + // Test if the parameters changed by a small enough amount. + // NOTE: This wasn't working right when the parameters fit exactly. + // Figure out why. + // status = gsl_multifit_test_delta(s->dx, s->x, 1e-4, 1e-4); + + // We test for convergence if chiSquared changes by less than 1.0 + // as specified in the ADD. + *chiSq = gsl_blas_dnrm2(s->f); + printf("psMinimize.c: chiSq is %.3f\n", *chiSq); + if (fabs(*chiSq - chiSqOld) < 1.0) { + status = GSL_SUCCESS; + } else { + status = GSL_CONTINUE; + } + chiSqOld = *chiSq; + + } while (status == GSL_CONTINUE && iter < MAX_LMM_ITERATIONS); + + // In the above steps we had removed the masked elements from the + // the solver. This next code blocks puts those masked elements + // into the solution. + if (paramMask != NULL) { + j = 0; + for (i = 0; i < initialGuess->n; i++) { + if (paramMask->data.U8[i] == 0) { + initialGuess->data.F32[i] = gsl_vector_get(s->x, j++); + } else { + initialGuess->data.F32[i] = initialGuess->data.F32[i]; + } + } + } else { + for (i = 0; i < initialGuess->n; i++) { + initialGuess->data.F32[i] = gsl_vector_get(s->x, i); + } + } + + // Calculate the chi-squared for the derived solution. + *chiSq = gsl_blas_dnrm2(s->f); + + // Free all allocated memory + // NOTE: Free x. + gsl_multifit_fdfsolver_free(s); + psFree(xInit); + + // Bye bye. + return (initialGuess); +} + +/****************************************************************************** + This routine must fit a polynomial of degree myPoly to the data points + (x, y) and return the coefficients of that polynomial, as well as the + error for each data point (yErr). + +NOTE: yErr is currently ignored. + *****************************************************************************/ +psPolynomial1D* psVectorFitPolynomial1D(psPolynomial1D* myPoly, + const psVector* restrict x, + const psVector* restrict y, const psVector* restrict yErr) +{ + int polyOrder = myPoly->n; + psImage* A = NULL; + psImage* ALUD = NULL; + psVector* B = NULL; + psVector* outPerm = NULL; + psVector* X = NULL; // NOTE: do we need this? + psVector* coeffs = NULL; + int i = 0; + int j = 0; + int k = 0; + psVector* xSums = NULL; + + // printf("psVectorFitPolynomial1D()\n"); + // for (i=0;in;i++) { + // printf("(x, y, yErr) is (%f, %f, %f)\n", x->data.F64[i], y->data.F64[i], yErr->data.F64[i]); + // } + + PS_CHECK_NULL_1DPOLY(myPoly); + PS_CHECK_NULL_VECTOR(x); + PS_CHECK_EMPTY_VECTOR(x); + PS_CHECK_NULL_VECTOR(y); + PS_CHECK_EMPTY_VECTOR(y); + PS_CHECK_NULL_VECTOR(yErr); + PS_CHECK_EMPTY_VECTOR(yErr); + PS_CHECK_VECTOR_SIZE_EQUAL(x, y); + PS_CHECK_VECTOR_SIZE_EQUAL(y, yErr); + + A = psImageAlloc(polyOrder, polyOrder, PS_TYPE_F64); + ALUD = psImageAlloc(polyOrder, polyOrder, PS_TYPE_F64); + B = psVectorAlloc(polyOrder, PS_TYPE_F64); + coeffs = psVectorAlloc(polyOrder, PS_TYPE_F64); + X = psVectorAlloc(x->n, PS_TYPE_F64); + outPerm = psVectorAlloc(polyOrder, PS_TYPE_F64); + xSums = psVectorAlloc(1 + 2 * polyOrder, PS_TYPE_F64); + + // Initialize data structures. + for (i = 0; i < (polyOrder); i++) { + B->data.F64[i] = 0.0; + coeffs->data.F64[i] = 0.0; + outPerm->data.F64[i] = 0.0; + for (j = 0; j < (polyOrder); j++) { + A->data.F64[i][j] = 0.0; + ALUD->data.F64[i][j] = 0.0; + } + } + for (i = 0; i < X->n; i++) { + X->data.F64[i] = x->data.F64[i]; + } + + // Build the B and A data structs. + for (i = 0; i < X->n; i++) { + p_psBuildSums1D(X->data.F64[i], 2 * polyOrder, xSums); + + for (k = 0; k < (polyOrder); k++) { + B->data.F64[k] += y->data.F64[i] * xSums->data.F64[k]; + } + + for (k = 0; k < (polyOrder); k++) { + for (j = 0; j < (polyOrder); j++) { + A->data.F64[k][j] += xSums->data.F64[k + j]; + } + } + } + + ALUD = psMatrixLUD(ALUD, outPerm, A); + coeffs = psMatrixLUSolve(coeffs, ALUD, B, outPerm); + + for (k = 0; k < (polyOrder); k++) { + myPoly->coeff[k] = coeffs->data.F64[k]; + // printf("myPoly->coeff[%d] is %f\n", k, myPoly->coeff[k]); + } + + // for (i=0;in;i++) { + // printf("HMMM: psEvalPolynomial1D(%f) is %f\n", x->data.F64[i], psEvalPolynomial1D(x->data.F64[i], + // myPoly)); + // } + + psFree(A); + psFree(ALUD); + psFree(B); + psFree(coeffs); + psFree(X); + psFree(outPerm); + psFree(xSums); + + return (myPoly); +} Index: /tags/rel2_1/psLib/src/math/psMinimize.h =================================================================== --- /tags/rel2_1/psLib/src/math/psMinimize.h (revision 1553) +++ /tags/rel2_1/psLib/src/math/psMinimize.h (revision 1553) @@ -0,0 +1,105 @@ +#if !defined(PS_MINIMIZE_H) +#define PS_MINIMIZE_H + +#include "psFunctions.h" + +/** \file psMinimize.h + * \brief minimization operations + * \ingroup Stats + */ + +/** Functions **************************************************************/ + +/** \addtogroup Stats + * \{ + */ + +/** function of a collection of parameters and coordinate vector. + * + * @return float value to minimize + */ +typedef float (*psMinimizeFunction)( + const psVector* restrict params, ///< collection of parameters + const psVector* restrict coord ///< coordinates +); + +/** derivative function of psMinimizeFunction + * + * @return float the derivative in respect to params[derivParam] + */ +typedef float (*psMinimizeFunctionDeriv) ( + const psVector* restrict params, ///< collection of parameters + const psVector* restrict coord, ///< coordinates + int derivParam ///< index of parameter to calculate derivative of +); + +/** Minimizes a non-linear function. + * + * psMinimize determines and returns the vector that minimizes the specified + * function. It takes as input a function, myFunction, an initial guess for + * the vector that minimizes the function, initialGuess, the current + * coordiate coord, and an optional mask for the vector elements (function + * parameters) to minimize, paramMask (all parameters are fit if PSLib SDRS + * 25 July 13, 2004 Pan-STARRS Image Processing Pipeline PSDC-430-007-04 + * NULL). Note that paramMask must be of type psU8, while params must be of + * type psF32. The optional function, myFuncDeriv returns the derivative of + * the function. This function must be valid only for types psF32, psF64. + * + * @return psVector* minimized vector + */ +psVector* psMinimize( + psVector* restrict initialGuess, + psMinimizeFunction myFunction, + psMinimizeFunctionDeriv myFunctionDeriv, + const psVector* restrict coord, + const psVector* restrict paramMask +); + +/** Minimize chi^2 for input data. + * + * psMinimizeChi2 fits a model to observations by minimizing chi^2, returning + * the best-fit parameters. The input parameters are a function that + * evaluates the model for a specified domain, given the parameters, + * evalModel; a list of observations, (domain, data, and errors); an initial + * guess at the best-fit parameters, initialGuess which is returned with the + * best-fit parameters, and an optional mask specifying which parameters are + * to be fit, paramMask, which must be of type psU8. All parameters are fit + * if this vector is NULL. This function must be valid only for types psF32, + * psF64. + * + * @return psVector* minimized vector + */ +psVector* psMinimizeChi2( + psMinimizeFunction evalModel, ///< Model to fit; (domain and params) + psMinimizeFunctionDeriv DevalModel,///< Derivative of model to fit; (domain and params) + const psImage* restrict domain, ///< The domain values for the corresponding measurements + const psVector* restrict data, ///< Data to fit + const psVector* restrict errors, ///< Errors in the data + psVector* restrict initialGuess, ///< Initial guess + const psVector* restrict paramMask,///< 1 = fit for parameter, 0 = hold parameter constant + float *chiSq ///< chi squared +); + +/** Derive a polynomial fit by chi^2 minimisation (analytically) + * + * psVectorFitPolynomial1d returns the polynomial that best fits the + * observations. The input parameters are a polynomial that specifies the + * fit order, myPoly, which will be altered and returned with the best-fit + * coefficients; and the observations, x, y and yErr. The independent + * variable list, x may be NULL, in which case the vector index is used. + * The dependent variable error, yErr may be null, in which case the solution + * is determined in the assumption that all data errors are equal. This + * function must be valid only for types psF32, psF64. + * + * @return psPolynomial1D* polynomial fit + */ +psPolynomial1D* psVectorFitPolynomial1D( + psPolynomial1D* myPoly, ///< Polynomial to fit + const psVector* restrict x, ///< Ordinates (or NULL to just use the indices) + const psVector* restrict y, ///< Coordinates + const psVector* restrict yErr ///< Errors in coordinates, or NULL +); + +/* \} */// End of MathGroup Functions + +#endif Index: /tags/rel2_1/psLib/src/math/psPolynomial.c =================================================================== --- /tags/rel2_1/psLib/src/math/psPolynomial.c (revision 1553) +++ /tags/rel2_1/psLib/src/math/psPolynomial.c (revision 1553) @@ -0,0 +1,770 @@ + +/** @file psFunctions.c + * + * @brief Contains basic function allocation, deallocation, and evaluation + * routines. + * + * This file will hold the functions for allocated, freeing, and evaluating + * polynomials. It also contains a Gaussian functions. + * + * @version $Revision: 1.23 $ $Name: not supported by cvs2svn $ + * @date $Date: 2004-08-11 20:07:45 $ + * + * Copyright 2004 Maui High Performance Computing Center, University of Hawaii + */ + +/*****************************************************************************/ + +/* INCLUDE FILES */ + +/*****************************************************************************/ +#include +#include +#include +#include +#include +#include + +#include "psMemory.h" +#include "psVector.h" +#include "psTrace.h" +#include "psError.h" +#include "psAbort.h" +#include "psFunctions.h" + +#include +#include + +/*****************************************************************************/ + +/* DEFINE STATEMENTS */ + +/*****************************************************************************/ + +// None + +/*****************************************************************************/ + +/* TYPE DEFINITIONS */ + +/*****************************************************************************/ +static void polynomial1DFree(psPolynomial1D* myPoly); +static void polynomial2DFree(psPolynomial2D* myPoly); +static void polynomial3DFree(psPolynomial3D* myPoly); +static void polynomial4DFree(psPolynomial4D* myPoly); +static void dPolynomial1DFree(psDPolynomial1D* myPoly); +static void dPolynomial2DFree(psDPolynomial2D* myPoly); +static void dPolynomial3DFree(psDPolynomial3D* myPoly); +static void dPolynomial4DFree(psDPolynomial4D* myPoly); + +/*****************************************************************************/ + +/* GLOBAL VARIABLES */ + +/*****************************************************************************/ + +// None + +/*****************************************************************************/ + +/* FILE STATIC VARIABLES */ + +/*****************************************************************************/ + +// None + +/*****************************************************************************/ + +/* FUNCTION IMPLEMENTATION - LOCAL */ + +/*****************************************************************************/ + +// None + +/*****************************************************************************/ + +/* FUNCTION IMPLEMENTATION - PUBLIC */ + +/*****************************************************************************/ + +/***************************************************************************** + Evaluate a non-normalized Gaussian with the given mean and sigma at the + given coordianate. Note that this is not a Gaussian deviate. The + evaluated Gaussian is: \f[ exp(-\frac{(x-mean)^2}{2\sigma^2}) \f] + *****************************************************************************/ +float psGaussian(float x, float mean, float sigma, bool normal) +{ + float tmp = 1.0; + + if (normal == true) { + #ifdef DARWIN + tmp = 1.0 / (float)sqrt(2.0 * M_PI * (sigma * sigma)); + #else + + tmp = 1.0 / sqrtf(2.0 * M_PI * (sigma * sigma)); + #endif + + } + + return (tmp * exp(-((x - mean) * (x - mean)) / (2.0 * sigma * sigma))); +} + +/***************************************************************************** + psGaussianDev() + This routine creates a psVector of the specified size and type F32 + and fills it with a random Gaussian distribution of numbers with + the specified mean and sigma. This routine makes use of the GSL + routines for generating both uniformly distributed numbers and the + Gaussian distribution as well. + + NOTE: There is no way to seed the random generator. + *****************************************************************************/ +psVector* psGaussianDev(float mean, float sigma, int Npts) +{ + psVector* gauss = NULL; + const gsl_rng_type *T = NULL; + gsl_rng *r = NULL; + int i = 0; + + gauss = psVectorAlloc(Npts, PS_TYPE_F32); + gauss->n = Npts; + gsl_rng_env_setup(); + T = gsl_rng_default; + r = gsl_rng_alloc(T); + + for (i = 0; i < Npts; i++) { + gauss->data.F32[i] = mean + gsl_ran_gaussian(r, sigma); + } + + // NOTE: Should I free r as well? + return (gauss); +} + +/***************************************************************************** + This routine must allocate memory for the polynomial structures. + *****************************************************************************/ +psPolynomial1D* psPolynomial1DAlloc(int n) +{ + int i = 0; + psPolynomial1D* newPoly = NULL; + + newPoly = (psPolynomial1D* ) psAlloc(sizeof(psPolynomial1D)); + p_psMemSetDeallocator(newPoly, (psFreeFcn) polynomial1DFree); + newPoly->n = n; + newPoly->coeff = (float *)psAlloc(n * sizeof(float)); + newPoly->coeffErr = (float *)psAlloc(n * sizeof(float)); + newPoly->mask = (char *)psAlloc(n * sizeof(char)); + for (i = 0; i < n; i++) { + newPoly->coeff[i] = 0.0; + newPoly->coeffErr[i] = 0.0; + newPoly->mask[i] = 0.0; + } + + return (newPoly); +} + +psPolynomial2D* psPolynomial2DAlloc(int nX, int nY) +{ + int x = 0; + int y = 0; + psPolynomial2D* newPoly = NULL; + + newPoly = (psPolynomial2D* ) psAlloc(sizeof(psPolynomial2D)); + p_psMemSetDeallocator(newPoly, (psFreeFcn) polynomial2DFree); + newPoly->nX = nX; + newPoly->nY = nY; + + newPoly->coeff = (float **)psAlloc(nX * sizeof(float *)); + newPoly->coeffErr = (float **)psAlloc(nX * sizeof(float *)); + newPoly->mask = (char **)psAlloc(nX * sizeof(char *)); + for (x = 0; x < nX; x++) { + newPoly->coeff[x] = (float *)psAlloc(nY * sizeof(float)); + newPoly->coeffErr[x] = (float *)psAlloc(nY * sizeof(float)); + newPoly->mask[x] = (char *)psAlloc(nY * sizeof(char)); + } + for (x = 0; x < nX; x++) { + for (y = 0; y < nY; y++) { + newPoly->coeff[x][y] = 0.0; + newPoly->coeffErr[x][y] = 0.0; + newPoly->mask[x][y] = 0; + } + } + + return (newPoly); +} + +psPolynomial3D* psPolynomial3DAlloc(int nX, int nY, int nZ) +{ + int x = 0; + int y = 0; + int z = 0; + psPolynomial3D* newPoly = NULL; + + newPoly = (psPolynomial3D* ) psAlloc(sizeof(psPolynomial3D)); + p_psMemSetDeallocator(newPoly, (psFreeFcn) polynomial3DFree); + newPoly->nX = nX; + newPoly->nY = nY; + newPoly->nZ = nZ; + + newPoly->coeff = (float ***)psAlloc(nX * sizeof(float **)); + newPoly->coeffErr = (float ***)psAlloc(nX * sizeof(float **)); + newPoly->mask = (char ***)psAlloc(nX * sizeof(char **)); + for (x = 0; x < nX; x++) { + newPoly->coeff[x] = (float **)psAlloc(nY * sizeof(float *)); + newPoly->coeffErr[x] = (float **)psAlloc(nY * sizeof(float *)); + newPoly->mask[x] = (char **)psAlloc(nY * sizeof(char *)); + for (y = 0; y < nY; y++) { + newPoly->coeff[x][y] = (float *)psAlloc(nZ * sizeof(float)); + newPoly->coeffErr[x][y] = (float *)psAlloc(nZ * sizeof(float)); + newPoly->mask[x][y] = (char *)psAlloc(nZ * sizeof(char)); + } + } + for (x = 0; x < nX; x++) { + for (y = 0; y < nY; y++) { + for (z = 0; z < nZ; z++) { + newPoly->coeff[x][y][z] = 0.0; + newPoly->coeffErr[x][y][z] = 0.0; + newPoly->mask[x][y][z] = 0; + } + } + } + + return (newPoly); +} + +psPolynomial4D* psPolynomial4DAlloc(int nW, int nX, int nY, int nZ) +{ + int w = 0; + int x = 0; + int y = 0; + int z = 0; + psPolynomial4D* newPoly = NULL; + + newPoly = (psPolynomial4D* ) psAlloc(sizeof(psPolynomial4D)); + p_psMemSetDeallocator(newPoly, (psFreeFcn) polynomial4DFree); + newPoly->nW = nW; + newPoly->nX = nX; + newPoly->nY = nY; + newPoly->nZ = nZ; + + newPoly->coeff = (float ****)psAlloc(nW * sizeof(float ***)); + newPoly->coeffErr = (float ****)psAlloc(nW * sizeof(float ***)); + newPoly->mask = (char ****)psAlloc(nW * sizeof(char ***)); + for (w = 0; w < nW; w++) { + newPoly->coeff[w] = (float ***)psAlloc(nX * sizeof(float **)); + newPoly->coeffErr[w] = (float ***)psAlloc(nX * sizeof(float **)); + newPoly->mask[w] = (char ***)psAlloc(nX * sizeof(char **)); + for (x = 0; x < nX; x++) { + newPoly->coeff[w][x] = (float **)psAlloc(nY * sizeof(float *)); + newPoly->coeffErr[w][x] = (float **)psAlloc(nY * sizeof(float *)); + newPoly->mask[w][x] = (char **)psAlloc(nY * sizeof(char *)); + for (y = 0; y < nY; y++) { + newPoly->coeff[w][x][y] = (float *)psAlloc(nZ * sizeof(float)); + newPoly->coeffErr[w][x][y] = (float *)psAlloc(nZ * sizeof(float)); + newPoly->mask[w][x][y] = (char *)psAlloc(nZ * sizeof(char)); + } + } + } + for (w = 0; w < nW; w++) { + for (x = 0; x < nX; x++) { + for (y = 0; y < nY; y++) { + for (z = 0; z < nZ; z++) { + newPoly->coeff[w][x][y][z] = 0.0; + newPoly->coeffErr[w][x][y][z] = 0.0; + newPoly->mask[w][x][y][z] = 0; + } + } + } + } + + return (newPoly); +} + +static void polynomial1DFree(psPolynomial1D* myPoly) +{ + psFree(myPoly->coeff); + psFree(myPoly->coeffErr); + psFree(myPoly->mask); +} + +static void polynomial2DFree(psPolynomial2D* myPoly) +{ + int x = 0; + + for (x = 0; x < myPoly->nX; x++) { + psFree(myPoly->coeff[x]); + psFree(myPoly->coeffErr[x]); + psFree(myPoly->mask[x]); + } + psFree(myPoly->coeff); + psFree(myPoly->coeffErr); + psFree(myPoly->mask); +} + +static void polynomial3DFree(psPolynomial3D* myPoly) +{ + int x = 0; + int y = 0; + + for (x = 0; x < myPoly->nX; x++) { + for (y = 0; y < myPoly->nY; y++) { + psFree(myPoly->coeff[x][y]); + psFree(myPoly->coeffErr[x][y]); + psFree(myPoly->mask[x][y]); + } + psFree(myPoly->coeff[x]); + psFree(myPoly->coeffErr[x]); + psFree(myPoly->mask[x]); + } + + psFree(myPoly->coeff); + psFree(myPoly->coeffErr); + psFree(myPoly->mask); +} + +static void polynomial4DFree(psPolynomial4D* myPoly) +{ + int w = 0; + int x = 0; + int y = 0; + + for (w = 0; w < myPoly->nW; w++) { + for (x = 0; x < myPoly->nX; x++) { + for (y = 0; y < myPoly->nY; y++) { + psFree(myPoly->coeff[w][x][y]); + psFree(myPoly->coeffErr[w][x][y]); + psFree(myPoly->mask[w][x][y]); + } + psFree(myPoly->coeff[w][x]); + psFree(myPoly->coeffErr[w][x]); + psFree(myPoly->mask[w][x]); + } + psFree(myPoly->coeff[w]); + psFree(myPoly->coeffErr[w]); + psFree(myPoly->mask[w]); + } + + psFree(myPoly->coeff); + psFree(myPoly->coeffErr); + psFree(myPoly->mask); +} + +/***************************************************************************** + Polynomial coefficients will be accessed in [w][x][y][z] fashion. + + XXX: Determine, from IfA, whether ot not the "mask[]" terms should be used + in polynomial evaluation. If so, then all of the following polynomial + evaluation functions must be modified to do so. + + XXX: Should the "coeffErr[]" should be used as well? + *****************************************************************************/ +float psPolynomial1DEval(float x, const psPolynomial1D* myPoly) +{ + int loop_x = 0; + float polySum = 0.0; + float xSum = 1.0; + + if (NULL == myPoly) { + psAbort(__func__, "psPolynomial1DEval(): myPoly is NULL\n"); + } + + // NOTE: Do we want to flag this case? + if (myPoly->n == 0) { + return (1.0); + } + + if (NULL == myPoly->coeff) { + psAbort(__func__, "psPolynomial1DEval(): myPoly->coeff is NULL\n"); + } + + for (loop_x = 0; loop_x < myPoly->n; loop_x++) { + polySum += xSum * myPoly->coeff[loop_x]; + xSum *= x; + } + + return (polySum); +} + +float psPolynomial2DEval(float x, float y, const psPolynomial2D* myPoly) +{ + int loop_x = 0; + int loop_y = 0; + float polySum = 0.0; + float xSum = 1.0; + float ySum = 1.0; + + for (loop_x = 0; loop_x < myPoly->nX; loop_x++) { + ySum = xSum; + for (loop_y = 0; loop_y < myPoly->nY; loop_y++) { + polySum += ySum * myPoly->coeff[loop_x][loop_y]; + ySum *= y; + } + xSum *= x; + } + + return (polySum); +} + +float psPolynomial3DEval(float x, float y, float z, const psPolynomial3D* myPoly) +{ + int loop_x = 0; + int loop_y = 0; + int loop_z = 0; + float polySum = 0.0; + float xSum = 1.0; + float ySum = 1.0; + float zSum = 1.0; + + for (loop_x = 0; loop_x < myPoly->nX; loop_x++) { + ySum = xSum; + for (loop_y = 0; loop_y < myPoly->nY; loop_y++) { + zSum = ySum; + for (loop_z = 0; loop_z < myPoly->nZ; loop_z++) { + polySum += zSum * myPoly->coeff[loop_x][loop_y][loop_z]; + zSum *= z; + } + ySum *= y; + } + xSum *= x; + } + + return (polySum); +} + +float psPolynomial4DEval(float w, float x, float y, float z, const psPolynomial4D* myPoly) +{ + int loop_w = 0; + int loop_x = 0; + int loop_y = 0; + int loop_z = 0; + float polySum = 0.0; + float wSum = 1.0; + float xSum = 1.0; + float ySum = 1.0; + float zSum = 1.0; + + for (loop_w = 0; loop_w < myPoly->nW; loop_w++) { + xSum = wSum; + for (loop_x = 0; loop_x < myPoly->nX; loop_x++) { + ySum = xSum; + for (loop_y = 0; loop_y < myPoly->nY; loop_y++) { + zSum = ySum; + for (loop_z = 0; loop_z < myPoly->nZ; loop_z++) { + polySum += zSum * myPoly->coeff[loop_w][loop_x][loop_y][loop_z]; + zSum *= z; + } + ySum *= y; + } + xSum *= x; + } + wSum *= w; + } + + return (polySum); +} + +psDPolynomial1D* psDPolynomial1DAlloc(int n) +{ + int i = 0; + psDPolynomial1D* newPoly = NULL; + + newPoly = (psDPolynomial1D* ) psAlloc(sizeof(psDPolynomial1D)); + p_psMemSetDeallocator(newPoly, (psFreeFcn) dPolynomial1DFree); + newPoly->n = n; + newPoly->coeff = (double *)psAlloc(n * sizeof(double)); + newPoly->coeffErr = (double *)psAlloc(n * sizeof(double)); + newPoly->mask = (char *)psAlloc(n * sizeof(char)); + for (i = 0; i < n; i++) { + newPoly->coeff[i] = 0.0; + newPoly->coeffErr[i] = 0.0; + newPoly->mask[i] = 0.0; + } + + return (newPoly); +} + +psDPolynomial2D* psDPolynomial2DAlloc(int nX, int nY) +{ + int x = 0; + int y = 0; + psDPolynomial2D* newPoly = NULL; + + newPoly = (psDPolynomial2D* ) psAlloc(sizeof(psDPolynomial2D)); + p_psMemSetDeallocator(newPoly, (psFreeFcn) dPolynomial2DFree); + newPoly->nX = nX; + newPoly->nY = nY; + + newPoly->coeff = (double **)psAlloc(nX * sizeof(double *)); + newPoly->coeffErr = (double **)psAlloc(nX * sizeof(double *)); + newPoly->mask = (char **)psAlloc(nX * sizeof(char *)); + for (x = 0; x < nX; x++) { + newPoly->coeff[x] = (double *)psAlloc(nY * sizeof(double)); + newPoly->coeffErr[x] = (double *)psAlloc(nY * sizeof(double)); + newPoly->mask[x] = (char *)psAlloc(nY * sizeof(char)); + } + for (x = 0; x < nX; x++) { + for (y = 0; y < nY; y++) { + newPoly->coeff[x][y] = 0.0; + newPoly->coeffErr[x][y] = 0.0; + newPoly->mask[x][y] = 0; + } + } + + return (newPoly); +} + +psDPolynomial3D* psDPolynomial3DAlloc(int nX, int nY, int nZ) +{ + int x = 0; + int y = 0; + int z = 0; + psDPolynomial3D* newPoly = NULL; + + newPoly = (psDPolynomial3D* ) psAlloc(sizeof(psDPolynomial3D)); + p_psMemSetDeallocator(newPoly, (psFreeFcn) dPolynomial3DFree); + newPoly->nX = nX; + newPoly->nY = nY; + newPoly->nZ = nZ; + + newPoly->coeff = (double ***)psAlloc(nX * sizeof(double **)); + newPoly->coeffErr = (double ***)psAlloc(nX * sizeof(double **)); + newPoly->mask = (char ***)psAlloc(nX * sizeof(char **)); + for (x = 0; x < nX; x++) { + newPoly->coeff[x] = (double **)psAlloc(nY * sizeof(double *)); + newPoly->coeffErr[x] = (double **)psAlloc(nY * sizeof(double *)); + newPoly->mask[x] = (char **)psAlloc(nY * sizeof(char *)); + for (y = 0; y < nY; y++) { + newPoly->coeff[x][y] = (double *)psAlloc(nZ * sizeof(double)); + newPoly->coeffErr[x][y] = (double *)psAlloc(nZ * sizeof(double)); + newPoly->mask[x][y] = (char *)psAlloc(nZ * sizeof(char)); + } + } + for (x = 0; x < nX; x++) { + for (y = 0; y < nY; y++) { + for (z = 0; z < nZ; z++) { + newPoly->coeff[x][y][z] = 0.0; + newPoly->coeffErr[x][y][z] = 0.0; + newPoly->mask[x][y][z] = 0; + } + } + } + + return (newPoly); +} + +psDPolynomial4D* psDPolynomial4DAlloc(int nW, int nX, int nY, int nZ) +{ + int w = 0; + int x = 0; + int y = 0; + int z = 0; + psDPolynomial4D* newPoly = NULL; + + newPoly = (psDPolynomial4D* ) psAlloc(sizeof(psDPolynomial4D)); + p_psMemSetDeallocator(newPoly, (psFreeFcn) dPolynomial4DFree); + newPoly->nW = nW; + newPoly->nX = nX; + newPoly->nY = nY; + newPoly->nZ = nZ; + + newPoly->coeff = (double ****)psAlloc(nW * sizeof(double ***)); + newPoly->coeffErr = (double ****)psAlloc(nW * sizeof(double ***)); + newPoly->mask = (char ****)psAlloc(nW * sizeof(char ***)); + for (w = 0; w < nW; w++) { + newPoly->coeff[w] = (double ***)psAlloc(nX * sizeof(double **)); + newPoly->coeffErr[w] = (double ***)psAlloc(nX * sizeof(double **)); + newPoly->mask[w] = (char ***)psAlloc(nX * sizeof(char **)); + for (x = 0; x < nX; x++) { + newPoly->coeff[w][x] = (double **)psAlloc(nY * sizeof(double *)); + newPoly->coeffErr[w][x] = (double **)psAlloc(nY * sizeof(double *)); + newPoly->mask[w][x] = (char **)psAlloc(nY * sizeof(char *)); + for (y = 0; y < nY; y++) { + newPoly->coeff[w][x][y] = (double *)psAlloc(nZ * sizeof(double)); + newPoly->coeffErr[w][x][y] = (double *)psAlloc(nZ * sizeof(double)); + newPoly->mask[w][x][y] = (char *)psAlloc(nZ * sizeof(char)); + } + } + } + for (w = 0; w < nW; w++) { + for (x = 0; x < nX; x++) { + for (y = 0; y < nY; y++) { + for (z = 0; z < nZ; z++) { + newPoly->coeff[w][x][y][z] = 0.0; + newPoly->coeffErr[w][x][y][z] = 0.0; + newPoly->mask[w][x][y][z] = 0; + } + } + } + } + + return (newPoly); +} + +static void dPolynomial1DFree(psDPolynomial1D* myPoly) +{ + psFree(myPoly->coeff); + psFree(myPoly->coeffErr); + psFree(myPoly->mask); +} + +static void dPolynomial2DFree(psDPolynomial2D* myPoly) +{ + int x = 0; + + for (x = 0; x < myPoly->nX; x++) { + psFree(myPoly->coeff[x]); + psFree(myPoly->coeffErr[x]); + psFree(myPoly->mask[x]); + } + psFree(myPoly->coeff); + psFree(myPoly->coeffErr); + psFree(myPoly->mask); +} + +static void dPolynomial3DFree(psDPolynomial3D* myPoly) +{ + int x = 0; + int y = 0; + + for (x = 0; x < myPoly->nX; x++) { + for (y = 0; y < myPoly->nY; y++) { + psFree(myPoly->coeff[x][y]); + psFree(myPoly->coeffErr[x][y]); + psFree(myPoly->mask[x][y]); + } + psFree(myPoly->coeff[x]); + psFree(myPoly->coeffErr[x]); + psFree(myPoly->mask[x]); + } + + psFree(myPoly->coeff); + psFree(myPoly->coeffErr); + psFree(myPoly->mask); +} + +static void dPolynomial4DFree(psDPolynomial4D* myPoly) +{ + int w = 0; + int x = 0; + int y = 0; + + for (w = 0; w < myPoly->nW; w++) { + for (x = 0; x < myPoly->nX; x++) { + for (y = 0; y < myPoly->nY; y++) { + psFree(myPoly->coeff[w][x][y]); + psFree(myPoly->coeffErr[w][x][y]); + psFree(myPoly->mask[w][x][y]); + } + psFree(myPoly->coeff[w][x]); + psFree(myPoly->coeffErr[w][x]); + psFree(myPoly->mask[w][x]); + } + psFree(myPoly->coeff[w]); + psFree(myPoly->coeffErr[w]); + psFree(myPoly->mask[w]); + } + + psFree(myPoly->coeff); + psFree(myPoly->coeffErr); + psFree(myPoly->mask); +} + +/***************************************************************************** + Polynomial coefficients will be accessed in [w][x][y][z] fashion. + *****************************************************************************/ +double psDPolynomial1DEval(double x, const psDPolynomial1D* myPoly) +{ + int loop_x = 0; + double polySum = 0.0; + double xSum = 1.0; + + // NOTE: Do we want to flag this case? + if (myPoly->n == 0) { + return (1.0); + } + + for (loop_x = 0; loop_x < myPoly->n; loop_x++) { + polySum += xSum * myPoly->coeff[loop_x]; + xSum *= x; + } + + return (polySum); +} + +double psDPolynomial2DEval(double x, double y, const psDPolynomial2D* myPoly) +{ + int loop_x = 0; + int loop_y = 0; + double polySum = 0.0; + double xSum = 1.0; + double ySum = 1.0; + + for (loop_x = 0; loop_x < myPoly->nX; loop_x++) { + ySum = xSum; + for (loop_y = 0; loop_y < myPoly->nY; loop_y++) { + polySum += ySum * myPoly->coeff[loop_x][loop_y]; + ySum *= y; + } + xSum *= x; + } + + return (polySum); +} + +double psDPolynomial3DEval(double x, double y, double z, const psDPolynomial3D* myPoly) +{ + int loop_x = 0; + int loop_y = 0; + int loop_z = 0; + double polySum = 0.0; + double xSum = 1.0; + double ySum = 1.0; + double zSum = 1.0; + + for (loop_x = 0; loop_x < myPoly->nX; loop_x++) { + ySum = xSum; + for (loop_y = 0; loop_y < myPoly->nY; loop_y++) { + zSum = ySum; + for (loop_z = 0; loop_z < myPoly->nZ; loop_z++) { + polySum += zSum * myPoly->coeff[loop_x][loop_y][loop_z]; + zSum *= z; + } + ySum *= y; + } + xSum *= x; + } + + return (polySum); +} + +double psDPolynomial4DEval(double w, double x, double y, double z, const psDPolynomial4D* myPoly) +{ + int loop_w = 0; + int loop_x = 0; + int loop_y = 0; + int loop_z = 0; + double polySum = 0.0; + double wSum = 1.0; + double xSum = 1.0; + double ySum = 1.0; + double zSum = 1.0; + + for (loop_w = 0; loop_w < myPoly->nW; loop_w++) { + xSum = wSum; + for (loop_x = 0; loop_x < myPoly->nX; loop_x++) { + ySum = xSum; + for (loop_y = 0; loop_y < myPoly->nY; loop_y++) { + zSum = ySum; + for (loop_z = 0; loop_z < myPoly->nZ; loop_z++) { + polySum += zSum * myPoly->coeff[loop_w][loop_x][loop_y][loop_z]; + zSum *= z; + } + ySum *= y; + } + xSum *= x; + } + wSum *= w; + } + + return (polySum); +} Index: /tags/rel2_1/psLib/src/math/psPolynomial.h =================================================================== --- /tags/rel2_1/psLib/src/math/psPolynomial.h (revision 1553) +++ /tags/rel2_1/psLib/src/math/psPolynomial.h (revision 1553) @@ -0,0 +1,318 @@ + +/** @file psFunctions.h +* \brief Standard Mathematical Functions. +* \ingroup Stats +* +* This file will hold the prototypes for procedures which allocate, free, +* and evaluate various polynomials. Those polynomial structures are also +* defined here. +* +* @ingroup Stats +* +* @author Someone at IfA +* @author George Gusciora, MHPCC +* +* @version $Revision: 1.19 $ $Name: not supported by cvs2svn $ +* @date $Date: 2004-08-11 02:35:58 $ +* +* Copyright 2004 Maui High Performance Computing Center, University of Hawaii +*/ + +#if !defined(PS_FUNCTIONS_H) +#define PS_FUNCTIONS_H + +#include + +#include "psVector.h" + +/** \addtogroup Stats + * \{ + */ + +/** Evaluate a non-normalized Gaussian with the given mean and sigma at the + * given coordianate. + * + * Note that this is not a Gaussian deviate. The evaluated Gaussian is: + * \f[ exp(-\frac{(x-mean)^2}{2\sigma^2}) \f] + * + * @return float value on the gaussian curve given the input parameters + */ +float psGaussian( + float x, ///< Value at which to evaluate + float mean, ///< Mean for the Gaussian + float stddev, ///< Standard deviation for the Gaussian + bool normal ///< Indicates whether result should be normalized +); + +/** Produce a vector of random numbers from a Gaussian distribution with + * the specified mean and sigma + * + * @return psVector* vector of random numbers + * + */ +psVector* psGaussianDev( + float mean, ///< The mean of the Gaussian + float sigma, ///< The sigma of the Gaussian + int Npts ///< The size of the vector +); + +/** One-dimensional polynomial */ +typedef struct +{ + int n; ///< Number of terms + float *coeff; ///< Coefficients + float *coeffErr; ///< Error in coefficients + char *mask; ///< Coefficient mask +} +psPolynomial1D; + +/** Two-dimensional polynomial */ +typedef struct +{ + int nX; ///< Number of terms in x + int nY; ///< Number of terms in y + float **coeff; ///< Coefficients + float **coeffErr; ///< Error in coefficients + char **mask; ///< Coefficients mask +} +psPolynomial2D; + +/** Three-dimensional polynomial */ +typedef struct +{ + int nX; ///< Number of terms in x + int nY; ///< Number of terms in y + int nZ; ///< Number of terms in z + float ***coeff; ///< Coefficients + float ***coeffErr; ///< Error in coefficients + char ***mask; ///< Coefficients mask +} +psPolynomial3D; + +/** Four-dimensional polynomial */ +typedef struct +{ + int nW; ///< Number of terms in w + int nX; ///< Number of terms in x + int nY; ///< Number of terms in y + int nZ; ///< Number of terms in z + float ****coeff; ///< Coefficients + float ****coeffErr; ///< Error in coefficients + char ****mask; ///< Coefficients mask +} +psPolynomial4D; + + +/** Allocates a psPolynomial1D structure with n terms + * + * @return psPolynomial1D* new 1-D polynomial struct + */ +psPolynomial1D* psPolynomial1DAlloc( + int n ///< Number of terms +); + +/** Allocates a 2-D polynomial structure + * + * @return psPolynomial2D* new 2-D polynomial struct + */ +psPolynomial2D* psPolynomial2DAlloc( + int nX, ///< Number of terms in x + int nY ///< Number of terms in y +); + +/** Allocates a 3-D polynomial structure + * + * @return psPolynomial3D* new 3-D polynomial struct + */ +psPolynomial3D* psPolynomial3DAlloc( + int nX, ///< Number of terms in x + int nY, ///< Number of terms in y + int nZ ///< Number of terms in z +); + +/** Allocates a 4-D polynomial structure + * + * @return psPolynomial4D* new 4-D polynomial struct + */ +psPolynomial4D* psPolynomial4DAlloc( + int nW, ///< Number of terms in w + int nX, ///< Number of terms in x + int nY, ///< Number of terms in y + int nZ ///< Number of terms in z +); + +/** Evaluates a 1-D polynomial at specific coordinates. + * + * @return float result of polynomial at given location + */ +float psPolynomial1DEval( + float x, ///< location at which to evaluate + const psPolynomial1D* myPoly ///< Coefficients for the polynomial +); + +/** Evaluates a 2-D polynomial at specific coordinates. + * + * @return float result of polynomial at given location + */ +float psPolynomial2DEval( + float x, ///< x location at which to evaluate + float y, ///< y location at which to evaluate + const psPolynomial2D* myPoly ///< Coefficients for the polynomial +); + +/** Evaluates a 3-D polynomial at specific coordinates. + * + * @return float result of polynomial at given location + */ +float psPolynomial3DEval( + float x, ///< x location at which to evaluate + float y, ///< y location at which to evaluate + float z, ///< z location at which to evaluate + const psPolynomial3D* myPoly ///< Coefficients for the polynomial +); + +/** Evaluates a 4-D polynomial at specific coordinates. + * + * @return float result of polynomial at given location + */ +float psPolynomial4DEval( + float w, ///< w location at which to evaluate + float x, ///< x location at which to evaluate + float y, ///< y location at which to evaluate + float z, ///< z location at which to evaluate + const psPolynomial4D* myPoly ///< Coefficients for the polynomial +); + +/*****************************************************************************/ + +/* Double-precision polynomials, mainly for use in astrometry */ + +/** Double-precision one-dimensional polynomial */ +typedef struct +{ + int n; ///< Number of terms + double *coeff; ///< Coefficients + double *coeffErr; ///< Error in coefficients + char *mask; ///< Coefficient mask +} +psDPolynomial1D; + +/** Double-precision two-dimensional polynomial */ +typedef struct +{ + int nX; ///< Number of terms in x + int nY; ///< Number of terms in y + double **coeff; ///< Coefficients + double **coeffErr; ///< Error in coefficients + char **mask; ///< Coefficients mask +} +psDPolynomial2D; + +/** Double-precision three-dimensional polynomial */ +typedef struct +{ + int nX; ///< Number of terms in x + int nY; ///< Number of terms in y + int nZ; ///< Number of terms in z + double ***coeff; ///< Coefficients + double ***coeffErr; ///< Error in coefficients + char ***mask; ///< Coefficient mask +} +psDPolynomial3D; + +/** Double-precision four-dimensional polynomial */ +typedef struct +{ + int nW; ///< Number of terms in w + int nX; ///< Number of terms in x + int nY; ///< Number of terms in y + int nZ; ///< Number of terms in z + double ****coeff; ///< Coefficients + double ****coeffErr; ///< Error in coefficients + char ****mask; ///< Coefficients mask +} +psDPolynomial4D; + +/** Allocates a double-precision 1-D polynomial structure with n terms + * + * @return psPolynomial1D* new double-precision 1-D polynomial struct + */ +psDPolynomial1D* psDPolynomial1DAlloc( + int n ///< Number of terms +); + +/** Allocates a double-precision 2-D polynomial structure + * + * @return psPolynomial2D* new double-precision 2-D polynomial struct + */ +psDPolynomial2D* psDPolynomial2DAlloc( + int nX, ///< Number of terms in x + int nY ///< Number of terms in y +); + +/** Allocates a double-precision 3-D polynomial structure + * + * @return psPolynomial3D* new double-precision 3-D polynomial struct + */ +psDPolynomial3D* psDPolynomial3DAlloc( + int nX, ///< Number of terms in x + int nY, ///< Number of terms in y + int nZ ///< Number of terms in z +); + +/** Allocates a double-precision 4-D polynomial structure + * + * @return psPolynomial4D* new double-precision 4-D polynomial struct + */ +psDPolynomial4D* psDPolynomial4DAlloc( + int nW, ///< Number of terms in w + int nX, ///< Number of terms in x + int nY, ///< Number of terms in y + int nZ ///< Number of terms in z +); + +/** Evaluates a double-precision 1-D polynomial at specific coordinates. + * + * @return float result of polynomial at given location + */ +double psDPolynomial1DEval( + double x, ///< Value at which to evaluate + const psDPolynomial1D* myPoly ///< Coefficients for the polynomial +); + +/** Evaluates a double-precision 2-D polynomial at specific coordinates. + * + * @return float result of polynomial at given location + */ +double psDPolynomial2DEval( + double x, ///< Value x at which to evaluate + double y, ///< Value y at which to evaluate + const psDPolynomial2D* myPoly ///< Coefficients for the polynomial +); + +/** Evaluates a double-precision 3-D polynomial at specific coordinates. + * + * @return float result of polynomial at given location + */ +double psDPolynomial3DEval( + double x, ///< Value x at which to evaluate + double y, ///< Value y at which to evaluate + double z, ///< Value z at which to evaluate + const psDPolynomial3D* myPoly ///< Coefficients for the polynomial +); + +/** Evaluates a double-precision 4-D polynomial at specific coordinates. + * + * @return float result of polynomial at given location + */ +double psDPolynomial4DEval( + double w, ///< Value w at which to evaluate + double x, ///< Value x at which to evaluate + double y, ///< Value y at which to evaluate + double z, ///< Value z at which to evaluate + const psDPolynomial4D* myPoly ///< Coefficients for the polynomial +); + +/* \} */// End of MathGroup Functions + +#endif Index: /tags/rel2_1/psLib/src/math/psSpline.c =================================================================== --- /tags/rel2_1/psLib/src/math/psSpline.c (revision 1553) +++ /tags/rel2_1/psLib/src/math/psSpline.c (revision 1553) @@ -0,0 +1,770 @@ + +/** @file psFunctions.c + * + * @brief Contains basic function allocation, deallocation, and evaluation + * routines. + * + * This file will hold the functions for allocated, freeing, and evaluating + * polynomials. It also contains a Gaussian functions. + * + * @version $Revision: 1.23 $ $Name: not supported by cvs2svn $ + * @date $Date: 2004-08-11 20:07:45 $ + * + * Copyright 2004 Maui High Performance Computing Center, University of Hawaii + */ + +/*****************************************************************************/ + +/* INCLUDE FILES */ + +/*****************************************************************************/ +#include +#include +#include +#include +#include +#include + +#include "psMemory.h" +#include "psVector.h" +#include "psTrace.h" +#include "psError.h" +#include "psAbort.h" +#include "psFunctions.h" + +#include +#include + +/*****************************************************************************/ + +/* DEFINE STATEMENTS */ + +/*****************************************************************************/ + +// None + +/*****************************************************************************/ + +/* TYPE DEFINITIONS */ + +/*****************************************************************************/ +static void polynomial1DFree(psPolynomial1D* myPoly); +static void polynomial2DFree(psPolynomial2D* myPoly); +static void polynomial3DFree(psPolynomial3D* myPoly); +static void polynomial4DFree(psPolynomial4D* myPoly); +static void dPolynomial1DFree(psDPolynomial1D* myPoly); +static void dPolynomial2DFree(psDPolynomial2D* myPoly); +static void dPolynomial3DFree(psDPolynomial3D* myPoly); +static void dPolynomial4DFree(psDPolynomial4D* myPoly); + +/*****************************************************************************/ + +/* GLOBAL VARIABLES */ + +/*****************************************************************************/ + +// None + +/*****************************************************************************/ + +/* FILE STATIC VARIABLES */ + +/*****************************************************************************/ + +// None + +/*****************************************************************************/ + +/* FUNCTION IMPLEMENTATION - LOCAL */ + +/*****************************************************************************/ + +// None + +/*****************************************************************************/ + +/* FUNCTION IMPLEMENTATION - PUBLIC */ + +/*****************************************************************************/ + +/***************************************************************************** + Evaluate a non-normalized Gaussian with the given mean and sigma at the + given coordianate. Note that this is not a Gaussian deviate. The + evaluated Gaussian is: \f[ exp(-\frac{(x-mean)^2}{2\sigma^2}) \f] + *****************************************************************************/ +float psGaussian(float x, float mean, float sigma, bool normal) +{ + float tmp = 1.0; + + if (normal == true) { + #ifdef DARWIN + tmp = 1.0 / (float)sqrt(2.0 * M_PI * (sigma * sigma)); + #else + + tmp = 1.0 / sqrtf(2.0 * M_PI * (sigma * sigma)); + #endif + + } + + return (tmp * exp(-((x - mean) * (x - mean)) / (2.0 * sigma * sigma))); +} + +/***************************************************************************** + psGaussianDev() + This routine creates a psVector of the specified size and type F32 + and fills it with a random Gaussian distribution of numbers with + the specified mean and sigma. This routine makes use of the GSL + routines for generating both uniformly distributed numbers and the + Gaussian distribution as well. + + NOTE: There is no way to seed the random generator. + *****************************************************************************/ +psVector* psGaussianDev(float mean, float sigma, int Npts) +{ + psVector* gauss = NULL; + const gsl_rng_type *T = NULL; + gsl_rng *r = NULL; + int i = 0; + + gauss = psVectorAlloc(Npts, PS_TYPE_F32); + gauss->n = Npts; + gsl_rng_env_setup(); + T = gsl_rng_default; + r = gsl_rng_alloc(T); + + for (i = 0; i < Npts; i++) { + gauss->data.F32[i] = mean + gsl_ran_gaussian(r, sigma); + } + + // NOTE: Should I free r as well? + return (gauss); +} + +/***************************************************************************** + This routine must allocate memory for the polynomial structures. + *****************************************************************************/ +psPolynomial1D* psPolynomial1DAlloc(int n) +{ + int i = 0; + psPolynomial1D* newPoly = NULL; + + newPoly = (psPolynomial1D* ) psAlloc(sizeof(psPolynomial1D)); + p_psMemSetDeallocator(newPoly, (psFreeFcn) polynomial1DFree); + newPoly->n = n; + newPoly->coeff = (float *)psAlloc(n * sizeof(float)); + newPoly->coeffErr = (float *)psAlloc(n * sizeof(float)); + newPoly->mask = (char *)psAlloc(n * sizeof(char)); + for (i = 0; i < n; i++) { + newPoly->coeff[i] = 0.0; + newPoly->coeffErr[i] = 0.0; + newPoly->mask[i] = 0.0; + } + + return (newPoly); +} + +psPolynomial2D* psPolynomial2DAlloc(int nX, int nY) +{ + int x = 0; + int y = 0; + psPolynomial2D* newPoly = NULL; + + newPoly = (psPolynomial2D* ) psAlloc(sizeof(psPolynomial2D)); + p_psMemSetDeallocator(newPoly, (psFreeFcn) polynomial2DFree); + newPoly->nX = nX; + newPoly->nY = nY; + + newPoly->coeff = (float **)psAlloc(nX * sizeof(float *)); + newPoly->coeffErr = (float **)psAlloc(nX * sizeof(float *)); + newPoly->mask = (char **)psAlloc(nX * sizeof(char *)); + for (x = 0; x < nX; x++) { + newPoly->coeff[x] = (float *)psAlloc(nY * sizeof(float)); + newPoly->coeffErr[x] = (float *)psAlloc(nY * sizeof(float)); + newPoly->mask[x] = (char *)psAlloc(nY * sizeof(char)); + } + for (x = 0; x < nX; x++) { + for (y = 0; y < nY; y++) { + newPoly->coeff[x][y] = 0.0; + newPoly->coeffErr[x][y] = 0.0; + newPoly->mask[x][y] = 0; + } + } + + return (newPoly); +} + +psPolynomial3D* psPolynomial3DAlloc(int nX, int nY, int nZ) +{ + int x = 0; + int y = 0; + int z = 0; + psPolynomial3D* newPoly = NULL; + + newPoly = (psPolynomial3D* ) psAlloc(sizeof(psPolynomial3D)); + p_psMemSetDeallocator(newPoly, (psFreeFcn) polynomial3DFree); + newPoly->nX = nX; + newPoly->nY = nY; + newPoly->nZ = nZ; + + newPoly->coeff = (float ***)psAlloc(nX * sizeof(float **)); + newPoly->coeffErr = (float ***)psAlloc(nX * sizeof(float **)); + newPoly->mask = (char ***)psAlloc(nX * sizeof(char **)); + for (x = 0; x < nX; x++) { + newPoly->coeff[x] = (float **)psAlloc(nY * sizeof(float *)); + newPoly->coeffErr[x] = (float **)psAlloc(nY * sizeof(float *)); + newPoly->mask[x] = (char **)psAlloc(nY * sizeof(char *)); + for (y = 0; y < nY; y++) { + newPoly->coeff[x][y] = (float *)psAlloc(nZ * sizeof(float)); + newPoly->coeffErr[x][y] = (float *)psAlloc(nZ * sizeof(float)); + newPoly->mask[x][y] = (char *)psAlloc(nZ * sizeof(char)); + } + } + for (x = 0; x < nX; x++) { + for (y = 0; y < nY; y++) { + for (z = 0; z < nZ; z++) { + newPoly->coeff[x][y][z] = 0.0; + newPoly->coeffErr[x][y][z] = 0.0; + newPoly->mask[x][y][z] = 0; + } + } + } + + return (newPoly); +} + +psPolynomial4D* psPolynomial4DAlloc(int nW, int nX, int nY, int nZ) +{ + int w = 0; + int x = 0; + int y = 0; + int z = 0; + psPolynomial4D* newPoly = NULL; + + newPoly = (psPolynomial4D* ) psAlloc(sizeof(psPolynomial4D)); + p_psMemSetDeallocator(newPoly, (psFreeFcn) polynomial4DFree); + newPoly->nW = nW; + newPoly->nX = nX; + newPoly->nY = nY; + newPoly->nZ = nZ; + + newPoly->coeff = (float ****)psAlloc(nW * sizeof(float ***)); + newPoly->coeffErr = (float ****)psAlloc(nW * sizeof(float ***)); + newPoly->mask = (char ****)psAlloc(nW * sizeof(char ***)); + for (w = 0; w < nW; w++) { + newPoly->coeff[w] = (float ***)psAlloc(nX * sizeof(float **)); + newPoly->coeffErr[w] = (float ***)psAlloc(nX * sizeof(float **)); + newPoly->mask[w] = (char ***)psAlloc(nX * sizeof(char **)); + for (x = 0; x < nX; x++) { + newPoly->coeff[w][x] = (float **)psAlloc(nY * sizeof(float *)); + newPoly->coeffErr[w][x] = (float **)psAlloc(nY * sizeof(float *)); + newPoly->mask[w][x] = (char **)psAlloc(nY * sizeof(char *)); + for (y = 0; y < nY; y++) { + newPoly->coeff[w][x][y] = (float *)psAlloc(nZ * sizeof(float)); + newPoly->coeffErr[w][x][y] = (float *)psAlloc(nZ * sizeof(float)); + newPoly->mask[w][x][y] = (char *)psAlloc(nZ * sizeof(char)); + } + } + } + for (w = 0; w < nW; w++) { + for (x = 0; x < nX; x++) { + for (y = 0; y < nY; y++) { + for (z = 0; z < nZ; z++) { + newPoly->coeff[w][x][y][z] = 0.0; + newPoly->coeffErr[w][x][y][z] = 0.0; + newPoly->mask[w][x][y][z] = 0; + } + } + } + } + + return (newPoly); +} + +static void polynomial1DFree(psPolynomial1D* myPoly) +{ + psFree(myPoly->coeff); + psFree(myPoly->coeffErr); + psFree(myPoly->mask); +} + +static void polynomial2DFree(psPolynomial2D* myPoly) +{ + int x = 0; + + for (x = 0; x < myPoly->nX; x++) { + psFree(myPoly->coeff[x]); + psFree(myPoly->coeffErr[x]); + psFree(myPoly->mask[x]); + } + psFree(myPoly->coeff); + psFree(myPoly->coeffErr); + psFree(myPoly->mask); +} + +static void polynomial3DFree(psPolynomial3D* myPoly) +{ + int x = 0; + int y = 0; + + for (x = 0; x < myPoly->nX; x++) { + for (y = 0; y < myPoly->nY; y++) { + psFree(myPoly->coeff[x][y]); + psFree(myPoly->coeffErr[x][y]); + psFree(myPoly->mask[x][y]); + } + psFree(myPoly->coeff[x]); + psFree(myPoly->coeffErr[x]); + psFree(myPoly->mask[x]); + } + + psFree(myPoly->coeff); + psFree(myPoly->coeffErr); + psFree(myPoly->mask); +} + +static void polynomial4DFree(psPolynomial4D* myPoly) +{ + int w = 0; + int x = 0; + int y = 0; + + for (w = 0; w < myPoly->nW; w++) { + for (x = 0; x < myPoly->nX; x++) { + for (y = 0; y < myPoly->nY; y++) { + psFree(myPoly->coeff[w][x][y]); + psFree(myPoly->coeffErr[w][x][y]); + psFree(myPoly->mask[w][x][y]); + } + psFree(myPoly->coeff[w][x]); + psFree(myPoly->coeffErr[w][x]); + psFree(myPoly->mask[w][x]); + } + psFree(myPoly->coeff[w]); + psFree(myPoly->coeffErr[w]); + psFree(myPoly->mask[w]); + } + + psFree(myPoly->coeff); + psFree(myPoly->coeffErr); + psFree(myPoly->mask); +} + +/***************************************************************************** + Polynomial coefficients will be accessed in [w][x][y][z] fashion. + + XXX: Determine, from IfA, whether ot not the "mask[]" terms should be used + in polynomial evaluation. If so, then all of the following polynomial + evaluation functions must be modified to do so. + + XXX: Should the "coeffErr[]" should be used as well? + *****************************************************************************/ +float psPolynomial1DEval(float x, const psPolynomial1D* myPoly) +{ + int loop_x = 0; + float polySum = 0.0; + float xSum = 1.0; + + if (NULL == myPoly) { + psAbort(__func__, "psPolynomial1DEval(): myPoly is NULL\n"); + } + + // NOTE: Do we want to flag this case? + if (myPoly->n == 0) { + return (1.0); + } + + if (NULL == myPoly->coeff) { + psAbort(__func__, "psPolynomial1DEval(): myPoly->coeff is NULL\n"); + } + + for (loop_x = 0; loop_x < myPoly->n; loop_x++) { + polySum += xSum * myPoly->coeff[loop_x]; + xSum *= x; + } + + return (polySum); +} + +float psPolynomial2DEval(float x, float y, const psPolynomial2D* myPoly) +{ + int loop_x = 0; + int loop_y = 0; + float polySum = 0.0; + float xSum = 1.0; + float ySum = 1.0; + + for (loop_x = 0; loop_x < myPoly->nX; loop_x++) { + ySum = xSum; + for (loop_y = 0; loop_y < myPoly->nY; loop_y++) { + polySum += ySum * myPoly->coeff[loop_x][loop_y]; + ySum *= y; + } + xSum *= x; + } + + return (polySum); +} + +float psPolynomial3DEval(float x, float y, float z, const psPolynomial3D* myPoly) +{ + int loop_x = 0; + int loop_y = 0; + int loop_z = 0; + float polySum = 0.0; + float xSum = 1.0; + float ySum = 1.0; + float zSum = 1.0; + + for (loop_x = 0; loop_x < myPoly->nX; loop_x++) { + ySum = xSum; + for (loop_y = 0; loop_y < myPoly->nY; loop_y++) { + zSum = ySum; + for (loop_z = 0; loop_z < myPoly->nZ; loop_z++) { + polySum += zSum * myPoly->coeff[loop_x][loop_y][loop_z]; + zSum *= z; + } + ySum *= y; + } + xSum *= x; + } + + return (polySum); +} + +float psPolynomial4DEval(float w, float x, float y, float z, const psPolynomial4D* myPoly) +{ + int loop_w = 0; + int loop_x = 0; + int loop_y = 0; + int loop_z = 0; + float polySum = 0.0; + float wSum = 1.0; + float xSum = 1.0; + float ySum = 1.0; + float zSum = 1.0; + + for (loop_w = 0; loop_w < myPoly->nW; loop_w++) { + xSum = wSum; + for (loop_x = 0; loop_x < myPoly->nX; loop_x++) { + ySum = xSum; + for (loop_y = 0; loop_y < myPoly->nY; loop_y++) { + zSum = ySum; + for (loop_z = 0; loop_z < myPoly->nZ; loop_z++) { + polySum += zSum * myPoly->coeff[loop_w][loop_x][loop_y][loop_z]; + zSum *= z; + } + ySum *= y; + } + xSum *= x; + } + wSum *= w; + } + + return (polySum); +} + +psDPolynomial1D* psDPolynomial1DAlloc(int n) +{ + int i = 0; + psDPolynomial1D* newPoly = NULL; + + newPoly = (psDPolynomial1D* ) psAlloc(sizeof(psDPolynomial1D)); + p_psMemSetDeallocator(newPoly, (psFreeFcn) dPolynomial1DFree); + newPoly->n = n; + newPoly->coeff = (double *)psAlloc(n * sizeof(double)); + newPoly->coeffErr = (double *)psAlloc(n * sizeof(double)); + newPoly->mask = (char *)psAlloc(n * sizeof(char)); + for (i = 0; i < n; i++) { + newPoly->coeff[i] = 0.0; + newPoly->coeffErr[i] = 0.0; + newPoly->mask[i] = 0.0; + } + + return (newPoly); +} + +psDPolynomial2D* psDPolynomial2DAlloc(int nX, int nY) +{ + int x = 0; + int y = 0; + psDPolynomial2D* newPoly = NULL; + + newPoly = (psDPolynomial2D* ) psAlloc(sizeof(psDPolynomial2D)); + p_psMemSetDeallocator(newPoly, (psFreeFcn) dPolynomial2DFree); + newPoly->nX = nX; + newPoly->nY = nY; + + newPoly->coeff = (double **)psAlloc(nX * sizeof(double *)); + newPoly->coeffErr = (double **)psAlloc(nX * sizeof(double *)); + newPoly->mask = (char **)psAlloc(nX * sizeof(char *)); + for (x = 0; x < nX; x++) { + newPoly->coeff[x] = (double *)psAlloc(nY * sizeof(double)); + newPoly->coeffErr[x] = (double *)psAlloc(nY * sizeof(double)); + newPoly->mask[x] = (char *)psAlloc(nY * sizeof(char)); + } + for (x = 0; x < nX; x++) { + for (y = 0; y < nY; y++) { + newPoly->coeff[x][y] = 0.0; + newPoly->coeffErr[x][y] = 0.0; + newPoly->mask[x][y] = 0; + } + } + + return (newPoly); +} + +psDPolynomial3D* psDPolynomial3DAlloc(int nX, int nY, int nZ) +{ + int x = 0; + int y = 0; + int z = 0; + psDPolynomial3D* newPoly = NULL; + + newPoly = (psDPolynomial3D* ) psAlloc(sizeof(psDPolynomial3D)); + p_psMemSetDeallocator(newPoly, (psFreeFcn) dPolynomial3DFree); + newPoly->nX = nX; + newPoly->nY = nY; + newPoly->nZ = nZ; + + newPoly->coeff = (double ***)psAlloc(nX * sizeof(double **)); + newPoly->coeffErr = (double ***)psAlloc(nX * sizeof(double **)); + newPoly->mask = (char ***)psAlloc(nX * sizeof(char **)); + for (x = 0; x < nX; x++) { + newPoly->coeff[x] = (double **)psAlloc(nY * sizeof(double *)); + newPoly->coeffErr[x] = (double **)psAlloc(nY * sizeof(double *)); + newPoly->mask[x] = (char **)psAlloc(nY * sizeof(char *)); + for (y = 0; y < nY; y++) { + newPoly->coeff[x][y] = (double *)psAlloc(nZ * sizeof(double)); + newPoly->coeffErr[x][y] = (double *)psAlloc(nZ * sizeof(double)); + newPoly->mask[x][y] = (char *)psAlloc(nZ * sizeof(char)); + } + } + for (x = 0; x < nX; x++) { + for (y = 0; y < nY; y++) { + for (z = 0; z < nZ; z++) { + newPoly->coeff[x][y][z] = 0.0; + newPoly->coeffErr[x][y][z] = 0.0; + newPoly->mask[x][y][z] = 0; + } + } + } + + return (newPoly); +} + +psDPolynomial4D* psDPolynomial4DAlloc(int nW, int nX, int nY, int nZ) +{ + int w = 0; + int x = 0; + int y = 0; + int z = 0; + psDPolynomial4D* newPoly = NULL; + + newPoly = (psDPolynomial4D* ) psAlloc(sizeof(psDPolynomial4D)); + p_psMemSetDeallocator(newPoly, (psFreeFcn) dPolynomial4DFree); + newPoly->nW = nW; + newPoly->nX = nX; + newPoly->nY = nY; + newPoly->nZ = nZ; + + newPoly->coeff = (double ****)psAlloc(nW * sizeof(double ***)); + newPoly->coeffErr = (double ****)psAlloc(nW * sizeof(double ***)); + newPoly->mask = (char ****)psAlloc(nW * sizeof(char ***)); + for (w = 0; w < nW; w++) { + newPoly->coeff[w] = (double ***)psAlloc(nX * sizeof(double **)); + newPoly->coeffErr[w] = (double ***)psAlloc(nX * sizeof(double **)); + newPoly->mask[w] = (char ***)psAlloc(nX * sizeof(char **)); + for (x = 0; x < nX; x++) { + newPoly->coeff[w][x] = (double **)psAlloc(nY * sizeof(double *)); + newPoly->coeffErr[w][x] = (double **)psAlloc(nY * sizeof(double *)); + newPoly->mask[w][x] = (char **)psAlloc(nY * sizeof(char *)); + for (y = 0; y < nY; y++) { + newPoly->coeff[w][x][y] = (double *)psAlloc(nZ * sizeof(double)); + newPoly->coeffErr[w][x][y] = (double *)psAlloc(nZ * sizeof(double)); + newPoly->mask[w][x][y] = (char *)psAlloc(nZ * sizeof(char)); + } + } + } + for (w = 0; w < nW; w++) { + for (x = 0; x < nX; x++) { + for (y = 0; y < nY; y++) { + for (z = 0; z < nZ; z++) { + newPoly->coeff[w][x][y][z] = 0.0; + newPoly->coeffErr[w][x][y][z] = 0.0; + newPoly->mask[w][x][y][z] = 0; + } + } + } + } + + return (newPoly); +} + +static void dPolynomial1DFree(psDPolynomial1D* myPoly) +{ + psFree(myPoly->coeff); + psFree(myPoly->coeffErr); + psFree(myPoly->mask); +} + +static void dPolynomial2DFree(psDPolynomial2D* myPoly) +{ + int x = 0; + + for (x = 0; x < myPoly->nX; x++) { + psFree(myPoly->coeff[x]); + psFree(myPoly->coeffErr[x]); + psFree(myPoly->mask[x]); + } + psFree(myPoly->coeff); + psFree(myPoly->coeffErr); + psFree(myPoly->mask); +} + +static void dPolynomial3DFree(psDPolynomial3D* myPoly) +{ + int x = 0; + int y = 0; + + for (x = 0; x < myPoly->nX; x++) { + for (y = 0; y < myPoly->nY; y++) { + psFree(myPoly->coeff[x][y]); + psFree(myPoly->coeffErr[x][y]); + psFree(myPoly->mask[x][y]); + } + psFree(myPoly->coeff[x]); + psFree(myPoly->coeffErr[x]); + psFree(myPoly->mask[x]); + } + + psFree(myPoly->coeff); + psFree(myPoly->coeffErr); + psFree(myPoly->mask); +} + +static void dPolynomial4DFree(psDPolynomial4D* myPoly) +{ + int w = 0; + int x = 0; + int y = 0; + + for (w = 0; w < myPoly->nW; w++) { + for (x = 0; x < myPoly->nX; x++) { + for (y = 0; y < myPoly->nY; y++) { + psFree(myPoly->coeff[w][x][y]); + psFree(myPoly->coeffErr[w][x][y]); + psFree(myPoly->mask[w][x][y]); + } + psFree(myPoly->coeff[w][x]); + psFree(myPoly->coeffErr[w][x]); + psFree(myPoly->mask[w][x]); + } + psFree(myPoly->coeff[w]); + psFree(myPoly->coeffErr[w]); + psFree(myPoly->mask[w]); + } + + psFree(myPoly->coeff); + psFree(myPoly->coeffErr); + psFree(myPoly->mask); +} + +/***************************************************************************** + Polynomial coefficients will be accessed in [w][x][y][z] fashion. + *****************************************************************************/ +double psDPolynomial1DEval(double x, const psDPolynomial1D* myPoly) +{ + int loop_x = 0; + double polySum = 0.0; + double xSum = 1.0; + + // NOTE: Do we want to flag this case? + if (myPoly->n == 0) { + return (1.0); + } + + for (loop_x = 0; loop_x < myPoly->n; loop_x++) { + polySum += xSum * myPoly->coeff[loop_x]; + xSum *= x; + } + + return (polySum); +} + +double psDPolynomial2DEval(double x, double y, const psDPolynomial2D* myPoly) +{ + int loop_x = 0; + int loop_y = 0; + double polySum = 0.0; + double xSum = 1.0; + double ySum = 1.0; + + for (loop_x = 0; loop_x < myPoly->nX; loop_x++) { + ySum = xSum; + for (loop_y = 0; loop_y < myPoly->nY; loop_y++) { + polySum += ySum * myPoly->coeff[loop_x][loop_y]; + ySum *= y; + } + xSum *= x; + } + + return (polySum); +} + +double psDPolynomial3DEval(double x, double y, double z, const psDPolynomial3D* myPoly) +{ + int loop_x = 0; + int loop_y = 0; + int loop_z = 0; + double polySum = 0.0; + double xSum = 1.0; + double ySum = 1.0; + double zSum = 1.0; + + for (loop_x = 0; loop_x < myPoly->nX; loop_x++) { + ySum = xSum; + for (loop_y = 0; loop_y < myPoly->nY; loop_y++) { + zSum = ySum; + for (loop_z = 0; loop_z < myPoly->nZ; loop_z++) { + polySum += zSum * myPoly->coeff[loop_x][loop_y][loop_z]; + zSum *= z; + } + ySum *= y; + } + xSum *= x; + } + + return (polySum); +} + +double psDPolynomial4DEval(double w, double x, double y, double z, const psDPolynomial4D* myPoly) +{ + int loop_w = 0; + int loop_x = 0; + int loop_y = 0; + int loop_z = 0; + double polySum = 0.0; + double wSum = 1.0; + double xSum = 1.0; + double ySum = 1.0; + double zSum = 1.0; + + for (loop_w = 0; loop_w < myPoly->nW; loop_w++) { + xSum = wSum; + for (loop_x = 0; loop_x < myPoly->nX; loop_x++) { + ySum = xSum; + for (loop_y = 0; loop_y < myPoly->nY; loop_y++) { + zSum = ySum; + for (loop_z = 0; loop_z < myPoly->nZ; loop_z++) { + polySum += zSum * myPoly->coeff[loop_w][loop_x][loop_y][loop_z]; + zSum *= z; + } + ySum *= y; + } + xSum *= x; + } + wSum *= w; + } + + return (polySum); +} Index: /tags/rel2_1/psLib/src/math/psSpline.h =================================================================== --- /tags/rel2_1/psLib/src/math/psSpline.h (revision 1553) +++ /tags/rel2_1/psLib/src/math/psSpline.h (revision 1553) @@ -0,0 +1,318 @@ + +/** @file psFunctions.h +* \brief Standard Mathematical Functions. +* \ingroup Stats +* +* This file will hold the prototypes for procedures which allocate, free, +* and evaluate various polynomials. Those polynomial structures are also +* defined here. +* +* @ingroup Stats +* +* @author Someone at IfA +* @author George Gusciora, MHPCC +* +* @version $Revision: 1.19 $ $Name: not supported by cvs2svn $ +* @date $Date: 2004-08-11 02:35:58 $ +* +* Copyright 2004 Maui High Performance Computing Center, University of Hawaii +*/ + +#if !defined(PS_FUNCTIONS_H) +#define PS_FUNCTIONS_H + +#include + +#include "psVector.h" + +/** \addtogroup Stats + * \{ + */ + +/** Evaluate a non-normalized Gaussian with the given mean and sigma at the + * given coordianate. + * + * Note that this is not a Gaussian deviate. The evaluated Gaussian is: + * \f[ exp(-\frac{(x-mean)^2}{2\sigma^2}) \f] + * + * @return float value on the gaussian curve given the input parameters + */ +float psGaussian( + float x, ///< Value at which to evaluate + float mean, ///< Mean for the Gaussian + float stddev, ///< Standard deviation for the Gaussian + bool normal ///< Indicates whether result should be normalized +); + +/** Produce a vector of random numbers from a Gaussian distribution with + * the specified mean and sigma + * + * @return psVector* vector of random numbers + * + */ +psVector* psGaussianDev( + float mean, ///< The mean of the Gaussian + float sigma, ///< The sigma of the Gaussian + int Npts ///< The size of the vector +); + +/** One-dimensional polynomial */ +typedef struct +{ + int n; ///< Number of terms + float *coeff; ///< Coefficients + float *coeffErr; ///< Error in coefficients + char *mask; ///< Coefficient mask +} +psPolynomial1D; + +/** Two-dimensional polynomial */ +typedef struct +{ + int nX; ///< Number of terms in x + int nY; ///< Number of terms in y + float **coeff; ///< Coefficients + float **coeffErr; ///< Error in coefficients + char **mask; ///< Coefficients mask +} +psPolynomial2D; + +/** Three-dimensional polynomial */ +typedef struct +{ + int nX; ///< Number of terms in x + int nY; ///< Number of terms in y + int nZ; ///< Number of terms in z + float ***coeff; ///< Coefficients + float ***coeffErr; ///< Error in coefficients + char ***mask; ///< Coefficients mask +} +psPolynomial3D; + +/** Four-dimensional polynomial */ +typedef struct +{ + int nW; ///< Number of terms in w + int nX; ///< Number of terms in x + int nY; ///< Number of terms in y + int nZ; ///< Number of terms in z + float ****coeff; ///< Coefficients + float ****coeffErr; ///< Error in coefficients + char ****mask; ///< Coefficients mask +} +psPolynomial4D; + + +/** Allocates a psPolynomial1D structure with n terms + * + * @return psPolynomial1D* new 1-D polynomial struct + */ +psPolynomial1D* psPolynomial1DAlloc( + int n ///< Number of terms +); + +/** Allocates a 2-D polynomial structure + * + * @return psPolynomial2D* new 2-D polynomial struct + */ +psPolynomial2D* psPolynomial2DAlloc( + int nX, ///< Number of terms in x + int nY ///< Number of terms in y +); + +/** Allocates a 3-D polynomial structure + * + * @return psPolynomial3D* new 3-D polynomial struct + */ +psPolynomial3D* psPolynomial3DAlloc( + int nX, ///< Number of terms in x + int nY, ///< Number of terms in y + int nZ ///< Number of terms in z +); + +/** Allocates a 4-D polynomial structure + * + * @return psPolynomial4D* new 4-D polynomial struct + */ +psPolynomial4D* psPolynomial4DAlloc( + int nW, ///< Number of terms in w + int nX, ///< Number of terms in x + int nY, ///< Number of terms in y + int nZ ///< Number of terms in z +); + +/** Evaluates a 1-D polynomial at specific coordinates. + * + * @return float result of polynomial at given location + */ +float psPolynomial1DEval( + float x, ///< location at which to evaluate + const psPolynomial1D* myPoly ///< Coefficients for the polynomial +); + +/** Evaluates a 2-D polynomial at specific coordinates. + * + * @return float result of polynomial at given location + */ +float psPolynomial2DEval( + float x, ///< x location at which to evaluate + float y, ///< y location at which to evaluate + const psPolynomial2D* myPoly ///< Coefficients for the polynomial +); + +/** Evaluates a 3-D polynomial at specific coordinates. + * + * @return float result of polynomial at given location + */ +float psPolynomial3DEval( + float x, ///< x location at which to evaluate + float y, ///< y location at which to evaluate + float z, ///< z location at which to evaluate + const psPolynomial3D* myPoly ///< Coefficients for the polynomial +); + +/** Evaluates a 4-D polynomial at specific coordinates. + * + * @return float result of polynomial at given location + */ +float psPolynomial4DEval( + float w, ///< w location at which to evaluate + float x, ///< x location at which to evaluate + float y, ///< y location at which to evaluate + float z, ///< z location at which to evaluate + const psPolynomial4D* myPoly ///< Coefficients for the polynomial +); + +/*****************************************************************************/ + +/* Double-precision polynomials, mainly for use in astrometry */ + +/** Double-precision one-dimensional polynomial */ +typedef struct +{ + int n; ///< Number of terms + double *coeff; ///< Coefficients + double *coeffErr; ///< Error in coefficients + char *mask; ///< Coefficient mask +} +psDPolynomial1D; + +/** Double-precision two-dimensional polynomial */ +typedef struct +{ + int nX; ///< Number of terms in x + int nY; ///< Number of terms in y + double **coeff; ///< Coefficients + double **coeffErr; ///< Error in coefficients + char **mask; ///< Coefficients mask +} +psDPolynomial2D; + +/** Double-precision three-dimensional polynomial */ +typedef struct +{ + int nX; ///< Number of terms in x + int nY; ///< Number of terms in y + int nZ; ///< Number of terms in z + double ***coeff; ///< Coefficients + double ***coeffErr; ///< Error in coefficients + char ***mask; ///< Coefficient mask +} +psDPolynomial3D; + +/** Double-precision four-dimensional polynomial */ +typedef struct +{ + int nW; ///< Number of terms in w + int nX; ///< Number of terms in x + int nY; ///< Number of terms in y + int nZ; ///< Number of terms in z + double ****coeff; ///< Coefficients + double ****coeffErr; ///< Error in coefficients + char ****mask; ///< Coefficients mask +} +psDPolynomial4D; + +/** Allocates a double-precision 1-D polynomial structure with n terms + * + * @return psPolynomial1D* new double-precision 1-D polynomial struct + */ +psDPolynomial1D* psDPolynomial1DAlloc( + int n ///< Number of terms +); + +/** Allocates a double-precision 2-D polynomial structure + * + * @return psPolynomial2D* new double-precision 2-D polynomial struct + */ +psDPolynomial2D* psDPolynomial2DAlloc( + int nX, ///< Number of terms in x + int nY ///< Number of terms in y +); + +/** Allocates a double-precision 3-D polynomial structure + * + * @return psPolynomial3D* new double-precision 3-D polynomial struct + */ +psDPolynomial3D* psDPolynomial3DAlloc( + int nX, ///< Number of terms in x + int nY, ///< Number of terms in y + int nZ ///< Number of terms in z +); + +/** Allocates a double-precision 4-D polynomial structure + * + * @return psPolynomial4D* new double-precision 4-D polynomial struct + */ +psDPolynomial4D* psDPolynomial4DAlloc( + int nW, ///< Number of terms in w + int nX, ///< Number of terms in x + int nY, ///< Number of terms in y + int nZ ///< Number of terms in z +); + +/** Evaluates a double-precision 1-D polynomial at specific coordinates. + * + * @return float result of polynomial at given location + */ +double psDPolynomial1DEval( + double x, ///< Value at which to evaluate + const psDPolynomial1D* myPoly ///< Coefficients for the polynomial +); + +/** Evaluates a double-precision 2-D polynomial at specific coordinates. + * + * @return float result of polynomial at given location + */ +double psDPolynomial2DEval( + double x, ///< Value x at which to evaluate + double y, ///< Value y at which to evaluate + const psDPolynomial2D* myPoly ///< Coefficients for the polynomial +); + +/** Evaluates a double-precision 3-D polynomial at specific coordinates. + * + * @return float result of polynomial at given location + */ +double psDPolynomial3DEval( + double x, ///< Value x at which to evaluate + double y, ///< Value y at which to evaluate + double z, ///< Value z at which to evaluate + const psDPolynomial3D* myPoly ///< Coefficients for the polynomial +); + +/** Evaluates a double-precision 4-D polynomial at specific coordinates. + * + * @return float result of polynomial at given location + */ +double psDPolynomial4DEval( + double w, ///< Value w at which to evaluate + double x, ///< Value x at which to evaluate + double y, ///< Value y at which to evaluate + double z, ///< Value z at which to evaluate + const psDPolynomial4D* myPoly ///< Coefficients for the polynomial +); + +/* \} */// End of MathGroup Functions + +#endif Index: /tags/rel2_1/psLib/src/math/psStats.c =================================================================== --- /tags/rel2_1/psLib/src/math/psStats.c (revision 1553) +++ /tags/rel2_1/psLib/src/math/psStats.c (revision 1553) @@ -0,0 +1,1888 @@ + +/** @file psStats.c + * \brief basic statistical operations + * @ingroup Stats + * + * This file will hold the definition of the histogram and stats data + * structures. It also contains prototypes for procedures which operate + * on those data structures. + * + * @author George Gusciora, MHPCC + * + * @version $Revision: 1.53 $ $Name: not supported by cvs2svn $ + * @date $Date: 2004-08-09 23:34:57 $ + * + * Copyright 2004 Maui High Performance Computing Center, University of Hawaii + */ + +#include +#include +#include +#include +#include +#include + +/*****************************************************************************/ + +/* INCLUDE FILES */ + +/*****************************************************************************/ +#include "psMemory.h" +#include "psImage.h" +#include "psVector.h" +#include "psTrace.h" +#include "psError.h" +#include "psAbort.h" +#include "psStats.h" +#include "psMinimize.h" +#include "psFunctions.h" + +/*****************************************************************************/ + +/* DEFINE STATEMENTS */ + +/*****************************************************************************/ +// will use robust statistical methods. +#define GAUSS_WIDTH 20 // The width of the Gaussian or boxcar smoothing. +#define CLIPPED_NUM_ITER_LB 1 +#define CLIPPED_NUM_ITER_UB 10 +#define CLIPPED_SIGMA_LB 1.0 +#define CLIPPED_SIGMA_UB 10.0 +#define true 1 +#define false 0 +#define MY_MAX_FLOAT HUGE +#define MAX_ITERATIONS 10 + +void p_psVectorRobustStats(const psVector* restrict myVector, + const psVector* restrict maskVector, unsigned int maskVal, psStats* stats); + +/** Preprocessor macro to generate error on an incorrect type */ +#define PS_CHECK_VECTOR_TYPE(NAME, TYPE) \ +if (NAME->type.type != TYPE) { \ + psError(__func__,"Invalid operation: %s has incorrect type.", #NAME); \ +} + +/** Preprocessor macro to generate error on a NULL vector */ +#define PS_CHECK_NULL_VECTOR(NAME) \ +if (NAME == NULL || NAME->data.V == NULL) { \ + psError(__func__,"Invalid operation: %s or its data is NULL.", #NAME); \ +} + +/** Preprocessor macro to generate error for zero length vector */ +#define PS_CHECK_EMPTY_VECTOR(NAME) \ +if (NAME->n < 1) { \ + psError(__func__,"Invalid operation: %s has zero n value.", #NAME); \ +} + +/** Preprocessor macro to generate error on differing size vectors */ +#define PS_CHECK_VECTOR_SIZE_EQUAL(VEC1, VEC2) \ +if (VEC1->n != VEC2->n) { \ + psError(__func__,"Vector %s has size %d, Vector %s has size %d.", #VEC1, VEC1->n, #VEC2, VEC2->n); \ +} + +#define PS_PRINT_VECTOR(NAME) \ +for (int my_i=0;my_in;my_i++) { \ + printf("%s->data.F32[%d] is %f\n", #NAME, my_i, NAME->data.F32[my_i]); \ +} \ +printf("\n"); \ + + +/*****************************************************************************/ + +/* TYPE DEFINITIONS */ + +/*****************************************************************************/ + +/*****************************************************************************/ + +/* GLOBAL VARIABLES */ + +/*****************************************************************************/ + +// None + +/*****************************************************************************/ + +/* FILE STATIC VARIABLES */ + +/*****************************************************************************/ + +// None + +/*****************************************************************************/ + +/* FUNCTION IMPLEMENTATION - LOCAL */ + +/*****************************************************************************/ + +bool p_psGetStatValue(const psStats* stats, double *value) +{ + + switch (stats->options & ~(PS_STAT_USE_RANGE | PS_STAT_USE_BINSIZE | PS_STAT_ROBUST_FOR_SAMPLE)) { + case PS_STAT_SAMPLE_MEAN: + *value = stats->sampleMean; + return true; + + case PS_STAT_SAMPLE_MEDIAN: + *value = stats->sampleMedian; + return true; + + case PS_STAT_SAMPLE_STDEV: + *value = stats->sampleStdev; + return true; + + case PS_STAT_ROBUST_MEAN: + *value = stats->robustMean; + return true; + + case PS_STAT_ROBUST_MEDIAN: + *value = stats->robustMedian; + return true; + + case PS_STAT_ROBUST_MODE: + *value = stats->robustMode; + return true; + + case PS_STAT_ROBUST_STDEV: + *value = stats->robustStdev; + return true; + + case PS_STAT_CLIPPED_MEAN: + *value = stats->clippedMean; + return true; + + case PS_STAT_CLIPPED_STDEV: + *value = stats->clippedStdev; + return true; + + case PS_STAT_MAX: + *value = stats->max; + return true; + + case PS_STAT_MIN: + *value = stats->min; + return true; + + default: + return false; + } +} + +/***************************************************************************** +p_psVectorPrint(myVector, maskVector, maskVal, stats): a private internal +function that simply prints a vector to STDOUT. Used primarily for +debugging. + *****************************************************************************/ + +void p_psVectorPrint(psVector* myVector, psVector* maskVector, unsigned int maskVal, psStats* stats) +{ + int i = 0; // Loop index variable. + + for (i = 0; i < myVector->n; i++) { + if (maskVector != NULL) + printf("Element %d is %f (mask is %d)\n", i, myVector->data.F32[i], maskVector->data.U8[i]); + else + printf("Element %d is %f\n", i, myVector->data.F32[i]); + } +} + +/****************************************************************************** + ****************************************************************************** + ****************************************************************************** + MISC PRIVATE STATISTICAL FUNCTIONS + + NOTE: it is assumed that any call to these statistical functions will + have been preceded by a call to the psVectorStats() function. Various + sanity tests will only be performed in psVectorStats(). + Is the mask vector the same length as the data vector? + Is the mask vector of type PS_TYPE_U8? + Is the stats data structure NULL? + Is the in data structure NULL? + Is the in data structure of type PS_TYPE_F32? + ****************************************************************************** + ****************************************************************************** + *****************************************************************************/ + +/****************************************************************************** +p_psVectorSampleMean(myVector, maskVector, maskVal, stats): calculates the +mean of the input vector. +Inputs + myVector + maskVector + maskVal + stats +Returns + NULL +ASSUMPTION: the mean is always calculated exactly. Robust means are never +calculated in this routine. + *****************************************************************************/ + +void p_psVectorSampleMean(const psVector* restrict myVector, + const psVector* restrict maskVector, unsigned int maskVal, psStats* stats) +{ + int i = 0; // Loop index variable + float mean = 0.0; // The mean + int count = 0; // # of points in this mean? + float rangeMin = 0.0; // Exclude data below this + float rangeMax = 0.0; // Exclude date above this + + // If PS_STAT_USE_RANGE is requested, then we enter a slightly different + // loop. + if (stats->options & PS_STAT_USE_RANGE) { + rangeMin = stats->min; + rangeMax = stats->max; + if (maskVector != NULL) { + for (i = 0; i < myVector->n; i++) { + // Check if the data is with the specified range + if (!(maskVal & maskVector->data.U8[i]) && + (rangeMin <= myVector->data.F32[i]) && (myVector->data.F32[i] <= rangeMax)) { + mean += myVector->data.F32[i]; + count++; + } + } + mean /= (float)count; + } else { + for (i = 0; i < myVector->n; i++) { + if ((rangeMin <= myVector->data.F32[i]) && (myVector->data.F32[i] <= rangeMax)) { + mean += myVector->data.F32[i]; + count++; + } + } + mean /= (float)count; + } + } else { + if (maskVector != NULL) { + for (i = 0; i < myVector->n; i++) { + if (!(maskVal & maskVector->data.U8[i])) { + mean += myVector->data.F32[i]; + count++; + } + } + mean /= (float)count; + } else { + for (i = 0; i < myVector->n; i++) { + mean += myVector->data.F32[i]; + } + mean /= (float)myVector->n; + } + } + + stats->sampleMean = mean; +} + +/****************************************************************************** +p_psVectorSampleMax(myVector, maskVector, maskVal, stats): calculates the +max of the input vector. +Inputs + myVector + maskVector + maskVal + stats +Returns + NULL + *****************************************************************************/ +void p_psVectorMax(const psVector* restrict myVector, + const psVector* restrict maskVector, unsigned int maskVal, psStats* stats) +{ + int i = 0; // Loop index variable + float max = -MY_MAX_FLOAT; // The calculated maximum + float rangeMin = 0.0; // Exclude data below this + float rangeMax = 0.0; // Exclude date above this + + // If PS_STAT_USE_RANGE is requested, then we enter a different loop. + if (stats->options & PS_STAT_USE_RANGE) { + rangeMin = stats->min; + rangeMax = stats->max; + if (maskVector != NULL) { + for (i = 0; i < myVector->n; i++) { + if (!(maskVal & maskVector->data.U8[i])) { + if ((myVector->data.F32[i] > max) && + (rangeMin <= myVector->data.F32[i]) && (myVector->data.F32[i] <= rangeMax)) { + max = myVector->data.F32[i]; + } + } + } + } else { + for (i = 0; i < myVector->n; i++) { + if ((myVector->data.F32[i] > max) && + (rangeMin <= myVector->data.F32[i]) && (myVector->data.F32[i] <= rangeMax)) { + max = myVector->data.F32[i]; + } + } + } + } else { + if (maskVector != NULL) { + for (i = 0; i < myVector->n; i++) { + if (!(maskVal & maskVector->data.U8[i])) { + if (myVector->data.F32[i] > max) { + max = myVector->data.F32[i]; + } + } + } + } else { + for (i = 0; i < myVector->n; i++) { + if (myVector->data.F32[i] > max) { + max = myVector->data.F32[i]; + } + } + } + } + + stats->max = max; +} + +/****************************************************************************** +p_psVectorSampleMin(myVector, maskVector, maskVal, stats): calculates the +minimum of the input vector. +Inputs + myVector + maskVector + maskVal + stats +Returns + NULL + *****************************************************************************/ +void p_psVectorMin(const psVector* restrict myVector, + const psVector* restrict maskVector, unsigned int maskVal, psStats* stats) +{ + int i = 0; // Loop index variable + float min = MY_MAX_FLOAT; // The calculated maximum + float rangeMin = 0.0; // Exclude data below this + float rangeMax = 0.0; // Exclude date above this + + if (stats->options & PS_STAT_USE_RANGE) { + rangeMin = stats->min; + rangeMax = stats->max; + if (maskVector != NULL) { + for (i = 0; i < myVector->n; i++) { + if (!(maskVal & maskVector->data.U8[i])) { + if ((myVector->data.F32[i] < min) && + (rangeMin <= myVector->data.F32[i]) && (myVector->data.F32[i] <= rangeMax)) { + min = myVector->data.F32[i]; + } + } + } + } else { + for (i = 0; i < myVector->n; i++) { + if ((myVector->data.F32[i] < min) && + (rangeMin <= myVector->data.F32[i]) && (myVector->data.F32[i] <= rangeMax)) { + min = myVector->data.F32[i]; + } + } + } + } else { + if (maskVector != NULL) { + for (i = 0; i < myVector->n; i++) { + if (!(maskVal & maskVector->data.U8[i])) { + if (myVector->data.F32[i] < min) { + min = myVector->data.F32[i]; + } + } + } + } else { + for (i = 0; i < myVector->n; i++) { + if (myVector->data.F32[i] < min) { + min = myVector->data.F32[i]; + } + } + } + } + + stats->min = min; +} + +/****************************************************************************** +p_psVectorNValues(myVector, maskVector, maskVal, stats): calculates the +number of non-masked pixels in the vector that fall within the min/max +range, if given. +Inputs + myVector + maskVector + maskVal + stats +Returns + NULL + *****************************************************************************/ +int p_psVectorNValues(const psVector* restrict myVector, + const psVector* restrict maskVector, unsigned int maskVal, psStats* stats) +{ + int i = 0; // Loop index variable + int numData = 0; // The number of data points + float rangeMin = 0.0; // Exclude data below this + float rangeMax = 0.0; // Exclude date above this + + if (stats->options & PS_STAT_USE_RANGE) { + rangeMin = stats->min; + rangeMax = stats->max; + if (maskVector != NULL) { + for (i = 0; i < myVector->n; i++) { + if (!(maskVal & maskVector->data.U8[i]) && + (rangeMin <= myVector->data.F32[i]) && (myVector->data.F32[i] <= rangeMax)) { + numData++; + } + } + } else { + for (i = 0; i < myVector->n; i++) { + if ((rangeMin <= myVector->data.F32[i]) && (myVector->data.F32[i] <= rangeMax)) { + numData++; + } + } + } + } else { + rangeMin = stats->min; + rangeMax = stats->max; + if (maskVector != NULL) { + for (i = 0; i < myVector->n; i++) { + if (!(maskVal & maskVector->data.U8[i])) { + numData++; + } + } + } else { + numData = myVector->n; + } + } + return (numData); +} + +/****************************************************************************** +p_psVectorSampleMedian(myVector, maskVector, maskVal, stats): calculates the +median of the input vector. +Inputs + myVector + maskVector + maskVal + stats +Returns + NULL + *****************************************************************************/ +void p_psVectorSampleMedian(const psVector* restrict myVector, + const psVector* restrict maskVector, unsigned int maskVal, psStats* stats) +{ + psVector* unsortedVector = NULL; // Temporary vector + psVector* sortedVector = NULL; // Temporary vector + int i = 0; // Loop index variable + int count = 0; // # of points in this mean? + int nValues = 0; // # of points in vector + float rangeMin = 0.0; // Exclude data below this + float rangeMax = 0.0; // Exclude date above this + + // Determine if the number of data points exceed a threshold which will + // cause to generate robust stats, as opposed to exact stats. + // XXX: This code is no longer used. We now calculate the median exactly + // regardless of the vector size. + /* + * if (myVector->n > stats->sampleLimit) { psAbort(__func__, "Robust Statistic Algorithms have not yet + * been defined or implemented."); + * + * // Calculate the robust quartiles. stats2 = psStatsAlloc(PS_STAT_ROBUST_MEDIAN); + * p_psVectorRobustStats(myVector, maskVector, maskVal, stats2); + * + * // Store the robust quartiles into the sample quartile members. stats->sampleMedian = + * stats2->robustMedian; + * + * // Free temporary data buffers. psFree(stats2); + * + * // Set the PS_STAT_ROBUST_FOR_SAMPLE bit in the stats structure. stats->options = stats->options | + * PS_STAT_ROBUST_FOR_SAMPLE; + * + * return; } */ + + // Determine how many data points fit inside this min/max range + // and are not masked, IF the maskVector is not NULL> + nValues = p_psVectorNValues(myVector, maskVector, maskVal, stats); + + // Allocate temporary vectors for the data. + unsortedVector = psVectorAlloc(nValues, PS_TYPE_F32); + unsortedVector->n = unsortedVector->nalloc; + + sortedVector = psVectorAlloc(nValues, PS_TYPE_F32); + sortedVector->n = sortedVector->nalloc; + + // Determine if we must only use data points within a min/max range. + if (stats->options & PS_STAT_USE_RANGE) { + rangeMin = stats->min; + rangeMax = stats->max; + + // Store all non-masked data points within the min/max range + // into the temporary vectors. + count = 0; + if (maskVector != NULL) { + for (i = 0; i < myVector->n; i++) { + if (!(maskVal & maskVector->data.U8[i]) && + (rangeMin <= myVector->data.F32[i]) && (myVector->data.F32[i] <= rangeMax)) { + unsortedVector->data.F32[count++] = maskVector->data.F32[i]; + } + } + } else { + for (i = 0; i < myVector->n; i++) { + if ((rangeMin <= myVector->data.F32[i]) && (myVector->data.F32[i] <= rangeMax)) { + unsortedVector->data.F32[count++] = myVector->data.F32[i]; + } + } + } + } else { + // Store all non-masked data points into the temporary vectors. + count = 0; + if (maskVector != NULL) { + for (i = 0; i < myVector->n; i++) { + if (!(maskVal & maskVector->data.U8[i])) { + unsortedVector->data.F32[count++] = myVector->data.F32[i]; + } + } + } else { + for (i = 0; i < myVector->n; i++) { + unsortedVector->data.F32[i] = myVector->data.F32[i]; + } + } + } + // Sort the temporary vectors. + psVectorSort(sortedVector, unsortedVector); + + // Calculate the median exactly. + // XXX: Is this the correct action? + if (0 == (nValues % 2)) { + stats->sampleMedian = 0.5 * (sortedVector->data.F32[(nValues / 2) - 1] + + sortedVector->data.F32[nValues / 2]); + } else { + stats->sampleMedian = sortedVector->data.F32[nValues / 2]; + } + + // Free the temporary data structures. + psFree(unsortedVector); + psFree(sortedVector); +} + +/****************************************************************************** + This routine smoothes the data in the input robustHistogram with a + Gaussian of width sigma. + + XXX: Must consult with IfA on the proper values for the Gaussian + smoothing. Currently, the Gaussian coefficients are such that only + the center coefficient is non-zero. This is because "e" is being + raised to a very large negative number for all points except the + center point. + + XXX: use a static variable for gaussianCoefs[] and compute them once. + *****************************************************************************/ +psVector* p_psVectorsmoothHistGaussian(psHistogram* robustHistogram, float sigma) +{ + int i = 0; // Loop index variable + int j = 0; // Loop index variable + float denom = 0.0; // Temporary variable + float expo = 0.0; // Temporary variable + float gaussianCoefs[1 + (2 * GAUSS_WIDTH)]; // The Gaussian Coefficients + psVector* smooth = psVectorAlloc(robustHistogram->nums->n, PS_TYPE_F32); + + for (i = 0; i < (1 + (2 * GAUSS_WIDTH)); i++) { + if (fabs(sigma) >= FLT_EPSILON) { + // If sigma does not equal zero, then we use Gaussian smoothing. + #ifdef DARWIN + denom = (float)sqrt(2.0 * M_PI * sigma * sigma); + #else + + denom = sqrtf(2.0 * M_PI * sigma * sigma); + #endif + + expo = -(float)((i - GAUSS_WIDTH) * (i - GAUSS_WIDTH)); + expo /= (2.0 * sigma * sigma); + gaussianCoefs[i] = exp(expo / denom); + + // NOTE: Gaussian smoothing just isn't working with low sigma + // values. The problem is that the Gaussian coefficients are + // all zero, except for the middle coefficient, which is exactly + // one. Therefore, I'm using boxcar smoothing. + gaussianCoefs[i] = 1.0 / (1.0 + (2.0 * (float)GAUSS_WIDTH)); + // printf("gaussianCoefs[%d] is %f\n", i, gaussianCoefs[i]); + } else { + /* If sigma equals zero (all pixels have the same value) the above code will divide by zero. + * Therefore, we don't need to smooth the data. */ + for (i = 0; i < robustHistogram->nums->n; i++) { + smooth->data.F32[i] = (float)robustHistogram->nums->data.S32[i]; + } + return (smooth); + } + } + + // Perform the actual smoothing. + for (i = 0; i < robustHistogram->nums->n; i++) { + smooth->data.F32[i] = 0.0; + for (j = -GAUSS_WIDTH; j <= +GAUSS_WIDTH; j++) { + if (((j + i) >= 0) && ((j + i) < smooth->n)) { + smooth->data.F32[i] += (gaussianCoefs[j + GAUSS_WIDTH] * + (float)robustHistogram->nums->data.S32[j + i]); + } + } + } + return (smooth); +} + +/****************************************************************************** +p_psVectorSampleQuartiles(myVector, maskVector, maskVal, stats): calculates +the upper and/or lower quartiles of the input vector. +Inputs + myVector + maskVector + maskVal + stats +Returns + NULL + *****************************************************************************/ +void p_psVectorSampleQuartiles(const psVector* restrict myVector, + const psVector* restrict maskVector, unsigned int maskVal, psStats* stats) +{ + psVector* unsortedVector = NULL; // Temporary vector + psVector* sortedVector = NULL; // Temporary vector + int i = 0; // Loop index variable + int count = 0; // # of points in this mean? + int nValues = 0; // # data points + float rangeMin = 0.0; // Exclude data below this + float rangeMax = 0.0; // Exclude date above this + + // Determine how many data points fit inside this min/max range + // and are not maxed, IF the maskVector is not NULL> + nValues = p_psVectorNValues(myVector, maskVector, maskVal, stats); + + // Allocate temporary vectors for the data. + unsortedVector = psVectorAlloc(nValues, PS_TYPE_F32); + unsortedVector->n = unsortedVector->nalloc; + sortedVector = psVectorAlloc(nValues, PS_TYPE_F32); + sortedVector->n = sortedVector->nalloc; + + // Determine if we must only use data points within a min/max range. + if (stats->options & PS_STAT_USE_RANGE) { + rangeMin = stats->min; + rangeMax = stats->max; + // Store all non-masked data points within the min/max range + // into the temporary vectors. + count = 0; + if (maskVector != NULL) { + for (i = 0; i < myVector->n; i++) { + if (!(maskVal & maskVector->data.U8[i]) && + (rangeMin <= myVector->data.F32[i]) && (myVector->data.F32[i] <= rangeMax)) { + unsortedVector->data.F32[count++] = myVector->data.F32[i]; + } + } + } else { + for (i = 0; i < myVector->n; i++) { + if ((rangeMin <= myVector->data.F32[i]) && (myVector->data.F32[i] <= rangeMax)) { + unsortedVector->data.F32[count++] = myVector->data.F32[i]; + } + } + } + } else { + // Store all non-masked data points into the temporary vectors. + count = 0; + if (maskVector != NULL) { + for (i = 0; i < myVector->n; i++) { + if (!(maskVal & maskVector->data.U8[i])) { + unsortedVector->data.F32[count++] = myVector->data.F32[i]; + } + } + } else { + for (i = 0; i < myVector->n; i++) { + unsortedVector->data.F32[i] = myVector->data.F32[i]; + } + } + } + + // Sort the temporary vectors. + psVectorSort(sortedVector, unsortedVector); + + // Calculate the quartile points exactly. + stats->sampleUQ = sortedVector->data.F32[3 * (nValues / 4)]; + stats->sampleLQ = sortedVector->data.F32[nValues / 4]; + + // Free the temporary data structures. + psFree(unsortedVector); + psFree(sortedVector); +} + +/****************************************************************************** +p_psVectorSampleStdev(myVector, maskVector, maskVal, stats): calculates the +stdev of the input vector. +Inputs + myVector + maskVector + maskVal + stats +Returns + NULL + + *****************************************************************************/ +void p_psVectorSampleStdev(const psVector* restrict myVector, + const psVector* restrict maskVector, unsigned int maskVal, psStats* stats) +{ + int i = 0; // Loop index variable + int countInt = 0; // # of data points being used + float countFloat = 0.0; // # of data points being used + float mean = 0.0; // The mean + float diff = 0.0; // Used in calculating stdev + float sumSquares = 0.0; // temporary variable + float sumDiffs = 0.0; // temporary variable + float rangeMin = 0.0; // Exclude data below this + float rangeMax = 0.0; // Exclude date above this + + // This procedure requires the mean. If it has not been already + // calculated, then call p_psVectorSampleMean() + if (0 != isnan(stats->sampleMean)) { + p_psVectorSampleMean(myVector, maskVector, maskVal, stats); + } + mean = stats->sampleMean; + + if (stats->options & PS_STAT_USE_RANGE) { + if (maskVector != NULL) { + for (i = 0; i < myVector->n; i++) { + if (!(maskVal & maskVector->data.U8[i]) && + (rangeMin <= myVector->data.F32[i]) && (myVector->data.F32[i] <= rangeMax)) { + diff = myVector->data.F32[i] - mean; + sumSquares += (diff * diff); + sumDiffs += diff; + countInt++; + } + } + } else { + for (i = 0; i < myVector->n; i++) { + if ((rangeMin <= myVector->data.F32[i]) && (myVector->data.F32[i] <= rangeMax)) { + diff = myVector->data.F32[i] - mean; + sumSquares += (diff * diff); + sumDiffs += diff; + countInt++; + } + } + countInt = myVector->n; + } + } else { + if (maskVector != NULL) { + for (i = 0; i < myVector->n; i++) { + if (!(maskVal & maskVector->data.U8[i])) { + diff = myVector->data.F32[i] - mean; + sumSquares += (diff * diff); + sumDiffs += diff; + countInt++; + } + } + } else { + for (i = 0; i < myVector->n; i++) { + diff = myVector->data.F32[i] - mean; + sumSquares += (diff * diff); + sumDiffs += diff; + countInt++; + } + countInt = myVector->n; + } + } + countFloat = (float)countInt; + + #ifdef DARWIN + + stats->sampleStdev = (float)sqrt((sumSquares - (sumDiffs * sumDiffs / countFloat)) / (countFloat - 1)); + #else + + stats->sampleStdev = sqrtf((sumSquares - (sumDiffs * sumDiffs / countFloat)) / (countFloat - 1)); + #endif +} + +/****************************************************************************** +p_psVectorClippedStats(myVector, maskVector, maskVal, stats): calculates the +clipped stats (mean or stdev) of the input vector. + +Inputs + myVector + maskVector + maskVal + stats +Returns + NULL + *****************************************************************************/ +void p_psVectorClippedStats(const psVector* restrict myVector, + const psVector* restrict maskVector, unsigned int maskVal, psStats* stats) +{ + int i = 0; // Loop index variable + int j = 0; // Loop index variable + float clippedMean = 0.0; // self-explanatory + float clippedStdev = 0.0; // self-explanatory + float oldStanMean = 0.0; // Temporary variable + float oldStanStdev = 0.0; // Temporary variable + psVector* tmpMask = NULL; // Temporary vector + + // Endure that stats->clipIter is within the proper range. + if (!((CLIPPED_NUM_ITER_LB <= stats->clipIter) && (stats->clipIter <= CLIPPED_NUM_ITER_UB))) { + psAbort(__func__, "Unallowed value for clipIter (%d).\n", stats->clipIter); + } + // Endure that stats->clipSigma is within the proper range. + if (!((CLIPPED_SIGMA_LB <= stats->clipSigma) && (stats->clipSigma <= CLIPPED_SIGMA_UB))) { + psAbort(__func__, "Unallowed value for clipSigma (%f).\n", stats->clipSigma); + } + // We allocate a temporary mask vector since during the iterative + // steps that follow, we will be masking off additional data points. + // However, we do no want to modify the original mask vector. + tmpMask = psVectorAlloc(myVector->n, PS_TYPE_U8); + tmpMask->n = myVector->n; + + // If we were called with a mask vector, then initialize the temporary + // mask vector with those values. + if (maskVector != NULL) { + for (i = 0; i < tmpMask->n; i++) { + tmpMask->data.U8[i] = maskVector->data.U8[i]; + } + } + // 1. Compute the sample median. + // NOTE: This seems odd. Verify with IfA that we want to calculate the + // median here, not the mean. + p_psVectorSampleMedian(myVector, maskVector, maskVal, stats); + + // 2. Compute the sample standard deviation. + p_psVectorSampleStdev(myVector, maskVector, maskVal, stats); + + // 3. Use the sample median as the first estimator of the mean X. + clippedMean = stats->sampleMean; + + // 4. Use the sample stdev as the first estimator of the mean stdev. + clippedStdev = stats->sampleStdev; + + // Must save the old sampleMean and sampleStdev since the following code + // block overwrites them. + oldStanMean = stats->sampleMean; + oldStanStdev = stats->sampleStdev; + + // 5. Repeat N times: + for (i = 0; i < stats->clipIter; i++) { + for (j = 0; j < myVector->n; j++) { + // a) Exclude all values x_i for which |x_i - x| > K * stdev + if (fabs(myVector->data.F32[j] - clippedMean) > (stats->clipSigma * clippedStdev)) { + tmpMask->data.U8[i] = 0xff; + } + // b) compute new mean and stdev + p_psVectorSampleMedian(myVector, tmpMask, maskVal, stats); + p_psVectorSampleStdev(myVector, tmpMask, maskVal, stats); + + // c) Use the new mean for x + clippedMean = stats->sampleMean; + + // d) Use the new stdev for stdev + clippedStdev = stats->sampleStdev; + } + + } + stats->sampleMean = oldStanMean; + stats->sampleStdev = oldStanStdev; + + // 7. The last calcuated value of x is the cliped mean. + if (stats->options & PS_STAT_CLIPPED_MEAN) { + stats->clippedMean = clippedMean; + } + // 8. The last calcuated value of stdev is the cliped stdev. + if (stats->options & PS_STAT_CLIPPED_STDEV) { + stats->clippedStdev = clippedStdev; + } + + psFree(tmpMask); +} + +/***************************************************************************** +p_psNormalizeVector(myData): this is a private function which normalizes the +elements of a vector to a range between 0.0 and 1.0. + *****************************************************************************/ +void p_psNormalizeVector(psVector* myData) +{ + float min = (float)HUGE; + float max = (float)-HUGE; + float range = 0.0; + int i = 0; + + for (i = 0; i < myData->n; i++) { + if (myData->data.F32[i] < min) { + min = myData->data.F32[i]; + } + if (myData->data.F32[i] > max) { + max = myData->data.F32[i]; + } + } + + range = max - min; + for (i = 0; i < myData->n; i++) { + myData->data.F32[i] = (myData->data.F32[i] - min) / range; + } +} + +/***************************************************************************** +p_psGaussian(myData, myParams): an internal function, used by robust stats, +intended to compute the Gaussian with a specified sigma/mean, at the +specified data point. + *****************************************************************************/ +float p_psGaussian(const psVector* restrict myData, const psVector* restrict myParams) +{ + float x = myData->data.F32[0]; + float mean = myParams->data.F32[0]; + float stdev = myParams->data.F32[1]; + float tmp = exp(-((x - mean) * (x - mean)) / (2.0 * stdev * stdev)); + + tmp /= ((float)sqrt(2.0 * M_PI * (stdev * stdev))); + + // printf("p_psGaussian((%.2f), %.2f, %.2f) is %.2f\n", x, mean, stdev, tmp); + return (tmp); +} + +/***************************************************************************** +p_psGaussianDeriv(myData, myParams, whichParam): an internal function, which +calculates the specified partial derivative of the above Gaussian function. + *****************************************************************************/ +float p_psGaussianDeriv(const psVector* restrict myData, const psVector* restrict myParams, int whichParam) +{ + float x = myData->data.F32[0]; + float mean = myParams->data.F32[0]; + float stdev = myParams->data.F32[1]; + float tmp = 0.0; + + if (whichParam == 0) { + // Return the derivative w.r.t. the mean. + tmp = (x - mean) * p_psGaussian(myData, myParams); + tmp /= (stdev * stdev); + } else if (whichParam == 1) { + // Return the derivative w.r.t. the stdev. + tmp = (x - mean) * (x - mean) * p_psGaussian(myData, myParams); + tmp /= (stdev * stdev * stdev); + } + printf("p_psGaussianDeriv((%.2f), %.2f, %.2f, (%d)) is %.2f\n", x, mean, stdev, whichParam, tmp); + + return (tmp); +} + +/***************************************************************************** +p_psQuadratic(myData, myParams): an internal function, used by robust stats, +intended to compute a quadratic, with the specified parameters, at the +specified data point. + *****************************************************************************/ +float p_psQuadratic(const psVector* restrict myParams, const psVector* restrict myCoords) +{ + float x = myCoords->data.F32[0]; + float A = myParams->data.F32[0]; + float B = myParams->data.F32[1]; + float C = myParams->data.F32[2]; + float tmp = 0.0; + + tmp = (A * x * x) + (B * x) + C; + return (tmp); +} + +/***************************************************************************** +p_psQuadraticDeriv(myData, myParams, whichParam): an internal function, which +calculates the specified partial derivative of the above quadratic function. + *****************************************************************************/ +float p_psQuadraticDeriv(const psVector* restrict myParams, + const psVector* restrict myCoords, int whichParamDeriv) +{ + float x = myCoords->data.F32[0]; + float tmp = 0.0; + + if (whichParamDeriv == 0) { + tmp = x * x; + } else if (whichParamDeriv == 1) { + tmp = x; + } else if (whichParamDeriv == 2) { + tmp = 1.0; + } + + return (tmp); +} + +/****************************************************************************** +p_ps1DPolyMedian(myPoly, rangeLow, rangeHigh, midpoint): This routine takes +as input a 1-D polynomial of arbitrary order (though we are using 2nd-order +polynomials here) and a range of x-values for which it is defined: +[rangeLow, rangeHigh]. It determines the x-value of that polynomial such +that f(x) == midpoint. This functions uses a binary-search algorithm on the +range and assumes that the polynomial is monotonically increasing or +decreasing within that range. + *****************************************************************************/ +float p_ps1DPolyMedian(psPolynomial1D* myPoly, float rangeLow, float rangeHigh, float getThisValue) +{ + int numIterations = 0; + float midpoint = 0.0; + float oldMidpoint = 1.0; + float f = 0.0; + + // printf("p_ps1DPolyMedian(%f, %f, %f) \n", rangeLow, rangeHigh, getThisValue); + + while (numIterations < MAX_ITERATIONS) { + midpoint = (rangeHigh + rangeLow) / 2.0; + if (fabs(midpoint - oldMidpoint) <= FLT_EPSILON) { + return (midpoint); + } + oldMidpoint = midpoint; + + f = psPolynomial1DEval(midpoint, myPoly); + // printf("p_ps1DPolyMedian() iteration %d. f(%f) is %f\n", numIterations, midpoint, f); + if (fabs(f - getThisValue) <= FLT_EPSILON) { + return (midpoint); + } + + if (f > getThisValue) { + rangeHigh = midpoint; + } else { + rangeLow = midpoint; + } + numIterations++; + } + return (midpoint); +} + +/****************************************************************************** +p_psFitQuadratic(robustHistogram. cumulativeSums, binNum, fitFloat): given +the specified histogram, with the specified pre-calculated cumulativeSums, +this routine fits a quadratic f(x) to the 3 bins surrounding bin "binNum", +and then finds the point x such that f(x) == fitFloat. + +XXX: This function is currently not being used. + *****************************************************************************/ +float p_psFitQuadratic(psHistogram* histogram, psVector* cumulativeSums, int binNum, float fitFloat) +{ + psVector* x = psVectorAlloc(3, PS_TYPE_F64); + psVector* y = psVectorAlloc(3, PS_TYPE_F64); + psVector* yErr = psVectorAlloc(3, PS_TYPE_F64); + psPolynomial1D* myPoly = psPolynomial1DAlloc(2); + + if ((binNum > 0) && (binNum < (histogram->nums->n + 1))) { + x->data.F64[0] = (double)0.5 * + (histogram->bounds->data.F32[binNum - 1] + histogram->bounds->data.F32[binNum]); + x->data.F64[1] = (double)0.5 * + (histogram->bounds->data.F32[binNum] + histogram->bounds->data.F32[binNum + 1]); + x->data.F64[2] = (double)0.5 * + (histogram->bounds->data.F32[binNum + 1] + histogram->bounds->data.F32[binNum + 2]); + + y->data.F64[0] = cumulativeSums->data.F32[binNum - 1]; + y->data.F64[1] = cumulativeSums->data.F32[binNum]; + y->data.F64[2] = cumulativeSums->data.F32[binNum + 1]; + + if (!((y->data.F64[0] <= fitFloat) && (fitFloat <= y->data.F64[2]))) { + psAbort(__func__, "p_psVectorRobustStats(0): midpoint not within y-range\n"); + } + + yErr->data.F64[0] = 1.0; + yErr->data.F64[1] = 1.0; + yErr->data.F64[2] = 1.0; + + myPoly = psVectorFitPolynomial1D(myPoly, x, y, yErr); + return (p_ps1DPolyMedian(myPoly, x->data.F64[0], x->data.F64[2], fitFloat)); + } else { + return (0.5 * (histogram->bounds->data.F32[binNum + 1] + histogram->bounds->data.F32[binNum])); + } + + psFree(x); + psFree(y); + psFree(yErr); + psFree(myPoly); + return (0.0); +} + +/****************************************************************************** +p_psVectorRobustStats(myVector, maskVector, maskVal, stats): this procedure +calculates a variety of robust stat measures: + PS_STAT_ROBUST_MEAN + PS_STAT_ROBUST_MEDIAN + PS_STAT_ROBUST_MODE + PS_STAT_ROBUST_STDEV + PS_STAT_ROBUST_QUARTILE +I have included all that computation in a single function, as opposed to +breaking it across several functions for one primary reason: they all +require the same basic initial processing steps (calculate the histogram, +etc.) however there is no currently defined means, in the SDRS, to specify +this computation as a separate step. If the above robust stat measures were +calcualted in separate functiosn, then much of the initial processing would +be duplicated. + +Inputs + myVector + maskVector + maskVal + stats +Returns + NULL +*****************************************************************************/ +void p_psVectorRobustStats(const psVector* restrict myVector, + const psVector* restrict maskVector, unsigned int maskVal, psStats* stats) +{ + psHistogram* robustHistogram = NULL; + psVector* robustHistogramVector = NULL; + float binSize = 0.0; // Size of the histogram bins + int LQBinNum = -1; // Bin num for lower quartile + int UQBinNum = -1; // Bin num for upper quartile + int i = 0; // Loop index variable + int maxBinNum = 0; + float maxBinCount = 0.0; + float dL = 0.0; + int numBins = 0; + psStats* tmpStats = psStatsAlloc(PS_STAT_CLIPPED_STDEV | PS_STAT_CLIPPED_MEAN); + + // psImage* domain; + // psVector* errors; + // psVector* data; + // psVector* initialGuess; + // psVector* theParams; + // float chiSq=0.0; + // float max = -HUGE; + // float max_pos; + float myMean = 0.0; + float myStdev = 0.0; + float countFloat = 0.0; + float diff = 0.0; + float sumSquares = 0.0; + float sumDiffs = 0.0; + psVector* x = psVectorAlloc(3, PS_TYPE_F64); + psVector* y = psVectorAlloc(3, PS_TYPE_F64); + psVector* yErr = psVectorAlloc(3, PS_TYPE_F64); + psPolynomial1D* myPoly = psPolynomial1DAlloc(2); + psVector* cumulativeRobustSumsFullRange = NULL; + psVector* cumulativeRobustSumsDlRange = NULL; + float sumRobust = 0.0; + float sumN50 = 0.0; + float sumNfit = 0.0; + float cumulativeMedian = 0.0; + + // Compute the initial bin size of the robust histogram. This is done + // by computing the clipped standard deviation of the vector, and dividing + // that by 10.0; + p_psVectorClippedStats(myVector, maskVector, maskVal, tmpStats); + binSize = tmpStats->clippedStdev / 10.0f; + + // If stats->clippedStdev == 0.0, then all data elements have the same + // value. Therefore, we can set the appropiate results and return. + if (fabs(binSize) <= FLT_EPSILON) { + if (stats->options & PS_STAT_ROBUST_MEAN) { + stats->robustMean = stats->clippedMean; + } + if (stats->options & PS_STAT_ROBUST_MEDIAN) { + stats->robustMedian = stats->clippedMean; + } + if (stats->options & PS_STAT_ROBUST_MODE) { + stats->robustMode = stats->clippedMean; + } + if (stats->options & PS_STAT_ROBUST_STDEV) { + stats->robustStdev = 0.0; + } + if (stats->options & PS_STAT_ROBUST_QUARTILE) { + stats->robustUQ = stats->clippedMean; + stats->robustLQ = stats->clippedMean; + } + // XXX: Set these to the number of unmasked data points? + stats->robustNfit = 0.0; + stats->robustN50 = 0.0; + psFree(tmpStats); + return; + } + // Determine minimum and maximum values in the data vector. + if (isnan(stats->min)) { + p_psVectorMin(myVector, maskVector, maskVal, stats); + } + if (isnan(stats->max)) { + p_psVectorMax(myVector, maskVector, maskVal, stats); + } + // Create the histogram structure. NOTE: we can not specify the bin size + // precisely since the argument to psHistogramAlloc() is the number of + // bins, not the binSize. Also, if we get here, we know that + // binSize != 0.0. + numBins = (int)((stats->max - stats->min) / binSize); + robustHistogram = psHistogramAlloc(stats->min, stats->max, numBins); + + // Populate the histogram array. + psVectorHistogram(robustHistogram, myVector, maskVector, maskVal); + + // Smooth the histogram. + // XXX: is that the right stdev? + robustHistogramVector = p_psVectorsmoothHistGaussian(robustHistogram, tmpStats->clippedStdev / 4.0f); + + // The following was necessary to fit a gaussian to the data, since + // gaussian functions produce data between 0.0 and 1.0. + // p_psNormalizeVector(robustHistogramVector); + + /************************************************************************** + Determine the lower/upper quartiles. + **************************************************************************/ + // We define a vector called "cumulativeRobustSums..." where the value at + // index position i is equal to the sum of bins 0:i. This will be used + // now and later in determining the lower/upper quartiles. + cumulativeRobustSumsFullRange = psVectorAlloc(robustHistogramVector->n, PS_TYPE_F32); + cumulativeRobustSumsFullRange->data.F32[0] = robustHistogramVector->data.F32[0]; + for (i = 1; i < robustHistogramVector->n; i++) { + cumulativeRobustSumsFullRange->data.F32[i] = + cumulativeRobustSumsFullRange->data.F32[i - 1] + robustHistogramVector->data.F32[i]; + } + sumRobust = cumulativeRobustSumsFullRange->data.F32[robustHistogramVector->n - 1]; + + // Determine the bin number containing the lower quartile point. + LQBinNum = -1; + for (i = 0; i < cumulativeRobustSumsFullRange->n; i++) { + if (cumulativeRobustSumsFullRange->data.F32[i] >= (sumRobust / 4.0)) { + LQBinNum = i; + break; + } + } + + // Determine the bin number containing the upper quartile point. + UQBinNum = -1; + for (i = cumulativeRobustSumsFullRange->n - 1; i >= 0; i--) { + if (cumulativeRobustSumsFullRange->data.F32[i] <= (3.0 * sumRobust / 4.0)) { + UQBinNum = i; + break; + } + } + + if ((LQBinNum == -1) || (UQBinNum == -1)) { + psAbort(__func__, "Could not determine the robust lower/upper quartiles."); + } + + /************************************************************************** + Determine the mode in the range LQ:UQ. + **************************************************************************/ + // Determine the bin with the peak value in the range LQ to UQ. + maxBinNum = LQBinNum; + maxBinCount = robustHistogramVector->data.F32[LQBinNum]; + sumN50 = (float)robustHistogram->nums->data.S32[LQBinNum]; + for (i = LQBinNum + 1; i <= UQBinNum; i++) { + if (robustHistogramVector->data.F32[i] > maxBinCount) { + maxBinNum = i; + maxBinCount = robustHistogramVector->data.F32[i]; + } + sumN50 += (float)robustHistogram->nums->data.S32[i]; + } + + // XXX: is dL defined as the value at the LQ/UQ, or the bin number? + dL = (UQBinNum - LQBinNum) / 4; + + printf("(LQBinNum, UQBinNum, maxBinNum) is (%d, %d, %d)\n", LQBinNum, UQBinNum, maxBinNum); + + /************************************************************************** + Determine the mean/stdev for the bins in the range mode-dL to mode+dL + **************************************************************************/ + cumulativeRobustSumsDlRange = psVectorAlloc(robustHistogramVector->n, PS_TYPE_F32); + for (i = 0; i < robustHistogramVector->n; i++) { + cumulativeRobustSumsDlRange->data.F32[i] = 0.0; + } + sumNfit = 0.0; + cumulativeMedian = 0.0; + for (i = maxBinNum - dL; i <= maxBinNum + dL; i++) { + if ((0 <= i) && (i < robustHistogramVector->n)) { + cumulativeRobustSumsDlRange->data.F32[i] = + cumulativeRobustSumsDlRange->data.F32[i - 1] + robustHistogramVector->data.F32[i]; + cumulativeMedian += robustHistogramVector->data.F32[i]; + sumNfit += (float)robustHistogram->nums->data.S32[i]; + } + } + + // Calculate the mean of the smoothed robust histogram in the range + // mode-dL to mode+dL. We use the midpoint of each bin as the mean for + // that bin (this is a non-exact approximation). + myMean = 0.0; + for (i = maxBinNum - dL; i <= maxBinNum + dL; i++) { + if ((0 <= i) && (i < robustHistogramVector->n)) { + myMean += (robustHistogramVector->data.F32[i]) * 0.5 * + (robustHistogram->bounds->data.F32[i + 1] + robustHistogram->bounds->data.F32[i]); + countFloat += robustHistogramVector->data.F32[i]; + } + } + myMean /= countFloat; + + // Calculate the stdev of the smoothed robust histogram in the range + // mode-dL to mode+dL. We use the midpoint of each bin as the mean for + // that bin. + for (i = maxBinNum - dL; i <= maxBinNum + dL; i++) { + if ((0 <= i) && (i < robustHistogramVector->n)) { + diff = (0.5 * (robustHistogram->bounds->data.F32[i + 1] + + robustHistogram->bounds->data.F32[i])) - myMean; + sumSquares += diff * diff * robustHistogramVector->data.F32[i]; + sumDiffs += diff * robustHistogramVector->data.F32[i]; + } + } + myStdev = sqrt((sumSquares - (sumDiffs * sumDiffs / countFloat)) / (countFloat - 1)); + + /************************************************************************** + Set the appropriate members in the output stats struct. + **************************************************************************/ + if (stats->options & PS_STAT_ROBUST_MEAN) { + stats->robustMean = myMean; + } + + if (stats->options & PS_STAT_ROBUST_MODE) { + stats->robustMode = 0.5 * + (robustHistogram->bounds->data.F32[maxBinNum] + robustHistogram->bounds->data.F32[maxBinNum + 1]); + } + + if (stats->options & PS_STAT_ROBUST_STDEV) { + stats->robustStdev = myStdev; + } + // To determine the median (and later, the lower/upper quartile), we fit + // a quadratic to the three bins surrounding the bin containing the median. + // The quadratic y=f(x) with x being the midpoint of each bin, and y being + // the cumulative number of data points in all bins up to, and including, + // this bin. We then solve the quadratic for + + if (stats->options & PS_STAT_ROBUST_MEDIAN) { + if ((maxBinNum > 0) && (maxBinNum < (robustHistogram->nums->n - 1))) { + x->data.F64[0] = (double)0.5 * + (robustHistogram->bounds->data.F32[maxBinNum - 1] + + robustHistogram->bounds->data.F32[maxBinNum]); + x->data.F64[1] = (double)0.5 * + (robustHistogram->bounds->data.F32[maxBinNum] + + robustHistogram->bounds->data.F32[maxBinNum + 1]); + x->data.F64[2] = (double)0.5 * + (robustHistogram->bounds->data.F32[maxBinNum + 1] + + robustHistogram->bounds->data.F32[maxBinNum + 2]); + + y->data.F64[0] = cumulativeRobustSumsDlRange->data.F32[maxBinNum - 1]; + y->data.F64[1] = cumulativeRobustSumsDlRange->data.F32[maxBinNum]; + y->data.F64[2] = cumulativeRobustSumsDlRange->data.F32[maxBinNum + 1]; + + // Ensure that cumulativeMedian/2 is actually within the range of the bins + // we are using. + cumulativeMedian *= 0.5; + if (!((y->data.F64[0] <= cumulativeMedian) && (cumulativeMedian <= y->data.F64[2]))) { + printf("((%f), %f, %f)\n", cumulativeMedian, y->data.F64[0], y->data.F64[2]); + psAbort(__func__, "p_psVectorRobustStats(1): midpoint not within y-range\n"); + } + // XXX: yErr is not currently used by psVectorFitPolynomial1D(). We + // may have to set this meaningfully later. + yErr->data.F64[0] = 1.0; + yErr->data.F64[1] = 1.0; + yErr->data.F64[2] = 1.0; + + // Determine the coefficients of the polynomial. + myPoly = psVectorFitPolynomial1D(myPoly, x, y, yErr); + // Call p_ps1DPolyMedian(), which does a binary search on the + // polynomial, looking for the value x such that + // f(x) = cumulativeMedian. + stats->robustMedian = p_ps1DPolyMedian(myPoly, x->data.F64[0], x->data.F64[2], cumulativeMedian); + } else { + // If the mode is the first/last histogram bin, then simply use + // the midpoint of that bin. + stats->robustMedian = 0.5 * (robustHistogram->bounds->data.F32[maxBinNum + 1] + + robustHistogram->bounds->data.F32[maxBinNum]); + } + } + // The lower/upper quartile calculations are very similar to the median + // calculations. We fit a quadratic to the array containing the + // cumulative data points in each bin, then search for x such that + // f(x) equals the lower/upper quartile exactly. + // + if (stats->options & PS_STAT_ROBUST_QUARTILE) { + countFloat = cumulativeRobustSumsFullRange->data.F32[robustHistogramVector->n - 1]; + + if ((LQBinNum > 0) && (LQBinNum < (robustHistogram->nums->n - 1))) { + x->data.F64[0] = (double)0.5 * + (robustHistogram->bounds->data.F32[LQBinNum - 1] + + robustHistogram->bounds->data.F32[LQBinNum]); + x->data.F64[1] = (double)0.5 * + (robustHistogram->bounds->data.F32[LQBinNum] + + robustHistogram->bounds->data.F32[LQBinNum + 1]); + x->data.F64[2] = (double)0.5 * + (robustHistogram->bounds->data.F32[LQBinNum + 1] + + robustHistogram->bounds->data.F32[LQBinNum + 2]); + + y->data.F64[0] = cumulativeRobustSumsFullRange->data.F32[LQBinNum - 1]; + y->data.F64[1] = cumulativeRobustSumsFullRange->data.F32[LQBinNum]; + y->data.F64[2] = cumulativeRobustSumsFullRange->data.F32[LQBinNum + 1]; + + if (!((y->data.F64[0] <= (countFloat / 4.0)) && ((countFloat / 4.0) <= y->data.F64[2]))) { + psAbort(__func__, "p_psVectorRobustStats(2): midpoint not within y-range\n"); + } + + yErr->data.F64[0] = 1.0; + yErr->data.F64[1] = 1.0; + yErr->data.F64[2] = 1.0; + + myPoly = psVectorFitPolynomial1D(myPoly, x, y, yErr); + stats->robustLQ = p_ps1DPolyMedian(myPoly, x->data.F64[0], x->data.F64[2], countFloat / 4.0); + + } else { + // If the LQ is the first/last histogram bin, then simply use + // the midpoint of that bin. + stats->robustLQ = 0.5 * (robustHistogram->bounds->data.F32[LQBinNum + 1] + + robustHistogram->bounds->data.F32[LQBinNum]); + } + + if ((UQBinNum > 0) && (UQBinNum < (robustHistogram->nums->n - 1))) { + x->data.F64[0] = (double)0.5 * + (robustHistogram->bounds->data.F32[UQBinNum - 1] + + robustHistogram->bounds->data.F32[UQBinNum]); + x->data.F64[1] = (double)0.5 * + (robustHistogram->bounds->data.F32[UQBinNum] + + robustHistogram->bounds->data.F32[UQBinNum + 1]); + x->data.F64[2] = (double)0.5 * + (robustHistogram->bounds->data.F32[UQBinNum + 1] + + robustHistogram->bounds->data.F32[UQBinNum + 2]); + + y->data.F64[0] = cumulativeRobustSumsFullRange->data.F32[UQBinNum - 1]; + y->data.F64[1] = cumulativeRobustSumsFullRange->data.F32[UQBinNum]; + y->data.F64[2] = cumulativeRobustSumsFullRange->data.F32[UQBinNum + 1]; + + if (!((y->data.F64[0] <= (3.0 * countFloat / 4.0)) && + ((3.0 * countFloat / 4.0) <= y->data.F64[2]))) { + psAbort(__func__, "p_psVectorRobustStats(3): midpoint not within y-range\n"); + } + + yErr->data.F64[0] = 1.0; + yErr->data.F64[1] = 1.0; + yErr->data.F64[2] = 1.0; + + myPoly = psVectorFitPolynomial1D(myPoly, x, y, yErr); + stats->robustUQ = p_ps1DPolyMedian(myPoly, + x->data.F64[0], x->data.F64[2], 3.0 * countFloat / 4.0); + } else { + // If the UQ is the first/last histogram bin, then simply use + // the midpoint of that bin. + stats->robustUQ = 0.5 * (robustHistogram->bounds->data.F32[UQBinNum + 1] + + robustHistogram->bounds->data.F32[UQBinNum]); + } + } + stats->robustNfit = sumNfit; + stats->robustN50 = sumN50; + + psFree(x); + psFree(y); + psFree(yErr); + psFree(tmpStats); + psFree(robustHistogram); + psFree(myPoly); + psFree(cumulativeRobustSumsFullRange); + psFree(cumulativeRobustSumsDlRange); +} + +/* +void p_ps_FitTheGaussian() +{ + + // Fit a Gaussian to the bins in the range MODE-dL to Mode+dL + // NOTE: This code uses the psMinimize.c functions to perform + // the fit. It doesn't quite work, 100% of the time. For the time being + // I am commenting this code out, and replacing it with code which + // calculates the mean directly on the robustHistogram. + + domain = psImageAlloc(1, robustHistogramVector->n, PS_TYPE_F32); + errors = psVectorAlloc(robustHistogramVector->n, PS_TYPE_F32); + data = psVectorAlloc(robustHistogramVector->n, PS_TYPE_F32); + initialGuess = psVectorAlloc(2, PS_TYPE_F32); + + max = -HUGE; + max_pos = -1; + for (i=0;in;i++) { + domain->data.F32[i][0] = 0.5 * (robustHistogram->bounds->data.F32[i+1] + + robustHistogram->bounds->data.F32[i]); + data->data.F32[i] = (float) robustHistogramVector->data.F32[i]; + errors->data.F32[i] = 1.0; + //printf("DATA (%.2f, %.2f)\n", domain->data.F32[i][0], data->data.F32[i]); + if (data->data.F32[i] > max) { + max = data->data.F32[i]; + max_pos = domain->data.F32[i][0]; + } + } + + initialGuess->data.F32[0] = max_pos; + initialGuess->data.F32[1] = 1.0; + printf("Initial (mean. stdev) is (%.3f, %.3f)\n", initialGuess->data.F32[0], initialGuess->data.F32[1]); + + printf("Calling psMinimizeChi2()\n"); + theParams = psMinimizeChi2(p_psGaussian, + p_psGaussianDeriv, + domain, + data, + errors, + initialGuess, + NULL, + &chiSq); + printf("Called psMinimizeChi2()\n"); + printf("p_psVectorRobustStats() is (%f, %f)\n", theParams->data.F32[0], theParams->data.F32[1]); +} +*/ + +/*****************************************************************************/ + +/* FUNCTION IMPLEMENTATION - PUBLIC */ + +/*****************************************************************************/ + +static void histogramFree(psHistogram* myHist); + +/****************************************************************************** + psStatsAlloc(): This routine must create a new psStats data structure. + *****************************************************************************/ +psStats* psStatsAlloc(psStatsOptions options) +{ + psStats* newStruct = NULL; + + newStruct = (psStats* ) psAlloc(sizeof(psStats)); + newStruct->sampleMean = NAN; + newStruct->sampleMedian = NAN; + newStruct->sampleStdev = NAN; + newStruct->sampleUQ = NAN; + newStruct->sampleLQ = NAN; + newStruct->sampleLimit = 30000; + newStruct->robustMean = NAN; + newStruct->robustMedian = NAN; + newStruct->robustMode = NAN; + newStruct->robustStdev = NAN; + newStruct->robustUQ = NAN; + newStruct->robustLQ = NAN; + newStruct->robustN50 = NAN; + newStruct->robustNfit = NAN; + newStruct->clippedMean = NAN; + newStruct->clippedStdev = NAN; + newStruct->clipSigma = 3.0; + newStruct->clipIter = 3.0; + newStruct->min = NAN; + newStruct->max = NAN; + newStruct->binsize = NAN; + newStruct->options = options; + + return (newStruct); +} + +/****************************************************************************** +psHistogramAlloc(lower, upper, n): allocate a uniform histogram structure +with the specifed upper and lower limits, and the specifed number of bins. +This routine will also set the bounds for each of the bins. + +Input: + lower + upper + n +Returns: + The histogram structure + *****************************************************************************/ +psHistogram* psHistogramAlloc(float lower, float upper, int n) +{ + int i = 0; // Loop index variable + psHistogram* newHist = NULL; // The new histogram structure + float binSize = 0.0; // The histogram bin size + + // NOTE: Verify that this is the correct action. + if (n == 0) { + return (NULL); + } + if (n < 0) { + psAbort(__func__, "psHistogramAlloc() called with bin size %d.\n", n); + } + // NOTE: Verify that this is the correct action. + if (lower > upper) { + return (NULL); + } + // Allocate memory for the new histogram structure. If there are N + // bins, then there are N+1 bounds to those bins. + newHist = (psHistogram* ) psAlloc(sizeof(psHistogram)); + p_psMemSetDeallocator(newHist, (psFreeFcn) histogramFree); + newHist->bounds = psVectorAlloc(n + 1, PS_TYPE_F32); + newHist->bounds->n = newHist->bounds->nalloc; + + // Calculate the bounds for each bin. + binSize = (upper - lower) / (float)n; + // NOTE: Is the following necessary? It prevents the max data point + // from being in a non-existant bin. + binSize += FLT_EPSILON; + for (i = 0; i < n + 1; i++) { + newHist->bounds->data.F32[i] = lower + (binSize * (float)i); + } + + // Allocate the bins, and initialize them to zero. + newHist->nums = psVectorAlloc(n, PS_TYPE_U32); + newHist->nums->n = newHist->nums->nalloc; + for (i = 0; i < newHist->nums->n; i++) { + newHist->nums->data.U32[i] = 0; + } + + // Initialize the other members. + newHist->minNum = 0; + newHist->maxNum = 0; + newHist->uniform = true; + + return (newHist); +} + +/****************************************************************************** +psHistogramAllocGenric(bounds): allocate a non-uniform histogram structure +with the specifed bounds. + +Input: + bounds +Returns: + The histogram structure + *****************************************************************************/ +psHistogram* psHistogramAllocGeneric(const psVector* restrict bounds) +{ + psHistogram* newHist = NULL; // The new histogram structure + int i; // Loop index variable + + // NOTE: Verify that this is the correct action. + if (bounds == NULL) { + // psAbort(__func__, "psHistogram requested with NULL bounds"); + return (NULL); + } + // NOTE: Verify that this is the correct action. + if (bounds->n <= 1) { + // psAbort(__func__, "psHistogram requested with NULL bounds"); + return (NULL); + } + + if (bounds->type.type != PS_TYPE_F32) { + // psAbort(__func__, "psHistogram request a bound which is not type F32"); + return (NULL); + } + // Allocate memory for the new histogram structure. + newHist = (psHistogram* ) psAlloc(sizeof(psHistogram)); + p_psMemSetDeallocator(newHist, (psFreeFcn) histogramFree); + newHist->bounds = psVectorAlloc(bounds->n, PS_TYPE_F32); + newHist->bounds->n = newHist->bounds->nalloc; + for (i = 0; i < bounds->n; i++) { + newHist->bounds->data.F32[i] = bounds->data.F32[i]; + } + + // Allocate the bins, and initialize them to zero. If there are N bounds, + // then there are N-1 bins. + newHist->nums = psVectorAlloc((bounds->n) - 1, PS_TYPE_U32); + newHist->nums->n = newHist->nums->nalloc; + for (i = 0; i < newHist->nums->n; i++) { + newHist->nums->data.U32[i] = 0; + } + + // Initialize the other members. + newHist->minNum = 0; + newHist->maxNum = 0; + newHist->uniform = false; + + return (newHist); +} + +static void histogramFree(psHistogram* myHist) +{ + psFree(myHist->bounds); + psFree(myHist->nums); +} + +/***************************************************************************** +psVectorHistogram(out, in, mask, maskVal): this procedure takes as input a +preallocated and initialized histogram structure. It fills the bins in that +histogram structure in accordance with the input data "in" and the, possibly +NULL, mask vector. + +Inputs: + out + in + mask + maskVal +Returns: + The histogram structure "out". + *****************************************************************************/ +psHistogram* psVectorHistogram(psHistogram* out, + const psVector* restrict in, + const psVector* restrict mask, unsigned int maskVal) +{ + int i = 0; // Loop index variable + int j = 0; // Loop index variable + float binSize = 0.0; // Histogram bin size + int binNum = 0; // A temporary bin number + int numBins = 0; // The total number of bins + + // NOTE: Verify that this is the correct action. + if (out == NULL) { + return (NULL); + } + // Check the specified output histogram for type psF32 + if (out->bounds->type.type != PS_TYPE_F32) { + psAbort(__func__, "Only data type PS_TYPE_F32 for the output.bounds member."); + } + + if (out->nums->type.type != PS_TYPE_U32) { + psAbort(__func__, "Only data type PS_TYPE_U32 for output.nums member."); + } + // NOTE: Verify that this is the correct action. + if (in == NULL) { + return (out); + } + + if (in->type.type != PS_TYPE_F32) { + psAbort(__func__, "Only data type PS_TYPE_F32 is currently supported (0x%x).", in->type.type); + } + + if (mask != NULL) { + if (in->n != mask->n) { + psAbort(__func__, "Vector data and vector mask are of different sizes."); + } + if (mask->type.type != PS_TYPE_U8) { + psAbort(__func__, "Vector mask must be type PS_TYPE_U8"); + } + } + // NOTE: determine the correct action for a variety of other cases: + // in vector has 0 elements, and histogram structure has zero bins. + + numBins = out->nums->n; + for (i = 0; i < in->n; i++) { + // Check if this pixel is masked, and if so, skip it. + if ((mask == NULL) || ((mask != NULL) && (!(mask->data.U8[i] & maskVal)))) { + // Check if this pixel is below the minimum value, and if so + // count it, then skip it. + if (in->data.F32[i] < out->bounds->data.F32[0]) { + out->minNum++; + // Check if this pixel is above the maximum value, and if so + // count it, then skip it. + } else if (in->data.F32[i] > out->bounds->data.F32[numBins]) { + out->maxNum++; + } else { + // If this is a uniform histogram, determining the correct + // number is trivial. + if (out->uniform == true) { + binSize = out->bounds->data.F32[1] - out->bounds->data.F32[0]; + binNum = (int)((in->data.F32[i] - out->bounds->data.F32[0]) / binSize); + + // NOTE: This next if-statement really shouldn't be necessary. + // However, do to numerical lack of precision, we occasionally + // produce a binNum outside the range of bins. + if (binNum >= out->nums->n) { + binNum = out->nums->n - 1; + } + + (out->nums->data.S32[binNum])++; + + // If this is a non-uniform histogram, determining the correct + // bin number requires a bit more work. + } else { + // NOTE: This is slow. Put a smarter algorithm here to + // find the correct bin number (bin search, probably) + for (j = 0; j < (out->bounds->n) - 1; j++) { + if ((out->bounds->data.S32[j] <= in->data.F32[i]) && + (in->data.F32[i] <= out->bounds->data.S32[j + 1])) { + (out->nums->data.S32[j])++; + } + } + } + } + } + } + return (out); +} + +/****************************************************************************** +p_psConvertToF32(myVector, maskVector, maskVal, stats): this is the cheap +way to support a variety of vector data types: we simply convert the input +vector to F32 at the beginning, and write all of our functions in F32. If +the vast majority of all vector stat operations are F32 (or any other single +type), then this is probably the best way to go. Otherwise, when the +algorithms stablize, we will then macro everything and put type support in +the various stat functions. + *****************************************************************************/ +psVector* p_psConvertToF32(psStats* stats, psVector* in, psVector* mask, unsigned int maskVal) +{ + int i = 0; + psVector* tmp = NULL; + + if (in->type.type == PS_TYPE_S32) { + tmp = psVectorAlloc(in->n, PS_TYPE_F32); + for (i = 0; i < in->n; i++) { + tmp->data.F32[i] = (float)in->data.S32[i]; + } + } else if (in->type.type == PS_TYPE_U32) { + tmp = psVectorAlloc(in->n, PS_TYPE_F32); + for (i = 0; i < in->n; i++) { + tmp->data.F32[i] = (float)in->data.U32[i]; + } + } else if (in->type.type == PS_TYPE_F64) { + tmp = psVectorAlloc(in->n, PS_TYPE_F32); + for (i = 0; i < in->n; i++) { + tmp->data.F32[i] = (float)in->data.F64[i]; + } + } else if (in->type.type == PS_TYPE_F32) { + // do nothing + } else { + psAbort(__func__, "unsupported vector type 0x%x\n", in->type.type); + } + return (tmp); +} + +/****************************************************************************** +psVectorStats(myVector, maskVector, maskVal, stats): this is the public API +function which calls the above private stats functions based on what bits +were set in stats->options. + +Inputs + myVector + maskVector + maskVal + stats +Returns + The stats structure. + +NOTE: The current strategy is to implement everything assuming that all +input data is of type PS_TYPE_F32. Once the basic code is in place, we will +macro-ize everything and add PS_TYPE_U16 and PS_TYPE_F64. + *****************************************************************************/ +psStats* psVectorStats(psStats* stats, psVector* in, psVector* mask, unsigned int maskVal) +{ + psVector* inF32; + int mustFreeTmp = 1; + + // NOTE: Verify that this is the correct action. + if (in == NULL) { + return (stats); + } + if (stats == NULL) { + return (NULL); + } + + inF32 = p_psConvertToF32(stats, in, mask, maskVal); + if (inF32 == NULL) { + inF32 = in; + mustFreeTmp = 0; + } + // XXX: Should we abort if (stats->min == stats->max)? + if ((stats->options & PS_STAT_USE_RANGE) && (stats->min >= stats->max)) { + psAbort(__func__, "psVectorStats() called with range: %f to %f\n", stats->min, stats->max); + } + // PS_CHECK_VECTOR_TYPE(in, PS_TYPE_F32); + if (mask != NULL) { + PS_CHECK_NULL_VECTOR(mask); + PS_CHECK_EMPTY_VECTOR(mask); + PS_CHECK_VECTOR_SIZE_EQUAL(mask, in); + PS_CHECK_VECTOR_TYPE(mask, PS_TYPE_U8); + } + // ************************************************************************ + if (stats->options & PS_STAT_SAMPLE_MEAN) { + p_psVectorSampleMean(in, mask, maskVal, stats); + } + // ************************************************************************ + if (stats->options & PS_STAT_SAMPLE_MEDIAN) { + p_psVectorSampleMedian(in, mask, maskVal, stats); + } + // ************************************************************************ + // NOTE: The Stdev calculation requires the mean. Should we assume the + // mean has already been calculated? Or should we always calculate it? + if (stats->options & PS_STAT_SAMPLE_STDEV) { + p_psVectorSampleMean(in, mask, maskVal, stats); + p_psVectorSampleStdev(in, mask, maskVal, stats); + } + // ************************************************************************ + if (stats->options & PS_STAT_SAMPLE_QUARTILE) { + p_psVectorSampleQuartiles(in, mask, maskVal, stats); + } + // Since the various robust stats quantities share much computation, they + // are grouped together in a single private function: + // p_psVectorRobustStats() + if ((stats->options & PS_STAT_ROBUST_MEAN) || + (stats->options & PS_STAT_ROBUST_MEDIAN) || + (stats->options & PS_STAT_ROBUST_MODE) || + (stats->options & PS_STAT_ROBUST_STDEV) || (stats->options & PS_STAT_ROBUST_QUARTILE)) { + p_psVectorRobustStats(in, mask, maskVal, stats); + } + + if ((stats->options & PS_STAT_CLIPPED_MEAN) || (stats->options & PS_STAT_CLIPPED_STDEV)) { + p_psVectorClippedStats(in, mask, maskVal, stats); + } + // ************************************************************************ + if (stats->options & PS_STAT_MAX) { + p_psVectorMax(in, mask, maskVal, stats); + } + // ************************************************************************ + if (stats->options & PS_STAT_MIN) { + p_psVectorMin(in, mask, maskVal, stats); + } + + if (mustFreeTmp == 1) { + psFree(inF32); + } + return (stats); +} Index: /tags/rel2_1/psLib/src/math/psStats.h =================================================================== --- /tags/rel2_1/psLib/src/math/psStats.h (revision 1553) +++ /tags/rel2_1/psLib/src/math/psStats.h (revision 1553) @@ -0,0 +1,185 @@ + +/** @file psStats.h + * \brief basic statistical operations + * @ingroup Stats + * + * This file will hold the definition of the histogram and stats data + * structures. It also contains prototypes for procedures which operate + * on those data structures. + * + * @author George Gusciora, MHPCC + * + * @version $Revision: 1.25 $ $Name: not supported by cvs2svn $ + * @date $Date: 2004-08-11 19:16:04 $ + * + * Copyright 2004 Maui High Performance Computing Center, University of Hawaii + */ +#if !defined(PS_STATS_H) +#define PS_STATS_H + +#include "psVector.h" + +/// @addtogroup Stats +/// @{ + +/****************************************************************************** + Statistical functions and data structures. + *****************************************************************************/ + +/** enumeration of statistical calculation options + * + * @see psStats, psVectorStats, psImageStats + */ +typedef enum { + PS_STAT_SAMPLE_MEAN = 0x000001, + PS_STAT_SAMPLE_MEDIAN = 0x000002, + PS_STAT_SAMPLE_STDEV = 0x000004, + PS_STAT_SAMPLE_QUARTILE = 0x000008, + PS_STAT_ROBUST_MEAN = 0x000010, + PS_STAT_ROBUST_MEDIAN = 0x000020, + PS_STAT_ROBUST_MODE = 0x000040, + PS_STAT_ROBUST_STDEV = 0x000080, + PS_STAT_ROBUST_QUARTILE = 0x000100, + PS_STAT_CLIPPED_MEAN = 0x000200, + PS_STAT_CLIPPED_STDEV = 0x000400, + PS_STAT_MAX = 0x000800, + PS_STAT_MIN = 0x001000, + PS_STAT_USE_RANGE = 0x002000, + PS_STAT_USE_BINSIZE = 0x004000, + PS_STAT_ROBUST_FOR_SAMPLE = 0x008000 +} psStatsOptions; + +/** This is the generic statistics structure. It contails the data members + for the various statistic values. It also contains the options member to + specifiy which statistics should be calculated. */ +typedef struct +{ + double sampleMean; ///< formal mean of sample + double sampleMedian; ///< formal median of sample + double sampleStdev; ///< standard deviation of sample + double sampleUQ; ///< upper quartile of sample + double sampleLQ; ///< lower quartile of sample + double sampleLimit; ///< + double robustMean; ///< robust mean of array + double robustMedian; ///< robust median of array + double robustMode; ///< Robust mode of array + double robustStdev; ///< robust standard deviation of array + double robustUQ; ///< robust upper quartile + double robustLQ; ///< robust lower quartile + double XXX; + double robustN50; ///< + double robustNfit; ///< + double clippedMean; ///< Nsigma clipped mean + double clippedStdev; ///< standard deviation after clipping + double clipSigma; ///< Nsigma used for clipping; user input + int clipIter; ///< Number of clipping iterations; user input + double min; ///< minimum data value in array + double max; ///< maximum data value in array + double binsize; ///< + psStatsOptions options; ///< bitmask of calculated values +} +psStats; + +/** Performs statistical calculations on a vector. + * + * @return psStats* the statistical results as specified by stats->options + */ +psStats* psVectorStats( + psStats* stats, + ///< stats structure defines stats to be calculated and how + + psVector* in, + ///< Vector to be analysed: must be F32 + + psVector* mask, + ///< Ignore elements where (maskVector & maskVal) != 0: must be INT or NULL + + unsigned int maskVal + ///< Only mask elements with one of these bits set in maskVector +); + +/** Allocator of the psStats structure. + * + * @return psStats* A new psStats struct with the options member set to the + * value given. + */ +psStats* psStatsAlloc( + psStatsOptions options ///< Statistics to calculate +); + +/****************************************************************************** + Histogram functions and data structures. + *****************************************************************************/ + +/** The basic histogram structure which contains bounds and bins. + * + * In this structure, the vector bounds specifies the boundaries of the + * histogram bins, and must of type psF32, while nums specifies the number + * of entries in the bin, and must of type psU32. The value of bounds.n must + * therefore be 1 greater than than nums.n. The two values minNum and maxNum + * are the number of data values which fell below the lower limit bound or + * above the upper limit bound, respectively. + */ +typedef struct +{ + psVector* bounds; ///< Bounds for the bins (type F32) + psVector* nums; ///< Number in each of the bins (INT) + int minNum; ///< Number below the minimum + int maxNum; ///< Number above the maximum + bool uniform; ///< Is it a uniform distribution? +} +psHistogram; + +/** Allocator for psHistogram where the bounds of the bins are implicitly + * specified through simply specifying an upper and lower limit along with + * the size of the bins. + * + * @return psHistogram* Newly allocated psHistogram + */ +psHistogram* psHistogramAlloc( + float lower, ///< Lower limit for the bins + float upper, ///< Upper limit for the bins + int n ///< Number of bins +); + +/** Allocator for psHistogram where the bounds of the bins are explicitly + * specified. + * + * @return psHistogram* Newly allocated psHistogram + */ +psHistogram* psHistogramAllocGeneric( + const psVector* restrict bounds ///< Bounds for the bins +); + +/** Calculate a histogram + * + * The following function populates the histogram bins from the specified + * vector (in). It alters and returns the histogram out structure. The input + * vector may be of types psU8, psU16, psF32, psF64. + * + * @return psHistogram* histogram result + */ +psHistogram* psVectorHistogram( + psHistogram* out, ///< Histogram data + const psVector* restrict in, ///< Vector to analyse + const psVector* restrict mask, ///< Mask dat for input vector + unsigned int maskVal ///< Mask value +); + +/** Extracts the statistic value specified by stats->options. + * + * @return bool If more than one statistic result is set in stats->options, + * false is returned and the value parameter is not set, + * otherwise true is returned. + */ +bool p_psGetStatValue( + const psStats* stats, + ///< the statistic struct to operate on + + double *value + ///< if return is true, this is set to the specified statistic value by stats->options +); + +/// @} + +#endif Index: /tags/rel2_1/psLib/src/mathtypes/psImage.c =================================================================== --- /tags/rel2_1/psLib/src/mathtypes/psImage.c (revision 1553) +++ /tags/rel2_1/psLib/src/mathtypes/psImage.c (revision 1553) @@ -0,0 +1,436 @@ + +/** @file psImage.c + * + * @brief Contains basic image definitions and operations. + * + * This file defines the basic type for an image struct and functions useful + * in manupulating images. + * + * @author Robert DeSonia, MHPCC + * @author Ross Harman, MHPCC + * + * @version $Revision: 1.39 $ $Name: not supported by cvs2svn $ + * @date $Date: 2004-08-09 23:34:58 $ + * + * Copyright 2004 Maui High Performance Computing Center, University of Hawaii + * + * That is the routine used to generate matrices. + */ + +/******************************************************************************/ + +/* INCLUDE FILES */ + +/******************************************************************************/ + +#include +#include + +#include "psMemory.h" +#include "psAbort.h" +#include "psError.h" +#include "psImage.h" + +static void imageFree(psImage* image); + +/*****************************************************************************/ + +/* FUNCTION IMPLEMENTATION - PUBLIC */ + +/*****************************************************************************/ + +psImage* psImageAlloc(unsigned int numCols, unsigned int numRows, const psElemType type) +{ + int area = 0; + int elementSize = PSELEMTYPE_SIZEOF(type); // element + + // size in + // bytes + int rowSize = numCols * elementSize; // row + + // size + + // in bytes. + + area = numCols * numRows; + + if (area < 1) { + psError(__func__, + "Invalid value for number of rows or columns " "(numRows=%d, numCols=%d).", numRows, numCols); + return NULL; + } + + psImage* image = (psImage* ) psAlloc(sizeof(psImage)); + + if (image == NULL) { + psAbort(__func__, " : Line %d - Failed to allocate memory", __LINE__); + } + + p_psMemSetDeallocator(image, (psFreeFcn) imageFree); + + image->data.V = psAlloc(sizeof(void *) * numRows); + if (image->data.V == NULL) { + psAbort(__func__, " : Line %d - Failed to allocate memory", __LINE__); + } + + image->data.V[0] = psAlloc(area * elementSize); + if (image->data.V[0] == NULL) { + psAbort(__func__, " : Line %d - Failed to allocate memory", __LINE__); + } + + for (int i = 1; i < numRows; i++) { + image->data.V[i] = (void *)((int8_t *) image->data.V[i - 1] + rowSize); + } + + *(int *)&image->col0 = 0; + *(int *)&image->row0 = 0; + *(unsigned int *)&image->numCols = numCols; + *(unsigned int *)&image->numRows = numRows; + *(psDimen* ) & image->type.dimen = PS_DIMEN_IMAGE; + *(psElemType* ) & image->type.type = type; + image->parent = NULL; + image->nChildren = 0; + image->children = NULL; + + return image; +} + +static void imageFree(psImage* image) +{ + if (image == NULL) { + return; + } + + if (image->type.type == PS_TYPE_PTR) { + // 2-D array of pointers -- must + // dereference + unsigned int oldNumRows = image->numRows; + unsigned int oldNumCols = image->numCols; + psPTR* rowPtr; + + for (unsigned int row = 0; row < oldNumRows; row++) { + rowPtr = image->data.PTR[row]; + for (unsigned int col = 0; col < oldNumCols; col++) { + psMemDecrRefCounter(rowPtr[col]); + } + } + } + + psImageFreeChildren(image); + + psFree(image->data.V[0]); + psFree(image->data.V); + image->data.V = NULL; +} + +psImage* psImageRecycle(psImage* old, unsigned int numCols, unsigned int numRows, const psElemType type) +{ + int elementSize = PSELEMTYPE_SIZEOF(type); // element + + // size in + // bytes + int rowSize = numCols * elementSize; // row + + // size + + // in bytes. + + if (old == NULL) { + old = psImageAlloc(numCols, numRows, type); + return old; + } + + if (old->type.dimen != PS_DIMEN_IMAGE) { + psError(__func__, "Can not realloc image because input is not an image."); + return NULL; + } + + if (old->type.type == PS_TYPE_PTR) { + // 2-D array of pointers -- must + // dereference + unsigned int oldNumRows = old->numRows; + unsigned int oldNumCols = old->numCols; + psPTR* rowPtr; + + for (unsigned int row = 0; row < oldNumRows; row++) { + rowPtr = old->data.PTR[row]; + for (unsigned int col = 0; col < oldNumCols; col++) { + psMemDecrRefCounter(rowPtr[col]); + rowPtr[col] = NULL; + } + } + } + + /* image already the right size/type? */ + if (numCols == old->numCols && numRows == old->numRows && type == old->type.type) { + return old; + } + // Resize the image buffer + old->data.V[0] = psRealloc(old->data.V[0], numCols * numRows * elementSize); + old->data.V = (void **)psRealloc(old->data.V, numRows * sizeof(void *)); + + // recreate the row pointers + for (int i = 1; i < numRows; i++) { + old->data.V[i] = (void *)((int8_t *) old->data.V[i - 1] + rowSize); + } + + *(unsigned int *)&old->numCols = numCols; + *(unsigned int *)&old->numRows = numRows; + *(psElemType* ) & old->type.type = type; + + return old; +} + +int psImageFreeChildren(psImage* image) +{ + int i = 0; + int nChildren = 0; + psImage* *children = NULL; + int numFreed = 0; + + if (image == NULL) { + return numFreed; + } + + nChildren = image->nChildren; + children = image->children; + + for (i = 0; i < nChildren; i++) { + if (children[i] != NULL) { + numFreed++; + psFree(children[i]); + } + } + psFree(children); + + image->nChildren = 0; + image->children = NULL; + + return numFreed; +} + +/***************************************************************************** +p_psImagePixelInterpolation(image, x, y): this routine takes as input an +image and coordinates (x, y) and produces as output the corresponding pixel +value at the those coordinates. For fractional corrdinates (x, y), 2-D +linear interpolation is performed on the image. + *****************************************************************************/ +psF32 psImagePixelInterpolate(const psImage* input, + float x, float y, psF32 unexposedValue, psImageInterpolateMode mode) +{ + + if (input == NULL) { + psError(__func__, "Image can not be NULL."); + return unexposedValue; + } + #define PSIMAGE_PIXEL_INTERPOLATE_CASE(TYPE) \ +case PS_TYPE_##TYPE: \ + switch (mode) { \ + case PS_INTERPOLATE_FLAT: \ + return p_psImagePixelInterpolateFLAT_##TYPE(input,x,y,unexposedValue); \ + break; \ + case PS_INTERPOLATE_BILINEAR: \ + return p_psImagePixelInterpolateBILINEAR_##TYPE(input,x,y,unexposedValue); \ + break; \ + default: \ + psError(__func__,"Unsupported interpolation mode (#%d)",mode); \ + } \ + break + + switch (input->type.type) { + PSIMAGE_PIXEL_INTERPOLATE_CASE(U8); + PSIMAGE_PIXEL_INTERPOLATE_CASE(U16); + PSIMAGE_PIXEL_INTERPOLATE_CASE(U32); + PSIMAGE_PIXEL_INTERPOLATE_CASE(U64); + PSIMAGE_PIXEL_INTERPOLATE_CASE(S8); + PSIMAGE_PIXEL_INTERPOLATE_CASE(S16); + PSIMAGE_PIXEL_INTERPOLATE_CASE(S32); + PSIMAGE_PIXEL_INTERPOLATE_CASE(S64); + PSIMAGE_PIXEL_INTERPOLATE_CASE(F32); + PSIMAGE_PIXEL_INTERPOLATE_CASE(F64); + PSIMAGE_PIXEL_INTERPOLATE_CASE(C32); + PSIMAGE_PIXEL_INTERPOLATE_CASE(C64); + default: + psError(__func__, "Unsupported image datatype (%d)", input->type.type); + } + + return unexposedValue; +} + +#define PSIMAGE_PIXEL_INTERPOLATE_FLAT(TYPE) \ +inline psF64 p_psImagePixelInterpolateFLAT_##TYPE(const psImage* input, \ + float x, \ + float y, \ + psF64 unexposedValue) \ +{ \ + int intX = (int) round((psF64)(x) - 0.5); \ + int intY = (int) round((psF64)(y) - 0.5); \ + int lastX = input->numCols - 1; \ + int lastY = input->numRows - 1; \ + \ + if ((intX < 0) || \ + (intX > lastX) || \ + (intY < 0) || \ + (intY > lastY)) { \ + return unexposedValue; \ + } \ + \ + return input->data.TYPE[intY][intX]; \ +} + +#define PSIMAGE_PIXEL_INTERPOLATE_FLAT_COMPLEX(TYPE) \ +inline psC64 p_psImagePixelInterpolateFLAT_##TYPE(const psImage* input, \ + float x, \ + float y, \ + psC64 unexposedValue) \ +{ \ + int intX = (int) round((psF64)(x) - 0.5); \ + int intY = (int) round((psF64)(y) - 0.5); \ + int lastX = input->numCols - 1; \ + int lastY = input->numRows - 1; \ + \ + if ((intX < 0) || \ + (intX > lastX) || \ + (intY < 0) || \ + (intY > lastY)) { \ + return unexposedValue; \ + } \ + \ + return input->data.TYPE[intY][intX]; \ +} + +PSIMAGE_PIXEL_INTERPOLATE_FLAT(U8) +PSIMAGE_PIXEL_INTERPOLATE_FLAT(U16) +PSIMAGE_PIXEL_INTERPOLATE_FLAT(U32) +PSIMAGE_PIXEL_INTERPOLATE_FLAT(U64) +PSIMAGE_PIXEL_INTERPOLATE_FLAT(S8) +PSIMAGE_PIXEL_INTERPOLATE_FLAT(S16) +PSIMAGE_PIXEL_INTERPOLATE_FLAT(S32) +PSIMAGE_PIXEL_INTERPOLATE_FLAT(S64) +PSIMAGE_PIXEL_INTERPOLATE_FLAT(F32) +PSIMAGE_PIXEL_INTERPOLATE_FLAT(F64) +PSIMAGE_PIXEL_INTERPOLATE_FLAT_COMPLEX(C32) +PSIMAGE_PIXEL_INTERPOLATE_FLAT_COMPLEX(C64) +#define PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(TYPE) \ +inline psF64 p_psImagePixelInterpolateBILINEAR_##TYPE(const psImage* input, \ + float x, \ + float y, \ + psF64 unexposedValue) \ +{ \ + double floorX = floor((psF64)(x) - 0.5); \ + double floorY = floor((psF64)(y) - 0.5); \ + double fracX = x - 0.5 - floorX; \ + double fracY = y - 0.5 - floorY; \ + int intFloorX = (int) floorX; \ + int intFloorY = (int) floorY; \ + int lastX = input->numCols - 1; \ + int lastY = input->numRows - 1; \ + double rx = 0.0; \ + psF64 pixel = 0.0; \ + ps##TYPE* currentRow; \ + ps##TYPE* nextRow; \ + \ + if ((intFloorX < 0) || \ + (intFloorX > lastX) || \ + (intFloorY < 0) || \ + (intFloorY > lastY)) { \ + return unexposedValue; \ + } \ + \ + currentRow = input->data.TYPE[intFloorY]; \ + if (intFloorY == lastY) { \ + pixel = currentRow[intFloorX]; \ + if (intFloorX < lastX) { \ + pixel+= fracY * ((psF64)currentRow[intFloorX+1] - \ + (psF64)currentRow[intFloorX]); \ + } \ + return(pixel); \ + } \ + nextRow = input->data.TYPE[intFloorY+1]; \ + if (intFloorX == lastX) { \ + pixel = currentRow[intFloorX]; \ + if (intFloorY < lastY) { \ + pixel+= fracX * ((psF64)nextRow[intFloorX] - \ + (psF64)currentRow[intFloorX]); \ + } \ + return(pixel); \ + } \ + \ + rx = currentRow[intFloorX] + \ + fracX * ((psF64)currentRow[intFloorX+1] - \ + (psF64)currentRow[intFloorX]); \ + \ + pixel = rx + fracY * ((psF64)nextRow[intFloorX] + \ + fracX * ((psF64)nextRow[intFloorX+1] - \ + (psF64)nextRow[intFloorX]) - rx); \ + \ + return(pixel); \ +} +#define PSIMAGE_PIXEL_INTERPOLATE_BILINEAR_COMPLEX(TYPE) \ +inline psC64 p_psImagePixelInterpolateBILINEAR_##TYPE(const psImage* input, \ + float x, \ + float y, \ + psC64 unexposedValue) \ +{ \ + double floorX = floor((psF64)(x) - 0.5); \ + double floorY = floor((psF64)(y) - 0.5); \ + double fracX = x - 0.5 - floorX; \ + double fracY = y - 0.5 - floorY; \ + int intFloorX = (int) floorX; \ + int intFloorY = (int) floorY; \ + int lastX = input->numCols - 1; \ + int lastY = input->numRows - 1; \ + double rx = 0.0; \ + psC64 pixel = 0.0; \ + ps##TYPE* currentRow; \ + ps##TYPE* nextRow; \ + \ + if ((intFloorX < 0) || \ + (intFloorX > lastX) || \ + (intFloorY < 0) || \ + (intFloorY > lastY)) { \ + return unexposedValue; \ + } \ + \ + currentRow = input->data.TYPE[intFloorY]; \ + if (intFloorY == lastY) { \ + pixel = currentRow[intFloorX]; \ + if (intFloorX < lastX) { \ + pixel+= fracY * (currentRow[intFloorX+1] - \ + currentRow[intFloorX]); \ + } \ + return(pixel); \ + } \ + nextRow = input->data.TYPE[intFloorY+1]; \ + if (intFloorX == lastX) { \ + pixel = currentRow[intFloorX]; \ + if (intFloorY < lastY) { \ + pixel+= fracX * (nextRow[intFloorX] - \ + currentRow[intFloorX]); \ + } \ + return(pixel); \ + } \ + \ + rx = currentRow[intFloorX] + \ + fracX * (currentRow[intFloorX+1] - \ + currentRow[intFloorX]); \ + \ + pixel = rx + fracY * ((psF64)nextRow[intFloorX] + \ + fracX * (nextRow[intFloorX+1] - \ + nextRow[intFloorX]) - rx); \ + \ + return(pixel); \ +} + +PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(U8) +PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(U16) +PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(U32) +PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(U64) +PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(S8) +PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(S16) +PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(S32) +PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(S64) +PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(F32) +PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(F64) +PSIMAGE_PIXEL_INTERPOLATE_BILINEAR_COMPLEX(C32) +PSIMAGE_PIXEL_INTERPOLATE_BILINEAR_COMPLEX(C64) Index: /tags/rel2_1/psLib/src/mathtypes/psImage.h =================================================================== --- /tags/rel2_1/psLib/src/mathtypes/psImage.h (revision 1553) +++ /tags/rel2_1/psLib/src/mathtypes/psImage.h (revision 1553) @@ -0,0 +1,162 @@ + +/** @file psImage.h + * + * @brief Contains basic image definitions and operations + * + * This file defines the basic type for an image struct and functions useful + * in manupulating images. + * + * @ingroup Image + * + * @author Robert DeSonia, MHPCC + * @author Ross Harman, MHPCC + * + * @version $Revision: 1.32 $ $Name: not supported by cvs2svn $ + * @date $Date: 2004-08-10 01:05:53 $ + * + * Copyright 2004 Maui High Performance Computing Center, University of Hawaii + */ +#ifndef PS_IMAGE_H +#define PS_IMAGE_H + +#include + +#include "psType.h" + +/// @addtogroup Image +/// @{ + +/** enumeration of options in interpolation + * + */ +typedef enum { + PS_INTERPOLATE_FLAT, ///< 'flat' interpolation (nearest pixel) + PS_INTERPOLATE_BILINEAR ///< bi-linear interpolation +} psImageInterpolateMode; + +/** Basic image data structure. + * + * Struct for maintaining image data of varying types. It also contains + * information about image size, parent images and children images. + * + */ +typedef struct psImage +{ + const psType type; ///< Image data type and dimension. + const unsigned int numCols; ///< Number of columns in image + const unsigned int numRows; ///< Number of rows in image. + const int col0; ///< Column position relative to parent. + const int row0; ///< Row position relative to parent. + + union { + psU8* *U8; ///< Unsigned 8-bit integer data. + psU16* *U16; ///< Unsigned 16-bit integer data. + psU32* *U32; ///< Unsigned 32-bit integer data. + psU64* *U64; ///< Unsigned 64-bit integer data. + psS8* *S8; ///< Signed 8-bit integer data. + psS16* *S16; ///< Signed 16-bit integer data. + psS32* *S32; ///< Signed 32-bit integer data. + psS64* *S64; ///< Signed 64-bit integer data. + psF32* *F32; ///< Single-precision float data. + psF64* *F64; ///< Double-precision float data. + psC32* *C32; ///< Single-precision complex data. + psC64* *C64; ///< Double-precision complex data. + psPTR* *PTR; ///< Void pointers. + psPTR* V; ///< Pointer to data. + } data; ///< Union for data types. + const struct psImage* parent; ///< Parent, if a subimage. + int nChildren; ///< Number of subimages. + struct psImage* *children; ///< Children of this region. +} +psImage; + +/** Create an image of the specified size and type. + * + * Uses psLib memory allocation functions to create an image struct of the + * specified size and type. + * + * @return psImage* : Pointer to psImage. + * + */ +psImage* psImageAlloc( + unsigned int numCols, ///< Number of rows in image. + unsigned int numRows, ///< Number of columns in image. + const psElemType type ///< Type of data for image. +); + +/** Resize a given image to the given size/type. + * + * @return psImage* Resized psImage. + * + */ +psImage* psImageRecycle( + psImage* old, ///< the psImage to recycle by resizing image buffer + unsigned int numCols, ///< the desired number of columns in image + unsigned int numRows, ///< the desired number of rows in image + const psElemType type ///< the desired datatype of the image +); + +/** Frees all children of a psImage. + * + * @return int Number of children freed. + * + */ +int psImageFreeChildren( + psImage* image ///< psImage in which all children shall be deallocated +); + +/** Interpolate image pixel value given floating point coordinates. + * + * @return psF32 Pixel value interpolated from image or unexposedValue if + * given x,y doesn't coorespond to a valid image location + */ +psF32 psImagePixelInterpolate( + const psImage* input, ///< input image for interpolation + float x, ///< column location to derive value of + float y, ///< row location ot derive value of + psF32 unexposedValue, ///< return value if x,y location is not in image. + psImageInterpolateMode mode ///< interpolation mode +); + +#define p_psImagePixelInterpolateFcns(TYPE) \ +inline psF64 p_psImagePixelInterpolateFLAT_##TYPE( \ + const psImage* input, \ + float x, \ + float y, \ + psF64 unexposedValue \ + ); \ +inline psF64 p_psImagePixelInterpolateBILINEAR_##TYPE( \ + const psImage* input, \ + float x, \ + float y, \ + psF64 unexposedValue \ + ); + +#define p_psImagePixelInterpolateComplexFcns(TYPE) \ +inline psC64 p_psImagePixelInterpolateFLAT_##TYPE( \ + const psImage* input, \ + float x, \ + float y, \ + psC64 unexposedValue \ + ); \ +inline psC64 p_psImagePixelInterpolateBILINEAR_##TYPE( \ + const psImage* input, \ + float x, \ + float y, \ + psC64 unexposedValue \ + ); + +p_psImagePixelInterpolateFcns(U8) +p_psImagePixelInterpolateFcns(U16) +p_psImagePixelInterpolateFcns(U32) +p_psImagePixelInterpolateFcns(U64) +p_psImagePixelInterpolateFcns(S8) +p_psImagePixelInterpolateFcns(S16) +p_psImagePixelInterpolateFcns(S32) +p_psImagePixelInterpolateFcns(S64) +p_psImagePixelInterpolateFcns(F32) +p_psImagePixelInterpolateFcns(F64) +p_psImagePixelInterpolateComplexFcns(C32) +p_psImagePixelInterpolateComplexFcns(C64) +/// @} +#endif Index: /tags/rel2_1/psLib/src/mathtypes/psScalar.c =================================================================== --- /tags/rel2_1/psLib/src/mathtypes/psScalar.c (revision 1553) +++ /tags/rel2_1/psLib/src/mathtypes/psScalar.c (revision 1553) @@ -0,0 +1,153 @@ + +/** @file psScalar.c + * + * @brief Contains basic scalar definitions and operations + * + * This file defines the basic type for a scalar struct and functions useful + * in manupulating scalars. + * * + * @author Ross Harman, MHPCC + * + * @version $Revision: 1.8 $ $Name: not supported by cvs2svn $ + * @date $Date: 2004-08-10 19:27:47 $ + * + * Copyright 2004 Maui High Performance Computing Center, University of Hawaii + */ + +/******************************************************************************/ + +/* INCLUDE FILES */ + +/******************************************************************************/ +#include "psMemory.h" +#include "psError.h" +#include "psScalar.h" +#include "psLogMsg.h" +#include "psAbort.h" + +/******************************************************************************/ + +/* DEFINE STATEMENTS */ + +/******************************************************************************/ + +// None + +/******************************************************************************/ + +/* TYPE DEFINITIONS */ + +/******************************************************************************/ + +// None + +/*****************************************************************************/ + +/* GLOBAL VARIABLES */ + +/*****************************************************************************/ + +// None + +/*****************************************************************************/ + +/* FILE STATIC VARIABLES */ + +/*****************************************************************************/ + +// None + +/*****************************************************************************/ + +/* FUNCTION IMPLEMENTATION - LOCAL */ + +/*****************************************************************************/ + +// None + +/*****************************************************************************/ + +/* FUNCTION IMPLEMENTATION - PUBLIC */ + +/*****************************************************************************/ +psScalar* psScalarAlloc(psC64 value, psElemType dataType) +{ + psScalar* scalar = NULL; + + // Create scalar + scalar = (psScalar* ) psAlloc(sizeof(psScalar)); + if (scalar == NULL) { + psAbort(__func__, " : Line %d - Failed to allocate memory", __LINE__); + } + + scalar->type.dimen = PS_DIMEN_SCALAR; + scalar->type.type = dataType; + + switch (dataType) { + case PS_TYPE_S8: + scalar->data.S8 = (psS8) value; + break; + case PS_TYPE_U8: + scalar->data.U8 = (psU8) value; + break; + case PS_TYPE_S16: + scalar->data.S16 = (psS16) value; + break; + case PS_TYPE_U16: + scalar->data.U16 = (psU16) value; + break; + case PS_TYPE_S32: + scalar->data.S32 = (psS32) value; + break; + case PS_TYPE_U32: + scalar->data.U32 = (psU32) value; + break; + case PS_TYPE_S64: + scalar->data.S64 = (psS64) value; + break; + case PS_TYPE_U64: + scalar->data.U64 = (psU64) value; + break; + case PS_TYPE_F32: + scalar->data.F32 = (psF32) value; + break; + case PS_TYPE_F64: + scalar->data.F64 = (psF64) value; + break; + case PS_TYPE_C32: + scalar->data.C32 = (psC32) value; + break; + case PS_TYPE_C64: + scalar->data.C64 = (psC64) value; + break; + default: + psError(__func__, ": Line %d - Invalid PS_TYPE: %d", __LINE__, dataType); + } + + return scalar; +} + +psScalar* psScalarCopy(psScalar *scalar) +{ + psScalar *newScalar = NULL; + + if (scalar == NULL) { + psError(__func__, "Null scalar not allowed"); + } + + newScalar = psScalarAlloc(scalar->data.C64, scalar->type.type); + if (newScalar == NULL) { + psAbort(__func__, " : Line %d - Failed to allocate memory", __LINE__); + } + + return newScalar; +} + +void psScalarFree(psScalar* restrict scalar) +{ + if (scalar == NULL) { + return; + } + + psFree(scalar); +} Index: /tags/rel2_1/psLib/src/mathtypes/psScalar.h =================================================================== --- /tags/rel2_1/psLib/src/mathtypes/psScalar.h (revision 1553) +++ /tags/rel2_1/psLib/src/mathtypes/psScalar.h (revision 1553) @@ -0,0 +1,93 @@ + +/** @file psScalar.h + * + * @brief Contains basic scalar definitions and operations + * + * This file defines the basic type for a scalar struct and functions useful + * in manupulating scalars. + * + * @ingroup Scalar + * + * @author Ross Harman, MHPCC + * + * @version $Revision: 1.9 $ $Name: not supported by cvs2svn $ + * @date $Date: 2004-08-11 20:08:08 $ + * + * Copyright 2004 Maui High Performance Computing Center, University of Hawaii + */ + +#ifndef PS_SCALAR_H +#define PS_SCALAR_H + +#include "psType.h" + +/// @addtogroup Scalar +/// @{ + +/** Basic scalar data structure. + * + * Struct for maintaining a scalar of frequently used primitive types. + * + */ +typedef struct +{ + psType type; ///< Type of data. + + union { + psU8 U8; ///< Unsigned 8-bit integer data. + psU16 U16; ///< Unsigned 16-bit integer data. + psU32 U32; ///< Unsigned 32-bit integer data. + psU64 U64; ///< Unsigned 64-bit integer data. + psS8 S8; ///< Signed 8-bit integer data. + psS16 S16; ///< Signed 16-bit integer data. + psS32 S32; ///< Signed 32-bit integer data. + psS64 S64; ///< Signed 64-bit integer data. + psF32 F32; ///< Single-precision float data. + psF64 F64; ///< Double-precision float data. + psC32 C32; ///< Single-precision complex data. + psC64 C64; ///< Double-precision complex data. + } data; ///< Union for data types. +} +psScalar; + +/*****************************************************************************/ + +/* FUNCTION PROTOTYPES */ + +/*****************************************************************************/ + +/** Allocate a scalar. + * + * Uses psLib memory allocation functions to create scalar data as defined by the psType type. + * Accepts a complex 64 bit float for input value, as max size, but resizes according to + * correct type. + * + * @return psScalar* Pointer to a new psScalar. + */ +psScalar* psScalarAlloc( + psC64 value, ///< Data to be put into psScalar. + psElemType dataType ///< Type of data to be held by psScalar. +); + +/** Deallocate a scalar. + * + * Uses psLib memory allocation functions to deallocate a scalar. + * + */ +void psScalarFree( + psScalar* restrict scalar ///< Scalar to free. +); + +/** Copy a scalar. + * + * Uses psLib memory allocation functions to copy a scalar. + * + * @return psScalar* A copy of the input scalar + */ +psScalar* psScalarCopy( + psScalar *scalar ///< Scalar to copy. +); + +/// @} + +#endif Index: /tags/rel2_1/psLib/src/mathtypes/psVector.c =================================================================== --- /tags/rel2_1/psLib/src/mathtypes/psVector.c (revision 1553) +++ /tags/rel2_1/psLib/src/mathtypes/psVector.c (revision 1553) @@ -0,0 +1,357 @@ + +/** @file psVector.c +* +* @brief Contains support for basic vector types +* +* This file defines the basic type for a vector struct and functions useful +* in manupulating vectors. +* +* @author Ross Harman, MHPCC +* +* @version $Revision: 1.22 $ $Name: not supported by cvs2svn $ +* @date $Date: 2004-08-09 23:34:57 $ +* +* Copyright 2004 Maui High Performance Computing Center, University of Hawaii +*/ + +/******************************************************************************/ + +/* INCLUDE FILES */ + +/******************************************************************************/ +#include // for memcpy +#include +#include + +#include "psMemory.h" +#include "psError.h" +#include "psVector.h" +#include "psLogMsg.h" +#include "psCompare.h" + +/******************************************************************************/ + +/* DEFINE STATEMENTS */ + +/******************************************************************************/ + +// None + +/******************************************************************************/ + +/* TYPE DEFINITIONS */ + +/******************************************************************************/ + +// None + +/*****************************************************************************/ + +/* GLOBAL VARIABLES */ + +/*****************************************************************************/ + +// None + +/*****************************************************************************/ + +/* FILE STATIC VARIABLES */ + +/*****************************************************************************/ + +// None + +/*****************************************************************************/ + +/* FUNCTION IMPLEMENTATION - LOCAL */ + +/*****************************************************************************/ +static void vectorFree(psVector* restrict psVec); + +/*****************************************************************************/ + +/* FUNCTION IMPLEMENTATION - PUBLIC */ + +/*****************************************************************************/ +psVector* psVectorAlloc(unsigned int nalloc, psElemType elemType) +{ + psVector* psVec = NULL; + int elementSize = 0; + + // Invalid nalloc + if (nalloc < 1) { + psError(__func__, "Invalid value for nalloc. nalloc: %d\n", nalloc); + return NULL; + } + + elementSize = PSELEMTYPE_SIZEOF(elemType); + + // Create vector struct + psVec = (psVector* ) psAlloc(sizeof(psVector)); + p_psMemSetDeallocator(psVec, (psFreeFcn) vectorFree); + + psVec->type.dimen = PS_DIMEN_VECTOR; + psVec->type.type = elemType; + psVec->nalloc = nalloc; + psVec->n = nalloc; + + // Create vector data array + psVec->data.V = psAlloc(nalloc * elementSize); + + return psVec; +} + +psVector* psVectorRealloc(unsigned int nalloc, psVector* restrict in) +{ + int elementSize = 0; + psElemType elemType; + + // Invalid nalloc + if (nalloc < 1) { + psError(__func__, "Invalid value for realloc (%d)\n", nalloc); + return NULL; + } + + if (in == NULL) { + psError(__func__, "Null input vector\n"); + return NULL; + } else if (in->nalloc != nalloc) { // No need to realloc to same size + elemType = in->type.type; + elementSize = PSELEMTYPE_SIZEOF(elemType); + if (nalloc < in->n) { + in->n = nalloc; + } + // Realloc after decrementation to avoid accessing freed array elements + in->data.V = psRealloc(in->data.V, nalloc * elementSize); + in->nalloc = nalloc; + } + + return in; +} + +psVector* psVectorRecycle(psVector* restrict in, unsigned int nalloc, psElemType type) +{ + psElemType elemType; + + if (in == NULL) { + return psVectorAlloc(nalloc, type); + } + + elemType = in->type.type; + + if (in->nalloc == nalloc && elemType == type) { + // it is proper size/type already + return in; + } + // Invalid nalloc + if (nalloc < 1) { + psError(__func__, "Invalid value for nalloc (%d)\n", nalloc); + psFree(in); + return NULL; + } + + in->data.V = psRealloc(in->data.V, nalloc * PSELEMTYPE_SIZEOF(type)); + + in->type.type = type; + in->nalloc = nalloc; + in->n = nalloc; + + return in; +} + +psVector* psVectorSort(psVector* restrict outVector, const psVector* restrict inVector) +{ + int inN = 0; + int outN = 0; + int elSize = 0; + void *inVec = NULL; + void *outVec = NULL; + psElemType inType = 0; + + if (inVector == NULL) { + psError(__func__, " : Line %d - Null input vector\n", __LINE__); + return outVector; + } + + inType = inVector->type.type; + inN = inVector->n; + inVec = inVector->data.V; + elSize = PSELEMTYPE_SIZEOF(inType); + + if (outVector == NULL) { + outVector = psVectorAlloc(inN, inType); + outVector->n = inVector->n; + } + + outN = outVector->n; + outVec = outVector->data.V; + + if (inN != outN) { + psError(__func__, " : Line %d - Input and output vector sizes are not equal: in=%d out=%d\n", + __LINE__, inN, outN); + return outVector; + } + + if (inType != outVector->type.type) { + psError(__func__, " : Line %d - Input and output vectors are not same type: in=%d out=%d\n", __LINE__, + inType, outVector->type.type); + return outVector; + } + + if (inN == 0) { + psError(__func__, " : Line %d - No elements in use for input vector\n", __LINE__); + return outVector; + } + + if (outN == 0) { + psError(__func__, " : Line %d - No elements in use for output vector\n", __LINE__); + return outVector; + } + // Copy input vector values into output vector + memcpy(outVec, inVec, elSize * outN); + + // Sort output vector + switch (inType) { + case PS_TYPE_U8: + qsort(outVec, inN, elSize, psCompareU8); + break; + case PS_TYPE_U16: + qsort(outVec, inN, elSize, psCompareU16); + break; + case PS_TYPE_U32: + qsort(outVec, inN, elSize, psCompareU32); + break; + case PS_TYPE_U64: + qsort(outVec, inN, elSize, psCompareU64); + break; + case PS_TYPE_S8: + qsort(outVec, inN, elSize, psCompareS8); + break; + case PS_TYPE_S16: + qsort(outVec, inN, elSize, psCompareS16); + break; + case PS_TYPE_S32: + qsort(outVec, inN, elSize, psCompareS32); + break; + case PS_TYPE_S64: + qsort(outVec, inN, elSize, psCompareS64); + break; + case PS_TYPE_F32: + qsort(outVec, inN, elSize, psCompareF32); + break; + case PS_TYPE_F64: + qsort(outVec, inN, elSize, psCompareF64); + break; + default: + psError(__func__, " : Line %d - Invalid psType\n", __LINE__); + } + + return outVector; +} + +#define SORT_INDICES(TYPE) \ +for(i=0; idata.TYPE[i] - inVec[j]); \ + if(diff < FLT_EPSILON) { \ + outVec[i] = j; \ + break; \ + } \ + } \ +} + +psVector* psVectorSortIndex(psVector* restrict outVector, const psVector* restrict inVector) +{ + int inN = 0; + int outN = 0; + int i = 0; + int j = 0; + float *inVec = NULL; + int *outVec = NULL; + double diff = 0.0f; + psVector* tmpVector = NULL; + psElemType inType = 0; + + if (inVector == NULL) { + psError(__func__, " : Line %d - Null input vector\n", __LINE__); + return outVector; + } + + inN = inVector->n; + inVec = inVector->data.V; + inType = inVector->type.type; + + if (outVector == NULL) { + outVector = psVectorAlloc(inN, PS_TYPE_U32); + outVector->n = inN; + } + + outN = outVector->n; + outVec = outVector->data.V; + + if (inN != outN) { + psError(__func__, " : Line %d - Input and output vector sizes are not equal: in=%d out=%d\n", + __LINE__, inN, outN); + return outVector; + } + + if (outVector->type.type != PS_TYPE_U32) { + psError(__func__, " : Line %d - Output vector is not of type U32: out=%d\n", + __LINE__, outVector->type.type); + return outVector; + } + + tmpVector = psVectorAlloc(inN, inType); + tmpVector->n = inN; + tmpVector = psVectorSort(tmpVector, inVector); + + // Sort output vector + switch (inType) { + case PS_TYPE_U8: + SORT_INDICES(U8); + break; + case PS_TYPE_U16: + SORT_INDICES(U16); + break; + case PS_TYPE_U32: + SORT_INDICES(U32); + break; + case PS_TYPE_U64: + SORT_INDICES(U64); + break; + case PS_TYPE_S8: + SORT_INDICES(S8); + break; + case PS_TYPE_S16: + SORT_INDICES(S16); + break; + case PS_TYPE_S32: + SORT_INDICES(S32); + break; + case PS_TYPE_S64: + SORT_INDICES(S64); + break; + case PS_TYPE_F32: + SORT_INDICES(F32); + break; + case PS_TYPE_F64: + SORT_INDICES(F64); + break; + default: + psError(__func__, " : Line %d - Invalid psType\n", __LINE__); + } + + // Free temp memory + psFree(tmpVector); + + return outVector; +} + +static void vectorFree(psVector* restrict psVec) +{ + if (psVec == NULL) { + return; + } + + psFree(psVec->data.V); +} Index: /tags/rel2_1/psLib/src/mathtypes/psVector.h =================================================================== --- /tags/rel2_1/psLib/src/mathtypes/psVector.h (revision 1553) +++ /tags/rel2_1/psLib/src/mathtypes/psVector.h (revision 1553) @@ -0,0 +1,133 @@ + +/** @file psVector.h + * + * @brief Contains basic vector definitions and operations + * + * This file defines the basic type for a vector struct and functions useful + * in manupulating vectors. + * + * @ingroup Vector + * + * @author Robert DeSonia, MHPCC + * @author Ross Harman, MHPCC + * + * @version $Revision: 1.20 $ $Name: not supported by cvs2svn $ + * @date $Date: 2004-08-11 20:17:35 $ + * + * Copyright 2004 Maui High Performance Computing Center, University of Hawaii + */ + +#ifndef PS_VECTOR_H +#define PS_VECTOR_H + +#include "psType.h" + +/// @addtogroup Vector +/// @{ + +/** An vector to support primitive types. + * + * Struct for maintaining an vector of frequently used primitive types. + * + */ +typedef struct +{ + psType type; ///< Type of data. + unsigned int nalloc; ///< Total number of elements available. + unsigned int n; ///< Number of elements in use. + + union { + psU8* U8; ///< Unsigned 8-bit integer data. + psU16* U16; ///< Unsigned 16-bit integer data. + psU32* U32; ///< Unsigned 32-bit integer data. + psU64* U64; ///< Unsigned 64-bit integer data. + psS8* S8; ///< Signed 8-bit integer data. + psS16* S16; ///< Signed 16-bit integer data. + psS32* S32; ///< Signed 32-bit integer data. + psS64* S64; ///< Signed 64-bit integer data. + psF32* F32; ///< Single-precision float data. + psF64* F64; ///< Double-precision float data. + psC32* C32; ///< Single-precision complex data. + psC64* C64; ///< Double-precision complex data. + psPTR V; ///< Pointer to data. + } data; ///< Union for data types. +} +psVector; + +/*****************************************************************************/ + +/* FUNCTION PROTOTYPES */ + +/*****************************************************************************/ + +/** Allocate a vector. + * + * Uses psLib memory allocation functions to create a vector collection of + * data as defined by the psType type. + * + * @return psVector* Pointer to psVector. + */ +psVector* psVectorAlloc( + unsigned int nalloc, ///< Total number of elements to make available. + psElemType dataType ///< Type of data to be held by vector. +); + +/** Reallocate a vector. + * + * Uses psLib memory allocation functions to reallocate a vector collection + * of data. The vector is reallocated according to the psType type member + * contained within the vector. + * + * @return psVector* Pointer to psVector. + * + */ +psVector* psVectorRealloc( + unsigned int nalloc, ///< Total number of elements to make available. + psVector* restrict psVec ///< Vector to reallocate. +); + +/** Recycle a vector. + * + * Uses psLib memory allocation functions to reallocate a vector collection + * of data. The vector is reallocated according to the psElemType type + * parameter. + * + * @return psVector* Pointer to psVector. + * + */ +psVector* psVectorRecycle( + psVector* restrict psVec, + ///< Vector to recycle. If NULL, a new vector is created. No effort + ///< taken to preserve the values. + + unsigned int nalloc, ///< Total number of elements to make available. + psElemType type ///< the datatype of the returned vector +); + +/** Sort an array of floats. + * + * Sorts an array of floats in ascending order. This function is valid for + * all non-complex data types. + * + * @return psVector* Pointer to sorted psVector. + */ +psVector* psVectorSort( + psVector* restrict outVector, ///< the output vector to recycle, or NULL if new vector desired. + const psVector* restrict inVector ///< the vector to sort. +); + +/** Creates an array of indices based on sort ordered of array. + * + * Sorts a vector and creates an integer array holding indices of + * sorted float values based on pre-sort index positions. + * + * @return psVector* vector of the indices of sort. + */ +psVector* psVectorSortIndex( + psVector* restrict outVector, ///< vector to recycle + const psVector* restrict inVector ///< vector to sort +); + +/// @} + +#endif Index: /tags/rel2_1/psLib/src/pslib.h =================================================================== --- /tags/rel2_1/psLib/src/pslib.h (revision 1553) +++ /tags/rel2_1/psLib/src/pslib.h (revision 1553) @@ -0,0 +1,158 @@ + +/** @file pslib.h +* +* @brief Contains the complete list of header files for pslib. +* +* This header file includes all the necessary header files for a user to +* user all public functions within the pslib library. +* +* @author Eric Van Alst, MHPCC +* +* @version $Revision: 1.20 $ $Name: not supported by cvs2svn $ +* @date $Date: 2004-08-09 23:40:54 $ +* +* Copyright 2004 Maui High Performance Computing Center, University of Hawaii +*/ + +#ifndef PS_LIB_H +#define PS_LIB_H + +/******************************************************************************/ + +/* INCLUDE FILES */ + +/******************************************************************************/ + +// System Utilities + +/// @defgroup SysUtils System Utilities +/// @{ + +/** @defgroup MemoryManagement Memory Management Utilities + * + * This is the generic memory management system put inbetween the user's high level code and the OS-level + * memory allocation routines. This system adds such features as callback routines for memory error events, + * tracing capabilities, and reference counting. + * + * @ingroup SysUtils + */ + +#include "fitsio.h" + +#include "psMemory.h" + +/// @defgroup LogTrace Tracing and Logging +/// @ingroup SysUtils +#include "psLogMsg.h" +#include "psTrace.h" + +/// @defgroup ErrorHandling Error Handling +/// @ingroup SysUtils +#include "psAbort.h" +#include "psError.h" + +#include "psString.h" + +/// @} + +// Collections +/// @defgroup DataContainer Data Containers +/// @{ + +#include "psType.h" + +/// @defgroup LinkedList Linked List +/// @ingroup DataContainer +#include "psList.h" + +/// @defgroup HashTable Hash Table +/// @ingroup DataContainer +#include "psHash.h" + +/// @defgroup Scalar Scalar +/// @ingroup DataContainer +#include "psScalar.h" + +/// @defgroup Vector Vector Container +/// @ingroup DataContainer +#include "psVector.h" + +/// @defgroup Array Array Container +/// @ingroup DataContainer +#include "psArray.h" + +/// @defgroup Image Image Container +/// @ingroup DataContainer +/// @{ +#include "psImage.h" +#include "psImageExtraction.h" +#include "psImageManip.h" + +/// @defgroup ImageIO Image File I/O Functions +/// @ingroup Image +#include "psImageIO.h" + +/// @defgroup ImageStats Image Statistical Functions +/// @ingroup Image +#include "psImageStats.h" + +/// @} + +/// @defgroup BitSet Bit Set Container +/// @ingroup DataContainer +#include "psBitSet.h" + +/// @} + +// Data Manipulation +/// @defgroup DataManip Data Manipulation +/// @{ + +/// @defgroup Compare Comparison Functions +/// @ingroup DataManip +#include "psCompare.h" + +/// @defgroup Stats Statistic Functions +/// @ingroup DataManip +#include "psStats.h" + +/// @defgroup Matrix Matrix Operations +/// @ingroup DataManip +#include "psMatrix.h" + +/// @defgroup MatrixVectorArithmetic Matrix Vector Arithmetic Operations +/// @ingroup DataManip +#include "psMatrixVectorArithmetic.h" + +/// @defgroup Transform Fourier Transform Operations +/// @ingroup DataManip +#include "psFFT.h" + +#include "psFunctions.h" +#include "psMinimize.h" + +/// @} + +// Astronomy +/// @defgroup Astronomy Astronomy Functions +/// @{ + +/// @defgroup CoordinateTransform Coordinate Functions +/// @ingroup Astronomy +#include "psCoord.h" + +/// @defgroup Photometry Photometry +/// @ingroup Astronomy +#include "psPhotometry.h" + +/// @defgroup Time Time Functions +/// @ingroup Astronomy +#include "psTime.h" + +/// @defgroup Metadata Metadata Functions +/// @ingroup Astronomy +#include "psMetadata.h" + +/// @} + +#endif Index: /tags/rel2_1/psLib/src/sys/psAbort.c =================================================================== --- /tags/rel2_1/psLib/src/sys/psAbort.c (revision 1553) +++ /tags/rel2_1/psLib/src/sys/psAbort.c (revision 1553) @@ -0,0 +1,89 @@ + +/** @file psAbort.c + * + * @brief Contains the definition for abort function + * + * The abort logging and handling shall be performed by psAbort function. + * This will allow for consistent handling of other software units + * needing to abort from program execution. + * + * @author Eric Van Alst, MHPCC + * + * @version $Revision: 1.8 $ $Name: not supported by cvs2svn $ + * @date $Date: 2004-08-07 00:06:06 $ + * + * Copyright 2004 Maui High Performance Computing Center, University of Hawaii + */ + +/******************************************************************************/ + +/* INCLUDE FILES */ + +/******************************************************************************/ +#include +#include +#include "psAbort.h" +#include "psLogMsg.h" + +/******************************************************************************/ + +/* DEFINE STATEMENTS */ + +/******************************************************************************/ + +// None + +/******************************************************************************/ + +/* TYPE DEFINITIONS */ + +/******************************************************************************/ + +// None + +/*****************************************************************************/ + +/* GLOBAL VARIABLES */ + +/*****************************************************************************/ + +// None + +/*****************************************************************************/ + +/* FILE STATIC VARIABLES */ + +/*****************************************************************************/ + +// None + +/*****************************************************************************/ + +/* FUNCTION IMPLEMENTATION - LOCAL */ + +/*****************************************************************************/ + +// None + +/*****************************************************************************/ + +/* FUNCTION IMPLEMENTATION - PUBLIC */ + +/*****************************************************************************/ + +void psAbort(const char *name, const char *fmt, ...) +{ + va_list argPtr; // variable list arguement pointer + + // Get the variable list parameters to pass to logging function + va_start(argPtr, fmt); + + // Call logging function with PS_LOG_ABORT level + psLogMsgV(name, PS_LOG_ABORT, fmt, argPtr); + + // Clean up stack after variable arguement has been used + va_end(argPtr); + + // Call system abort function to terminate program execution + abort(); +} Index: /tags/rel2_1/psLib/src/sys/psAbort.h =================================================================== --- /tags/rel2_1/psLib/src/sys/psAbort.h (revision 1553) +++ /tags/rel2_1/psLib/src/sys/psAbort.h (revision 1553) @@ -0,0 +1,47 @@ + +/** @file psAbort.h + * + * @brief Contains the declarations for the abort function + * + * The abort logging and handling shall be performed by psAbort function. + * This will allow for consistent handling of other software units + * needing to abort from program execution. + * + * @ingroup ErrorHandling + * + * @author Eric Van Alst, MHPCC + * + * @version $Revision: 1.8 $ $Name: not supported by cvs2svn $ + * @date $Date: 2004-08-10 01:55:34 $ + * + * Copyright 2004 Maui High Performance Computing Center, University of Hawaii + */ + +#ifndef PS_ABORT_H +#define PS_ABORT_H + +// Doxygen grouping tags + +/** @addtogroup ErrorHandling + * @{ + */ + +/** Reports an abort message to logging facility + * + * This function will invoke the psLogMsg function with a level of + * PS_LOG_ABORT and pass the parameters name and fmt to generate a proper + * log message. After logging, this function will call system abort + * function to abnormally terminate the program. + * + * @return void No return value + * + */ +void psAbort( + const char *name, ///< Source of abort such as file or function detected + const char *fmt, ///< A printf style formatting statement defining msg + ... +); + +/* @} */// Doxygen - End of SystemGroup Functions + +#endif Index: /tags/rel2_1/psLib/src/sys/psError.c =================================================================== --- /tags/rel2_1/psLib/src/sys/psError.c (revision 1553) +++ /tags/rel2_1/psLib/src/sys/psError.c (revision 1553) @@ -0,0 +1,86 @@ + +/** @file psError.c + * + * @brief Contains the definitions for the error reporting functions + * + * Error reporting functions shall be used to create log entries in the + * event errors are detected. The messages shall give enough information + * to allow the user to know where the error has occurred and the type + * of error detected. + * + * @author Eric Van Alst, MHPCC + * + * @version $Revision: 1.10 $ $Name: not supported by cvs2svn $ + * @date $Date: 2004-08-07 00:06:06 $ + * + * Copyright 2004 Maui High Performance Computing Center, University of Hawaii + */ + +/******************************************************************************/ + +/* INCLUDE FILES */ + +/******************************************************************************/ +#include +#include "psLogMsg.h" +#include "psError.h" + +/******************************************************************************/ + +/* DEFINE STATEMENTS */ + +/******************************************************************************/ + +// None + +/******************************************************************************/ + +/* TYPE DEFINITIONS */ + +/******************************************************************************/ + +// None + +/*****************************************************************************/ + +/* GLOBAL VARIABLES */ + +/*****************************************************************************/ + +// None + +/*****************************************************************************/ + +/* FILE STATIC VARIABLES */ + +/*****************************************************************************/ + +// None + +/*****************************************************************************/ + +/* FUNCTION IMPLEMENTATIONS - LOCAL */ + +/*****************************************************************************/ + +// None + +/*****************************************************************************/ + +/* FUNCTION IMPLEMENTATIONS - PUBLIC */ + +/*****************************************************************************/ + +void psError(const char *name, const char *fmt, ...) +{ + va_list argPtr; // variable list arguement pointer + + // Get the variable list parameters to pass to logging function + va_start(argPtr, fmt); + + // Call logging function with PS_LOG_ERROR level + psLogMsgV(name, PS_LOG_ERROR, fmt, argPtr); + + // Clean up stack after variable argument has been used + va_end(argPtr); +} Index: /tags/rel2_1/psLib/src/sys/psError.h =================================================================== --- /tags/rel2_1/psLib/src/sys/psError.h (revision 1553) +++ /tags/rel2_1/psLib/src/sys/psError.h (revision 1553) @@ -0,0 +1,43 @@ + +/** @file psError.h + * + * @brief Contains the declarations for the error reporting functions + * + * Error reporting functions shall be used to create log entries in the + * event errors are detected. The messages shall give enough information + * to allow the user to know where the error has occurred and the type + * of error detected. + * + * @ingroup ErrorHandling + * + * @author Eric Van Alst, MHPCC + * + * @version $Revision: 1.8 $ $Name: not supported by cvs2svn $ + * @date $Date: 2004-08-10 01:55:34 $ + * + * Copyright 2004 Maui High Performance Computing Center, University of Hawaii + */ + +#ifndef PS_ERROR_H +#define PS_ERROR_H + +/** @addtogroup ErrorHandling + * @{ + */ + +/** Reports an error message to the logging facility + * + * This function will invoke the psLogMsg function with a level of + * PS_LOG_ERROR and pass the parameters name and fmt to generate a proper + * log message. + * + */ +void psError( + const char *name, ///< Source of error such as file or function detected + const char *fmt, ///< A printf style formatting statement defining msg + ... +); + +/* @} */// End of SysUtils Functions + +#endif Index: /tags/rel2_1/psLib/src/sys/psLogMsg.c =================================================================== --- /tags/rel2_1/psLib/src/sys/psLogMsg.c (revision 1553) +++ /tags/rel2_1/psLib/src/sys/psLogMsg.c (revision 1553) @@ -0,0 +1,365 @@ + +/** @file psLogMsg.c + * @brief Procedures for logging messages. + * \ingroup LogTrace + * + * This file will hold the prototypes for defining procedure which set + * message log levels, messahe log formats, message log destinations, and + * for generating the messages themselves. + * @ingroup LogTrace + * + * @author Robert Lupton, Princeton University + * @author George Gusciora, MHPCC + * + * @version $Revision: 1.26 $ $Name: not supported by cvs2svn $ + * @date $Date: 2004-08-10 01:55:34 $ + * + * Copyright 2004 Maui High Performance Computing Center, University of Hawaii + */ + +/***************************************************************************** +NOTES: currently, the prototype code has the following global variables: + static int p_psGlobalLogDest; + static int p_psGlobalLogLevel; + static int p_psLogTime; + static int p_psLogHost; + static int p_psLogLevel; + static int p_psLogName; + static int p_psLogMsg; + *****************************************************************************/ +#include +#include +#include +#include +#include +#include +#include +#include + +#include "psLogMsg.h" +#include "psError.h" +#include "psTrace.h" + +#define MIN_LOG_LEVEL 0 +#define MAX_LOG_LEVEL 9 + +#define MAX_LOG_LINE_LENGTH 128 +static FILE *logDest = (FILE *) 1; // flag to initialize to stderr before using. +static int globalLogLevel = PS_LOG_INFO; // log all messages at this or above +static bool logTime = true; // Flag to include time info +static bool logHost = true; // Flag to include host info +static bool logLevel = true; // Flag to include level info +static bool logName = true; // Flag to include name info +static bool logMsg = true; // Flag to include message info + +/***************************************************************************** +psLogSetLevel(): Set the current log level and return old level. +Input: + level (int): the new log level. +Output: + none +Return: + The old log level. + *****************************************************************************/ +int psLogSetLevel(int level) +{ + // Save old global log level for changing it. + int oldLevel = globalLogLevel; + + if ((level < MIN_LOG_LEVEL) || (level > MAX_LOG_LEVEL)) { + psLogMsg("logmsg", PS_LOG_WARN, "Attempt to set invalid logMsg level: %d", level); + level = (level < MIN_LOG_LEVEL) ? MIN_LOG_LEVEL : MAX_LOG_LEVEL; + } + // Set new global log level + globalLogLevel = level; + + // Return old global log level + return oldLevel; +} + +/***************************************************************************** +psLogSetDestination(): sets the destination where log messages will be +sent to. + +Input: + dest (int): the new log destination +Output: + None. +Return: + An integer specifying the old log destination. + *****************************************************************************/ +bool psLogSetDestination(const char *dest) +{ + char protocol[5]; + char location[257]; + + // if logDest has not been initialized, do so before using it + if (logDest == (FILE *) 1) { + logDest = stderr; + } + + if (dest == NULL || strcmp(dest, "none") == 0) { + if (logDest != NULL && logDest != stderr && logDest != stdout) { + fclose(logDest); + } + logDest = NULL; + return true; + } + + if (sscanf(dest, "%4s:%256s", protocol, location) < 2) { + psError(__func__, "The specified destination, %s, is malformed.", dest); + return false; + } + + if (strcmp(protocol, "dest") == 0) { + if (strcmp(location, "stderr") == 0) { + if (logDest != NULL && logDest != stderr && logDest != stdout) { + fclose(logDest); + } + logDest = stderr; + return true; + } + if (strcmp(location, "stdout") == 0) { + if (logDest != NULL && logDest != stderr && logDest != stdout) { + fclose(logDest); + } + logDest = stdout; + return true; + } + psError(__func__, "The location, %s, for protocol 'dest' is invalid.", location); + return 1; + } else if (strcmp(protocol, "file") == 0) { + FILE *file = fopen(location, "w"); + + if (file == NULL) { + psError(__func__, "Could not open file '%s' for output.", location); + return false; + } + if (logDest != NULL && logDest != stderr && logDest != stdout) { + fclose(logDest); + } + logDest = file; + return true; + } + + psError(__func__, "Do not know how to handle the protocol '%s'.", protocol); + return false; +} + +/***************************************************************************** +psLogSetFormat(): Set the format of psLogMsg output. More precisely, + provide a string consisting of the letters {H (host), L (level), M + (message), N (name), T (time)}. The default is "HLMNT". This string + determines whether or not they associated type of information will be + included in message logs. It does not determine the order in which that + information will appear (that order is fixed). + +Input: + fmt: a string specifying the format. +Output: + none. +Return: + NULL. + *****************************************************************************/ +void psLogSetFormat(const char *fmt) +{ + // assume nothing desired unless specified + logHost = false; + logLevel = false; + logMsg = false; + logName = false; + logTime = false; + + // if fmt is NULL, no logging is desired. + if (fmt == NULL) { + return; + } + + if (strlen(fmt) == 0) { + fmt = "THLNM"; + } + // Step through each character in the format string. For each letter + // in that string, set/unset the appropriate logging. + + for (const char *ptr = fmt; *ptr != '\0'; ptr++) { + switch (*ptr) { + case 'H': + case 'h': + logHost = true; + break; + case 'L': + case 'l': + logLevel = true; + break; + case 'M': + case 'm': + logMsg = true; + break; + case 'N': + case 'n': + logName = true; + break; + case 'T': + case 't': + logTime = true; + break; + default: + psError(__func__, "Unknown logging keyword %c", *ptr); + break; + } + } + + if (!logMsg) { + psTrace("utils.logMsg", 1, "You must at least log error messages (You chose \"%s\")", fmt); + } +} + +#if !defined(HOST_NAME_MAX) // should be in limits.h +#define HOST_NAME_MAX 256 +#endif + +/***************************************************************************** + psVLogMsg(): This routine sends the message, which is a printf style + string specified in the "..." argument, to the current message log + destination with the severity specified by the "level" argument. + Input: + name + level + fmt + ap + Output: + none + Return: + NULL. + *****************************************************************************/ +void psLogMsgV(const char *name, int level, const char *fmt, va_list ap) +{ + static int first = 1; // Flag for calling gethostname() + static char hostname[HOST_NAME_MAX + 1]; + + // Buffer for hostname. + char clevel = 0; // letter-name for level + char head[MAX_LOG_LINE_LENGTH + 2]; // the added two are for the ending | and \0 + char *head_ptr = head; // where we've got to in head + int maxLength = MAX_LOG_LINE_LENGTH; + time_t clock = time(NULL); // The current time. + struct tm *utc = gmtime(&clock); // The current gm time. + + // if logDest has not been initialized, do so before using it + if (logDest == (FILE *) 1) { + logDest = stderr; + } + // If logging is off, or if the level is too high, return immediately. + if ((level > globalLogLevel) || (logDest == NULL)) { + return; + } + // If I have not been here yet, determine my hostname and save it. + if (first) { + first = 0; + gethostname(hostname, HOST_NAME_MAX); + } + + switch (level) { + case PS_LOG_ABORT: + clevel = 'A'; + break; + + case PS_LOG_ERROR: + clevel = 'E'; + break; + + case PS_LOG_WARN: + clevel = 'W'; + break; + + case PS_LOG_INFO: + clevel = 'I'; + break; + + case 4: + case 5: + case 6: + case 7: + case 8: + case 9: + clevel = level + '0'; + break; + + default: + psTrace("utils.logMsg", 2, "Invalid logMsg level: %d (%s)\n", level, fmt); + level = (level < 0) ? 0 : 9; + break; + } + + // Create the various log fields... + if (logTime) { + maxLength -= snprintf(head_ptr, maxLength, "%4d:%02d:%02d %02d:%02d:%02dZ", + utc->tm_year + 1900, utc->tm_mon + 1, utc->tm_mday, + utc->tm_hour, utc->tm_min, utc->tm_sec) - 1; + head_ptr += strlen(head_ptr); + } + // Hostname should be 20 characters. + if (logHost) { + if (head_ptr > head) { + *head_ptr++ = '|'; + } + maxLength -= snprintf(head_ptr, maxLength, "%-20s", hostname); + head_ptr += strlen(head_ptr); + } + if (logLevel) { + if (head_ptr > head) { + *head_ptr++ = '|'; + } + maxLength -= snprintf(head_ptr, maxLength, "%c", clevel); + head_ptr += strlen(head_ptr); + } + // The name field must be 15 characters. + if (logName) { + if (head_ptr > head) { + *head_ptr++ = '|'; + } + maxLength -= snprintf(head_ptr, maxLength, "%15.15s", name); + head_ptr += strlen(head_ptr); + } + + if (head_ptr > head) { + *head_ptr++ = '|'; + } else if (!logMsg) { // no output desired + return; + } + *head_ptr = '\0'; + + fputs(head, logDest); + if (logMsg) { + vfprintf(logDest, fmt, ap); + if (fmt[strlen(fmt) - 1] != '\n') { + fputc('\n', logDest); + } + } else { + fputc('\n', logDest); + } +} + +/***************************************************************************** + psLogMsg(): This routine sends the message, which is a printf style + string specified in the "..." argument, to the current message log + destination with the severity specified by the "level" argument. + Input: + name: Indicates the source of this log message. + level: The severity of this log message. + fmt: The printf-stype formatted string, followed by the arguments + to that string. + ... The arguments to the above printf-style string. + Output: + none + Return: + NULL + *****************************************************************************/ +void psLogMsg(const char *name, int level, const char *fmt, ...) +{ + va_list ap; + + va_start(ap, fmt); + psLogMsgV(name, level, fmt, ap); + va_end(ap); +} Index: /tags/rel2_1/psLib/src/sys/psLogMsg.h =================================================================== --- /tags/rel2_1/psLib/src/sys/psLogMsg.h (revision 1553) +++ /tags/rel2_1/psLib/src/sys/psLogMsg.h (revision 1553) @@ -0,0 +1,104 @@ + +/** @file psLogMsg.h + * @brief Procedures for logging messages. + * \ingroup LogTrace + * + * This file will hold the prototypes for defining procedure which set + * message log levels, messahe log formats, message log destinations, and + * for generating the messages themselves. + * @ingroup LogTrace + * + * @author Robert Lupton, Princeton University + * @author George Gusciora, MHPCC + * + * @version $Revision: 1.16 $ $Name: not supported by cvs2svn $ + * @date $Date: 2004-08-10 01:55:34 $ + * + * Copyright 2004 Maui High Performance Computing Center, University of Hawaii + */ +#if !defined(PS_LOG_MSG_H) +#define PS_LOG_MSG_H +#include +#include + +/** @addtogroup LogTrace + * @{ + */ + +/** This procedure sets the destination for future log messages. Currently + * the destination is specified by an integer which can have the following + * pre-defined values: PS_LOG_NONE, PS_LOG_TO_STDOUT, and PS_LOG_TO_STDERR. + * In future versions, this procedure will take a character string as an + * argument which can specify more general log destinations. + * + * @return int true if set successfully, otherwise false. + */ +bool psLogSetDestination( + const char *dest ///< Specifies where to send messages. +); + +/** This procedure sets the message level for future log messages. Subsequent + * log messages, with a log level of "mylevel", will only be logged if + * "mylevel" is less than the current log level set by this procedure. + * Ie. higher values set by this procedure will cause more log messages to + * be displayed. + * + * @return int old logging level + */ +int psLogSetLevel( + int level ///< Specifies the system log level +); + +/** This procedure sets the log format for future log messages. The argument + * must be a character string consistsing of the letters H (host), L + * (level), M (message), N (name), and T (time). The default is "THLNM". + * Deleting a letter from the string will cause the associated information + * to not be logged. + * + */ +void psLogSetFormat( + const char *fmt ///< Specifies the system log format +); + +/** This procedure logs a message to the destination set by a prior + * call to psLogSetDestination(), if myLevel is less than the level + * specified by a prior call to psLogSetLevel(). The message is specified + * with a printf-stype string an arguments. + * + */ +void psLogMsg( + const char *name, ///< name of the log source + int myLevel, ///< severity level of this log message + const char *fmt, ///< printf-style format command + ... +); + +/** This procedure is functionally equivalent to psLogMsg(), except that + * it takes a va_list as the message parameter, not a printf-style string. + * + */ +void psLogMsgV( + const char *name, ///< name of the log source + int myLevel, ///< severity level of this log message + const char *fmt, ///< printf-style format command + va_list ap ///< varargs argument list +); + +///< Status codes for log messages +enum { + PS_LOG_ABORT = 0, ///< log message is a critical error, perform an abort after printing + PS_LOG_ERROR, ///< log message is an error, but don't abort + PS_LOG_WARN, ///< log message is a warning + PS_LOG_INFO ///< log message is informational only +}; + +///< Destinations for log messages +enum { + PS_LOG_NONE, ///< turn off logging + PS_LOG_TO_STDERR, ///< log to system's stderr + PS_LOG_TO_STDOUT ///< log to system's stdout +}; + +/// @} + +#endif Index: /tags/rel2_1/psLib/src/sys/psMemory.c =================================================================== --- /tags/rel2_1/psLib/src/sys/psMemory.c (revision 1553) +++ /tags/rel2_1/psLib/src/sys/psMemory.c (revision 1553) @@ -0,0 +1,631 @@ + +/** @file psMemory.c +* +* @brief Contains the definitions for the memory management system +* +* psMemory.h has additional information and documentation of the routines found in this file. +* +* @author Robert DeSonia, MHPCC +* @author Robert Lupton, Princeton University +* +* @version $Revision: 1.34 $ $Name: not supported by cvs2svn $ +* @date $Date: 2004-08-09 23:34:58 $ +* +* Copyright 2004 Maui High Performance Computing Center, University of Hawaii +*/ + +#define PS_ALLOW_MALLOC // we're allowed to call malloc() + +#include +#include +#include +#include + +#include "psMemory.h" +#include "psError.h" +#include "psAbort.h" +#include "psLogMsg.h" + +#define P_PS_MEMMAGIC (void *)0xdeadbeef // Magic number in psMemBlock header + +#define P_PS_LARGE_BLOCK_SIZE 65536 // size where under, we try to recycle + +static int checkMemBlock(const psMemBlock* m, const char *funcName); +static psMemBlock* lastMemBlockAllocated = NULL; +static pthread_mutex_t memBlockListMutex = PTHREAD_MUTEX_INITIALIZER; +static pthread_mutex_t memIdMutex = PTHREAD_MUTEX_INITIALIZER; + +static pthread_mutex_t recycleMemBlockListMutex = PTHREAD_MUTEX_INITIALIZER; + +static int recycleBins = 13; +static int recycleBinSize[14] = { + 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 8192, 16384, 32768, P_PS_LARGE_BLOCK_SIZE + }; + +// N.B. recycleBinSize should be terminated by P_PS_LARGE_BLOCK_SIZE (simplifies search loops) +static psMemBlock* recycleMemBlockList[13] = { + NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL + }; + +#ifdef PS_MEM_DEBUG +static psMemBlock* deadBlockList; // a place to put dead memBlocks in debug mode. +#endif + +/** + * Unique ID for allocated blocks + */ +static psMemoryId memid = 0; + +/** + * Default memExhausted callback. + */ +static void *memExhaustedCallbackDefault(size_t size) +{ + void *ptr = NULL; + + pthread_mutex_lock(&recycleMemBlockListMutex); + int level = recycleBins - 1; + + while (level >= 0 && ptr == NULL) { + while (recycleMemBlockList[level] != NULL && ptr == NULL) { + psMemBlock* old = recycleMemBlockList[level]; + + recycleMemBlockList[level] = recycleMemBlockList[level]->nextBlock; + free(old); + ptr = malloc(size); + } + level--; + } + pthread_mutex_unlock(&recycleMemBlockListMutex); + + return ptr; +} + +static psMemExhaustedCallback memExhaustedCallback = memExhaustedCallbackDefault; + +psMemExhaustedCallback psMemExhaustedCallbackSet(psMemExhaustedCallback func) +{ + psMemExhaustedCallback old = memExhaustedCallback; + + if (func != NULL) { + memExhaustedCallback = func; + } else { + memExhaustedCallback = memExhaustedCallbackDefault; + } + + return old; +} + +static void memProblemCallbackDefault(const psMemBlock* ptr, const char *file, int lineno) +{ + if (ptr->refCounter < 1) { + psError(__func__, + "Block %ld allocated at %s:%d freed more than once at %s:%d\n", + ptr->id, ptr->file, ptr->lineno, file, lineno); + } + + if (lineno > 0) { + psAbort(__func__, "Detected a problem in the memory system at %s:%d", file, lineno); + } +} +static psMemProblemCallback memProblemCallback = memProblemCallbackDefault; + +psMemProblemCallback psMemProblemCallbackSet(psMemProblemCallback func) +{ + psMemProblemCallback old = memProblemCallback; + + if (func != NULL) { + memProblemCallback = func; + } else { + memProblemCallback = memProblemCallbackDefault; + } + + return old; +} + +/* + * And now the I-want-to-be-informed callbacks + * + * Call the callbacks when these IDs are allocated/freed + */ +psMemoryId p_psMemAllocateID = 0; // notify user this block is allocated +psMemoryId p_psMemFreeID = 0; // notify user this block is freed + +psMemoryId psMemAllocateCallbackSetID(psMemoryId id) +{ + psMemoryId old = p_psMemAllocateID; + + p_psMemAllocateID = id; + + return old; +} + +psMemoryId psMemFreeCallbackSetID(psMemoryId id) +{ + psMemoryId old = p_psMemFreeID; + + p_psMemFreeID = id; + + return old; +} + +/* + * Default callback for both allocate and free. Note that the + * value of p_psMemAllocateID/p_psMemFreeID is incremented + * by the return value (so returning 0 means that the callback + * isn't resignalled) + */ +static psMemoryId memAllocateCallbackDefault(const psMemBlock* ptr) +{ + static psMemoryId incr = 0; // "p_psMemAllocateID += incr" + + return incr; +} + +static psMemoryId memFreeCallbackDefault(const psMemBlock* ptr) +{ + static psMemoryId incr = 0; // "p_psMemFreeID += incr" + + return incr; +} + +/* + * The default callbacks, and the routines to change them + */ +static psMemAllocateCallback memAllocateCallback = memAllocateCallbackDefault; +static psMemFreeCallback memFreeCallback = memFreeCallbackDefault; + +psMemAllocateCallback psMemAllocateCallbackSet(psMemAllocateCallback func) +{ + psMemFreeCallback old = memAllocateCallback; + + if (func != NULL) { + memAllocateCallback = func; + } else { + memAllocateCallback = memAllocateCallbackDefault; + } + + return old; +} + +psMemFreeCallback psMemFreeCallbackSet(psMemFreeCallback func) +{ + psMemFreeCallback old = memFreeCallback; + + if (func != NULL) { + memFreeCallback = func; + } else { + memFreeCallback = memFreeCallbackDefault; + } + + return old; +} + +/* + * Return memory ID counter for next block to be allocated + */ +psMemoryId psMemGetId(void) +{ + psMemoryId id; + + pthread_mutex_lock(&memIdMutex); + id = memid + 1; + pthread_mutex_unlock(&memIdMutex); + + return id; +} + +/* + * Routines to check the consistency of the allocated and/or free memory arena + * + * N.b. If the block wasn't allocated by psAlloc, it will appear corrupted + */ + +static int checkMemBlock(const psMemBlock* m, const char *funcName) +{ + // n.b. since this is called by psMemCheckCorruption while the memblock list is mutex locked, + // we shouldn't call such things as p_psAlloc/p_psFree here. + + if (m == NULL) { + psError(funcName, "Memory Corruption: NULL memory block found."); + return 1; + } + + if (m->refCounter == 0) { + // using an unreferenced block of memory, are you? + psError(__func__, "Memory Corruption: memory block %ld was freed but still used.", m->id); + return 1; + } + + if (m->startblock != P_PS_MEMMAGIC || m->endblock != P_PS_MEMMAGIC) { + psError(funcName, "Memory Corruption: memory block %ld is corrupted (buffer underflow)", m->id); + return 1; + } + if (*(void **)((int8_t *) (m + 1) + m->userMemorySize) != P_PS_MEMMAGIC) { + psError(funcName, "Memory Corruption: memory block %ld is corrupted (buffer overflow)", m->id); + return 1; + } + + return 0; +} + +int psMemCheckCorruption(bool abort_on_error) +{ + int nbad = 0; // number of bad blocks + + // get exclusive access to the memBlock list to avoid it changing on us while we use it. + pthread_mutex_lock(&memBlockListMutex); + + for (psMemBlock* iter = lastMemBlockAllocated; iter != NULL; iter = iter->nextBlock) { + if (checkMemBlock(iter, __func__)) { + nbad++; + + memProblemCallback(iter, __func__, __LINE__); + + if (abort_on_error) { + // release the lock on the memblock list + pthread_mutex_unlock(&memBlockListMutex); + psAbort(__func__, "Detected memory corruption"); + return nbad; + } + } + } + + // release the lock on the memblock list + pthread_mutex_unlock(&memBlockListMutex); + return nbad; +} + +void *p_psAlloc(size_t size, const char *file, int lineno) +{ + + psMemBlock* ptr = NULL; + + // memory is of the size I want to bother recycling? + if (size < P_PS_LARGE_BLOCK_SIZE) { + // find the bin we need. + int level = 0; + + while (size > recycleBinSize[level]) { + level++; + } + // Are we in one of the bins + if (level < recycleBins) { + + size = recycleBinSize[level]; // round-up size to next sized bin. + + pthread_mutex_lock(&recycleMemBlockListMutex); + + if (recycleMemBlockList[level] != NULL) { + ptr = recycleMemBlockList[level]; + recycleMemBlockList[level] = ptr->nextBlock; + if (recycleMemBlockList[level] != NULL) { + recycleMemBlockList[level]->previousBlock = NULL; + } + size = ptr->userMemorySize; + } + + pthread_mutex_unlock(&recycleMemBlockListMutex); + } + } + + if (ptr == NULL) { + ptr = malloc(sizeof(psMemBlock) + size + sizeof(void *)); + + if (ptr == NULL) { + ptr = memExhaustedCallback(size); + if (ptr == NULL) { + psAbort(__func__, "Failed to allocate %u bytes at %s:%d", size, file, lineno); + } + } + + ptr->startblock = P_PS_MEMMAGIC; + ptr->endblock = P_PS_MEMMAGIC; + ptr->userMemorySize = size; + pthread_mutex_init(&ptr->refCounterMutex, NULL); + } + // increment the memory id safely. + pthread_mutex_lock(&memBlockListMutex); + *(psMemoryId* ) & ptr->id = ++memid; + pthread_mutex_unlock(&memBlockListMutex); + + ptr->file = file; + ptr->freeFcn = NULL; + *(unsigned int *)&ptr->lineno = lineno; + *(void **)((int8_t *) (ptr + 1) + size) = P_PS_MEMMAGIC; + ptr->previousBlock = NULL; + + ptr->refCounter = 1; // one user so far + + // need exclusive access of the memory block list now... + pthread_mutex_lock(&memBlockListMutex); + + // insert the new block to the front of the memBlock linked-list + ptr->nextBlock = lastMemBlockAllocated; + if (ptr->nextBlock != NULL) { + ptr->nextBlock->previousBlock = ptr; + } + lastMemBlockAllocated = ptr; + + pthread_mutex_unlock(&memBlockListMutex); + + // Did the user ask to be informed about this allocation? + if (ptr->id == p_psMemAllocateID) { + p_psMemAllocateID += memAllocateCallback(ptr); + } + // And return the user the memory that they allocated + return ptr + 1; // user memory +} + +void *p_psRealloc(void *vptr, size_t size, const char *file, int lineno) +{ + if (vptr == NULL) { + return p_psAlloc(size, file, lineno); + } else { + psMemBlock* ptr = ((psMemBlock* ) vptr) - 1; + bool isBlockLast = false; + + if (checkMemBlock(ptr, __func__) != 0) { + memProblemCallback(ptr, file, lineno); + psAbort(file, "Realloc detected a memory corruption (id %ld @ %s:%d).", + ptr->id, ptr->file, ptr->lineno); + } + + pthread_mutex_lock(&memBlockListMutex); + + isBlockLast = (ptr == lastMemBlockAllocated); + + ptr = (psMemBlock* ) realloc(ptr, sizeof(psMemBlock) + size + sizeof(void *)); + + if (ptr == NULL) { + psAbort(__func__, "Failed to reallocate %ld bytes at %s:%d", size, file, lineno); + } + + ptr->userMemorySize = size; + *(void **)((int8_t *) (ptr + 1) + size) = P_PS_MEMMAGIC; + + if (isBlockLast) { + lastMemBlockAllocated = ptr; + } + // the block location may have changed, so fix the linked list addresses. + if (ptr->nextBlock != NULL) { + ptr->nextBlock->previousBlock = ptr; + } + if (ptr->previousBlock != NULL) { + ptr->previousBlock->nextBlock = ptr; + } + + pthread_mutex_unlock(&memBlockListMutex); + + // Did the user ask to be informed about this allocation? + if (ptr->id == p_psMemAllocateID) { + p_psMemAllocateID += memAllocateCallback(ptr); + } + + return ptr + 1; // usr memory + } +} + +void p_psFree(void *vptr, const char *file, int lineno) +{ + (void)p_psMemDecrRefCounter(vptr, file, lineno); // this handles the free, if required. +} + +/* + * Check for memory leaks. + */ +int psMemCheckLeaks(psMemoryId id0, psMemBlock* ** arr, FILE * fd) +{ + int nleak = 0; + int j = 0; + psMemBlock* topBlock = lastMemBlockAllocated; + + pthread_mutex_lock(&memBlockListMutex); + + for (psMemBlock* iter = topBlock; iter != NULL; iter = iter->nextBlock) { + if ((psMemGetRefCounter(iter + 1) > 0) && (iter->id >= id0)) { + nleak++; + + if (fd != NULL) { + if (nleak == 1) { + fprintf(fd, " %20s:line ID\n", "file"); + } + + fprintf(fd, " %20s:%-4d %ld\n", iter->file, iter->lineno, iter->id); + } + } + } + + pthread_mutex_unlock(&memBlockListMutex); + + if (nleak == 0 || arr == NULL) { + return nleak; + } + + *arr = p_psAlloc(nleak * sizeof(psMemBlock), __FILE__, __LINE__); + pthread_mutex_lock(&memBlockListMutex); + + for (psMemBlock* iter = topBlock; iter != NULL; iter = iter->nextBlock) { + if ((psMemGetRefCounter(iter + 1) > 0) && (iter->id >= id0)) { + (*arr)[j++] = iter; + if (j == nleak) { // found them all + break; + } + } + } + + pthread_mutex_unlock(&memBlockListMutex); + + return nleak; +} + +/* + * Reference counting APIs + */ +// return refCounter +psReferenceCount psMemGetRefCounter(void *vptr) +{ + psMemBlock* ptr; + unsigned int refCount; + + if (vptr == NULL) { + return 0; + } + + ptr = ((psMemBlock* ) vptr) - 1; + + if (checkMemBlock(ptr, __func__) != 0) { + memProblemCallback(ptr, __func__, __LINE__); + } + + pthread_mutex_lock(&ptr->refCounterMutex); + refCount = ptr->refCounter; + pthread_mutex_unlock(&ptr->refCounterMutex); + + return refCount; +} + +// increment and return refCounter +void *p_psMemIncrRefCounter(void *vptr, const char *file, int lineno) +{ + psMemBlock* ptr; + + if (vptr == NULL) { + return vptr; + } + + ptr = ((psMemBlock* ) vptr) - 1; + + if (checkMemBlock(ptr, __func__)) { + memProblemCallback(ptr, file, lineno); + } + + pthread_mutex_lock(&ptr->refCounterMutex); + ptr->refCounter++; + pthread_mutex_unlock(&ptr->refCounterMutex); + + return vptr; +} + +// decrement and return refCounter +void *p_psMemDecrRefCounter(void *vptr, const char *file, int lineno) +{ + if (vptr == NULL) { + return NULL; + } + + psMemBlock* ptr = ((psMemBlock* ) vptr) - 1; + + if (checkMemBlock(ptr, __func__) != 0) { + memProblemCallback(ptr, file, lineno); + return NULL; + } + + pthread_mutex_lock(&ptr->refCounterMutex); + + if (ptr->refCounter > 1) { + // / XXX - Probably should have another mutex here. + ptr->refCounter--; // multiple references, just decrement the count. + pthread_mutex_unlock(&ptr->refCounterMutex); + + } else { + pthread_mutex_unlock(&ptr->refCounterMutex); + + // Did the user ask to be informed about this deallocation? + if (ptr->id == p_psMemFreeID) { + p_psMemFreeID += memFreeCallback(ptr); + } + + if (ptr->freeFcn != NULL) { + ptr->freeFcn(vptr); + } + + pthread_mutex_lock(&memBlockListMutex); + + // cut the memBlock out of the memBlock list + if (ptr->nextBlock != NULL) { + ptr->nextBlock->previousBlock = ptr->previousBlock; + } + if (ptr->previousBlock != NULL) { + ptr->previousBlock->nextBlock = ptr->nextBlock; + } + if (lastMemBlockAllocated == ptr) { + lastMemBlockAllocated = ptr->nextBlock; + } + + pthread_mutex_unlock(&memBlockListMutex); + + // do we need to recycle? + if (ptr->userMemorySize < P_PS_LARGE_BLOCK_SIZE) { + + int level = 1; + + while (ptr->userMemorySize >= recycleBinSize[level]) { + level++; + } + level--; + + ptr->refCounter = 0; + ptr->previousBlock = NULL; + + pthread_mutex_lock(&recycleMemBlockListMutex); + ptr->nextBlock = recycleMemBlockList[level]; + if (recycleMemBlockList[level] != NULL) { + recycleMemBlockList[level]->previousBlock = ptr; + } + recycleMemBlockList[level] = ptr; + pthread_mutex_unlock(&recycleMemBlockListMutex); + + } else { + // memory is larger than I want to recycle. + #ifdef PS_MEM_DEBUG + (void)p_psRealloc(vptr, 0, file, lineno); + ptr->previousBlock = NULL; + ptr->nextBlock = deadBlockList; + if (deadBlockList != NULL) { + deadBlockList->previous = ptr; + } + deadBlockList = ptr; + #else + + pthread_mutex_destroy(&ptr->refCounterMutex); + free(ptr); + #endif + + } + + vptr = NULL; // since we freed it, make sure we return NULL. + } + + return vptr; +} + +void p_psMemSetDeallocator(void *vptr, psFreeFcn freeFcn) +{ + if (vptr == NULL) { + return; + } + + psMemBlock* ptr = ((psMemBlock* ) vptr) - 1; + + if (checkMemBlock(ptr, __func__) != 0) { + memProblemCallback(ptr, __func__, __LINE__); + } + + ptr->freeFcn = freeFcn; + +} +psFreeFcn p_psMemGetDeallocator(void *vptr) +{ + if (vptr == NULL) { + return NULL; + } + + psMemBlock* ptr = ((psMemBlock* ) vptr) - 1; + + if (checkMemBlock(ptr, __func__) != 0) { + memProblemCallback(ptr, __func__, __LINE__); + } + + return ptr->freeFcn; +} Index: /tags/rel2_1/psLib/src/sys/psMemory.h =================================================================== --- /tags/rel2_1/psLib/src/sys/psMemory.h (revision 1553) +++ /tags/rel2_1/psLib/src/sys/psMemory.h (revision 1553) @@ -0,0 +1,393 @@ +/** @file psMemory.h + * + * @brief Contains the definitions for the memory management system + * + * This is the generic memory management system put inbetween the user's high level code and the OS-level + * memory allocation routines. This system adds such features as callback routines for memory error events, + * tracing capabilities, and reference counting. + * + * @author Robert DeSonia, MHPCC + * @author Robert Lupton, Princeton University + * + * @ingroup MemoryManagement + * + * @version $Revision: 1.28 $ $Name: not supported by cvs2svn $ + * @date $Date: 2004-08-10 01:55:34 $ + * + * Copyright 2004 Maui High Performance Computing Center, University of Hawaii + */ + +#if !defined(PS_MEMORY_H) +#define PS_MEMORY_H + +#include // needed for FILE +#include +#include // we need a mutex to make this stuff thread safe. + +/** @addtogroup MemoryManagement + * @{ + */ + +/** + * @addtogroup memCallback Memory Callbacks + * + * Routines dealing with the creating and setting of memory management callback functions. + */ + +/** + * @addtogroup memTracing Memory Tracing + * + * Routines dealing with memory tracing and corruption checking. + */ + +/** + * @addtogroup memRefCount Reference Count + * + * Routines dealing with the reference counting of allocated buffers. + */ + +/// typedef for memory identification numbers. Guaranteed to be some variety of integer. +typedef unsigned long psMemoryId; + +/// typedef for a memory block's reference count. Guaranteed to be some variety of integer. +typedef unsigned long psReferenceCount; + +/// typedef for deallocator. +typedef void (*psFreeFcn) (void *ptr); + +/** Book-keeping data for storage allocator. + * N.b. sizeof(psMemBlock) must be chosen such that if ptr is a pointer + * returned by malloc, then ((char *)ptr + sizeof(psMemBlock)) is properly + * aligned for all storage types. + */ +typedef struct psMemBlock +{ + const void *startblock; ///< initialised to p_psMEMMAGIC + struct psMemBlock* previousBlock; ///< previous block in allocation list + struct psMemBlock* nextBlock; ///< next block allocation list + psFreeFcn freeFcn; ///< deallocator. If NULL, use generic deallocation. + size_t userMemorySize; ///< the size of the user-portion of the memory block + const psMemoryId id; ///< a unique ID for this allocation + const char *file; ///< set from __FILE__ in e.g. p_psAlloc + const int lineno; ///< set from __LINE__ in e.g. p_psAlloc + pthread_mutex_t refCounterMutex; ///< mutex to ensure exclusive access to reference counter + psReferenceCount refCounter; ///< how many times pointer is referenced + const void *endblock; ///< initialised to p_psMEMMAGIC +} +psMemBlock; + +/** prototype of a basic callback used by memory functions + * + * @see psMemAllocateCallbackSet + * @ingroup memCallback + */ +typedef psMemoryId(*psMemAllocateCallback) ( + const psMemBlock* ptr ///< the psMemBlock just allocated +); + +/** prototype of memory free callback used by memory functions + * + * @see psMemFreeCallbackSet + * @ingroup memCallback + */ +typedef psMemoryId(*psMemFreeCallback) ( + const psMemBlock* ptr ///< the psMemBlock being freed +); + +/** prototype of a callback used in error conditions + * + * This callback should not try to call psAlloc or psFree. + * + * @see psMemProblemCallbackSet + * @ingroup memCallback + */ +typedef void (*psMemProblemCallback) ( + const psMemBlock* ptr, ///< the pointer to the problematic memory block. + const char *file, ///< the file in which the problem originated + int lineno ///< the line number in which the problem originated +); + +/** prototype of a callback function used when memory runs out + * + * @return void* pointer to requested buffer of the size size_t, or NULL if memory could not + * be found. + * + * @see psMemExhaustedCallbackSet + * @ingroup memCallback + */ +typedef void *(*psMemExhaustedCallback) ( + size_t size ///< the size of buffer required +); + +/** Memory allocation. This operates much like malloc(), but is guaranteed to return a non-NULL value. + * + * @return void* pointer to the allocated buffer. This will not be NULL. + * @see psFree + */ +#ifdef DOXYGEN +void *psAlloc(size_t size ///< Size required + ); +#else + +void *p_psAlloc(size_t size, ///< Size required + const char *file, ///< File of call + int lineno ///< Line number of call + ); + +void p_psMemSetDeallocator(void *ptr, psFreeFcn freeFcn); +psFreeFcn p_psMemGetDeallocator(void *ptr); + +/// Memory allocation. psAlloc sends file and line number to p_psAlloc. +#define psAlloc(size) p_psAlloc(size, __FILE__, __LINE__) +#endif + +/** Memory re-allocation. This operates much like realloc(), but is guaranteed to return a non-NULL value. + * + * @return void* pointer to resized buffer. This will not be NULL. + * @see psAlloc, psFree + */ +#ifdef DOXYGEN +void *psRealloc( + void *ptr ///< Pointer to re-allocate + size_t size, ///< Size required +); +#else + +void *p_psRealloc( + void *ptr, ///< Pointer to re-allocate + size_t size, ///< Size required + const char *file, ///< File of call + int lineno ///< Line number of call +); + +/// Memory re-allocation. psRealloc sends file and line number to p_psRealloc. +#define psRealloc(ptr, size) p_psRealloc(ptr, size, __FILE__, __LINE__) + +#endif + +/** Free memory. This operates much like free(). + * + * @see psAlloc, psRealloc + */ +#ifdef DOXYGEN +void psFree( + void *ptr, ///< Pointer to free, if NULL, function returns immediately. +); +#else + +void p_psFree( + void *ptr, ///< Pointer to free + const char *file, ///< File of call + int lineno ///< Line number of call +); + +/// Free memory. psFree sends file and line number to p_psFree. +#define psFree(size) p_psFree(size, __FILE__, __LINE__) + +#endif + +/** Check for memory leaks. This scans for allocated memory buffers not freed with an ID not less than id0. + * This is used to check for memory leaks by: + * -# before a block of code to be checked, store the current ID count via psGetMemId + * -# after the block of code to be checked, call this function using the ID stored above. If all + * memory in the block that was allocated has been freed, this call should output nothing and + * return 0. + * + * If memory leaks are found, the Memory Problem callback will be called as well. + * + * return int number of memory blocks found as 'leaks', i.e., the number of currently allocated memory + * blocks above id0 that have not been freed. + * @see psAlloc, psFree, psgetMemId, psMemProblemCallbackSet + * @ingroup memTracing + */ +int psMemCheckLeaks( + psMemoryId id0, ///< don't list blocks with id < id0 + psMemBlock* ** arr, ///< pointer to array of pointers to leaked blocks, or NULL + FILE * fd ///< print list of leaks to fd (or NULL) +); + +/** Check for memory corruption. Scans all currently allocated memory buffers and checks for corruptions, + * i.e., invalid markers that signify a buffer under/overflow. + * + * @ingroup memTracing + */ +int psMemCheckCorruption( + bool abort_on_error ///< Abort on detecting corruption? +); + +/** Return reference counter + * + * @ingroup memRefCount + */ +psReferenceCount psMemGetRefCounter( + void *vptr ///< Pointer to get refCounter for +); + +/** Increment reference counter and return the pointer + * + * @ingroup memRefCount + */ +#ifdef DOXYGEN +void *psMemIncrRefCounter( + void *vptr ///< Pointer to increment refCounter, and return +); +#else + +void *p_psMemIncrRefCounter( + void *vptr, ///< Pointer to increment refCounter, and return + const char *file, ///< File of call + int lineno ///< Line number of call +); + +#define psMemIncrRefCounter(vptr) p_psMemIncrRefCounter(vptr, __FILE__, __LINE__) +#endif + +/** Decrement reference counter and return the pointer + * + * @ingroup memRefCount + * + * @return void* the pointer deremented in refCount, or NULL if pointer is + * fully dereferenced. + */ +#ifdef DOXYGEN +void* psMemDecrRefCounter( + void* vptr ///< Pointer to decrement refCounter, and return +); +#else + +void *p_psMemDecrRefCounter( + void *vptr, ///< Pointer to decrement refCounter, and return + const char *file, ///< File of call + int lineno ///< Line number of call +); + +#define psMemDecrRefCounter(vptr) p_psMemDecrRefCounter(vptr, __FILE__, __LINE__) +#endif + +/** Set callback for problems. + * + * At various occasions, the memory manager can check the state of the memory + * stack. If any of these checks discover that the memory stack is corrupted, + * the psMemProblemCallback is called. + + * @ingroup memCallback + * + * @return psMemProblemCallback old psMemProblemCallback function + */ +psMemProblemCallback psMemProblemCallbackSet( + psMemProblemCallback func ///< Function to run at memory problem detection +); + +/** Set callback for out-of-memory. + * + * If not enough memory is available to satisfy a request by psAlloc or + * psRealloc, these functions attempt to find an alternative solution by + * calling the psMemExhaustedCallback, a function which may be set by the + * programmer in appropriate circumstances, rather than immediately fail. + * The typical use of such a feature may be when a program needs a large + * chunk of memory to do an operation, but the exact size is not critical. + * This feature gives the programmer the opportunity to make a smaller + * request and try again, limiting the size of the operating buffer. + * + * @ingroup memCallback + * + * @return psMemExhaustedCallback old psMemExhaustedCallback function + */ +psMemExhaustedCallback psMemExhaustedCallbackSet( + psMemExhaustedCallback func ///< Function to run at memory exhaustion +); + +/** Set call back for when a particular memory block is allocated + * + * A private variable, p_psMemAllocateID, can be used to trace the allocation + * and freeing of specific memory blocks. If p_psMemAllocateID is set and a + * memory block with that ID is allocated, psMemAllocateCallback is called + * just before memory is returned to the calling function. + * + * @ingroup memCallback + * + * @return psMemAllocateCallback old psMemAllocateCallback function + */ +psMemAllocateCallback psMemAllocateCallbackSet( + psMemAllocateCallback func ///< Function to run at memory allocation of specific mem block +); + +/** Set call back for when a particular memory block is freed + * + * A private variable, p_psMemFreeID, can be used to trace the freeing of + * specific memory blocks. If p_psMemFreeID is set and the memory block with + * the ID is about to be freed, the psMemFreeCallback callback is called just + * before the memory block is freed. + * + * @ingroup memCallback + * + * @return psMemFreeCallback old psMemFreeCallback function + */ +psMemFreeCallback psMemFreeCallbackSet( + psMemFreeCallback func ///< Function to run at memory free of specific mem block +); + +/** get next memory ID + * + * @ingroup memCallback + * + * @return psMemoryId the next memory ID to be used + */ +psMemoryId psMemGetId(void); + +/** set p_psMemAllocateID to specific id + * + * A private variable, p_psMemAllocateID, can be used to trace the allocation + * and freeing of specific memory blocks. If p_psMemAllocateID is set and a + * memory block with that ID is allocated, psMemAllocateCallback is called + * just before memory is returned to the calling function. + * + * @ingroup memCallback + * + * @return psMemoryId + * + * @see psMemAllocateCallbackSet + */ +psMemoryId psMemAllocateCallbackSetID( + psMemoryId id ///< ID to set +); + +/** set p_psMemFreeID to id + * + * A private variable, p_psMemFreeID, can be used to trace the freeing of + * specific memory blocks. If p_psMemFreeID is set and the memory block with + * the ID is about to be freed, the psMemFreeCallback callback is called just + * before the memory block is freed. + * + * @ingroup memCallback + * + * @return psMemoryId the old p_psMemFreeID + * + * @see psMemFreeCallbackSet + */ +psMemoryId psMemFreeCallbackSetID( + psMemoryId id ///< ID to set +); + +//@} End of Memory Management Functions + +#ifndef DOXYGEN + +/* + * Ensure that any program using malloc/realloc/free will fail to compile + */ +#ifndef PS_ALLOW_MALLOC +#ifdef __GNUC__ +#pragma GCC poison malloc realloc calloc free +#else +#define malloc(S) _Pragma("error Use of malloc is not allowed. Use psAlloc instead.") +#define realloc(P,S) _Pragma("error Use of realloc is not allowed. Use psRealloc instead.") +#define calloc(S) _Pragma("error Use of calloc is not allowed. Use psAlloc instead.") +#define free(P) _Pragma("error Use of free is not allowed. Use psFree instead.") +#endif +#endif + +#endif +// doxygen skip + +#endif // end of header file Index: /tags/rel2_1/psLib/src/sys/psString.c =================================================================== --- /tags/rel2_1/psLib/src/sys/psString.c (revision 1553) +++ /tags/rel2_1/psLib/src/sys/psString.c (revision 1553) @@ -0,0 +1,103 @@ + +/** @file psString.c + * + * @brief Contains the definition of string utility functions + * + * String utility functions defined shall provide basic string copying + * capabilities while using the preferred memory management utilities. + * + * @author Eric Van Alst, MHPCC + * + * @version $Revision: 1.8 $ $Name: not supported by cvs2svn $ + * @date $Date: 2004-08-07 00:06:06 $ + * + * Copyright 2004 Maui High Performance Computing Center, University of Hawaii + */ + +/******************************************************************************/ + +/* INCLUDE FILES */ + +/******************************************************************************/ +#include +#include +#include "psString.h" +#include "psMemory.h" +#include "psError.h" + +/******************************************************************************/ + +/* DEFINE STATEMENTS */ + +/******************************************************************************/ + +// None + +/******************************************************************************/ + +/* TYPE DEFINITIONS */ + +/******************************************************************************/ + +// None + +/*****************************************************************************/ + +/* GLOBAL VARIABLES */ + +/*****************************************************************************/ + +// None + +/*****************************************************************************/ + +/* FILE STATIC VARIABLES */ + +/*****************************************************************************/ + +// None + +/*****************************************************************************/ + +/* FUNCTION IMPLEMENTATION - LOCAL */ + +/*****************************************************************************/ + +// None + +/*****************************************************************************/ + +/* FUNCTION IMPLEMENTATION - PUBLIC */ + +/*****************************************************************************/ + +char *psStringCopy(const char *str) +{ + // Allocate memory using psAlloc function + // Copy input string to memory just allocated + // Return the copy + return strcpy(psAlloc(strlen(str) + 1), str); +} + +char *psStringNCopy(const char *str, int nChar) +{ + char *returnValue = NULL; + + // Check the number of characters to copy is non-negative + if (nChar < 0) { + // Log error message and return NULL + psError(__FILE__, "psStringNCopy with negative count specified %d", nChar); + return NULL; + } + // Allocate memory using psAlloc function - nChar bytes + // Copy input string to memory allocated up to nChar characters + // Return the copy + returnValue = strncpy(psAlloc((size_t) nChar + 1), str, (size_t) nChar); + + // Ensure the last byte is NULL character + if (nChar > 0) { + returnValue[nChar - 1] = '\0'; + } + // Return the string pointer + return returnValue; +} Index: /tags/rel2_1/psLib/src/sys/psString.h =================================================================== --- /tags/rel2_1/psLib/src/sys/psString.h (revision 1553) +++ /tags/rel2_1/psLib/src/sys/psString.h (revision 1553) @@ -0,0 +1,70 @@ +/** @file psString.h + * + * @brief Contains the declarations of string utility functions + * + * @ingroup SysUtils + * + * String utility functions defined shall provide basic string copying + * capabilities. + * + * @author Eric Van Alst, MHPCC + * + * @version $Revision: 1.8 $ $Name: not supported by cvs2svn $ + * @date $Date: 2004-08-10 01:55:34 $ + * + * Copyright 2004 Maui High Performance Computing Center, University of Hawaii + */ + +#ifndef PS_STRING_H +#define PS_STRING_H + + +/** This macro will convert the argument to a quoted string */ +#define PS_STRING(S) #S + +// Doxygen group tags + +/** @addtogroup SysUtils + * @{ + */ + +/** Copies the input string + * + * This function shall allocate memory to the length of the input string + * plus one and copy the input string to the newly allocated memory. + * + * @return char* Copy of input string + * + */ +char *psStringCopy( + const char *str + /**< Input string of characters to copy */ +); + +/** Copies the input string up to the specified number of characters + * + * This function shall allocate memory to the length specified by nChar + * plus one and copy the input string to the newly allocated memory. + * This function will only copy nChar bytes from the input to new string, + * so if the input string is larger than nChar characters the copied + * string will be a substring of the input string. If the input string + * is smaller than nChar bytes then the remaining bytes allocated will + * be set to NULL. + * + * @return char* Copy of input string + * + */ + +/*@null@*/ + +char *psStringNCopy( + const char *str, + /**< Input string of characters to copy */ + + int nChar + /**< Number of bytes to allocate for string copy */ +); + +/* @} */// Doxygen - End of SystemGroup Functions + +#endif Index: /tags/rel2_1/psLib/src/sys/psTrace.c =================================================================== --- /tags/rel2_1/psLib/src/sys/psTrace.c (revision 1553) +++ /tags/rel2_1/psLib/src/sys/psTrace.c (revision 1553) @@ -0,0 +1,402 @@ + +/** @file psTrace.c + * \brief basic run-time trace facilities + * \ingroup LogTrace + * + * This file will hold the code for procedures to insert + * trace messages into the code. + * + * @author Robert Lupton, Princeton University + * @author George Gusciora, MHPCC + * + * @version $Revision: 1.17 $ $Name: not supported by cvs2svn $ + * @date $Date: 2004-08-09 23:40:55 $ + * + * Copyright 2004 Maui High Performance Computing Center, University of Hawaii + */ + +/***************************************************************************** + NOTES: + In the SRD, higher trace levels correspond to a numerically lower trace + value in the code. This is a bit confusing. For example, a high-level + message might be something like "Begin Processing". The module programmer + might give that a numerically low trace level, such as 1, so then any + non-zero trace level in that code component will display thatmessage. + + We build a tree of trace components. Every node in the tree has a + depth, which is it's distance from the root. However, this is not + not the same thing as a node's "level", which corresponds to the + trace level of that node. + + I added a function psTraceFree() which frees all nodes in the trace component + tree. Previously, there had been no function in the API which accomplished + this purpose. + *****************************************************************************/ + +#ifndef PS_NO_TRACE + +#include +#include +#include +#include +#include "psMemory.h" +#include "psTrace.h" +#include "psString.h" +#include "psError.h" + +static p_psComponent* p_psCroot = NULL; // The root of the trace component +static FILE *p_psTraceFP = NULL; // File destination for messages. + +static void componentFree(p_psComponent* comp); +static p_psComponent* componentAlloc(const char *name, int level); + +/***************************************************************************** +componentAlloc(): allocate memory for a new node, and initialize members. + *****************************************************************************/ +static p_psComponent* componentAlloc(const char *name, int level) +{ + p_psComponent* comp = psAlloc(sizeof(p_psComponent)); + + p_psMemSetDeallocator(comp, (psFreeFcn) componentFree); + comp->name = psStringCopy(name); + comp->level = level; + comp->n = 0; + comp->subcomp = NULL; + return comp; +} + +/***************************************************************************** +componentFree(): free the current node in the root tree, and all children +nodes as well. + *****************************************************************************/ +static void componentFree(p_psComponent* comp) +{ + if (comp == NULL) { + return; + } + + if (comp->subcomp != NULL) { + for (int i = 0; i < comp->n; i++) { + psFree(comp->subcomp[i]); + } + psFree(comp->subcomp); + } + + psFree((char *)comp->name); +} + +/***************************************************************************** +initTrace(): simply initialize the component root tree. +*****************************************************************************/ +static void initTrace(void) +{ + if (p_psCroot == NULL) { + p_psCroot = componentAlloc(".", PS_DEFAULT_TRACE_LEVEL); + } +} + +/***************************************************************************** +Set all trace levels to zero. + *****************************************************************************/ +void p_psTraceReset(p_psComponent* currentNode) +{ + int i = 0; + + if (NULL == currentNode) { + return; + } + + currentNode->level = 0; + for (i = 0; i < currentNode->n; i++) { + if (NULL == currentNode->subcomp[i]) { + psError(__func__, + "Sub-component %d of node %s in the trace tree is NULL.\n", i, currentNode->name); + } else { + p_psTraceReset(currentNode->subcomp[i]); + } + } + return; +} + +/***************************************************************************** +Set all trace levels to zero. + *****************************************************************************/ +void psTraceReset() +{ + p_psTraceReset(p_psCroot); +} + +/***************************************************************************** +Free all nodes in the component tree. + *****************************************************************************/ +void psTraceFree() +{ + psFree(p_psCroot); +} + +/***************************************************************************** +componentAdd(): Adds the component named "addNodeName" to the root tree. + +NOTE: replace the call to strsep() with a call to strtok(), which conforms +to ANSI-C. + *****************************************************************************/ +static void componentAdd(const char *addNodeName, int level) +{ + int i = 0; // Loop index variable. + char name[strlen(addNodeName) + 1]; // buffer for writeable copy. + char *pname = name; + char *firstComponent = NULL; // first component of name + p_psComponent* currentNode = p_psCroot; + int nodeExists = 0; + + // Is this the root node? If so, simply set level and return. + if (strcmp(".", addNodeName) == 0) { + p_psCroot->level = level; + return; + } + + if (addNodeName[0] != '.') { + printf("ERROR: failed to add %s to the root component tree.\n", addNodeName); + exit(1); + } + + strcpy(name, addNodeName); + pname = &name[1]; + // Iterate through the components of addNodeName. Strip off the first + // component of the name, find that in the root tree, or add it if it + // does not exist, then move to the next component in the name. + + while (pname != NULL) { + firstComponent = strsep(&pname, "."); + nodeExists = 0; + for (i = 0; i < currentNode->n; i++) { + if (strcmp(currentNode->subcomp[i]->name, firstComponent) == 0) { + currentNode = currentNode->subcomp[i]; + nodeExists = 1; + if (pname == NULL) { + currentNode->level = level; + } + } + } + + if (nodeExists == 0) { + currentNode->subcomp = psRealloc(currentNode->subcomp, + (currentNode->n + 1) * sizeof(p_psComponent* )); + currentNode->n = (currentNode->n) + 1; + + currentNode->subcomp[(currentNode->n) - 1] = componentAlloc(firstComponent, level); + } + } +} + +/***************************************************************************** + psSetTraceLevel(): add the component named "comp" to the component tree, + if it is not already there, and set it's trace level to "level". + Input: + comp + level + Output: + none + Returns: + zero +*****************************************************************************/ +int psTraceSetLevel(const char *comp, // component of interest + int level) // desired trace level +{ + // If the root component tree does not exist, then initialize it. + if (p_psCroot == NULL) { + initTrace(); + } + // Add the new component to the component tree. + componentAdd(comp, level); + + // return 0 on success. + return 0; +} + +/***************************************************************************** + doGetTraceLevel() + This function recursively searches the root component tree for the + component named "name", which is supplied by a parameter. If it + finds that component, it returns the level of that component. + Otherwise, it returns ???. + + Inputs: + name: + Outputs: + none + Returns: + The trace level of the "name" component. + *****************************************************************************/ +static int doGetTraceLevel(const char *aname) +{ + char name[strlen(aname) + 1]; // need a writeable copy: for strsep() + char *pname = name; + char *firstComponent = NULL; // first component of name + p_psComponent* currentNode = p_psCroot; + int i = 0; + + if (NULL == currentNode) { + return (PS_UNKNOWN_TRACE_LEVEL); + } + + if (strcmp(".", aname) == 0) { + return (p_psCroot->level); + } + + if (aname[0] != '.') { + return (PS_UNKNOWN_TRACE_LEVEL); + } + + strcpy(name, aname); + pname = &name[1]; + while (pname != NULL) { + firstComponent = strsep(&pname, "."); + for (i = 0; i < currentNode->n; i++) { + if (NULL == currentNode->subcomp[i]) { + psError(__func__, + "Sub-component %d of node %s in trace tree is NULL.\n", i, currentNode->name); + } + + if (strcmp(currentNode->subcomp[i]->name, firstComponent) == 0) { + currentNode = currentNode->subcomp[i]; + if (pname == NULL) { + return (currentNode->level); + } + } + } + } + return (PS_UNKNOWN_TRACE_LEVEL); +} + +/***************************************************************************** + psGetTraceLevel() + Return a trace level of "name" in the root component tree. If the + exact string of components in "name" does not exist in the root + tree, we return the deepest level of the match. + Input: + name + Output: + none + Return: + The level of "name" in the root component tree. + *****************************************************************************/ +int psTraceGetLevel(const char *name) +{ + if (p_psCroot == NULL) { + return (PS_UNKNOWN_TRACE_LEVEL); + } + // Search the component root tree, determine the trace level. + return (doGetTraceLevel(name)); +} + +/***************************************************************************** + doPrintTraceLevels() + This function recursively searches the component tree supplied by the + parameter "comp" and prints the name and level of each component. + Inputs: + comp: a node in the component tree. + level: the level of that node + Outputs: + none + Returns: + null + *****************************************************************************/ +static void doPrintTraceLevels(const p_psComponent* comp, int depth) +{ + int i = 0; + + if (comp->name[0] == '\0') { + printf("%*s%-*s %d\n", depth, "", 20 - depth, + "(root)", (comp->level == PS_UNKNOWN_TRACE_LEVEL) ? 0 : comp->level); + } else { + if (comp->level == PS_UNKNOWN_TRACE_LEVEL) { + printf("%*s%-*s %s\n", depth, "", 20 - depth, comp->name, "."); + } else { + printf("%*s%-*s %d\n", depth, "", 20 - depth, comp->name, comp->level); + } + } + + for (i = 0; i < comp->n; i++) { + doPrintTraceLevels(comp->subcomp[i], depth + 1); + } +} + +/***************************************************************************** +psPrintTraceLevels(): Simply print all the trace levels in the trace level +component tree. +Inputs: + none +Outputs: + none +Returns: + null +*****************************************************************************/ +void psTracePrintLevels(void) +{ + if (p_psCroot == NULL) { + return; + } + + doPrintTraceLevels(p_psCroot, 0); +} + +/***************************************************************************** +p_psTrace(): we display the trace message to standard output if the trace +level of that message, supplied by the parameter "level" is higher than the +trace level that is currently associated with the component named by the +parameter "comp". +Input: + comp + level + ... a printf-style output string. +Output: + none +Return: + null + *****************************************************************************/ +void p_psTrace(const char *comp, // component being traced + int level, // desired trace level + ...) // arguments +{ + char *fmt = NULL; + va_list ap; + int i = 0; + + if (NULL == comp) { + psError(__func__, "p_psTrace() called on a NULL trace level tree\n"); + } + // Only display this message if it's trace level is less than the level + // of it's associatedcomponent. + if (level <= psTraceGetLevel(comp)) { + va_start(ap, level); + + // The following functions get the variable list of parameters with + // which this function was called, and print them to the standard + // output. + fmt = va_arg(ap, char *); + + if (p_psTraceFP != NULL) { + // We indent each message one space for each level of the message. + for (i = 0; i < level; i++) { + fprintf(p_psTraceFP, " "); + } + vfprintf(p_psTraceFP, fmt, ap); + } else { + // We indent each message one space for each level of the message. + for (i = 0; i < level; i++) { + putchar(' '); + } + vprintf(fmt, ap); + } + va_end(ap); + } + // NOTE: should we free *fmt as well? Read the man page. +} + +void psTraceSetDestination(FILE * fp) +{ + p_psTraceFP = fp; +} + +#endif Index: /tags/rel2_1/psLib/src/sys/psTrace.h =================================================================== --- /tags/rel2_1/psLib/src/sys/psTrace.h (revision 1553) +++ /tags/rel2_1/psLib/src/sys/psTrace.h (revision 1553) @@ -0,0 +1,93 @@ + +/** @file psTrace.h + * \brief basic run-time trace facilities + * \ingroup LogTrace + * + * This file will hold the prototypes for defining procedures to insert + * trace messages into the code. + * + * @author Robert Lupton, Princeton University + * @author George Gusciora, MHPCC + * + * @version $Revision: 1.15 $ $Name: not supported by cvs2svn $ + * @date $Date: 2004-08-09 23:40:55 $ + * + * Copyright 2004 Maui High Performance Computing Center, University of Hawaii + */ +#if !defined(PS_TRACE_H) +#define PS_TRACE_H 1 + +#define PS_UNKNOWN_TRACE_LEVEL -9999 // we don't know this name's level +#define PS_DEFAULT_TRACE_LEVEL 0 + +/** \addtogroup LogTrace + * \{ + */ + +/** Functions **************************************************************/ + +//#define PS_NO_TRACE 1 ///< to turn off all tracing + +#if defined(PS_NO_TRACE) +# define psTrace(facil, level, ...) (void)0 +/* do nothing */ +# define p_psTrace(facil, level, ...) (void)0 +/* do nothing */ +# define psTraceSetLevel(facil,level) 0 +# define psTraceGetLevel(facil) 0 +# define psTraceReset() (void)0 /* do nothing */ +# define psTraceFree() (void)0 /* do nothing */ +# define psTracePrintLevels() (void)0 +/* do nothing */ +# define psTraceSetDestination(fp) (void)0 +/* do nothing */ +# else + + /** Basic structure for the component tree. A component is a string of the + form aaa.bbb.ccc, and may itself contain further subcomponents. The + Component structure doesn't in fact contain it's full name, but only the + last part. */ + typedef struct p_psComponent + { + const char *name; // last part of name of component + int level; // trace level for this component + int n; // number of subcomponents + struct p_psComponent* *subcomp; // next level of subcomponents + } +p_psComponent; + +#ifndef DOXYGEN +/// Send a trace message +void p_psTrace(const char *facil, ///< facilty of interest + int myLevel, ///< desired trace level + ...) ///< trace message arguments +; +#endif + +/// Set trace level +int psTraceSetLevel(const char *facil, ///< facilty of interest + int level) ///< desired trace level +; + +/// Get the trace level +int psTraceGetLevel(const char *facil) ///< facilty of interest +; + +/// Set all trace levels to zero (do not free nodes in the component tree). +void psTraceReset(); + +/// Free all nodes in the component tree. +void psTraceFree(); + +/// print trace levels +void psTracePrintLevels(void); + +/// Set the destination of future trace messages. +void psTraceSetDestination(FILE * fp); + +/* \} */// End of SystemGroup Functions + +#define psTrace(facil, level, ...) p_psTrace(facil, level, __VA_ARGS__) +#endif + +#endif Index: /tags/rel2_1/psLib/src/sys/psType.h =================================================================== --- /tags/rel2_1/psLib/src/sys/psType.h (revision 1553) +++ /tags/rel2_1/psLib/src/sys/psType.h (revision 1553) @@ -0,0 +1,156 @@ + +/** @file psType.h +* +* @brief Contains support for basic types +* +* This file defines common datatypes used throughout psLib. +* +* @ingroup DataContainer +* +* @author Robert DeSonia, MHPCC +* @author Ross Harman, MHPCC +* +* @version $Revision: 1.20 $ $Name: not supported by cvs2svn $ +* @date $Date: 2004-08-10 01:55:34 $ +* +* Copyright 2004 Maui High Performance Computing Center, University of Hawaii +*/ + +#ifndef PS_TYPE_H +#define PS_TYPE_H + +#include +#include +#include + +/// @addtogroup DataContainer +/// @{ + +/******************************************************************************/ + +/* TYPE DEFINITIONS */ + +/******************************************************************************/ + +/** Basic data types used by the containers. + * + * The basic types of the primitives used by psLib are defined within this enum. This enum is in turn used by + * the psType struct. + * + */ + +typedef uint8_t psU8; ///< 8-bit unsigned int +typedef uint16_t psU16; ///< 16-bit unsigned int +typedef uint32_t psU32; ///< 32-bit unsigned int +typedef uint64_t psU64; ///< 64-bit unsigned int +typedef int8_t psS8; ///< 8-bit signed int +typedef int16_t psS16; ///< 16-bit signed int +typedef int32_t psS32; ///< 32-bit signed int +typedef int64_t psS64; ///< 64-bit signed int +typedef float psF32; ///< 32-bit floating point +typedef double psF64; ///< 64-bit floating point +typedef complex float psC32; ///< complex with 32-bit floating point Real and Imagary numbers +typedef complex double psC64; ///< complex with 64-bit floating point Real and Imagary numbers +typedef void *psPTR; ///< void pointer + +typedef enum { + PS_TYPE_S8 = 0x0101, ///< Character. + PS_TYPE_S16 = 0x0102, ///< Short integer. + PS_TYPE_S32 = 0x0104, ///< Integer. + PS_TYPE_S64 = 0x0108, ///< Long integer. + PS_TYPE_U8 = 0x0301, ///< Unsigned character. + PS_TYPE_U16 = 0x0302, ///< Unsigned short integer. + PS_TYPE_U32 = 0x0304, ///< Unsigned integer. + PS_TYPE_U64 = 0x0308, ///< Unsigned long integer. + PS_TYPE_F32 = 0x0404, ///< Single-precision Floating point. + PS_TYPE_F64 = 0x0408, ///< Double-precision floating point. + PS_TYPE_C32 = 0x0808, ///< Complex numbers consisting of single-precision floating point. + PS_TYPE_C64 = 0x0810, ///< Complex numbers consisting of double-precision floating point. + PS_TYPE_PTR = 0x0000 ///< Something else that's not supported for arithmetic. +} psElemType; + +#define PS_TYPE_MASK PS_TYPE_U8 /**< the psElemType to use for mask image */ +#define PS_TYPE_MASK_DATA U8 /**< the data member to use for mask image */ +#define PS_TYPE_MASK_NAME "psU8" /**< the data type for mask as a string */ + +typedef psU8 psMaskType; ///< the C datatype for a mask image + + +#define PS_MIN_S8 INT8_MIN /**< minimum valid psS8 value */ +#define PS_MIN_S16 INT16_MIN /**< minimum valid psS16 value */ +#define PS_MIN_S32 INT32_MIN /**< minimum valid psS32 value */ +#define PS_MIN_S64 INT64_MIN /**< minimum valid psS64 value */ +#define PS_MIN_U8 0 /**< minimum valid psU8 value */ +#define PS_MIN_U16 0 /**< minimum valid psU16 value */ +#define PS_MIN_U32 0 /**< minimum valid psU32 value */ +#define PS_MIN_U64 0 /**< minimum valid psU64 value */ +#define PS_MIN_F32 -FLT_MAX /**< minimum valid psF32 value */ +#define PS_MIN_F64 -DBL_MAX /**< minimum valid psF64 value */ +#define PS_MIN_C32 -FLT_MAX /**< minimum valid real or imaginary psC32 value */ +#define PS_MIN_C64 -DBL_MAX /**< minimum valid real or imaginary psC32 value */ + +#define PS_MAX_S8 INT8_MAX /**< maximum valid psS8 value */ +#define PS_MAX_S16 INT16_MAX /**< maximum valid psS16 value */ +#define PS_MAX_S32 INT32_MAX /**< maximum valid psS32 value */ +#define PS_MAX_S64 INT64_MAX /**< maximum valid psS64 value */ +#define PS_MAX_U8 UINT8_MAX /**< maximum valid psU8 value */ +#define PS_MAX_U16 UINT16_MAX /**< maximum valid psU16 value */ +#define PS_MAX_U32 UINT32_MAX /**< maximum valid psU32 value */ +#define PS_MAX_U64 UINT64_MAX /**< maximum valid psU64 value */ +#define PS_MAX_F32 FLT_MAX /**< maximum valid psF32 value */ +#define PS_MAX_F64 DBL_MAX /**< maximum valid psF64 value */ +#define PS_MAX_C32 FLT_MAX /**< maximum valid real or imaginary psC32 value */ +#define PS_MAX_C64 DBL_MAX /**< maximum valid real or imaginary psC32 value */ + +/// Macro to get the bad pixel reason code (stored as part of mask value) +#define PS_BADPIXEL_BITMASK 0x0f +#define PS_GET_BADPIXEL(maskValue) (maskValue & PS_BADPIXEL_BITMASK) + +#define PS_IS_BADPIXEL(maskValue) (PS_GET_BADPIXEL(maskValue) != 0) + +/// Macro to apply a bad pixel reason code to mask image +#define PS_SET_BADPIXEL(maskValue, reasonCode) \ +{ \ + maskValue = (psMaskType)((reasonCode & PS_BADPIXEL_BITMASK) | (maskValue & ~PS_BADPIXEL_BITMASK)); \ +} + +/// Macro to determine if the psElemType is an integer. +#define PS_IS_PSELEMTYPE_INT(x) ((x & 0x100) == 0x100) +/// Macro to determine if the psElemType is unsigned. +#define PS_IS_PSELEMTYPE_UNSIGNED(x) ((x & 0x200) == 0x200) +/// Macro to determine if the psElemType is a real (non-complex) floating-point type. +#define PS_IS_PSELEMTYPE_REAL(x) ((x & 0x400) == 0x400) +/// Macro to determine if the psElemType is complex number type. +#define PS_IS_PSELEMTYPE_COMPLEX(x) ((x & 0x800) == 0x800) +/// Macro to determine the storage size, in bytes, of the psElemType. +#define PSELEMTYPE_SIZEOF(x) ( (x==PS_TYPE_PTR) ? sizeof(void*) :(x & 0xFF) ) + +/** Dimensions of a data type. + * + * The dimensions of containers used by psLib are defined within this enum. This enum is used by the psType +struct. * + */ +typedef enum { + PS_DIMEN_SCALAR, ///< Scalar. + PS_DIMEN_VECTOR, ///< Vector. + PS_DIMEN_TRANSV, ///< Transposed vector. + PS_DIMEN_IMAGE, ///< Image. + PS_DIMEN_OTHER ///< Something else that's not supported for arithmetic. +} psDimen; + +/** The type of a data type. + * + * All psLib complex types consist of primitive components. This struct provides the description of those + * primitives. + * + */ +typedef struct +{ + psElemType type; ///< Primitive type. + psDimen dimen; ///< Dimensionality. +} +psType; + +/// @} + +#endif Index: /tags/rel2_1/psLib/src/sysUtils/.cvsignore =================================================================== --- /tags/rel2_1/psLib/src/sysUtils/.cvsignore (revision 1553) +++ /tags/rel2_1/psLib/src/sysUtils/.cvsignore (revision 1553) @@ -0,0 +1,1 @@ +*.i Index: /tags/rel2_1/psLib/src/sysUtils/Makefile =================================================================== --- /tags/rel2_1/psLib/src/sysUtils/Makefile (revision 1553) +++ /tags/rel2_1/psLib/src/sysUtils/Makefile (revision 1553) @@ -0,0 +1,82 @@ +############################################################################### +## +## Makefile: sysUtils +## +## $Revision: 1.18 $ $Name: not supported by cvs2svn $ +## $Date: 2004-08-09 20:28:54 $ +## +## Copyright 2004 Maui High Performance Computing Center, University of Hawaii +############################################################################### + +# Define variable prefix to the top level project - psLib +# This is necessary for definition is Makefile.Globals uses prefix + +ifndef prefix + export prefix=$(shell cd ../..;pwd) +endif + +# Define the two targets to be built + +TARGET_STATIC = libpslib.a + +# Include the make global definitions for the project + +include ../Makefile.Globals + +# Set CFLAGS used by the implicit rule to compile .c + +CFLAGS := $(CFLAGS_RELOC) -I../collections -I../dataManip -I../sysUtils -I../include + +# Define the source objects + +SRC_OBJS = psMemory.o \ + psError.o \ + psTrace.o \ + psLogMsg.o \ + psAbort.o \ + psString.o + +OBJS = $(addprefix makedir/,$(SRC_OBJS)) + +# Define PHONY target "all" which will make all the necessary items + +all: $(TARGET_STATIC) + +# Rule to make static library + +libpslib.a: $(OBJS) +# The ar option -r is to add/replace object and -s is to create +# a symbol table in the archive + $(AR) rcs ../$@ $(OBJS) + +# Define PHONY target "install" which will install necessary files + +install: $(TARGET_STATIC) + install *.h $(includedir) + +# Define PHONY target "distclean" which will cleanup the distribution + +distclean: clean + $(RM) ../$(TARGET_STATIC) + +# Define PHONY target "clean" which will cleanup the development area + +clean: + @echo " Deleting intermediate files for 'sysUtils'" + $(RM) $(OBJS) *.lint + +cleandep: + $(RM) $(OBJS:.o=.d) + +%.lint: %.c + splint +posixlib -exportlocal -realcompare $(INCLUDE_GLOBAL) $? > $@; cat $@ + +makedir/%.o: %.c + $(CC) -c $(CFLAGS) -o $@ $< + +makedir/%.d: %.c + $(CC) -MM $(CFLAGS) $< > $@.tmp + sed 's|\($*\)\.o[ :]*|\1.o $@ : |g' $@.tmp > $@ + $(RM) -f $@.tmp + +include $(OBJS:.o=.d) Index: /tags/rel2_1/psLib/src/sysUtils/README =================================================================== --- /tags/rel2_1/psLib/src/sysUtils/README (revision 1553) +++ /tags/rel2_1/psLib/src/sysUtils/README (revision 1553) @@ -0,0 +1,2 @@ +This directory includes code related to the 'system utilities' section of the +IfA supplied SDR. Index: /tags/rel2_1/psLib/src/sysUtils/psAbort.c =================================================================== --- /tags/rel2_1/psLib/src/sysUtils/psAbort.c (revision 1553) +++ /tags/rel2_1/psLib/src/sysUtils/psAbort.c (revision 1553) @@ -0,0 +1,89 @@ + +/** @file psAbort.c + * + * @brief Contains the definition for abort function + * + * The abort logging and handling shall be performed by psAbort function. + * This will allow for consistent handling of other software units + * needing to abort from program execution. + * + * @author Eric Van Alst, MHPCC + * + * @version $Revision: 1.8 $ $Name: not supported by cvs2svn $ + * @date $Date: 2004-08-07 00:06:06 $ + * + * Copyright 2004 Maui High Performance Computing Center, University of Hawaii + */ + +/******************************************************************************/ + +/* INCLUDE FILES */ + +/******************************************************************************/ +#include +#include +#include "psAbort.h" +#include "psLogMsg.h" + +/******************************************************************************/ + +/* DEFINE STATEMENTS */ + +/******************************************************************************/ + +// None + +/******************************************************************************/ + +/* TYPE DEFINITIONS */ + +/******************************************************************************/ + +// None + +/*****************************************************************************/ + +/* GLOBAL VARIABLES */ + +/*****************************************************************************/ + +// None + +/*****************************************************************************/ + +/* FILE STATIC VARIABLES */ + +/*****************************************************************************/ + +// None + +/*****************************************************************************/ + +/* FUNCTION IMPLEMENTATION - LOCAL */ + +/*****************************************************************************/ + +// None + +/*****************************************************************************/ + +/* FUNCTION IMPLEMENTATION - PUBLIC */ + +/*****************************************************************************/ + +void psAbort(const char *name, const char *fmt, ...) +{ + va_list argPtr; // variable list arguement pointer + + // Get the variable list parameters to pass to logging function + va_start(argPtr, fmt); + + // Call logging function with PS_LOG_ABORT level + psLogMsgV(name, PS_LOG_ABORT, fmt, argPtr); + + // Clean up stack after variable arguement has been used + va_end(argPtr); + + // Call system abort function to terminate program execution + abort(); +} Index: /tags/rel2_1/psLib/src/sysUtils/psAbort.h =================================================================== --- /tags/rel2_1/psLib/src/sysUtils/psAbort.h (revision 1553) +++ /tags/rel2_1/psLib/src/sysUtils/psAbort.h (revision 1553) @@ -0,0 +1,47 @@ + +/** @file psAbort.h + * + * @brief Contains the declarations for the abort function + * + * The abort logging and handling shall be performed by psAbort function. + * This will allow for consistent handling of other software units + * needing to abort from program execution. + * + * @ingroup ErrorHandling + * + * @author Eric Van Alst, MHPCC + * + * @version $Revision: 1.8 $ $Name: not supported by cvs2svn $ + * @date $Date: 2004-08-10 01:55:34 $ + * + * Copyright 2004 Maui High Performance Computing Center, University of Hawaii + */ + +#ifndef PS_ABORT_H +#define PS_ABORT_H + +// Doxygen grouping tags + +/** @addtogroup ErrorHandling + * @{ + */ + +/** Reports an abort message to logging facility + * + * This function will invoke the psLogMsg function with a level of + * PS_LOG_ABORT and pass the parameters name and fmt to generate a proper + * log message. After logging, this function will call system abort + * function to abnormally terminate the program. + * + * @return void No return value + * + */ +void psAbort( + const char *name, ///< Source of abort such as file or function detected + const char *fmt, ///< A printf style formatting statement defining msg + ... +); + +/* @} */// Doxygen - End of SystemGroup Functions + +#endif Index: /tags/rel2_1/psLib/src/sysUtils/psError.c =================================================================== --- /tags/rel2_1/psLib/src/sysUtils/psError.c (revision 1553) +++ /tags/rel2_1/psLib/src/sysUtils/psError.c (revision 1553) @@ -0,0 +1,86 @@ + +/** @file psError.c + * + * @brief Contains the definitions for the error reporting functions + * + * Error reporting functions shall be used to create log entries in the + * event errors are detected. The messages shall give enough information + * to allow the user to know where the error has occurred and the type + * of error detected. + * + * @author Eric Van Alst, MHPCC + * + * @version $Revision: 1.10 $ $Name: not supported by cvs2svn $ + * @date $Date: 2004-08-07 00:06:06 $ + * + * Copyright 2004 Maui High Performance Computing Center, University of Hawaii + */ + +/******************************************************************************/ + +/* INCLUDE FILES */ + +/******************************************************************************/ +#include +#include "psLogMsg.h" +#include "psError.h" + +/******************************************************************************/ + +/* DEFINE STATEMENTS */ + +/******************************************************************************/ + +// None + +/******************************************************************************/ + +/* TYPE DEFINITIONS */ + +/******************************************************************************/ + +// None + +/*****************************************************************************/ + +/* GLOBAL VARIABLES */ + +/*****************************************************************************/ + +// None + +/*****************************************************************************/ + +/* FILE STATIC VARIABLES */ + +/*****************************************************************************/ + +// None + +/*****************************************************************************/ + +/* FUNCTION IMPLEMENTATIONS - LOCAL */ + +/*****************************************************************************/ + +// None + +/*****************************************************************************/ + +/* FUNCTION IMPLEMENTATIONS - PUBLIC */ + +/*****************************************************************************/ + +void psError(const char *name, const char *fmt, ...) +{ + va_list argPtr; // variable list arguement pointer + + // Get the variable list parameters to pass to logging function + va_start(argPtr, fmt); + + // Call logging function with PS_LOG_ERROR level + psLogMsgV(name, PS_LOG_ERROR, fmt, argPtr); + + // Clean up stack after variable argument has been used + va_end(argPtr); +} Index: /tags/rel2_1/psLib/src/sysUtils/psError.h =================================================================== --- /tags/rel2_1/psLib/src/sysUtils/psError.h (revision 1553) +++ /tags/rel2_1/psLib/src/sysUtils/psError.h (revision 1553) @@ -0,0 +1,43 @@ + +/** @file psError.h + * + * @brief Contains the declarations for the error reporting functions + * + * Error reporting functions shall be used to create log entries in the + * event errors are detected. The messages shall give enough information + * to allow the user to know where the error has occurred and the type + * of error detected. + * + * @ingroup ErrorHandling + * + * @author Eric Van Alst, MHPCC + * + * @version $Revision: 1.8 $ $Name: not supported by cvs2svn $ + * @date $Date: 2004-08-10 01:55:34 $ + * + * Copyright 2004 Maui High Performance Computing Center, University of Hawaii + */ + +#ifndef PS_ERROR_H +#define PS_ERROR_H + +/** @addtogroup ErrorHandling + * @{ + */ + +/** Reports an error message to the logging facility + * + * This function will invoke the psLogMsg function with a level of + * PS_LOG_ERROR and pass the parameters name and fmt to generate a proper + * log message. + * + */ +void psError( + const char *name, ///< Source of error such as file or function detected + const char *fmt, ///< A printf style formatting statement defining msg + ... +); + +/* @} */// End of SysUtils Functions + +#endif Index: /tags/rel2_1/psLib/src/sysUtils/psLogMsg.c =================================================================== --- /tags/rel2_1/psLib/src/sysUtils/psLogMsg.c (revision 1553) +++ /tags/rel2_1/psLib/src/sysUtils/psLogMsg.c (revision 1553) @@ -0,0 +1,365 @@ + +/** @file psLogMsg.c + * @brief Procedures for logging messages. + * \ingroup LogTrace + * + * This file will hold the prototypes for defining procedure which set + * message log levels, messahe log formats, message log destinations, and + * for generating the messages themselves. + * @ingroup LogTrace + * + * @author Robert Lupton, Princeton University + * @author George Gusciora, MHPCC + * + * @version $Revision: 1.26 $ $Name: not supported by cvs2svn $ + * @date $Date: 2004-08-10 01:55:34 $ + * + * Copyright 2004 Maui High Performance Computing Center, University of Hawaii + */ + +/***************************************************************************** +NOTES: currently, the prototype code has the following global variables: + static int p_psGlobalLogDest; + static int p_psGlobalLogLevel; + static int p_psLogTime; + static int p_psLogHost; + static int p_psLogLevel; + static int p_psLogName; + static int p_psLogMsg; + *****************************************************************************/ +#include +#include +#include +#include +#include +#include +#include +#include + +#include "psLogMsg.h" +#include "psError.h" +#include "psTrace.h" + +#define MIN_LOG_LEVEL 0 +#define MAX_LOG_LEVEL 9 + +#define MAX_LOG_LINE_LENGTH 128 +static FILE *logDest = (FILE *) 1; // flag to initialize to stderr before using. +static int globalLogLevel = PS_LOG_INFO; // log all messages at this or above +static bool logTime = true; // Flag to include time info +static bool logHost = true; // Flag to include host info +static bool logLevel = true; // Flag to include level info +static bool logName = true; // Flag to include name info +static bool logMsg = true; // Flag to include message info + +/***************************************************************************** +psLogSetLevel(): Set the current log level and return old level. +Input: + level (int): the new log level. +Output: + none +Return: + The old log level. + *****************************************************************************/ +int psLogSetLevel(int level) +{ + // Save old global log level for changing it. + int oldLevel = globalLogLevel; + + if ((level < MIN_LOG_LEVEL) || (level > MAX_LOG_LEVEL)) { + psLogMsg("logmsg", PS_LOG_WARN, "Attempt to set invalid logMsg level: %d", level); + level = (level < MIN_LOG_LEVEL) ? MIN_LOG_LEVEL : MAX_LOG_LEVEL; + } + // Set new global log level + globalLogLevel = level; + + // Return old global log level + return oldLevel; +} + +/***************************************************************************** +psLogSetDestination(): sets the destination where log messages will be +sent to. + +Input: + dest (int): the new log destination +Output: + None. +Return: + An integer specifying the old log destination. + *****************************************************************************/ +bool psLogSetDestination(const char *dest) +{ + char protocol[5]; + char location[257]; + + // if logDest has not been initialized, do so before using it + if (logDest == (FILE *) 1) { + logDest = stderr; + } + + if (dest == NULL || strcmp(dest, "none") == 0) { + if (logDest != NULL && logDest != stderr && logDest != stdout) { + fclose(logDest); + } + logDest = NULL; + return true; + } + + if (sscanf(dest, "%4s:%256s", protocol, location) < 2) { + psError(__func__, "The specified destination, %s, is malformed.", dest); + return false; + } + + if (strcmp(protocol, "dest") == 0) { + if (strcmp(location, "stderr") == 0) { + if (logDest != NULL && logDest != stderr && logDest != stdout) { + fclose(logDest); + } + logDest = stderr; + return true; + } + if (strcmp(location, "stdout") == 0) { + if (logDest != NULL && logDest != stderr && logDest != stdout) { + fclose(logDest); + } + logDest = stdout; + return true; + } + psError(__func__, "The location, %s, for protocol 'dest' is invalid.", location); + return 1; + } else if (strcmp(protocol, "file") == 0) { + FILE *file = fopen(location, "w"); + + if (file == NULL) { + psError(__func__, "Could not open file '%s' for output.", location); + return false; + } + if (logDest != NULL && logDest != stderr && logDest != stdout) { + fclose(logDest); + } + logDest = file; + return true; + } + + psError(__func__, "Do not know how to handle the protocol '%s'.", protocol); + return false; +} + +/***************************************************************************** +psLogSetFormat(): Set the format of psLogMsg output. More precisely, + provide a string consisting of the letters {H (host), L (level), M + (message), N (name), T (time)}. The default is "HLMNT". This string + determines whether or not they associated type of information will be + included in message logs. It does not determine the order in which that + information will appear (that order is fixed). + +Input: + fmt: a string specifying the format. +Output: + none. +Return: + NULL. + *****************************************************************************/ +void psLogSetFormat(const char *fmt) +{ + // assume nothing desired unless specified + logHost = false; + logLevel = false; + logMsg = false; + logName = false; + logTime = false; + + // if fmt is NULL, no logging is desired. + if (fmt == NULL) { + return; + } + + if (strlen(fmt) == 0) { + fmt = "THLNM"; + } + // Step through each character in the format string. For each letter + // in that string, set/unset the appropriate logging. + + for (const char *ptr = fmt; *ptr != '\0'; ptr++) { + switch (*ptr) { + case 'H': + case 'h': + logHost = true; + break; + case 'L': + case 'l': + logLevel = true; + break; + case 'M': + case 'm': + logMsg = true; + break; + case 'N': + case 'n': + logName = true; + break; + case 'T': + case 't': + logTime = true; + break; + default: + psError(__func__, "Unknown logging keyword %c", *ptr); + break; + } + } + + if (!logMsg) { + psTrace("utils.logMsg", 1, "You must at least log error messages (You chose \"%s\")", fmt); + } +} + +#if !defined(HOST_NAME_MAX) // should be in limits.h +#define HOST_NAME_MAX 256 +#endif + +/***************************************************************************** + psVLogMsg(): This routine sends the message, which is a printf style + string specified in the "..." argument, to the current message log + destination with the severity specified by the "level" argument. + Input: + name + level + fmt + ap + Output: + none + Return: + NULL. + *****************************************************************************/ +void psLogMsgV(const char *name, int level, const char *fmt, va_list ap) +{ + static int first = 1; // Flag for calling gethostname() + static char hostname[HOST_NAME_MAX + 1]; + + // Buffer for hostname. + char clevel = 0; // letter-name for level + char head[MAX_LOG_LINE_LENGTH + 2]; // the added two are for the ending | and \0 + char *head_ptr = head; // where we've got to in head + int maxLength = MAX_LOG_LINE_LENGTH; + time_t clock = time(NULL); // The current time. + struct tm *utc = gmtime(&clock); // The current gm time. + + // if logDest has not been initialized, do so before using it + if (logDest == (FILE *) 1) { + logDest = stderr; + } + // If logging is off, or if the level is too high, return immediately. + if ((level > globalLogLevel) || (logDest == NULL)) { + return; + } + // If I have not been here yet, determine my hostname and save it. + if (first) { + first = 0; + gethostname(hostname, HOST_NAME_MAX); + } + + switch (level) { + case PS_LOG_ABORT: + clevel = 'A'; + break; + + case PS_LOG_ERROR: + clevel = 'E'; + break; + + case PS_LOG_WARN: + clevel = 'W'; + break; + + case PS_LOG_INFO: + clevel = 'I'; + break; + + case 4: + case 5: + case 6: + case 7: + case 8: + case 9: + clevel = level + '0'; + break; + + default: + psTrace("utils.logMsg", 2, "Invalid logMsg level: %d (%s)\n", level, fmt); + level = (level < 0) ? 0 : 9; + break; + } + + // Create the various log fields... + if (logTime) { + maxLength -= snprintf(head_ptr, maxLength, "%4d:%02d:%02d %02d:%02d:%02dZ", + utc->tm_year + 1900, utc->tm_mon + 1, utc->tm_mday, + utc->tm_hour, utc->tm_min, utc->tm_sec) - 1; + head_ptr += strlen(head_ptr); + } + // Hostname should be 20 characters. + if (logHost) { + if (head_ptr > head) { + *head_ptr++ = '|'; + } + maxLength -= snprintf(head_ptr, maxLength, "%-20s", hostname); + head_ptr += strlen(head_ptr); + } + if (logLevel) { + if (head_ptr > head) { + *head_ptr++ = '|'; + } + maxLength -= snprintf(head_ptr, maxLength, "%c", clevel); + head_ptr += strlen(head_ptr); + } + // The name field must be 15 characters. + if (logName) { + if (head_ptr > head) { + *head_ptr++ = '|'; + } + maxLength -= snprintf(head_ptr, maxLength, "%15.15s", name); + head_ptr += strlen(head_ptr); + } + + if (head_ptr > head) { + *head_ptr++ = '|'; + } else if (!logMsg) { // no output desired + return; + } + *head_ptr = '\0'; + + fputs(head, logDest); + if (logMsg) { + vfprintf(logDest, fmt, ap); + if (fmt[strlen(fmt) - 1] != '\n') { + fputc('\n', logDest); + } + } else { + fputc('\n', logDest); + } +} + +/***************************************************************************** + psLogMsg(): This routine sends the message, which is a printf style + string specified in the "..." argument, to the current message log + destination with the severity specified by the "level" argument. + Input: + name: Indicates the source of this log message. + level: The severity of this log message. + fmt: The printf-stype formatted string, followed by the arguments + to that string. + ... The arguments to the above printf-style string. + Output: + none + Return: + NULL + *****************************************************************************/ +void psLogMsg(const char *name, int level, const char *fmt, ...) +{ + va_list ap; + + va_start(ap, fmt); + psLogMsgV(name, level, fmt, ap); + va_end(ap); +} Index: /tags/rel2_1/psLib/src/sysUtils/psLogMsg.h =================================================================== --- /tags/rel2_1/psLib/src/sysUtils/psLogMsg.h (revision 1553) +++ /tags/rel2_1/psLib/src/sysUtils/psLogMsg.h (revision 1553) @@ -0,0 +1,104 @@ + +/** @file psLogMsg.h + * @brief Procedures for logging messages. + * \ingroup LogTrace + * + * This file will hold the prototypes for defining procedure which set + * message log levels, messahe log formats, message log destinations, and + * for generating the messages themselves. + * @ingroup LogTrace + * + * @author Robert Lupton, Princeton University + * @author George Gusciora, MHPCC + * + * @version $Revision: 1.16 $ $Name: not supported by cvs2svn $ + * @date $Date: 2004-08-10 01:55:34 $ + * + * Copyright 2004 Maui High Performance Computing Center, University of Hawaii + */ +#if !defined(PS_LOG_MSG_H) +#define PS_LOG_MSG_H +#include +#include + +/** @addtogroup LogTrace + * @{ + */ + +/** This procedure sets the destination for future log messages. Currently + * the destination is specified by an integer which can have the following + * pre-defined values: PS_LOG_NONE, PS_LOG_TO_STDOUT, and PS_LOG_TO_STDERR. + * In future versions, this procedure will take a character string as an + * argument which can specify more general log destinations. + * + * @return int true if set successfully, otherwise false. + */ +bool psLogSetDestination( + const char *dest ///< Specifies where to send messages. +); + +/** This procedure sets the message level for future log messages. Subsequent + * log messages, with a log level of "mylevel", will only be logged if + * "mylevel" is less than the current log level set by this procedure. + * Ie. higher values set by this procedure will cause more log messages to + * be displayed. + * + * @return int old logging level + */ +int psLogSetLevel( + int level ///< Specifies the system log level +); + +/** This procedure sets the log format for future log messages. The argument + * must be a character string consistsing of the letters H (host), L + * (level), M (message), N (name), and T (time). The default is "THLNM". + * Deleting a letter from the string will cause the associated information + * to not be logged. + * + */ +void psLogSetFormat( + const char *fmt ///< Specifies the system log format +); + +/** This procedure logs a message to the destination set by a prior + * call to psLogSetDestination(), if myLevel is less than the level + * specified by a prior call to psLogSetLevel(). The message is specified + * with a printf-stype string an arguments. + * + */ +void psLogMsg( + const char *name, ///< name of the log source + int myLevel, ///< severity level of this log message + const char *fmt, ///< printf-style format command + ... +); + +/** This procedure is functionally equivalent to psLogMsg(), except that + * it takes a va_list as the message parameter, not a printf-style string. + * + */ +void psLogMsgV( + const char *name, ///< name of the log source + int myLevel, ///< severity level of this log message + const char *fmt, ///< printf-style format command + va_list ap ///< varargs argument list +); + +///< Status codes for log messages +enum { + PS_LOG_ABORT = 0, ///< log message is a critical error, perform an abort after printing + PS_LOG_ERROR, ///< log message is an error, but don't abort + PS_LOG_WARN, ///< log message is a warning + PS_LOG_INFO ///< log message is informational only +}; + +///< Destinations for log messages +enum { + PS_LOG_NONE, ///< turn off logging + PS_LOG_TO_STDERR, ///< log to system's stderr + PS_LOG_TO_STDOUT ///< log to system's stdout +}; + +/// @} + +#endif Index: /tags/rel2_1/psLib/src/sysUtils/psMemory.c =================================================================== --- /tags/rel2_1/psLib/src/sysUtils/psMemory.c (revision 1553) +++ /tags/rel2_1/psLib/src/sysUtils/psMemory.c (revision 1553) @@ -0,0 +1,631 @@ + +/** @file psMemory.c +* +* @brief Contains the definitions for the memory management system +* +* psMemory.h has additional information and documentation of the routines found in this file. +* +* @author Robert DeSonia, MHPCC +* @author Robert Lupton, Princeton University +* +* @version $Revision: 1.34 $ $Name: not supported by cvs2svn $ +* @date $Date: 2004-08-09 23:34:58 $ +* +* Copyright 2004 Maui High Performance Computing Center, University of Hawaii +*/ + +#define PS_ALLOW_MALLOC // we're allowed to call malloc() + +#include +#include +#include +#include + +#include "psMemory.h" +#include "psError.h" +#include "psAbort.h" +#include "psLogMsg.h" + +#define P_PS_MEMMAGIC (void *)0xdeadbeef // Magic number in psMemBlock header + +#define P_PS_LARGE_BLOCK_SIZE 65536 // size where under, we try to recycle + +static int checkMemBlock(const psMemBlock* m, const char *funcName); +static psMemBlock* lastMemBlockAllocated = NULL; +static pthread_mutex_t memBlockListMutex = PTHREAD_MUTEX_INITIALIZER; +static pthread_mutex_t memIdMutex = PTHREAD_MUTEX_INITIALIZER; + +static pthread_mutex_t recycleMemBlockListMutex = PTHREAD_MUTEX_INITIALIZER; + +static int recycleBins = 13; +static int recycleBinSize[14] = { + 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 8192, 16384, 32768, P_PS_LARGE_BLOCK_SIZE + }; + +// N.B. recycleBinSize should be terminated by P_PS_LARGE_BLOCK_SIZE (simplifies search loops) +static psMemBlock* recycleMemBlockList[13] = { + NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL + }; + +#ifdef PS_MEM_DEBUG +static psMemBlock* deadBlockList; // a place to put dead memBlocks in debug mode. +#endif + +/** + * Unique ID for allocated blocks + */ +static psMemoryId memid = 0; + +/** + * Default memExhausted callback. + */ +static void *memExhaustedCallbackDefault(size_t size) +{ + void *ptr = NULL; + + pthread_mutex_lock(&recycleMemBlockListMutex); + int level = recycleBins - 1; + + while (level >= 0 && ptr == NULL) { + while (recycleMemBlockList[level] != NULL && ptr == NULL) { + psMemBlock* old = recycleMemBlockList[level]; + + recycleMemBlockList[level] = recycleMemBlockList[level]->nextBlock; + free(old); + ptr = malloc(size); + } + level--; + } + pthread_mutex_unlock(&recycleMemBlockListMutex); + + return ptr; +} + +static psMemExhaustedCallback memExhaustedCallback = memExhaustedCallbackDefault; + +psMemExhaustedCallback psMemExhaustedCallbackSet(psMemExhaustedCallback func) +{ + psMemExhaustedCallback old = memExhaustedCallback; + + if (func != NULL) { + memExhaustedCallback = func; + } else { + memExhaustedCallback = memExhaustedCallbackDefault; + } + + return old; +} + +static void memProblemCallbackDefault(const psMemBlock* ptr, const char *file, int lineno) +{ + if (ptr->refCounter < 1) { + psError(__func__, + "Block %ld allocated at %s:%d freed more than once at %s:%d\n", + ptr->id, ptr->file, ptr->lineno, file, lineno); + } + + if (lineno > 0) { + psAbort(__func__, "Detected a problem in the memory system at %s:%d", file, lineno); + } +} +static psMemProblemCallback memProblemCallback = memProblemCallbackDefault; + +psMemProblemCallback psMemProblemCallbackSet(psMemProblemCallback func) +{ + psMemProblemCallback old = memProblemCallback; + + if (func != NULL) { + memProblemCallback = func; + } else { + memProblemCallback = memProblemCallbackDefault; + } + + return old; +} + +/* + * And now the I-want-to-be-informed callbacks + * + * Call the callbacks when these IDs are allocated/freed + */ +psMemoryId p_psMemAllocateID = 0; // notify user this block is allocated +psMemoryId p_psMemFreeID = 0; // notify user this block is freed + +psMemoryId psMemAllocateCallbackSetID(psMemoryId id) +{ + psMemoryId old = p_psMemAllocateID; + + p_psMemAllocateID = id; + + return old; +} + +psMemoryId psMemFreeCallbackSetID(psMemoryId id) +{ + psMemoryId old = p_psMemFreeID; + + p_psMemFreeID = id; + + return old; +} + +/* + * Default callback for both allocate and free. Note that the + * value of p_psMemAllocateID/p_psMemFreeID is incremented + * by the return value (so returning 0 means that the callback + * isn't resignalled) + */ +static psMemoryId memAllocateCallbackDefault(const psMemBlock* ptr) +{ + static psMemoryId incr = 0; // "p_psMemAllocateID += incr" + + return incr; +} + +static psMemoryId memFreeCallbackDefault(const psMemBlock* ptr) +{ + static psMemoryId incr = 0; // "p_psMemFreeID += incr" + + return incr; +} + +/* + * The default callbacks, and the routines to change them + */ +static psMemAllocateCallback memAllocateCallback = memAllocateCallbackDefault; +static psMemFreeCallback memFreeCallback = memFreeCallbackDefault; + +psMemAllocateCallback psMemAllocateCallbackSet(psMemAllocateCallback func) +{ + psMemFreeCallback old = memAllocateCallback; + + if (func != NULL) { + memAllocateCallback = func; + } else { + memAllocateCallback = memAllocateCallbackDefault; + } + + return old; +} + +psMemFreeCallback psMemFreeCallbackSet(psMemFreeCallback func) +{ + psMemFreeCallback old = memFreeCallback; + + if (func != NULL) { + memFreeCallback = func; + } else { + memFreeCallback = memFreeCallbackDefault; + } + + return old; +} + +/* + * Return memory ID counter for next block to be allocated + */ +psMemoryId psMemGetId(void) +{ + psMemoryId id; + + pthread_mutex_lock(&memIdMutex); + id = memid + 1; + pthread_mutex_unlock(&memIdMutex); + + return id; +} + +/* + * Routines to check the consistency of the allocated and/or free memory arena + * + * N.b. If the block wasn't allocated by psAlloc, it will appear corrupted + */ + +static int checkMemBlock(const psMemBlock* m, const char *funcName) +{ + // n.b. since this is called by psMemCheckCorruption while the memblock list is mutex locked, + // we shouldn't call such things as p_psAlloc/p_psFree here. + + if (m == NULL) { + psError(funcName, "Memory Corruption: NULL memory block found."); + return 1; + } + + if (m->refCounter == 0) { + // using an unreferenced block of memory, are you? + psError(__func__, "Memory Corruption: memory block %ld was freed but still used.", m->id); + return 1; + } + + if (m->startblock != P_PS_MEMMAGIC || m->endblock != P_PS_MEMMAGIC) { + psError(funcName, "Memory Corruption: memory block %ld is corrupted (buffer underflow)", m->id); + return 1; + } + if (*(void **)((int8_t *) (m + 1) + m->userMemorySize) != P_PS_MEMMAGIC) { + psError(funcName, "Memory Corruption: memory block %ld is corrupted (buffer overflow)", m->id); + return 1; + } + + return 0; +} + +int psMemCheckCorruption(bool abort_on_error) +{ + int nbad = 0; // number of bad blocks + + // get exclusive access to the memBlock list to avoid it changing on us while we use it. + pthread_mutex_lock(&memBlockListMutex); + + for (psMemBlock* iter = lastMemBlockAllocated; iter != NULL; iter = iter->nextBlock) { + if (checkMemBlock(iter, __func__)) { + nbad++; + + memProblemCallback(iter, __func__, __LINE__); + + if (abort_on_error) { + // release the lock on the memblock list + pthread_mutex_unlock(&memBlockListMutex); + psAbort(__func__, "Detected memory corruption"); + return nbad; + } + } + } + + // release the lock on the memblock list + pthread_mutex_unlock(&memBlockListMutex); + return nbad; +} + +void *p_psAlloc(size_t size, const char *file, int lineno) +{ + + psMemBlock* ptr = NULL; + + // memory is of the size I want to bother recycling? + if (size < P_PS_LARGE_BLOCK_SIZE) { + // find the bin we need. + int level = 0; + + while (size > recycleBinSize[level]) { + level++; + } + // Are we in one of the bins + if (level < recycleBins) { + + size = recycleBinSize[level]; // round-up size to next sized bin. + + pthread_mutex_lock(&recycleMemBlockListMutex); + + if (recycleMemBlockList[level] != NULL) { + ptr = recycleMemBlockList[level]; + recycleMemBlockList[level] = ptr->nextBlock; + if (recycleMemBlockList[level] != NULL) { + recycleMemBlockList[level]->previousBlock = NULL; + } + size = ptr->userMemorySize; + } + + pthread_mutex_unlock(&recycleMemBlockListMutex); + } + } + + if (ptr == NULL) { + ptr = malloc(sizeof(psMemBlock) + size + sizeof(void *)); + + if (ptr == NULL) { + ptr = memExhaustedCallback(size); + if (ptr == NULL) { + psAbort(__func__, "Failed to allocate %u bytes at %s:%d", size, file, lineno); + } + } + + ptr->startblock = P_PS_MEMMAGIC; + ptr->endblock = P_PS_MEMMAGIC; + ptr->userMemorySize = size; + pthread_mutex_init(&ptr->refCounterMutex, NULL); + } + // increment the memory id safely. + pthread_mutex_lock(&memBlockListMutex); + *(psMemoryId* ) & ptr->id = ++memid; + pthread_mutex_unlock(&memBlockListMutex); + + ptr->file = file; + ptr->freeFcn = NULL; + *(unsigned int *)&ptr->lineno = lineno; + *(void **)((int8_t *) (ptr + 1) + size) = P_PS_MEMMAGIC; + ptr->previousBlock = NULL; + + ptr->refCounter = 1; // one user so far + + // need exclusive access of the memory block list now... + pthread_mutex_lock(&memBlockListMutex); + + // insert the new block to the front of the memBlock linked-list + ptr->nextBlock = lastMemBlockAllocated; + if (ptr->nextBlock != NULL) { + ptr->nextBlock->previousBlock = ptr; + } + lastMemBlockAllocated = ptr; + + pthread_mutex_unlock(&memBlockListMutex); + + // Did the user ask to be informed about this allocation? + if (ptr->id == p_psMemAllocateID) { + p_psMemAllocateID += memAllocateCallback(ptr); + } + // And return the user the memory that they allocated + return ptr + 1; // user memory +} + +void *p_psRealloc(void *vptr, size_t size, const char *file, int lineno) +{ + if (vptr == NULL) { + return p_psAlloc(size, file, lineno); + } else { + psMemBlock* ptr = ((psMemBlock* ) vptr) - 1; + bool isBlockLast = false; + + if (checkMemBlock(ptr, __func__) != 0) { + memProblemCallback(ptr, file, lineno); + psAbort(file, "Realloc detected a memory corruption (id %ld @ %s:%d).", + ptr->id, ptr->file, ptr->lineno); + } + + pthread_mutex_lock(&memBlockListMutex); + + isBlockLast = (ptr == lastMemBlockAllocated); + + ptr = (psMemBlock* ) realloc(ptr, sizeof(psMemBlock) + size + sizeof(void *)); + + if (ptr == NULL) { + psAbort(__func__, "Failed to reallocate %ld bytes at %s:%d", size, file, lineno); + } + + ptr->userMemorySize = size; + *(void **)((int8_t *) (ptr + 1) + size) = P_PS_MEMMAGIC; + + if (isBlockLast) { + lastMemBlockAllocated = ptr; + } + // the block location may have changed, so fix the linked list addresses. + if (ptr->nextBlock != NULL) { + ptr->nextBlock->previousBlock = ptr; + } + if (ptr->previousBlock != NULL) { + ptr->previousBlock->nextBlock = ptr; + } + + pthread_mutex_unlock(&memBlockListMutex); + + // Did the user ask to be informed about this allocation? + if (ptr->id == p_psMemAllocateID) { + p_psMemAllocateID += memAllocateCallback(ptr); + } + + return ptr + 1; // usr memory + } +} + +void p_psFree(void *vptr, const char *file, int lineno) +{ + (void)p_psMemDecrRefCounter(vptr, file, lineno); // this handles the free, if required. +} + +/* + * Check for memory leaks. + */ +int psMemCheckLeaks(psMemoryId id0, psMemBlock* ** arr, FILE * fd) +{ + int nleak = 0; + int j = 0; + psMemBlock* topBlock = lastMemBlockAllocated; + + pthread_mutex_lock(&memBlockListMutex); + + for (psMemBlock* iter = topBlock; iter != NULL; iter = iter->nextBlock) { + if ((psMemGetRefCounter(iter + 1) > 0) && (iter->id >= id0)) { + nleak++; + + if (fd != NULL) { + if (nleak == 1) { + fprintf(fd, " %20s:line ID\n", "file"); + } + + fprintf(fd, " %20s:%-4d %ld\n", iter->file, iter->lineno, iter->id); + } + } + } + + pthread_mutex_unlock(&memBlockListMutex); + + if (nleak == 0 || arr == NULL) { + return nleak; + } + + *arr = p_psAlloc(nleak * sizeof(psMemBlock), __FILE__, __LINE__); + pthread_mutex_lock(&memBlockListMutex); + + for (psMemBlock* iter = topBlock; iter != NULL; iter = iter->nextBlock) { + if ((psMemGetRefCounter(iter + 1) > 0) && (iter->id >= id0)) { + (*arr)[j++] = iter; + if (j == nleak) { // found them all + break; + } + } + } + + pthread_mutex_unlock(&memBlockListMutex); + + return nleak; +} + +/* + * Reference counting APIs + */ +// return refCounter +psReferenceCount psMemGetRefCounter(void *vptr) +{ + psMemBlock* ptr; + unsigned int refCount; + + if (vptr == NULL) { + return 0; + } + + ptr = ((psMemBlock* ) vptr) - 1; + + if (checkMemBlock(ptr, __func__) != 0) { + memProblemCallback(ptr, __func__, __LINE__); + } + + pthread_mutex_lock(&ptr->refCounterMutex); + refCount = ptr->refCounter; + pthread_mutex_unlock(&ptr->refCounterMutex); + + return refCount; +} + +// increment and return refCounter +void *p_psMemIncrRefCounter(void *vptr, const char *file, int lineno) +{ + psMemBlock* ptr; + + if (vptr == NULL) { + return vptr; + } + + ptr = ((psMemBlock* ) vptr) - 1; + + if (checkMemBlock(ptr, __func__)) { + memProblemCallback(ptr, file, lineno); + } + + pthread_mutex_lock(&ptr->refCounterMutex); + ptr->refCounter++; + pthread_mutex_unlock(&ptr->refCounterMutex); + + return vptr; +} + +// decrement and return refCounter +void *p_psMemDecrRefCounter(void *vptr, const char *file, int lineno) +{ + if (vptr == NULL) { + return NULL; + } + + psMemBlock* ptr = ((psMemBlock* ) vptr) - 1; + + if (checkMemBlock(ptr, __func__) != 0) { + memProblemCallback(ptr, file, lineno); + return NULL; + } + + pthread_mutex_lock(&ptr->refCounterMutex); + + if (ptr->refCounter > 1) { + // / XXX - Probably should have another mutex here. + ptr->refCounter--; // multiple references, just decrement the count. + pthread_mutex_unlock(&ptr->refCounterMutex); + + } else { + pthread_mutex_unlock(&ptr->refCounterMutex); + + // Did the user ask to be informed about this deallocation? + if (ptr->id == p_psMemFreeID) { + p_psMemFreeID += memFreeCallback(ptr); + } + + if (ptr->freeFcn != NULL) { + ptr->freeFcn(vptr); + } + + pthread_mutex_lock(&memBlockListMutex); + + // cut the memBlock out of the memBlock list + if (ptr->nextBlock != NULL) { + ptr->nextBlock->previousBlock = ptr->previousBlock; + } + if (ptr->previousBlock != NULL) { + ptr->previousBlock->nextBlock = ptr->nextBlock; + } + if (lastMemBlockAllocated == ptr) { + lastMemBlockAllocated = ptr->nextBlock; + } + + pthread_mutex_unlock(&memBlockListMutex); + + // do we need to recycle? + if (ptr->userMemorySize < P_PS_LARGE_BLOCK_SIZE) { + + int level = 1; + + while (ptr->userMemorySize >= recycleBinSize[level]) { + level++; + } + level--; + + ptr->refCounter = 0; + ptr->previousBlock = NULL; + + pthread_mutex_lock(&recycleMemBlockListMutex); + ptr->nextBlock = recycleMemBlockList[level]; + if (recycleMemBlockList[level] != NULL) { + recycleMemBlockList[level]->previousBlock = ptr; + } + recycleMemBlockList[level] = ptr; + pthread_mutex_unlock(&recycleMemBlockListMutex); + + } else { + // memory is larger than I want to recycle. + #ifdef PS_MEM_DEBUG + (void)p_psRealloc(vptr, 0, file, lineno); + ptr->previousBlock = NULL; + ptr->nextBlock = deadBlockList; + if (deadBlockList != NULL) { + deadBlockList->previous = ptr; + } + deadBlockList = ptr; + #else + + pthread_mutex_destroy(&ptr->refCounterMutex); + free(ptr); + #endif + + } + + vptr = NULL; // since we freed it, make sure we return NULL. + } + + return vptr; +} + +void p_psMemSetDeallocator(void *vptr, psFreeFcn freeFcn) +{ + if (vptr == NULL) { + return; + } + + psMemBlock* ptr = ((psMemBlock* ) vptr) - 1; + + if (checkMemBlock(ptr, __func__) != 0) { + memProblemCallback(ptr, __func__, __LINE__); + } + + ptr->freeFcn = freeFcn; + +} +psFreeFcn p_psMemGetDeallocator(void *vptr) +{ + if (vptr == NULL) { + return NULL; + } + + psMemBlock* ptr = ((psMemBlock* ) vptr) - 1; + + if (checkMemBlock(ptr, __func__) != 0) { + memProblemCallback(ptr, __func__, __LINE__); + } + + return ptr->freeFcn; +} Index: /tags/rel2_1/psLib/src/sysUtils/psMemory.h =================================================================== --- /tags/rel2_1/psLib/src/sysUtils/psMemory.h (revision 1553) +++ /tags/rel2_1/psLib/src/sysUtils/psMemory.h (revision 1553) @@ -0,0 +1,393 @@ +/** @file psMemory.h + * + * @brief Contains the definitions for the memory management system + * + * This is the generic memory management system put inbetween the user's high level code and the OS-level + * memory allocation routines. This system adds such features as callback routines for memory error events, + * tracing capabilities, and reference counting. + * + * @author Robert DeSonia, MHPCC + * @author Robert Lupton, Princeton University + * + * @ingroup MemoryManagement + * + * @version $Revision: 1.28 $ $Name: not supported by cvs2svn $ + * @date $Date: 2004-08-10 01:55:34 $ + * + * Copyright 2004 Maui High Performance Computing Center, University of Hawaii + */ + +#if !defined(PS_MEMORY_H) +#define PS_MEMORY_H + +#include // needed for FILE +#include +#include // we need a mutex to make this stuff thread safe. + +/** @addtogroup MemoryManagement + * @{ + */ + +/** + * @addtogroup memCallback Memory Callbacks + * + * Routines dealing with the creating and setting of memory management callback functions. + */ + +/** + * @addtogroup memTracing Memory Tracing + * + * Routines dealing with memory tracing and corruption checking. + */ + +/** + * @addtogroup memRefCount Reference Count + * + * Routines dealing with the reference counting of allocated buffers. + */ + +/// typedef for memory identification numbers. Guaranteed to be some variety of integer. +typedef unsigned long psMemoryId; + +/// typedef for a memory block's reference count. Guaranteed to be some variety of integer. +typedef unsigned long psReferenceCount; + +/// typedef for deallocator. +typedef void (*psFreeFcn) (void *ptr); + +/** Book-keeping data for storage allocator. + * N.b. sizeof(psMemBlock) must be chosen such that if ptr is a pointer + * returned by malloc, then ((char *)ptr + sizeof(psMemBlock)) is properly + * aligned for all storage types. + */ +typedef struct psMemBlock +{ + const void *startblock; ///< initialised to p_psMEMMAGIC + struct psMemBlock* previousBlock; ///< previous block in allocation list + struct psMemBlock* nextBlock; ///< next block allocation list + psFreeFcn freeFcn; ///< deallocator. If NULL, use generic deallocation. + size_t userMemorySize; ///< the size of the user-portion of the memory block + const psMemoryId id; ///< a unique ID for this allocation + const char *file; ///< set from __FILE__ in e.g. p_psAlloc + const int lineno; ///< set from __LINE__ in e.g. p_psAlloc + pthread_mutex_t refCounterMutex; ///< mutex to ensure exclusive access to reference counter + psReferenceCount refCounter; ///< how many times pointer is referenced + const void *endblock; ///< initialised to p_psMEMMAGIC +} +psMemBlock; + +/** prototype of a basic callback used by memory functions + * + * @see psMemAllocateCallbackSet + * @ingroup memCallback + */ +typedef psMemoryId(*psMemAllocateCallback) ( + const psMemBlock* ptr ///< the psMemBlock just allocated +); + +/** prototype of memory free callback used by memory functions + * + * @see psMemFreeCallbackSet + * @ingroup memCallback + */ +typedef psMemoryId(*psMemFreeCallback) ( + const psMemBlock* ptr ///< the psMemBlock being freed +); + +/** prototype of a callback used in error conditions + * + * This callback should not try to call psAlloc or psFree. + * + * @see psMemProblemCallbackSet + * @ingroup memCallback + */ +typedef void (*psMemProblemCallback) ( + const psMemBlock* ptr, ///< the pointer to the problematic memory block. + const char *file, ///< the file in which the problem originated + int lineno ///< the line number in which the problem originated +); + +/** prototype of a callback function used when memory runs out + * + * @return void* pointer to requested buffer of the size size_t, or NULL if memory could not + * be found. + * + * @see psMemExhaustedCallbackSet + * @ingroup memCallback + */ +typedef void *(*psMemExhaustedCallback) ( + size_t size ///< the size of buffer required +); + +/** Memory allocation. This operates much like malloc(), but is guaranteed to return a non-NULL value. + * + * @return void* pointer to the allocated buffer. This will not be NULL. + * @see psFree + */ +#ifdef DOXYGEN +void *psAlloc(size_t size ///< Size required + ); +#else + +void *p_psAlloc(size_t size, ///< Size required + const char *file, ///< File of call + int lineno ///< Line number of call + ); + +void p_psMemSetDeallocator(void *ptr, psFreeFcn freeFcn); +psFreeFcn p_psMemGetDeallocator(void *ptr); + +/// Memory allocation. psAlloc sends file and line number to p_psAlloc. +#define psAlloc(size) p_psAlloc(size, __FILE__, __LINE__) +#endif + +/** Memory re-allocation. This operates much like realloc(), but is guaranteed to return a non-NULL value. + * + * @return void* pointer to resized buffer. This will not be NULL. + * @see psAlloc, psFree + */ +#ifdef DOXYGEN +void *psRealloc( + void *ptr ///< Pointer to re-allocate + size_t size, ///< Size required +); +#else + +void *p_psRealloc( + void *ptr, ///< Pointer to re-allocate + size_t size, ///< Size required + const char *file, ///< File of call + int lineno ///< Line number of call +); + +/// Memory re-allocation. psRealloc sends file and line number to p_psRealloc. +#define psRealloc(ptr, size) p_psRealloc(ptr, size, __FILE__, __LINE__) + +#endif + +/** Free memory. This operates much like free(). + * + * @see psAlloc, psRealloc + */ +#ifdef DOXYGEN +void psFree( + void *ptr, ///< Pointer to free, if NULL, function returns immediately. +); +#else + +void p_psFree( + void *ptr, ///< Pointer to free + const char *file, ///< File of call + int lineno ///< Line number of call +); + +/// Free memory. psFree sends file and line number to p_psFree. +#define psFree(size) p_psFree(size, __FILE__, __LINE__) + +#endif + +/** Check for memory leaks. This scans for allocated memory buffers not freed with an ID not less than id0. + * This is used to check for memory leaks by: + * -# before a block of code to be checked, store the current ID count via psGetMemId + * -# after the block of code to be checked, call this function using the ID stored above. If all + * memory in the block that was allocated has been freed, this call should output nothing and + * return 0. + * + * If memory leaks are found, the Memory Problem callback will be called as well. + * + * return int number of memory blocks found as 'leaks', i.e., the number of currently allocated memory + * blocks above id0 that have not been freed. + * @see psAlloc, psFree, psgetMemId, psMemProblemCallbackSet + * @ingroup memTracing + */ +int psMemCheckLeaks( + psMemoryId id0, ///< don't list blocks with id < id0 + psMemBlock* ** arr, ///< pointer to array of pointers to leaked blocks, or NULL + FILE * fd ///< print list of leaks to fd (or NULL) +); + +/** Check for memory corruption. Scans all currently allocated memory buffers and checks for corruptions, + * i.e., invalid markers that signify a buffer under/overflow. + * + * @ingroup memTracing + */ +int psMemCheckCorruption( + bool abort_on_error ///< Abort on detecting corruption? +); + +/** Return reference counter + * + * @ingroup memRefCount + */ +psReferenceCount psMemGetRefCounter( + void *vptr ///< Pointer to get refCounter for +); + +/** Increment reference counter and return the pointer + * + * @ingroup memRefCount + */ +#ifdef DOXYGEN +void *psMemIncrRefCounter( + void *vptr ///< Pointer to increment refCounter, and return +); +#else + +void *p_psMemIncrRefCounter( + void *vptr, ///< Pointer to increment refCounter, and return + const char *file, ///< File of call + int lineno ///< Line number of call +); + +#define psMemIncrRefCounter(vptr) p_psMemIncrRefCounter(vptr, __FILE__, __LINE__) +#endif + +/** Decrement reference counter and return the pointer + * + * @ingroup memRefCount + * + * @return void* the pointer deremented in refCount, or NULL if pointer is + * fully dereferenced. + */ +#ifdef DOXYGEN +void* psMemDecrRefCounter( + void* vptr ///< Pointer to decrement refCounter, and return +); +#else + +void *p_psMemDecrRefCounter( + void *vptr, ///< Pointer to decrement refCounter, and return + const char *file, ///< File of call + int lineno ///< Line number of call +); + +#define psMemDecrRefCounter(vptr) p_psMemDecrRefCounter(vptr, __FILE__, __LINE__) +#endif + +/** Set callback for problems. + * + * At various occasions, the memory manager can check the state of the memory + * stack. If any of these checks discover that the memory stack is corrupted, + * the psMemProblemCallback is called. + + * @ingroup memCallback + * + * @return psMemProblemCallback old psMemProblemCallback function + */ +psMemProblemCallback psMemProblemCallbackSet( + psMemProblemCallback func ///< Function to run at memory problem detection +); + +/** Set callback for out-of-memory. + * + * If not enough memory is available to satisfy a request by psAlloc or + * psRealloc, these functions attempt to find an alternative solution by + * calling the psMemExhaustedCallback, a function which may be set by the + * programmer in appropriate circumstances, rather than immediately fail. + * The typical use of such a feature may be when a program needs a large + * chunk of memory to do an operation, but the exact size is not critical. + * This feature gives the programmer the opportunity to make a smaller + * request and try again, limiting the size of the operating buffer. + * + * @ingroup memCallback + * + * @return psMemExhaustedCallback old psMemExhaustedCallback function + */ +psMemExhaustedCallback psMemExhaustedCallbackSet( + psMemExhaustedCallback func ///< Function to run at memory exhaustion +); + +/** Set call back for when a particular memory block is allocated + * + * A private variable, p_psMemAllocateID, can be used to trace the allocation + * and freeing of specific memory blocks. If p_psMemAllocateID is set and a + * memory block with that ID is allocated, psMemAllocateCallback is called + * just before memory is returned to the calling function. + * + * @ingroup memCallback + * + * @return psMemAllocateCallback old psMemAllocateCallback function + */ +psMemAllocateCallback psMemAllocateCallbackSet( + psMemAllocateCallback func ///< Function to run at memory allocation of specific mem block +); + +/** Set call back for when a particular memory block is freed + * + * A private variable, p_psMemFreeID, can be used to trace the freeing of + * specific memory blocks. If p_psMemFreeID is set and the memory block with + * the ID is about to be freed, the psMemFreeCallback callback is called just + * before the memory block is freed. + * + * @ingroup memCallback + * + * @return psMemFreeCallback old psMemFreeCallback function + */ +psMemFreeCallback psMemFreeCallbackSet( + psMemFreeCallback func ///< Function to run at memory free of specific mem block +); + +/** get next memory ID + * + * @ingroup memCallback + * + * @return psMemoryId the next memory ID to be used + */ +psMemoryId psMemGetId(void); + +/** set p_psMemAllocateID to specific id + * + * A private variable, p_psMemAllocateID, can be used to trace the allocation + * and freeing of specific memory blocks. If p_psMemAllocateID is set and a + * memory block with that ID is allocated, psMemAllocateCallback is called + * just before memory is returned to the calling function. + * + * @ingroup memCallback + * + * @return psMemoryId + * + * @see psMemAllocateCallbackSet + */ +psMemoryId psMemAllocateCallbackSetID( + psMemoryId id ///< ID to set +); + +/** set p_psMemFreeID to id + * + * A private variable, p_psMemFreeID, can be used to trace the freeing of + * specific memory blocks. If p_psMemFreeID is set and the memory block with + * the ID is about to be freed, the psMemFreeCallback callback is called just + * before the memory block is freed. + * + * @ingroup memCallback + * + * @return psMemoryId the old p_psMemFreeID + * + * @see psMemFreeCallbackSet + */ +psMemoryId psMemFreeCallbackSetID( + psMemoryId id ///< ID to set +); + +//@} End of Memory Management Functions + +#ifndef DOXYGEN + +/* + * Ensure that any program using malloc/realloc/free will fail to compile + */ +#ifndef PS_ALLOW_MALLOC +#ifdef __GNUC__ +#pragma GCC poison malloc realloc calloc free +#else +#define malloc(S) _Pragma("error Use of malloc is not allowed. Use psAlloc instead.") +#define realloc(P,S) _Pragma("error Use of realloc is not allowed. Use psRealloc instead.") +#define calloc(S) _Pragma("error Use of calloc is not allowed. Use psAlloc instead.") +#define free(P) _Pragma("error Use of free is not allowed. Use psFree instead.") +#endif +#endif + +#endif +// doxygen skip + +#endif // end of header file Index: /tags/rel2_1/psLib/src/sysUtils/psString.c =================================================================== --- /tags/rel2_1/psLib/src/sysUtils/psString.c (revision 1553) +++ /tags/rel2_1/psLib/src/sysUtils/psString.c (revision 1553) @@ -0,0 +1,103 @@ + +/** @file psString.c + * + * @brief Contains the definition of string utility functions + * + * String utility functions defined shall provide basic string copying + * capabilities while using the preferred memory management utilities. + * + * @author Eric Van Alst, MHPCC + * + * @version $Revision: 1.8 $ $Name: not supported by cvs2svn $ + * @date $Date: 2004-08-07 00:06:06 $ + * + * Copyright 2004 Maui High Performance Computing Center, University of Hawaii + */ + +/******************************************************************************/ + +/* INCLUDE FILES */ + +/******************************************************************************/ +#include +#include +#include "psString.h" +#include "psMemory.h" +#include "psError.h" + +/******************************************************************************/ + +/* DEFINE STATEMENTS */ + +/******************************************************************************/ + +// None + +/******************************************************************************/ + +/* TYPE DEFINITIONS */ + +/******************************************************************************/ + +// None + +/*****************************************************************************/ + +/* GLOBAL VARIABLES */ + +/*****************************************************************************/ + +// None + +/*****************************************************************************/ + +/* FILE STATIC VARIABLES */ + +/*****************************************************************************/ + +// None + +/*****************************************************************************/ + +/* FUNCTION IMPLEMENTATION - LOCAL */ + +/*****************************************************************************/ + +// None + +/*****************************************************************************/ + +/* FUNCTION IMPLEMENTATION - PUBLIC */ + +/*****************************************************************************/ + +char *psStringCopy(const char *str) +{ + // Allocate memory using psAlloc function + // Copy input string to memory just allocated + // Return the copy + return strcpy(psAlloc(strlen(str) + 1), str); +} + +char *psStringNCopy(const char *str, int nChar) +{ + char *returnValue = NULL; + + // Check the number of characters to copy is non-negative + if (nChar < 0) { + // Log error message and return NULL + psError(__FILE__, "psStringNCopy with negative count specified %d", nChar); + return NULL; + } + // Allocate memory using psAlloc function - nChar bytes + // Copy input string to memory allocated up to nChar characters + // Return the copy + returnValue = strncpy(psAlloc((size_t) nChar + 1), str, (size_t) nChar); + + // Ensure the last byte is NULL character + if (nChar > 0) { + returnValue[nChar - 1] = '\0'; + } + // Return the string pointer + return returnValue; +} Index: /tags/rel2_1/psLib/src/sysUtils/psString.h =================================================================== --- /tags/rel2_1/psLib/src/sysUtils/psString.h (revision 1553) +++ /tags/rel2_1/psLib/src/sysUtils/psString.h (revision 1553) @@ -0,0 +1,70 @@ +/** @file psString.h + * + * @brief Contains the declarations of string utility functions + * + * @ingroup SysUtils + * + * String utility functions defined shall provide basic string copying + * capabilities. + * + * @author Eric Van Alst, MHPCC + * + * @version $Revision: 1.8 $ $Name: not supported by cvs2svn $ + * @date $Date: 2004-08-10 01:55:34 $ + * + * Copyright 2004 Maui High Performance Computing Center, University of Hawaii + */ + +#ifndef PS_STRING_H +#define PS_STRING_H + + +/** This macro will convert the argument to a quoted string */ +#define PS_STRING(S) #S + +// Doxygen group tags + +/** @addtogroup SysUtils + * @{ + */ + +/** Copies the input string + * + * This function shall allocate memory to the length of the input string + * plus one and copy the input string to the newly allocated memory. + * + * @return char* Copy of input string + * + */ +char *psStringCopy( + const char *str + /**< Input string of characters to copy */ +); + +/** Copies the input string up to the specified number of characters + * + * This function shall allocate memory to the length specified by nChar + * plus one and copy the input string to the newly allocated memory. + * This function will only copy nChar bytes from the input to new string, + * so if the input string is larger than nChar characters the copied + * string will be a substring of the input string. If the input string + * is smaller than nChar bytes then the remaining bytes allocated will + * be set to NULL. + * + * @return char* Copy of input string + * + */ + +/*@null@*/ + +char *psStringNCopy( + const char *str, + /**< Input string of characters to copy */ + + int nChar + /**< Number of bytes to allocate for string copy */ +); + +/* @} */// Doxygen - End of SystemGroup Functions + +#endif Index: /tags/rel2_1/psLib/src/sysUtils/psTrace.c =================================================================== --- /tags/rel2_1/psLib/src/sysUtils/psTrace.c (revision 1553) +++ /tags/rel2_1/psLib/src/sysUtils/psTrace.c (revision 1553) @@ -0,0 +1,402 @@ + +/** @file psTrace.c + * \brief basic run-time trace facilities + * \ingroup LogTrace + * + * This file will hold the code for procedures to insert + * trace messages into the code. + * + * @author Robert Lupton, Princeton University + * @author George Gusciora, MHPCC + * + * @version $Revision: 1.17 $ $Name: not supported by cvs2svn $ + * @date $Date: 2004-08-09 23:40:55 $ + * + * Copyright 2004 Maui High Performance Computing Center, University of Hawaii + */ + +/***************************************************************************** + NOTES: + In the SRD, higher trace levels correspond to a numerically lower trace + value in the code. This is a bit confusing. For example, a high-level + message might be something like "Begin Processing". The module programmer + might give that a numerically low trace level, such as 1, so then any + non-zero trace level in that code component will display thatmessage. + + We build a tree of trace components. Every node in the tree has a + depth, which is it's distance from the root. However, this is not + not the same thing as a node's "level", which corresponds to the + trace level of that node. + + I added a function psTraceFree() which frees all nodes in the trace component + tree. Previously, there had been no function in the API which accomplished + this purpose. + *****************************************************************************/ + +#ifndef PS_NO_TRACE + +#include +#include +#include +#include +#include "psMemory.h" +#include "psTrace.h" +#include "psString.h" +#include "psError.h" + +static p_psComponent* p_psCroot = NULL; // The root of the trace component +static FILE *p_psTraceFP = NULL; // File destination for messages. + +static void componentFree(p_psComponent* comp); +static p_psComponent* componentAlloc(const char *name, int level); + +/***************************************************************************** +componentAlloc(): allocate memory for a new node, and initialize members. + *****************************************************************************/ +static p_psComponent* componentAlloc(const char *name, int level) +{ + p_psComponent* comp = psAlloc(sizeof(p_psComponent)); + + p_psMemSetDeallocator(comp, (psFreeFcn) componentFree); + comp->name = psStringCopy(name); + comp->level = level; + comp->n = 0; + comp->subcomp = NULL; + return comp; +} + +/***************************************************************************** +componentFree(): free the current node in the root tree, and all children +nodes as well. + *****************************************************************************/ +static void componentFree(p_psComponent* comp) +{ + if (comp == NULL) { + return; + } + + if (comp->subcomp != NULL) { + for (int i = 0; i < comp->n; i++) { + psFree(comp->subcomp[i]); + } + psFree(comp->subcomp); + } + + psFree((char *)comp->name); +} + +/***************************************************************************** +initTrace(): simply initialize the component root tree. +*****************************************************************************/ +static void initTrace(void) +{ + if (p_psCroot == NULL) { + p_psCroot = componentAlloc(".", PS_DEFAULT_TRACE_LEVEL); + } +} + +/***************************************************************************** +Set all trace levels to zero. + *****************************************************************************/ +void p_psTraceReset(p_psComponent* currentNode) +{ + int i = 0; + + if (NULL == currentNode) { + return; + } + + currentNode->level = 0; + for (i = 0; i < currentNode->n; i++) { + if (NULL == currentNode->subcomp[i]) { + psError(__func__, + "Sub-component %d of node %s in the trace tree is NULL.\n", i, currentNode->name); + } else { + p_psTraceReset(currentNode->subcomp[i]); + } + } + return; +} + +/***************************************************************************** +Set all trace levels to zero. + *****************************************************************************/ +void psTraceReset() +{ + p_psTraceReset(p_psCroot); +} + +/***************************************************************************** +Free all nodes in the component tree. + *****************************************************************************/ +void psTraceFree() +{ + psFree(p_psCroot); +} + +/***************************************************************************** +componentAdd(): Adds the component named "addNodeName" to the root tree. + +NOTE: replace the call to strsep() with a call to strtok(), which conforms +to ANSI-C. + *****************************************************************************/ +static void componentAdd(const char *addNodeName, int level) +{ + int i = 0; // Loop index variable. + char name[strlen(addNodeName) + 1]; // buffer for writeable copy. + char *pname = name; + char *firstComponent = NULL; // first component of name + p_psComponent* currentNode = p_psCroot; + int nodeExists = 0; + + // Is this the root node? If so, simply set level and return. + if (strcmp(".", addNodeName) == 0) { + p_psCroot->level = level; + return; + } + + if (addNodeName[0] != '.') { + printf("ERROR: failed to add %s to the root component tree.\n", addNodeName); + exit(1); + } + + strcpy(name, addNodeName); + pname = &name[1]; + // Iterate through the components of addNodeName. Strip off the first + // component of the name, find that in the root tree, or add it if it + // does not exist, then move to the next component in the name. + + while (pname != NULL) { + firstComponent = strsep(&pname, "."); + nodeExists = 0; + for (i = 0; i < currentNode->n; i++) { + if (strcmp(currentNode->subcomp[i]->name, firstComponent) == 0) { + currentNode = currentNode->subcomp[i]; + nodeExists = 1; + if (pname == NULL) { + currentNode->level = level; + } + } + } + + if (nodeExists == 0) { + currentNode->subcomp = psRealloc(currentNode->subcomp, + (currentNode->n + 1) * sizeof(p_psComponent* )); + currentNode->n = (currentNode->n) + 1; + + currentNode->subcomp[(currentNode->n) - 1] = componentAlloc(firstComponent, level); + } + } +} + +/***************************************************************************** + psSetTraceLevel(): add the component named "comp" to the component tree, + if it is not already there, and set it's trace level to "level". + Input: + comp + level + Output: + none + Returns: + zero +*****************************************************************************/ +int psTraceSetLevel(const char *comp, // component of interest + int level) // desired trace level +{ + // If the root component tree does not exist, then initialize it. + if (p_psCroot == NULL) { + initTrace(); + } + // Add the new component to the component tree. + componentAdd(comp, level); + + // return 0 on success. + return 0; +} + +/***************************************************************************** + doGetTraceLevel() + This function recursively searches the root component tree for the + component named "name", which is supplied by a parameter. If it + finds that component, it returns the level of that component. + Otherwise, it returns ???. + + Inputs: + name: + Outputs: + none + Returns: + The trace level of the "name" component. + *****************************************************************************/ +static int doGetTraceLevel(const char *aname) +{ + char name[strlen(aname) + 1]; // need a writeable copy: for strsep() + char *pname = name; + char *firstComponent = NULL; // first component of name + p_psComponent* currentNode = p_psCroot; + int i = 0; + + if (NULL == currentNode) { + return (PS_UNKNOWN_TRACE_LEVEL); + } + + if (strcmp(".", aname) == 0) { + return (p_psCroot->level); + } + + if (aname[0] != '.') { + return (PS_UNKNOWN_TRACE_LEVEL); + } + + strcpy(name, aname); + pname = &name[1]; + while (pname != NULL) { + firstComponent = strsep(&pname, "."); + for (i = 0; i < currentNode->n; i++) { + if (NULL == currentNode->subcomp[i]) { + psError(__func__, + "Sub-component %d of node %s in trace tree is NULL.\n", i, currentNode->name); + } + + if (strcmp(currentNode->subcomp[i]->name, firstComponent) == 0) { + currentNode = currentNode->subcomp[i]; + if (pname == NULL) { + return (currentNode->level); + } + } + } + } + return (PS_UNKNOWN_TRACE_LEVEL); +} + +/***************************************************************************** + psGetTraceLevel() + Return a trace level of "name" in the root component tree. If the + exact string of components in "name" does not exist in the root + tree, we return the deepest level of the match. + Input: + name + Output: + none + Return: + The level of "name" in the root component tree. + *****************************************************************************/ +int psTraceGetLevel(const char *name) +{ + if (p_psCroot == NULL) { + return (PS_UNKNOWN_TRACE_LEVEL); + } + // Search the component root tree, determine the trace level. + return (doGetTraceLevel(name)); +} + +/***************************************************************************** + doPrintTraceLevels() + This function recursively searches the component tree supplied by the + parameter "comp" and prints the name and level of each component. + Inputs: + comp: a node in the component tree. + level: the level of that node + Outputs: + none + Returns: + null + *****************************************************************************/ +static void doPrintTraceLevels(const p_psComponent* comp, int depth) +{ + int i = 0; + + if (comp->name[0] == '\0') { + printf("%*s%-*s %d\n", depth, "", 20 - depth, + "(root)", (comp->level == PS_UNKNOWN_TRACE_LEVEL) ? 0 : comp->level); + } else { + if (comp->level == PS_UNKNOWN_TRACE_LEVEL) { + printf("%*s%-*s %s\n", depth, "", 20 - depth, comp->name, "."); + } else { + printf("%*s%-*s %d\n", depth, "", 20 - depth, comp->name, comp->level); + } + } + + for (i = 0; i < comp->n; i++) { + doPrintTraceLevels(comp->subcomp[i], depth + 1); + } +} + +/***************************************************************************** +psPrintTraceLevels(): Simply print all the trace levels in the trace level +component tree. +Inputs: + none +Outputs: + none +Returns: + null +*****************************************************************************/ +void psTracePrintLevels(void) +{ + if (p_psCroot == NULL) { + return; + } + + doPrintTraceLevels(p_psCroot, 0); +} + +/***************************************************************************** +p_psTrace(): we display the trace message to standard output if the trace +level of that message, supplied by the parameter "level" is higher than the +trace level that is currently associated with the component named by the +parameter "comp". +Input: + comp + level + ... a printf-style output string. +Output: + none +Return: + null + *****************************************************************************/ +void p_psTrace(const char *comp, // component being traced + int level, // desired trace level + ...) // arguments +{ + char *fmt = NULL; + va_list ap; + int i = 0; + + if (NULL == comp) { + psError(__func__, "p_psTrace() called on a NULL trace level tree\n"); + } + // Only display this message if it's trace level is less than the level + // of it's associatedcomponent. + if (level <= psTraceGetLevel(comp)) { + va_start(ap, level); + + // The following functions get the variable list of parameters with + // which this function was called, and print them to the standard + // output. + fmt = va_arg(ap, char *); + + if (p_psTraceFP != NULL) { + // We indent each message one space for each level of the message. + for (i = 0; i < level; i++) { + fprintf(p_psTraceFP, " "); + } + vfprintf(p_psTraceFP, fmt, ap); + } else { + // We indent each message one space for each level of the message. + for (i = 0; i < level; i++) { + putchar(' '); + } + vprintf(fmt, ap); + } + va_end(ap); + } + // NOTE: should we free *fmt as well? Read the man page. +} + +void psTraceSetDestination(FILE * fp) +{ + p_psTraceFP = fp; +} + +#endif Index: /tags/rel2_1/psLib/src/sysUtils/psTrace.h =================================================================== --- /tags/rel2_1/psLib/src/sysUtils/psTrace.h (revision 1553) +++ /tags/rel2_1/psLib/src/sysUtils/psTrace.h (revision 1553) @@ -0,0 +1,93 @@ + +/** @file psTrace.h + * \brief basic run-time trace facilities + * \ingroup LogTrace + * + * This file will hold the prototypes for defining procedures to insert + * trace messages into the code. + * + * @author Robert Lupton, Princeton University + * @author George Gusciora, MHPCC + * + * @version $Revision: 1.15 $ $Name: not supported by cvs2svn $ + * @date $Date: 2004-08-09 23:40:55 $ + * + * Copyright 2004 Maui High Performance Computing Center, University of Hawaii + */ +#if !defined(PS_TRACE_H) +#define PS_TRACE_H 1 + +#define PS_UNKNOWN_TRACE_LEVEL -9999 // we don't know this name's level +#define PS_DEFAULT_TRACE_LEVEL 0 + +/** \addtogroup LogTrace + * \{ + */ + +/** Functions **************************************************************/ + +//#define PS_NO_TRACE 1 ///< to turn off all tracing + +#if defined(PS_NO_TRACE) +# define psTrace(facil, level, ...) (void)0 +/* do nothing */ +# define p_psTrace(facil, level, ...) (void)0 +/* do nothing */ +# define psTraceSetLevel(facil,level) 0 +# define psTraceGetLevel(facil) 0 +# define psTraceReset() (void)0 /* do nothing */ +# define psTraceFree() (void)0 /* do nothing */ +# define psTracePrintLevels() (void)0 +/* do nothing */ +# define psTraceSetDestination(fp) (void)0 +/* do nothing */ +# else + + /** Basic structure for the component tree. A component is a string of the + form aaa.bbb.ccc, and may itself contain further subcomponents. The + Component structure doesn't in fact contain it's full name, but only the + last part. */ + typedef struct p_psComponent + { + const char *name; // last part of name of component + int level; // trace level for this component + int n; // number of subcomponents + struct p_psComponent* *subcomp; // next level of subcomponents + } +p_psComponent; + +#ifndef DOXYGEN +/// Send a trace message +void p_psTrace(const char *facil, ///< facilty of interest + int myLevel, ///< desired trace level + ...) ///< trace message arguments +; +#endif + +/// Set trace level +int psTraceSetLevel(const char *facil, ///< facilty of interest + int level) ///< desired trace level +; + +/// Get the trace level +int psTraceGetLevel(const char *facil) ///< facilty of interest +; + +/// Set all trace levels to zero (do not free nodes in the component tree). +void psTraceReset(); + +/// Free all nodes in the component tree. +void psTraceFree(); + +/// print trace levels +void psTracePrintLevels(void); + +/// Set the destination of future trace messages. +void psTraceSetDestination(FILE * fp); + +/* \} */// End of SystemGroup Functions + +#define psTrace(facil, level, ...) p_psTrace(facil, level, __VA_ARGS__) +#endif + +#endif Index: /tags/rel2_1/psLib/src/sysUtils/psType.h =================================================================== --- /tags/rel2_1/psLib/src/sysUtils/psType.h (revision 1553) +++ /tags/rel2_1/psLib/src/sysUtils/psType.h (revision 1553) @@ -0,0 +1,156 @@ + +/** @file psType.h +* +* @brief Contains support for basic types +* +* This file defines common datatypes used throughout psLib. +* +* @ingroup DataContainer +* +* @author Robert DeSonia, MHPCC +* @author Ross Harman, MHPCC +* +* @version $Revision: 1.20 $ $Name: not supported by cvs2svn $ +* @date $Date: 2004-08-10 01:55:34 $ +* +* Copyright 2004 Maui High Performance Computing Center, University of Hawaii +*/ + +#ifndef PS_TYPE_H +#define PS_TYPE_H + +#include +#include +#include + +/// @addtogroup DataContainer +/// @{ + +/******************************************************************************/ + +/* TYPE DEFINITIONS */ + +/******************************************************************************/ + +/** Basic data types used by the containers. + * + * The basic types of the primitives used by psLib are defined within this enum. This enum is in turn used by + * the psType struct. + * + */ + +typedef uint8_t psU8; ///< 8-bit unsigned int +typedef uint16_t psU16; ///< 16-bit unsigned int +typedef uint32_t psU32; ///< 32-bit unsigned int +typedef uint64_t psU64; ///< 64-bit unsigned int +typedef int8_t psS8; ///< 8-bit signed int +typedef int16_t psS16; ///< 16-bit signed int +typedef int32_t psS32; ///< 32-bit signed int +typedef int64_t psS64; ///< 64-bit signed int +typedef float psF32; ///< 32-bit floating point +typedef double psF64; ///< 64-bit floating point +typedef complex float psC32; ///< complex with 32-bit floating point Real and Imagary numbers +typedef complex double psC64; ///< complex with 64-bit floating point Real and Imagary numbers +typedef void *psPTR; ///< void pointer + +typedef enum { + PS_TYPE_S8 = 0x0101, ///< Character. + PS_TYPE_S16 = 0x0102, ///< Short integer. + PS_TYPE_S32 = 0x0104, ///< Integer. + PS_TYPE_S64 = 0x0108, ///< Long integer. + PS_TYPE_U8 = 0x0301, ///< Unsigned character. + PS_TYPE_U16 = 0x0302, ///< Unsigned short integer. + PS_TYPE_U32 = 0x0304, ///< Unsigned integer. + PS_TYPE_U64 = 0x0308, ///< Unsigned long integer. + PS_TYPE_F32 = 0x0404, ///< Single-precision Floating point. + PS_TYPE_F64 = 0x0408, ///< Double-precision floating point. + PS_TYPE_C32 = 0x0808, ///< Complex numbers consisting of single-precision floating point. + PS_TYPE_C64 = 0x0810, ///< Complex numbers consisting of double-precision floating point. + PS_TYPE_PTR = 0x0000 ///< Something else that's not supported for arithmetic. +} psElemType; + +#define PS_TYPE_MASK PS_TYPE_U8 /**< the psElemType to use for mask image */ +#define PS_TYPE_MASK_DATA U8 /**< the data member to use for mask image */ +#define PS_TYPE_MASK_NAME "psU8" /**< the data type for mask as a string */ + +typedef psU8 psMaskType; ///< the C datatype for a mask image + + +#define PS_MIN_S8 INT8_MIN /**< minimum valid psS8 value */ +#define PS_MIN_S16 INT16_MIN /**< minimum valid psS16 value */ +#define PS_MIN_S32 INT32_MIN /**< minimum valid psS32 value */ +#define PS_MIN_S64 INT64_MIN /**< minimum valid psS64 value */ +#define PS_MIN_U8 0 /**< minimum valid psU8 value */ +#define PS_MIN_U16 0 /**< minimum valid psU16 value */ +#define PS_MIN_U32 0 /**< minimum valid psU32 value */ +#define PS_MIN_U64 0 /**< minimum valid psU64 value */ +#define PS_MIN_F32 -FLT_MAX /**< minimum valid psF32 value */ +#define PS_MIN_F64 -DBL_MAX /**< minimum valid psF64 value */ +#define PS_MIN_C32 -FLT_MAX /**< minimum valid real or imaginary psC32 value */ +#define PS_MIN_C64 -DBL_MAX /**< minimum valid real or imaginary psC32 value */ + +#define PS_MAX_S8 INT8_MAX /**< maximum valid psS8 value */ +#define PS_MAX_S16 INT16_MAX /**< maximum valid psS16 value */ +#define PS_MAX_S32 INT32_MAX /**< maximum valid psS32 value */ +#define PS_MAX_S64 INT64_MAX /**< maximum valid psS64 value */ +#define PS_MAX_U8 UINT8_MAX /**< maximum valid psU8 value */ +#define PS_MAX_U16 UINT16_MAX /**< maximum valid psU16 value */ +#define PS_MAX_U32 UINT32_MAX /**< maximum valid psU32 value */ +#define PS_MAX_U64 UINT64_MAX /**< maximum valid psU64 value */ +#define PS_MAX_F32 FLT_MAX /**< maximum valid psF32 value */ +#define PS_MAX_F64 DBL_MAX /**< maximum valid psF64 value */ +#define PS_MAX_C32 FLT_MAX /**< maximum valid real or imaginary psC32 value */ +#define PS_MAX_C64 DBL_MAX /**< maximum valid real or imaginary psC32 value */ + +/// Macro to get the bad pixel reason code (stored as part of mask value) +#define PS_BADPIXEL_BITMASK 0x0f +#define PS_GET_BADPIXEL(maskValue) (maskValue & PS_BADPIXEL_BITMASK) + +#define PS_IS_BADPIXEL(maskValue) (PS_GET_BADPIXEL(maskValue) != 0) + +/// Macro to apply a bad pixel reason code to mask image +#define PS_SET_BADPIXEL(maskValue, reasonCode) \ +{ \ + maskValue = (psMaskType)((reasonCode & PS_BADPIXEL_BITMASK) | (maskValue & ~PS_BADPIXEL_BITMASK)); \ +} + +/// Macro to determine if the psElemType is an integer. +#define PS_IS_PSELEMTYPE_INT(x) ((x & 0x100) == 0x100) +/// Macro to determine if the psElemType is unsigned. +#define PS_IS_PSELEMTYPE_UNSIGNED(x) ((x & 0x200) == 0x200) +/// Macro to determine if the psElemType is a real (non-complex) floating-point type. +#define PS_IS_PSELEMTYPE_REAL(x) ((x & 0x400) == 0x400) +/// Macro to determine if the psElemType is complex number type. +#define PS_IS_PSELEMTYPE_COMPLEX(x) ((x & 0x800) == 0x800) +/// Macro to determine the storage size, in bytes, of the psElemType. +#define PSELEMTYPE_SIZEOF(x) ( (x==PS_TYPE_PTR) ? sizeof(void*) :(x & 0xFF) ) + +/** Dimensions of a data type. + * + * The dimensions of containers used by psLib are defined within this enum. This enum is used by the psType +struct. * + */ +typedef enum { + PS_DIMEN_SCALAR, ///< Scalar. + PS_DIMEN_VECTOR, ///< Vector. + PS_DIMEN_TRANSV, ///< Transposed vector. + PS_DIMEN_IMAGE, ///< Image. + PS_DIMEN_OTHER ///< Something else that's not supported for arithmetic. +} psDimen; + +/** The type of a data type. + * + * All psLib complex types consist of primitive components. This struct provides the description of those + * primitives. + * + */ +typedef struct +{ + psElemType type; ///< Primitive type. + psDimen dimen; ///< Dimensionality. +} +psType; + +/// @} + +#endif Index: /tags/rel2_1/psLib/src/types/psArray.c =================================================================== --- /tags/rel2_1/psLib/src/types/psArray.c (revision 1553) +++ /tags/rel2_1/psLib/src/types/psArray.c (revision 1553) @@ -0,0 +1,122 @@ + +/** @file psArray.c + * + * @brief Contains support for basic vector types + * + * This file defines the basic type for a vector struct and functions useful + * in manupulating vectors. + * + * @author Ross Harman, MHPCC + * + * @version $Revision: 1.13 $ $Name: not supported by cvs2svn $ + * @date $Date: 2004-08-09 23:34:57 $ + * + * Copyright 2004 Maui High Performance Computing Center, University of Hawaii + */ + +/******************************************************************************/ + +/* INCLUDE FILES */ + +/******************************************************************************/ +#include // for qsort, etc. + +#include "psMemory.h" +#include "psError.h" +#include "psArray.h" +#include "psLogMsg.h" + +/*****************************************************************************/ + +/* FUNCTION IMPLEMENTATION - LOCAL */ + +/*****************************************************************************/ +static void arrayFree(psArray* restrict psArr); + +/*****************************************************************************/ + +/* FUNCTION IMPLEMENTATION - PUBLIC */ + +/*****************************************************************************/ +psArray* psArrayAlloc(unsigned int nalloc) +{ + psArray* psArr = NULL; + + // Invalid nalloc + if (nalloc < 1) { + psError(__func__, "Invalid value for nalloc. nalloc: %d\n", nalloc); + return NULL; + } + // Create vector struct + psArr = (psArray* ) psAlloc(sizeof(psArray)); + p_psMemSetDeallocator(psArr, (psFreeFcn) arrayFree); + + psArr->nalloc = nalloc; + psArr->n = nalloc; + + // Create vector data array + psArr->data = psAlloc(nalloc * sizeof(psPTR)); + + return psArr; +} + +psArray* psArrayRealloc(unsigned int nalloc, psArray* restrict in) +{ + // Invalid nalloc + if (nalloc < 1) { + psError(__func__, "Invalid value for realloc (%d)\n", nalloc); + return NULL; + } + + if (in == NULL) { + psError(__func__, "Null input vector\n"); + return NULL; + } else if (in->nalloc != nalloc) { // No need to realloc to same size + if (nalloc < in->n) { + for (int i = nalloc; i < in->n; i++) { // For reduction in vector size + psFree(in->data[i]); + } + in->n = nalloc; + } + // Realloc after decrementation to avoid accessing freed array elements + in->data = psRealloc(in->data, nalloc * sizeof(psPTR)); + in->nalloc = nalloc; + } + + return in; +} + +static void arrayFree(psArray* restrict psArr) +{ + if (psArr == NULL) { + return; + } + + psArrayElementFree(psArr); + + psFree(psArr->data); +} + +void psArrayElementFree(psArray* restrict psArr) +{ + + if (psArr == NULL) { + return; + } + + for (int i = 0; i < psArr->n; i++) { + psFree(psArr->data[i]); + psArr->data[i] = NULL; + } +} + +psArray* psArraySort(psArray* in, psComparePtrFcn compare) +{ + if (in == NULL) { + return NULL; + } + + qsort(in->data, in->n, sizeof(psPTR), (int (*)(const void *, const void *))compare); + + return in; +} Index: /tags/rel2_1/psLib/src/types/psArray.h =================================================================== --- /tags/rel2_1/psLib/src/types/psArray.h (revision 1553) +++ /tags/rel2_1/psLib/src/types/psArray.h (revision 1553) @@ -0,0 +1,105 @@ + +/** @file psArray.h + * + * @brief Contains basic array definitions and operations + * + * This file defines the basic type for a array struct and functions useful + * in manupulating arrays. + * + * @ingroup Array + * + * @author Robert DeSonia, MHPCC + * @author Ross Harman, MHPCC + * + * @version $Revision: 1.16 $ $Name: not supported by cvs2svn $ + * @date $Date: 2004-08-11 19:47:31 $ + * + * Copyright 2004 Maui High Performance Computing Center, University of Hawaii + */ + +#ifndef PS_ARRAY_H +#define PS_ARRAY_H + +#include "psType.h" +#include "psCompare.h" + +/// @addtogroup Array +/// @{ + +/** An array to support primitive types. + * + * Struct for maintaining an array of frequently used primitive types. + * + */ +typedef struct +{ + unsigned int nalloc; ///< Total number of elements available. + unsigned int n; ///< Number of elements in use. + psPTR* data; ///< An Array of pointer elements +} +psArray; + +/*****************************************************************************/ + +/* FUNCTION PROTOTYPES */ + +/*****************************************************************************/ + +/** Allocate an array. + * + * Uses psLib memory allocation functions to create an array collection of + * data + * + * @return psArray* : Pointer to psArray. + * + */ +psArray* psArrayAlloc( + unsigned int nalloc ///< Total number of elements to make available. +); + +/** Reallocate an array. + * + * Uses psLib memory allocation functions to reallocate an array collection + * of data. + * + * @return psArray* : Pointer to psArray. + * + */ +psArray* psArrayRealloc( + unsigned int nalloc, ///< Total number of elements to make available. + psArray* restrict psArr ///< array to reallocate. +); + +/** Deallocate/Dereference elements of an array. + * + * Uses psLib memory allocation functions to deallocate/dereference elements + * of a array of void pointers. The array psArr is not freed, and its elements + * will all be set to NULL. + * + */ +void psArrayElementFree( + psArray* restrict psArr ///< Void pointer array to destroy. +); + +/** Sort the array according to an external compare function. + * + * Sorts an array via the specification of a comparison function + * to specify how the objects on the array should be sorted. + * + * The comparison function must return an integer less than, equal to, or + * greater than zero if the first argument is considered to be respectively + * less than, equal to, or greater than the second. + * + * If two members compare as equal, their order in the sorted array is + * undefined. + * + * @return psArray* The sorted array. + */ +psArray* psArraySort( + psArray* in, ///< input array to sort. + psComparePtrFcn compare ///< the compare function +); + +/// @} + +#endif Index: /tags/rel2_1/psLib/src/types/psBitSet.c =================================================================== --- /tags/rel2_1/psLib/src/types/psBitSet.c (revision 1553) +++ /tags/rel2_1/psLib/src/types/psBitSet.c (revision 1553) @@ -0,0 +1,297 @@ + +/** @file psBitSet.c + * + * @brief Creates an array of bytes of arbitrary length for storing individual bits. + * + * Bit masks are useful tools for toggling various flags and options. This set of functions module provides + * a mechanism to create an array of bits of arbitrary length and manipulate them with basic binary + * operations. A print function is also provided to display the entire set of bits in binary format as a + * string. + * + * @author Ross Harman, MHPCC + * + * @version $Revision: 1.16 $ $Name: not supported by cvs2svn $ + * @date $Date: 2004-08-09 23:34:57 $ + * + * Copyright 2004 Maui High Performance Computing Center, University of Hawaii + */ + +/******************************************************************************/ + +/* INCLUDE FILES */ + +/******************************************************************************/ +#include +#include +#include +#include +#include + +#include "psBitSet.h" +#include "psMemory.h" +#include "psError.h" +#include "psAbort.h" + +/******************************************************************************/ + +/* DEFINE STATEMENTS */ + +/******************************************************************************/ + +// None + +/******************************************************************************/ + +/* TYPE DEFINITIONS */ + +/******************************************************************************/ + +// None + +/*****************************************************************************/ + +/* GLOBAL VARIABLES */ + +/*****************************************************************************/ + +// None + +/*****************************************************************************/ + +/* FILE STATIC VARIABLES */ + +/*****************************************************************************/ + +// None + +/*****************************************************************************/ + +/* FUNCTION IMPLEMENTATION - LOCAL */ + +/*****************************************************************************/ +static void psBitSetFree(psBitSet* restrict inBitSet); + +/** Private function to create a mask. + * + * Creates an eight bit mask with the given bit set. All other bits in the byte are zero. The input bit uses + * zero-based indexing, and is the cumulitive index within the array, not the localized byte's bit position. + * + * @return char*: Pointer to byte in which bit is contained. + */ +static char mask(int bit) +{ + char mask = (char)0x01; + + // Ignore splint warning about negative bit shifts + /* @i@ */ + mask = mask << (bit % 8); + + return mask; +} + +/*****************************************************************************/ + +/* FUNCTION IMPLEMENTATION - PUBLIC */ + +/*****************************************************************************/ +psBitSet* psBitSetAlloc(int n) +{ + int numBytes = 0; + psBitSet* newObj = NULL; + + if (n <= 0) { + psError(__func__, " : Line %d - Allocation size must be > 0: size = %d", __LINE__, n); + return 0; + } + + numBytes = ceil(n / 8.0); + newObj = psAlloc(sizeof(psBitSet)); + if (newObj == NULL) { + psAbort(__func__, " : Line %d - Failed to allocate memory", __LINE__); + } + p_psMemSetDeallocator(newObj, (psFreeFcn) psBitSetFree); + newObj->n = numBytes; + + // Ignore splint warning about releasing pointer members, since they've not been allocated yet + /* @i@ */ + newObj->bits = psAlloc(sizeof(char) * numBytes); + if (newObj->bits == NULL) { + psAbort(__func__, " : Line %d - Failed to allocate memory", __LINE__); + } + + memset(newObj->bits, numBytes, 0); + + return newObj; +} + +static void psBitSetFree(psBitSet* restrict inBitSet) +{ + if (inBitSet == NULL) { + psError(__func__, " : Line %d - Null psBitSet for inBitSet argument", __LINE__); + return; + } + psFree(inBitSet->bits); +} + +psBitSet* psBitSetSet(psBitSet* inBitSet, int bit) +{ + char *byte = NULL; + + if (inBitSet == NULL) { + psError(__func__, " : Line %d - Null psBitSet for inBitSet argument", __LINE__); + return inBitSet; + } else if (bit < 0) { + psError(__func__, " : Line %d - Bit position too small: %d", __LINE__, bit); + return inBitSet; + } else if (bit > inBitSet->n * 8 - 1) { + psError(__func__, " : Line %d - Bit position too large: %d", __LINE__, bit); + return inBitSet; + } + // Variable byte is the byte in the array that contains the bit to be set + byte = inBitSet->bits + bit / 8; + *byte |= mask(bit); + + return inBitSet; +} + +bool psBitSetTest(const psBitSet* inBitSet, int bit) +{ + char *byte = NULL; + + if (inBitSet == NULL) { + psError(__func__, " : Line %d - Null psBitSet for inBitSet argument", __LINE__); + return 0; + } else if (bit < 0) { + psError(__func__, " : Line %d - Bit position too small: %d", __LINE__, bit); + return 0; + } else if (bit > inBitSet->n * 8 - 1) { + psError(__func__, " : Line %d - Bit position too large: %d", __LINE__, bit); + return 0; + } + // Variable byte is the byte in the array that contains the bit to be tested + byte = inBitSet->bits + bit / 8; + if ((int)(*byte & mask(bit)) == 0) { + return 0; + } + + return 1; +} + +psBitSet* psBitSetOp(psBitSet* outBitSet, const psBitSet* restrict inBitSet1, char *operator, + const psBitSet* restrict inBitSet2) +{ + int i = 0; + int n = 0; + char tempChar = '0'; + char *outBits = NULL; + char *inBits1 = NULL; + char *inBits2 = NULL; + + if (inBitSet1 == NULL) { + psError(__func__, " : Line %d - Null psBitSet for inBitSet1 argument", __LINE__); + return outBitSet; + } + + if (operator == NULL) { + psError(__func__, " : Line %d - Null input operator\n", __LINE__); + return outBitSet; + } + + if (inBitSet2 == NULL) { + psError(__func__, " : Line %d - Null psBitSet for inBitSet2 argument", __LINE__); + return outBitSet; + } + + if (outBitSet == NULL) { + outBitSet = psBitSetAlloc(inBitSet1->n * 8); + } + + if (inBitSet1->n != inBitSet2->n || outBitSet->n != inBitSet1->n) { + psError(__func__, " : Line %d - psBitSet sizes not the same", __LINE__); + return outBitSet; + } + + n = outBitSet->n; + outBits = outBitSet->bits; + inBits1 = inBitSet1->bits; + inBits2 = inBitSet2->bits; + + tempChar = toupper(operator[0]); + switch (tempChar) { + case 'A': + for (i = 0; i < n; i++) { + outBits[i] = inBits1[i] & inBits2[i]; + } + break; + case 'O': + for (i = 0; i < n; i++) { + outBits[i] = inBits1[i] | inBits2[i]; + } + break; + case 'X': + for (i = 0; i < n; i++) { + outBits[i] = inBits1[i] ^ inBits2[i]; + } + break; + default: + psError(__func__, " : Line %d - Invalid psBitMask binary operation: %s", __LINE__, operator); + } + + return outBitSet; +} + +psBitSet* psBitSetNot(psBitSet* outBitSet, const psBitSet* restrict inBitSet) +{ + int i = 0; + int n = 0; + char *outBits = NULL; + char *inBits = NULL; + + if (inBitSet == NULL) { + psError(__func__, " : Line %d - Null psBitSet for inBitSet argument", __LINE__); + return outBitSet; + } + + n = inBitSet->n; + if (n == 0) { + psError(__func__, " : Line %d - No elements in inBitSet", __LINE__); + return outBitSet; + } + + if (outBitSet == NULL) { + outBitSet = psBitSetAlloc(n * 8); + } + + if (inBitSet->n != outBitSet->n) { + psError(__func__, " : Line %d - psBitSet sizes not the same", __LINE__); + return outBitSet; + } + + outBits = outBitSet->bits; + inBits = inBitSet->bits; + + for (i = 0; i < n; i++) { + outBits[i] = ~inBits[i]; + } + + return outBitSet; +} + +char *psBitSetToString(const psBitSet* restrict inBitSet) +{ + int i = 0; + int numBits = inBitSet->n * 8; + char *outString = psAlloc((size_t) numBits + 1); + + if (outString == NULL) { + psAbort(__func__, " : Line %d - Failed to allocate memory", __LINE__); + } + + for (i = 0; i < numBits; i++) { + outString[numBits - i - 1] = (psBitSetTest(inBitSet, i) == 1) ? '1' : '0'; + } + + outString[numBits] = 0; + + return outString; +} Index: /tags/rel2_1/psLib/src/types/psBitSet.h =================================================================== --- /tags/rel2_1/psLib/src/types/psBitSet.h (revision 1553) +++ /tags/rel2_1/psLib/src/types/psBitSet.h (revision 1553) @@ -0,0 +1,134 @@ + +/** @file psBitSet.h + * + * @brief Creates an array of bytes of arbitrary length for storing individual bits. + * + * Bit masks are useful tools for toggling various flags and options. This set of functions module provides + * a mechanism to create an array of bits of arbitrary length and manipulate them with basic binary + * operations. A print function is also provided to display the entire set of bits in binary format as a + * string. + * + * @ingroup BitSet + * + * @author Ross Harman, MHPCC + * + * @version $Revision: 1.13 $ $Name: not supported by cvs2svn $ + * @date $Date: 2004-08-11 19:53:33 $ + * + * Copyright 2004 Maui High Performance Computing Center, University of Hawaii + */ + +#ifndef PSBITSET_H +#define PSBITSET_H + +/// @addtogroup BitSet +/// @{ + +/******************************************************************************/ + +/* TYPE DEFINITIONS */ + +/******************************************************************************/ + +/** Struct containing array of bytes to hold bit data and corresponding array length. + * + * The bits in the struct are assembled in as an array of bytes with eight bits per byte. The bits are + * arranged with the LSB in first (right most) position of the first array element. + */ +typedef struct +{ + int n; ///< Number of bytes in the array + char *bits; ///< Aray of bytes holding bits +} +psBitSet; + +/*****************************************************************************/ + +/* FUNCTION PROTOTYPES */ + +/*****************************************************************************/ + +/** Allocate a psBitSet. + * + * Create a psBitSet with the number of bits specified by the user. All bits are set to zero upon + * allocation. + * + * @return psBitSet* : Pointer to struct containing array of bits and size of array. + */ + +/*@null@*/ +psBitSet* psBitSetAlloc( + int n ///< Number of bits in psBitSet array +); + +/** Set a bit. + * + * Sets a bit at a given bit location, either one or zero. The bit is set based on a zero index with the + * first bit set in the zero bit slot of the zero element of the byte array. As an example, setting bit 3 in + * an array with two elements would result in an psBitSet that looks like 00000000 00001000. + * + * @return psBitSet* : Pointer to struct containing psBitSet. + */ +psBitSet* psBitSetSet( + /* @returned@ */ + psBitSet* restrict inMask, ///< Pointer to psBitSet to be set. + int bit ///< Bit to be set. +); + +/** Test the value of a bit. + * + * Prints the value of a bit at a given bit location, either one or zero. The resulting bit is based on a + * zero index format with the first bit set in the zero bit slot of the zero element of the byte array + * As an example, testing bit 3 in a psBitSet with two bytes that looks like 00000000 00001000 would return a + * value of one, since that is the value that was set. + * + * @return int: Value of bit, either one or zero. + */ + +bool psBitSetTest( + const psBitSet* restrict inMask, ///< Pointer psBitSet to be tested. + int bit ///< Bit to be tested. +); + +/** Perform a binary operation on two psBitSets + * + * Perform an AND, OR, or XOR on two psBitSets. If the BitMasks are not the same size, the operation will not + * be performed and an error message will be logged. + * + * @return psBitSet* : Pointer to struct containing result of binary operation. + */ +psBitSet* psBitSetOp( + /* @returned@ */ + psBitSet* restrict outMask, ///< Resulting psBitSet from binary operation + const psBitSet* restrict inMask1, ///< First psBitSet on which to operate + char *operator, ///< Bit operation + const psBitSet* restrict inMask2 ///< First psBitSet on which to operate +); + +/** Perform a not operation on a psBitSet + * + * Toggles bits in a psBitset. All zero bits are set to one and all one bits are set to zero. + * + * @return psBitSet* : Pointer to struct containing result of operation. + */ + +psBitSet* psBitSetNot( + psBitSet* outBitSet, ///< Resulting psBitSet from operation + const psBitSet* restrict inBitSet ///< Input psBitSet +); + +/** Convert the psBitSet to a string of ones and zeros. + * + * Converts the contents of a psBitSet to a string representation of its binary form of ones and zeros. The + * LSB is the right-most chracter. Each set of eight characters represents one byte. + * + * @return char*: Pointer to character array containing string data. + */ + +char *psBitSetToString( + const psBitSet* restrict inMask ///< psBitSet to convert */ +); + +/// @} + +#endif Index: /tags/rel2_1/psLib/src/types/psHash.c =================================================================== --- /tags/rel2_1/psLib/src/types/psHash.c (revision 1553) +++ /tags/rel2_1/psLib/src/types/psHash.c (revision 1553) @@ -0,0 +1,408 @@ + +/** @file psHash.c +* +* @brief Contains support for basic hashing functions. +* +* This file will hold the functions for defining a hash table with arbitrary +* data types, allocating/deallocating that hash table, adding and removing +* data from that hash table, and listing all keys defined in the hash table. +* +* @author Robert Lupton, Princeton University +* @author George Gusciora, MHPCC +* +* @version $Revision: 1.2 $ $Name: not supported by cvs2svn $ +* @date $Date: 2004-08-09 23:34:57 $ +* +* Copyright 2004 Maui High Performance Computing Center, University of Hawaii +*/ +#include +#include +#include +#include +#include "psHash.h" +#include "psMemory.h" +#include "psString.h" +#include "psTrace.h" +#include "psAbort.h" + +static psHashBucket* hashBucketAlloc(const char *key, void *data, psHashBucket* next); +static void hashBucketFree(psHashBucket* bucket); +static void *doHashWork(psHash* table, const char *key, void *data, bool remove + ); +static void hashFree(psHash* table); + +/****************************************************************************** +psHashKeyList(table): this function creates a linked list with an entry in +that list for every key in the hash table. +Inputs: + table: a hash table +Return; + The linked list + *****************************************************************************/ +psList* psHashKeyList(psHash* table) +{ + int i = 0; // Loop index variable + psList* myLinkList = NULL; // The output data structure + psHashBucket* ptr = NULL; // Used to step thru linked list. + + if (table == NULL) { + return NULL; + } + // Create the linked list + myLinkList = psListAlloc(NULL); + + // Loop through every bucket in the hash table. If that bucket is not + // NULL, then add the bucket's key to the linked list. + for (i = 0; i < table->nbucket; i++) { + if (table->buckets[i] != NULL) { + // Since a bucket contains a linked list of keys/data, we must + // step trough each key in that linked list: + + ptr = table->buckets[i]; + while (ptr != NULL) { + psListAdd(myLinkList, ptr->key, PS_LIST_HEAD); + ptr = ptr->next; + } + } + } + + // Return the linked list + return (myLinkList); +} + +/****************************************************************************** +hashBucketAlloc(key, data, next): This procedure creates a new hash bucket +with the specified key, data, and next. +Inputs: + key: the new bucket's key pointer + data: the new bucket's data pointer + next: the new bucket's key pointer +Return: + the new hash bucket. + *****************************************************************************/ +static psHashBucket* hashBucketAlloc(const char *key, void *data, psHashBucket* next) +{ + if (key == NULL) { + psAbort(__func__, "psHashBucket() called with NULL key."); + } + // Allocate memory for the new hash bucket. + psHashBucket* bucket = psAlloc(sizeof(psHashBucket)); + + p_psMemSetDeallocator(bucket, (psFreeFcn) hashBucketFree); + + // Initialize the bucket. + bucket->key = psStringCopy(key); + + if (data == NULL) { + // NOTE: Should we flag a warning message? + bucket->data = NULL; + } else { + bucket->data = psMemIncrRefCounter(data); + } + + bucket->next = next; + + return bucket; +} + +/****************************************************************************** +hashBucketFree(bucket): This procedure deallocates the specified +hash bucket. +Inputs: + bucket: the hash bucket to be freed. +Return: + NONE + *****************************************************************************/ +static void hashBucketFree(psHashBucket* bucket) +{ + if (bucket == NULL) { + return; + } + + psFree(bucket->key); + + psFree(bucket->data); +} + +/****************************************************************************** +psHashAlloc(nbucket): this procedure creates a new hash table with the +specified number of buckets. +Inputs: + nbucket: initial number of buckets +Return: + The new hash table. + *****************************************************************************/ +psHash* psHashAlloc(int nbucket) // initial number of buckets +{ + int i = 0; // loop index variable + + // Create the new hash table. + psHash* table = psAlloc(sizeof(psHash)); + + p_psMemSetDeallocator(table, (psFreeFcn) hashFree); + + // Allocate memory for the buckets. + table->buckets = psAlloc(nbucket * sizeof(psHashBucket* )); + table->nbucket = nbucket; + + psTrace("utils.hash", 1, "Creating %d-element hash table\n", nbucket); + + // Initialize all buckets to NULL. + for (i = 0; i < nbucket; i++) + { + table->buckets[i] = NULL; + } + + // Return the new hash table. + return table; +} + +/****************************************************************************** +psHashFree(table, itemFree): This procedure deallocates the specified hash +table. It loops through each bucket, and calls hashBucketFree() on that +bucket. + +Inputs: + table: a hash table +Return: + NONE + *****************************************************************************/ +static void hashFree(psHash* table) +{ + int i = 0; // Loop index variable. + + if (table == NULL) { + return; + } + // Loop through each bucket in the hash table. If that bucket is not + // NULL, then free the bucket via a function call to hashBucketFree(); + for (i = 0; i < table->nbucket; i++) { + + // A bucket is composed of a linked list of buckets. + while (table->buckets[i] != NULL) { + psHashBucket* bucket = table->buckets[i]; + table->buckets[i] = bucket->next; + psFree(bucket); + } + } + + // Free the bucket structure, then the hash table. + psFree(table->buckets); +} + +/****************************************************************************** +doHashWork(table, key, data, remove): This is an internal +procedure which does the bulk of the work in using the hash table. Depending +upon the input parameters, it will either insert a new key/data into the hash +table, retrieve the data for a specified key, or remove a key/data item. If +we try to insert a key that already exists in the hash table, then we deallocate +the existing data/key item. +Inputs: + table: a hash table + key: the key to insert, retrieve, or remove. Must not be NULL. + data: the data to insert, if not NULL + remove: set to non-zero if the key/data should be removed from the table. +Return: + NONE + +NOTE: consider removing this private function and simply putting the code +into the psHashInsert(), psHashLookup(), and psHashRemove(). Why? Because +there is little common code between those functions. + *****************************************************************************/ +static void *doHashWork(psHash* table, const char *key, void *data, bool remove + ) +{ + long int hash = 1; // This will contain an integer value + + // "hashed" from the key. + char *tmpchar = NULL; // Used in computing the hash function. + psHashBucket* ptr = NULL; // Used to retrieve the hash bucket. + psHashBucket* optr = NULL; // "original pointer": used to step + + // thru the linked list for a bucket. + + // The following condition should never be true, since this is a private + // function, but I'm checking it anyway since future coders might change + // the way this procedure is called. + if ((table == NULL) || (key == NULL)) { + + psAbort(__func__, "psHashRemove() called with NULL key or table."); + } + // NOTE: This is the originally supplied hash function. + // for (int i = 0, len = strlen(key); i < len; i++) { + // hash = (hash << 1) ^ key[i]; + // } + // hash &= (table->nbucket - 1); + + // This hash algorithm is from Sedgewick. NOTE: must reread to ensure that + // the size of the hash table is not required to be a prime number. + tmpchar = (char *)key; + for (hash = 0; *tmpchar != '\0'; tmpchar++) { + hash = (64 * hash + *tmpchar) % (table->nbucket); + } + + // NOTE: This should not be necessary, but for now, I'm checking bounds + // anyway. + if ((hash < 0) || (hash >= table->nbucket)) { + psAbort(__func__, "Internal hash function out of range (%d)", hash); + } + // ptr will have the correct hash bucket. + ptr = table->buckets[hash]; + + // We know the correct hash bucket, now we need to know what to do. + // If the data parameter is NULL, then, by definition, this is a retrieve + // or a remove operation on the hash table. + + if (data == NULL) { + if (remove + ) { + // We search through the linked list for this bucket in + // the hash table and look for an entry for this key. + + optr = ptr; + while (ptr != NULL) { + // Determine if this entry holds the correct key. + if (strcmp(key, ptr->key) == 0) { + // The following lines of code are fairly standard ways + // of removing an item from a single-linked list. + + void *data = ptr->data; + + optr->next = ptr->next; + if (ptr == table->buckets[hash]) { + table->buckets[hash] = ptr->next; + } + psFree(ptr); + + // By definition, the data associated with that key + // must be returned, not freed. + return data; + } + optr = ptr; + ptr = ptr->next; + } + return NULL; // not in hash + } + else { + // If we get here, then a retrieve operation is requested. So, + // we step trough the linked list at this bucket, and return the + // data once we find it, or return NULL if we don't. + while (ptr != NULL) { + if (strcmp(key, ptr->key) == 0) { + return ptr->data; + } + ptr = ptr->next; + } + return NULL; // not in hash + } + } else { + // We get here if this procedure was called with non-NULL data. + // Therefore, we should insert that data into the hash table. + // First, we search through the linked list for this bucket in + // the hash table and look for a duplicate entry for this key. + + while (ptr != NULL) { + if (strcmp(key, ptr->key) == 0) { + // We have found this key in the hash table. + + psTrace("utils.hash.insert", 3, "Replacing data for %s\n", key); + + // NOTE: I have changed this behavior from the originally + // supplied code. Formerly, if itemFree was NULL, then + // the new data was not inserted into the hash table. + + psFree(ptr->data); + + ptr->data = psMemIncrRefCounter(data); + return data; + } + ptr = ptr->next; + } + // We did not found key in the linked list for this bucket of the hash + // table. So, we insert this data at the head of that linked list. + + table->buckets[hash] = hashBucketAlloc(key, data, table->buckets[hash]); + return data; + } +} + +/****************************************************************************** +psHashInsert(table, key, data, itemFree): this procedure, which is part of +the public API, inserts a new key/data pair into the hash table. +Inputs: + table: a hash table + key: the key to use + data: the data to insert. + itemFree: a function pointer +Return: + boolean value defining success or failure + *****************************************************************************/ +bool psHashAdd(psHash* table, const char *key, void *data) +{ + if (table == NULL) { + psAbort(__func__, "psHashInsert() called with NULL hash table."); + } + if (key == NULL) { + psAbort(__func__, "psHashInsert() called with NULL key."); + } + if (data == NULL) { + psAbort(__func__, "psHashLookup() called with NULL data."); + } + + return (doHashWork(table, key, data, 0) != NULL); +} + +/****************************************************************************** +psHashLookup(table, key): this procedure, which is part of the public API, +looks up the specified key in the hash table and returns the data associated +with that key. + +Inputs: + table: a hash table + key: the key to use +Return: + The data associated with that key. + *****************************************************************************/ +void *psHashLookup(psHash* table, // table to lookup key in + const char *key) // key to lookup +{ + if (table == NULL) { + psAbort(__func__, "psHashLookup() called with NULL hash table."); + } + if (key == NULL) { + psAbort(__func__, "psHashLookup() called with NULL key."); + } + + return doHashWork(table, key, NULL, 0); +} + +/****************************************************************************** +psHashRemove(table, key, itemFree): this procedure, which is part of the +public API, removes the specified key from the hash table. +Inputs: + table: a hash table + key: the key to remove + itemFree: a function pointer +Return: + boolean value defining success or failure + *****************************************************************************/ +bool psHashRemove(psHash* table, const char *key) +{ + void *data = NULL; + bool retVal = false; + + if (table == NULL) { + psAbort(__func__, "psHashRemove() called with NULL hash table."); + } + if (key == NULL) { + psAbort(__func__, "psHashRemove() called with NULL key."); + } + + data = doHashWork(table, key, NULL, 1); + if (data != NULL) { + retVal = true; + } else { + retVal = false; + } + return retVal; +} Index: /tags/rel2_1/psLib/src/types/psHash.h =================================================================== --- /tags/rel2_1/psLib/src/types/psHash.h (revision 1553) +++ /tags/rel2_1/psLib/src/types/psHash.h (revision 1553) @@ -0,0 +1,73 @@ + +/** @file psHash.h + * @brief Contains support for basic hashing functions. + * @ingroup HashTable + * + * This file will hold the prototypes for defining a hash table with arbitrary + * data types, allocating/deallocating that has table, adding and removing + * data from that hash table, and listing all keys defined in the hash table. + * + * @author Robert Lupton, Princeton University + * @author George Gusciora, MHPCC + * + * @version $Revision: 1.4 $ $Name: not supported by cvs2svn $ + * @date $Date: 2004-08-09 23:40:55 $ + * + * Copyright 2004 Maui High Performance Computing Center, University of Hawaii + */ +#if !defined(PS_HASH_H) +#define PS_HASH_H + +/** \addtogroup HashTable + * \{ + */ +#include + +#include "psList.h" + +/** A bucket that holds an item of data. */ +typedef struct psHashBucket +{ + char *key; ///< key for this item of data + void *data; ///< the data itself + struct psHashBucket* next; ///< list of other possible keys +} +psHashBucket; + +//typedef struct HashTable psHash; ///< Opaque type for a hash table + +/** The hash-table itself. */ +typedef struct psHash +{ + int nbucket; ///< Number of buckets in hash table. + psHashBucket* *buckets; ///< The bucket data. +} +psHash; + +/// Allocate hash buckets in table. +psHash* psHashAlloc(int nbucket ///< The number of buckets to allocate. + ); + +/// Insert entry into table. +bool psHashAdd(psHash* table, ///< table to insert in + const char *key, ///< key to use + void *data ///< data to insert + ); + +/// Lookup key in table. +void *psHashLookup(psHash* table, ///< table to lookup key in + const char *key ///< key to lookup + ); + +/// Remove key from table. +bool psHashRemove(psHash* table, ///< table to lookup key in + const char *key ///< key to lookup + ); + +/// List all keys in table. +psList* psHashKeyList(psHash* table ///< table to list keys from. + ); + +/* \} */// End of DataGroup Functions + +#endif Index: /tags/rel2_1/psLib/src/types/psList.c =================================================================== --- /tags/rel2_1/psLib/src/types/psList.c (revision 1553) +++ /tags/rel2_1/psLib/src/types/psList.c (revision 1553) @@ -0,0 +1,475 @@ + +/** @file psList.c + * @brief Support for doubly linked lists + * @ingroup LinkedList + * + * @author Robert Lupton, Princeton University + * @author Robert Daniel DeSonia, MHPCC + * + * @version $Revision: 1.16 $ $Name: not supported by cvs2svn $ + * @date $Date: 2004-08-14 01:48:45 $ + * + * Copyright 2004 Maui High Performance Computing Center, University of Hawaii + */ + +#include +#include +#include +#include // we need a mutex to make this stuff thread safe. + +#include "psError.h" +#include "psAbort.h" +#include "psMemory.h" +#include "psList.h" +#include "psTrace.h" +#include "psLogMsg.h" + +#define ITER_INIT_HEAD ((void *)1) // next iteration should return head +#define ITER_INIT_TAIL ((void *)2) // next iteration should return tail + +// private functions. +static psListElem* listGetIterator(psList* list); +static int listGetIteratorIndex(psList* list); +static void listSetIterator(psList* list, int where, bool lockList); +static void listFree(psList* list); + +psList* psListAlloc(void *data) +{ + psList* list = psAlloc(sizeof(psList)); + + p_psMemSetDeallocator(list, (psFreeFcn) listFree); + + list->size = 0; + list->head = list->tail = NULL; + list->iter = ITER_INIT_HEAD; + list->iterIndex = PS_LIST_HEAD; + + pthread_mutex_init(&(list->lock), NULL) + ; + + if (data != NULL) { + psListAdd(list, data, PS_LIST_TAIL); + } + + return list; +} + +static void listFree(psList* list) +{ + if (list == NULL) { + return; + } + + pthread_mutex_lock(&list->lock) + ; + + for (psListElem* ptr = list->head; ptr != NULL;) { + psListElem* next = ptr->next; + + psFree(ptr->data); + psFree(ptr); + + ptr = next; + } + + pthread_mutex_unlock(&list->lock) + ; + + pthread_mutex_destroy(&list->lock) + ; + +} + +bool psListAdd(psList* list, void *data, int where) +{ + psListElem* position; + psListElem* elem; + int cursorIndex = 0; + + if (list == NULL) { + return false; + } + + if (data == NULL) { + return false; + } + + if (where <= PS_LIST_UNKNOWN) { + // / XXX What is the better way to communicate this failure to the caller? + psLogMsg(__func__, PS_LOG_WARN, "The given insert location (%i) for psListAdd is invalid.", where); + return false; + } + + elem = psAlloc(sizeof(psListElem)); + + pthread_mutex_lock(&list->lock) + ; + + if (where > 0 && where > list->size) { + psLogMsg(__func__, PS_LOG_WARN, + "Invalid index %d (only %d elements in psList); assuming tail.", where, list->size); + where = PS_LIST_TAIL; + } + + if (where == PS_LIST_TAIL || list->size == 0) { + // insert the element at the end of the list + elem->prev = list->tail; + elem->next = NULL; + + if (list->tail != NULL) { + list->tail->next = elem; + } + + if (list->head == NULL) { + list->head = elem; + } + list->tail = elem; + + list->size++; + list->iter = elem; + list->iterIndex = list->size - 1; + } else { + // move ourselves to the given position + listSetIterator(list, where, false); + position = listGetIterator(list); + cursorIndex = listGetIteratorIndex(list); + + if (position == NULL) { + psError(__func__, "%s failed to move cursor to specified location (%d)", __func__, where); + position = list->head; // since we no list->size != 0, this must be non-NULL + } + // insert our new element in front of the given position + elem->prev = position->prev; + elem->next = position; + position->prev = elem; + + if (elem->prev == NULL) { // must be front of list + list->head = elem; + } else { + elem->prev->next = elem; + } + + list->size++; + list->iter = elem; + list->iterIndex = cursorIndex; + } + + elem->data = psMemIncrRefCounter(data); + + pthread_mutex_unlock(&list->lock) + ; + + return true; +} + +/*****************************************************************************/ + +/* + * Remove an element from a list + */ +bool psListRemove(psList* list, void *data, int which) +{ + psListElem* elem = NULL; // element to remove + int cursorIndex = 0; + + if (list == NULL) { + psError(__func__, "list parameter found to be NULL in %s", __func__); + return false; + } + // get exclusive access to list so that other threads will not get in the way. + pthread_mutex_lock(&list->lock) + ; + + if (which == PS_LIST_UNKNOWN) { + // search list for the data item. + + int i = 0; // index + + for (psListElem* ptr = list->head; ptr != NULL; ptr = ptr->next) { + if (ptr->data == data) { + which = i; + break; + } + i++; + } + + if (which == PS_LIST_UNKNOWN) { + psError(__func__, "Failed to find item in given psList."); + pthread_mutex_unlock(&list->lock) + ; + return false; + } + } + // position the list's cursor to the desired location + listSetIterator(list, which, false); + elem = listGetIterator(list); + cursorIndex = listGetIteratorIndex(list); + + if (elem == NULL) { + psError(__func__, "Couldn't position to given index (%d) to remove element from list.", which); + pthread_mutex_unlock(&list->lock) + ; + return false; + } + + list->size--; + + if (elem->prev == NULL) { // head of list? + list->head = elem->next; + } else { + elem->prev->next = elem->next; + } + + if (elem->next == NULL) { // tail of list? + list->tail = elem->prev; + + // removed tail, so iter should be the last element of list to keep it valid + if (list->size > 0) { + list->iter = list->tail; + list->iterIndex = list->size - 1; + } else { + list->iter = ITER_INIT_TAIL; + } + } else { + elem->next->prev = elem->prev; + list->iter = elem->next; + list->iterIndex = cursorIndex; + } + + pthread_mutex_unlock(&list->lock) + ; + + // OK, delete list element and its data + psFree(elem->data); + psFree(elem); + + return true; +} + +void psListSetIterator(psList* list, int where) +{ + listSetIterator(list, where, true); +} + +void listSetIterator(psList* list, int where, bool lockList) +{ + psListElem* cursor; + int position; + + if (list == NULL) { + psError(__func__, "Unexpected null pointer for psList parameter (%s:%d).", __FILE__, __LINE__); + return; + } + + if (where == PS_LIST_CURRENT) { + return; + } + + if (lockList) { + pthread_mutex_lock(&list->lock) + ; + // don't want the list changing on us while we move about + } + + if (where >= (int)list->size) { + list->iter = NULL; + if (lockList) { + pthread_mutex_unlock(&list->lock) + ; + } + return; + } + + switch (where) { + case PS_LIST_HEAD: + list->iter = ITER_INIT_HEAD; + break; + + case PS_LIST_TAIL: + list->iter = ITER_INIT_TAIL; + break; + + case PS_LIST_PREVIOUS: + cursor = listGetIterator(list); + position = listGetIteratorIndex(list); + + if (cursor != NULL) { + list->iter = cursor->prev; + list->iterIndex = position - 1; + } + break; + + case PS_LIST_NEXT: + cursor = listGetIterator(list); + position = listGetIteratorIndex(list); + + if (cursor != NULL) { + list->iter = cursor->next; + list->iterIndex = position + 1; + } + break; + + case PS_LIST_CURRENT: + break; + + default: + if (where <= PS_LIST_HEAD) { // bascially same as PS_LIST_UNKNOWN above + psError(__func__, "Can't move to an unknown position. Not moving the iterator position."); + } else { + cursor = listGetIterator(list); + if (cursor == NULL) { // reset the iterator if it is invalid + list->iter = ITER_INIT_HEAD; + list->iterIndex = 0; + } + + int position = listGetIteratorIndex(list); + + if (where < position) { + int diff = position - where; + + for (int count = 0; count < diff; count++) { + listSetIterator(list, PS_LIST_PREVIOUS, false); + } + } else { + int diff = where - position; + + for (int count = 0; count < diff; count++) { + listSetIterator(list, PS_LIST_NEXT, false); + } + } + } + break; + } + + if (lockList) { + pthread_mutex_unlock(&list->lock) + ; + } +} + +psListElem* listGetIterator(psList* list) +{ + if (list == NULL) { + return NULL; + } + + if (list->iter == ITER_INIT_HEAD) { + return list->head; + } else if (list->iter == ITER_INIT_TAIL) { + return list->tail; + } else { + return list->iter; + } +} + +int listGetIteratorIndex(psList* list) +{ + if (list->iter == ITER_INIT_HEAD) { + return 0; + } else if (list->iter == ITER_INIT_TAIL) { + return list->size - 1; + } else { + return list->iterIndex; + } +} + +void *psListGet(psList* list, int which) +{ + psListElem* element; + + psListSetIterator(list, which); + element = listGetIterator(list); + + if (element == NULL) { + return NULL; + } else { + return element->data; + } +} + +/* + * and now return the previous/next element of the list + */ +void *psListGetNext(psList* list) +{ + return psListGet(list, PS_LIST_NEXT); +} + +void *psListGetPrevious(psList* list) +{ + return psListGet(list, PS_LIST_PREVIOUS); +} + +void *psListGetCurrent(psList* list) +{ + return psListGet(list, PS_LIST_CURRENT); +} + +/* + * Convert a psList to/from a psVoidPtrArray + */ +psArray* psListToArray(psList* restrict list) +{ + psListElem* ptr; + unsigned int n; + psArray* restrict arr; + + if (list == NULL) { + return NULL; + } + + if (list->size > 0) { + arr = psArrayAlloc(list->size); + } else { + arr = psArrayAlloc(1); + } + + arr->n = list->size; + + ptr = list->head; + n = list->size; + for (int i = 0; i < n; i++) { + arr->data[i] = psMemIncrRefCounter(ptr->data); + ptr = ptr->next; + } + + return arr; +} + +psList* psArrayToList(psArray* arr) +{ + unsigned int n; + psList* list; // list of elements + + if (arr == NULL) { + return NULL; + } + + list = psListAlloc(NULL); + n = arr->n; + for (int i = 0; i < n; i++) { + psListAdd(list, arr->data[i], PS_LIST_TAIL); + } + + return list; +} + +psList* psListSort(psList* list, psComparePtrFcn compare) +{ + psArray* arr; + + if (list == NULL) { + return NULL; + } + // convert to indexable vector for use by qsort. + arr = psListToArray(list); + psFree(list); + + arr = psArraySort(arr, compare); + + // convert back to linked list + list = psArrayToList(arr); + psFree(arr); + + return list; +} Index: /tags/rel2_1/psLib/src/types/psList.h =================================================================== --- /tags/rel2_1/psLib/src/types/psList.h (revision 1553) +++ /tags/rel2_1/psLib/src/types/psList.h (revision 1553) @@ -0,0 +1,192 @@ +#if !defined(PS_LIST_H) +#define PS_LIST_H + +/** @file psList.h + * @brief Support for doubly linked lists + * + * @author Robert Lupton, Princeton University + * @author Robert Daniel DeSonia, MHPCC + * + * @ingroup LinkedList + * + * @version $Revision: 1.14 $ $Name: not supported by cvs2svn $ + * @date $Date: 2004-08-11 20:04:51 $ + * + * Copyright 2004 Maui High Performance Computing Center, University of Hawaii + */ + +#include // we need a mutex to make this stuff thread safe. +#include // we use the bool type. + +#include "psCompare.h" +#include "psArray.h" + +/** @addtogroup LinkedList + * @{ + */ + +/** Special values of index into list + * + * This list of possible list position values should be contiguous non-positive values ending with + * PS_LIST_UNKNOWN. Any value less-than-or-equal-to PS_LIST_UNKNOWN is considered a undefined position. + * + */ +enum { + PS_LIST_HEAD = 0, ///< at head + PS_LIST_TAIL = -1, ///< at tail + PS_LIST_PREVIOUS = -2, ///< previous element + PS_LIST_CURRENT = -3, ///< current element + PS_LIST_NEXT = -4, ///< next element + PS_LIST_UNKNOWN = -5 ///< unknown position (should be last in enum list) +}; + +/** Doubly-linked list element */ +typedef struct psListElem +{ + struct psListElem* prev; ///< previous link in list + struct psListElem* next; ///< next link in list + void *data; ///< real data item +} +psListElem; + +/** The psList Linked list structure. User should not allocate this struct + * directly; rather the psListAlloc should be used. + * + * @see psListAlloc, psListFree + */ +typedef struct +{ + unsigned int size; ///< number of elements on list + psListElem* head; ///< first element on list (may be NULL) + psListElem* tail; ///< last element on list (may be NULL) + psListElem* iter; ///< iteration cursor + unsigned int iterIndex; ///< the numeric position of the iteration cursor in the list + pthread_mutex_t lock; ///< mutex to lock a node during changes +} +psList; + +/** Creates a psList linked list object. + * + * @return psList* A new psList object. + */ +psList* psListAlloc( + void *data + ///< initial data item; may be NULL if no an empty psList is desired +) +; + +/** Adds an element to a psList at position given. + * + * @return psList* The psList with added data item. If list parameter is + * NULL, the return value will also be NULL. + */ +bool psListAdd( + psList* restrict list, ///< list to add to (if NULL, nothing is done) + void *data, ///< data item to add. If NULL, list is not modified. + int where ///< index, PS_LIST_HEAD, PS_LIST_TAIL, or numbered location. +); + +/** Remove an item from a list. If which parameter is PS_LIST_UNKNOWN, + * + * @return bool TRUE if element is successfully removed, otherwise FALSE. + */ +bool psListRemove( + psList* restrict list, + ///< list to remove element from + void *data, + ///< if which is PS_LIST_UNKNOWN, data item to find and remove, otherwise this is ignored. + int which + ///< index of item, or PS_LIST_UNKNOWN, PS_LIST_NEXT, PS_LIST_PREV, or numbered location. +); + +/** Retrieve an item from a list. + * + * @return void* the item corresponding to the which parameter. If + * which is invalid (e.g., a numbered index greater + * than the list size or if the list is empty), a + * NULL is returned. + */ +void *psListGet( + psList* restrict list, ///< list to retrieve element from + int which ///< index number, or PS_LIST_NEXT, PS_LIST_PREV, PS_LIST_UNKNOWN +); + +/** Set the iterator of the list to a given position. If where is invalid the + * iterator position is not changed. + * + */ +void psListSetIterator( + psList* restrict list, ///< list to retrieve element from + int where ///< index number, PS_LIST_HEAD, or PS_LIST_TAIL +); + +/** Get next element relative to the iterator. This also moves the iterator to + * the next list position. + * + * @return void* the data item next on the list or NULL if the iterator + * is already pointing to the last element or the list + * parameter was NULL. + */ +void *psListGetNext( + psList* restrict list ///< list to retrieve element from +); + +/** Get current element according to the psList's iterator cursor. This does + * not move the iterator location. + * + * @return void* the data item cooresponding to current iterator + * cursor position of the list, or NULL if either the + * iterator is not valid or list parameter was NULL. + */ +void *psListGetCurrent( + psList* restrict list ///< list to retrieve element from +); + +/** Get previous element relative to list's iterator. This also moves the + * iterator to the previous list position. + * + * @return void* the data item previous on the list or NULL if the iterator + * is already pointing to the first element or the list + * parameter was NULL. + */ +void *psListGetPrevious( + psList* restrict list ///< list to retrieve element from +); + +/** Convert a linked list to an array + * + * @return psArray* A new psArray populated with elements from the list, + * or NULL if the given dlist parameter is NULL. + */ +psArray* psListToArray( + psList* dlist ///< List to convert +); + +/** Convert array to a doubly-linked list + * + * @return psList* A new psList populated with elements formt the psArray, + * or NULL is the given arr parameter is NULL. + */ +psList* psArrayToList( + psArray* arr ///< vector to convert +); + +/** Sort a list via a comparison function. + * + * The comparison function must return an integer less than, equal to, or + * greater than zero if the first argument is considered to be respectively + * less than, equal to, or greater than the second. + * + * If two members compare as equal, their order in the sorted array is + * undefined. + * + * @return psList* Sorted list. + */ +psList* psListSort( + psList* list, ///< the list to sort + psComparePtrFcn compare ///< the comparison function +); + +/// @} End of DataGroup Functions + +#endif Index: /tags/rel2_1/psLib/src/types/psMetadata.c =================================================================== --- /tags/rel2_1/psLib/src/types/psMetadata.c (revision 1553) +++ /tags/rel2_1/psLib/src/types/psMetadata.c (revision 1553) @@ -0,0 +1,761 @@ + +/** @file psMetadata.c +* +* +* @brief Contains metadata struuctures, enumerations and functions prototypes +* +* This file defines metadata item, metadata type, metadata flags, metadata containers, and function +* prototypes necessary creating psLib metadata APIs +* +* @ingroup Metadata +* +* @author Ross Harman, MHPCC +* +* @version $Revision: 1.24 $ $Name: not supported by cvs2svn $ +* @date $Date: 2004-08-14 02:55:46 $ +* +* Copyright 2004 Maui High Performance Computing Center, University of Hawaii +*/ + +/******************************************************************************/ +/* INCLUDE FILES */ +/******************************************************************************/ +#include +#include +#include + +#include "fitsio.h" +#include "psType.h" +#include "psMemory.h" +#include "psError.h" +#include "psAbort.h" +#include "psList.h" +#include "psHash.h" +#include "psMetadata.h" +#include "psString.h" + +/******************************************************************************/ +/* DEFINE STATEMENTS */ +/******************************************************************************/ + +#define FITS_ERROR(STRING,PS_ERROR) \ +fits_get_errstatus(status, fitsErr); \ +psError( __func__, STRING, PS_ERROR, fitsErr); \ +status = 0; \ +return output; + +/** Maximum size of a FITS line */ +#define FITS_LINE_SIZE 80 + +/** Maximum size of a string */ +#define MAX_STRING_LENGTH 1024 + +/******************************************************************************/ +/* TYPE DEFINITIONS */ +/******************************************************************************/ + +// None + +/*****************************************************************************/ +/* GLOBAL VARIABLES */ +/*****************************************************************************/ + +// None + +/*****************************************************************************/ +/* FILE STATIC VARIABLES */ +/*****************************************************************************/ + +static int metadataId = 0; + +/*****************************************************************************/ +/* FUNCTION IMPLEMENTATION - LOCAL */ +/*****************************************************************************/ + +static void metadataItemFree(psMetadataItem* metadataItem) +{ + psMetadataType type; + + type = metadataItem->type; + + if (metadataItem == NULL) { + return; + } + + psFree(metadataItem->name); + psFree(metadataItem->comment); + psFree(metadataItem->items); + + if (type == PS_META_STR || + type == PS_META_IMG || + type == PS_META_JPEG || type == PS_META_PNG || type == PS_META_ASTROM || type == PS_META_UNKNOWN) { + psFree(metadataItem->data.V); + } +} + +static void metadataFree(psMetadata* metadata) +{ + if (metadata == NULL) { + return; + } + psFree(metadata->list); + psFree(metadata->table); +} + +/*****************************************************************************/ +/* FUNCTION IMPLEMENTATION - PUBLIC */ +/*****************************************************************************/ + +psMetadataItem* psMetadataItemAlloc(const char *name, psMetadataType type, const char *comment, ...) +{ + va_list argPtr; + psMetadataItem* metadataItem = NULL; + + // Get the variable list parameters to pass to allocation function + va_start(argPtr, comment); + + // Call metadata item allocation + metadataItem = psMetadataItemAllocV(name, type, comment, argPtr); + + // Clean up stack after variable arguement has been used + va_end(argPtr); + + return metadataItem; +} + +psMetadataItem* psMetadataItemAllocV(const char *name, psMetadataType type, const char *comment, + va_list argPtr) +{ + psMetadataItem* metadataItem = NULL; + + if (name == NULL) { + psError(__func__, "Null value for name not allowed"); + return NULL; + } + // Allocate metadata item + metadataItem = (psMetadataItem* ) psAlloc(sizeof(psMetadataItem)); + if (metadataItem == NULL) { + psAbort(__func__, "Failed to allocate memory"); + } + // Set deallocator + p_psMemSetDeallocator(metadataItem, (psFreeFcn) metadataItemFree); + + // Allocate and set metadata item comment + metadataItem->comment = (char *)psAlloc(sizeof(char) * MAX_STRING_LENGTH); + if (comment == NULL) { + // Per SDRS, null isn't allowed, must use "" instead + strncpy(metadataItem->comment, "", MAX_STRING_LENGTH); + } else { + strncpy(metadataItem->comment, comment, MAX_STRING_LENGTH); + } + + // Set metadata item unique id + *(int *)(&metadataItem->id) = ++metadataId; + + // Set metadata item type + metadataItem->type = type; + + // Set metadata item value + switch (type) { + case PS_META_ITEM_SET: + metadataItem->data.V = NULL; + break; + case PS_META_BOOL: + metadataItem->data.B = (bool)va_arg(argPtr, int); + break; + case PS_META_S32: + metadataItem->data.S32 = va_arg(argPtr, psS32); + break; + case PS_META_F32: + metadataItem->data.F32 = (psF32)va_arg(argPtr, psF64); + break; + case PS_META_F64: + metadataItem->data.F64 = va_arg(argPtr, psF64); + break; + case PS_META_STR: + metadataItem->data.V = psStringNCopy(va_arg(argPtr, char *), MAX_STRING_LENGTH); + break; + case PS_META_IMG: + case PS_META_JPEG: + case PS_META_PNG: + case PS_META_ASTROM: + case PS_META_UNKNOWN: + default: + psError(__func__, "Invalid psMetadataType: %d", type); + } + + // Allocate and set metadata item name + metadataItem->name = (char *)psAlloc(sizeof(char) * MAX_STRING_LENGTH); + vsprintf(metadataItem->name, name, argPtr); + + // Allocate metadata items with same name. + metadataItem->items = psListAlloc(NULL); + + return metadataItem; +} + +psMetadata* psMetadataAlloc(void) +{ + psList* list = NULL; + psHash* table = NULL; + psMetadata* metadata = NULL; + + // Allocate metadata + metadata = (psMetadata* ) psAlloc(sizeof(psMetadata)); + if (metadata == NULL) { + psAbort(__func__, "Failed to allocate metadata"); + } + // Set deallocator + p_psMemSetDeallocator(metadata, (psFreeFcn) metadataFree); + + // Allocate metadata's internal containers + list = (psList* ) psListAlloc(NULL); + if (list == NULL) { + psAbort(__func__, "Failed to allocate list"); + } + + table = (psHash* ) psHashAlloc(10); + if (table == NULL) { + psAbort(__func__, "Failed to allocate table"); + } + + metadata->list = list; + metadata->table = table; + + return metadata; +} + +bool psMetadataAddItem( psMetadata *restrict md, int where, psMetadataItem *restrict metadataItem ) +{ + char * key = NULL; + psHash *mdTable = NULL; + psList *mdList = NULL; + psMetadataItem *existingEntry = NULL; + psMetadataItem *newFolderEntry = NULL; + psMetadataType newType = PS_META_ITEM_SET; + + if(md == NULL) { + psError( __func__, "Null metadata collection not allowed" ); + return false; + } + + if(metadataItem == NULL) { + psError( __func__, "Null metadata item not allowed" ); + return false; + } + + newType = metadataItem->type; + + mdTable = md->table; + if(mdTable == NULL) { + psError( __func__, "Null metadata table not allowed" ); + return false; + } + + mdList = md->list; + if(mdList == NULL) { + psError( __func__, "Null metadata list not allowed"); + return false; + } + + key = metadataItem->name; + if(key == NULL) { + psError(__func__, "Null key item not allowed"); + return false; + } + + // See if key is already in table + existingEntry = (psMetadataItem*)psHashLookup(mdTable, key); + if(existingEntry != NULL) { + + if(existingEntry->type == PS_META_ITEM_SET) { + + // Add leaf node to existing folder node + if(!psListAdd(existingEntry->items, metadataItem, PS_LIST_TAIL)) { + psError( __func__, "Couldn't add metadata item to items list. Name: %s", + metadataItem->name ); + return false; + } + } else if(existingEntry->type != PS_META_ITEM_SET && newType!= PS_META_ITEM_SET) { + + // Leaf node replaces another leaf. Make new folder node and add leaves. + newFolderEntry = psMetadataItemAlloc(key, PS_META_ITEM_SET, NULL, NULL); + + if(!psListAdd(newFolderEntry->items, existingEntry, PS_LIST_TAIL)) { + psError( __func__, "Couldn't add metadata item to items list. Name: %s", key); + psFree(newFolderEntry); + return false; + } + + if(!psListAdd(newFolderEntry->items, metadataItem, PS_LIST_TAIL)) { + psError( __func__, "Couldn't add metadata item to items list. Name: %s", key); + psFree(newFolderEntry); + return false; + } + + if(!psHashRemove(mdTable, key)) { + psError( __func__, "Couldn't remove metadata item from metadata table. Name: %s", key); + psFree(newFolderEntry); + return false; + } + + if(!psHashAdd(mdTable, key, newFolderEntry)) { + psError( __func__, "Couldn't add metadata item to metadata table. Name: %s", key); + psFree(newFolderEntry); + return false; + } + + // Remove local reference to new folder node + psMemDecrRefCounter(newFolderEntry); + } else { + + // Folder node replaces leaf or folder node - Put old node into new folder and remove from table + if(!psListAdd(metadataItem->items, existingEntry, PS_LIST_TAIL)) { + psError( __func__, "Couldn't add metadata item to items list. Name: %s", key); + return false; + } + + if(!psHashRemove(mdTable, key)) { + psError( __func__, "Couldn't remove metadata item from metadata table. Name: %s", key); + return false; + } + + if(!psHashAdd(mdTable, key, metadataItem)) { + psError( __func__, "Couldn't add metadata item to metadata table. Name: %s", key); + return false; + } + } + } else { + + // Node doesn't exist - Add new metadata item to metadata collection's hash + if(!psHashAdd(mdTable, key, metadataItem)) { + psError( __func__, "Couldn't add metadata item to metadata table. Name: %s", key); + return false; + } + } + + // Add all items to metadata collection's list, even if they have the same metadata item names + if(!psListAdd( mdList, metadataItem, where )) { + psError( __func__, "Couldn't add metadata item to metadata collection list. Name: %s", + metadataItem->name ); + return false; + } + + return true; +} + +bool psMetadataAdd(psMetadata* restrict md, int where, const char *name, psMetadataType type, + const char *comment, ...) +{ + va_list argPtr; + psMetadataItem* metadataItem = NULL; + + va_start(argPtr, comment); + metadataItem = psMetadataItemAllocV(name, type, comment, argPtr); + va_end(argPtr); + + if (!psMetadataAddItem(md, where, metadataItem)) { + psError(__func__, "Couldn't add metadata item to metadata collection list. Name: %s", + metadataItem->name); + psFree(metadataItem); + return false; + } + // Decrement reference count, since the metadata item is now in metadata collection and no longer needed + // here + psMemDecrRefCounter(metadataItem); + + return true; +} + + + +bool psMetadataRemove(psMetadata* restrict md, int where, const char *restrict key) +{ + int numChildren = 0; + psList* mdList = NULL; + psHash* mdTable = NULL; + psMetadataItem* entry = NULL; + psMetadataItem* entryChild = NULL; + + + if (md == NULL) { + psError(__func__, "Null metadata collection not allowed"); + return false; + } + + mdList = md->list; + if (mdList == NULL) { + psError(__func__, "Null metadata list not allowed"); + return false; + } + + mdTable = md->table; + if (mdTable == NULL) { + psError(__func__, "Null metadata table not allowed"); + return false; + } + // Select removal by key or index + if (key != NULL) { + + // Remove by key name + entry = (psMetadataItem* ) psHashLookup(mdTable, key); + if (entry == NULL) { + psError(__func__, "Couldn't find metadata item. Name: %s", key); + return false; + } + + numChildren = entry->items->size; + if (entry->type == PS_META_ITEM_SET && numChildren > 0) { + + // Table entry has children. Entry and children must be removed from metadata collection's list + psListSetIterator(entry->items, PS_LIST_HEAD); + entryChild = psListGetCurrent(entry->items); + while (entryChild != NULL) { + if (!psListRemove(mdList, entryChild, PS_LIST_UNKNOWN)) { + psError(__func__, "Couldn't remove metadata item from list. Name: %s", key); + return false; + } + entryChild = psListGetNext(entry->items); + } + } else { + + // Table entry has no children. Remove entry from metadata collection's list + if (!psListRemove(mdList, entry, PS_LIST_UNKNOWN)) { + psError(__func__, "Couldn't remove metadata item from list. Name: %s", key); + return false; + } + } + // Remove entry from metadata collection's table + if (!psHashRemove(mdTable, key)) { + psError(__func__, "Couldn't remove metadata item from table. Name: %s", key); + return false; + } + } else { + + // Remove by index + entry = psListGet(mdList, where); + if (entry == NULL) { + psError(__func__, "Couldn't find metadata item in list. Index: %d", where); + return false; + } + + key = entry->name; + if (key == NULL) { + psError(__func__, "Null key name not allowed. Index: %d", where); + return false; + } + // Use recursive remove, now that key is known + psMetadataRemove(md, PS_LIST_UNKNOWN, key); + } + + return true; +} + +psMetadataItem* psMetadataLookup(psMetadata* restrict md, const char *restrict key) +{ + psHash* mdTable = NULL; + psMetadataItem* entry = NULL; + + + if (md == NULL) { + psError(__func__, "Null metadata collection not allowed"); + return NULL; + } + + mdTable = md->table; + if (mdTable == NULL) { + psError(__func__, "Null metadata table not allowed"); + return NULL; + } + + if (key == NULL) { + psError(__func__, "Null key name not allowed"); + return NULL; + } + + entry = (psMetadataItem* ) psHashLookup(mdTable, key); + if (entry == NULL) { + psError(__func__, "Could not find metadata item. Key: %s", key); + return NULL; + } + + return entry; +} + +psMetadataItem* psMetadataGet(psMetadata* restrict md, int where) +{ + psList* mdList = NULL; + psMetadataItem* entry = NULL; + + + if (md == NULL) { + psError(__func__, "Null metadata collection not allowed"); + return NULL; + } + + mdList = md->list; + if (mdList == NULL) { + psError(__func__, "Null metadata list not allowed"); + return NULL; + } + + entry = (psMetadataItem* ) psListGet(mdList, where); + if (entry == NULL) { + psError(__func__, "Couldn't find metadata item with given index. Index: %d", where); + return NULL; + } + + return entry; +} + +bool psMetadataSetIterator(psMetadata* restrict md, int where) +{ + psList* mdList = NULL; + + if (md == NULL) { + psError(__func__, "Null metadata collection not allowed"); + return false; + } + + mdList = md->list; + if (mdList == NULL) { + psError(__func__, "Null metadata list not allowed"); + return false; + } + + psListSetIterator(mdList, where); + + return true; +} + +psMetadataItem* psMetadataGetNext(psMetadata* restrict md, const char *restrict match, int which) +{ + psList* mdList = NULL; + psMetadataItem* entry = NULL; + + + if (md == NULL) { + psError(__func__, "Null metadata collection not allowed"); + return NULL; + } + + mdList = md->list; + if (mdList == NULL) { + psError(__func__, "Null metadata list not allowed"); + return NULL; + } + + psListSetIterator(mdList, which); + entry = psListGetCurrent(mdList); + while (entry != NULL) { + if(match != NULL) { + if (!strncmp(match, entry->name, strlen(match))) { + + // Match found + return entry; + } + entry = psListGetNext(mdList); + } else { + return psListGetNext(mdList); + } + } + + // Match not found + if (entry == NULL) { + psError(__func__, "Couldn't find metadata item"); + } + + return entry; +} + +psMetadataItem* psMetadataGetPrevious(psMetadata* restrict md, const char *restrict match, int which) +{ + psList* mdList = NULL; + psMetadataItem* entry = NULL; + + + if (md == NULL) { + psError(__func__, "Null metadata collection not allowed"); + return NULL; + } + + mdList = md->list; + if (mdList == NULL) { + psError(__func__, "Null metadata list not allowed"); + return NULL; + } + + psListSetIterator(mdList, which); + entry = psListGetCurrent(mdList); + while (entry != NULL) { + if(match != NULL) { + if (!strncmp(match, entry->name, strlen(match))) { + + // Match found + return entry; + } + entry = psListGetPrevious(mdList); + } else { + return psListGetPrevious(mdList); + } + } + + // Match not found + if (entry == NULL) { + psError(__func__, "Couldn't find metadata item", match); + } + + return entry; +} + +void psMetadataItemPrint(FILE * fd, const char *format, const psMetadataItem* restrict metadataItem) +{ + psMetadataType type; + + if (fd == NULL) { + psError(__func__, "Null file descriptor not allowed"); + return; + } + + if (format == NULL) { + psError(__func__, "Null format not allowed"); + return; + } + + if (metadataItem == NULL) { + psError(__func__, "Null metadata not allowed"); + return; + } + + type = metadataItem->type; + + switch (type) { + case PS_META_BOOL: + fprintf(fd, format, metadataItem->data.B); + break; + case PS_META_S32: + fprintf(fd,format, metadataItem->data.S32); + break; + case PS_META_F32: + fprintf(fd, format, metadataItem->data.F32); + break; + case PS_META_F64: + fprintf(fd, format, metadataItem->data.F64); + break; + case PS_META_STR: + fprintf(fd, format, metadataItem->data.V); + break; + case PS_META_ITEM_SET: + case PS_META_IMG: + case PS_META_JPEG: + case PS_META_PNG: + case PS_META_ASTROM: + case PS_META_UNKNOWN: + default: + psError(__func__, " Invalid psMetadataType to print: %d", type); + } +} + +psMetadata* psMetadataFReadHeader(psMetadata* output, char *extName, int extNum, fitsfile * fd) +{ + bool tempBool; + bool success; + char keyType; + char keyName[FITS_LINE_SIZE]; + char keyValue[FITS_LINE_SIZE]; + char keyComment[FITS_LINE_SIZE]; + char fitsErr[MAX_STRING_LENGTH]; + int i; + int hduType = 0; + int status = 0; + int numKeys = 0; + int keyNum = 0; + psMetadataType metadataItemType; + + if (fd == NULL) { + psError(__func__, "Null FITS file descriptor not allowed"); + return NULL; + } + + if (extName == NULL && extNum == 0) { + psError(__func__, "Null extName and extNum = 0 not allowed"); + return NULL; + } else if (extName && extNum) { + psError(__func__, "Both extName and extNum arguments should not have non zero values."); + return NULL; + } + // Allocate metadata if user didn't + if (output == NULL) { + output = psMetadataAlloc(); + } + // Move to user designated HDU number or HDU name in FITS file. HDU numbers starts at one. + if (extName != NULL) { + if (fits_movnam_hdu(fd, ANY_HDU, extName, 0, &status) != 0) { + FITS_ERROR("FITS error while locating header %s: %s", extName); + } + } else { + if (fits_movabs_hdu(fd, extNum, &hduType, &status) != 0) { + FITS_ERROR("FITS error while locating header %d: %s", extNum); + } + } + + // Get number of key names + if (fits_get_hdrpos(fd, &numKeys, &keyNum, &status) != 0) { + FITS_ERROR("FITS error while reading key %d: %s", keyNum); + } + // Get each key name. Keywords start at one. + for (i = 1; i <= numKeys; i++) { + if (fits_read_keyn(fd, i, keyName, keyValue, keyComment, &status) != 0) { + FITS_ERROR("FITS error while reading key %d: %s", keyNum); + } + if (fits_get_keytype(keyValue, &keyType, &status) != 0) { + fits_get_errstatus(status, fitsErr); + if (status != VALUE_UNDEFINED) { + FITS_ERROR("FITS error while determining key %d type: %s", keyNum); + } else { + // Some keywords are still valid even though they don't have a type, like COMMENTS and + // HISTORY + keyType = 'C'; + status = 0; + } + } + + switch (keyType) { + case 'I': + metadataItemType = PS_META_S32; + success = + psMetadataAdd(output, PS_LIST_TAIL, keyName, metadataItemType, keyComment, + atoi(keyValue)); + break; + case 'F': + metadataItemType = PS_META_F64; + success = + psMetadataAdd(output, PS_LIST_TAIL, keyName, metadataItemType, keyComment, + atof(keyValue)); + break; + case 'C': + metadataItemType = PS_META_STR; + success = + psMetadataAdd(output, PS_LIST_TAIL, keyName, metadataItemType, keyComment, keyValue); + break; + case 'L': + metadataItemType = PS_META_BOOL; + tempBool = (keyValue[0] == 'T') ? 1 : 0; + success = + psMetadataAdd(output, PS_LIST_TAIL, keyName, metadataItemType, keyComment, tempBool); + break; + case 'U': + case 'X': + default: + psError(__func__, "Invalid psMetadataType: %c", keyType); + return output; + } + + if (!success) { + psError(__func__, "Failed to add metadata item. Name: %s", keyName); + return output; + } + } + + return output; +} Index: /tags/rel2_1/psLib/src/types/psMetadata.h =================================================================== --- /tags/rel2_1/psLib/src/types/psMetadata.h (revision 1553) +++ /tags/rel2_1/psLib/src/types/psMetadata.h (revision 1553) @@ -0,0 +1,298 @@ + +/** @file psMetadata.h +* +* @brief Contains metadata struuctures, enumerations and functions prototypes +* +* This file defines metadata item, metadata type, metadata flags, metadata containers, and function +* prototypes necessary creating psLib metadata APIs +* +* @ingroup Metadata +* +* @author Ross Harman, MHPCC +* +* @version $Revision: 1.20 $ $Name: not supported by cvs2svn $ +* @date $Date: 2004-08-12 01:23:20 $ +* +* Copyright 2004 Maui High Performance Computing Center, University of Hawaii +*/ +#ifndef PS_METADATA_H +#define PS_METADATA_H + +#include +#include +#include + +#include "psHash.h" +#include "psList.h" + +/// @addtogroup Metadata +/// @{ + +/** Metadata item type. + * + * Enumeration for maintaining metadata item types. + */ +typedef enum { + PS_META_ITEM_SET = 0, ///< Null. Metadata is in psMetadataItem.items + PS_META_BOOL, ///< Boolean data. + PS_META_S32, ///< Signed 32-bit integer data. + PS_META_F32, ///< Single-precision float data. + PS_META_F64, ///< Double-precision float data. + PS_META_STR, ///< String data (Stored in as void *). + PS_META_IMG, ///< Image data (Stored in as void *). + PS_META_JPEG, ///< JPEG data (Stored in as void *). + PS_META_PNG, ///< PNG data (Stored in as void *). + PS_META_ASTROM, ///< Astrometric coefficients (Stored in as void *). + PS_META_UNKNOWN, ///< Other data (Stored in as void *). + PS_META_NTYPE ///< Number of types. Must be last. +} psMetadataType; + +/** Metadata item data structure. + * + * Struct for maintaining metadata items of varying types. It also contains + * information about the item name, flags, comments, and other items with the same name. + */ +typedef struct psMetadataItem +{ + const int id; ///< Unique ID for metadata item. + char *restrict name; ///< Name of metadata item. + psMetadataType type; ///< Type of metadata item. + union { + bool B; ///< boolean data + psS32 S32; ///< Signed 32-bit integer data. + psF32 F32; ///< Single-precision float data. + psF64 F64; ///< Double-precision float data. + psPTR V; ///< Pointer to other type of data. + } data; ///< Union for data types. + char *comment; ///< Optional comment ("", not NULL). + psList* restrict items; ///< List of psMetadataItems with same name. +} +psMetadataItem; + +/** Metadata data structure. + * + * Struct for holding metadata items. Metadata items are held in two + * containers. The first employs a doubly-linked list to preserve the order + * of the metadata. The second container employs a hash table which + * allows fast lookup when given a metadata keyword. + */ +typedef struct psMetadata +{ + psList* restrict list; ///< the metadata in linked-list + psHash* restrict table; ///< the metadata in a hash table +} +psMetadata; + +/*****************************************************************************/ + +/* FUNCTION PROTOTYPES */ + +/*****************************************************************************/ + +/** Create a metadata item. + * + * Returns a fill psMetadataItem ready for insertion into the psMetadata + * struct. The name argument specifies the name to use for this item, and + * may include sprintf formatting codes. The format entry specifies both + * the metadata type and optional flags and is created by bit-wise or of the + * appropriate type and flag. The comment argument is a fixed string used to + * comment the metadata item. The arguments to the name formatting codes and + * the metadata itself are passed as arguments following the comment string. + * The data must be a pointer for any of the elements stored in data.void. + * The argument list must be interpreted appropriately by the va_list + * operators in the function specified size and type. + * + * @return psMetadataItem* : Pointer metadata item. + */ +psMetadataItem* psMetadataItemAlloc( + const char *name, ///< Name of metadata item. + psMetadataType type, ///< Type of metadata item. + const char *comment, ///< Comment for metadata item. + ... ///< Arguments for name formatting and metadata item data. +); + +/** Create a metadata item with va_list. + * + * Returns a fill psMetadataItem ready for insertion into the psMetadata + * struct. The name argument specifies the name to use for this item, and + * may include sprintf formatting codes. The format entry specifies both + * the metadata type and optional flags and is created by bit-wise or of the + * appropriate type and flag. The comment argument is a fixed string used to + * comment the metadata item. The arguments to the name formatting codes and + * the metadata itself are passed as arguments following the comment string. + * The data must be a pointer for any of the elements stored in data.void. + * The argument list must be interpreted appropriately by the va_list + * operators in the function specified size and type. + * + * @return psMetadataItem* : Pointer metadata item. + */ +psMetadataItem* psMetadataItemAllocV( + const char *name, ///< Name of metadata item. + psMetadataType type, ///< Type of metadata item. + const char *comment, ///< Comment for metadata item. + va_list list ///< Arguments for name formatting and metadata item data. +); + +/** Create a metadata collection. + * + * Returns an empty metadata container with fully allocated internal metadata + * containers. + * + * @return psMetadata* : Pointer metadata. + */ +psMetadata* psMetadataAlloc(void); + +/** Add existing metadata item to metadata collection. + * + * Add a metadata item that has already been created to the metadata + * collection. + * + * @return bool: True for success, false for failure. + */ +bool psMetadataAddItem( + psMetadata* restrict md, ///< Metadata collection to insert metadat item. + int where, ///< Location to be added. + psMetadataItem* restrict item ///< Metadata item to be added. +); + +/** Create and add a metadata item to metadata collection. + * + * Creates a new metadata item add to the metadata collection. + * + * @return bool: True for success, false for failure. + */ +bool psMetadataAdd( + psMetadata* restrict md, ///< Metadata collection to insert metadat item. + int where, ///< Location to be added. + const char *name, ///< Name of metadata item. + psMetadataType type, ///< Type of metadata item. + const char *comment, ///< Comment for metadata item. + ... ///< Arguments for name formatting and metadata item data. +); + +/** Remove an item from metadata collection. + * + * Items may be removed from metadata by specifing a key or location. If the + * name is null, the where argument is used instead. If name is not null, + * where is set to PS_LIST_UNKNOWN. If the item is found, it is removed from + * the metadata and true is returned. If the key is not unique, then all + * items corresponding to it are removed. + * + * @return bool: True for success, false for failure. + */ +bool psMetadataRemove( + psMetadata* restrict md, ///< Metadata collection to insert metadat item. + int where, ///< Location to be removed. + const char *restrict key ///< Name of metadata key. +); + +/** Find an item in the metadata collection based on key name. + * + * Items may be found in the metadata by providing a key. If the key is + * non-unique, the first item is returned. If the item is not found, null is + * returned. + * + * @return psMetadataItem* : Pointer metadata item. + */ +psMetadataItem* psMetadataLookup( + psMetadata* restrict md, ///< Metadata collection to insert metadata item. + const char *restrict key ///< Name of metadata key. +); + +/** Find an item in the metadata collection based on list index. + * + * Items may be found in the metadata by their entry position in the list + * container. + * + * @return psMetadataItem* : Pointer metadata item. + */ +psMetadataItem* psMetadataGet( + psMetadata* restrict md, ///< Metadata collection to insert metadat item. + int where ///< Location to be retrieved. +); + +/** Set or reset metadata iterator. + * + * Metadata may be iterated by setting or resetting an iterator to a location + * in the metadata list. + * + * @return void: void. + */ +bool psMetadataSetIterator( + psMetadata* restrict md, ///< Metadata collection to iterate. + int where ///< Location of iterator. +); + +/** Get next metadata item. + * + * Get next metadata item in iterator list. + * + * @return psMetadataItem* : Pointer metadata item. + */ +psMetadataItem* psMetadataGetNext( + psMetadata* restrict md, ///< Metadata collection to iterate. + const char *restrict match, ///< Beginning of key name. + int which ///< Iterator to be used. +); + +/** Get previous metadata item. + * + * Get previous metadata item in iterator list. + * + * @return psMetadataItem* : Pointer metadata item. + */ +psMetadataItem* psMetadataGetPrevious( + psMetadata* restrict md, ///< Metadata collection to iterate. + const char *restrict match, ///< Beginning of key name. + int which ///< Iterator to be used. +); + +/** Print metadata item to file. + * + * Metadata items may be printed to an open file descriptor based on a + * provided format. The format is a sprintf format statement with exactly + * one % formatting command. If the metadata item type is a numeric type, + * this formatting command must also be numeric, and the type conversion + * performed to the value to match the format type. If the metadata type is + * a string, the fromatting command must also be for a string. If the + * metadata type is any other data type, printing is not allowed. + * + * @return psMetadataItem* : Pointer metadata item. + */ +void psMetadataItemPrint( + FILE * fd, ///< Pointer to file to write metadata item. + const char *format, ///< Format to print metadata item. + const psMetadataItem* restrict metadataItem ///< Metadata item to print. +); + +/** Read metadata header. + * + * Read a metadata header from file. If the file is not found, an error is + * reported. This file is currently unimplemented. + * + * @return psMetadata* : Pointer metadata. + */ +psMetadata* psMetadataReadHeader( + psMetadata* output, ///< Resulting metadata from read. + char *extname, ///< File name extension string. + int extnum, ///< File name extension number. Starts at 1. + char *filename ///< Name of file to read. +); + +/** Read metadata header. + * + * Read a metadata header from file. If the file is not found, an error is + * reported. + * + * @return psMetadata* : Pointer metadata. + */ +psMetadata* psMetadataFReadHeader( + psMetadata* output, ///< Resulting metadata from read. + char *extName, ///< File name extension string. + int extNum, ///< File name extension number. + fitsfile * fd ///< Pointer to file to read. +); + +/// @} + +#endif Index: /tags/rel2_1/psLib/test/.cvsignore =================================================================== --- /tags/rel2_1/psLib/test/.cvsignore (revision 1553) +++ /tags/rel2_1/psLib/test/.cvsignore (revision 1553) @@ -0,0 +1,3 @@ +temp +tst_psTime_01 +tst_psTime_02 Index: /tags/rel2_1/psLib/test/FullUnitTest =================================================================== --- /tags/rel2_1/psLib/test/FullUnitTest (revision 1553) +++ /tags/rel2_1/psLib/test/FullUnitTest (revision 1553) @@ -0,0 +1,710 @@ +#!/usr/bin/perl +# +# This is a perl script test harness which will recursively search the +# directory tree looking for files named UnitTest and then execute +# the script +# +# SYNOSIS : FullUnitTest options arguements +# +# where options = +# --verbose Display extra information to user +# --noverbose Don't display extra information to user +# --recursiv e Recursively run tests in directory tree +# --norecursive Test only the specified or current directory +# --silent Don't display any information to user +# --nosilent Display progress of script to user +# +# arguements = directory(ies) to perform tests +# +# RETURN : integer number of tests which failed +# +# $Revision: 1.13 $ $Name: not supported by cvs2svn $ +# $Date: 2004-08-14 02:27:02 $ +# +# Copyright 2004 Maui High Performance Computing Center, University of Hawaii +# +############################################################################## + +# Provide functions for determining the pathname of current working directory +use Cwd; + +# Provides functions for handling long command line options +use Getopt::Long; + +# Assign variables based on the presence of command line options to the script +# The ! option allows for --nooption to be set to zero +# (e.g. --noverbose --recursive causes $verbose=0 and $recursive=1) +GetOptions( + "verbose!" => \$verbose, + "recursive!" => \$recursive, + "silent!" => \$silent, + "clean!" => \$clean +); + +# Check if both silent and verbose options are set and if so stop the script +die "Can't specify both verbose and silent options." if ( $verbose && $silent ); + +# Set up the PSLIB_ROOT environment variable if the user doesn't have +if ( !$ENV{'PSLIB_ROOT'} ) { + + # Use the directory directly above where FullUnitTest script resides + $PSLIB_ROOT = `cd ..;pwd`; + + # Remove newline for the end of path returned + chomp($PSLIB_ROOT); + + # Set the environment variable + $ENV{'PSLIB_ROOT'} = $PSLIB_ROOT; + print("PSLIB_ROOT not found: set to $PSLIB_ROOT.\n") if $verbose; +} + +# add PSLIB_ROOT/lib to LD_LIBRARY_PATH and DYLD_LIBRARY_PATH environment +# variables +$ENV{'LD_LIBRARY_PATH'} = "$ENV{'PSLIB_ROOT'}/lib:$ENV{'LD_LIBRARY_PATH'}"; +$ENV{'DYLD_LIBRARY_PATH'} = "$ENV{'PSLIB_ROOT'}/lib:$ENV{'DYLD_LIBRARY_PATH'}"; + +# Initialize variables for counting the makes and test failures and the +# total makes and tests performed +$makeFailCount = 0; +$testpointFailCount = 0; +$testDriverFailCount = 0; +$totalTestpoints = 0; +$totalTestDrivers = 0; +$totalMakes = 0; + +# Initialize variable indicating how many arguements were passed +$args = 0; + +# Loop through all the arguements passed to the script +foreach (@ARGV) { + + # Remove newline if there is one + chomp; + + # Increment number of arguements found + $args++; + + # Set variable to current working directory + $cwd = cwd; + + # Change directory to the directory of the arguement + chdir($_); + + # Check for the recursive option + if ($recursive) { + + # Invoke subroutine to go to the lowest directory in tree + # starting at the specified directory + &worm($_); + } + else { + + # Invoke subroutines to run the test at the specified directory + &makeTestDrivers($_); + &executeTestDrivers($_); + } + + # Change directory back to the directory where FullUnitTest was invoked + chdir($cwd); +} + +# Check if there were no arguements specified +if ( $args == 0 ) { + + # Display message to user that all directories under the current will be + # tested + print("Recursively testing current directory tree.\n") if $verbose; + + # Invoke subroutine to go to recursively test each directory in tree + &worm( $ENV{"PWD"} ); +} + +# Check if there were any failures during make or testing +if ( $makeFailCount > 0 || $testDriverFailCount > 0 ) { + + # Display summary of failures + print("\nMake Failures = $makeFailCount out of $totalMakes"); + print( +"\nTest Driver Failures = $testDriverFailCount out of $totalTestDrivers\n" + ); + print( "\nMakes that failed:\n " . join( "\n ", @makesFailed ) . "\n" ) + if $makeFailCount; + print( "\nTests that failed:\n " . join( "\n ", @testsFailed ) . "\n" ) + if $testDriverFailCount; +} +else { + + # Display message of all makes and tests pass to user if silent option + # not specified + print( +"\nAll $totalTestDrivers Test Drivers Passed with $totalTestpoints Testpoints.\n" + ) + if ( !$silent ); +} + +# Exit with the number of tests that failed +exit($testDriverFailCount); + +################################################################################ +# +# SUBROUTINE: worm +# +# Description: This subroutine will perform the necessary unit tests be +# calling makeTestDrivers and executeTestDrivers subroutines +# and then check each subdirectory below the base directory +# recursively. +# +# Parameter(s): base directory to start testing +# +# Return: None +# +################################################################################ + +sub worm { + + # Assign local variable to input parameter + local ($base_dir) = @_; + local ( @files, $i ); + + # Invoke subroutine to make test driver in the base directory + &makeTestDrivers($base_dir); + + # Invoke subroutine to execute tests in the base directory + &executeTestDrivers($base_dir); + + # Create array of entries found in directory + @files = <*>; + + # Loop through the file list looking for another directory that is not + # labelled CVS and recursively invoke subroutine worm + $i = 0; + while ( $files[$i] ) { + + # Check for directory and directory not labelled CVS + if ( -d $files[$i] + && ( $files[$i] ne "CVS" ) + && ( $files[$i] ne "temp" ) + && ( $files[$i] ne "verified" ) ) + { + + # Change current directory to directory found + chdir( $files[$i] ); + + # Invoke subroutine worm again + &worm( $files[$i] ); + + # Change current directory back to parent + chdir(".."); + } + + # Increment file list index + $i++; + } +} + +################################################################################ +# +# SUBROUTINE: makeTestDrivers +# +# Description: This subroutine will perform a make for all the necessary +# test drivers. This will occur in the specified +# base directory which is passed as the only parameter. +# +# Parameter(s): base directory where make and test drivers are located +# +# Return: None +# +################################################################################ + +sub makeTestDrivers { + local ($base_dir) = @_; + local ($pwd); + + # Set variable pwd to current working directory + $pwd = cwd; + + # Display message to user in which directory testing is taken place only + # if the silent command option was not specified + print("---- Entering $pwd ----\n") if ( !$silent ); + + # Check for the existence of a file name Makefile in current directory + if ( -e "Makefile" ) { + + # Increment the total number of makes executed + $totalMakes++; + + if ($clean) { + + # Execute the make clean + `make clean`; + + # Execute the make distclean + `make distclean`; + } + + # Execute the make and save results + $_ = join( "\n|| ", split( "\n", "\n" . `make` ) ); + + # Check the output of make for return value != 0 or any of the + # following words: FAILED, FAULT, ERROR, Not found, SIGNAL + if ( ( $? != 0 ) + || m/FAILED/i + || m/FAULT/i + || m/\bERROR/i + || m/Not found/i + || m/SIGNAL/i ) + { + + # Display the errored output of make if silent option not enabled + print("$_\n") if ( !$silent ); + + # Display the make failed in the current directory + print("\nMake for $pwd Failed\n"); + + # Increment the number of makes that have failed + $makeFailCount++; + + # Push the current working directory onto the list of failed + # make directories list + push( @makesFailed, $pwd ); + } + else { + + # Display the results of the successful make if verbose option set + print("$_\n") if $verbose; + + # Display the make was successful if silent option not set + print("\nMake successful.\n") if ( !$silent ); + if ($clean) { + `make install`; + } + } + } +} + +################################################################################ +# +# SUBROUTINE: executeTestDrivers +# +# Description: This subroutine will execute all the necessary +# test drivers. This will occur in the specified +# base directory which is passed as the only parameter. +# +# Parameter(s): base directory where make and test drivers are located +# +################################################################################ + +sub executeTestDrivers { + local ($base_dir) = @_; + local ( @files, $j ); + local ($pwd); + local ($exitValue) = 0; + + # Set variable to pwd to current test directory + $pwd = cwd; + + # Create a list of all elements in base directory + @files = <*>; + + # Loop through all the items in the files array + $initialTest = 0; + $j = 0; + while ( $files[$j] ) { + + # Check that the item is not a directory and is executable and + # conforms to the test driver naming convention TST + if ( !( -d $files[$j] ) + && ( -x $files[$j] ) + && ( $files[$j] =~ /^TST/i || $files[$j] =~ /^ATST/i ) ) + { + + # Increment total number of test drivers executed + $totalTestDrivers++; + + # Perform subdirectory checks only the first time a test + # file is found with the list of enteries + if ( $initialTest == 0 ) { + $initialTest++; + + # Check for a temp subdirectory already exists and if not + # then create one + &checkForTempDirectory(); + + # Check for the presence of verified directory + if ( &checkForVerifiedDirectory() ) { + + # Display message to user that verified directories do not + # exist eventhough TST files have been found + # print("Unable to execute test drivers in $base_dir\n"); + print("No verified subdirectory present.\n") if ($verbose); + + # Increment test fail count + # $testDriverFailCount++; + # Save the file failed + # push(@testsFailed, $pwd . "/" . $files[$j]); + # return; + } + } + + # Display message to user of which test driver is being executed + print("--- Executing test driver $files[$j]\n") if ( !$silent ); + + # Execute the test driver + system( +"./$files[$j] 1> temp/$files[$j].stdout 2> temp/$files[$j].stderr" + ); + $retVal = $?; + + # Count testpoints + $testPattern = "\"\\*\\*\\*\\* TESTPOINT \\*\\*\\*\\*\""; + $totalPoints = `grep -c $testPattern temp/$files[$j].stdout`; + $totalPoints += `grep -c $testPattern temp/$files[$j].stderr`; + $failPoints = + `grep "> TESTPOINT FAILED" temp/$files[$j].stdout | wc -l`; + $failPoints += + `grep "> TESTPOINT FAILED" temp/$files[$j].stderr | wc -l`; + $testpointFailCount += $failPoints; + $totalTestpoints += $totalPoints; + + # Check result of test driver + if ( ( ( $retVal != 0 ) && ( $files[$j] =~ /^TST/i ) ) + || ( ( $retVal == 0 ) && ( $files[$j] =~ /^ATST/i ) ) ) + { + + # Display test driver failed + $failPoints++; + print( + "Test driver: $files[$j] Failed (Return value $retVal).\n"); + + # Increment the total number of test failed + $testDriverFailCount++; + + # Push the current working directory on the list of failed + push( @testsFailed, $pwd . "/" . $files[$j] ); + } + else { + + # Create filter versions of STDOUT and STDERR to replace variable + # items such as date, time and host + &filterStdFiles( $files[$j] ); + + # Perform difference on STDOUT file collected + # with verified files + $exitValue = &compareStream("verified/$files[$j].stdout"); + if ( $exitValue & 2 ) { + + # STDOUT verified doesn't exist. Search STDOUT capture + # for strings indicating error or failure + $exitValue |= &errorStrSearch("$files[$j].stdout"); + } + if ( ( $exitValue & 8 ) || ( $exitValue & 64 ) ) { + + # Increment the total number of test failed + $testDriverFailCount++; + + # Push test on failed list + print( +"Test failed ($failPoints out of $totalPoints testpoints failed)\n" + ) + if ( !$silent ); + push( @testsFailed, $pwd . "/" . $files[$j] ); + } + else { + + # Perform difference on STDERR file collection with verified + $exitValue = &compareStream("verified/$files[$j].stderr"); + if ( $exitValue & 4 ) { + + # STDERR verified doesn't exist. Search STDERR capture + # for strings indicating error or failure + $exitValue |= &errorStrSearch("$files[$j].stderr"); + } + if ( ( $exitValue & 16 ) || ( $exitValue & 128 ) ) { + + # Increment the total number of tests failed + $testDriverFailCount++; + + # Push test on failed list + print( +"Test failed ($failPoints out of $totalPoints testpoints failed)\n" + ) + if ( !$silent ); + push( @testsFailed, $pwd . "/" . $files[$j] ); + } + else { + print("Test successful ($totalPoints testpoints)\n") + if ( !$silent ); + } + } + } + } + $j++; + } +} + +################################################################################ +# +# SUBROUTINE: errorStrSearch +# +# Description: This subroutine will search the file specified in its +# parameter for error strings and if they do exists +# the appropriate value will be returned. +# +# Parameter(s): fileName - input file to search for strings +# +# Return: 0 - No error strings found +# 64 - Error strings found in STDOUT +# 128 - Error strings found in STDERR +# +############################################################################### + +sub errorStrSearch { + local ($fileName) = @_; + local ($returnVal) = 0; + + # Open the captured file + open( CAPT_FILE, ") { + if ( m/FAIL/i + || m/FAULT/i + || m/ERROR/i + || m/Not Found/i + || m/SIGNAL/i + || m/NO SUCH FILE/i + || m/\|E\|/i + || m/\|A\|/i ) + { + print; + if ( $fileName =~ m/out/ ) { + print( + " Failed - File $fileName contains error strings.\n" + ); + $returnVal = 64; + } + elsif ( $fileName =~ m/err/ ) { + print( + " Failed - File $fileName contains error strings.\n" + ); + $returnVal = 128; + } + last; + } + } + + # Close the capture file + close(CAPT_FILE); + + # Return the return value + return ($returnVal); +} + +################################################################################ +# +# SUBROUTINE: compareStream +# +# Description: This subroutine will compare the captured stream file with +# a file in the verified directory if one exists. +# +# Parameter(s): streamFile - input file to compare +# +# Return: 0 - Compare successful +# 2 - STDOUT verified file doesn't exist +# 4 - STDERR verified file doesn't exist +# 8 - STDOUT verified file doesn't compare +# 16 - STDERR verified file doesn't compare +# +############################################################################### + +sub compareStream { + local ($streamFile) = @_; + local ($returnVal) = 0; + local ($tempFile) = ""; + + # Check for existence of verified STD stream files + if ( !( -e $streamFile ) ) { + + # Display message to user that verified STDOUT file doesn't exist + print(" File $streamFile doesn't exist.\n") if ($verbose); + + # Set exit value bit 1 to indicate proper failure + if ( $streamFile =~ /out$/ ) { + $returnVal |= 2; + } + elsif ( $streamFile =~ /err$/ ) { + $returnVal |= 4; + } + } + else { + + # Verified STD stream file exists + + # Create name of the temp file to compare + $tempFile = $streamFile; + $tempFile =~ s/verified/temp/; + $tempFile = $tempFile . ".mod"; + + # Perform difference on the STD stream files + $diffstdout = `diff $streamFile $tempFile`; + + # Check the return value of the difference + if ( $? != 0 ) { + + # Difference of STD stream files failed + + # Check for STDOUT in file name to convey appropirate return value + if ( $streamFile =~ /out$/ ) { + + # Display message of the failure of difference to user + print(" Failed - STDOUT difference\n$diffstdout\n"); + + # Exit value to indicate STDOUT did not compare + $returnVal |= 8; + } + elsif ( $streamFile =~ /err$/ ) { + + # Display message of the failure of difference to user + print(" Failed - STDERR difference\n$diffstdout\n"); + + # Exit value to indicate STDERR did not compare + $returnVal |= 16; + } + } + } + + # Return the result of the compare + return ($returnVal); +} + +################################################################################ +# +# SUBROUTINE: checkForTempDirectory +# +# Description: This subroutine will check for the existence of a temp +# directory to store STDOUT, STDERR files during test. If +# the subdirectory doesn't exist, it will be created. +# +# Parameter(s): None +# +# Return: None +# +################################################################################ + +sub checkForTempDirectory { + + # Check if a temp directory already exists in the current work directory + if ( !( -e "temp" ) ) { + + # Create temp directory to store STDOUT, STDERR files during test + `mkdir temp`; + + # Display message of new directory created + print("Creating temp directory\n") if ($verbose); + } +} + +################################################################################ +# +# SUBROUTINE: checkForVerifiedDirectory +# +# Description: This subroutine will check for the existence of a verified +# directory which stores verified STDOUT, STDERR files for +# comparison during the test. +# +# Parameter(s): None +# +# Return: 0 - subdirectory present +# 1 - subdirectory not present +# +################################################################################ + +sub checkForVerifiedDirectory { + $returnValue = 0; + + # Check if verified subdirectory exists in the current working directory + if ( !( -e "verified" ) ) { + + # Set return value to 1 + $returnValue = 1; + } + return ($returnValue); +} + +################################################################################ +# +# SUBROUTINE: filterStdFiles +# +# Description: This subroutine will filter variable items in the STDOUT +# and STDERR files captured. Date, time and host names +# are variable items in the log messages captured. +# +# Parameter(s): test file name +# +# Return: None +# +################################################################################ + +sub filterStdFiles { + + local ($fileName) = @_; + + # Open the STDOUT file for reading + open( OUTFILE, "< temp/$fileName.stdout" ); + + # Open mod file to place filtered STDOUT + open( MODFILE, "> temp/$fileName.stdout.mod" ); + + # Replace the variable data, time and host information with constants + $hostname = `hostname`; + chop $hostname; + while () { + s/\s+\d+:\d+:\d+\w/