Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/.cvsignore =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/.cvsignore (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/.cvsignore (revision 21664) @@ -0,0 +1,27 @@ +autom4te.cache +Makefile +config.log +config.status +libtool +Makefile.in +aclocal.m4 +configure +Doxyfile +DoxygenLog +docs +man +psmodule-config +psmodule.pc +bin +include +lib +config.guess +config.sub +depcomp +install-sh +ltmain.sh +missing +psmodule.kdevelop.pcs +psmodule-*.tar.gz +psmodule-*.tar.bz2 +compile Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/AUTHORS =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/AUTHORS (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/AUTHORS (revision 21664) @@ -0,0 +1,1 @@ +Maui High Performance Computing Center, University of Hawai'i Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/COPYING =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/COPYING (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/COPYING (revision 21664) @@ -0,0 +1,6 @@ +(C) 2004 University of Hawai'i + +Permission to copy/distribute to be governed by: + Institute for Astronomy + 2680 Woodlawn Drive + Honolulu, HI 96822-1897 Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/ChangeLog =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/ChangeLog (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/ChangeLog (revision 21664) @@ -0,0 +1,1 @@ + Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/Doxyfile.in =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/Doxyfile.in (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/Doxyfile.in (revision 21664) @@ -0,0 +1,1079 @@ +# 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 Module 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 = @VERSION@ + +# 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 = @prefix@/docs/psmodule + +# 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 = src + +# 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 = @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: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/INSTALL =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/INSTALL (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/INSTALL (revision 21664) @@ -0,0 +1,167 @@ +Basic Installation +================== + + These are generic installation instructions. + + The `configure' shell script attempts to guess correct values for +various system-dependent variables used during compilation. It uses +those values to create a `Makefile' in each directory of the package. +It may also create one or more `.h' files containing system-dependent +definitions. Finally, it creates a shell script `config.status' that +you can run in the future to recreate the current configuration, a file +`config.cache' that saves the results of its tests to speed up +reconfiguring, and a file `config.log' containing compiler output +(useful mainly for debugging `configure'). + + If you need to do unusual things to compile the package, please try +to figure out how `configure' could check whether to do them, and mail +diffs or instructions to the address given in the `README' so they can +be considered for the next release. If at some point `config.cache' +contains results you don't want to keep, you may remove or edit it. + + The file `configure.in' is used to create `configure' by a program +called `autoconf'. You only need `configure.in' if you want to change +it or regenerate `configure' using a newer version of `autoconf'. + +The simplest way to compile this package is: + + 1. `cd' to the directory containing the package's source code and type + `./configure' to configure the package for your system. If you're + using `csh' on an old version of System V, you might need to type + `sh ./configure' instead to prevent `csh' from trying to execute + `configure' itself. + + Running `configure' takes a while. While running, it prints some + messages telling which features it is checking for. + + 2. Type `make' to compile the package. + + 3. Type `make install' to install the programs and any data files and + documentation. + + 4. You can remove the program binaries and object files from the + source code directory by typing `make clean'. + +Compilers and Options +===================== + + Some systems require unusual options for compilation or linking that +the `configure' script does not know about. You can give `configure' +initial values for variables by setting them in the environment. Using +a Bourne-compatible shell, you can do that on the command line like +this: + CC=c89 CFLAGS=-O2 LIBS=-lposix ./configure + +Or on systems that have the `env' program, you can do it like this: + env CPPFLAGS=-I/usr/local/include LDFLAGS=-s ./configure + +Compiling For Multiple Architectures +==================================== + + You can compile the package for more than one kind of computer at the +same time, by placing the object files for each architecture in their +own directory. To do this, you must use a version of `make' that +supports the `VPATH' variable, such as GNU `make'. `cd' to the +directory where you want the object files and executables to go and run +the `configure' script. `configure' automatically checks for the +source code in the directory that `configure' is in and in `..'. + + If you have to use a `make' that does not supports the `VPATH' +variable, you have to compile the package for one architecture at a time +in the source code directory. After you have installed the package for +one architecture, use `make distclean' before reconfiguring for another +architecture. + +Installation Names +================== + + By default, `make install' will install the package's files in +`/usr/local/bin', `/usr/local/man', etc. You can specify an +installation prefix other than `/usr/local' by giving `configure' the +option `--prefix=PATH'. + + You can specify separate installation prefixes for +architecture-specific files and architecture-independent files. If you +give `configure' the option `--exec-prefix=PATH', the package will use +PATH as the prefix for installing programs and libraries. +Documentation and other data files will still use the regular prefix. + + If the package supports it, you can cause programs to be installed +with an extra prefix or suffix on their names by giving `configure' the +option `--program-prefix=PREFIX' or `--program-suffix=SUFFIX'. + +Optional Features +================= + + Some packages pay attention to `--enable-FEATURE' options to +`configure', where FEATURE indicates an optional part of the package. +They may also pay attention to `--with-PACKAGE' options, where PACKAGE +is something like `gnu-as' or `x' (for the X Window System). The +`README' should mention any `--enable-' and `--with-' options that the +package recognizes. + + For packages that use the X Window System, `configure' can usually +find the X include and library files automatically, but if it doesn't, +you can use the `configure' options `--x-includes=DIR' and +`--x-libraries=DIR' to specify their locations. + +Specifying the System Type +========================== + + There may be some features `configure' can not figure out +automatically, but needs to determine by the type of host the package +will run on. Usually `configure' can figure that out, but if it prints +a message saying it can not guess the host type, give it the +`--host=TYPE' option. TYPE can either be a short name for the system +type, such as `sun4', or a canonical name with three fields: + CPU-COMPANY-SYSTEM + +See the file `config.sub' for the possible values of each field. If +`config.sub' isn't included in this package, then this package doesn't +need to know the host type. + + If you are building compiler tools for cross-compiling, you can also +use the `--target=TYPE' option to select the type of system they will +produce code for and the `--build=TYPE' option to select the type of +system on which you are compiling the package. + +Sharing Defaults +================ + + If you want to set default values for `configure' scripts to share, +you can create a site shell script called `config.site' that gives +default values for variables like `CC', `cache_file', and `prefix'. +`configure' looks for `PREFIX/share/config.site' if it exists, then +`PREFIX/etc/config.site' if it exists. Or, you can set the +`CONFIG_SITE' environment variable to the location of the site script. +A warning: not all `configure' scripts look for a site script. + +Operation Controls +================== + + `configure' recognizes the following options to control how it +operates. + +`--cache-file=FILE' + Use and save the results of the tests in FILE instead of + `./config.cache'. Set FILE to `/dev/null' to disable caching, for + debugging `configure'. + +`--help' + Print a summary of the options to `configure', and exit. + +`--quiet' +`--silent' +`-q' + Do not print messages saying which checks are being made. + +`--srcdir=DIR' + Look for the package's source code in directory DIR. Usually + `configure' can determine that directory automatically. + +`--version' + Print the version of Autoconf used to generate the `configure' + script, and exit. + +`configure' also accepts some other, not widely useful, options. + Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/Makefile.am =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/Makefile.am (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/Makefile.am (revision 21664) @@ -0,0 +1,34 @@ +SUBDIRS = src test + +bin_SCRIPTS = psmodule-config + +pkgconfigdir = $(libdir)/pkgconfig +pkgconfig_DATA= psmodule.pc + +EXTRA_DIST = \ + Doxyfile.in \ + psmodule-config.in \ + psmodule.pc.in \ + autogen.sh + +if DOXYGEN + +docs: Doxyfile $(prefix)/docs/psmodule $(mandir)/man3 + doxygen Doxyfile + mv -f $(prefix)/docs/psmodule/man/man3/* $(mandir)/man3 + rm -rf $(prefix)/docs/psmodule/man + +$(prefix)/docs/psmodule: + mkdir -p $(prefix)/docs/psmodule + +$(mandir)/man3: + mkdir -p $(mandir)/man3 + +uninstall-hook: + rm -rf $(prefix)/docs/psmodule/* + +CLEANFILES = $(prefix)/docs/psmodule/* + +endif + +test: check Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/NEWS =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/NEWS (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/NEWS (revision 21664) @@ -0,0 +1,1 @@ + Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/README =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/README (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/README (revision 21664) @@ -0,0 +1,1 @@ + Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/TODO =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/TODO (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/TODO (revision 21664) @@ -0,0 +1,1 @@ + Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/autogen.sh =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/autogen.sh (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/autogen.sh (revision 21664) @@ -0,0 +1,106 @@ +#!/bin/sh +# Run this to generate all the initial makefiles, etc. + +srcdir=`dirname $0` +test -z "$srcdir" && srcdir=. + +ORIGDIR=`pwd` +cd $srcdir + +PROJECT=psmodule +TEST_TYPE=-f +FILE=psmodule.pc.in + +DIE=0 + +if [ "`which glibtoolize 2> /dev/null`" != "" ] + then LIBTOOLIZE=glibtoolize + else LIBTOOLIZE=libtoolize +fi + +ACLOCAL=aclocal +AUTOHEADER=autoheader +AUTOMAKE=automake +AUTOCONF=autoconf + +($LIBTOOLIZE --version) < /dev/null > /dev/null 2>&1 || { + echo + echo "You must have $LIBTOOlIZE installed to compile $PROJECT." + echo "Download the appropriate package for your distribution," + echo "or get the source tarball at http://ftp.gnu.org/gnu/libtool/" + DIE=1 +} + +($ACLOCAL --version) < /dev/null > /dev/null 2>&1 || { + echo + echo "You must have $ACLOCAL installed to compile $PROJECT." + echo "Download the appropriate package for your distribution," + echo "or get the source tarball at http://ftp.gnu.org/gnu/automake/" + DIE=1 +} + +($AUTOHEADER --version) < /dev/null > /dev/null 2>&1 || { + echo + echo "You must have $AUTOHEADER installed to compile $PROJECT." + echo "Download the appropriate package for your distribution," + echo "or get the source tarball at http://ftp.gnu.org/gnu/autoconf/" + DIE=1 +} + +($AUTOMAKE --version) < /dev/null > /dev/null 2>&1 || { + echo + echo "You must have $AUTOMAKE installed to compile $PROJECT." + echo "Download the appropriate package for your distribution," + echo "or get the source tarball at http://ftp.gnu.org/gnu/automake/" + DIE=1 +} + +($AUTOCONF --version) < /dev/null > /dev/null 2>&1 || { + echo + echo "You must have $AUTOCONF installed to compile $PROJECT." + echo "Download the appropriate package for your distribution," + echo "or get the source tarball at http://ftp.gnu.org/gnu/autoconf/" + DIE=1 +} + +if test "$DIE" -eq 1; then + exit 1 +fi + +test $TEST_TYPE $FILE || { + echo "You must run this script in the top-level $PROJECT directory" + exit 1 +} + +if test -z "$*"; then + echo "I am going to run ./configure with no arguments - if you wish " + echo "to pass any to it, please specify them on the $0 command line." +fi + +$LIBTOOLIZE --copy --force || echo "$LIBTOOlIZE failed" +$ACLOCAL || echo "$ACLOCAL failed" +$AUTOHEADER || echo "$AUTOHEADER failed" +$AUTOMAKE --add-missing --force-missing --copy || echo "$AUTOMAKE failed" +$AUTOCONF || echo "$AUTOCONF failed" + +cd $ORIGDIR + +run_configure=true +for arg in $*; do + case $arg in + --no-configure) + run_configure=false + ;; + *) + ;; + esac +done + +if $run_configure; then + $srcdir/configure --enable-maintainer-mode "$@" + echo + echo "Now type 'make' to compile $PROJECT." +else + echo + echo "Now run 'configure' and 'make' to compile $PROJECT." +fi Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/configure.ac =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/configure.ac (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/configure.ac (revision 21664) @@ -0,0 +1,120 @@ +AC_PREREQ(2.59) + +AC_INIT([psmodule],[0.9.99],[http://pan-starrs.ifa.hawaii.edu/bugzilla]) +AC_CONFIG_SRCDIR([psmodule.pc.in]) + +AM_INIT_AUTOMAKE([1.7 foreign dist-bzip2]) +AM_CONFIG_HEADER([src/config.h]) +AM_MAINTAINER_MODE + +dnl otherise AC_PROG_CC will default CFLAGS to "-g -02" +if test -z ${CFLAGS} ; then + CFLAGS="" +fi +AC_SUBST([CFLAGS]) + +AC_LANG(C) +AC_PROG_CC +dnl FIXME document why GNU_SOURCE is being set +AC_GNU_SOURCE +AC_PROG_INSTALL +AM_PROG_LIBTOOL + +AC_PREFIX_DEFAULT([`pwd`]) + +dnl cflags -------------------------------------------------------------------- +dnl FIXME document why -std=gnu99 is being set + +AC_MSG_CHECKING([C99 flag]) +if test "$GCC" = "yes" ; then + AM_CFLAGS="-std=gnu99" + AC_MSG_RESULT([-std=gnu99]) +else + AM_CFLAGS="-std=c99" + AC_MSG_RESULT([-std=c99]) +fi +AM_CFLAGS="${AM_CFLAGS=} -Wall -Werror" +AC_SUBST([AM_CFLAGS]) + +dnl ------------------- PERL options --------------------- + AC_ARG_WITH(perl, + [AS_HELP_STRING(--with-perl=FILE,Specify location of PERL executable.)], + [AC_CHECK_PROG(PERL, $withval, $withval)], + [AC_CHECK_PROG(PERL, perl, `which perl`)]) + if test "$PERL" == "" + then + AC_MSG_ERROR([PERL is required. Use --with-perl to specify its install location.]) + fi + AC_SUBST(PERL,$PERL) + +SRCPATH='${top_srcdir}/src' +SRCDIRS="astrom config detrend imcombine imsubtract objects" +# escape two escapes at this level so \\ gets passed to the shell and \ to perl +SRCINC=`echo "${SRCDIRS=}" | ${PERL} -pe "s|(\w+)|-I\\\\${SRCPATH=}/\1|g"` +SRCINC="-I${SRCPATH=} ${SRCINC=}" +SRCSUBLIBS=`echo "${SRCDIRS=}" | ${PERL} -pe "s|(\w+)|\1/libpsmodule\1.la|g"` +AC_SUBST(SRCSUBLIBS,${SRCSUBLIBS=}) +AC_SUBST(SRCINC,${SRCINC=}) +AC_SUBST([SRCDIRS],${SRCDIRS=}) + +dnl handle debug building +AC_ARG_ENABLE(optimize, + [AS_HELP_STRING(--enable-optimize,enable compiler optimization)], + [AC_MSG_RESULT(compile optimization enabled) + CFLAGS="${CFLAGS=} -O2"], + [AC_MSG_RESULT([compile optimization disabled]) + CFLAGS="${CFLAGS=} -O0 -g"] +) + +dnl doxygen ------------------------------------------------------------------- + +AC_CHECK_PROG([doxygen], [doxygen], [true], [false]) +AM_CONDITIONAL(DOXYGEN, test x$doxygen = xtrue) + +dnl pslib --------------------------------------------------------------------- +AC_ARG_WITH(pslib-config, +[ --with-pslib-config=FILE Specify location of psLib-config script], +[PSLIB_CONFIG=$withval]) + +if test -z ${PSLIB_CONFIG} ; then + PKG_CHECK_MODULES([PSLIB], [pslib >= 0.9.0]) +else + AC_CHECK_FILE($PSLIB_CONFIG,[], + [AC_MSG_ERROR([psLib is required. If not in path, use --with-pslib-config to specify pslib-config script location.])]) + AC_MSG_CHECKING([PSLIB_CFLAGS]) + PSLIB_CFLAGS="`${PSLIB_CONFIG} --cflags`" + AC_MSG_RESULT([${PSLIB_CFLAGS}]) + AC_MSG_CHECKING([PSLIB_LIBS]) + PSLIB_LIBS="`${PSLIB_CONFIG} --libs`" + AC_MSG_RESULT([${PSLIB_LIBS}]) +fi + +PSMODULE_CFLAGS="${PSMODULE_CFLAGS=} ${PSLIB_CFLAGS}" +PSMODULE_LIBS="${PSMODULE_CFLAGS=} ${PSLIB_LIBS}" +dnl --------------------------------------------------------------------------- + +AC_SUBST([PSMODULE_CFLAGS]) +AC_SUBST([PSMODULE_LIBS]) + +AC_CONFIG_FILES([ + Makefile + src/Makefile + src/astrom/Makefile + src/config/Makefile + src/detrend/Makefile + src/imcombine/Makefile + src/imsubtract/Makefile + src/objects/Makefile + test/Makefile + test/astrom/Makefile + test/config/Makefile + test/detrend/Makefile + test/imcombine/Makefile + test/imsubtract/Makefile + test/objects/Makefile + Doxyfile + psmodule-config + psmodule.pc +]) + +AC_OUTPUT Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/psmodule-config.in =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/psmodule-config.in (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/psmodule-config.in (revision 21664) @@ -0,0 +1,76 @@ +#! /bin/sh + +prefix=@prefix@ +exec_prefix=@exec_prefix@ +libdir=@libdir@ +includedir=@includedir@ + +usage() +{ + cat < + + + Robert Daniel DeSonia + desonia@mhpcc.hawaii.edu + 0.1 + KDevAutoProject + C + + C + Code + + . + false + + + + + + + src/psmodule + debug + + + src/tst_pmFlatField + true + executable + / + + true + + + + + optimized + kdevgccoptions + kdevgppoptions + kdevg77options + -O2 -g0 + + + --enable-debug=full + debug + kdevgccoptions + kdevgppoptions + kdevg77options + -O0 -g3 + + + + + + + + false + 1 + false + + + + + + ada + ada_bugs_gcc + bash + bash_bugs + clanlib + w3c-dom-level2-html + fortran_bugs_gcc + gnome1 + gnustep + gtk + gtk_bugs + haskell + haskell_bugs_ghc + java_bugs_gcc + java_bugs_sun + kde2book + libstdc++ + opengl + pascal_bugs_fp + php + php_bugs + perl + perl_bugs + python + python_bugs + qt-kdev3 + ruby + ruby_bugs + sdl + stl + w3c-svg + sw + w3c-uaag10 + wxwidgets_bugs + + + Guide to the Qt Translation Tools + Qt Assistant Manual + Qt Designer Manual + Qt Reference Documentation + qmake User Guide + + + KDE Libraries (Doxygen) + + + html/ + html/ + + + + + + + + + + + + + + + + false + false + + + *.o,*.lo,CVS + false + false + + + + + + true + true + true + false + true + true + true + 250 + 400 + 250 + + + + + .h + .cpp + + + + + + + + + + + true + false + false + + + false + true + + + + true + true + true + true + -C + + Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/psmodule.kdevses =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/psmodule.kdevses (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/psmodule.kdevses (revision 21664) @@ -0,0 +1,56 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/psmodule.pc.in =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/psmodule.pc.in (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/psmodule.pc.in (revision 21664) @@ -0,0 +1,10 @@ +prefix=@prefix@ +exec_prefix=@exec_prefix@ +libdir=@libdir@ +includedir=@includedir@ + +Name: psmodule +Description: Pan-STARRS Module Library +Version: @VERSION@ +Libs: -L${libdir} -lpsmodule @PSMODULE_LIBS@ +Cflags: -I${includedir} @PSMODULE_CFLAGS@ Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/.cvsignore =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/.cvsignore (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/.cvsignore (revision 21664) @@ -0,0 +1,9 @@ +.deps +.libs +Makefile +config.h +stamp-h1 +Makefile.in +config.h.in +*.la +*.lo Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/Makefile.am =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/Makefile.am (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/Makefile.am (revision 21664) @@ -0,0 +1,9 @@ +SUBDIRS = $(SRCDIRS) +lib_LTLIBRARIES = libpsmodule.la + +libpsmodule_la_SOURCES = dummy.c +libpsmodule_la_CPPFLAGS = $(SRCINC) +libpsmodule_la_LIBADD = $(SRCSUBLIBS) +libpsmodule_la_DEPENDENCIES = $(SRCSUBLIBS) + +EXTRA_DIST = psErrorCodes.dat Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/astrom/.cvsignore =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/astrom/.cvsignore (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/astrom/.cvsignore (revision 21664) @@ -0,0 +1,6 @@ +.deps +.libs +Makefile +Makefile.in +*.la +*.lo Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/astrom/Makefile.am =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/astrom/Makefile.am (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/astrom/Makefile.am (revision 21664) @@ -0,0 +1,34 @@ +noinst_LTLIBRARIES = libpsmoduleastrom.la + +libpsmoduleastrom_la_CPPFLAGS = $(SRCINC) $(PSMODULE_CFLAGS) +libpsmoduleastrom_la_LDFLAGS = -release $(PACKAGE_VERSION) +libpsmoduleastrom_la_SOURCES = \ + pmFPA.c \ + pmFPAAstrometry.c \ + pmAstrometryObjects.c \ + pmFPAConstruct.c \ + pmFPARead.c \ + pmFPAWrite.c \ + pmReadout.c \ + psAdditionals.c \ + pmConcepts.c \ + pmConceptsRead.c \ + pmConceptsWrite.c \ + pmConceptsStandard.c \ + pmChipMosaic.c + +psmoduleincludedir = $(includedir) +psmoduleinclude_HEADERS = \ + pmFPA.h \ + pmFPAAstrometry.h \ + pmAstrometryObjects.h \ + pmFPAConstruct.h \ + pmFPARead.h \ + pmFPAWrite.h \ + pmReadout.h \ + psAdditionals.h \ + pmConcepts.h \ + pmConceptsRead.h \ + pmConceptsWrite.h \ + pmConceptsStandard.h \ + pmChipMosaic.h Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/astrom/pmAstrometry.c =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/astrom/pmAstrometry.c (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/astrom/pmAstrometry.c (revision 21664) @@ -0,0 +1,534 @@ +/** @file psAstrometry.c +* +* @brief This file defines the basic types for astronomical coordinate +* transformation +* +* @ingroup AstroImage +* +* @author GLG, MHPCC +* +* XXX: We should review the extent of the warning messages on these functions +* when the transformations are not successful. +* +* XXX: Should we implement non-linear cell->chip transforms? +* +* @version $Revision: 1.11.2.1.2.2 $ $Name: not supported by cvs2svn $ +* @date $Date: 2006-01-20 02:36:41 $ +* +* Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii +*/ + +/******************************************************************************/ +/* INCLUDE FILES */ +/******************************************************************************/ +#include +#include +#include "pslib.h" + +#include "pmAstrometry.h" +#include "pmConcepts.h" + +/***************************************************************************** +checkValidImageCoords(): this is a private function which simply determines if +the supplied x,y coordinates are in the range for the supplied psImage. + +XXX: What about col0 and row0 +XXX: This should return a psBool. +XXX: Macro this for speed. + *****************************************************************************/ +static psS32 checkValidImageCoords( + double x, + double y, + psImage* tmpImage) +{ + PS_ASSERT_IMAGE_NON_NULL(tmpImage, 0); + + // The FLT_EPSILON is because -0.0 was failing this. + if (((x+FLT_EPSILON) < 0.0) || (x > (double)tmpImage->numCols) || + ((y+FLT_EPSILON) < 0.0) || (y > (double)tmpImage->numRows)) { + return (0); + } + + return (1); +} + +/****************************************************************************** + *****************************************************************************/ +#define PS_FREE_HIERARCHY 1 +static void readoutFree(pmReadout *readout) +{ + if (readout != NULL) { + psFree(readout->image); + psFree(readout->mask); + psFree(readout->weight); + psFree(readout->analysis); + #if 0 + + psFree(readout->parent); + #endif + + readout->parent = NULL; + } +} + +static void cellFree(pmCell *cell) +{ + if (cell != NULL) { + psFree(cell->toChip); + psFree(cell->toFPA); + psFree(cell->toSky); + psFree(cell->concepts); + psFree(cell->analysis); + psFree(cell->camera); + // + // Set the parent to NULL in all cell->readouts before psFree(cell->readouts) + // in order to avoid memory reference counter problems. + // + #if 0 + + for (psS32 i = 0 ; i < cell->readouts->n ; i++) { + pmReadout *tmpReadout = (pmReadout *) cell->readouts->data[i]; + tmpReadout->parent = NULL; + if (PS_FREE_HIERARCHY == 1) { + psFree(tmpReadout); + } + } + psFree(cell->parent); + #endif + + cell->parent = NULL; + + psFree(cell->readouts); + psFree(cell->hdu); + + } +} + +static void chipFree(pmChip* chip) +{ + if (chip != NULL) { + psFree(chip->toFPA); + psFree(chip->fromFPA); + psFree(chip->concepts); + psFree(chip->analysis); + // + // Set the parent to NULL in all chip->cells before psFree(chip->cells) + // in order to avoid memory reference counter problems. + // + #if 0 + + for (psS32 i = 0 ; i < chip->cells->n ; i++) { + pmCell *tmpCell = (pmCell *) chip->cells->data[i]; + tmpCell->parent = NULL; + if (PS_FREE_HIERARCHY == 1) { + psFree(tmpCell); + } + } + psFree(chip->parent); + #endif + + chip->parent = NULL; + psFree(chip->cells); + psFree(chip->hdu); + } +} + + +static void FPAFree(pmFPA *fpa) +{ + if (fpa != NULL) { + psFree(fpa->fromTangentPlane); + psFree(fpa->toTangentPlane); + psFree(fpa->projection); + psFree(fpa->concepts); + psFree(fpa->analysis); + psFree(fpa->camera); + // + // Set the parent to NULL in all fpa->chips before psFree(fpa->chips) + // in order to avoid memory reference counter problems. + // + #if 0 + + for (psS32 i = 0 ; i < fpa->chips->n ; i++) { + pmChip *tmpChip = (pmChip *) fpa->chips->data[i]; + tmpChip->parent = NULL; + if (PS_FREE_HIERARCHY == 1) { + psFree(tmpChip); + } + } + #endif + psFree(fpa->chips); + psFree(fpa->hdu); + psFree(fpa->phu); + } +} + +void p_pmHDUFree(p_pmHDU *hdu) +{ + if (hdu) { + psFree(hdu->extname); + psFree(hdu->header); + psFree(hdu->images); + psFree(hdu->masks); + psFree(hdu->weights); + } +} + +// XXX: Verify these default values for row0, col0, rowBins, colBins +// PAP: These values may disappear in the future in favour of values in parent->concepts? +pmReadout *pmReadoutAlloc(pmCell *cell) +{ + pmReadout *tmpReadout = (pmReadout *) psAlloc(sizeof(pmReadout)); + + tmpReadout->col0 = 0; + tmpReadout->row0 = 0; + tmpReadout->colBins = 0; + tmpReadout->rowBins = 0; + tmpReadout->image = NULL; + tmpReadout->mask = NULL; + tmpReadout->weight = NULL; + tmpReadout->analysis = psMetadataAlloc(); + tmpReadout->parent = cell; + if (cell != NULL) { + cell->readouts = psArrayAdd(cell->readouts, 1, (psPtr) tmpReadout); + } + psMemSetDeallocator(tmpReadout, (psFreeFunc) readoutFree); + return(tmpReadout); +} + +// XXX: Verify these default values for row0, col0. +// PAP: These values may disappear in the future in favour of values in the "concepts"? +pmCell *pmCellAlloc( + pmChip *chip, + psMetadata *cameraData, + const char *name) +{ + pmCell *tmpCell = (pmCell *) psAlloc(sizeof(pmCell)); + + tmpCell->col0 = 0; + tmpCell->row0 = 0; + tmpCell->toChip = NULL; + tmpCell->toFPA = NULL; + tmpCell->toSky = NULL; + tmpCell->concepts = psMetadataAlloc(); + psBool rc = psMetadataAddStr(tmpCell->concepts, PS_LIST_HEAD, "CELL.NAME", 0, NULL, name); + if (rc == false) { + psLogMsg(__func__, PS_LOG_WARN, "WARNING: Could not add CELL.NAME to metadata.\n"); + } + tmpCell->camera = psMemIncrRefCounter(cameraData); + tmpCell->analysis = psMetadataAlloc(); + tmpCell->readouts = psArrayAlloc(0); + tmpCell->parent = chip; + if (chip != NULL) { + chip->cells = psArrayAdd(chip->cells, 1, (psPtr) tmpCell); + } + tmpCell->process = true; // All cells are processed by default + tmpCell->exists = false; // Not yet read in + tmpCell->hdu = NULL; + + pmConceptsBlankCell(tmpCell); + + psMemSetDeallocator(tmpCell, (psFreeFunc) cellFree); + return(tmpCell); +} + +// XXX: Verify these default values for row0, col0. +// PAP: row0, col0 may disappear in the future in favour of storing values in the "concepts". +pmChip *pmChipAlloc( + pmFPA *fpa, + const char *name) +{ + pmChip *tmpChip = (pmChip *) psAlloc(sizeof(pmChip)); + + tmpChip->col0 = 0; + tmpChip->row0 = 0; + tmpChip->toFPA = NULL; + tmpChip->fromFPA = NULL; + tmpChip->concepts = psMetadataAlloc(); + psBool rc = psMetadataAddStr(tmpChip->concepts, PS_LIST_HEAD, "CHIP.NAME", 0, NULL, name); + if (rc == false) { + psLogMsg(__func__, PS_LOG_WARN, "WARNING: Could not add CHIP.NAME to metadata.\n"); + } + tmpChip->analysis = psMetadataAlloc(); + tmpChip->cells = psArrayAlloc(0); + tmpChip->parent = fpa; + if (fpa != NULL) { + fpa->chips = psArrayAdd(fpa->chips, 1, (psPtr) tmpChip); + } + tmpChip->process = true; // Work on all chips, by default + tmpChip->exists = false; // Not read in yet + tmpChip->hdu = NULL; + + pmConceptsBlankChip(tmpChip); + + psMemSetDeallocator(tmpChip, (psFreeFunc) chipFree); + return(tmpChip); +} + +pmFPA *pmFPAAlloc(const psMetadata *camera) +{ + pmFPA *tmpFPA = (pmFPA *) psAlloc(sizeof(pmFPA)); + + tmpFPA->fromTangentPlane = NULL; + tmpFPA->toTangentPlane = NULL; + tmpFPA->projection = NULL; + tmpFPA->concepts = psMetadataAlloc(); + tmpFPA->analysis = NULL; + tmpFPA->camera = psMemIncrRefCounter((psPtr)camera); + tmpFPA->chips = psArrayAlloc(0); + tmpFPA->hdu = NULL; + tmpFPA->phu = NULL; + + pmConceptsBlankFPA(tmpFPA); + + psMemSetDeallocator(tmpFPA, (psFreeFunc) FPAFree); + return(tmpFPA); +} + +p_pmHDU *p_pmHDUAlloc(const char *extname) +{ + p_pmHDU *hdu = psAlloc(sizeof(p_pmHDU)); + psMemSetDeallocator(hdu, (psFreeFunc)p_pmHDUFree); + + hdu->extname = psStringCopy(extname); + hdu->header = NULL; + hdu->images = NULL; + hdu->masks = NULL; + hdu->weights = NULL; + + return hdu; +} + +static psBool cellCheckParents(pmCell *cell) +{ + if (cell == NULL) { + return(true); + } + psBool flag = true; + + for (psS32 i = 0 ; i < cell->readouts->n ; i++) { + pmReadout *tmpReadout = (pmReadout *) cell->readouts->data[i]; + PS_ASSERT_PTR_NON_NULL(tmpReadout, false); + if (tmpReadout->parent != cell) { + tmpReadout->parent = cell; + flag = false; + } + } + return(flag); +} + +static psBool chipCheckParents(pmChip *chip) +{ + if (chip == NULL) { + return(true); + } + psBool flag = true; + + for (psS32 i = 0 ; i < chip->cells->n ; i++) { + pmCell *tmpCell = (pmCell *) chip->cells->data[i]; + PS_ASSERT_PTR_NON_NULL(tmpCell, false); + if (tmpCell->parent != chip) { + tmpCell->parent = chip; + flag = false; + } + + flag &= cellCheckParents(tmpCell); + } + return(flag); +} + +psBool pmFPACheckParents(pmFPA *fpa) +{ + if (fpa == NULL) { + return(true); + } + psBool flag = true; + + for (psS32 i = 0 ; i < fpa->chips->n ; i++) { + pmChip *tmpChip = (pmChip *) fpa->chips->data[i]; + PS_ASSERT_PTR_NON_NULL(tmpChip, false); + if (tmpChip->parent != fpa) { + tmpChip->parent = fpa; + flag = false; + } + + flag &= chipCheckParents(tmpChip); + } + return(flag); +} + + + +/***************************************************************************** + *****************************************************************************/ + +// Set cells within a chip to be processed or not +static bool setCellsProcess(const pmChip *chip, // Chip of interest + bool process // Process this chip? + ) +{ + PS_ASSERT_PTR_NON_NULL(chip, false); + + psArray *cells = chip->cells; // Component cells + if (! cells) { + return false; + } + for (int i = 0; i < cells->n; i++) { + pmCell *tmpCell = cells->data[i]; // Cell of interest + if (tmpCell) { + tmpCell->process = process; + } + } + + return true; +} + +/***************************************************************************** + *****************************************************************************/ +bool pmFPASelectChip( + pmFPA *fpa, + int chipNum) +{ + PS_ASSERT_PTR_NON_NULL(fpa, false); + + psArray *chips = fpa->chips; // Component chips + if ((chips == NULL) || (chipNum >= chips->n)) { + return(false); + } + + for (int i = 0 ; i < chips->n ; i++) { + pmChip *tmpChip = (pmChip *) chips->data[i]; + if (tmpChip == NULL) { + continue; + } + if (i == chipNum) { + tmpChip->process = true; + setCellsProcess(tmpChip, true); + } else { + tmpChip->process = false; + setCellsProcess(tmpChip, false); + } + + } + + return true; +} + + +/***************************************************************************** +XXX: The SDRS is ambiguous on a few things: + Whether or not the other chips should be set process=true. [PAP: No] + Should we return the number of chip process=true before or after they're set, [PAP: After] + *****************************************************************************/ +/** + * + * pmFPAExcludeChip shall set process to false only for the specified chip + * number (chipNum). In the event that the specified chip number does not exist + * within the fpa, the function shall generate a warning, and perform no action. + * The function shall return the number of chips within the fpa that have process + * set to true. + * + */ +int pmFPAExcludeChip( + pmFPA *fpa, + int chipNum) +{ + PS_ASSERT_PTR_NON_NULL(fpa, false); + + psArray *chips = fpa->chips; // Component chips + if (chips == NULL) { + psLogMsg(__func__, PS_LOG_WARN, "WARNING: fpa->chips == NULL\n"); + return(0); + } + if ((chipNum >= chips->n) || (NULL == (pmChip *) chips->data[chipNum])) { + psLogMsg(__func__, PS_LOG_WARN, "WARNING: the specified chip (%d) does not exist.\n", chipNum); + return(0); + } + + int numChips = 0; // Number of chips to be processed + for (int i = 0 ; i < chips->n ; i++) { + pmChip *tmpChip = (pmChip *) chips->data[i]; // Chip of interest + if (tmpChip != NULL) { + if (i == chipNum) { + tmpChip->process = false; + setCellsProcess(tmpChip, false); // Wipe out the cell as well + } else if (tmpChip->process) { + numChips++; + } + } + } + + return(numChips); +} + + +bool pmCellSetWeights(pmCell *cell // Cell for which to set weights + ) +{ + float gain = psMetadataLookupF32(NULL, cell->concepts, "CELL.GAIN"); // Cell gain + float readnoise = psMetadataLookupF32(NULL, cell->concepts, "CELL.READNOISE"); // Cell read noise + psRegion *trimsec = psMetadataLookupPtr(NULL, cell->concepts, "CELL.TRIMSEC"); // Trim section + + p_pmHDU *hdu = cell->hdu; // The data unit, containing the weight and mask originals + if (!hdu) { + pmChip *chip = cell->parent; // The parent chip + if (chip->hdu) { + hdu = chip->hdu; + } else { + pmFPA *fpa = chip->parent; // The parent FPA + hdu = fpa->hdu; + if (!hdu) { + psError(PS_ERR_UNKNOWN, true, "Unable to find the HDU in the hierarchy!\n"); + return false; + } + } + } + + psArray *pixels = hdu->images; // Array of images + psArray *weights = hdu->weights; // Array of weight images + psArray *masks = hdu->masks; // Array of mask images + // Generate the weights and masks if required + if (! weights) { + weights = psArrayAlloc(pixels->n); + for (int i = 0; i < pixels->n; i++) { + psImage *image = pixels->data[i]; + weights->data[i] = psImageAlloc(image->numCols, image->numRows, PS_TYPE_F32); + psImageInit(weights->data[i], 0.0); + } + hdu->weights = weights; + } + if (! masks) { + masks = psArrayAlloc(pixels->n); + for (int i = 0; i < pixels->n; i++) { + psImage *image = pixels->data[i]; + masks->data[i] = psImageAlloc(image->numCols, image->numRows, PS_TYPE_U8); + psImageInit(masks->data[i], 0); + } + hdu->masks = masks; + } + + // Set the pixels + psArray *readouts = cell->readouts; // Array of readouts + for (int i = 0; i < readouts->n; i++) { + pmReadout *readout = readouts->data[i]; // The readout of interest + + if (! readout->weight) { + readout->weight = weights->data[i]; + } + if (! readout->mask) { + readout->mask = masks->data[i]; + } + + // Mask is already set to 0 + + // Set weight image to the variance = g*f + rn^2 + psImage *image = psImageSubset(readout->image, *trimsec); // The pixels + psImage *weight = psImageSubset(readout->weight, *trimsec); // The weight map + psBinaryOp(weight, image, "*", psScalarAlloc(gain, PS_TYPE_F32)); + psBinaryOp(weight, weight, "+", psScalarAlloc(readnoise*readnoise, PS_TYPE_F32)); + } + + return true; +} + + Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/astrom/pmAstrometry.h =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/astrom/pmAstrometry.h (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/astrom/pmAstrometry.h (revision 21664) @@ -0,0 +1,467 @@ +/** @file pmAstrometry.h +* +* @brief This file defines the basic types for astronomical coordinate +* transformation +* +* @ingroup AstroImage +* +* @author GLG, MHPCC +* +* @version $Revision: 1.5.2.1.2.1 $ $Name: not supported by cvs2svn $ +* @date $Date: 2006-01-14 03:10:19 $ +* +* Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii +*/ + +#ifndef PS_ASTROMETRY_H +#define PS_ASTROMETRY_H +#if HAVE_CONFIG_H +#include +#endif +#include "pslib.h" +#include "psDB.h" + +/// @addtogroup AstroImage +/// @{ + +// XXX: Is this correct? Must determine what p_pmHDU is. +// XXX: Create the p_pmHDU alloc/free. +typedef struct +{ + const char *extname; // Extension name, if it corresponds to this level + psMetadata *header; // The FITS header, if it corresponds to this level + psArray *images; // The pixel data, if it corresponds to this level + psArray *masks; // The mask data, if it corresponds to this level + psArray *weights; // The weight data, if it corresponds to this level +} +p_pmHDU; + +/** Focal plane data structure + * + * A focal plane consists of one or more chips (according to the number of + * pieces of contiguous silicon). It contains metadata containers for the + * concepts and analysis, a link to the parent, and pointers to the FITS header, + * if that corresponds to this level (the FPA may be the PHU, but will not ever + * contain pixels). For astrometry, it contains a transformation from the focal + * plane to the tangent plane and the fixed pattern residuals. It is expected + * that the transformation will consist of two 4D polynomials (i.e. a function + * of two coordinates in position, the magnitude of the object, and the color of + * the object) in order to correct for optical distortions and the effects of + * the atmosphere; hence we think that it is prudent to include a reverse + * transformation which will be derived from numerically inverting the forward + * transformation. + * + */ +typedef struct +{ + // Astrometric transformations + psPlaneDistort* fromTangentPlane; ///< Transformation from tangent plane to focal plane + psPlaneDistort* toTangentPlane; ///< Transformation from focal plane to tangent plane + psProjection *projection; ///< Projection from tangent plane to sky + // Information + psMetadata *concepts; ///< Cache for PS concepts + psMetadata *analysis; ///< FPA-level analysis metadata + const psMetadata *camera; ///< Camera configuration + psArray *chips; ///< The chips + p_pmHDU *hdu; ///< FITS data + psMetadata *phu; ///< Primary Header +} +pmFPA; + +/** Chip data structure + * + * A chip consists of one or more cells (according to the number of amplifiers + * on the device). The chip contains metadata containers for the concepts and + * analysis, a link to the parent, and pointers to the pointers to the various + * FITS data, if that corresponds to this level. For astrometry, in addition to + * the rough positioning information, it contains a coordinate transform from + * the chip to the focal plane. It is expected that this transform will consist + * of two second-order 2D polynomials; hence we think that it is prudent to + * include a reverse transformation which will be derived from numerically + * inverting the forward transformation. A boolean indicates whether the chip is + * of interest, allowing it to be excluded from analysis. + * + */ +typedef struct +{ + // Offset specifying position on focal plane + int col0; ///< Offset from the left of FPA. + int row0; ///< Offset from the bottom of FPA. + // Astrometric transformations + psPlaneTransform* toFPA; ///< Transformation from chip to FPA coordinates + psPlaneTransform* fromFPA; ///< Transformation from FPA to chip coordinates + // Information + psMetadata *concepts; ///< Cache for PS concepts + psMetadata *analysis; ///< Chip-level analysis metadata + psArray *cells; ///< The cells (referred to by name) + pmFPA *parent; ///< Parent FPA + bool process; ///< Do we bother about reading and working with this chip? + bool exists; ///< Does the chip exist --- has it been read in? + p_pmHDU *hdu; ///< FITS data +} +pmChip; + +/** 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 +{ + // Offset specifying position on chip + int col0; ///< Offset from the left of chip. + int row0; ///< Offset from the bottom of chip. + // Astrometric transformations + psPlaneTransform* toChip; ///< Transformations from cell to chip coordinates + psPlaneTransform* toFPA; ///< Transformations from cell to FPA coordinates + psPlaneTransform* toSky; ///< Transformations from cell to sky coordinates + // Information + psMetadata *concepts; ///< Cache for PS concepts + psMetadata *camera; ///< Camera Info + psMetadata *analysis; ///< Cell-level analysis metadata + psArray *readouts; ///< The readouts (referred to by number) + pmChip *parent; ///< Parent chip + bool process; ///< Do we bother about reading and working with this cell? + bool exists; ///< Does the cell exist --- has it been read in? + p_pmHDU *hdu; ///< FITS data +} +pmCell; + +/** Readout data structure. + * + * A readout is the result of a single read of a cell (or a portion thereof). + * It contains the offset from the lower-left corner of the chip, in the case + * that the CCD was windowed, as well as the binning factors and parity (if the + * binning value is negative, then the parity is reversed). It also contains the + * pixel data, metadata containers for the concepts and analysis, and a link to + * the parent. + * + */ +typedef struct +{ + // Position on the cell + // XXX: These may be removed in the future; use parent->concepts instead? + int col0; ///< Offset from the left of chip. + int row0; ///< Offset from the bottom of chip. + int colBins; ///< Amount of binning in x-dimension + int rowBins; ///< Amount of binning in y-dimension + // Information + psImage *image; ///< Imaging area of readout + psImage *mask; ///< Mask of input image + psImage *weight; ///< Weight of input image + psMetadata *analysis; ///< Readout-level analysis metadata + pmCell *parent; ///< Parent cell +} +pmReadout; + + +/** Allocates a pmReadout + * + * The constructor shall make an empty pmReadout. If the parent cell is not + * NULL, the parent link is made and the readout shall be placed in the + * parents array of readouts. The metadata containers shall be allocated. All + * other pointers in the structure shall be initialized to NULL. + * + * @return pmReadout* newly allocated pmReadout with all internal pointers set to NULL + */ +pmReadout *pmReadoutAlloc( + pmCell *cell ///< Parent cell +); + +/** Allocates a pmCell + * + * The constructor shall make an empty pmCell. If the parent chip is not NULL, + * the parent link is made and the cell shall be placed in the parents array of + * cells. The readouts array shall be allocated with a zero size, and the + * metadata containers constructed. All other pointers in the structure shall be + * initialized to NULL. + * + * @return pmCell* newly allocated pmCell + */ +pmCell *pmCellAlloc( + pmChip *chip, ///< Parent chip + psMetadata *cameraData, ///< Camera data + const char *name ///< Name of cell +); + +/** Allocates a pmChip + * + * The constructor shall make an empty pmChip. If the parent fpa is not NULL, + * the parent link is made and the chip shall be placed in the parent's array + * of chips. The cells array shall be allocated with a zero size, and the + * metadata containers constructed. All other pointers in the structure shall be + * initialized to NULL. + * + * @return pmChip* newly allocated pmChip + */ +pmChip *pmChipAlloc( + pmFPA *fpa, ///< FPA to which the chip belongs + const char *name ///< Name of chip +); + +/** Allocates a pmFPA + * + * The constructor shall make an empty pmFPA. The chips array shall be + * allocated with a zero size, the camera and db pointers set to the values + * provided, and the concepts metadata constructed. All other pointers in the + * structure shall be initialized to NULL. + * + */ +pmFPA *pmFPAAlloc( + const psMetadata *camera ///< Camera configuration +); + +/** Allocates a p_pmHDU + * + * XXX: More detailed description + * + * @return p_pmHDU* newly allocated p_pmHDU + */ +p_pmHDU *p_pmHDUAlloc(const char *extname // Extension name + ); + + +/** Verify parent links. + * + * This function checks the validity of the parent links in the FPA hierarchy. + * If a parent link is not set (or not set correctly), it is corrected, and the + * function shall return false. If all the parent pointers were correct, the + * function shall return true. + * + */ +bool pmFPACheckParents( + pmFPA *fpa +); + + + +/** FUNC DESC + * + * + * + * + */ + + + +/** + * + * pmFPASelectChip shall set valid to true for the specified chip number + * (chipNum), and all other chips shall have valid set to false. In the event + * that the specified chip number does not exist within the fpa, the function + * shall return false. + * + */ +bool pmFPASelectChip( + pmFPA *fpa, + int chipNum +); + +/** + * + * pmFPAExcludeChip shall set valid to false only for the specified chip + * number (chipNum). In the event that the specified chip number does not exist + * within the fpa, the function shall generate a warning, and perform no action. + * The function shall return the number of chips within the fpa that have valid + * set to true. + * + */ +int pmFPAExcludeChip( + pmFPA *fpa, + int chipNum +); + + +/***************************************************************************** + Old Stuff + *****************************************************************************/ + + + +/** Find cooresponding cell for given FPA coordinate + * + * @return pmCell* the cell cooresponding to the coord in FPA + */ +pmCell* pmCellInFPA( + const psPlane* coord, ///< the coordinate in FPA plane + const pmFPA* FPA ///< the FPA to search for the cell +); + + +/** Find cooresponding chip for given FPA coordinate + * + * @return pmChip* the chip cooresponding to coord + */ +pmChip* pmChipInFPA( + const psPlane* coord, ///< the coordinate in FPA plane + const pmFPA* FPA ///< the FPA to search for the cell +); + + +/** Find cooresponding cell for given Chip coordinate + * + * @return pmCell* the cell cooresponding to coord + */ +pmCell* pmCellInChip( + const psPlane* coord, ///< the coordinate in Chip plane + const pmChip* chip ///< the chip to search for the cell +); + + +/** Translate a cell coordinate into a chip coordinate + * + * @return psPlane* the resulting chip coordinate + */ +psPlane* pmCoordCellToChip( + psPlane* out, ///< a plane struct to recycle. If NULL, a new struct is created + const psPlane* in, ///< the coordinate within Cell + const pmCell* cell ///< the Cell in interest +); + + +/** Translate a chip coordinate into a FPA coordinate + * + * @return psPlane* the resulting FPA coordinate + */ +psPlane* pmCoordChipToFPA( + psPlane* out, ///< a plane struct to recycle. If NULL, a new struct is created + const psPlane* in, ///< the coordinate within Chip + const pmChip* chip ///< the chip in interest +); + + +/** Translate a FPA coordinate into a Tangent Plane coordinate + * + * @return psPlane* the resulting Tangent Plane coordinate + */ +psPlane* pmCoordFPAToTP( + 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 pmFPA* fpa ///< the FPA in interest +); + + +/** Translate a Tangent Plane coordinate into a Sky coordinate + * + * @return psSphere* the resulting Sky coordinate + */ +psSphere* pmCoordTPToSky( + psSphere* out, ///< a sphere struct to recycle. If NULL, a new struct is created + const psPlane* in, ///< the coordinate within Tangent Plane + const psProjection *projection +); + +/** Translate a cell coordinate into a FPA coordinate + * + * @return psPlane* the resulting FPA coordinate + */ +psPlane* pmCoordCellToFPA( + psPlane* out, ///< a plane struct to recycle. If NULL, a new struct is created + const psPlane* in, ///< the coordinate within cell + const pmCell* cell ///< the cell in interest +); + + +/** Translate a cell coordinate into a Sky coordinate + * + * @return psSphere* the resulting Sky coordinate + */ +psSphere* pmCoordCellToSky( + 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 pmCell* 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* pmCoordCellToSkyQuick( + psSphere* out, ///< a sphere struct to recycle. If NULL, a new struct is created + const psPlane* in, ///< the coordinate within cell + const pmCell* cell ///< the cell in interest +); + + +/** Translate a Sky coordinate into a Tangent Plane coordinate + * + * @return psPlane* the resulting Tangent Plane coordinate + */ +psPlane* pmCoordSkyToTP( + psPlane* out, ///< a plane struct to recycle. If NULL, a new struct is created + const psSphere* in, ///< the sky coordinate + const psProjection *projection +); + +/** Translate a Tangent Plane coordinate into a FPA coordinate + * + * @return psPlane* the resulting FPA coordinate + */ +psPlane* pmCoordTPToFPA( + 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 pmFPA* fpa ///< the FPA of interest +); + + +/** Translate a FPA coordinate into a chip coordinate + * + * @return psPlane* the resulting chip coordinate + */ +psPlane* pmCoordFPAToChip( + psPlane* out, ///< a plane struct to recycle. If NULL, a new struct is created + const psPlane* in, ///< the FPA coordinate + const pmChip* chip ///< the chip of interest +); + + +/** Translate a chip coordinate into a cell coordinate + * + * @return psPlane* the resulting cell coordinate + */ +psPlane* pmCoordChipToCell( + psPlane* out, ///< a plane struct to recycle. If NULL, a new struct is created + const psPlane* in, ///< the Chip coordinate + const pmCell* cell ///< the cell of interest +); + + +/** Translate a sky coordinate into a cell coordinate + * + * @return psPlane* the resulting cell coordinate + */ +psPlane* pmCoordSkyToCell( + psPlane* out, ///< a plane struct to recycle. If NULL, a new struct is created + const psSphere* in, ///< the Sky coordinate + float color, ///< Color of source + float magnitude, ///< Magnitude of source + const pmCell* 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* pmCoordSkyToCellQuick( + psPlane* out, ///< a plane struct to recycle. If NULL, a new struct is created + const psSphere* in, ///< the Sky coordinate + const pmCell* cell ///< the cell of interest +); + + +#endif // #ifndef PS_ASTROMETRY_H + Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/astrom/pmAstrometryObjects.c =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/astrom/pmAstrometryObjects.c (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/astrom/pmAstrometryObjects.c (revision 21664) @@ -0,0 +1,626 @@ +/** @file pmAstrometryObjects.c +* +* @brief This file defines the basic types for matching objects +* based on their astrometry. +* +* @ingroup AstroImage +* +* @author EAM, IfA +* +* @version $Revision: 1.1.10.2 $ $Name: not supported by cvs2svn $ +* @date $Date: 2006-01-20 02:36:41 $ +* +* Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii +*/ + +/******************************************************************************/ +/* INCLUDE FILES */ +/******************************************************************************/ +#include +#include +#include "pslib.h" +#include "pmFPA.h" +#include "pmAstrometryObjects.h" + + +#define PM_ASTROMETRYOBJECTS_DEBUG 1 +/****************************************************************************** +pmAstromObjSortByFPX(**a, **b): sort by mag (descending) + +Is this a private routine? +Should we do the early asserts? + ******************************************************************************/ + +int pmAstromObjSortByFPX( + const void **a, + const void **b) +{ + if (PM_ASTROMETRYOBJECTS_DEBUG) { + PS_ASSERT_PTR_NON_NULL(a, 0); + PS_ASSERT_PTR_NON_NULL(*a, 0); + PS_ASSERT_PTR_NON_NULL(b, 0); + PS_ASSERT_PTR_NON_NULL(*b, 0); + } + + pmAstromObj *A = *(pmAstromObj **)a; + pmAstromObj *B = *(pmAstromObj **)b; + + psF32 diff = A->FP.x - B->FP.x; + if (diff > FLT_EPSILON) { + return (+1); + } + + if (diff < FLT_EPSILON) { + return (-1); + } + return (0); +} + + + +/****************************************************************************** +pmAstromObjSortByMag(**a, **b): sort by mag (descending) + +Is this a private routine? +Should we do the early asserts? + ******************************************************************************/ +int pmAstromObjSortByMag( + const void **a, + const void **b) +{ + if (PM_ASTROMETRYOBJECTS_DEBUG) { + PS_ASSERT_PTR_NON_NULL(a, 0); + PS_ASSERT_PTR_NON_NULL(*a, 0); + PS_ASSERT_PTR_NON_NULL(b, 0); + PS_ASSERT_PTR_NON_NULL(*b, 0); + } + + pmAstromObj *A = *(pmAstromObj **)a; + pmAstromObj *B = *(pmAstromObj **)b; + + psF32 diff = A->Mag - B->Mag; + if (diff > FLT_EPSILON) { + return (-1); + } + + if (diff < FLT_EPSILON) { + return (+1); + } + + return (0); +} + + +/****************************************************************************** +pmAstromRadiusMatch(st1, st2, config) + ******************************************************************************/ +psArray *pmAstromRadiusMatch( + psArray *st1, + psArray *st2, + psMetadata *config) +{ + PS_ASSERT_PTR_NON_NULL(st1, NULL); + PS_ASSERT_PTR_NON_NULL(st2, NULL); + PS_ASSERT_PTR_NON_NULL(config, NULL); + bool status; + int jStart; + double dX, dY, dR; + + double RADIUS = psMetadataLookupF32 (&status, config, "PSASTRO.MATCH.RADIUS"); + double RADIUS_SQR = PS_SQR (RADIUS); + + // sort both lists by Focal Plane X coord + st1 = psArraySort (st1, pmAstromObjSortByFPX); + st2 = psArraySort (st2, pmAstromObjSortByFPX); + + psArray *matches = psArrayAlloc (100); + matches->n = 0; + + int i = 0; + int j = 0; + while ((i < st1->n) && (j < st2->n)) { + + dX = ((pmAstromObj *)st1->data[i])->FP.x - ((pmAstromObj *)st2->data[j])->FP.x; + if (dX < -RADIUS) { + i++; + continue; + } + if (dX > +RADIUS) { + j++; + continue; + } + + jStart = j; + while ((dX > -RADIUS) && (j < st2->n)) { + + dX = ((pmAstromObj *)st1->data[i])->FP.x - ((pmAstromObj *)st2->data[j])->FP.x; + dY = ((pmAstromObj *)st1->data[i])->FP.y - ((pmAstromObj *)st2->data[j])->FP.y; + dR = dX*dX + dY*dY; + + if (dR > RADIUS_SQR) { + j++; + continue; + } + + // got a match; add to output list + pmAstromMatch *match = pmAstromMatchAlloc (i, j); + psArrayAdd (matches, 100, match); + + j++; + } + j = jStart; + i++; + } + return (matches); +} + + + +/****************************************************************************** +pmAstromMatchFit(map, raw, ref, match, config): take two matched star lists +and fit a psPlaneTransform between them + ******************************************************************************/ +psPlaneTransform *pmAstromMatchFit( + psPlaneTransform *map, + psArray *raw, + psArray *ref, + psArray *match, + psMetadata *config) +{ + PS_ASSERT_PTR_NON_NULL(raw, NULL); + PS_ASSERT_PTR_NON_NULL(ref, NULL); + PS_ASSERT_PTR_NON_NULL(match, NULL); + PS_ASSERT_PTR_NON_NULL(config, NULL); + + bool status; + pmAstromObj *rawStar, *refStar; + pmAstromMatch *pair; + + if (map == NULL) { + int nX = psMetadataLookupS32 (&status, config, "PSASTRO.CHIP.NX"); + if (!status) { + nX = 1; + } + int nY = psMetadataLookupS32 (&status, config, "PSASTRO.CHIP.NY"); + if (!status) { + nY = 1; + } + map = psPlaneTransformAlloc (nX, nY); + // XXX EAM : not clear that we are allowed to use orders > 1 + } + + psStats *stats = psStatsAlloc (PS_STAT_CLIPPED_MEAN | PS_STAT_CLIPPED_STDEV); + stats->clipSigma = psMetadataLookupF32 (&status, config, "PSASTRO.CHIP.NSIGMA"); + stats->clipIter = psMetadataLookupS32 (&status, config, "PSASTRO.CHIP.NITER"); + + // XXX EAM : clip fit seems to only work for F32! + // XXX EAM : clip fit fails to handle NULL error + psVector *X = psVectorAlloc (match->n, PS_TYPE_F32); + psVector *Y = psVectorAlloc (match->n, PS_TYPE_F32); + psVector *x = psVectorAlloc (match->n, PS_TYPE_F32); + psVector *y = psVectorAlloc (match->n, PS_TYPE_F32); + psVector *wt = psVectorAlloc (match->n, PS_TYPE_F32); + + // take the matched stars, first fit + for (int i = 0; i < match->n; i++) { + + pair = match->data[i]; + rawStar = raw->data[pair->i1]; + refStar = ref->data[pair->i2]; + + X->data.F32[i] = rawStar->chip.x; + Y->data.F32[i] = rawStar->chip.y; + + x->data.F32[i] = refStar->FP.x; + y->data.F32[i] = refStar->FP.y; + + wt->data.F32[i] = 1.0; + } + + // no masking, no errors + psVectorClipFitPolynomial2D (map->x, stats, NULL, 0, X, wt, x, y); + psVectorClipFitPolynomial2D (map->y, stats, NULL, 0, Y, wt, x, y); + psFree (x); + psFree (y); + psFree (X); + psFree (Y); + psFree (wt); + psFree (stats); + + return (map); +} + + + +/****************************************************************************** +pmAstromRotateObj(old, center, angle): rotate the focal-plane coordinates +about the center coordinate angle specified in radians + ******************************************************************************/ +psArray *pmAstromRotateObj( + psArray *old, + psPlane center, + double angle) +{ + PS_ASSERT_PTR_NON_NULL(old, NULL); + + double X, Y; + pmAstromObj *newObj; + pmAstromObj *oldObj; + + psArray *new = psArrayAlloc (old->n); + + double cs = cos(angle); + double sn = sin(angle); + double xCenter = center.x; + double yCenter = center.y; + + for (int i = 0; i < old->n; i++) { + + oldObj = (pmAstromObj *)old->data[i]; + newObj = pmAstromObjCopy (oldObj); + + X = oldObj->FP.x - xCenter; + Y = oldObj->FP.y - yCenter; + + newObj->FP.x = X*cs + Y*sn + xCenter; + newObj->FP.y = Y*cs - X*sn + yCenter; + + new->data[i] = newObj; + } + return (new); +} + + + +/****************************************************************************** +pmAstromObjFree(obj) + ******************************************************************************/ +static void pmAstromObjFree(pmAstromObj *obj) +{ + if (obj == NULL) { + return; + } + + return; +} + + +/****************************************************************************** +pmAstromObjAlloc() + ******************************************************************************/ +pmAstromObj *pmAstromObjAlloc(void) +{ + pmAstromObj *obj = psAlloc (sizeof(pmAstromObj)); + psMemSetDeallocator (obj, (psFreeFunc) pmAstromObjFree); + + obj->pix.x = 0; + obj->pix.y = 0; + + obj->FP.x = 0; + obj->FP.y = 0; + + obj->TP.x = 0; + obj->TP.y = 0; + + obj->sky.r = 0; + obj->sky.d = 0; + + obj->Mag = 0; + obj->dMag = 0; + + return (obj); +} + + +/****************************************************************************** +pmAstromObjCopy(old) + ******************************************************************************/ +pmAstromObj *pmAstromObjCopy(pmAstromObj *old) +{ + PS_ASSERT_PTR_NON_NULL(old, NULL); + pmAstromObj *obj = pmAstromObjAlloc(); + + obj[0] = old[0]; + + return(obj); +} + + +/****************************************************************************** + ******************************************************************************/ +static void pmAstromMatchFree (pmAstromMatch *match) +{ + if (match == NULL) + return; + return; +} + + +/****************************************************************************** + ******************************************************************************/ +pmAstromMatch *pmAstromMatchAlloc( + int i1, + int i2) +{ + pmAstromMatch *match = psAlloc (sizeof(pmAstromMatch)); + psMemSetDeallocator(match, (psFreeFunc) pmAstromMatchFree); + + match->i1 = i1; + match->i2 = i2; + + return (match); +} + + +static double maxOffpix; // maximum allowed offset between lists, in raw pixels +static double Scale; // grid pixel scale static +double Offset; // deltas to pixels +/****************************************************************************** +AstromGridBin(*dx, *dy, dX, dY): local function to convert x,y coords to grid +bins it requires the globals defined above. + + ******************************************************************************/ +static bool AstromGridBin( + int *dx, + int *dy, + double dX, + double dY) +{ + if (PM_ASTROMETRYOBJECTS_DEBUG) { + PS_ASSERT_PTR_NON_NULL(dx, false); + PS_ASSERT_PTR_NON_NULL(dy, false); + } + + if (fabs(dX) > maxOffpix) { + return false; + } + + if (fabs(dY) > maxOffpix) { + return false; + } + + *dx = dX / Scale + Offset; + *dy = dY / Scale + Offset; + return true; +} + + +/****************************************************************************** +pmAstromGridAngle(raw, ref, config): match the two lists using the binned +delta-delta max. + ******************************************************************************/ +pmAstromStats pmAstromGridAngle( + psArray *raw, + psArray *ref, + psMetadata *config) +{ + // XXX: What to do if input parameters are bad? + pmAstromStats badStat; + PS_ASSERT_PTR_NON_NULL(raw, badStat); + PS_ASSERT_PTR_NON_NULL(ref, badStat); + PS_ASSERT_PTR_NON_NULL(config, badStat); + + bool status; + int nPix; // size of matching grid + int nPixHalf; // half-size of matching grid + double dX, dY; // offset between a possible matched pair + int iX, iY; // corresponding grid bin + + pmAstromObj *ob1, *ob2; // short-cut pointers to the objects + pmAstromStats stats; // output match statistics + + // max allowed offset in either X or Y directions + double gridOffset = psMetadataLookupF32 (&status, config, "PSASTRO.GRID.OFFSET"); + + // sampling scale of the grid + double gridScale = psMetadataLookupF32 (&status, config, "PSASTRO.GRID.SCALE"); + + // set the static scaling factors + nPixHalf = (int)(gridOffset / gridScale + 0.5); // half-grid + nPix = 2*nPixHalf + 1; // full grid width + + // these are globals used by p_pmAstromGridBin + maxOffpix = gridScale * (nPixHalf + 0.5); // max offset from true center + Offset = maxOffpix / gridScale; + Scale = gridScale; + + // images used as accumulators for the loop below + psImage *gridNP = psImageAlloc (nPix, nPix, PS_TYPE_U32); + psImage *gridDX = psImageAlloc (nPix, nPix, PS_TYPE_F32); + psImage *gridDY = psImageAlloc (nPix, nPix, PS_TYPE_F32); + psImage *gridD2 = psImageAlloc (nPix, nPix, PS_TYPE_F32); + psImageInit (gridNP, 0); + psImageInit (gridDX, 0); + psImageInit (gridDY, 0); + psImageInit (gridD2, 0); + + // short-cut names for grid images + psS32 **NP = gridNP->data.S32; + psF32 **DX = gridDX->data.F32; + psF32 **DY = gridDY->data.F32; + psF32 **D2 = gridD2->data.F32; + + // accumulate grids for focal plane (L,M) matches + for (int i = 0; i < raw->n; i++) { + ob1 = (pmAstromObj *)raw->data[i]; + for (int j = 0; j < ref->n; j++) { + ob2 = (pmAstromObj *)ref->data[j]; + dX = ob1->FP.x - ob2->FP.x; + dY = ob1->FP.y - ob2->FP.y; + + // fprintf (stderr, "dX,dY: %8.2f %8.2f : %8.2f %8.2f : %8.2f %8.2f\n", dX, dY, ob1->FP.x, ob2->FP.x, ob1->FP.y, ob2->FP.y); + // find bin coordinates for this delta-delta + if (!AstromGridBin (&iX, &iY, dX, dY)) { + continue; // matched pair is too far offset + } + + // accumulate bin stats + NP[iY][iX] ++; + DX[iY][iX] += dX; + DY[iY][iX] += dY; + D2[iY][iX] += PS_SQR(dX) + PS_SQR(dY); + } + } + + // now assess the grid images + { + double minMetric = 1e10; + double minVar = 1e10; + int minX = -1; + int minY = -1; + double metric, var; + + // find the max pixel + psStats *imStats = psStatsAlloc (PS_STAT_MAX); + imStats = psImageStats (imStats, gridNP, NULL, 0); + + // only check bins with at least 1/2 of max bin + int minNpts = 0.5*imStats->max; + fprintf (stderr, "minNpts: %d, max: %d\n", minNpts, (int)(imStats->max)); + + // find the 'best' bin + for (int j = 0; j < gridNP->numRows; j++) + { + for (int i = 0; i < gridNP->numCols; i++) { + + if (NP[j][i] < minNpts) + continue; + + // this metric emphasize a narrow peak with lots of sources over one with few. + var = fabs((D2[j][i]/NP[j][i]) - PS_SQR(DX[j][i]/NP[j][i]) - PS_SQR(DY[j][i]/NP[j][i])); + metric = var / PS_SQR(PS_SQR(NP[j][i])); + + fprintf (stderr, "try : %f %f (%d pts, %f var, %f met)\n", DX[j][i]/NP[j][i], DY[j][i]/NP[j][i], NP[j][i], var, metric); + + if (metric < minMetric) { + minMetric = metric; + minVar = var; + minX = i; + minY = j; + } + } + } + + // convert the bin to delta-delta + stats.offset.x = DX[minY][minX] / NP[minY][minX]; + stats.offset.y = DY[minY][minX] / NP[minY][minX]; + stats.minMetric = minMetric; + stats.minVar = minVar; + stats.nMatch = NP[minY][minX]; + + // XXX EAM : This routine, and pmAstromGridMatch, need to handle failure cases better + } + return (stats); +} + + + +/****************************************************************************** +pmAstromGridMatch(*raw, *ref, *config): match two star lists. + ******************************************************************************/ + +pmAstromStats pmAstromGridMatch( + psArray *raw, + psArray *ref, + psMetadata *config) +{ + // XXX: What to do if input parameters are bad? + pmAstromStats badStat; + PS_ASSERT_PTR_NON_NULL(raw, badStat); + PS_ASSERT_PTR_NON_NULL(ref, badStat); + PS_ASSERT_PTR_NON_NULL(config, badStat); + + bool status; + double xMin, xMax, yMin, yMax; + pmAstromObj *obj; + psArray *rot; + + pmAstromStats minStat; + pmAstromStats newStat = {{0, 0, 0, 0}, {0, 0, 0, 0}, 0, 0, 0, 0}; + psPlane center; + + // find center of the raw field (focal-plane coords) + xMin = yMin = +1e10; + xMax = yMax = -1e10; + for (int i = 0; i < raw->n; i++) { + obj = (pmAstromObj *)raw->data[i]; + xMin = PS_MIN (obj->FP.x, xMin); + xMax = PS_MAX (obj->FP.x, xMax); + yMin = PS_MIN (obj->FP.y, yMin); + yMax = PS_MAX (obj->FP.y, yMax); + } + center.x = 0.5*(xMin + xMax); + center.y = 0.5*(yMin + yMax); + + double minAngle = psMetadataLookupF32 (&status, config, "PSASTRO.GRID.MIN.ANGLE"); + double maxAngle = psMetadataLookupF32 (&status, config, "PSASTRO.GRID.MAX.ANGLE"); + double delAngle = psMetadataLookupF32 (&status, config, "PSASTRO.GRID.DEL.ANGLE"); + + minStat.minMetric = 1e10; + for (double angle = minAngle; angle <= maxAngle; angle += delAngle) { + rot = pmAstromRotateObj (raw, center, angle); + newStat = pmAstromGridAngle (rot, ref, config); + newStat.angle = angle; + newStat.center = center; + if (newStat.minMetric < minStat.minMetric) { + minStat = newStat; + } + psFree (rot); + } + fprintf (stderr, "best: %f %f (%d pts, %f var, %f met)\n", newStat.offset.x, newStat.offset.y, newStat.nMatch, newStat.minVar, newStat.minMetric); + return (minStat); +} + + +/****************************************************************************** +pmAstromGridApply(*map, stat): apply the measured FPA offset and rotation +(stat) to the fpa astrom structures. + ******************************************************************************/ +psPlaneTransform *pmAstromGridApply( + psPlaneTransform *map, + pmAstromStats stat) +{ + PS_ASSERT_PTR_NON_NULL(map, NULL); + PS_ASSERT_POLY_NON_NULL(map->x, NULL); + PS_ASSERT_POLY_NON_NULL(map->y, NULL); + + double cs = cos (stat.angle); + double sn = sin (stat.angle); + + double dx = (map->x->coeff[0][0] - stat.center.x); + double dy = (map->y->coeff[0][0] - stat.center.y); + + // new offset + map->x->coeff[0][0] = cs*dx + sn*dy - stat.offset.x + stat.center.x; + map->y->coeff[0][0] = -sn*dx + cs*dy - stat.offset.y + stat.center.y; + + // original rotation matrix + double pc1_1 = map->x->coeff[1][0]; + double pc1_2 = map->x->coeff[0][1]; + double pc2_1 = map->y->coeff[1][0]; + double pc2_2 = map->y->coeff[0][1]; + + // new rotation matrix + map->x->coeff[1][0] = +cs*pc1_1 + sn*pc2_1; + map->x->coeff[0][1] = +cs*pc1_2 + sn*pc2_2; + map->y->coeff[1][0] = -sn*pc1_1 + cs*pc2_1; + map->y->coeff[0][1] = -sn*pc1_2 + cs*pc2_2; + + return (map); +} + +/* Illustration of the grid bins + dX bin + -35:-25 -> 0 bin = dX / Scale + Offset + -25:-15 -> 1 Scale = 10 + -15:-05 -> 2 Offset = 3.5 + -05:+05 -> 3 nPix = 3 (maxOffset = 35 = (nPix + 0.5)*dXix + +05:+15 -> 4 dPix = 10 + +15:+25 -> 5 + +25:+35 -> 6 + + maxOffsetRequest = 30 + nPix = (int) (maxOffset / dPix + 0.5); + maxOffset = (nPix + 0.5)*Scale; +*/ + Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/astrom/pmAstrometryObjects.h =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/astrom/pmAstrometryObjects.h (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/astrom/pmAstrometryObjects.h (revision 21664) @@ -0,0 +1,390 @@ +/** @file pmAstrometryObjects.h +* +* @brief This file defines the basic types for matching objects +* based on their astrometry. +* +* @ingroup AstroImage +* +* @author EAM, IfA +* +* @version $Revision: 1.1.10.1 $ $Name: not supported by cvs2svn $ +* @date $Date: 2006-01-20 02:36:41 $ +* +* Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii +*/ + +#if !defined(PM_ASTROMETRYOBJECTS_H) +#define PM_PM_ASTROMETRYOBJECTS_H_H + +# include +# include // for strcasecmp +# include // for unlink +# include +# include + +/* + * + * This structure specifies the coordinate of the detection in each of the + * four necessary coordinate frames: pix defines the position in the psReadout + * frame, FP defines the position in the Focal Plane frame, TP defines the + * position in the Tangent Plane frame, sky defines the position on the Celestial + * Sphere. In addition, a measurement of the brightness is given by the element + * Mag. Such a data structure should be used for both the raw and the reference + * stars. In astrometric processing, the raw detections will be projected using + * the best available information to each of these coordinate frames from the pix + * coordinates, while the reference detections will be projected to the other + * frames from the sky coordinates. + * + * XXX: There are more members here than in the SDRS. + * + */ +typedef struct +{ + psPlane pix; ///< the position in the pmReadout frame + psPlane cell; ///< the position in the pmCell frame + psPlane chip; ///< the position in the pmChip frame + psPlane FP; ///< the position in the pmFPA frame + psPlane TP; ///< the position in the tangent plane + psSphere sky; ///< the position on the Celestial Sphere. + double Mag; ///< A measurement of the brightness. + double dMag; ///< What is this? +} +pmAstromObj; + + + +/* + * + * The pmAstromMatch structure defines the cross-correlation between two + * arrays. A single such data item specifies that item number pmAstromMatch.idx1 + * in the first list corresponds to pmAstromMatch.idx2 in the second list. + * + */ +typedef struct +{ + int i1; ///< What is this? + int i2; ///< What is this? +} +pmAstromMatch; + + +/* + * + * XXX: Not in SDRS. + * + */ +typedef struct +{ + psPlane center; ///< + psPlane offset; ///< + double angle; ///< + double minMetric; ///< + double minVar; ///< + int nMatch; ///< +} +pmAstromStats; + + + +/* + * + * If the two sets of coordinates are expected to agree very well (ie, the + * current best-guess astrometric solution is quite close to the radius. The + * following function accepts two sets of pmAstromObj sources and determines the + * matched objects between the two lists. The input sources must have been + * projected to the Focal Plane coordinates (pmAstromObj.FP), and the supplied + * options entry must contain the desired match radius (keyword: + * ASTROM.MATCH.RADIUS). The output consists an array of pmAstromMatch values, + * defined below. + * + */ +psArray *pmAstromRadiusMatch( + psArray *st1, + psArray *st2, + psMetadata *config +); + + + +/* + * + * This function accepts an array of pmAstromObj objects and rotates them by + * the given angle about the given center coordinate pCenter,qCenter in the Focal + * Plane Array coordinates. + * + * XXX: This differs from the SDRS + * + */ +/* SDRS +psArray *pmAstromRotateObj( + psArray *old, + double angle, + double pCenter, + double qCenter +); +*/ +psArray *pmAstromRotateObj( + psArray *old, + psPlane center, + double angle +); + + +/* + * + * If the two sets of coordinates are not known to agree well, but the + * relative scale and approximate relative rotation is known, then a much faster + * match can be found using pair-pair displacements. In such a case, the two + * lists can be considered as having the same coordinate system, with an unknown + * relative displacement. In this algorithm, all possible pair-wise differences + * between the source positions in the two lists are constructed and accumulated + * in a grid of possible offset values. The resulting grid is searched for a + * cluster representing the offset between the two input lists. This algorithm + * can only tolerate a small error in the relative scale or the relative rotation + * of the two coordinate lists. However, this process is naturally O(N2), and is + * thus advantageous over triangle matching in some circumstances. This process + * can be extended to allow a larger uncertainty in the relative rotation by + * allowing the procedure to scan over a range of rotations. We define the + * following function to apply this matching algorithm: + * + * XXX: In the SDRS, this function is a pointer. + * + */ +pmAstromStats pmAstromGridMatch( + psArray *st1, + psArray *st2, + psMetadata *config +); + + +/* + * + * The result of a pmAstromGridMatch may be used to modify the astrometry + * transformation information for a pmFPA image hierarchy structure. The result + * of pmAstromGridMatch defines the adjustments which should be made to the + * reference coordinate of the projection (pmFPA.projection.R,D) and the + * effective rotation of the Focal Plane. The rotation implies modification of + * the linear terms of the pmFPA.toTangentPlane transformation. These two + * adjustments are made using the function: + * + * XXX: This function name is different in the SDRS. + * + */ +psPlaneTransform *pmAstromGridApply( + psPlaneTransform *map, + pmAstromStats stat +); + + +/* + * + * This function is identical to pmAstromGridMatch, but is valid for only a + * single relative rotation. The input config information need not contain any of + * the GRID.*.ANGLE entries (they will be ignored). + * + * XXX: This function name is different in the SDRS. + * + */ +/* in pmAstromGrid.c */ +pmAstromStats pmAstromGridAngle( + psArray *st1, + psArray *st2, + psMetadata *config); + + + +/* + * + * This function accepts the raw and reference source lists and the list of + * matched entries. It uses the matched list to determine a polynomial + * transformation between the two coordinate systems. The fitting uses clipping + * to exclude outliers, likely representing poor matches. The config element must + * contain the information ASTROM.NSIGMA (specifying the number of sigma used in + * the clipping) and ASTROM.NCLIP (specifying the number of clipping iterations + * must be performed). The config element must also specify the order of the + * polynomial fit (keyword: ASTROM.ORDER). The result of this fit is a set of + * modifications of the components of the pmFPA.toTangentPlane transformation, + * and the modifications of the reference coordinate of the projection + * (pmFPA.projection.R,D) and the projection scale (pmFPA.projection.Xs,Ys). The + * modifications to pmFPA.toTangentPlane incorporate the rotation component of + * the linear terms and the higher-order terms of the polynomial fits. + * + * XXX: No prototype code. + * + */ +bool pmAstromFitFPA( + pmFPA *fpa, + psArray *st1, + psArray *st2, + psArray *match, + psMetadata *config +); + + + +/* + * + * This function accepts the raw and reference source lists for a single chip + * and the list of matched entries. It uses the matched list to determine a + * polynomial transformation between the two coordinate systems. The fitting + * uses clipping to exclude outliers, likely representing poor matches. The + * config element must contain the information ASTROM.NSIGMA + *(specifying the number of sigma used in the clipping) and ASTROM.NCLIP + *(specifying the number of clipping iterations must be performed). The config + *element must also specify the order of the polynomial fit (keyword: + *ASTROM.ORDER). The result of this fit is a set of modifications of the + *components of the pmChip.toFPA transformation. + * + * XXX: No prototype code. + * + */ +bool pmAstromFitChip( + pmFPA *fpa, + psArray *st1, + psArray *st2, + psArray *match, + psMetadata *config +); + + +/* + * + * The following function determines the position residual, in the tangent + * plane, as a function of position in the focal plane, for a collection of raw + * measurements and matched reference stars. The configuration data must include + * the bin size over which the gradient is measured (keyword: ASTROM.GRAD.BOX). + * The function returns an array of pmAstromGradient structures, defined below. + * + * XXX: No prototype code. + * + */ +psArray pmAstromMeasureGradients( + psArray *starlist1, + psArray *starlist2, + psArray *match, + psMetadata *config +); + + + +/* + * + * The following data structure carries the information about the residual + * gradient of source positions in the tangent plane (pmAstromObj.TP) as a + * function of position in the focal plane (pmAstromObj.FP). + * + */ +typedef struct +{ + psPlane FP; + psPlane dTPdL; + psPlane dTPdM; +} +pmAstromGradient; + + +/* + * + * The gradient set measured above can be fitted with a pair of 2D + * polynomials. The resulting fits can then be related back to the implied + * polynomials which represent the distortion. The following function performs + * the fit and applies the result to the distortion transformation of the + * supplied pmFPA structure. The configuration variable supplies the polynomial + * order (keyword: ASTROM.DISTORT.ORDER). + * + * XXX: No prototype code. + * + */ +psArray pmAstromFitDistortion( + pmFPA *fpa, + psArray *gradients, + psMetadata *config); + + + + + +/******************************************************************************* + The following functions and structs were in the prototype code, but not the + SDRS. + ******************************************************************************/ +/* + * + * + * + * + */ + + +/* + * + * Allocates a pmAstromObj struct. + * + */ +pmAstromObj *pmAstromObjAlloc (void); + + + +/* + * + * Copies a pmAstromObj struct. + * + */ +pmAstromObj *pmAstromObjCopy( + pmAstromObj *old +); + + + +/* + * + * + * + */ +pmAstromMatch *pmAstromMatchAlloc( + int i1, + int i2 +); + + + + +/* + * + * + * + */ +psPlaneTransform *pmAstromMatchFit( + psPlaneTransform *map, + psArray *st1, + psArray *st2, + psArray *match, + psMetadata *config +); + + + +/* + * + * + * + */ +int pmAstromObjSortByFPX( + const void **a, + const void **b +); + + + +/* + * + * + * + */ +int pmAstromObjSortByMag( + const void **a, + const void **b +); + +#endif + Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/astrom/pmChipMosaic.c =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/astrom/pmChipMosaic.c (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/astrom/pmChipMosaic.c (revision 21664) @@ -0,0 +1,367 @@ +#include +#include + +#include "pslib.h" +#include "pmFPA.h" +#include "pmChipMosaic.h" + +#define MEM_LEAKS 0 + +// Compare a value with a maximum and minimum +#define COMPARE(value,min,max) \ +if ((value) < (min)) { \ + (min) = (value); \ +} \ +if ((value) > (max)) { \ + (max) = (value); \ +} + +// Mosaic multiple images, with flips, binning and offsets +psImage *p_pmImageMosaic(const psArray *source, // Images to splice in + const psVector *xFlip, const psVector *yFlip, // Need to flip x and y? + const psVector *xBinSource, const psVector *yBinSource, // Binning in x and y of + // source images + int xBinTarget, int yBinTarget, // Binning in x and y of target images + const psVector *x0, const psVector *y0 // Offsets for source images on target + ) +{ + assert(source); + assert(xFlip && xFlip->type.type == PS_TYPE_U8); + assert(yFlip && yFlip->type.type == PS_TYPE_U8); + assert(xBinSource && xBinSource->type.type == PS_TYPE_S32); + assert(yBinSource && yBinSource->type.type == PS_TYPE_S32); + assert(x0 && x0->type.type == PS_TYPE_S32); + assert(y0 && y0->type.type == PS_TYPE_S32); + + // Get the maximum extent of the mosaic image + int xMin = INT_MAX; + int xMax = - INT_MAX; + int yMin = INT_MAX; + int yMax = - INT_MAX; + psElemType type = 0; + for (int i = 0; i < source->n; i++) { + psImage *image = source->data[i]; // The image of interest + if (!image) { + continue; + } + + // Only implemented for F32 and U8 images so far. + assert(image->type.type == PS_TYPE_F32 || image->type.type == PS_TYPE_U8); + // All input types must be the same + if (type == 0) { + type = image->type.type; + } + assert(type == image->type.type); + + // Size of cell in x and y + int xParity = xFlip->data.U8[i] ? -1 : 1; + int yParity = yFlip->data.U8[i] ? -1 : 1; + psTrace(__func__, 5, "Extent of cell %d: %d -> %d , %d -> %d\n", i, x0->data.S32[i], + x0->data.S32[i] + xParity * xBinSource->data.S32[i] * image->numCols, y0->data.S32[i], + y0->data.S32[i] + yParity * yBinSource->data.S32[i] * image->numRows); + + COMPARE(x0->data.S32[i], xMin, xMax); + COMPARE(y0->data.S32[i], yMin, yMax); + // Subtract the parity to get the inclusive limit (not exclusive) + COMPARE(x0->data.S32[i] + xParity * xBinSource->data.S32[i] * image->numCols - xParity, xMin, xMax); + COMPARE(y0->data.S32[i] + yParity * yBinSource->data.S32[i] * image->numRows - yParity, yMin, yMax); + } + + // Set up the image + // Since both upper and lower values are inclusive, we need to add one to the size + float xSize = (float)(xMax - xMin + 1) / (float)xBinTarget; + if (xSize - (int)xSize > 0) { + xSize += 1; + } + float ySize = (float)(yMax - yMin + 1) / (float)yBinTarget; + if (ySize - (int)ySize > 0) { + ySize += 1; + } + + psTrace(__func__, 3, "Spliced image will be %dx%d\n", (int)xSize, (int)ySize); + psImage *mosaic = psImageAlloc((int)xSize, (int)ySize, type); // The mosaic image + psImageInit(mosaic, 0.0); + + // Next pass through the images to do the mosaicking + for (int i = 0; i < source->n; i++) { + psImage *image = source->data[i]; // The image of interest + if (!image) { + continue; + } + if (xBinSource->data.S32[i] == xBinTarget && yBinSource->data.S32[i] == yBinTarget && + xFlip->data.U8[i] == 0 && yFlip->data.U8[i] == 0) { + // Let someone else do the hard work; useful to test psImageOverlaySection if no other reason + psImageOverlaySection(mosaic, image, x0->data.S32[i], y0->data.S32[i], "+"); + } else { + // We have to do the hard work ourself + for (int y = 0; y < image->numRows; y++) { + int yParity = yFlip->data.U8[i] ? -1 : 1; + float yTargetBase = (y0->data.S32[i] + yParity * yBinSource->data.S32[i] * y) / yBinTarget; + for (int x = 0; x < image->numCols; x++) { + int xParity = xFlip->data.U8[i] ? -1 : 1; + float xTargetBase = (x0->data.S32[i] + xParity * xBinSource->data.S32[i] * x) / + xBinTarget; + + // In case the original image is binned but the mosaic is not, we need to fill in the + // values in the mosaic. + #define FILL_IN(TYPE) \ + for (int j = 0; j < yBinSource->data.S32[i]; j++) { \ + int yTarget = (int)(yTargetBase + yParity * (float)j / (float)yBinTarget); \ + for (int i = 0; i < xBinSource->data.S32[i]; i++) { \ + int xTarget = (int)(xTargetBase + xParity * (float)i / (float)xBinTarget); \ + mosaic->data.TYPE[yTarget][xTarget] += image->data.TYPE[y][x]; \ + } \ + } + + switch (type) { + case PS_TYPE_F32: + FILL_IN(F32); + break; + case PS_TYPE_U8: + FILL_IN(U8); + break; + default: + psAbort(__func__, "Should never get here.\n"); + } + + } + } // Iterating over input image + } + } + + return mosaic; +} + + +// Set the concepts in the new cell, based on the values in the old one +static bool cellConcepts(pmCell *target,// Target cell + psArray *sources, // Source cells + int xBin, int yBin // Binning + ) +{ + bool success = true; // Result of setting everything + float gain = 0.0; // Gain + float readnoise = 0.0; // Read noise + float saturation = 0.0; // Saturation level + float bad = 0.0; // Bad level + float exposure = 0.0; // Exposure time + float darktime = 0.0; // Dark time + double time = 0.0; // Time of observation + psTimeType timeSys = 0; // Time system + + int nCells = 0; // Number of cells; + for (int i = 0; i < sources->n; i++) { + pmCell *cell = sources->data[i];// The cell of interest + if (!cell) { + continue; + } + + nCells++; + gain += psMetadataLookupF32(NULL, cell->concepts, "CELL.GAIN"); + readnoise += psMetadataLookupF32(NULL, cell->concepts, "CELL.READNOISE"); + saturation += psMetadataLookupF32(NULL, cell->concepts, "CELL.SATURATION"); + bad += psMetadataLookupF32(NULL, cell->concepts, "CELL.BAD"); + exposure += psMetadataLookupF32(NULL, cell->concepts, "CELL.EXPOSURE"); + darktime += psMetadataLookupF32(NULL, cell->concepts, "CELL.DARKTIME"); + time += psTimeToMJD(psMetadataLookupPtr(NULL, cell->concepts, "CELL.TIME")); + if (i == 0) { + timeSys = psMetadataLookupS32(NULL, cell->concepts, "CELL.TIMESYS"); + } else if (timeSys != psMetadataLookupS32(NULL, cell->concepts, "CELL.TIMESYS")) { + psLogMsg(__func__, PS_LOG_ERROR, "Differing time systems in use: %d vs %d\n", timeSys, + psMetadataLookupS32(NULL, cell->concepts, "CELL.TIMESYS")); + success = false; + } + } + gain /= (float)nCells; + readnoise /= (float)nCells; + saturation /= (float)nCells; + bad /= (float)nCells; + exposure /= (float)nCells; + darktime /= (float)nCells; + psTime *timePtr = psTimeFromMJD(time/(double)nCells); + timePtr = psTimeConvert(timePtr, timeSys); + + // XXX *REALLY* need a generic "concept update" function that handles the type and comments transparently. + psMetadataAddF32(target->concepts, PS_LIST_TAIL, "CELL.GAIN", PS_META_REPLACE, "Gain (e/ADU)", gain); + psMetadataAddF32(target->concepts, PS_LIST_TAIL, "CELL.READNOISE", PS_META_REPLACE, "Read noise (e)", readnoise); + psMetadataAddF32(target->concepts, PS_LIST_TAIL, "CELL.SATURATION", PS_META_REPLACE, "Saturation level (ADU)", saturation); + psMetadataAddF32(target->concepts, PS_LIST_TAIL, "CELL.BAD", PS_META_REPLACE, "Bad level (ADU)", bad); + psMetadataAddF32(target->concepts, PS_LIST_TAIL, "CELL.EXPOSURE", PS_META_REPLACE, "Exposure time (sec)", exposure); + psMetadataAddF32(target->concepts, PS_LIST_TAIL, "CELL.DARKTIME", PS_META_REPLACE, "Time since last CCD flush (sec)", darktime); + psMetadataAddPtr(target->concepts, PS_LIST_TAIL, "CELL.TIME", PS_DATA_TIME | PS_META_REPLACE, "Time of observation", timePtr); + psMetadataAddS32(target->concepts, PS_LIST_TAIL, "CELL.TIMESYS", PS_META_REPLACE, "Time system", timeSys); + psFree(timePtr); + + // Now fill in the ones I know by other means + psMetadataAddS32(target->concepts, PS_LIST_TAIL, "CELL.X0", PS_META_REPLACE, "Position of (0,0) on the chip", 0); + psMetadataAddS32(target->concepts, PS_LIST_TAIL, "CELL.Y0", PS_META_REPLACE, "Position of (0,0) on the chip", 0); + psMetadataAddS32(target->concepts, PS_LIST_TAIL, "CELL.XPARITY", PS_META_REPLACE, "Orientation in x compared to the rest of the FPA", 1); + psMetadataAddS32(target->concepts, PS_LIST_TAIL, "CELL.YPARITY", PS_META_REPLACE, "Orientation in x compared to the rest of the FPA", 1); + psMetadataAddS32(target->concepts, PS_LIST_TAIL, "CELL.XBIN", PS_META_REPLACE, "Binning in x", xBin); + psMetadataAddS32(target->concepts, PS_LIST_TAIL, "CELL.YBIN", PS_META_REPLACE, "Binning in x", yBin); + psMetadataAddS32(target->concepts, PS_LIST_TAIL, "CELL.READDIR", PS_META_REPLACE, "Read direction (faked)", 1); + psRegion *trimsec = psMetadataLookupPtr(NULL, target->concepts, "CELL.TRIMSEC"); + trimsec->x0 = trimsec->x1 = trimsec->y0 = trimsec->y1 = 0.0; + + return success; +} + + + +// Mosaic a chip together into a single image +int pmChipMosaic(pmChip *chip,// Chip to mosaic + int xBinChip, int yBinChip // Binning of mosaic image in x and y + ) +{ + + psArray *cells = chip->cells; // The array of cells + psArray *images = psArrayAlloc(cells->n); // Array of images that will be mosaicked + psArray *weights = psArrayAlloc(cells->n); // Array of weight images to be mosaicked + psArray *masks = psArrayAlloc(cells->n); // Array of mask images to be mosaicked + psVector *x0 = psVectorAlloc(cells->n, PS_TYPE_S32); // Origin x coordinates + psVector *y0 = psVectorAlloc(cells->n, PS_TYPE_S32); // Origin y coordinates + psVector *xBin = psVectorAlloc(cells->n, PS_TYPE_S32); // Binning in x + psVector *yBin = psVectorAlloc(cells->n, PS_TYPE_S32); // Binning in y + psVector *xFlip = psVectorAlloc(cells->n, PS_TYPE_U8); // Flip in x? + psVector *yFlip = psVectorAlloc(cells->n, PS_TYPE_U8); // Flip in y? + + // Set up the required inputs + psTrace(__func__, 1, "Mosaicking %d cells...\n", cells->n); + for (int i = 0; i < cells->n; i++) { + pmCell *cell = cells->data[i]; // The cell of interest + if (!cell) { + continue; + } + x0->data.S32[i] = psMetadataLookupS32(NULL, cell->concepts, "CELL.X0"); + y0->data.S32[i] = psMetadataLookupS32(NULL, cell->concepts, "CELL.Y0"); + psTrace(__func__, 5, "Cell %d: x0=%d y0=%d\n", i, x0->data.S32[i], y0->data.S32[i]); + xBin->data.S32[i] = psMetadataLookupS32(NULL, cell->concepts, "CELL.XBIN"); + yBin->data.S32[i] = psMetadataLookupS32(NULL, cell->concepts, "CELL.XBIN"); + int xParity = psMetadataLookupS32(NULL, cell->concepts, "CELL.XPARITY"); + int yParity = psMetadataLookupS32(NULL, cell->concepts, "CELL.YPARITY"); + if (xParity == 1) { + xFlip->data.U8[i] = 0; + } else if (xParity == -1) { + xFlip->data.U8[i] = 1; + } else { + psLogMsg(__func__, PS_LOG_WARN, "The x parity of cell %d is not +/- 1 (it's %d) --- " + "assuming +1.\n", i, xParity); + xFlip->data.U8[i] = 0; + } + if (yParity == 1) { + yFlip->data.U8[i] = 0; + } else if (yParity == -1) { + yFlip->data.U8[i] = 1; + } else { + psLogMsg(__func__, PS_LOG_WARN, "The y parity of cell %d is not +/- 1 (it's %d) --- " + "assuming +1.\n", i, yParity); + yFlip->data.U8[i] = 0; + } + + psArray *readouts = cell->readouts; // The array of readouts + if (readouts->n > 1) { + psLogMsg(__func__, PS_LOG_WARN, "Cell %d contains more than one readout --- only the first will " + "be mosaicked.\n", i); + } + pmReadout *readout = readouts->data[0]; // The only readout we'll bother with + + // The images to put into the mosaic + images->data[i] = psMemIncrRefCounter(readout->image); + weights->data[i] = psMemIncrRefCounter(readout->weight); + masks->data[i] = psMemIncrRefCounter(readout->mask); + } + // Mosaic the images together and we're done + psImage *image = p_pmImageMosaic(images, xFlip, yFlip, xBin, yBin, xBinChip, yBinChip, x0, y0); + psImage *weight = p_pmImageMosaic(weights, xFlip, yFlip, xBin, yBin, xBinChip, yBinChip, x0, y0); + psImage *mask = p_pmImageMosaic(masks, xFlip, yFlip, xBin, yBin, xBinChip, yBinChip, x0, y0); + + // Clean up + psFree(x0); + psFree(y0); + psFree(xBin); + psFree(yBin); + psFree(xFlip); + psFree(yFlip); + psFree(images); + psFree(weights); + psFree(masks); + int nCells = cells->n; + + // Fix up the HDU + if (chip->parent->hdu) { + psLogMsg(__func__, PS_LOG_WARN, "The original format has the entire FPA in a single extension. " + "The FPA hierarchy may be invalid following the pmChipMosaic.\n"); + } else { + if (! chip->hdu) { + psString chipName = psMetadataLookupStr(NULL, chip->concepts, "CHIP.NAME"); + chip->hdu = p_pmHDUAlloc(chipName); + } + p_pmHDU *hdu = chip->hdu; + psArrayElementsFree(hdu->images); + psArrayElementsFree(hdu->weights); + psArrayElementsFree(hdu->masks); + hdu->images = psArrayRealloc(hdu->images,1); + hdu->weights = psArrayRealloc(hdu->weights, 1); + hdu->masks = psArrayRealloc(hdu->masks, 1); + hdu->images->data[0] = image; + hdu->weights->data[0] = weight; + hdu->masks->data[0] = mask; + psMetadataAddS32(hdu->header, PS_LIST_TAIL, "NAXIS1", PS_META_REPLACE, "Number of columns", image->numCols); + psMetadataAddS32(hdu->header, PS_LIST_TAIL, "NAXIS2", PS_META_REPLACE, "Number of rows", image->numRows); + } + + // Chop off all the component cells, and construct a new one + pmCell *newCell = pmCellAlloc(NULL, NULL, __func__); // New cell + cellConcepts(newCell, cells, xBinChip, yBinChip); + pmChipFreeCells(chip); + // Have to put in the new cell manually, since we didn't want to put it in before blowing the cells away. + newCell->parent = chip; + psArrayAdd(chip->cells, 1, newCell); + newCell->exists = true; + newCell->process = true; + + // Now make a new readout to go in the new cell + pmReadout *newReadout = pmReadoutAlloc(newCell); // New readout + // Want the readouts to contain a subimage, but that subimage is the whole image. + // This preserves the relationship there was before, where freeing the parent frees the child. + psRegion entire = {0.0, 0.0, 0.0, 0.0}; + newReadout->image = psMemIncrRefCounter(psImageSubset(image, entire)); + newReadout->weight = psMemIncrRefCounter(psImageSubset(weight, entire)); + newReadout->mask = psMemIncrRefCounter(psImageSubset(mask, entire)); + // Drop references + psFree(newReadout); + psFree(newCell); + + // Well, we've stuffed around with the camera configuration, so it's no longer valid... + #if 0 + + psFree(chip->parent->camera); + chip->parent->camera = NULL; + #endif + + return nCells; +} + + +int pmFPAMosaicCells(pmFPA *fpa, // FPA + int xBinChip, int yBinChip // Binning of mosaic image in x and y + ) +{ + assert(fpa); + + int numChips = 0; + psArray *chips = fpa->chips; // Component chips + for (int i = 0; i < chips->n; i++) { + pmChip *chip = chips->data[i]; // The chip of interest + if (! chip || ! chip->exists || ! chip->process) { + continue; + } + + numChips++; + pmChipMosaic(chip, xBinChip, yBinChip); // Mosaic of cells within the chip + + } + + return numChips; + +} Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/astrom/pmChipMosaic.h =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/astrom/pmChipMosaic.h (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/astrom/pmChipMosaic.h (revision 21664) @@ -0,0 +1,26 @@ +#ifndef PM_CHIP_MOSAIC_H +#define PM_CHIP_MOSAIC_H + +#include "pslib.h" +#include "pmFPA.h" + +// Mosaic multiple images, with flips, binning and offsets +psImage *p_pmImageMosaic(const psArray *source, // Images to splice in + const psVector *xFlip, const psVector *yFlip, // Need to flip x and y? + const psVector *xBinSource, const psVector *yBinSource, // Binning in x and y of + // source images + int xBinTarget, int yBinTarget, // Binning in x and y of target images + const psVector *x0, const psVector *y0 // Offsets for source images on target + ); + +// Mosaic a chip together into a single cell with single readout +int pmChipMosaic(pmChip *chip,// Chip to mosaic + int xBinChip, int yBinChip // Binning of mosaic image in x and y + ); + +// Mosaic all the cells in all (valid) chips together (neglecting the overscans); return number of chips +int pmFPAMosaicCells(pmFPA *fpa, // FPA + int xBinChip, int yBinChip // Binning of mosaic image in x and y + ); + +#endif Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/astrom/pmConcepts.c =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/astrom/pmConcepts.c (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/astrom/pmConcepts.c (revision 21664) @@ -0,0 +1,576 @@ +// XXX *REALLY* need generic "concept update" and "concept read" functions that handles the type transparently + +#include +#include + +#include "pslib.h" +#include "pmConcepts.h" +#include "pmConceptsRead.h" +#include "pmConceptsWrite.h" +#include "pmConceptsStandard.h" +#include "psAdditionals.h" + +static bool conceptsInitialised = false;// Have concepts been read? +static psMetadata *conceptsFPA = NULL; // Known concepts for FPA +static psMetadata *conceptsChip = NULL; // Known concepts for chip +static psMetadata *conceptsCell = NULL; // Known concepts for cell + +// Free a concept +static void conceptSpecFree(pmConceptSpec *spec) +{ + psFree(spec->blank); +} + +pmConceptSpec *pmConceptSpecAlloc(psMetadataItem *blank, // Blank value; contains the name + pmConceptReadFunc read, // Function to call to read the concept + pmConceptWriteFunc write // Function to call to write the concept + ) +{ + pmConceptSpec *spec = psAlloc(sizeof(pmConceptSpec)); + psMemSetDeallocator(spec, (psFreeFunc)conceptSpecFree); + + spec->blank = psMemIncrRefCounter(blank); + spec->read = read; + spec->write = write; + + return spec; +} + + +bool pmConceptRegister(psMetadataItem *blank, // Blank value; contains the name + pmConceptReadFunc read, // Function to call to read the concept + pmConceptWriteFunc write, // Function to call to write the concept + pmConceptLevel level // Level at which to store concept in the FPA hierarchy + ) +{ + assert(blank); + if (!conceptsInitialised) { + pmConceptsInit(); + } + + pmConceptSpec *spec = pmConceptSpecAlloc(blank, read, write); // The concept specification + psMetadata **target = NULL; // The metadata of known concepts to write to + switch (level) { + case PM_CONCEPT_LEVEL_FPA: + target = &conceptsFPA; + break; + case PM_CONCEPT_LEVEL_CHIP: + target = &conceptsChip; + break; + case PM_CONCEPT_LEVEL_CELL: + target = &conceptsCell; + break; + default: + psError(PS_ERR_IO, true, "Unknown concept level provided: %d\n", level); + psFree(spec); + return false; + } + + psMetadataAdd(*target, PS_LIST_TAIL, blank->name, PS_DATA_UNKNOWN | PS_META_REPLACE, + "Concepts specification", spec); + psFree(spec); // Drop reference + + return true; +} + +// This function gets called for the really boring concepts --- where all you have to do is read from a header +// or database and you don't need to muck around with conversions. +// There is no similar "writePlain", since the type is already known. +static psMetadataItem *readPlain(psMetadataItem *blank, // The blank value with name, comment, type + pmFPA *fpa, // The FPA of interest + pmChip *chip, // The Chip of interest + pmCell *cell, // The cell of interest + psDB *db // Database handle + ) +{ + switch (blank->type) { + case PS_DATA_STRING: { + psString string = pmConceptReadString(fpa, chip, cell, db, blank->name); + psMetadataItem *item = psMetadataItemAllocStr(blank->name, blank->comment, string); + psFree(string); + return item; + } + case PS_DATA_S32: + return psMetadataItemAllocS32(blank->name, blank->comment, + pmConceptReadS32(fpa, chip, cell, db, blank->name)); + case PS_DATA_F32: + return psMetadataItemAllocF32(blank->name, blank->comment, + pmConceptReadF32(fpa, chip, cell, db, blank->name)); + case PS_DATA_F64: + return psMetadataItemAllocF64(blank->name, blank->comment, + pmConceptReadF64(fpa, chip, cell, db, blank->name)); + default: + psLogMsg(__func__, PS_LOG_WARN, "Concept %s (%s) is not of a standard type (%x)\n", + blank->name, blank->comment, blank->type); + } + return NULL; +} + +// Set all registered concepts to blank value for the specified level +static bool conceptsBlank(psMetadata **specs, // One of the concepts specifications + psMetadata *target // Place to install the concepts + ) +{ + if (!conceptsInitialised) { + pmConceptsInit(); + } + psMetadataIterator *specsIter = psMetadataIteratorAlloc(*specs, PS_LIST_HEAD, NULL); // Iterator on specs + psMetadataItem *specItem = NULL; // Item from the specs metadata + while ((specItem = psMetadataGetAndIncrement(specsIter))) { + psTrace(__func__, 9, "Blanking %s...\n", specItem->name); + pmConceptSpec *spec = specItem->data.V; // The specification + psMetadataItem *blank = spec->blank; // The concept + psMetadataAddItem(target, blank, PS_LIST_TAIL, PS_META_REPLACE); + } + psFree(specsIter); + + return true; +} + +// Read all registered concepts for the specified level +static bool conceptsRead(psMetadata **specs, // One of the concepts specifications + pmFPA *fpa, // The FPA + pmChip *chip, // The chip + pmCell *cell, // The cell + psDB *db, // Database handle + psMetadata *target // Place into which to read the concepts + ) +{ + if (!conceptsInitialised) { + pmConceptsInit(); + } + psMetadataIterator *specsIter = psMetadataIteratorAlloc(*specs, PS_LIST_HEAD, NULL); // Iterator on specs + psMetadataItem *specItem = NULL; // Item from the specs metadata + while ((specItem = psMetadataGetAndIncrement(specsIter))) { + pmConceptSpec *spec = specItem->data.V; // The specification + psMetadataItem *conceptItem = NULL; // The item to add to the concepts + if (spec->read) { + conceptItem = spec->read(fpa, chip, cell, db); + } else { + conceptItem = readPlain(spec->blank, fpa, chip, cell, db); + if (conceptItem->type != spec->blank->type) { + psLogMsg(__func__, PS_LOG_ERROR, "Type of concept %s following read (%x) does not match " + "blank type (%x).\n", spec->blank->name, conceptItem->type, spec->blank->type); + } + } + psMetadataAddItem(target, conceptItem, PS_LIST_TAIL, PS_META_REPLACE); + psFree(conceptItem); // Drop reference + } + psFree(specsIter); + return true; +} + +// Write all registered concepts for the specified level +static bool conceptsWrite(psMetadata **specs, // One of the concepts specifications + pmFPA *fpa, // The FPA + pmChip *chip, // The chip + pmCell *cell, // The cell + psDB *db, // Database handle + psMetadata *source // The concepts to write out + ) +{ + if (!conceptsInitialised) { + pmConceptsInit(); + } + if (! fpa->camera) { + return false; + } + psMetadataIterator *iter = psMetadataIteratorAlloc(source, PS_LIST_HEAD, NULL); // Iterator on concepts + psMetadataItem *item = NULL; // Item from the concepts + while ((item = psMetadataGetAndIncrement(iter))) { + const char *name = item->name; // Name of the concept + if (!strcmp(name, "CELL.NAME") || !strcmp(name, "CHIP.NAME")) { + // These concepts are not written out; they are set from things like the FITS extname + continue; + } + psMetadataItem *specItem = psMetadataLookup(*specs, name); // Specification for the concept + if (specItem) { + pmConceptSpec *spec = specItem->data.V; // The specification + if (spec->write) { + spec->write(fpa, chip, cell, db); // The concept + } else { + pmConceptWrite(fpa, chip, cell, db, source, spec->blank->name); + } + } else { + psLogMsg(__func__, PS_LOG_WARN, "Unable to find specification to write concept %s in FPA\n", + name); + } + } + psFree(iter); + + return true; +} + +// Set the concepts for a given FPA to blanks +bool pmConceptsBlankFPA(pmFPA *fpa // FPA for which to set blank concepts + ) +{ + psTrace("psModule.concepts", 5, "Blanking FPA concepts: %x %x\n", conceptsFPA, fpa->concepts); + return conceptsBlank(&conceptsFPA, fpa->concepts); +} + +// Read the concepts for a given FPA +bool pmConceptsReadFPA(pmFPA *fpa, // FPA for which to read concepts + psDB *db // Database handle + ) +{ + psTrace("psModule.concepts", 5, "Reading FPA concepts: %x %x\n", conceptsFPA, fpa->concepts); + return conceptsRead(&conceptsFPA, fpa, NULL, NULL, db, fpa->concepts); +} + +// Read the concepts for a given FPA +bool pmConceptsWriteFPA(pmFPA *fpa, // FPA for which to write concepts + psDB *db // Database handle + ) +{ + psTrace("psModule.concepts", 5, "Writing FPA concepts: %x %x\n", conceptsFPA, fpa->concepts); + return conceptsWrite(&conceptsFPA, fpa, NULL, NULL, db, fpa->concepts); +} + +// Set the concepts for a given chip to blanks +bool pmConceptsBlankChip(pmChip *chip // FPA for which to set blank concepts + ) +{ + psTrace("psModule.concepts", 5, "Blanking chip concepts: %x %x\n", conceptsChip, chip->concepts); + return conceptsBlank(&conceptsChip, chip->concepts); +} + +// Read the concepts for a given FPA +bool pmConceptsReadChip(pmChip *chip, // Chip for which to read concepts + psDB *db // Database handle + ) +{ + psTrace("psModule.concepts", 5, "Reading chip concepts: %x %x\n", conceptsChip, chip->concepts); + pmFPA *fpa = chip->parent; // FPA to which the chip belongs + return conceptsRead(&conceptsChip, fpa, chip, NULL, db, chip->concepts); +} + +// Read the concepts for a given FPA +bool pmConceptsWriteChip(pmChip *chip, // Chip for which to write concepts + psDB *db // Database handle + ) +{ + psTrace("psModule.concepts", 5, "Writing chip concepts: %x %x\n", conceptsChip, chip->concepts); + pmFPA *fpa = chip->parent; // FPA to which the chip belongs + return conceptsWrite(&conceptsChip, fpa, chip, NULL, db, chip->concepts); +} + +// Set the concepts for a given chip to blanks +bool pmConceptsBlankCell(pmCell *cell // Cell for which to set blank concepts + ) +{ + psTrace("psModule.concepts", 5, "Blanking cell concepts: %x %x\n", conceptsCell, cell->concepts); + return conceptsBlank(&conceptsCell, cell->concepts); +} + +// Read the concepts for a given FPA +bool pmConceptsReadCell(pmCell *cell, // Cell for which to read concepts + psDB *db // Database handle + ) +{ + psTrace("psModule.concepts", 5, "Writing cell concepts: %x %x\n", conceptsCell, cell->concepts); + pmChip *chip = cell->parent; // Chip to which the cell belongs + pmFPA *fpa = chip->parent; // FPA to which the chip belongs + return conceptsRead(&conceptsCell, fpa, chip, cell, db, cell->concepts); +} + +// Read the concepts for a given FPA +bool pmConceptsWriteCell(pmCell *cell, // FPA for which to write concepts + psDB *db // Database handle + ) +{ + psTrace("psModule.concepts", 5, "Writing cell concepts: %x %x\n", conceptsCell, cell->concepts); + pmChip *chip = cell->parent; // Chip to which the cell belongs + pmFPA *fpa = chip->parent; // FPA to which the chip belongs + return conceptsWrite(&conceptsCell, fpa, chip, cell, db, cell->concepts); +} + + +bool pmConceptsInit(void) +{ + bool init = false; // Did we initialise anything? + if (! conceptsFPA) { + conceptsFPA = psMetadataAlloc(); + init = true; + + // Install the standard concepts + + // FPA.NAME + { + psMetadataItem *fpaName = psMetadataItemAllocStr("FPA.NAME", "Name of FPA", ""); + pmConceptRegister(fpaName, NULL, NULL, PM_CONCEPT_LEVEL_FPA); + psFree(fpaName); + } + + // FPA.AIRMASS + { + psMetadataItem *fpaAirmass = psMetadataItemAllocF32("FPA.AIRMASS", "Airmass at boresight", 0.0); + pmConceptRegister(fpaAirmass, NULL, NULL, PM_CONCEPT_LEVEL_FPA); + psFree(fpaAirmass); + } + + // FPA.FILTER + { + psMetadataItem *fpaFilter = psMetadataItemAllocStr("FPA.FILTER", "Filter used", ""); + pmConceptRegister(fpaFilter, NULL, NULL, PM_CONCEPT_LEVEL_FPA); + psFree(fpaFilter); + } + + // FPA.POSANGLE + { + psMetadataItem *fpaPosangle = psMetadataItemAllocF32("FPA.POSANGLE", + "Position angle of instrument", 0.0); + pmConceptRegister(fpaPosangle, NULL, NULL, PM_CONCEPT_LEVEL_FPA); + psFree(fpaPosangle); + } + + // FPA.RADECSYS + { + psMetadataItem *fpaRadecsys = psMetadataItemAllocStr("FPA.RADECSYS", + "Celestial coordinate system", ""); + pmConceptRegister(fpaRadecsys, NULL, NULL, PM_CONCEPT_LEVEL_FPA); + psFree(fpaRadecsys); + } + + // FPA.RA + { + psMetadataItem *fpaRa = psMetadataItemAllocF64("FPA.RA", "Right Ascension of boresight", NAN); + pmConceptRegister(fpaRa, (pmConceptReadFunc)pmConceptRead_FPA_RA, + (pmConceptWriteFunc)pmConceptWrite_FPA_RA, PM_CONCEPT_LEVEL_FPA); + psFree(fpaRa); + } + + // FPA.DEC + { + psMetadataItem *fpaDec = psMetadataItemAllocF64("FPA.DEC", "Declination of boresight", NAN); + pmConceptRegister(fpaDec, (pmConceptReadFunc)pmConceptRead_FPA_DEC, + (pmConceptWriteFunc)pmConceptWrite_FPA_DEC, PM_CONCEPT_LEVEL_FPA); + psFree(fpaDec); + } + + // Done with FPA level concepts + } + if (! conceptsChip) { + conceptsChip = psMetadataAlloc(); + init = true; + // There are no standard concepts at the chip level to be installed + } + if (! conceptsCell) { + conceptsCell = psMetadataAlloc(); + init = true; + + // Install the standard concepts + + // CELL.GAIN + { + psMetadataItem *cellGain = psMetadataItemAllocF32("CELL.GAIN", "CCD gain (e/count)", NAN); + pmConceptRegister(cellGain, NULL, NULL, PM_CONCEPT_LEVEL_CELL); + psFree(cellGain); + } + + // CELL.READNOISE + { + psMetadataItem *cellReadnoise = psMetadataItemAllocF32("CELL.READNOISE", + "CCD read noise (e)", NAN); + pmConceptRegister(cellReadnoise, NULL, NULL, PM_CONCEPT_LEVEL_CELL); + psFree(cellReadnoise); + } + + // CELL.SATURATION + { + psMetadataItem *cellSaturation = psMetadataItemAllocF32("CELL.SATURATION", + "Saturation level (counts)", NAN); + pmConceptRegister(cellSaturation, NULL, NULL, PM_CONCEPT_LEVEL_CELL); + psFree(cellSaturation); + } + + // CELL.BAD + { + psMetadataItem *cellBad = psMetadataItemAllocF32("CELL.BAD", "Bad level (counts)", NAN); + pmConceptRegister(cellBad, NULL, NULL, PM_CONCEPT_LEVEL_CELL); + psFree(cellBad); + } + + // CELL.XPARITY + { + psMetadataItem *cellXparity = psMetadataItemAllocS32("CELL.XPARITY", + "Orientation in x compared to the rest of the FPA", 0); + pmConceptRegister(cellXparity, NULL, NULL, PM_CONCEPT_LEVEL_CELL); + psFree(cellXparity); + } + + // CELL.YPARITY + { + psMetadataItem *cellYparity = psMetadataItemAllocS32("CELL.YPARITY", + "Orientation in x compared to the rest of the FPA", 0); + pmConceptRegister(cellYparity, NULL, NULL, PM_CONCEPT_LEVEL_CELL); + psFree(cellYparity); + } + + // CELL.READDIR + { + psMetadataItem *cellReaddir = psMetadataItemAllocS32("CELL.READDIR", + "Read direction, rows=1, cols=2", 1); + pmConceptRegister(cellReaddir, NULL, NULL, PM_CONCEPT_LEVEL_CELL); + psFree(cellReaddir); + } + + + // These (CELL.EXPOSURE and CELL.DARKTIME) used to be READOUT.EXPOSURE and READOUT.DARKTIME, but that + // doesn't really make sense at the moment. Maybe we need to add a "parent" link to the readouts. + // But then how are the exposure times REALLY derived? They're not in the FITS headers, because a + // readout is a plane in a 3D image. We'll have to dream up some additional suffix to specify these, + // but for now.... + + // CELL.EXPOSURE + { + psMetadataItem *cellExposure = psMetadataItemAllocF32("CELL.EXPOSURE", + "Exposure time (sec)", NAN); + pmConceptRegister(cellExposure, NULL, NULL, PM_CONCEPT_LEVEL_CELL); + psFree(cellExposure); + } + + // CELL.DARKTIME + { + psMetadataItem *cellDarktime = psMetadataItemAllocF32("CELL.DARKTIME", + "Time since flush (sec)", NAN); + pmConceptRegister(cellDarktime, NULL, NULL, PM_CONCEPT_LEVEL_CELL); + psFree(cellDarktime); + } + + // CELL.TRIMSEC + { + psRegion *trimsec = psAlloc(sizeof(psRegion)); // Blank trimsec + trimsec->x0 = trimsec->y0 = trimsec->x1 = trimsec->y1 = NAN; + psMetadataItem *cellTrimsec = psMetadataItemAllocPtr("CELL.TRIMSEC", PS_DATA_UNKNOWN, + "Trim section", trimsec); + psFree(trimsec); + pmConceptRegister(cellTrimsec, (pmConceptReadFunc)pmConceptRead_CELL_TRIMSEC, + (pmConceptWriteFunc)pmConceptWrite_CELL_TRIMSEC, PM_CONCEPT_LEVEL_CELL); + psFree(cellTrimsec); + } + + // CELL.BIASSEC + { + psList *biassecs = psListAlloc(NULL); // Blank biassecs + psMetadataItem *cellBiassec = psMetadataItemAllocPtr("CELL.BIASSEC", PS_DATA_LIST, + "Bias sections", biassecs); + psFree(biassecs); + pmConceptRegister(cellBiassec, (pmConceptReadFunc)pmConceptRead_CELL_BIASSEC, + (pmConceptWriteFunc)pmConceptWrite_CELL_BIASSEC, PM_CONCEPT_LEVEL_CELL); + psFree(cellBiassec); + } + + // CELL.XBIN + { + psMetadataItem *cellXbin = psMetadataItemAllocS32("CELL.XBIN", "Binning in x", 0); + pmConceptRegister(cellXbin, (pmConceptReadFunc)pmConceptRead_CELL_XBIN, + (pmConceptWriteFunc)pmConceptWrite_CELL_XBIN, PM_CONCEPT_LEVEL_CELL); + psFree(cellXbin); + } + + // CELL.YBIN + { + psMetadataItem *cellYbin = psMetadataItemAllocS32("CELL.YBIN", "Binning in y", 0); + pmConceptRegister(cellYbin, (pmConceptReadFunc)pmConceptRead_CELL_YBIN, + (pmConceptWriteFunc)pmConceptWrite_CELL_YBIN, PM_CONCEPT_LEVEL_CELL); + psFree(cellYbin); + } + + // CELL.TIMESYS + { + psMetadataItem *cellTimesys = psMetadataItemAllocS32("CELL.TIMESYS", "Time system", -1); + pmConceptRegister(cellTimesys, (pmConceptReadFunc)pmConceptRead_CELL_TIMESYS, + (pmConceptWriteFunc)pmConceptWrite_CELL_TIMESYS, PM_CONCEPT_LEVEL_CELL); + psFree(cellTimesys); + } + + // CELL.TIME + { + psTime *time = psTimeAlloc(PS_TIME_TAI); // Blank time + // Not particularly distinguishing, but should be good enough + time->sec = 0; + time->nsec = 0; + psMetadataItem *cellTime = psMetadataItemAlloc("CELL.TIME", PS_DATA_TIME, + "Time of exposure", time); + psFree(time); + pmConceptRegister(cellTime, (pmConceptReadFunc)pmConceptRead_CELL_TIME, + (pmConceptWriteFunc)pmConceptWrite_CELL_TIME, PM_CONCEPT_LEVEL_CELL); + psFree(cellTime); + } + + // CELL.X0 + { + psMetadataItem *cellX0 = psMetadataItemAllocS32("CELL.X0", "Position of (0,0) on the chip", 0); + pmConceptRegister(cellX0, (pmConceptReadFunc)pmConceptRead_CELL_X0, + (pmConceptWriteFunc)pmConceptWrite_CELL_X0, PM_CONCEPT_LEVEL_CELL); + psFree(cellX0); + } + + // CELL.Y0 + { + psMetadataItem *cellY0 = psMetadataItemAllocS32("CELL.Y0", "Position of (0,0) on the chip", 0); + pmConceptRegister(cellY0, (pmConceptReadFunc)pmConceptRead_CELL_Y0, + (pmConceptWriteFunc)pmConceptWrite_CELL_Y0, PM_CONCEPT_LEVEL_CELL); + psFree(cellY0); + } + + } + + conceptsInitialised = true; + + return init; +} + +void pmConceptsDone(void) +{ + psFree(conceptsFPA); + psFree(conceptsChip); + psFree(conceptsCell); +} + + +// Copy concepts from one FPA to another +bool pmFPACopyConcepts(pmFPA *target, // The target FPA + pmFPA *source // The target FPA + ) +{ + // Copy FPA concepts + target->concepts = pap_psMetadataCopy(target->concepts, source->concepts); + + // Copy chip concepts + psArray *targetChips = target->chips; // Chips in target + psArray *sourceChips = source->chips; // Chips in source + if (targetChips->n != sourceChips->n) { + psError(PS_ERR_IO, true, "Number of chips in target (%d) and source (%d) differ --- unable to copy " + "concepts.\n", targetChips->n, sourceChips->n); + return false; + } + for (int i = 0; i < targetChips->n; i++) { + pmChip *targetChip = targetChips->data[i]; // Target chip of interest + pmChip *sourceChip = sourceChips->data[i]; // Source chip of interest + if (! targetChip || ! sourceChip) { + continue; + } + targetChip->concepts = pap_psMetadataCopy(targetChip->concepts, sourceChip->concepts); + + // Copy cell concepts + psArray *targetCells = targetChip->cells; // Cells in target + psArray *sourceCells = sourceChip->cells; // Cells in source + if (targetCells->n != sourceCells->n) { + psError(PS_ERR_IO, true, "Number of cells in target (%d) and source (%d) differ for chip %d ---" + " unable to copy concepts.\n", targetCells->n, sourceCells->n, i); + return false; + } + for (int j = 0; j < targetCells->n; j++) { + pmCell *targetCell = targetCells->data[j]; // Target chip of interest + pmCell *sourceCell = sourceCells->data[j]; // Source chip of interest + if (! targetCell || ! sourceCell) { + continue; + } + targetCell->concepts = pap_psMetadataCopy(targetCell->concepts, sourceCell->concepts); + } + } + + return true; +} Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/astrom/pmConcepts.h =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/astrom/pmConcepts.h (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/astrom/pmConcepts.h (revision 21664) @@ -0,0 +1,79 @@ +#ifndef PM_CONCEPTS_H +#define PM_CONCEPTS_H + +#include "pslib.h" + +#include "pmFPA.h" + +// Function to call to read a concept +typedef psMetadataItem* (*pmConceptReadFunc)(pmFPA *fpa, pmChip *chip, pmCell *cell, psDB *db); +// Function to call to write a concept +typedef bool (*pmConceptWriteFunc)(pmFPA *fpa, pmChip *chip, pmCell *cell, psDB *db); + +// A "concept" specification +typedef struct +{ + psMetadataItem *blank; // Blank value of concept; also contains the name + pmConceptReadFunc read; // Function to call to read the concept + pmConceptWriteFunc write; // Function to call to write the concept +} +pmConceptSpec; + +// Allocator +pmConceptSpec *pmConceptSpecAlloc(psMetadataItem *blank, // Blank value; contains the name + pmConceptReadFunc read, // Function to call to read the concept + pmConceptWriteFunc write // Function to call to write the concept + ); + +// Level at which to store a concept in the FPA hierarchy +typedef enum { + PM_CONCEPT_LEVEL_FPA, // Store in the FPA + PM_CONCEPT_LEVEL_CHIP, // Store in the chip + PM_CONCEPT_LEVEL_CELL // Store in the cell +} pmConceptLevel; + +// Register a new concept +bool pmConceptRegister(psMetadataItem *blank, // Blank value; contains the name + pmConceptReadFunc read, // Function to call to read the concept + pmConceptWriteFunc write, // Function to call to write the concept + pmConceptLevel level // Level at which to store concept in the FPA hierarchy + ); + +// Set blanks, read or write concepts at the appropriate level +bool pmConceptsBlankFPA(pmFPA *fpa // FPA for which to set blank concepts + ); +bool pmConceptsReadFPA(pmFPA *fpa, // FPA for which to read concepts + psDB *db // Database handle + ); +bool pmConceptsWriteFPA(pmFPA *fpa, // FPA for which to write concepts + psDB *db // Database handle + ); +bool pmConceptsBlankChip(pmChip *chip // FPA for which to set blank concepts + ); +bool pmConceptsReadChip(pmChip *chip, // Chip for which to read concepts + psDB *db // Database handle + ); +bool pmConceptsWriteChip(pmChip *chip, // Chip for which to write concepts + psDB *db // Database handle + ); +bool pmConceptsBlankCell(pmCell *cell // Cell for which to set blank concepts + ); +bool pmConceptsReadCell(pmCell *cell, // Cell for which to read concepts + psDB *db // Database handle + ); +bool pmConceptsWriteCell(pmCell *cell, // FPA for which to write concepts + psDB *db // Database handle + ); + +// Set up the blank concepts +bool pmConceptsInit(void); +// Free the concept specs so there's no memory leak +void pmConceptsDone(void); + +// Copy all the concepts within an FPA to another FPA +bool pmFPACopyConcepts(pmFPA *target, // The target FPA + pmFPA *source // The target FPA + ); + + +#endif Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/astrom/pmConceptsRead.c =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/astrom/pmConceptsRead.c (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/astrom/pmConceptsRead.c (revision 21664) @@ -0,0 +1,387 @@ +#include + +#include "pslib.h" + +#include "pmFPA.h" +#include "pmConceptsRead.h" +#include "psAdditionals.h" + + +psMetadataItem *pmConceptReadFromCamera(pmCell *cell, // The cell + const char *concept // Name of concept + ) +{ + if (cell) { + psMetadata *camera = cell->camera; // Camera data + psMetadataItem *item = psMetadataLookup(camera, concept); + return item; + } + return NULL; +} + +psMetadataItem *pmConceptReadFromHeader(pmFPA *fpa, // The FPA that contains the chip + pmChip *chip, // The chip that contains the cell + pmCell *cell, // The cell + const char *concept // Name of concept + ) +{ + bool mdStatus = true; // Status of MD lookup + psMetadata *translation = psMetadataLookupMD(&mdStatus, fpa->camera, "TRANSLATION"); // FITS translation + if (! mdStatus) { + psError(PS_ERR_IO, false, "Unable to find TRANSLATION in camera configuration.\n"); + return NULL; + } + + // Look for how to translate the concept into a FITS header name + const char *keyword = psMetadataLookupStr(&mdStatus, translation, concept); + if (mdStatus && strlen(keyword) > 0) { + // We have a FITS header to look up --- search each level + if (cell && cell->hdu) { + psMetadataItem *cellItem = psMetadataLookup(cell->hdu->header, keyword); + if (cellItem) { + // XXX: Need to clean up before returning + return cellItem; + } + } + + if (chip && chip->hdu) { + psMetadataItem *chipItem = psMetadataLookup(chip->hdu->header, keyword); + if (chipItem) { + // XXX: Need to clean up before returning + return chipItem; + } + } + + if (fpa->hdu) { + psMetadataItem *fpaItem = psMetadataLookup(fpa->hdu->header, keyword); + if (fpaItem) { + // XXX: Need to clean up before returning + return fpaItem; + } + } + + if (fpa->phu) { + psMetadataItem *fpaItem = psMetadataLookup(fpa->phu, keyword); + if (fpaItem) { + // XXX: Need to clean up before returning + return fpaItem; + } + } + } + + // No header value + return NULL; +} + + +// Look for a default +psMetadataItem *pmConceptReadFromDefault(pmFPA *fpa, // The FPA that contains the chip + pmChip *chip, // The chip that contains the cell + pmCell *cell, // The cell + const char *concept // Name of concept + ) +{ + bool mdOK = true; // Status of MD lookup + psMetadata *defaults = psMetadataLookupMD(&mdOK, fpa->camera, "DEFAULTS"); + if (! mdOK) { + psError(PS_ERR_IO, false, "Unable to find DEFAULTS in camera configuration.\n"); + return NULL; + } + + psMetadataItem *defItem = psMetadataLookup(defaults, concept); + if (defItem) { + if (defItem->type == PS_DATA_METADATA) { + // A dependent default + psTrace(__func__, 7, "Evaluating dependent default....\n"); + psMetadata *dependents = defItem->data.V; // The list of dependents + // Find out what it depends on + psString dependName = psStringCopy(concept); + psStringAppend(&dependName, ".DEPEND"); + psString dependsOn = psMetadataLookupStr(&mdOK, defaults, dependName); + if (! mdOK) { + psError(PS_ERR_IO, false, "Unable to find %s in camera configuration for dependent default" + " --- ignored\n", dependName); + // XXX: Need to clean up before returning + return NULL; + } + psFree(dependName); + // Find the value of the dependent concept + psMetadataItem *depItem = pmConceptReadFromHeader(fpa, chip, cell, dependsOn); + if (! depItem) { + psError(PS_ERR_IO, true, "Unable to find value for %s (required for %s)\n", dependsOn, + concept); + return NULL; + } + if (depItem->type != PS_DATA_STRING) { + psError(PS_ERR_IO, true, "Value of %s is not of type string, as required for dependency" + " --- ignored.\n", dependsOn); + } + + defItem = psMetadataLookup(dependents, depItem->data.V); // This is now what we were after + } + } + + // XXX: Need to clean up before returning + return defItem; // defItem is either NULL or points to what was desired +} + + +// Look for a database lookup +// XXX: Not tested +psMetadataItem *pmConceptReadFromDB(pmFPA *fpa, // The FPA that contains the chip + pmChip *chip, // The chip that contains the cell + pmCell *cell, // The cell + psDB *db, // DB handle + const char *concept // Name of concept + ) +{ + if (! db) { + // No database initialised + return NULL; + } + + bool mdStatus = true; // Status of MD lookup + psMetadata *database = psMetadataLookupMD(&mdStatus, fpa->camera, "DATABASE"); + if (! mdStatus) { + // No error, because not everyone needs to use the DB + return NULL; + } + + psMetadata *dbLookup = psMetadataLookupMD(&mdStatus, database, concept); + if (dbLookup) { + const char *tableName = psMetadataLookupStr(&mdStatus, dbLookup, "TABLE"); // Name of the table + // const char *colName = psMetadataLookupStr(&mdStatus, dbLookup, "COLUMN"); // Name of the column + const char *givenCols = psMetadataLookupStr(&mdStatus, dbLookup, "GIVENDBCOL"); // Name of "where" + // columns + const char *givenPS = psMetadataLookupStr(&mdStatus, dbLookup, "GIVENPS"); // Values for "where" + // columns + + // Now, need to get the "given"s + if (strlen(givenCols) || strlen(givenPS)) { + psList *cols = psStringSplit(givenCols, ",;"); // List of column names + psList *values = psStringSplit(givenPS, ",;"); // List of value names for the columns + psMetadata *selection = psMetadataAlloc(); // The stuff to select in the DB + if (cols->n != values->n) { + psLogMsg(__func__, PS_LOG_WARN, "The GIVENDBCOL and GIVENPS entries for %s do not have " + "the same number of entries --- ignored.\n", concept); + } else { + // Iterators for the lists + psListIterator *colsIter = psListIteratorAlloc(cols, PS_LIST_HEAD, false); + psListIterator *valuesIter = psListIteratorAlloc(values, PS_LIST_HEAD, false); + char *column = NULL; // Name of the column + while ((column = psListGetAndIncrement(colsIter))) { + char *name = psListGetAndIncrement(valuesIter); // Name for the value + if (!strlen(column) || !strlen(name)) { + psLogMsg(__func__, PS_LOG_WARN, "One of the columns or value names for %s is " + " empty --- ignored.\n", concept); + } else { + // Search for the value name + psMetadataItem *item = pmConceptReadFromHeader(fpa, chip, cell, name); + if (! item) { + item = pmConceptReadFromDefault(fpa, chip, cell, name); + } + if (! item) { + psLogMsg(__func__, PS_LOG_ERROR, "Unable to find the value name %s for DB " + " lookup on %s --- ignored.\n", name, concept); + } else { + // We need to create a new psMetadataItem. I don't think we can't simply hack + // the existing one, since that could conceivably cause memory leaks + psMetadataItem *newItem = psMetadataItemAlloc(concept, item->type, + item->comment, item->data.V); + psMetadataAddItem(selection, newItem, PS_LIST_TAIL, PS_META_REPLACE); + psFree(newItem); + } + } + psFree(name); + psFree(column); + } // Iterating through the columns + psFree(colsIter); + psFree(valuesIter); + + psArray *dbResult = psDBSelectRows(db, tableName, selection, 2); // Lookup result + // Note that we use limit=2 in order to test if there are multiple rows returned + + psMetadataItem *result = NULL; // The final result of the DB lookup + if (dbResult->n == 0) { + psLogMsg(__func__, PS_LOG_WARN, "Unable to find any rows in DB for %s --- ignored\n", + concept); + } else { + if (dbResult-> n > 1) { + psLogMsg(__func__, PS_LOG_WARN, "Multiple rows returned in DB lookup for %s --- " + " using the first one only.\n", concept); + } + result = (psMetadataItem*)dbResult->data[0]; + } + // XXX: Need to clean up before returning + return result; + } + psFree(cols); + psFree(values); + } + } // Doing the "given"s. + + psAbort(__func__, "Shouldn't ever get here.\n"); + return NULL; +} + + +// Concept lookup +psMetadataItem *pmConceptRead(pmFPA *fpa, // The FPA + pmChip *chip,// The chip + pmCell *cell, // The cell + psDB *db, // DB handle + const char *name // Concept name + ) +{ + // Try headers, database, defaults in order + psMetadataItem *item = pmConceptReadFromCamera(cell, name); + if (! item) { + item = pmConceptReadFromHeader(fpa, chip, cell, name); + } + if (! item) { + item = pmConceptReadFromDB(fpa, chip, cell, db, name); + } + if (! item) { + item = pmConceptReadFromDefault(fpa, chip, cell, name); + } + return item; // item is either NULL, or points to what was desired +} + + +float pmConceptReadF32(pmFPA *fpa, // The FPA + pmChip *chip, // The chip + pmCell *cell, // The cell + psDB *db, // DB handle + const char *name // Name of the concept + ) +{ + psMetadataItem *item = pmConceptRead(fpa, chip, cell, db, name); + float value = NAN; + if (item) { + switch (item->type) { + case PS_DATA_F32: + value = item->data.F32; + break; + case PS_DATA_F64: + // Assume it's OK to truncate to floating point from double + value = (float)item->data.F64; + break; + case PS_DATA_S32: + // Promote to float + value = (float)item->data.S32; + break; + default: + psError(PS_ERR_IO, true, "Concept %s (%s) is not of floating point type (%x) --- treating as " + "undefined.\n", name, item->comment, item->type); + } + psTrace(__func__, 7, "Adding %s (%s): %f\n", name, item->comment, value); + } else { + psError(PS_ERR_IO, true, "Concept %s is not defined.\n", name); + } + + return value; +} + +double pmConceptReadF64(pmFPA *fpa, // The FPA + pmChip *chip, // The chip + pmCell *cell, // The cell + psDB *db, // DB handle + const char *name // Name of the concept + ) +{ + psMetadataItem *item = pmConceptRead(fpa, chip, cell, db, name); + double value = NAN; + if (item) { + switch (item->type) { + case PS_TYPE_F64: + value = item->data.F64; + break; + case PS_TYPE_F32: + // Promote to double + value = (double)item->data.F32; + break; + case PS_TYPE_S32: + // Promote to double + value = (double)item->data.S32; + break; + default: + psError(PS_ERR_IO, true, "Concept %s (%s) is not of double-precision floating point type (%x) " + "--- treating as undefined.\n", name, item->comment, item->type); + } + psTrace(__func__, 7, "Adding %s (%s): %f\n", name, item->comment, value); + } else { + psError(PS_ERR_IO, true, "Concept %s is not defined.\n", name); + } + + return value; +} + +int pmConceptReadS32(pmFPA *fpa, // The FPA + pmChip *chip, // The chip + pmCell *cell, // The cell + psDB *db, // DB handle + const char *name // Name of the concept + ) +{ + psMetadataItem *item = pmConceptRead(fpa, chip, cell, db, name); + int value = 0; + if (item) { + switch (item->type) { + case PS_TYPE_S32: + value = item->data.S32; + break; + case PS_TYPE_F32: + psLogMsg(__func__, PS_LOG_WARN, "Concept %s (%s) should be S32, but is F32 --- converting.\n", + name, comment); + value = (int)item->data.F32; + break; + case PS_TYPE_F64: + psLogMsg(__func__, PS_LOG_WARN, "Concept %s (%s) should be S32, but is F64 --- converting.\n", + name, comment); + value = (int)item->data.F64; + break; + default: + psError(PS_ERR_IO, true, "Concept %s (%s) is not of integer type (%x) --- treating as " + "undefined.\n", name, item->comment, item->type); + } + psTrace(__func__, 7, "Read concept %s (%s): %d\n", name, item->comment, value); + } else { + psError(PS_ERR_IO, true, "Concept %s is not defined.\n", name); + } + + return value; +} + +psString pmConceptReadString(pmFPA *fpa, // The FPA + pmChip *chip, // The chip + pmCell *cell, // The cell + psDB *db, // DB handle + const char *name // Name of the concept + ) +{ + psMetadataItem *item = pmConceptRead(fpa, chip, cell, db, name); + psString value = NULL; + if (item) { + switch (item->type) { + case PS_DATA_STRING: + value = psMemIncrRefCounter(item->data.V); + break; + case PS_DATA_F32: + psStringAppend(&value, "%f", item->data.F32); + break; + case PS_DATA_S32: + psStringAppend(&value, "%d", item->data.S32); + break; + default: + psError(PS_ERR_IO, true, "Concept %s (%s) is not of string type (%x) --- treating as " + "undefined.\n", name, item->comment, item->type); + } + psTrace(__func__, 7, "Read concept %s (%s): %s\n", name, item->comment, value); + } else { + psError(PS_ERR_IO, true, "Concept %s is not defined.\n", name); + value = psStringCopy(""); + } + + return value; +} + Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/astrom/pmConceptsRead.h =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/astrom/pmConceptsRead.h (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/astrom/pmConceptsRead.h (revision 21664) @@ -0,0 +1,65 @@ +#ifndef PM_CONCEPTS_READ_H +#define PM_CONCEPTS_READ_H + +#include "pmFPA.h" + +psMetadataItem *pmConceptReadFromCamera(pmCell *cell, // The cell + const char *concept // Name of concept + ); + +psMetadataItem *pmConceptReadFromHeader(pmFPA *fpa, // The FPA that contains the chip + pmChip *chip, // The chip that contains the cell + pmCell *cell, // The cell + const char *concept // Name of concept + ); + +psMetadataItem *pmConceptReadFromDefault(pmFPA *fpa, // The FPA that contains the chip + pmChip *chip, // The chip that contains the cell + pmCell *cell, // The cell + const char *concept // Name of concept + ); + +psMetadataItem *pmConceptReadFromDB(pmFPA *fpa, // The FPA that contains the chip + pmChip *chip, // The chip that contains the cell + pmCell *cell, // The cell + psDB *db, // DB handle + const char *concept // Name of concept + ); + +psMetadataItem *pmConceptRead(pmFPA *fpa, // The FPA + pmChip *chip,// The chip + pmCell *cell, // The cell + psDB *db, // DB handle + const char *concept // Concept name + ); + +float pmConceptReadF32(pmFPA *fpa, // The FPA + pmChip *chip, // The chip + pmCell *cell, // The cell + psDB *db, // DB handle + const char *name // Name of the concept + ); + +double pmConceptReadF64(pmFPA *fpa, // The FPA + pmChip *chip, // The chip + pmCell *cell, // The cell + psDB *db, // DB handle + const char *name // Name of the concept + ); + +int pmConceptReadS32(pmFPA *fpa, // The FPA + pmChip *chip, // The chip + pmCell *cell, // The cell + psDB *db, // DB handle + const char *name // Name of the concept + ); + +psString pmConceptReadString(pmFPA *fpa, // The FPA + pmChip *chip, // The chip + pmCell *cell, // The cell + psDB *db, // DB handle + const char *name // Name of the concept + ); + + +#endif Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/astrom/pmConceptsStandard.c =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/astrom/pmConceptsStandard.c (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/astrom/pmConceptsStandard.c (revision 21664) @@ -0,0 +1,1017 @@ +#include + +#include "pslib.h" + +#include "pmConceptsRead.h" +#include "pmConceptsWrite.h" +#include "pmFPA.h" +#include "pmConceptsStandard.h" +#include "psAdditionals.h" + + +#define COMPARE_REGIONS(a,b) (((a)->x0 == (b)->x0 && \ + (a)->x1 == (b)->x1 && \ + (a)->y0 == (b)->y0 && \ + (a)->y1 == (b)->y1) ? true : false) + + +// Read FPA.RA and translate +psMetadataItem *pmConceptRead_FPA_RA(pmFPA *fpa, pmChip *chip, pmCell *cell, psDB *db) +{ + double ra = NAN; // The Right Ascension + psMetadataItem *raItem = pmConceptRead(fpa, NULL, NULL, db, "FPA.RA"); // The FPA.RA item + if (raItem) { + switch (raItem->type) { + case PS_TYPE_F32: + ra = raItem->data.F32; + break; + case PS_TYPE_F64: + ra = raItem->data.F64; + break; + case PS_DATA_STRING: + // Sexagesimal format + { + int big, medium; + float small; + // XXX: Upgrade path is to allow dd:mm.mmm + if (sscanf(raItem->data.V, "%d:%d:%f", &big, &medium, &small) != 3 && + sscanf(raItem->data.V, "%d %d %f", &big, &medium, &small) != 3) + { + psError(PS_ERR_IO, true, "Cannot interpret FPA.RA: %s\n", raItem->data.V); + break; + } + ra = abs(big) + (float)medium/60.0 + small/3600.0; + if (big < 0) + { + ra *= -1.0; + } + } + break; + default: + psError(PS_ERR_IO, true, "FPA.RA is of an unexpected type: %x\n", raItem->type); + } + + // How to interpret the RA + const psMetadata *camera = fpa->camera; // Camera configuration data + bool mdok = true; // Status of MD lookup + psMetadata *formats = psMetadataLookupMD(&mdok, camera, "FORMATS"); + if (mdok && formats) { + psString raFormat = psMetadataLookupStr(&mdok, formats, "FPA.RA"); + if (mdok && strlen(raFormat) > 0) { + if (strcasecmp(raFormat, "HOURS") == 0) { + ra *= M_PI / 12.0; + } else if (strcasecmp(raFormat, "DEGREES") == 0) { + ra *= M_PI / 180.0; + } else if (strcasecmp(raFormat, "RADIANS") == 0) { + // No action required + } else { + psLogMsg(__func__, PS_LOG_WARN, "Don't understand FPA.RA in FORMATS (%s) --- assuming" + " HOURS.\n"); + ra *= M_PI / 12.0; + } + } else { + psError(PS_ERR_IO, false, "Unable to find FPA.RA in FORMATS --- assuming HOURS.\n"); + ra *= M_PI / 12.0; + } + } else { + psError(PS_ERR_IO, false, "Unable to find FORMAT metadata in camera configuration --- " + "assuming format for FPA.RA is HOURS.\n"); + ra *= M_PI / 12.0; + } + } else { + psError(PS_ERR_IO, false, "Couldn't find FPA.RA.\n"); + } + + return psMetadataItemAllocF64("FPA.RA", "Right Ascension of boresight", ra); +} + +// Read FPA.DEC and translate +psMetadataItem *pmConceptRead_FPA_DEC(pmFPA *fpa, pmChip *chip, pmCell *cell, psDB *db) +{ + double dec = NAN; // The DEC + psMetadataItem *decItem = pmConceptRead(fpa, NULL, NULL, db, "FPA.DEC"); // The FPA.DEC item + if (decItem) { + switch (decItem->type) { + case PS_TYPE_F32: + dec = decItem->data.F32; + break; + case PS_TYPE_F64: + dec = decItem->data.F64; + break; + case PS_DATA_STRING: + // Sexagesimal format + { + int big, medium; + float small; + // XXX: Upgrade path is to allow dd:mm.mmm + if (sscanf(decItem->data.V, "%d:%d:%f", &big, &medium, &small) != 3 && + sscanf(decItem->data.V, "%d %d %f", &big, &medium, &small) != 3) + { + psError(PS_ERR_IO, true, "Cannot interpret FPA.DEC: %s\n", decItem->data.V); + break; + } + dec = abs(big) + (float)medium/60.0 + small/3600.0; + if (big < 0) + { + dec *= -1.0; + } + } + break; + default: + psError(PS_ERR_IO, true, "FPA.DEC is of an unexpected type: %x\n", decItem->type); + } + + // How to interpret the DEC + const psMetadata *camera = fpa->camera; // Camera configuration data + bool mdok = true; // Status of MD lookup + psMetadata *formats = psMetadataLookupMD(&mdok, camera, "FORMATS"); + if (mdok && formats) { + psString decFormat = psMetadataLookupStr(&mdok, formats, "FPA.DEC"); + if (mdok && strlen(decFormat) > 0) { + if (strcasecmp(decFormat, "HOURS") == 0) { + dec *= M_PI / 12.0; + } else if (strcasecmp(decFormat, "DEGREES") == 0) { + dec *= M_PI / 180.0; + } else if (strcasecmp(decFormat, "RADIANS") == 0) { + // No action required + } else { + psLogMsg(__func__, PS_LOG_WARN, "Don't understand FPA.DEC in FORMATS (%s) --- " + "assuming DEGREES.\n"); + dec *= M_PI / 180.0; + } + } else { + psError(PS_ERR_IO, false, "Unable to find FPA.DEC in FORMATS --- assuming DEGREES.\n"); + dec *= M_PI / 180.0; + } + } else { + psError(PS_ERR_IO, false, "Unable to find FORMATS metadata in camera configuration --- " + "assuming format for FPA.DEC is DEGREES.\n"); + dec *= M_PI / 180.0; + } + } else { + psError(PS_ERR_IO, false, "Couldn't find FPA.DEC.\n"); + } + + return psMetadataItemAllocF64("FPA.DEC", "Declination of boresight", dec); +} + + +bool pmConceptWrite_FPA_RA(pmFPA *fpa, pmChip *chip, pmCell *cell, psDB *db) +{ + double ra = psMetadataLookupF64(NULL, fpa->concepts, "FPA.RA"); // The RA + + // How to interpret the RA + const psMetadata *camera = fpa->camera; // Camera configuration data + bool mdok = true; // Status of MD lookup + psMetadata *formats = psMetadataLookupMD(&mdok, camera, "FORMATS"); + if (mdok && formats) { + psString raFormat = psMetadataLookupStr(&mdok, formats, "FPA.RA"); + if (mdok && strlen(raFormat) > 0) { + if (strcasecmp(raFormat, "HOURS") == 0) { + ra /= M_PI / 12.0; + } else if (strcasecmp(raFormat, "DEGREES") == 0) { + ra /= M_PI / 180.0; + } else if (strcasecmp(raFormat, "RADIANS") == 0) { + // No action required + } else { + psLogMsg(__func__, PS_LOG_WARN, "Don't understand FPA.RA in FORMATS (%s) --- assuming" + " HOURS.\n"); + ra /= M_PI / 12.0; + } + } else { + psError(PS_ERR_IO, false, "Unable to find FPA.RA in FORMATS --- assuming HOURS.\n"); + ra /= M_PI / 12.0; + } + } else { + psError(PS_ERR_IO, false, "Unable to find FORMAT metadata in camera configuration --- " + "assuming format for FPA.RA is HOURS.\n"); + ra /= M_PI / 12.0; + } + + // We choose to write sexagesimal format + int big, medium; + float small; + big = (int)ra; + medium = (int)(60.0*(ra - (double)big)); + small = 3600.0*(ra - (double)big - 60.0 * (double)medium); + psString raString = psStringCopy(""); + psStringAppend(&raString, "%d:%d:%.2f", big, medium, small); + psMetadataItem *raItem = psMetadataItemAllocStr("FPA.RA", "Right Ascension of the boresight", + raString); + pmConceptWriteItem(fpa, NULL, NULL, db, raItem); + psFree(raItem); + psFree(raString); + + return true; +} + +bool pmConceptWrite_FPA_DEC(pmFPA *fpa, pmChip *chip, pmCell *cell, psDB *db) +{ + double dec = psMetadataLookupF64(NULL, fpa->concepts, "FPA.DEC"); // The DEC + + // How to interpret the DEC + const psMetadata *camera = fpa->camera; // Camera configuration data + bool mdok = true; // Status of MD lookup + psMetadata *formats = psMetadataLookupMD(&mdok, camera, "FORMATS"); + if (mdok && formats) { + psString decFormat = psMetadataLookupStr(&mdok, formats, "FPA.DEC"); + if (mdok && strlen(decFormat) > 0) { + if (strcasecmp(decFormat, "HOURS") == 0) { + dec /= M_PI / 12.0; + } else if (strcasecmp(decFormat, "DEGREES") == 0) { + dec /= M_PI / 180.0; + } else if (strcasecmp(decFormat, "RADIANS") == 0) { + // No action required + } else { + psLogMsg(__func__, PS_LOG_WARN, "Don't understand FPA.DEC in FORMATS (%s) --- assuming" + " DEGREES.\n"); + dec /= M_PI / 180.0; + } + } else { + psError(PS_ERR_IO, false, "Unable to find FPA.DEC in FORMATS --- assuming DEGREES.\n"); + dec /= M_PI / 180.0; + } + } else { + psError(PS_ERR_IO, false, "Unable to find FORMAT metadata in camera configuration --- " + "assuming format for FPA.DEC is HOURS.\n"); + dec /= M_PI / 12.0; + } + + // We choose to write sexagesimal format + int big, medium; + float small; + big = (int)dec; + medium = (int)(60.0*(dec - (double)big)); + small = 3600.0*(dec - (double)big - 60.0 * (double)medium); + psString decString = psStringCopy(""); + psStringAppend(&decString, "%d:%d:%.2f", big, medium, small); + psMetadataItem *decItem = psMetadataItemAllocStr("FPA.DEC", "Right Ascension of the boresight", + decString); + pmConceptWriteItem(fpa, NULL, NULL, db, decItem); + psFree(decItem); + psFree(decString); + + return true; +} + + +psMetadataItem *pmConceptRead_CELL_TRIMSEC(pmFPA *fpa, pmChip *chip, pmCell *cell, psDB *db) +{ + psRegion *trimsec = psAlloc(sizeof(psRegion)); // Make space for a psRegion (usually passed by value) + + psMetadataItem *secItem = pmConceptRead(fpa, chip, cell, db, "CELL.TRIMSEC"); + if (! secItem) { + psError(PS_ERR_IO, false, "Couldn't find CELL.TRIMSEC.\n"); + *trimsec = psRegionSet(0.0, 0.0, 0.0, 0.0); + } else if (secItem->type != PS_DATA_STRING) { + psError(PS_ERR_IO, true, "CELL.TRIMSEC is not of type STR (%x)\n", secItem->type); + *trimsec = psRegionSet(0.0, 0.0, 0.0, 0.0); + } else { + psString section = secItem->data.V; // The section string + + psMetadataItem *sourceItem = pmConceptRead(fpa, chip, cell, db, "CELL.TRIMSEC.SOURCE"); + if (! sourceItem) { + psError(PS_ERR_IO, false, "Couldn't find CELL.TRIMSEC.SOURCE.\n"); + *trimsec = psRegionSet(0.0, 0.0, 0.0, 0.0); + } else if (sourceItem->type != PS_DATA_STRING) { + psError(PS_ERR_IO, true, "CELL.TRIMSEC.SOURCE is not of type STR (%x)\n", sourceItem->type); + *trimsec = psRegionSet(0.0, 0.0, 0.0, 0.0); + } else { + psString source = sourceItem->data.V; // The source string + + if (strcasecmp(source, "VALUE") == 0) { + *trimsec = psRegionFromString(section); + } else if (strcasecmp(source, "HEADER") == 0) { + psMetadata *header = NULL; // The FITS header + if (cell->hdu) { + header = cell->hdu->header; + } else if (chip->hdu) { + header = chip->hdu->header; + } else if (fpa->hdu) { + header = fpa->hdu->header; + } + if (! header) { + psError(PS_ERR_IO, true, "Unable to find FITS header!\n"); + *trimsec = psRegionSet(0.0, 0.0, 0.0, 0.0); + } else { + bool mdok = true; // Status of MD lookup + psString secValue = psMetadataLookupStr(&mdok, header, section); + if (! mdok || ! secValue) { + psError(PS_ERR_IO, false, "Unable to locate header %s\n", section); + *trimsec = psRegionSet(0.0, 0.0, 0.0, 0.0); + } else { + *trimsec = psRegionFromString(secValue); + } + } + } else { + psError(PS_ERR_IO, true, "CELL.TRIMSEC.SOURCE (%s) is not HEADER or VALUE --- trying " + "VALUE.\n", source); + *trimsec = psRegionFromString(section); + } // Value of CELL.TRIMSEC.SOURCE + } // Looking up CELL.TRIMSEC.SOURCE + } // Looking up CELL.TRIMSEC + + psMetadataItem *item = psMetadataItemAllocPtr("CELL.TRIMSEC", PS_DATA_UNKNOWN, "Trim section", trimsec); + psFree(trimsec); + return item; +} + + +psMetadataItem *pmConceptRead_CELL_BIASSEC(pmFPA *fpa, pmChip *chip, pmCell *cell, psDB *db) +{ + psList *biassecs = psListAlloc(NULL); // List of bias sections + psMetadataItem *item = psMetadataItemAlloc("CELL.BIASSEC", PS_DATA_LIST, "Bias sections", biassecs); + psFree(biassecs); // Drop reference + + psMetadataItem *secItem = pmConceptRead(fpa, chip, cell, db, "CELL.BIASSEC"); + if (! secItem) { + psError(PS_ERR_IO, false, "Couldn't find CELL.BIASSEC.\n"); + return item; + } + if (secItem->type != PS_DATA_STRING) { + psError(PS_ERR_IO, true, "CELL.BIASSEC is not of type STR (%x)\n", secItem->type); + return item; + } + + psString sections = secItem->data.V; // The section string + + psMetadataItem *sourceItem = pmConceptRead(fpa, chip, cell, db, "CELL.BIASSEC.SOURCE"); + if (! sourceItem) { + psError(PS_ERR_IO, false, "Couldn't find CELL.BIASSEC.SOURCE.\n"); + return item; + } else if (sourceItem->type != PS_DATA_STRING) { + psError(PS_ERR_IO, true, "CELL.BIASSEC.SOURCE is not of type STR (%x)\n", sourceItem->type); + return item; + } + + psString source = sourceItem->data.V; // The source string + + if (! strcasecmp(source, "NONE")) { + return item; // There is no biassec + } + + psList *secList = psStringSplit(sections, " ;"); // List of sections + psListIterator *secIter = psListIteratorAlloc(secList, PS_LIST_HEAD, false); // Iterator over + // sections + psString aSection = NULL; // A section from the list + while ((aSection = psListGetAndIncrement(secIter))) { + psRegion *region = psAlloc(sizeof(psRegion)); // Make space for a psRegion (usually passed by + // value) + + if (strcasecmp(source, "VALUE") == 0) { + *region = psRegionFromString(aSection); + } else if (strcasecmp(source, "HEADER") == 0) { + psMetadata *header = NULL; // The FITS header + if (cell->hdu) { + header = cell->hdu->header; + } else if (chip->hdu) { + header = chip->hdu->header; + } else if (fpa->hdu) { + header = fpa->hdu->header; + } + if (! header) { + psError(PS_ERR_IO, true, "Unable to find FITS header!\n"); + *region = psRegionSet(0.0,0.0,0.0,0.0); + } else { + bool mdok = true; // Status of MD lookup + psString secValue = psMetadataLookupStr(&mdok, header, aSection); + if (! mdok || ! secValue) { + psError(PS_ERR_IO, false, "Unable to locate header %s\n", aSection); + *region = psRegionSet(0.0,0.0,0.0,0.0); + } else { + *region = psRegionFromString(secValue); + } + } + } else { + psError(PS_ERR_IO, true, "CELL.BIASSEC.SOURCE (%s) is not HEADER or VALUE --- trying " + "VALUE.\n", source); + *region = psRegionFromString(aSection); + } // Value of CELL.BIASSEC.SOURCE + + psListAdd(biassecs, PS_LIST_TAIL, region); + psFree(region); + } // Iterating over multiple sections + psFree(secIter); + psFree(secList); + + return item; +} + + +psMetadataItem *pmConceptRead_CELL_XBIN(pmFPA *fpa, pmChip *chip, pmCell *cell, psDB *db) +{ + int xBin = 1; // Binning factor in x + psMetadataItem *binItem = pmConceptRead(fpa, chip, cell, db, "CELL.XBIN"); + if (! binItem) { + psError(PS_ERR_IO, false, "Couldn't find CELL.XBIN.\n"); + } else if (binItem->type == PS_DATA_STRING) { + psString binString = binItem->data.V; // The string containing the binning + if (sscanf(binString, "%d %*d", &xBin) != 1 && + sscanf(binString, "%d,%*d", &xBin) != 1) { + psError(PS_ERR_IO, true, "Unable to read string to get x binning: %s\n", binString); + } + } else if (binItem->type == PS_TYPE_S32) { + xBin = binItem->data.S32; + } else { + psError(PS_ERR_IO, true, "Note sure how to interpret CELL.XBIN of type %x --- assuming 1.\n", + binItem->type); + } + + return psMetadataItemAllocS32("CELL.XBIN", "Binning in x", xBin); +} + +psMetadataItem *pmConceptRead_CELL_YBIN(pmFPA *fpa, pmChip *chip, pmCell *cell, psDB *db) +{ + int yBin = 1; // Binning factor in y + psMetadataItem *binItem = pmConceptRead(fpa, chip, cell, db, "CELL.YBIN"); + if (! binItem) { + psError(PS_ERR_IO, false, "Couldn't find CELL.YBIN.\n"); + } else if (binItem->type == PS_DATA_STRING) { + psString binString = binItem->data.V; // The string containing the binning + if (sscanf(binString, "%*d %d", &yBin) != 1 && + sscanf(binString, "%*d,%d", &yBin) != 1) { + psError(PS_ERR_IO, true, "Unable to read string to get y binning: %s\n", binString); + } + } else if (binItem->type == PS_TYPE_S32) { + yBin = binItem->data.S32; + } else { + psError(PS_ERR_IO, true, "Note sure how to interpret CELL.YBIN of type %x --- assuming 1.\n", + binItem->type); + } + + return psMetadataItemAllocS32("CELL.YBIN", "Binning in y", yBin); +} + +psMetadataItem *pmConceptRead_CELL_TIMESYS(pmFPA *fpa, pmChip *chip, pmCell *cell, psDB *db) +{ + psTimeType timeSys = PS_TIME_UTC; // The time system + psString sys = pmConceptReadString(fpa, chip, cell, db, "CELL.TIMESYS"); // The time system as a string + if (! sys || strlen(sys) <= 0) { + psError(PS_ERR_IO, true, "Can't interpret CELL.TIMESYS --- assuming UTC.\n"); + } else if (strcasecmp(sys, "TAI") == 0) { + timeSys = PS_TIME_TAI; + } else if (strcasecmp(sys, "UTC") == 0) { + timeSys = PS_TIME_UTC; + } else if (strcasecmp(sys, "UT1") == 0) { + timeSys = PS_TIME_UT1; + } else if (strcasecmp(sys, "TT") == 0) { + timeSys = PS_TIME_TT; + } else { + psError(PS_ERR_IO, true, "Can't interpret CELL.TIMESYS --- assuming UTC.\n"); + } + + psFree(sys); + return psMetadataItemAllocS32("CELL.TIMESYS", "Time system", timeSys); +} + + +psMetadataItem *pmConceptRead_CELL_TIME(pmFPA *fpa, pmChip *chip, pmCell *cell, psDB *db) +{ + // Need CELL.TIMESYS first + bool mdok = false; // Result of MD lookup + psTimeType timeSys = psMetadataLookupS32(&mdok, cell->concepts, "CELL.TIMESYS"); // The time system + if (!mdok) { + psLogMsg(__func__, PS_LOG_WARN, "Unable to find CELL.TIMESYS in concepts --- assuming UTC.\n"); + timeSys = PS_TIME_UTC; + } + psTime *time = NULL; // The time + + psMetadataItem *timeItem = pmConceptRead(fpa, chip, cell, db, "CELL.TIME"); + if (! timeItem) { + psError(PS_ERR_IO, false, "Couldn't find CELL.TIME.\n"); + } else { + // Get format + const psMetadata *camera = fpa->camera; // The camera configuration data + bool mdok = true; // Status of MD lookup + psMetadata *formats = psMetadataLookupMD(&mdok, camera, "FORMATS"); + if (mdok && formats) { + psString timeFormat = psMetadataLookupStr(&mdok, formats, "CELL.TIME"); + if (mdok && strlen(timeFormat) > 0) { + switch (timeItem->type) { + case PS_DATA_STRING: { + psString timeString = timeItem->data.V; // String with the time + if (strcasecmp(timeFormat, "ISO") == 0) { + // timeString contains an ISO time + time = psTimeFromISO(timeString, timeSys); + } else if (strcasecmp(timeFormat, "JD") == 0) { + double timeValue = strtod (timeString, NULL); + time = psTimeFromJD(timeValue); + } else if (strcasecmp(timeFormat, "MJD") == 0) { + double timeValue = strtod (timeString, NULL); + time = psTimeFromMJD(timeValue); + } else if (strstr(timeFormat, "SEPARATE")) { + // timeString contains headers for the date and time + psMetadata *header = NULL; // The FITS header + if (cell->hdu) { + header = cell->hdu->header; + } else if (chip->hdu) { + header = chip->hdu->header; + } else if (fpa->hdu) { + header = fpa->hdu->header; + } + if (! header) { + psError(PS_ERR_IO, true, "Unable to find FITS header!\n"); + } else { + // Get the headers + char *stuff1 = strpbrk(timeString, " ,;"); + psString dateName = psStringNCopy(timeString, + strlen(timeString) - strlen(stuff1)); + char *stuff2 = strpbrk(stuff1, "abcdefghijklmnopqrstuvwxyz" + "ABCDEFGHIJKLMNOPQRSTUVWXYZ"); + psString timeName = psStringCopy(stuff2); + + bool mdok = true; // Status of MD lookup + psString dateString = psMetadataLookupStr(&mdok, header, dateName); + psFree(dateName); + int day = 0, month = 0, year = 0; + if (sscanf(dateString, "%d-%d-%d", &day, &month, &year) != 3 && + sscanf(dateString, "%d/%d/%d", &day, &month, &year) != 3) { + psError(PS_ERR_IO, true, "Unable to read date: %s\n", dateString); + } else { + if (strstr(timeFormat, "BACKWARDS")) { + int temp = day; + day = year; + year = temp; + } + if (strstr(timeFormat, "PRE2000") || year < 2000) { + year += 2000; + } + + psMetadataItem *timeItem = psMetadataLookup(header, timeName); + if (! timeItem) { + psError(PS_ERR_IO, false, "Unable to find time header: %s\n", + timeName); + } else if (timeItem->type == PS_DATA_STRING) { + // Time is a string, in the usual way: + psStringAppend(&dateString, "T%s", timeItem->data.V); + } else { + // Assume that time is specified in Second of Day + double seconds = NAN; + switch (timeItem->type) { + case PS_TYPE_S32: + seconds = timeItem->data.S32; + break; + case PS_TYPE_F32: + seconds = timeItem->data.F32; + break; + case PS_TYPE_F64: + seconds = timeItem->data.F64; + break; + default: + psError(PS_ERR_IO, true, "Time header (%s) is not of an " + "expected type: %x\n", timeName, timeItem->type); + } + // Now print to timeString as "hh:mm:ss.ss" + int hours = seconds / 3600; + seconds -= (double)hours * 3600.0; + int minutes = seconds / 60; + seconds -= (double)minutes * 60.0; + psStringAppend(&dateString, "T%02d:%02d:%02f", hours, minutes, + seconds); + } + time = psTimeFromISO(dateString, timeSys); + } // Reading date and time + psFree(timeName); + } // Reading headers + } else { + psError(PS_ERR_IO, true, "Not sure how to parse CELL.TIME (%s) --- trying " + "ISO\n", timeString); + time = psTimeFromISO(timeString, timeSys); + } // Interpreting the time string + } + break; + case PS_TYPE_F32: { + double timeValue = (double)timeItem->data.F32; + if (strcasecmp(timeFormat, "JD") == 0) { + time = psTimeFromJD(timeValue); + } else if (strcasecmp(timeFormat, "MJD") == 0) { + time = psTimeFromMJD(timeValue); + } else { + psError(PS_ERR_IO, true, "Not sure how to parse CELL.TIME (%f) --- trying " + "JD\n", timeValue); + time = psTimeFromJD(timeValue); + } + } + break; + case PS_TYPE_F64: { + double timeValue = (double)timeItem->data.F64; + if (strcasecmp(timeFormat, "JD") == 0) { + time = psTimeFromJD(timeValue); + } else if (strcasecmp(timeFormat, "MJD") == 0) { + time = psTimeFromMJD(timeValue); + } else { + psError(PS_ERR_IO, true, "Not sure how to parse CELL.TIME (%f) --- trying " + "JD\n", timeValue); + time = psTimeFromJD(timeValue); + } + } + break; + default: + psError(PS_ERR_IO, true, "Unable to parse CELL.TIME.\n"); + } + } else { + psError(PS_ERR_IO, false, "Unable to find CELL.TIME in FORMATS.\n"); + } // Getting the format + } else { + psError(PS_ERR_IO, false, "Unable to find FORMATS in camera configuration.\n"); + } // Getting the formats + } // Getting CELL.TIME + + psMetadataItem *item = psMetadataItemAllocPtr("CELL.TIME", PS_DATA_TIME, "Time of exposure", time); + psFree(time); + return item; +} + +// Correct a position --- in case the user wants FORTRAN indexing (like the FITS standard...) +static int fortranCorr(pmFPA *fpa, // FPA, contains the camera configuration + const char *name // Name of concept to check for FORTRAN indexing + ) +{ + bool mdok = false; // Result of MD lookup + psMetadata *formats = psMetadataLookupMD(&mdok, fpa->camera, "FORMATS"); + if (mdok && formats) { + psString format = psMetadataLookupStr(&mdok, formats, name); + if (mdok && strlen(format) > 0 && strcasecmp(format, "FORTRAN") == 0) { + return -1; + } + } + return 0; +} + +psMetadataItem *pmConceptRead_CELL_X0(pmFPA *fpa, pmChip *chip, pmCell *cell, psDB *db) +{ + int x0 = pmConceptReadS32(fpa, chip, cell, db, "CELL.X0"); + x0 += fortranCorr(fpa, "CELL.X0"); + return psMetadataItemAllocS32("CELL.X0", "Position of (0,0) on the chip", x0); +} + + +psMetadataItem *pmConceptRead_CELL_Y0(pmFPA *fpa, pmChip *chip, pmCell *cell, psDB *db) +{ + int y0 = pmConceptReadS32(fpa, chip, cell, db, "CELL.Y0"); + y0 += fortranCorr(fpa, "CELL.X0"); + return psMetadataItemAllocS32("CELL.Y0", "Position of (0,0) on the chip", y0); +} + + +bool pmConceptWrite_CELL_TRIMSEC(pmFPA *fpa, pmChip *chip, pmCell *cell, psDB *db) +{ + psMetadataItem *trimsecItem = psMetadataLookup(cell->concepts, "CELL.TRIMSEC"); + psRegion *trimsec = trimsecItem->data.V; // The trimsec region + psString source = pmConceptReadString(fpa, chip, cell, db, "CELL.TRIMSEC.SOURCE"); // The source string + + if (strcasecmp(source, "VALUE") == 0) { + // Check that it's the same value as stored in the camera + psString checkString = psMetadataLookupStr(NULL, cell->camera, "CELL.TRIMSEC"); + psRegion checkRegion = psRegionFromString(checkString); + if (! COMPARE_REGIONS(&checkRegion, trimsec)) { + psError(PS_ERR_IO, true, "Target CELL.TRIMSEC is specified by value, and values don't " + "match.\n"); + return false; + } + return true; + } + + if (strcasecmp(source, "HEADER") == 0) { + psMetadata *header = NULL; // The FITS header + if (cell->hdu) { + header = cell->hdu->header; + } else if (chip->hdu) { + header = chip->hdu->header; + } else if (fpa->hdu) { + header = fpa->hdu->header; + } + if (! header) { + psError(PS_ERR_IO, true, "Unable to find FITS header!\n"); + return false; + } + psMetadataAddItem(header, trimsecItem, PS_LIST_TAIL, PS_META_REPLACE); + return true; + } + + psError(PS_ERR_IO, true, "CELL.TRIMSEC.SOURCE (%s) is not HEADER or VALUE.\n", source); + return false; +} + +bool pmConceptWrite_CELL_BIASSEC(pmFPA *fpa, pmChip *chip, pmCell *cell, psDB *db) +{ + psMetadataItem *biassecItem = psMetadataLookup(cell->concepts, "CELL.BIASSEC"); + psList *biassecs = biassecItem->data.V; // The biassecs region list + + if (biassecs->n == 0) { + psMetadataItem *noneItem = psMetadataItemAllocStr("CELL.BIASSEC", "Bias section", "NONE"); + pmConceptWriteItem(fpa, chip, cell, db, noneItem); + return true; + } + + psString source = pmConceptReadString(fpa, chip, cell, db, "CELL.TRIMSEC.SOURCE"); // The source string + + if (strcasecmp(source, "VALUE") == 0) { + // Check that it's the same value as stored in the camera + psString checkString = psMetadataLookupStr(NULL, cell->camera, "CELL.BIASSEC"); + psList *checkList = psStringSplit(checkString, " ;"); + if (biassecs->n != checkList->n) { + psError(PS_ERR_IO, true, "Target CELL.BIASSEC is specified by value, but number of " + "entries doesn't match.\n"); + psFree(checkList); + return false; + } + + // We don't care if the order matches or not + psVector *check = psVectorAlloc(biassecs->n, PS_TYPE_U8); // Vector to mark regions off + for (int i = 0; i < check->n; i++) { + check->data.U8[i] = 0; + } + psListIterator *biassecsIter = psListIteratorAlloc(biassecs, PS_LIST_HEAD, false); // Iterator + psListIterator *checkListIter = psListIteratorAlloc(checkList, PS_LIST_HEAD, false); + psRegion *biassec = NULL; // Region from iteration + while ((biassec = psListGetAndIncrement(biassecsIter))) { + psListIteratorSet(checkListIter, PS_LIST_HEAD); + psString checkRegionString = NULL; // Region string from iteration + int i = 0; // Counter + while ((checkRegionString = psListGetAndIncrement(checkListIter))) { + psRegion checkRegion = psRegionFromString(checkRegionString); + psTrace(__func__, 7, "Checking [%.0f:%.0f,%.0f:%.0f] against " + "[%.0f:%.0f,%.0f:%.0f]\n", biassec->x0, biassec->x1, biassec->y0, + biassec->y1, checkRegion.x0, checkRegion.x1, checkRegion.y0, + checkRegion.y1); + if (COMPARE_REGIONS(biassec, &checkRegion)) { + check->data.U8[i] = 1; + i++; + break; + } + i++; + } + } + + bool allMatch = true; // Does everything match? + for (int i = 0; i < check->n; i++) { + if (check->data.U8[i] == 0) { + psError(PS_ERR_IO, true, "Target CELL.BIASSEC is specified by value, but values " + "don't match.\n"); + allMatch = false; + } + } + // Clean up + psFree(checkListIter); + psFree(checkList); + psFree(biassecsIter); + psFree(check); + + return allMatch; + } + + if (strcasecmp(source, "HEADER") == 0) { + psString keywordsString = psMetadataLookupStr(NULL, cell->camera, "CELL.BIASSEC"); + psList *keywords = psStringSplit(keywordsString, " ,;"); + if (biassecs->n != keywords->n) { + psError(PS_ERR_IO, true, "Target CELL.BIASSEC is sepcified by headers, but the number " + "of headers doesn't match.\n"); + psFree(keywords); + return false; + } + + psMetadata *header = NULL; // The FITS header + if (cell->hdu) { + header = cell->hdu->header; + } else if (chip->hdu) { + header = chip->hdu->header; + } else if (fpa->hdu) { + header = fpa->hdu->header; + } + if (! header) { + psError(PS_ERR_IO, true, "Unable to find FITS header!\n"); + psFree(keywords); + return false; + } + + psListIterator *keywordsIter = psListIteratorAlloc(keywords, PS_LIST_HEAD, false); + psListIterator *biassecsIter = psListIteratorAlloc(biassecs, PS_LIST_HEAD, false); + psString keyword = NULL; // Header keyword from list + while ((keyword = psListGetAndIncrement(keywordsIter))) { + // Update the header + psRegion *biassec = psListGetAndIncrement(biassecsIter); + psString biassecString = psRegionToString(*biassec); + psMetadataAdd(header, PS_LIST_TAIL, keyword, PS_DATA_STRING | PS_META_REPLACE, "Bias section", + biassecString); + psFree(biassecString); + } + psFree(keywordsIter); + psFree(biassecsIter); + psFree(keywords); + + return true; + } + + psError(PS_ERR_IO, true, "CELL.BIASSEC.SOURCE (%s) is not HEADER or VALUE.\n", source); + return false; +} + +// This function actually does both CELL.XBIN and CELL.YBIN, since if CELL.XBIN and CELL.YBIN are specified by +// the same header, we need to check to update them together. +bool pmConceptWrite_CELL_XBIN(pmFPA *fpa, pmChip *chip, pmCell *cell, psDB *db) +{ + psMetadataItem *xBinItem = psMetadataLookup(cell->concepts, "CELL.XBIN"); // Binning factor in x + psMetadataItem *yBinItem = psMetadataLookup(cell->concepts, "CELL.YBIN"); // Binning factor in y + + const psMetadata *camera = fpa->camera; + psMetadata *translation = psMetadataLookupMD(NULL, camera, "TRANSLATION"); + psString xKeyword = psMetadataLookupStr(NULL, translation, "CELL.XBIN"); + psString yKeyword = psMetadataLookupStr(NULL, translation, "CELL.YBIN"); + if (strlen(xKeyword) > 0 && strcasecmp(xKeyword, yKeyword) != 0) { + pmConceptWriteToHeader(fpa, chip, cell, xBinItem); + xBinItem = NULL; + } + if (strlen(yKeyword) > 0 && strcasecmp(xKeyword, yKeyword) != 0) { + pmConceptWriteToHeader(fpa, chip, cell, yBinItem); + yBinItem = NULL; + } + if (strlen(xKeyword) > 0 && strlen(yKeyword) > 0 && strcasecmp(xKeyword, yKeyword) == 0) { + psString binString = psStringCopy(""); + psStringAppend(&binString, "%d,%d", xBinItem->data.S32, yBinItem->data.S32); + psMetadataItem *binItem = psMetadataItemAllocStr(xKeyword, "Binning factor in x and y", binString); + psFree(binString); + psMetadata *header = NULL; // The FITS header + if (cell->hdu) { + header = cell->hdu->header; + } else if (chip->hdu) { + header = chip->hdu->header; + } else if (fpa->hdu) { + header = fpa->hdu->header; + } + if (! header) { + psError(PS_ERR_IO, true, "Unable to find FITS header!\n"); + return false; + } + psMetadataAddItem(header, binItem, PS_LIST_TAIL, PS_META_REPLACE); + xBinItem = NULL; + yBinItem = NULL; + psFree(binItem); + } + + // Do it in the usual way if we have to + if (xBinItem) { + pmConceptWriteItem(fpa, chip, cell, db, xBinItem); + } + if (yBinItem) { + pmConceptWriteItem(fpa, chip, cell, db, yBinItem); + } + + return true; +} + +// This is a dummy function, since CELL.YBIN is done by CELL.XBIN +bool pmConceptWrite_CELL_YBIN(pmFPA *fpa, pmChip *chip, pmCell *cell, psDB *db) +{ + return true; +} + + + +bool pmConceptWrite_CELL_TIMESYS(pmFPA *fpa, pmChip *chip, pmCell *cell, psDB *db) +{ + psMetadataItem *sysItem = psMetadataLookup(cell->concepts, "CELL.TIMESYS"); + psString sys = NULL; // String to store + switch (sysItem->data.S32) { + case PS_TIME_TAI: + sys = psStringCopy("TAI"); + break; + case PS_TIME_UTC: + sys = psStringCopy("UTC"); + break; + case PS_TIME_UT1: + sys = psStringCopy("UT1"); + break; + case PS_TIME_TT: + sys = psStringCopy("TT"); + break; + default: + sys = psStringCopy("Unknown"); + } + psMetadataItem *newItem = psMetadataItemAllocStr("CELL.TIMESYS", "Time system", sys); + bool success = pmConceptWriteItem(fpa, chip, cell, db, newItem); + psFree(newItem); + psFree(sys); + + return success; +} + +bool pmConceptWrite_CELL_TIME(pmFPA *fpa, pmChip *chip, pmCell *cell, psDB *db) +{ + psMetadataItem *timeItem = psMetadataLookup(cell->concepts, "CELL.TIME"); + psTime *time = timeItem->data.V; // The time + psString dateTimeString = psTimeToISO(time); // String representation + + psMetadata *formats = psMetadataLookupMD(NULL, fpa->camera, "FORMATS"); + psString format = psMetadataLookupStr(NULL, formats, "CELL.TIME"); + + if (strlen(format) == 0) { + // No format specified --> do it in the usual way (maybe it's a DB lookup) + psMetadataItem *newTimeItem = psMetadataItemAllocStr("CELL.TIME", "Time of observation", + dateTimeString); + bool success = pmConceptWriteItem(fpa, chip, cell, db, newTimeItem); + psFree(newTimeItem); + psFree(dateTimeString); + return success; + } + if (strcasecmp(format, "ISO") == 0) { + // dateTimeString contains an ISO time + psMetadataItem *newTimeItem = psMetadataItemAllocStr("CELL.TIME", "Time of observation", + dateTimeString); + bool success = pmConceptWriteItem(fpa, chip, cell, db, newTimeItem); + psFree(newTimeItem); + psFree(dateTimeString); + return success; + } + if (strstr(format, "SEPARATE")) { + // We're working with two separate headers + psMetadata *header = NULL; // The FITS header + if (cell->hdu) { + header = cell->hdu->header; + } else if (chip->hdu) { + header = chip->hdu->header; + } else if (fpa->hdu) { + header = fpa->hdu->header; + } + if (! header) { + psError(PS_ERR_IO, true, "Unable to find FITS header!\n"); + psFree(dateTimeString); + return false; + } + + // Get the headers + const psMetadata *camera = fpa->camera; + psMetadata *translation = psMetadataLookupMD(NULL, camera, "TRANSLATION"); + psString keywords = psMetadataLookupStr(NULL, translation, "CELL.TIME"); + psList *dateTimeKeywords = psStringSplit(keywords, " ,;"); + psString dateKeyword = psListGet(dateTimeKeywords, PS_LIST_HEAD); + psString timeKeyword = psListGet(dateTimeKeywords, PS_LIST_TAIL); + + psList *dateTime = psStringSplit(dateTimeString, " T"); // Find the middle T + psString dateString = psListGet(dateTime, PS_LIST_HEAD); + psString timeString = psListGet(dateTime, PS_LIST_TAIL); + + // XXX: Couldn't be bothered doing these right now + if (strstr(format, "PRE2000")) { + psError(PS_ERR_IO, true, "Don't you realise it's the twenty-first century?\n"); + psFree(dateTimeString); + // Should free other stuff, but this is work in progress + return false; + } + if (strstr(format, "BACKWARDS")) { + psError(PS_ERR_IO, true, "You want it BACKWARDS? Not right now, thanks.\n"); + psFree(dateTimeString); + // Should free other stuff, but this is work in progress + return false; + } + + bool success = true; + psMetadataItem *dateItem = psMetadataItemAllocStr(dateKeyword, "Date of observation", dateString); + psMetadataItem *timeItem = psMetadataItemAllocStr(timeKeyword, "Time of observation", timeString); + success = psMetadataAddItem(header, dateItem, PS_LIST_TAIL, PS_META_REPLACE) && + psMetadataAddItem(header, timeItem, PS_LIST_TAIL, PS_META_REPLACE); + + psFree(dateTimeKeywords); + psFree(dateTime); + psFree(dateItem); + psFree(timeItem); + + return success; + } + if (strcasecmp(format, "MJD") == 0) { + double mjd = psTimeToMJD(time); + psMetadataItem *newTimeItem = psMetadataItemAllocF64("CELL.TIME", "MJD of observation", mjd); + bool success = pmConceptWriteItem(fpa, chip, cell, db, newTimeItem); + psFree(newTimeItem); + psFree(dateTimeString); + return success; + } + if (strcasecmp(format, "JD") == 0) { + double jd = psTimeToMJD(time); + psMetadataItem *newTimeItem = psMetadataItemAllocF64("CELL.TIME", "JD of observation", jd); + bool success = pmConceptWriteItem(fpa, chip, cell, db, newTimeItem); + psFree(newTimeItem); + psFree(dateTimeString); + return success; + } + + psError(PS_ERR_IO, true, "Not sure how to write concept CELL.TIME (%s)\n", dateTimeString); + return false; +} + +bool pmConceptWrite_CELL_X0(pmFPA *fpa, pmChip *chip, pmCell *cell, psDB *db) +{ + psMetadataItem *x0item = psMetadataLookup(cell->concepts, "CELL.X0"); + psMetadataItem *newItem = psMetadataItemAllocS32("CELL.X0", "Position of (0,0) on the chip", + x0item->data.S32 - fortranCorr(fpa, "CELL.X0")); + return pmConceptWriteItem(fpa, chip, cell, db, newItem); +} + +bool pmConceptWrite_CELL_Y0(pmFPA *fpa, pmChip *chip, pmCell *cell, psDB *db) +{ + psMetadataItem *y0item = psMetadataLookup(cell->concepts, "CELL.Y0"); + psMetadataItem *newItem = psMetadataItemAllocS32("CELL.Y0", "Position of (0,0) on the chip", + y0item->data.S32 - fortranCorr(fpa, "CELL.Y0")); + return pmConceptWriteItem(fpa, chip, cell, db, newItem); +} + Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/astrom/pmConceptsStandard.h =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/astrom/pmConceptsStandard.h (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/astrom/pmConceptsStandard.h (revision 21664) @@ -0,0 +1,28 @@ +#ifndef PM_CONCEPTS_STANDARD_H +#define PM_CONCEPTS_STANDARD_H + +#include "pslib.h" +#include "pmFPA.h" + +psMetadataItem *pmConceptRead_FPA_RA(pmFPA *fpa, pmChip *chip, pmCell *cell, psDB *db); +psMetadataItem *pmConceptRead_FPA_DEC(pmFPA *fpa, pmChip *chip, pmCell *cell, psDB *db); +bool pmConceptWrite_FPA_RA(pmFPA *fpa, pmChip *chip, pmCell *cell, psDB *db); +bool pmConceptWrite_FPA_DEC(pmFPA *fpa, pmChip *chip, pmCell *cell, psDB *db); +psMetadataItem *pmConceptRead_CELL_TRIMSEC(pmFPA *fpa, pmChip *chip, pmCell *cell, psDB *db); +psMetadataItem *pmConceptRead_CELL_BIASSEC(pmFPA *fpa, pmChip *chip, pmCell *cell, psDB *db); +psMetadataItem *pmConceptRead_CELL_XBIN(pmFPA *fpa, pmChip *chip, pmCell *cell, psDB *db); +psMetadataItem *pmConceptRead_CELL_YBIN(pmFPA *fpa, pmChip *chip, pmCell *cell, psDB *db); +psMetadataItem *pmConceptRead_CELL_TIMESYS(pmFPA *fpa, pmChip *chip, pmCell *cell, psDB *db); +psMetadataItem *pmConceptRead_CELL_TIME(pmFPA *fpa, pmChip *chip, pmCell *cell, psDB *db); +psMetadataItem *pmConceptRead_CELL_X0(pmFPA *fpa, pmChip *chip, pmCell *cell, psDB *db); +psMetadataItem *pmConceptRead_CELL_Y0(pmFPA *fpa, pmChip *chip, pmCell *cell, psDB *db); +bool pmConceptWrite_CELL_TRIMSEC(pmFPA *fpa, pmChip *chip, pmCell *cell, psDB *db); +bool pmConceptWrite_CELL_BIASSEC(pmFPA *fpa, pmChip *chip, pmCell *cell, psDB *db); +bool pmConceptWrite_CELL_XBIN(pmFPA *fpa, pmChip *chip, pmCell *cell, psDB *db); +bool pmConceptWrite_CELL_YBIN(pmFPA *fpa, pmChip *chip, pmCell *cell, psDB *db); +bool pmConceptWrite_CELL_TIMESYS(pmFPA *fpa, pmChip *chip, pmCell *cell, psDB *db); +bool pmConceptWrite_CELL_TIME(pmFPA *fpa, pmChip *chip, pmCell *cell, psDB *db); +bool pmConceptWrite_CELL_X0(pmFPA *fpa, pmChip *chip, pmCell *cell, psDB *db); +bool pmConceptWrite_CELL_Y0(pmFPA *fpa, pmChip *chip, pmCell *cell, psDB *db); + +#endif Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/astrom/pmConceptsWrite.c =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/astrom/pmConceptsWrite.c (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/astrom/pmConceptsWrite.c (revision 21664) @@ -0,0 +1,377 @@ +#include +#include +#include "pslib.h" + +#include "pmFPA.h" +#include "pmConceptsRead.h" +#include "psAdditionals.h" + + +static bool compareConcepts(psMetadataItem *item1, // First item to compare + psMetadataItem *item2 // Second item to compare + ) +{ + // First order checks + if (! item1 || ! item2) { + return false; + } + if (strcasecmp(item1->name, item2->name) != 0) { + return false; + } + + // Check the more boring types + switch (item1->type) { + case PS_TYPE_S32: + switch (item2->type) { + case PS_TYPE_S32: + return (item1->data.S32 == item2->data.S32) ? true : false; + case PS_TYPE_F32: + return (item1->data.S32 == (int)item2->data.F32) ? true : false; + case PS_TYPE_F64: + return (item1->data.S32 == (int)item2->data.F64) ? true : false; + default: + return false; + } + case PS_TYPE_F32: + switch (item2->type) { + case PS_TYPE_S32: + return (item1->data.F32 == (float)item2->data.S32) ? true : false; + case PS_TYPE_F32: + return (item1->data.F32 == item2->data.F32) ? true : false; + case PS_TYPE_F64: + return (item1->data.F32 == (float)item2->data.F64) ? true : false; + default: + return false; + } + case PS_TYPE_F64: + switch (item2->type) { + case PS_TYPE_S32: + return (item1->data.F64 == (double)item2->data.S32) ? true : false; + case PS_TYPE_F32: + return (item1->data.F64 == (double)item2->data.F32) ? true : false; + case PS_TYPE_F64: + return (item1->data.F64 == item2->data.F64) ? true : false; + default: + return false; + } + return (item1->data.F64 == item2->data.F64) ? true : false; + case PS_DATA_STRING: + if (item2->type != PS_DATA_STRING) { + return false; + } + return (strcasecmp(item1->data.V, item2->data.V) == 0) ? true : false; + default: + return false; + } + psAbort(__func__, "Should never get here.\n"); +} + + +// Well, not really "write", but check to make sure it's there and matches +bool pmConceptWriteToCamera(pmCell *cell, // The cell + psMetadataItem *concept // Concept + ) +{ + if (! cell->camera) { + return false; + } + if (cell) { + psMetadataItem *item = psMetadataLookup(cell->camera, concept->name); // Info we want + return compareConcepts(item, concept); + } + + return false; +} + +// Write the concept to the header in the appropriate location +bool pmConceptWriteToHeader(pmFPA *fpa, // The FPA that contains the chip + pmChip *chip, // The chip that contains the cell + pmCell *cell, // The cell + psMetadataItem *concept // Concept + ) +{ + bool mdok = true; // Status of MD lookup + bool status = false; // Status of setting header + if (! fpa->camera) { + return false; + } + psMetadata *translation = psMetadataLookupMD(&mdok, fpa->camera, "TRANSLATION"); // FITS translation + if (! mdok) { + psError(PS_ERR_IO, false, "Unable to find TRANSLATION in camera configuration.\n"); + return false; + } + + // Look for how to translate the concept into a FITS header name + const char *keyword = psMetadataLookupStr(&mdok, translation, concept->name); + if (mdok && strlen(keyword) > 0) { + psTrace(__func__, 6, "It's in keyword %s\n", keyword); + psMetadataItem *headerItem = NULL; // Item to add to header + // XXX: Need to expand range of types + switch (concept->type) { + case PS_DATA_STRING: + headerItem = psMetadataItemAllocStr(keyword, concept->comment, concept->data.V); + break; + case PS_DATA_S32: + headerItem = psMetadataItemAllocS32(keyword, concept->comment, concept->data.S32); + break; + case PS_DATA_F32: + headerItem = psMetadataItemAllocF32(keyword, concept->comment, concept->data.F32); + break; + case PS_DATA_F64: + headerItem = psMetadataItemAllocF64(keyword, concept->comment, concept->data.F64); + break; + default: + headerItem = psMetadataItemAlloc(keyword, concept->type, concept->comment, + concept->data.V); // Item for the header + } + + // We have a FITS header to look up --- search each level + if (cell && cell->hdu) { + psTrace(__func__, 7, "Adding to the cell level header...\n"); + psMetadataAddItem(cell->hdu->header, headerItem, PS_LIST_TAIL, PS_META_REPLACE); + status = true; + } else if (chip && chip->hdu) { + psTrace(__func__, 7, "Adding to the chip level header...\n"); + psMetadataAddItem(chip->hdu->header, headerItem, PS_LIST_TAIL, PS_META_REPLACE); + status = true; + } else if (fpa->hdu) { + psTrace(__func__, 7, "Adding to the FPA level header...\n"); + psMetadataAddItem(fpa->hdu->header, headerItem, PS_LIST_TAIL, PS_META_REPLACE); + status = true; + } else { + // In desperation, add to the PHU --- it HAS to be in the header somewhere! + if (! fpa->phu) { + fpa->phu = psMetadataAlloc(); + } + psTrace(__func__, 7, "Adding to the PHU...\n"); + psMetadataAddItem(fpa->phu, headerItem, PS_LIST_TAIL, PS_META_REPLACE); + status = true; + } + psFree(headerItem); + } + + // No header value + return status; +} + + +// Well, not really "write", but check to see if it's there, and matches +bool pmConceptWriteToDefault(pmFPA *fpa, // The FPA that contains the chip + pmChip *chip, // The chip that contains the cell + pmCell *cell, // The cell + psMetadataItem *concept // Concept + ) +{ + bool mdOK = true; // Status of MD lookup + if (! fpa->camera) { + return false; + } + psMetadata *defaults = psMetadataLookupMD(&mdOK, fpa->camera, "DEFAULTS"); + if (! mdOK || ! defaults) { + psError(PS_ERR_IO, false, "Unable to find DEFAULTS in camera configuration.\n"); + return false; + } + + psMetadataItem *defItem = psMetadataLookup(defaults, concept->name); + bool status = false; // Result of checking the database + if (defItem) { + if (defItem->type == PS_DATA_METADATA) { + // A dependent default + psTrace(__func__, 7, "Evaluating dependent default....\n"); + psMetadata *dependents = defItem->data.V; // The list of dependents + // Find out what it depends on + psString dependName = psStringCopy(concept->name); + psStringAppend(&dependName, ".DEPEND"); + psString dependsOn = psMetadataLookupStr(&mdOK, defaults, dependName); + if (! mdOK) { + psError(PS_ERR_IO, false, "Unable to find %s in camera configuration for dependent default" + " --- ignored\n", dependName); + // XXX: Need to clean up before returning + return false; + } + psFree(dependName); + // Find the value of the dependent concept + psMetadataItem *depItem = pmConceptReadFromHeader(fpa, chip, cell, dependsOn); + if (! depItem) { + psError(PS_ERR_IO, true, "Unable to find value for %s (required for %s)\n", dependsOn, + concept->name); + return false; + } + if (depItem->type != PS_DATA_STRING) { + psError(PS_ERR_IO, true, "Value of %s is not of type string, as required for dependency" + " --- ignored.\n", dependsOn); + } + + defItem = psMetadataLookup(dependents, depItem->data.V); // This is now what we were after + } + + status = compareConcepts(defItem, concept); + if (! status) { + psError(PS_ERR_IO, true, "Concept %s is specified by default in the camera configuration, " + "but doesn't match the actual value.\n", concept->name); + } + } + + // XXX: Need to clean up before returning + return status; +} + + +// XXX: Not tested at all +// XXX I WOULD NOT TRUST THIS FUNCTION IN THE SLIGHTEST YET! --- PAP +bool pmConceptWriteToDB(pmFPA *fpa, // The FPA that contains the chip + pmChip *chip, // The chip that contains the cell + pmCell *cell, // The cell + psDB *db, // DB handle + psMetadataItem *concept // Concept + ) +{ + if (! db) { + // No database initialised + return false; + } + + bool mdStatus = true; // Status of MD lookup + if (! fpa->camera) { + return false; + } + psMetadata *database = psMetadataLookupMD(&mdStatus, fpa->camera, "DATABASE"); + if (! mdStatus) { + // No error, because not everyone needs to use the DB + return NULL; + } + + psMetadata *dbLookup = psMetadataLookupMD(&mdStatus, database, concept->name); + if (dbLookup) { + const char *tableName = psMetadataLookupStr(&mdStatus, dbLookup, "TABLE"); // Name of the table + // const char *colName = psMetadataLookupStr(&mdStatus, dbLookup, "COLUMN"); // Name of the column + const char *givenCols = psMetadataLookupStr(&mdStatus, dbLookup, "GIVENDBCOL"); // Name of "where" + // columns + const char *givenPS = psMetadataLookupStr(&mdStatus, dbLookup, "GIVENPS"); // Values for "where" + // columns + + // Now, need to get the "given"s + if (strlen(givenCols) || strlen(givenPS)) { + psList *cols = psStringSplit(givenCols, ",;"); // List of column names + psList *values = psStringSplit(givenPS, ",;"); // List of value names for the columns + psMetadata *selection = psMetadataAlloc(); // The stuff to select in the DB + if (cols->n != values->n) { + psLogMsg(__func__, PS_LOG_WARN, "The GIVENDBCOL and GIVENPS entries for %s do not have " + "the same number of entries --- ignored.\n", concept); + } else { + // Iterators for the lists + psListIterator *colsIter = psListIteratorAlloc(cols, PS_LIST_HEAD, false); + psListIterator *valuesIter = psListIteratorAlloc(values, PS_LIST_HEAD, false); + char *column = NULL; // Name of the column + while ((column = psListGetAndIncrement(colsIter))) { + char *name = psListGetAndIncrement(valuesIter); // Name for the value + if (!strlen(column) || !strlen(name)) { + psLogMsg(__func__, PS_LOG_WARN, "One of the columns or value names for %s is " + " empty --- ignored.\n", concept); + } else { + // Search for the value name + psMetadataItem *item = pmConceptReadFromHeader(fpa, chip, cell, name); + if (! item) { + item = pmConceptReadFromDefault(fpa, chip, cell, name); + } + if (! item) { + psLogMsg(__func__, PS_LOG_ERROR, "Unable to find the value name %s for DB " + " lookup on %s --- ignored.\n", name, concept); + } else { + // We need to create a new psMetadataItem. I don't think we can't simply hack + // the existing one, since that could conceivably cause memory leaks + psMetadataItem *newItem = psMetadataItemAlloc(concept->name, item->type, + item->comment, item->data.V); + psMetadataAddItem(selection, newItem, PS_LIST_TAIL, PS_META_REPLACE); + psFree(newItem); + } + } + psFree(name); + psFree(column); + } // Iterating through the columns + psFree(colsIter); + psFree(valuesIter); + + // Check first to make sure we're only going to touch one row + psArray *dbResult = psDBSelectRows(db, tableName, selection, 2); // Lookup result + // Note that we use limit=2 in order to test if there are multiple rows returned + if (! dbResult || dbResult->n == 0) { + psLogMsg(__func__, PS_LOG_WARN, "Unable to find any rows in DB for %s --- ignored\n", + concept->name); + return false; + } else { + if (dbResult->n > 1) { + psLogMsg(__func__, PS_LOG_WARN, "Multiple rows returned in DB lookup for %s --- " + " ignored.\n", concept->name); + } + // Update the DB + psMetadata *update = psMetadataAlloc(); + psMetadataAddItem(update, concept, PS_LIST_HEAD, 0); + psDBUpdateRows(db, tableName, selection, update); + psFree(update); + return true; + } + } + psFree(cols); + psFree(values); + } + } // Doing the "given"s. + + psAbort(__func__, "Shouldn't ever get here?\n"); + return false; +} + + +// Concept write from item +bool pmConceptWriteItem(pmFPA *fpa, // The FPA + pmChip *chip, // The chip + pmCell *cell, // The cell + psDB *db, // DB handle + psMetadataItem *concept // Concept item + ) +{ + if (! fpa->camera) { + return false; + } + + // Try headers, database, defaults in order + psTrace(__func__, 3, "Trying to set concept %s...\n", concept->name); + bool status = pmConceptWriteToCamera(cell, concept); // Status for return + if (! status) { + psTrace(__func__, 5, "Trying header....\n"); + status = pmConceptWriteToHeader(fpa, chip, cell, concept); + } + if (! status) { + psTrace(__func__, 5, "Trying database....\n"); + status = pmConceptWriteToDB(fpa, chip, cell, db, concept); + } + if (! status) { + psTrace(__func__, 5, "Checking defaults....\n"); + status = pmConceptWriteToDefault(fpa, chip, cell, concept); + } + + if (! status) { + psError(PS_ERR_IO, true, "Unable to set %s (%s).\n", concept->name, concept->comment); + } + + return status; +} + + +// Concept write +bool pmConceptWrite(pmFPA *fpa, // The FPA + pmChip *chip,// The chip + pmCell *cell, // The cell + psDB *db, // DB handle + psMetadata *concepts, // Concepts MD from which to set + const char *name // Name of the concept + ) +{ + psMetadataItem *concept = psMetadataLookup(concepts, name); + if (! concept) { + psError(PS_ERR_IO, true, "No such concept as %s\n", name); + return false; + } + return pmConceptWriteItem(fpa, chip, cell, db, concept); +} + Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/astrom/pmConceptsWrite.h =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/astrom/pmConceptsWrite.h (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/astrom/pmConceptsWrite.h (revision 21664) @@ -0,0 +1,49 @@ +#ifndef PM_CONCEPTS_WRITE_H +#define PM_CONCEPTS_WRITE_H + +#include "pslib.h" +#include "pmFPA.h" + +// Well, not really "write", but check to make sure it's there and matches +bool pmConceptWriteToCamera(pmCell *cell, // The cell + psMetadataItem *concept // Concept + ); + +// Write the concept to the header in the appropriate location +bool pmConceptWriteToHeader(pmFPA *fpa, // The FPA that contains the chip + pmChip *chip, // The chip that contains the cell + pmCell *cell, // The cell + psMetadataItem *concept // Concept + ); + +// Well, not really "write", but check to see if it's there, and matches +bool pmConceptWriteToDefault(pmFPA *fpa, // The FPA that contains the chip + pmChip *chip, // The chip that contains the cell + pmCell *cell, // The cell + psMetadataItem *concept // Concept + ); + +bool pmConceptWriteToDB(pmFPA *fpa, // The FPA that contains the chip + pmChip *chip, // The chip that contains the cell + pmCell *cell, // The cell + psDB *db, // DB handle + psMetadataItem *concept // Concept + ); + +// Concept write from item +bool pmConceptWriteItem(pmFPA *fpa, // The FPA + pmChip *chip, // The chip + pmCell *cell, // The cell + psDB *db, // DB handle + psMetadataItem *concept // Concept item + ); + +bool pmConceptWrite(pmFPA *fpa, // The FPA + pmChip *chip,// The chip + pmCell *cell, // The cell + psDB *db, // DB handle + psMetadata *concepts, // Concepts MD from which to set + const char *name // Name of the concept + ); + +#endif Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/astrom/pmFPA.c =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/astrom/pmFPA.c (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/astrom/pmFPA.c (revision 21664) @@ -0,0 +1,684 @@ +/** @file pmFPA.c +* +* @brief This file defines the basic types for the FPA hierarchy +* +* @ingroup AstroImage +* +* @author GLG, MHPCC +* +* XXX: We should review the extent of the warning messages on these functions +* when the transformations are not successful. +* +* XXX: Should we implement non-linear cell->chip transforms? +* +* @version $Revision: 1.1.2.11 $ $Name: not supported by cvs2svn $ +* @date $Date: 2006-02-09 21:29:23 $ +* +* Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii +*/ + +/******************************************************************************/ +/* INCLUDE FILES */ +/******************************************************************************/ +#include +#include +#include +#include "pslib.h" + +#include "pmFPA.h" +#include "pmConcepts.h" +#include "pmMaskBadPixels.h" + +/****************************************************************************** + *****************************************************************************/ +#define PS_FREE_HIERARCHY 1 +#define PARENT_LINKS 0 + +static void readoutFree(pmReadout *readout) +{ + if (readout != NULL) { + psTrace(__func__, 9, "Removing readout %lx from cell %lx...\n", (size_t) readout, (size_t) readout->parent); + if (readout->parent) { + psArray *readouts = readout->parent->readouts; + for (int i = 0; i < readouts->n; i++) { + if (readouts->data[i] == readout) { + // pmReadout *tmpReadout = readouts->data[i]; + readouts->data[i] = NULL; + #if PARENT_LINKS + + psFree(tmpReadout); + #endif + + break; + } + } + } + psTrace(__func__, 9, "Freeing readout %lx\n", (size_t) readout); + + #if PARENT_LINKS + + psFree(readout->parent); + #endif + + psFree(readout->image); + psFree(readout->mask); + psFree(readout->weight); + psFree(readout->analysis); + psFree(readout->bias); + } +} + +static void cellFree(pmCell *cell) +{ + if (cell != NULL) { + psTrace(__func__, 9, "Removing cell %lx from chip %lx...\n", (size_t)cell, (size_t)cell->parent); + if (cell->parent) { + psArray *cells = cell->parent->cells; + for (int i = 0; i < cells->n; i++) { + if (cells->data[i] == cell) { + // pmCell *tmpCell = cells->data[i]; + cells->data[i] = NULL; + #if PARENT_LINKS + + psFree(tmpCell); + #endif + + break; + } + } + } + psTrace(__func__, 9, "Freeing cell %lx\n", (size_t)cell); + + pmCellFreeReadouts(cell); + psFree(cell->readouts); + #if PARENT_LINKS + + psFree(cell->parent); + #endif + + psFree(cell->toChip); + psFree(cell->toFPA); + psFree(cell->toSky); + psFree(cell->concepts); + psFree(cell->analysis); + psFree(cell->camera); + psFree(cell->hdu); + } +} + +static void chipFree(pmChip* chip) +{ + if (chip != NULL) { + psTrace(__func__, 9, "Removing chip %lx from fpa %lx...\n", (size_t)chip, (size_t)chip->parent); + if (chip->parent) { + psArray *chips = chip->parent->chips; + for (int i = 0; i < chips->n; i++) { + if (chips->data[i] == chip) { + // pmChip *tmpChip = chips->data[i]; + chips->data[i] = NULL; + #if PARENT_LINKS + + psFree(tmpChip); + #endif + + break; + } + } + } + psTrace(__func__, 9, "Freeing chip %lx\n", (size_t)chip); + + pmChipFreeCells(chip); + psFree(chip->cells); + #if PARENT_LINKS + + psFree(chip->parent); + #endif + + psFree(chip->toFPA); + psFree(chip->fromFPA); + psFree(chip->concepts); + psFree(chip->analysis); + psFree(chip->hdu); + } +} + + +static void FPAFree(pmFPA *fpa) +{ + if (fpa != NULL) { + psTrace(__func__, 9, "Freeing fpa %lx\n", (size_t)fpa); + psFree(fpa->fromTangentPlane); + psFree(fpa->toTangentPlane); + psFree(fpa->projection); + psFree(fpa->concepts); + psFree(fpa->analysis); + psFree(fpa->camera); + // + // Set the parent to NULL in all fpa->chips before psFree(fpa->chips) + // in order to avoid memory reference counter problems. + // + psArray *chips = fpa->chips; + for (psS32 i = 0 ; i < chips->n ; i++) { + pmChip *tmpChip = chips->data[i]; + if (! tmpChip) { + continue; + } + chips->data[i] = NULL; + tmpChip->parent = NULL; + if (PS_FREE_HIERARCHY == 1) { + psFree(tmpChip); + } + } + psFree(fpa->chips); + psFree(fpa->hdu); + psFree(fpa->phu); + } +} + +void pmCellFreeReadouts(pmCell *cell) +{ + // + // Set the parent to NULL in all cell->readouts before psFree(cell->readouts) + // in order to avoid memory reference counter problems. + // + psArray *readouts = cell->readouts; + for (psS32 i = 0 ; i < readouts->n ; i++) { + pmReadout *tmpReadout = readouts->data[i]; + if (! tmpReadout) { + continue; + } + readouts->data[i] = NULL; + tmpReadout->parent = NULL; + psTrace(__func__, 9, "Will now free readout %lx...\n", (size_t)tmpReadout); + psFree(tmpReadout); // Drop the readout + #if PARENT_LINKS + + psFree(cell); // Decrement reference counter on cell, since readout->parent isn't held any more + #endif + + } + cell->readouts = psArrayRealloc(cell->readouts, 0); + cell->readouts->n = 0; +} + + +void pmChipFreeCells(pmChip *chip) +{ + // + // Set the parent to NULL in all chip->cells before psFree(chip->cells) + // in order to avoid memory reference counter problems. + // + psArray *cells = chip->cells; + for (int i = 0 ; i < cells->n ; i++) { + pmCell *tmpCell = cells->data[i]; + if (! tmpCell) { + continue; + } + cells->data[i] = NULL; + tmpCell->parent = NULL; + pmCellFreeReadouts(tmpCell);// Drop all readouts the cell holds + psFree(tmpCell); // Drop the cell + #if PARENT_LINKS + + psFree(chip); // Decrement reference counter on chip, since cell->parent isn't held any more + #endif + + } + chip->cells = psArrayRealloc(chip->cells, 0); + chip->cells->n = 0; +} + + + +void p_pmHDUFree(p_pmHDU *hdu) +{ + if (hdu) { + psFree(hdu->extname); + psFree(hdu->header); + psFree(hdu->images); + psFree(hdu->masks); + psFree(hdu->weights); + } +} + +// XXX: Verify these default values for row0, col0, rowBins, colBins +// PAP: These values may disappear in the future in favour of values in parent->concepts? +pmReadout *pmReadoutAlloc(pmCell *cell) +{ + pmReadout *tmpReadout = (pmReadout *) psAlloc(sizeof(pmReadout)); + + tmpReadout->col0 = 0; + tmpReadout->row0 = 0; + tmpReadout->colBins = 0; + tmpReadout->rowBins = 0; + tmpReadout->image = NULL; + tmpReadout->mask = NULL; + tmpReadout->weight = NULL; + tmpReadout->bias = psListAlloc(NULL); + tmpReadout->analysis = psMetadataAlloc(); + #if PARENT_LINKS + + tmpReadout->parent = psMemIncrRefCounter(cell); + #else + + tmpReadout->parent = cell; + #endif + + if (cell != NULL) { + cell->readouts = psArrayAdd(cell->readouts, 1, (psPtr) tmpReadout); + } + psMemSetDeallocator(tmpReadout, (psFreeFunc) readoutFree); + return(tmpReadout); +} + +// XXX: Verify these default values for row0, col0. +// PAP: These values may disappear in the future in favour of values in the "concepts"? +pmCell *pmCellAlloc( + pmChip *chip, + psMetadata *cameraData, + const char *name) +{ + pmCell *tmpCell = (pmCell *) psAlloc(sizeof(pmCell)); + + tmpCell->col0 = 0; + tmpCell->row0 = 0; + tmpCell->toChip = NULL; + tmpCell->toFPA = NULL; + tmpCell->toSky = NULL; + tmpCell->concepts = psMetadataAlloc(); + psBool rc = psMetadataAddStr(tmpCell->concepts, PS_LIST_HEAD, "CELL.NAME", 0, NULL, name); + if (rc == false) { + psLogMsg(__func__, PS_LOG_WARN, "WARNING: Could not add CELL.NAME to metadata.\n"); + } + tmpCell->camera = psMemIncrRefCounter(cameraData); + tmpCell->analysis = psMetadataAlloc(); + tmpCell->readouts = psArrayAlloc(0); + #if PARENT_LINKS + + tmpCell->parent = psMemIncrRefCounter(chip); + #else + + tmpCell->parent = chip; + #endif + + if (chip != NULL) { + chip->cells = psArrayAdd(chip->cells, 1, (psPtr) tmpCell); + } + tmpCell->process = true; // All cells are processed by default + tmpCell->exists = false; // Not yet read in + tmpCell->hdu = NULL; + + pmConceptsBlankCell(tmpCell); + + psMemSetDeallocator(tmpCell, (psFreeFunc) cellFree); + return(tmpCell); +} + +// XXX: Verify these default values for row0, col0. +// PAP: row0, col0 may disappear in the future in favour of storing values in the "concepts". +pmChip *pmChipAlloc( + pmFPA *fpa, + const char *name) +{ + pmChip *tmpChip = (pmChip *) psAlloc(sizeof(pmChip)); + + tmpChip->col0 = 0; + tmpChip->row0 = 0; + tmpChip->toFPA = NULL; + tmpChip->fromFPA = NULL; + tmpChip->concepts = psMetadataAlloc(); + psBool rc = psMetadataAddStr(tmpChip->concepts, PS_LIST_HEAD, "CHIP.NAME", 0, NULL, name); + if (rc == false) { + psLogMsg(__func__, PS_LOG_WARN, "WARNING: Could not add CHIP.NAME to metadata.\n"); + } + tmpChip->analysis = psMetadataAlloc(); + tmpChip->cells = psArrayAlloc(0); + #if PARENT_LINKS + + tmpChip->parent = psMemIncrRefCounter(fpa); + #else + + tmpChip->parent = fpa; + #endif + + if (fpa != NULL) { + fpa->chips = psArrayAdd(fpa->chips, 1, (psPtr) tmpChip); + } + tmpChip->process = true; // Work on all chips, by default + tmpChip->exists = false; // Not read in yet + tmpChip->hdu = NULL; + + pmConceptsBlankChip(tmpChip); + + psMemSetDeallocator(tmpChip, (psFreeFunc) chipFree); + return(tmpChip); +} + +pmFPA *pmFPAAlloc(const psMetadata *camera) +{ + pmFPA *tmpFPA = (pmFPA *) psAlloc(sizeof(pmFPA)); + + tmpFPA->fromTangentPlane = NULL; + tmpFPA->toTangentPlane = NULL; + tmpFPA->projection = NULL; + tmpFPA->concepts = psMetadataAlloc(); + tmpFPA->analysis = NULL; + tmpFPA->camera = psMemIncrRefCounter((psPtr)camera); + tmpFPA->chips = psArrayAlloc(0); + tmpFPA->hdu = NULL; + tmpFPA->phu = NULL; + + pmConceptsBlankFPA(tmpFPA); + + psMemSetDeallocator(tmpFPA, (psFreeFunc) FPAFree); + return(tmpFPA); +} + +p_pmHDU *p_pmHDUAlloc(const char *extname) +{ + p_pmHDU *hdu = psAlloc(sizeof(p_pmHDU)); + psMemSetDeallocator(hdu, (psFreeFunc)p_pmHDUFree); + + hdu->extname = psStringCopy(extname); + hdu->header = NULL; + hdu->images = NULL; + hdu->masks = NULL; + hdu->weights = NULL; + + return hdu; +} + +static psBool cellCheckParents(pmCell *cell) +{ + if (cell == NULL) { + return(true); + } + psBool flag = true; + + for (psS32 i = 0 ; i < cell->readouts->n ; i++) { + pmReadout *tmpReadout = (pmReadout *) cell->readouts->data[i]; + PS_ASSERT_PTR_NON_NULL(tmpReadout, false); + if (tmpReadout->parent != cell) { + tmpReadout->parent = cell; + flag = false; + } + } + return(flag); +} + +static psBool chipCheckParents(pmChip *chip) +{ + if (chip == NULL) { + return(true); + } + psBool flag = true; + + for (psS32 i = 0 ; i < chip->cells->n ; i++) { + pmCell *tmpCell = (pmCell *) chip->cells->data[i]; + PS_ASSERT_PTR_NON_NULL(tmpCell, false); + if (tmpCell->parent != chip) { + tmpCell->parent = chip; + flag = false; + } + + flag &= cellCheckParents(tmpCell); + } + return(flag); +} + +psBool pmFPACheckParents(pmFPA *fpa) +{ + if (fpa == NULL) { + return(true); + } + psBool flag = true; + + for (psS32 i = 0 ; i < fpa->chips->n ; i++) { + pmChip *tmpChip = (pmChip *) fpa->chips->data[i]; + PS_ASSERT_PTR_NON_NULL(tmpChip, false); + if (tmpChip->parent != fpa) { + tmpChip->parent = fpa; + flag = false; + } + + flag &= chipCheckParents(tmpChip); + } + return(flag); +} + + + +/***************************************************************************** + *****************************************************************************/ + +// Set cells within a chip to be processed or not +static bool setCellsProcess(const pmChip *chip, // Chip of interest + bool process // Process this chip? + ) +{ + PS_ASSERT_PTR_NON_NULL(chip, false); + + psArray *cells = chip->cells; // Component cells + if (! cells) { + return false; + } + for (int i = 0; i < cells->n; i++) { + pmCell *tmpCell = cells->data[i]; // Cell of interest + if (tmpCell) { + tmpCell->process = process; + } + } + + return true; +} + +/***************************************************************************** + *****************************************************************************/ +bool pmFPASelectChip( + pmFPA *fpa, + int chipNum) +{ + PS_ASSERT_PTR_NON_NULL(fpa, false); + + psArray *chips = fpa->chips; // Component chips + if ((chips == NULL) || (chipNum >= chips->n)) { + return(false); + } + + for (int i = 0 ; i < chips->n ; i++) { + pmChip *tmpChip = (pmChip *) chips->data[i]; + if (tmpChip == NULL) { + continue; + } + if (i == chipNum) { + tmpChip->process = true; + setCellsProcess(tmpChip, true); + } else { + tmpChip->process = false; + setCellsProcess(tmpChip, false); + } + + } + + return true; +} + +bool pmChipSelectCell(pmChip *chip, + int cellNum + ) +{ + assert(chip); + + psArray *cells = chip->cells; // Component cells + if (!cells || cellNum > cells->n) { + return false; + } + + for (int i = 0; i < cells->n; i++) { + pmCell *cell = cells->data[i]; + if (!cell) { + continue; + } + cell->process = (i == cellNum); + } + + return true; +} + +/***************************************************************************** +XXX: The SDRS is ambiguous on a few things: + Whether or not the other chips should be set process=true. [PAP: No] + Should we return the number of chip process=true before or after they're set, [PAP: After] + *****************************************************************************/ +/** + * + * pmFPAExcludeChip shall set process to false only for the specified chip + * number (chipNum). In the event that the specified chip number does not exist + * within the fpa, the function shall generate a warning, and perform no action. + * The function shall return the number of chips within the fpa that have process + * set to true. + * + */ +int pmFPAExcludeChip( + pmFPA *fpa, + int chipNum) +{ + PS_ASSERT_PTR_NON_NULL(fpa, false); + + psArray *chips = fpa->chips; // Component chips + if (chips == NULL) { + psLogMsg(__func__, PS_LOG_WARN, "WARNING: fpa->chips == NULL\n"); + return(0); + } + if ((chipNum >= chips->n) || (NULL == (pmChip *) chips->data[chipNum])) { + psLogMsg(__func__, PS_LOG_WARN, "WARNING: the specified chip (%d) does not exist.\n", chipNum); + return(0); + } + + int numChips = 0; // Number of chips to be processed + for (int i = 0 ; i < chips->n ; i++) { + pmChip *tmpChip = (pmChip *) chips->data[i]; // Chip of interest + if (tmpChip != NULL) { + if (i == chipNum) { + tmpChip->process = false; + setCellsProcess(tmpChip, false); // Wipe out the cell as well + } else if (tmpChip->process) { + numChips++; + } + } + } + + return(numChips); +} + +int pmChipExcludeCell(pmChip *chip, + int cellNum + ) +{ + assert(chip); + + psArray *cells = chip->cells; // The component cells + if (!cells || cellNum > cells->n) { + return 0; + } + + int numCells = 0; // Number of cells to be processed + for (int i = 0; i < cells->n; i++) { + pmCell *cell = cells->data[i]; + if (!cell) { + continue; + } + if (i == cellNum) { + cell->process = false; + } else { + numCells++; + } + } + + return numCells; +} + + +bool pmCellSetWeights(pmCell *cell // Cell for which to set weights + ) +{ + float gain = psMetadataLookupF32(NULL, cell->concepts, "CELL.GAIN"); // Cell gain + float readnoise = psMetadataLookupF32(NULL, cell->concepts, "CELL.READNOISE"); // Cell read noise + psRegion *trimsec = psMetadataLookupPtr(NULL, cell->concepts, "CELL.TRIMSEC"); // Trim section + float saturation = psMetadataLookupF32(NULL, cell->concepts, "CELL.SATURATION"); // Saturation level + float bad = psMetadataLookupF32(NULL, cell->concepts, "CELL.BAD"); // Bad level + + p_pmHDU *hdu = cell->hdu; // The data unit, containing the weight and mask originals + if (!hdu) { + pmChip *chip = cell->parent; // The parent chip + if (chip->hdu) { + hdu = chip->hdu; + } else { + pmFPA *fpa = chip->parent; // The parent FPA + hdu = fpa->hdu; + if (!hdu) { + psError(PS_ERR_UNKNOWN, true, "Unable to find the HDU in the hierarchy!\n"); + return false; + } + } + } + + psArray *pixels = hdu->images; // Array of images + psArray *weights = hdu->weights; // Array of weight images + psArray *masks = hdu->masks; // Array of mask images + // Generate the weights and masks if required + if (! weights) { + weights = psArrayAlloc(pixels->n); + for (int i = 0; i < pixels->n; i++) { + psImage *image = pixels->data[i]; + weights->data[i] = psImageAlloc(image->numCols, image->numRows, PS_TYPE_F32); + psImageInit(weights->data[i], 0.0); + } + hdu->weights = weights; + } + if (! masks) { + masks = psArrayAlloc(pixels->n); + for (int i = 0; i < pixels->n; i++) { + psImage *image = pixels->data[i]; + masks->data[i] = psImageAlloc(image->numCols, image->numRows, PS_TYPE_U8); + psImageInit(masks->data[i], 0); + } + hdu->masks = masks; + } + + // Set the pixels + psArray *readouts = cell->readouts; // Array of readouts + for (int i = 0; i < readouts->n; i++) { + pmReadout *readout = readouts->data[i]; // The readout of interest + + if (! readout->weight) { + readout->weight = psMemIncrRefCounter(psImageSubset(weights->data[i], *trimsec)); + } + if (! readout->mask) { + readout->mask = psMemIncrRefCounter(psImageSubset(masks->data[i], *trimsec)); + } + + // Set up the mask + psImage *image = readout->image;// Pixels + psImage *mask = readout->mask; // Mask image + for (int i = 0; i < image->numRows; i++) { + for (int j = 0; j < image->numCols; j++) { + if (image->data.F32[i][j] > saturation) { + mask->data.U8[i][j] = PM_MASK_SAT; + } + if (image->data.F32[i][j] < bad) { + mask->data.U8[i][j] = PM_MASK_BAD; + } + } + } + + // Set weight image to the variance = g*f + rn^2 + psBinaryOp(readout->weight, image, "/", psScalarAlloc(gain, PS_TYPE_F32)); + psBinaryOp(readout->weight, readout->weight, "+", + psScalarAlloc(readnoise*readnoise/gain/gain, PS_TYPE_F32)); + } + + return true; +} + + Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/astrom/pmFPA.h =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/astrom/pmFPA.h (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/astrom/pmFPA.h (revision 21664) @@ -0,0 +1,294 @@ +/** @file pmFPA.h +* +* @brief This file defines the basic types the focal plane hierarchy. +* +* @ingroup AstroImage +* +* @author GLG, MHPCC +* +* @version $Revision: 1.1.2.3 $ $Name: not supported by cvs2svn $ +* @date $Date: 2006-01-22 03:23:32 $ +* +* Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii +*/ + +#ifndef PM_FPA_H +#define PM_FPA_H +#if HAVE_CONFIG_H +#include +#endif +#include "pslib.h" +#include "psDB.h" + +/// @addtogroup AstroImage +/// @{ + +// XXX: Is this correct? Must determine what p_pmHDU is. +// XXX: Create the p_pmHDU alloc/free. +typedef struct +{ + const char *extname; // Extension name, if it corresponds to this level + psMetadata *header; // The FITS header, if it corresponds to this level + psArray *images; // The pixel data, if it corresponds to this level + psArray *masks; // The mask data, if it corresponds to this level + psArray *weights; // The weight data, if it corresponds to this level +} +p_pmHDU; + +/** Focal plane data structure + * + * A focal plane consists of one or more chips (according to the number of + * pieces of contiguous silicon). It contains metadata containers for the + * concepts and analysis, a link to the parent, and pointers to the FITS header, + * if that corresponds to this level (the FPA may be the PHU, but will not ever + * contain pixels). For astrometry, it contains a transformation from the focal + * plane to the tangent plane and the fixed pattern residuals. It is expected + * that the transformation will consist of two 4D polynomials (i.e. a function + * of two coordinates in position, the magnitude of the object, and the color of + * the object) in order to correct for optical distortions and the effects of + * the atmosphere; hence we think that it is prudent to include a reverse + * transformation which will be derived from numerically inverting the forward + * transformation. + * + */ +typedef struct +{ + // Astrometric transformations + psPlaneDistort* fromTangentPlane; ///< Transformation from tangent plane to focal plane + psPlaneDistort* toTangentPlane; ///< Transformation from focal plane to tangent plane + psProjection *projection; ///< Projection from tangent plane to sky + // Information + psMetadata *concepts; ///< Cache for PS concepts + psMetadata *analysis; ///< FPA-level analysis metadata + const psMetadata *camera; ///< Camera configuration + psArray *chips; ///< The chips + p_pmHDU *hdu; ///< FITS data + psMetadata *phu; ///< Primary Header +} +pmFPA; + +/** Chip data structure + * + * A chip consists of one or more cells (according to the number of amplifiers + * on the device). The chip contains metadata containers for the concepts and + * analysis, a link to the parent, and pointers to the pointers to the various + * FITS data, if that corresponds to this level. For astrometry, in addition to + * the rough positioning information, it contains a coordinate transform from + * the chip to the focal plane. It is expected that this transform will consist + * of two second-order 2D polynomials; hence we think that it is prudent to + * include a reverse transformation which will be derived from numerically + * inverting the forward transformation. A boolean indicates whether the chip is + * of interest, allowing it to be excluded from analysis. + * + */ +typedef struct +{ + // Offset specifying position on focal plane + int col0; ///< Offset from the left of FPA. + int row0; ///< Offset from the bottom of FPA. + // Astrometric transformations + psPlaneTransform* toFPA; ///< Transformation from chip to FPA coordinates + psPlaneTransform* fromFPA; ///< Transformation from FPA to chip coordinates + // Information + psMetadata *concepts; ///< Cache for PS concepts + psMetadata *analysis; ///< Chip-level analysis metadata + psArray *cells; ///< The cells (referred to by name) + pmFPA *parent; ///< Parent FPA + bool process; ///< Do we bother about reading and working with this chip? + bool exists; ///< Does the chip exist --- has it been read in? + p_pmHDU *hdu; ///< FITS data +} +pmChip; + +/** 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 +{ + // Offset specifying position on chip + int col0; ///< Offset from the left of chip. + int row0; ///< Offset from the bottom of chip. + // Astrometric transformations + psPlaneTransform* toChip; ///< Transformations from cell to chip coordinates + psPlaneTransform* toFPA; ///< Transformations from cell to FPA coordinates + psPlaneTransform* toSky; ///< Transformations from cell to sky coordinates + // Information + psMetadata *concepts; ///< Cache for PS concepts + psMetadata *camera; ///< Camera Info + psMetadata *analysis; ///< Cell-level analysis metadata + psArray *readouts; ///< The readouts (referred to by number) + pmChip *parent; ///< Parent chip + bool process; ///< Do we bother about reading and working with this cell? + bool exists; ///< Does the cell exist --- has it been read in? + p_pmHDU *hdu; ///< FITS data +} +pmCell; + +/** Readout data structure. + * + * A readout is the result of a single read of a cell (or a portion thereof). + * It contains the offset from the lower-left corner of the chip, in the case + * that the CCD was windowed, as well as the binning factors and parity (if the + * binning value is negative, then the parity is reversed). It also contains the + * pixel data, metadata containers for the concepts and analysis, and a link to + * the parent. + * + */ +typedef struct +{ + // Position on the cell + // XXX: These may be removed in the future; use parent->concepts instead? + int col0; ///< Offset from the left of chip. + int row0; ///< Offset from the bottom of chip. + int colBins; ///< Amount of binning in x-dimension + int rowBins; ///< Amount of binning in y-dimension + // Information + psImage *image; ///< Imaging area of readout + psImage *mask; ///< Mask of input image + psImage *weight; ///< Weight of input image + psList *bias; ///< Overscan images + psMetadata *analysis; ///< Readout-level analysis metadata + pmCell *parent; ///< Parent cell +} +pmReadout; + +void pmCellFreeReadouts(pmCell *cell); +void pmChipFreeCells(pmChip *chip); + +/** Allocates a pmReadout + * + * The constructor shall make an empty pmReadout. If the parent cell is not + * NULL, the parent link is made and the readout shall be placed in the + * parents array of readouts. The metadata containers shall be allocated. All + * other pointers in the structure shall be initialized to NULL. + * + * @return pmReadout* newly allocated pmReadout with all internal pointers set to NULL + */ +pmReadout *pmReadoutAlloc( + pmCell *cell ///< Parent cell +); + +/** Allocates a pmCell + * + * The constructor shall make an empty pmCell. If the parent chip is not NULL, + * the parent link is made and the cell shall be placed in the parents array of + * cells. The readouts array shall be allocated with a zero size, and the + * metadata containers constructed. All other pointers in the structure shall be + * initialized to NULL. + * + * @return pmCell* newly allocated pmCell + */ +pmCell *pmCellAlloc( + pmChip *chip, ///< Parent chip + psMetadata *cameraData, ///< Camera data + const char *name ///< Name of cell +); + +/** Allocates a pmChip + * + * The constructor shall make an empty pmChip. If the parent fpa is not NULL, + * the parent link is made and the chip shall be placed in the parent's array + * of chips. The cells array shall be allocated with a zero size, and the + * metadata containers constructed. All other pointers in the structure shall be + * initialized to NULL. + * + * @return pmChip* newly allocated pmChip + */ +pmChip *pmChipAlloc( + pmFPA *fpa, ///< FPA to which the chip belongs + const char *name ///< Name of chip +); + +/** Allocates a pmFPA + * + * The constructor shall make an empty pmFPA. The chips array shall be + * allocated with a zero size, the camera and db pointers set to the values + * provided, and the concepts metadata constructed. All other pointers in the + * structure shall be initialized to NULL. + * + */ +pmFPA *pmFPAAlloc( + const psMetadata *camera ///< Camera configuration +); + +/** Allocates a p_pmHDU + * + * XXX: More detailed description + * + * @return p_pmHDU* newly allocated p_pmHDU + */ +p_pmHDU *p_pmHDUAlloc(const char *extname // Extension name + ); + + +/** Verify parent links. + * + * This function checks the validity of the parent links in the FPA hierarchy. + * If a parent link is not set (or not set correctly), it is corrected, and the + * function shall return false. If all the parent pointers were correct, the + * function shall return true. + * + */ +bool pmFPACheckParents( + pmFPA *fpa +); + + + +/** FUNC DESC + * + * + * + * + */ + + + +/** + * + * pmFPASelectChip shall set valid to true for the specified chip number + * (chipNum), and all other chips shall have valid set to false. In the event + * that the specified chip number does not exist within the fpa, the function + * shall return false. + * + */ +bool pmFPASelectChip( + pmFPA *fpa, + int chipNum +); + +bool pmChipSelectCell(pmChip *chip, + int cellNum + ); + +/** + * + * pmFPAExcludeChip shall set valid to false only for the specified chip + * number (chipNum). In the event that the specified chip number does not exist + * within the fpa, the function shall generate a warning, and perform no action. + * The function shall return the number of chips within the fpa that have valid + * set to true. + * + */ +int pmFPAExcludeChip( + pmFPA *fpa, + int chipNum +); + +int pmChipExcludeCell(pmChip *chip, + int cellNum + ); + +// Set the weights and masks within a cell, based on the gain and RN +bool pmCellSetWeights(pmCell *cell // Cell for which to set weights + ); + + + +#endif // #ifndef PM_FPA_H Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/astrom/pmFPAAstrometry.c =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/astrom/pmFPAAstrometry.c (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/astrom/pmFPAAstrometry.c (revision 21664) @@ -0,0 +1,512 @@ +#include +#include "pslib.h" +#include "pmFPAAstrometry.h" +#include "pmFPA.h" + + +/***************************************************************************** +checkValidImageCoords(): this is a private function which simply determines if +the supplied x,y coordinates are in the range for the supplied psImage. + +XXX: What about col0 and row0 +XXX: This should return a psBool. +XXX: Macro this for speed. + *****************************************************************************/ +static psS32 checkValidImageCoords( + double x, + double y, + psImage* tmpImage) +{ + PS_ASSERT_IMAGE_NON_NULL(tmpImage, 0); + + // The FLT_EPSILON is because -0.0 was failing this. + if (((x+FLT_EPSILON) < 0.0) || (x > (double)tmpImage->numCols) || + ((y+FLT_EPSILON) < 0.0) || (y > (double)tmpImage->numRows)) { + return (0); + } + + return (1); +} + +/*****************************************************************************/ +/* FUNCTION IMPLEMENTATION - PUBLIC */ +/*****************************************************************************/ + +pmCell* pmCellInFPA( + const psPlane* fpaCoord, + const pmFPA* FPA) +{ + PS_ASSERT_PTR_NON_NULL(fpaCoord, NULL); + PS_ASSERT_PTR_NON_NULL(FPA, NULL); + + pmChip* tmpChip = NULL; + psPlane chipCoord; + pmCell* outCell = NULL; + + // Determine which chip contains the fpaCoords. + tmpChip = pmChipInFPA(fpaCoord, FPA); + if (tmpChip == NULL) { + return(NULL); + } + + // Convert to those chip coordinates. + psPlane *rc = pmCoordFPAToChip(&chipCoord, fpaCoord, tmpChip); + if (rc == NULL) { + psLogMsg(__func__, PS_LOG_WARN, "WARNING: could not determine Chip coords.\n"); + return(NULL); + } + + // Determine which cell contains those chip coordinates. + outCell = pmCellInChip(&chipCoord, tmpChip); + if (outCell == NULL) { + psLogMsg(__func__, PS_LOG_WARN, "WARNING: could not determine the cell.\n"); + return(NULL); + } + + return (outCell); +} + +pmChip* pmChipInFPA( + const psPlane* fpaCoord, + const pmFPA* FPA) +{ + PS_ASSERT_PTR_NON_NULL(fpaCoord, NULL); + PS_ASSERT_PTR_NON_NULL(FPA, NULL); + PS_ASSERT_PTR_NON_NULL(FPA->chips, NULL); + + psArray* chips = FPA->chips; + psS32 nChips = chips->n; + psPlane chipCoord; + pmCell *tmpCell = 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. + // XXX: Depending on the number of chips, and their topology, there may be + // a much more efficient way of doing this. + // + for (psS32 i = 0; i < nChips; i++) { + pmChip* tmpChip = chips->data[i]; + PS_ASSERT_PTR_NON_NULL(tmpChip, NULL); + PS_ASSERT_PTR_NON_NULL(tmpChip->fromFPA, NULL); + + psPlaneTransformApply(&chipCoord, tmpChip->fromFPA, fpaCoord); + + tmpCell = pmCellInChip(&chipCoord, tmpChip); + if (tmpCell != NULL) { + return(tmpChip); + } + } + + psLogMsg(__func__, PS_LOG_WARN, "WARNING: could not determine the chip.\n"); + return (NULL); +} + + +pmCell* pmCellInChip( + const psPlane* chipCoord, + const pmChip* chip) +{ + PS_ASSERT_PTR_NON_NULL(chipCoord, NULL); + PS_ASSERT_PTR_NON_NULL(chip, NULL); + + psPlane cellCoord; + psArray* cells; + + 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. + // XXX: Depending on the number of cells, and their topology, there may be + // a much more efficient way of doing this. + // + for (psS32 i = 0; i < cells->n; i++) { + pmCell* tmpCell = (pmCell* ) cells->data[i]; + PS_ASSERT_PTR_NON_NULL(tmpCell, NULL); + + psPlaneTransform *chipToCell = NULL; + if (true == p_psIsProjectionLinear(tmpCell->toChip)) { + chipToCell = p_psPlaneTransformLinearInvert(tmpCell->toChip); + } else { + psLogMsg(__func__, PS_LOG_WARN, "WARNING: non-linear cell->chip transforms are not yet implemented.\n"); + //chipToCell = psPlaneTransformInvert(NULL, tmpCell->toChip, NULL, -1); + chipToCell = NULL; + } + if (chipToCell == NULL) { + psLogMsg(__func__, PS_LOG_WARN, "WARNING: could not invert the Cell->toChip transform.\n"); + return(NULL); + } + psArray* readouts = tmpCell->readouts; + + if (readouts != NULL) { + for (psS32 j = 0; j < readouts->n; j++) { + pmReadout* tmpReadout = readouts->data[j]; + PS_ASSERT_READOUT_NON_NULL(tmpReadout, NULL); + + psPlaneTransformApply(&cellCoord, + chipToCell, + chipCoord); + + if (checkValidImageCoords(cellCoord.x, + cellCoord.y, + tmpReadout->image)) { + psFree(chipToCell); + return (tmpCell); + } + } + } + psFree(chipToCell); + } + + //psLogMsg(__func__, PS_LOG_WARN, "WARNING: could not determine the cell.\n"); + return (NULL); +} + + +psPlane* pmCoordCellToFPA( + psPlane* fpaCoord, + const psPlane* cellCoord, + const pmCell* cell) +{ + PS_ASSERT_PTR_NON_NULL(cellCoord, NULL); + PS_ASSERT_PTR_NON_NULL(cell, NULL); + + psPlane *rc = psPlaneTransformApply(fpaCoord, cell->toFPA, cellCoord); + if (rc == NULL) { + psLogMsg(__func__, PS_LOG_WARN, "WARNING: could not transform cell coords to FPA coords.\n"); + } + return(rc); +} + + +psPlane* pmCoordChipToFPA( + psPlane* outCoord, + const psPlane* inCoord, + const pmChip* chip) +{ + PS_ASSERT_PTR_NON_NULL(inCoord, NULL); + PS_ASSERT_PTR_NON_NULL(chip, NULL); + + psPlane *rc = psPlaneTransformApply(outCoord, chip->toFPA, inCoord); + if (rc == NULL) { + psLogMsg(__func__, PS_LOG_WARN, "WARNING: could not transform chip coords to FPA coords.\n"); + } + return(rc); +} + + +psPlane* pmCoordFPAToChip( + psPlane* chipCoord, + const psPlane* fpaCoord, + const pmChip* chip) +{ + PS_ASSERT_PTR_NON_NULL(fpaCoord, NULL); + PS_ASSERT_PTR_NON_NULL(chip, NULL); + PS_ASSERT_PTR_NON_NULL(chip->fromFPA, NULL); + + psPlane *rc = psPlaneTransformApply(chipCoord, chip->fromFPA, fpaCoord); + if (rc == NULL) { + psLogMsg(__func__, PS_LOG_WARN, "WARNING: could not transform FPA coords to Chip coords.\n"); + } + return(rc); +} + +psPlane* pmCoordCellToChip( + psPlane* outCoord, + const psPlane* inCoord, + const pmCell* cell) +{ + PS_ASSERT_PTR_NON_NULL(inCoord, NULL); + PS_ASSERT_PTR_NON_NULL(cell, NULL); + + psPlane *rc = psPlaneTransformApply(outCoord, cell->toChip, inCoord); + if (rc == NULL) { + psLogMsg(__func__, PS_LOG_WARN, "WARNING: could not transform Cell coords to Chip coords.\n"); + } + return(rc); +} + +psPlane* pmCoordChipToCell( + psPlane* cellCoord, + const psPlane* chipCoord, + const pmCell* cell) +{ + PS_ASSERT_PTR_NON_NULL(chipCoord, NULL); + PS_ASSERT_PTR_NON_NULL(cell, NULL); + PS_ASSERT_PTR_NON_NULL(cell->parent, NULL); + + pmCell *tmpCell = pmCellInChip(chipCoord, cell->parent); + if (tmpCell == NULL) { + psLogMsg(__func__, PS_LOG_WARN, "WARNING: could not determine the proper cell.\n"); + return(NULL); + } + + psPlaneTransform *tmpChipToCell = NULL; + PS_ASSERT_PTR_NON_NULL(tmpCell->toChip, NULL); + if (true == p_psIsProjectionLinear(tmpCell->toChip)) { + tmpChipToCell = p_psPlaneTransformLinearInvert(tmpCell->toChip); + } else { + psLogMsg(__func__, PS_LOG_WARN, "WARNING: non-linear cell->chip transforms are not yet implemented.\n"); + // XXX: tmpChipToCell = psPlaneTransformInvert(NULL, tmpCell->toChip, NULL, -1); + tmpChipToCell = NULL; + } + if (tmpChipToCell == NULL) { + psLogMsg(__func__, PS_LOG_WARN, "WARNING: could not invert the Cell->toChip transform.\n"); + return(NULL); + } + + psPlane *rc = psPlaneTransformApply(cellCoord, tmpChipToCell, chipCoord); + if (rc == NULL) { + psLogMsg(__func__, PS_LOG_WARN, "WARNING: could not transform Chip coords to Cell coords.\n"); + } + psFree(tmpChipToCell); + return(rc); +} + +psPlane* pmCoordFPAToTP( + psPlane* outCoord, + const psPlane* inCoord, + double color, + double magnitude, + const pmFPA* fpa) +{ + PS_ASSERT_PTR_NON_NULL(inCoord, NULL); + PS_ASSERT_PTR_NON_NULL(fpa, NULL); + + psPlane *rc = psPlaneDistortApply(outCoord, fpa->toTangentPlane, inCoord, color, magnitude); + if (rc == NULL) { + psLogMsg(__func__, PS_LOG_WARN, "WARNING: could not transform FPA coords to tangent plane coords.\n"); + } + return(rc); +} + +psPlane* pmCoordTPToFPA( + psPlane* fpaCoord, + const psPlane* tpCoord, + double color, + double magnitude, + const pmFPA* fpa) +{ + PS_ASSERT_PTR_NON_NULL(tpCoord, NULL); + PS_ASSERT_PTR_NON_NULL(fpa, NULL); + PS_ASSERT_PTR_NON_NULL(fpa->fromTangentPlane, NULL); + + psPlane *rc = psPlaneDistortApply(fpaCoord, fpa->fromTangentPlane, tpCoord, color, magnitude); + if (rc == NULL) { + psLogMsg(__func__, PS_LOG_WARN, "WARNING: could not transform tangent plane coords to FPA coords.\n"); + } + return(rc); +} + + +/***************************************************************************** +XXXDeproject(outSphere, coord, projection): This private routine is a wrapper +for p_psDeproject(). The reason: p_psDeproject() and p_psProject() combined +do not seem to produce the original coordinates when they even though they +should. XXXDeproject() simply negates the ->r and ->d members of the output +psSphere if the input ->y is larger than 0.0. I don't know why it works. + +I'm guessing the p_psProject() and p_psDeproject() functions have bugs. + +XXX: It appears that p_psProject() and p_psDeproject() have been fixed. +Remove this. + *****************************************************************************/ +psSphere* XXXDeproject( + psSphere *outSphere, + const psPlane* coord, + const psProjection* projection) +{ + psSphere *rc = p_psDeproject(outSphere, coord, projection); + + if (coord->y >= 0.0) { + rc->d = -rc->d; + rc->r = -rc->r; + } + + return(rc); +} + +/***************************************************************************** + *****************************************************************************/ +psSphere* pmCoordTPToSky( + psSphere* outSphere, + const psPlane* tpCoord, + const psProjection *projection) +{ + PS_ASSERT_PTR_NON_NULL(tpCoord, NULL); + PS_ASSERT_PTR_NON_NULL(projection, NULL); + + // psSphere *rc = XXXDeproject(outSphere, tpCoord, projection); + psSphere *rc = p_psDeproject(outSphere, tpCoord, projection); + if (rc == NULL) { + psLogMsg(__func__, PS_LOG_WARN, "WARNING: could not transform tangent plane coords to sky coords.\n"); + } + return(rc); +} + +/***************************************************************************** + *****************************************************************************/ +psPlane* pmCoordSkyToTP( + psPlane* tpCoord, + const psSphere* in, + const psProjection *projection) +{ + PS_ASSERT_PTR_NON_NULL(in, NULL); + PS_ASSERT_PTR_NON_NULL(projection, NULL); + + psPlane *rc = p_psProject(tpCoord, in, projection); + if (rc == NULL) { + psLogMsg(__func__, PS_LOG_WARN, "WARNING: could not transform sky to tangent plane coords.\n"); + } + return(rc); +} + +/***************************************************************************** + *****************************************************************************/ +psSphere* pmCoordCellToSky( + psSphere* skyCoord, + const psPlane* cellCoord, + double color, + double magnitude, + const pmCell* cell) +{ + PS_ASSERT_PTR_NON_NULL(cellCoord, NULL); + PS_ASSERT_PTR_NON_NULL(cell, NULL); + PS_ASSERT_PTR_NON_NULL(cell->toFPA, NULL); + PS_ASSERT_PTR_NON_NULL(cell->parent, NULL); + PS_ASSERT_PTR_NON_NULL(cell->parent->parent, NULL); + PS_ASSERT_PTR_NON_NULL(cell->parent->parent->toTangentPlane, NULL); + PS_ASSERT_PTR_NON_NULL(cell->parent->parent->projection, NULL); + psPlane fpaCoord; + psPlane tpCoord; + psPlane *rc; + pmFPA* parFPA = (cell->parent)->parent; + + // Convert the input cell coordinates to FPA coordinates. + rc = psPlaneTransformApply(&fpaCoord, cell->toFPA, cellCoord); + if (rc == NULL) { + psLogMsg(__func__, PS_LOG_WARN, "WARNING: could transform cell coords to FPA coords.\n"); + return(NULL); + } + + // Convert the FPA coordinates to tangent plane Coordinates. + rc = psPlaneDistortApply(&tpCoord, parFPA->toTangentPlane, &fpaCoord, color, magnitude); + if (rc == NULL) { + psLogMsg(__func__, PS_LOG_WARN, "WARNING: could transform FPA coords to tangent plane coords.\n"); + return(NULL); + } + + // Convert the tangent plane Coordinates to sky coordinates. + psSphere *rc2 = pmCoordTPToSky(skyCoord, &tpCoord, parFPA->projection); + if (rc2 == NULL) { + psLogMsg(__func__, PS_LOG_WARN, "WARNING: could not transform cell coords to sky coords.\n"); + } + + return(rc2); +} + +/***************************************************************************** + *****************************************************************************/ +psPlane* pmCoordSkyToCell( + psPlane* cellCoord, + const psSphere* skyCoord, + float color, + float magnitude, + const pmCell* cell) +{ + PS_ASSERT_PTR_NON_NULL(skyCoord, NULL); + PS_ASSERT_PTR_NON_NULL(cell, NULL); + PS_ASSERT_PTR_NON_NULL(cell->parent, NULL); + PS_ASSERT_PTR_NON_NULL(cell->parent->parent, NULL); + pmChip *parChip = cell->parent; + pmFPA *parFPA = parChip->parent; + psPlane tpCoord; + psPlane fpaCoord; + psPlane chipCoord; + psPlane *rc; + + // Convert the skyCoords to tangent plane coords. + rc = pmCoordSkyToTP(&tpCoord, skyCoord, parFPA->projection); + if (rc == NULL) { + psLogMsg(__func__, PS_LOG_WARN, "WARNING: could not determine tangent plane coords.\n"); + return(NULL); + } + + // Convert the tangent plane coords to FPA coords. + rc = pmCoordTPToFPA(&fpaCoord, &tpCoord, color, magnitude, parFPA); + if (rc == NULL) { + psLogMsg(__func__, PS_LOG_WARN, "WARNING: could not determine FPA coords.\n"); + return(NULL); + } + + // Convert the FPA coords to chip coords. + rc = pmCoordFPAToChip(&chipCoord, &fpaCoord, parChip); + if (rc == NULL) { + psLogMsg(__func__, PS_LOG_WARN, "WARNING: could not determine chip coords.\n"); + return(NULL); + } + + // Convert the chip coords to cell coords. + rc = pmCoordChipToCell(cellCoord, &chipCoord, cell); + if (rc == NULL) { + psLogMsg(__func__, PS_LOG_WARN, "WARNING: could not determine cell coords.\n"); + return(NULL); + } + + return (cellCoord); +} + +/***************************************************************************** + *****************************************************************************/ +psSphere* pmCoordCellToSkyQuick( + psSphere* outSphere, + const psPlane* cellCoord, + const pmCell* cell) +{ + PS_ASSERT_PTR_NON_NULL(cellCoord, NULL); + PS_ASSERT_PTR_NON_NULL(cell, NULL); + PS_ASSERT_PTR_NON_NULL(cell->toSky, NULL); + psPlane outPlane; + psPlane *rc; + rc = psPlaneTransformApply(&outPlane, cell->toSky, cellCoord); + if (rc == NULL) { + psLogMsg(__func__, PS_LOG_WARN, "WARNING: could transform cell coords to sky coords.\n"); + return(NULL); + } + + psSphere *out = outSphere; + if (out == NULL) { + out = psSphereAlloc(); + } + out->r = outPlane.y; + out->d = outPlane.x; + + return(out); +} + +/***************************************************************************** + *****************************************************************************/ +psPlane* pmCoordSkyToCellQuick( + psPlane* cellCoord, + const psSphere* skyCoord, + const pmCell* cell) +{ + PS_ASSERT_PTR_NON_NULL(skyCoord, NULL); + PS_ASSERT_PTR_NON_NULL(cell, NULL); + PS_ASSERT_PTR_NON_NULL(cell->toSky, NULL); + psPlane skyPlane; + skyPlane.y = skyCoord->r; + skyPlane.x = skyCoord->d; + + psPlane *rc = psPlaneTransformApply(cellCoord, cell->toSky, &skyPlane); + if (rc == NULL) { + psLogMsg(__func__, PS_LOG_WARN, "WARNING: could not transform sky to cell coords.\n"); + } + return(cellCoord); +} Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/astrom/pmFPAAstrometry.h =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/astrom/pmFPAAstrometry.h (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/astrom/pmFPAAstrometry.h (revision 21664) @@ -0,0 +1,188 @@ +#ifndef PM_FPA_ASTROMETRY_H +#define PM_FPA_ASTROMETRY_H + +#include "pslib.h" +#include "pmFPA.h" + +/** Find cooresponding cell for given FPA coordinate + * + * @return pmCell* the cell cooresponding to the coord in FPA + */ +pmCell* pmCellInFPA( + const psPlane* coord, ///< the coordinate in FPA plane + const pmFPA* FPA ///< the FPA to search for the cell +); + + +/** Find cooresponding chip for given FPA coordinate + * + * @return pmChip* the chip cooresponding to coord + */ +pmChip* pmChipInFPA( + const psPlane* coord, ///< the coordinate in FPA plane + const pmFPA* FPA ///< the FPA to search for the cell +); + + +/** Find cooresponding cell for given Chip coordinate + * + * @return pmCell* the cell cooresponding to coord + */ +pmCell* pmCellInChip( + const psPlane* coord, ///< the coordinate in Chip plane + const pmChip* chip ///< the chip to search for the cell +); + + +/** Translate a cell coordinate into a chip coordinate + * + * @return psPlane* the resulting chip coordinate + */ +psPlane* pmCoordCellToChip( + psPlane* out, ///< a plane struct to recycle. If NULL, a new struct is created + const psPlane* in, ///< the coordinate within Cell + const pmCell* cell ///< the Cell in interest +); + + +/** Translate a chip coordinate into a FPA coordinate + * + * @return psPlane* the resulting FPA coordinate + */ +psPlane* pmCoordChipToFPA( + psPlane* out, ///< a plane struct to recycle. If NULL, a new struct is created + const psPlane* in, ///< the coordinate within Chip + const pmChip* chip ///< the chip in interest +); + + +/** Translate a FPA coordinate into a Tangent Plane coordinate + * + * @return psPlane* the resulting Tangent Plane coordinate + */ +psPlane* pmCoordFPAToTP( + 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 pmFPA* fpa ///< the FPA in interest +); + + +/** Translate a Tangent Plane coordinate into a Sky coordinate + * + * @return psSphere* the resulting Sky coordinate + */ +psSphere* pmCoordTPToSky( + psSphere* out, ///< a sphere struct to recycle. If NULL, a new struct is created + const psPlane* in, ///< the coordinate within Tangent Plane + const psProjection *projection +); + +/** Translate a cell coordinate into a FPA coordinate + * + * @return psPlane* the resulting FPA coordinate + */ +psPlane* pmCoordCellToFPA( + psPlane* out, ///< a plane struct to recycle. If NULL, a new struct is created + const psPlane* in, ///< the coordinate within cell + const pmCell* cell ///< the cell in interest +); + + +/** Translate a cell coordinate into a Sky coordinate + * + * @return psSphere* the resulting Sky coordinate + */ +psSphere* pmCoordCellToSky( + 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 pmCell* 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* pmCoordCellToSkyQuick( + psSphere* out, ///< a sphere struct to recycle. If NULL, a new struct is created + const psPlane* in, ///< the coordinate within cell + const pmCell* cell ///< the cell in interest +); + + +/** Translate a Sky coordinate into a Tangent Plane coordinate + * + * @return psPlane* the resulting Tangent Plane coordinate + */ +psPlane* pmCoordSkyToTP( + psPlane* out, ///< a plane struct to recycle. If NULL, a new struct is created + const psSphere* in, ///< the sky coordinate + const psProjection *projection +); + +/** Translate a Tangent Plane coordinate into a FPA coordinate + * + * @return psPlane* the resulting FPA coordinate + */ +psPlane* pmCoordTPToFPA( + 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 pmFPA* fpa ///< the FPA of interest +); + + +/** Translate a FPA coordinate into a chip coordinate + * + * @return psPlane* the resulting chip coordinate + */ +psPlane* pmCoordFPAToChip( + psPlane* out, ///< a plane struct to recycle. If NULL, a new struct is created + const psPlane* in, ///< the FPA coordinate + const pmChip* chip ///< the chip of interest +); + + +/** Translate a chip coordinate into a cell coordinate + * + * @return psPlane* the resulting cell coordinate + */ +psPlane* pmCoordChipToCell( + psPlane* out, ///< a plane struct to recycle. If NULL, a new struct is created + const psPlane* in, ///< the Chip coordinate + const pmCell* cell ///< the cell of interest +); + + +/** Translate a sky coordinate into a cell coordinate + * + * @return psPlane* the resulting cell coordinate + */ +psPlane* pmCoordSkyToCell( + psPlane* out, ///< a plane struct to recycle. If NULL, a new struct is created + const psSphere* in, ///< the Sky coordinate + float color, ///< Color of source + float magnitude, ///< Magnitude of source + const pmCell* 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* pmCoordSkyToCellQuick( + psPlane* out, ///< a plane struct to recycle. If NULL, a new struct is created + const psSphere* in, ///< the Sky coordinate + const pmCell* cell ///< the cell of interest +); + + +#endif Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/astrom/pmFPAConceptsGet.c =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/astrom/pmFPAConceptsGet.c (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/astrom/pmFPAConceptsGet.c (revision 21664) @@ -0,0 +1,1197 @@ +#include +#include +#include +#include "pslib.h" + +#include "pmAstrometry.h" +#include "pmFPAConceptsGet.h" + +////////////////////////////////////////////////////////////////////////////////////////////////////////////// +// Private functions +////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +psMetadataItem *p_pmFPAConceptGetFromCamera(pmCell *cell, // The cell + const char *concept // Name of concept + ) +{ + if (cell) { + psMetadata *camera = cell->camera; // Camera data + psMetadataItem *item = psMetadataLookup(camera, concept); + return item; + } + return NULL; +} + + +psMetadataItem *p_pmFPAConceptGetFromHeader(pmFPA *fpa, // The FPA that contains the chip + pmChip *chip, // The chip that contains the cell + pmCell *cell, // The cell + const char *concept // Name of concept + ) +{ + bool mdStatus = true; // Status of MD lookup + psMetadata *translation = psMetadataLookupMD(&mdStatus, fpa->camera, "TRANSLATION"); // FITS translation + if (! mdStatus) { + psError(PS_ERR_IO, false, "Unable to find TRANSLATION in camera configuration.\n"); + return NULL; + } + + // Look for how to translate the concept into a FITS header name + const char *keyword = psMetadataLookupStr(&mdStatus, translation, concept); + if (mdStatus && strlen(keyword) > 0) { + // We have a FITS header to look up --- search each level + if (cell && cell->hdu) { + psMetadataItem *cellItem = psMetadataLookup(cell->hdu->header, keyword); + if (cellItem) { + // XXX: Need to clean up before returning + return cellItem; + } + } + + if (chip && chip->hdu) { + psMetadataItem *chipItem = psMetadataLookup(chip->hdu->header, keyword); + if (chipItem) { + // XXX: Need to clean up before returning + return chipItem; + } + } + + if (fpa->hdu) { + psMetadataItem *fpaItem = psMetadataLookup(fpa->hdu->header, keyword); + if (fpaItem) { + // XXX: Need to clean up before returning + return fpaItem; + } + } + + if (fpa->phu) { + psMetadataItem *fpaItem = psMetadataLookup(fpa->phu, keyword); + if (fpaItem) { + // XXX: Need to clean up before returning + return fpaItem; + } + } + } + + // No header value + return NULL; +} + + +// Look for a default +psMetadataItem *p_pmFPAConceptGetFromDefault(pmFPA *fpa, // The FPA that contains the chip + pmChip *chip, // The chip that contains the cell + pmCell *cell, // The cell + const char *concept // Name of concept + ) +{ + bool mdOK = true; // Status of MD lookup + psMetadata *defaults = psMetadataLookupMD(&mdOK, fpa->camera, "DEFAULTS"); + if (! mdOK) { + psError(PS_ERR_IO, false, "Unable to find DEFAULTS in camera configuration.\n"); + return NULL; + } + + psMetadataItem *defItem = psMetadataLookup(defaults, concept); + if (defItem) { + if (defItem->type == PS_DATA_METADATA) { + // A dependent default + psTrace(__func__, 7, "Evaluating dependent default....\n"); + psMetadata *dependents = defItem->data.V; // The list of dependents + // Find out what it depends on + psString dependName = psStringCopy(concept); + psStringAppend(&dependName, ".DEPEND"); + psString dependsOn = psMetadataLookupStr(&mdOK, defaults, dependName); + if (! mdOK) { + psError(PS_ERR_IO, false, "Unable to find %s in camera configuration for dependent default" + " --- ignored\n", dependName); + // XXX: Need to clean up before returning + return NULL; + } + psFree(dependName); + // Find the value of the dependent concept + psMetadataItem *depItem = p_pmFPAConceptGetFromHeader(fpa, chip, cell, dependsOn); + if (! depItem) { + psError(PS_ERR_IO, true, "Unable to find value for %s (required for %s)\n", dependsOn, + concept); + return NULL; + } + if (depItem->type != PS_DATA_STRING) { + psError(PS_ERR_IO, true, "Value of %s is not of type string, as required for dependency" + " --- ignored.\n", dependsOn); + } + + defItem = psMetadataLookup(dependents, depItem->data.V); // This is now what we were after + } + } + + // XXX: Need to clean up before returning + return defItem; // defItem is either NULL or points to what was desired +} + + +// Look for a database lookup +// XXX: Not tested +psMetadataItem *p_pmFPAConceptGetFromDB(pmFPA *fpa, // The FPA that contains the chip + pmChip *chip, // The chip that contains the cell + pmCell *cell, // The cell + psDB *db, // DB handle + const char *concept // Name of concept + ) +{ + if (! db) { + // No database initialised + return NULL; + } + + bool mdStatus = true; // Status of MD lookup + psMetadata *database = psMetadataLookupMD(&mdStatus, fpa->camera, "DATABASE"); + if (! mdStatus) { + // No error, because not everyone needs to use the DB + return NULL; + } + + psMetadata *dbLookup = psMetadataLookupMD(&mdStatus, database, concept); + if (dbLookup) { + const char *tableName = psMetadataLookupStr(&mdStatus, dbLookup, "TABLE"); // Name of the table + // const char *colName = psMetadataLookupStr(&mdStatus, dbLookup, "COLUMN"); // Name of the column + const char *givenCols = psMetadataLookupStr(&mdStatus, dbLookup, "GIVENDBCOL"); // Name of "where" + // columns + const char *givenPS = psMetadataLookupStr(&mdStatus, dbLookup, "GIVENPS"); // Values for "where" + // columns + + // Now, need to get the "given"s + if (strlen(givenCols) || strlen(givenPS)) { + psList *cols = psStringSplit(givenCols, ",;"); // List of column names + psList *values = psStringSplit(givenPS, ",;"); // List of value names for the columns + psMetadata *selection = psMetadataAlloc(); // The stuff to select in the DB + if (cols->n != values->n) { + psLogMsg(__func__, PS_LOG_WARN, "The GIVENDBCOL and GIVENPS entries for %s do not have " + "the same number of entries --- ignored.\n", concept); + } else { + // Iterators for the lists + psListIterator *colsIter = psListIteratorAlloc(cols, PS_LIST_HEAD, false); + psListIterator *valuesIter = psListIteratorAlloc(values, PS_LIST_HEAD, false); + char *column = NULL; // Name of the column + while ((column = psListGetAndIncrement(colsIter))) { + char *name = psListGetAndIncrement(valuesIter); // Name for the value + if (!strlen(column) || !strlen(name)) { + psLogMsg(__func__, PS_LOG_WARN, "One of the columns or value names for %s is " + " empty --- ignored.\n", concept); + } else { + // Search for the value name + psMetadataItem *item = p_pmFPAConceptGetFromHeader(fpa, chip, cell, name); + if (! item) { + item = p_pmFPAConceptGetFromDefault(fpa, chip, cell, name); + } + if (! item) { + psLogMsg(__func__, PS_LOG_ERROR, "Unable to find the value name %s for DB " + " lookup on %s --- ignored.\n", name, concept); + } else { + // We need to create a new psMetadataItem. I don't think we can't simply hack + // the existing one, since that could conceivably cause memory leaks + psMetadataItem *newItem = psMetadataItemAlloc(concept, item->type, + item->comment, item->data.V); + psMetadataAddItem(selection, newItem, PS_LIST_TAIL, PS_META_REPLACE); + psFree(newItem); + } + } + psFree(name); + psFree(column); + } // Iterating through the columns + psFree(colsIter); + psFree(valuesIter); + + psArray *dbResult = psDBSelectRows(db, tableName, selection, 2); // Lookup result + // Note that we use limit=2 in order to test if there are multiple rows returned + + psMetadataItem *result = NULL; // The final result of the DB lookup + if (dbResult->n == 0) { + psLogMsg(__func__, PS_LOG_WARN, "Unable to find any rows in DB for %s --- ignored\n", + concept); + } else { + if (dbResult-> n > 1) { + psLogMsg(__func__, PS_LOG_WARN, "Multiple rows returned in DB lookup for %s --- " + " using the first one only.\n", concept); + } + result = (psMetadataItem*)dbResult->data[0]; + } + // XXX: Need to clean up before returning + return result; + } + psFree(cols); + psFree(values); + } + } // Doing the "given"s. + + psAbort(__func__, "Shouldn't ever get here.\n"); + return NULL; +} + + +// Concept lookup +psMetadataItem *p_pmFPAConceptGet(pmFPA *fpa, // The FPA + pmChip *chip,// The chip + pmCell *cell, // The cell + psDB *db, // DB handle + const char *concept // Concept name + ) +{ + // Try headers, database, defaults in order + psMetadataItem *item = p_pmFPAConceptGetFromCamera(cell, concept); + if (! item) { + item = p_pmFPAConceptGetFromHeader(fpa, chip, cell, concept); + } + if (! item) { + item = p_pmFPAConceptGetFromDB(fpa, chip, cell, db, concept); + } + if (! item) { + item = p_pmFPAConceptGetFromDefault(fpa, chip, cell, concept); + } + return item; // item is either NULL, or points to what was desired +} + + +void p_pmFPAConceptGetF32(pmFPA *fpa, // The FPA + pmChip *chip, // The chip + pmCell *cell, // The cell + psDB *db, // DB handle + psMetadata *concepts, // The concepts MD + const char *name, // Name of the concept + const char *comment // Comment for concept + ) +{ + psMetadataItem *item = p_pmFPAConceptGet(fpa, chip, cell, db, name); + float value = NAN; + if (item) { + switch (item->type) { + case PS_DATA_F32: + value = item->data.F32; + break; + case PS_DATA_F64: + // Assume it's OK to truncate to floating point from double + value = (float)item->data.F64; + break; + case PS_DATA_S32: + // Promote to float + value = (float)item->data.S32; + break; + default: + psError(PS_ERR_IO, true, "Concept %s (%s) is not of floating point type (%x) --- treating as " + "undefined.\n", name, comment, item->type); + } + } else { + psError(PS_ERR_IO, true, "Concept %s (%s) is not defined.\n", name, comment); + } + psTrace(__func__, 7, "Adding %s (%s): %f\n", name, comment, value); + + psMetadataAdd(concepts, PS_LIST_TAIL, name, PS_TYPE_F32 | PS_META_REPLACE, comment, value); +} + +void p_pmFPAConceptGetF64(pmFPA *fpa, // The FPA + pmChip *chip, // The chip + pmCell *cell, // The cell + psDB *db, // DB handle + psMetadata *concepts, // The concepts MD + const char *name, // Name of the concept + const char *comment // Comment for concept + ) +{ + psMetadataItem *item = p_pmFPAConceptGet(fpa, chip, cell, db, name); + double value = NAN; + if (item) { + switch (item->type) { + case PS_TYPE_F64: + value = item->data.F64; + break; + case PS_TYPE_F32: + // Promote to double + value = (double)item->data.F32; + break; + case PS_TYPE_S32: + // Promote to double + value = (double)item->data.S32; + break; + default: + psError(PS_ERR_IO, true, "Concept %s (%s) is not of double-precision floating point type (%x) " + "--- treating as undefined.\n", name, comment, item->type); + } + } else { + psError(PS_ERR_IO, true, "Concept %s (%s) is not defined.\n", name, comment); + } + psTrace(__func__, 7, "Adding %s (%s): %f\n", name, comment, value); + + psMetadataAdd(concepts, PS_LIST_TAIL, name, PS_TYPE_F64 | PS_META_REPLACE, comment, value); +} + +void p_pmFPAConceptGetS32(pmFPA *fpa, // The FPA + pmChip *chip, // The chip + pmCell *cell, // The cell + psDB *db, // DB handle + psMetadata *concepts, // The concepts MD + const char *name, // Name of the concept + const char *comment // Comment for concept + ) +{ + psMetadataItem *item = p_pmFPAConceptGet(fpa, chip, cell, db, name); + int value = 0; + if (item) { + switch (item->type) { + case PS_TYPE_S32: + value = item->data.S32; + break; + case PS_TYPE_F32: + psLogMsg(__func__, PS_LOG_WARN, "Concept %s (%s) should be S32, but is F32 --- converting.\n", + name, comment); + value = (int)item->data.F32; + break; + case PS_TYPE_F64: + psLogMsg(__func__, PS_LOG_WARN, "Concept %s (%s) should be S32, but is F64 --- converting.\n", + name, comment); + value = (int)item->data.F64; + break; + default: + psError(PS_ERR_IO, true, "Concept %s (%s) is not of integer type (%x) --- treating as " + "undefined.\n", name, comment, item->type); + } + } else { + psError(PS_ERR_IO, true, "Concept %s (%s) is not defined.\n", name, comment); + } + psTrace(__func__, 7, "Adding %s (%s): %d\n", name, comment, value); + + psMetadataAdd(concepts, PS_LIST_TAIL, name, PS_TYPE_S32 | PS_META_REPLACE, comment, value); +} + +void p_pmFPAConceptGetString(pmFPA *fpa, // The FPA + pmChip *chip, // The chip + pmCell *cell, // The cell + psDB *db, // DB handle + psMetadata *concepts, // The concepts MD + const char *name, // Name of the concept + const char *comment // Comment for concept + ) +{ + psMetadataItem *item = p_pmFPAConceptGet(fpa, chip, cell, db, name); + psString value = NULL; + if (item) { + switch (item->type) { + case PS_DATA_STRING: + value = psMemIncrRefCounter(item->data.V); + break; + case PS_DATA_F32: + psStringAppend(&value, "%f", item->data.F32); + break; + case PS_DATA_S32: + psStringAppend(&value, "%d", item->data.S32); + break; + default: + psError(PS_ERR_IO, true, "Concept %s (%s) is not of string type (%x) --- treating as " + "undefined.\n", name, comment, item->type); + } + } else { + psError(PS_ERR_IO, true, "Concept %s (%s) is not defined.\n", name, comment); + value = psStringCopy(""); + } + psTrace(__func__, 7, "Adding %s (%s): %s\n", name, comment, value); + + psMetadataAdd(concepts, PS_LIST_TAIL, name, PS_DATA_STRING | PS_META_REPLACE, comment, value); + psFree(value); +} + + +////////////////////////////////////////////////////////////////////////////////////////////////////////////// +// Public functions +////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +// Ingest concepts for the FPA +void pmFPAIngestConcepts(pmFPA *fpa, // The FPA + psDB *db // DB handle + ) +{ + if (! fpa->concepts) { + fpa->concepts = psMetadataAlloc(); + } + + // FPA.NAME + p_pmFPAConceptGetString(fpa, NULL, NULL, db, fpa->concepts, "FPA.NAME", "Name of FPA"); + + // FPA.AIRMASS + p_pmFPAConceptGetF32(fpa, NULL, NULL, db, fpa->concepts, "FPA.AIRMASS", "Airmass at boresight"); + + // FPA.FILTER + p_pmFPAConceptGetString(fpa, NULL, NULL, db, fpa->concepts, "FPA.FILTER", "Filter used"); + + // FPA.POSANGLE + p_pmFPAConceptGetF32(fpa, NULL, NULL, db, fpa->concepts, "FPA.POSANGLE", "Position angle for instrument"); + + // FPA.RADECSYS + p_pmFPAConceptGetString(fpa, NULL, NULL, db, fpa->concepts, "FPA.RADECSYS", "Celestial coordinate system"); + + // These take some extra work + + // FPA.RA + { + double ra = NAN; // The RA + psMetadataItem *raItem = p_pmFPAConceptGet(fpa, NULL, NULL, db, "FPA.RA"); // The FPA.RA item + if (raItem) + { + switch (raItem->type) { + case PS_TYPE_F32: + ra = raItem->data.F32; + break; + case PS_TYPE_F64: + ra = raItem->data.F64; + break; + case PS_DATA_STRING: + // Sexagesimal format + { + int big, medium; + float small; + // XXX: Upgrade path is to allow dd:mm.mmm + if (sscanf(raItem->data.V, "%d:%d:%f", &big, &medium, &small) != 3 && + sscanf(raItem->data.V, "%d %d %f", &big, &medium, &small) != 3) + { + psError(PS_ERR_IO, true, "Cannot interpret FPA.RA: %s\n", raItem->data.V); + break; + } + ra = abs(big) + (float)medium/60.0 + small/3600.0; + if (big < 0) + { + ra *= -1.0; + } + } + break; + default: + psError(PS_ERR_IO, true, "FPA.RA is of an unexpected type: %x\n", raItem->type); + } + + // How to interpret the RA + const psMetadata *camera = fpa->camera; // Camera configuration data + bool mdok = true; // Status of MD lookup + psMetadata *formats = psMetadataLookupMD(&mdok, camera, "FORMATS"); + if (mdok && formats) { + psString raFormat = psMetadataLookupStr(&mdok, formats, "FPA.RA"); + if (mdok && strlen(raFormat) > 0) { + if (strcasecmp(raFormat, "HOURS") == 0) { + ra *= M_PI / 12.0; + } else if (strcasecmp(raFormat, "DEGREES") == 0) { + ra *= M_PI / 180.0; + } else if (strcasecmp(raFormat, "RADIANS") == 0) { + // No action required + } else { + psLogMsg(__func__, PS_LOG_WARN, "Don't understand FPA.RA in FORMATS (%s) --- assuming" + " HOURS.\n"); + ra *= M_PI / 12.0; + } + } else { + psError(PS_ERR_IO, false, "Unable to find FPA.RA in FORMATS --- assuming HOURS.\n"); + ra *= M_PI / 12.0; + } + } else { + psError(PS_ERR_IO, false, "Unable to find FORMAT metadata in camera configuration --- " + "assuming format for FPA.RA is HOURS.\n"); + ra *= M_PI / 12.0; + } + } else + { + psError(PS_ERR_IO, false, "Couldn't find FPA.RA.\n"); + } + + psMetadataAdd(fpa->concepts, PS_LIST_TAIL, "FPA.RA", PS_DATA_F64 | PS_META_REPLACE, + "Right Ascension of the boresight (radians)", ra); + + } + + // FPA.DEC + { + double dec = NAN; // The DEC + psMetadataItem *decItem = p_pmFPAConceptGet(fpa, NULL, NULL, db, "FPA.DEC"); // The FPA.DEC item + if (decItem) { + switch (decItem->type) { + case PS_TYPE_F32: + dec = decItem->data.F32; + break; + case PS_TYPE_F64: + dec = decItem->data.F64; + break; + case PS_DATA_STRING: + // Sexagesimal format + { + int big, medium; + float small; + // XXX: Upgrade path is to allow dd:mm.mmm + if (sscanf(decItem->data.V, "%d:%d:%f", &big, &medium, &small) != 3 && + sscanf(decItem->data.V, "%d %d %f", &big, &medium, &small) != 3) + { + psError(PS_ERR_IO, true, "Cannot interpret FPA.DEC: %s\n", decItem->data.V); + break; + } + dec = abs(big) + (float)medium/60.0 + small/3600.0; + if (big < 0) + { + dec *= -1.0; + } + } + break; + default: + psError(PS_ERR_IO, true, "FPA.DEC is of an unexpected type: %x\n", decItem->type); + } + + // How to interpret the DEC + const psMetadata *camera = fpa->camera; // Camera configuration data + bool mdok = true; // Status of MD lookup + psMetadata *formats = psMetadataLookupMD(&mdok, camera, "FORMATS"); + if (mdok && formats) { + psString decFormat = psMetadataLookupStr(&mdok, formats, "FPA.DEC"); + if (mdok && strlen(decFormat) > 0) { + if (strcasecmp(decFormat, "HOURS") == 0) { + dec *= M_PI / 12.0; + } else if (strcasecmp(decFormat, "DEGREES") == 0) { + dec *= M_PI / 180.0; + } else if (strcasecmp(decFormat, "RADIANS") == 0) { + // No action required + } else { + psLogMsg(__func__, PS_LOG_WARN, "Don't understand FPA.DEC in FORMATS (%s) --- " + "assuming DEGREES.\n"); + dec *= M_PI / 180.0; + } + } else { + psError(PS_ERR_IO, false, "Unable to find FPA.DEC in FORMATS --- assuming DEGREES.\n"); + dec *= M_PI / 180.0; + } + } else { + psError(PS_ERR_IO, false, "Unable to find FORMATS metadata in camera configuration --- " + "assuming format for FPA.DEC is DEGREES.\n"); + dec *= M_PI / 180.0; + } + } else { + psError(PS_ERR_IO, false, "Couldn't find FPA.DEC.\n"); + } + + psMetadataAdd(fpa->concepts, PS_LIST_TAIL, "FPA.DEC", PS_DATA_F64 | PS_META_REPLACE, + "Declination of the boresight (radians)", dec); + + } + + // Pau. +} + + +// Ingest concepts for the chip +bool pmChipIngestConcepts(pmChip *chip, // The chip + psDB *db // DB handle + ) +{ + // pmFPA *fpa = chip->parent; // The parent FPA + + if (! chip->concepts) { + chip->concepts = psMetadataAlloc(); + } + + // CHIP.NAME --- added by pmFPAConstruct + + // Pau. + return true; +} + + +// Add corrective to a position --- in case the user wants FORTRAN indexing (like the FITS standard...) +static bool correctPosition(pmFPA *fpa, // FPA, contains the camera configuration + pmCell *cell, // Cell containing the concept to correct + const char *conceptName // Name of concept to correct + ) +{ + bool mdok = false; // Result of MD lookup + psMetadata *formats = psMetadataLookupMD(&mdok, fpa->camera, "FORMATS"); + if (mdok && formats) { + psString format = psMetadataLookupStr(&mdok, formats, conceptName); + if (mdok && strlen(format) > 0 && strcasecmp(format, "FORTRAN") == 0) { + psMetadataItem *valueItem = psMetadataLookup(cell->concepts, conceptName); + valueItem->data.S32 -= 1; + } + } + return true; +} + +bool p_pmCellIngestConcept(pmFPA *fpa, // The FPA + pmChip *chip, // The chip + pmCell *cell, // The cell + psDB *db, // DB handle + const char *concept // Name of the concept + ) +{ + if (strcmp(concept, "CELL.GAIN") == 0) { + p_pmFPAConceptGetF32(fpa, chip, cell, db, cell->concepts, "CELL.GAIN", "CCD gain (e/count)"); + } else if (strcmp(concept, "CELL.READNOISE") == 0) { + p_pmFPAConceptGetF32(fpa, chip, cell, db, cell->concepts, "CELL.READNOISE", "CCD read noise (e)"); + } else if (strcmp(concept, "CELL.SATURATION") == 0) { + p_pmFPAConceptGetF32(fpa, chip, cell, db, cell->concepts, "CELL.SATURATION", + "Saturation level (ADU)"); + } else if (strcmp(concept, "CELL.BAD") == 0) { + p_pmFPAConceptGetF32(fpa, chip, cell, db, cell->concepts, "CELL.BAD", "Bad level (ADU)"); + } else if (strcmp(concept, "CELL.XPARITY") == 0) { + p_pmFPAConceptGetS32(fpa, chip, cell, db, cell->concepts, "CELL.XPARITY", + "Orientation in x compared to the rest of the FPA"); + } else if (strcmp(concept, "CELL.YPARITY") == 0) { + p_pmFPAConceptGetS32(fpa, chip, cell, db, cell->concepts, "CELL.YPARITY", + "Orientation in y compared to the rest of the FPA"); + } else if (strcmp(concept, "CELL.READDIR") == 0) { + p_pmFPAConceptGetS32(fpa, chip, cell, db, cell->concepts, "CELL.READDIR", + "Read direction: 1=row, 2=col"); + } else if (strcmp(concept, "CELL.EXPOSURE") == 0) { // used to be READOUT.EXPOSURE + p_pmFPAConceptGetF32(fpa, chip, cell, db, cell->concepts, "CELL.EXPOSURE", "Exposure time (sec)"); + } else if (strcmp(concept, "CELL.DARKTIME") == 0) { // used to be READOUT.DARKTIME + p_pmFPAConceptGetF32(fpa, chip, cell, db, cell->concepts, "CELL.DARKTIME", + "Time since CCD flush (sec)"); + // These take some extra work + } else if (strcmp(concept, "CELL.TRIMSEC") == 0) { + psRegion *trimsec = psAlloc(sizeof(psRegion)); // Make space for a psRegion (usually passed by value) + + psMetadataItem *secItem = p_pmFPAConceptGet(fpa, chip, cell, db, "CELL.TRIMSEC"); + if (! secItem) { + psError(PS_ERR_IO, false, "Couldn't find CELL.TRIMSEC.\n"); + *trimsec = psRegionSet(0.0, 0.0, 0.0, 0.0); + } else if (secItem->type != PS_DATA_STRING) { + psError(PS_ERR_IO, true, "CELL.TRIMSEC is not of type STR (%x)\n", secItem->type); + *trimsec = psRegionSet(0.0, 0.0, 0.0, 0.0); + } else { + psString section = secItem->data.V; // The section string + + psMetadataItem *sourceItem = p_pmFPAConceptGet(fpa, chip, cell, db, "CELL.TRIMSEC.SOURCE"); + if (! sourceItem) { + psError(PS_ERR_IO, false, "Couldn't find CELL.TRIMSEC.SOURCE.\n"); + *trimsec = psRegionSet(0.0, 0.0, 0.0, 0.0); + } else if (sourceItem->type != PS_DATA_STRING) { + psError(PS_ERR_IO, true, "CELL.TRIMSEC.SOURCE is not of type STR (%x)\n", sourceItem->type); + *trimsec = psRegionSet(0.0, 0.0, 0.0, 0.0); + } else { + psString source = sourceItem->data.V; // The source string + + if (strcasecmp(source, "VALUE") == 0) { + *trimsec = psRegionFromString(section); + } else if (strcasecmp(source, "HEADER") == 0) { + psMetadata *header = NULL; // The FITS header + if (cell->hdu) { + header = cell->hdu->header; + } else if (chip->hdu) { + header = chip->hdu->header; + } else if (fpa->hdu) { + header = fpa->hdu->header; + } + if (! header) { + psError(PS_ERR_IO, true, "Unable to find FITS header!\n"); + *trimsec = psRegionSet(0.0, 0.0, 0.0, 0.0); + } else { + bool mdok = true; // Status of MD lookup + psString secValue = psMetadataLookupStr(&mdok, header, section); + if (! mdok || ! secValue) { + psError(PS_ERR_IO, false, "Unable to locate header %s\n", section); + *trimsec = psRegionSet(0.0, 0.0, 0.0, 0.0); + } else { + *trimsec = psRegionFromString(secValue); + } + } + } else { + psError(PS_ERR_IO, true, "CELL.TRIMSEC.SOURCE (%s) is not HEADER or VALUE --- trying " + "VALUE.\n", source); + *trimsec = psRegionFromString(section); + } // Value of CELL.TRIMSEC.SOURCE + } // Looking up CELL.TRIMSEC.SOURCE + } // Looking up CELL.TRIMSEC + + psMetadataAdd(cell->concepts, PS_LIST_TAIL, "CELL.TRIMSEC", PS_DATA_UNKNOWN | PS_META_REPLACE, + "Trim section", trimsec); + psFree(trimsec); + + } else if (strcmp(concept, "CELL.BIASSEC") == 0) { + psList *biassecs = psListAlloc(NULL); // List of bias sections + + psMetadataItem *secItem = p_pmFPAConceptGet(fpa, chip, cell, db, "CELL.BIASSEC"); + if (! secItem) { + psError(PS_ERR_IO, false, "Couldn't find CELL.BIASSEC.\n"); + } else if (secItem->type != PS_DATA_STRING) { + psError(PS_ERR_IO, true, "CELL.BIASSEC is not of type STR (%x)\n", secItem->type); + } else { + psString sections = secItem->data.V; // The section string + + psMetadataItem *sourceItem = p_pmFPAConceptGet(fpa, chip, cell, db, "CELL.BIASSEC.SOURCE"); + if (! sourceItem) { + psError(PS_ERR_IO, false, "Couldn't find CELL.BIASSEC.SOURCE.\n"); + } else if (sourceItem->type != PS_DATA_STRING) { + psError(PS_ERR_IO, true, "CELL.BIASSEC.SOURCE is not of type STR (%x)\n", sourceItem->type); + } else { + psString source = sourceItem->data.V; // The source string + + psList *secList = psStringSplit(sections, " ;"); // List of sections + psListIterator *secIter = psListIteratorAlloc(secList, PS_LIST_HEAD, false); // Iterator over + // sections + psString aSection = NULL; // A section from the list + while ((aSection = psListGetAndIncrement(secIter))) { + psRegion *region = psAlloc(sizeof(psRegion)); // Make space for a psRegion (usually passed + // by value) + + if (strcasecmp(source, "VALUE") == 0) { + *region = psRegionFromString(aSection); + } else if (strcasecmp(source, "HEADER") == 0) { + psMetadata *header = NULL; // The FITS header + if (cell->hdu) { + header = cell->hdu->header; + } else if (chip->hdu) { + header = chip->hdu->header; + } else if (fpa->hdu) { + header = fpa->hdu->header; + } + if (! header) { + psError(PS_ERR_IO, true, "Unable to find FITS header!\n"); + *region = psRegionSet(0.0,0.0,0.0,0.0); + } else { + bool mdok = true; // Status of MD lookup + psString secValue = psMetadataLookupStr(&mdok, header, aSection); + if (! mdok || ! secValue) { + psError(PS_ERR_IO, false, "Unable to locate header %s\n", aSection); + *region = psRegionSet(0.0,0.0,0.0,0.0); + } else { + *region = psRegionFromString(secValue); + } + } + } else { + psError(PS_ERR_IO, true, "CELL.BIASSEC.SOURCE (%s) is not HEADER or VALUE --- trying " + "VALUE.\n", source); + *region = psRegionFromString(aSection); + } // Value of CELL.BIASSEC.SOURCE + + psListAdd(biassecs, PS_LIST_TAIL, region); + psFree(region); + } // Iterating over multiple sections + psFree(secIter); + psFree(secList); + } // Looking up CELL.BIASSEC.SOURCE + } // Looking up CELL.BIASSEC + + psMetadataAdd(cell->concepts, PS_LIST_TAIL, "CELL.BIASSEC", PS_DATA_LIST | PS_META_REPLACE, + "Bias sections", biassecs); + psFree(biassecs); + + } else if (strcmp(concept, "CELL.XBIN") == 0) { + int xBin = 1; // Binning factor in x + psMetadataItem *binItem = p_pmFPAConceptGet(fpa, chip, cell, db, "CELL.XBIN"); + if (! binItem) { + psError(PS_ERR_IO, false, "Couldn't find CELL.XBIN.\n"); + } else if (binItem->type == PS_DATA_STRING) { + psString binString = binItem->data.V; // The string containing the binning + if (sscanf(binString, "%d %*d", &xBin) != 1 && + sscanf(binString, "%d,%*d", &xBin) != 1) { + psError(PS_ERR_IO, true, "Unable to read string to get x binning: %s\n", binString); + } + } else if (binItem->type == PS_TYPE_S32) { + xBin = binItem->data.S32; + } else { + psError(PS_ERR_IO, true, "Note sure how to interpret CELL.XBIN of type %x --- assuming 1.\n", + binItem->type); + } + + psMetadataAdd(cell->concepts, PS_LIST_TAIL, "CELL.XBIN", PS_TYPE_S32 | PS_META_REPLACE, + "Binning in x", xBin); + + } else if (strcmp(concept, "CELL.YBIN") == 0) { + int yBin = 1; // Binning factor in y + psMetadataItem *binItem = p_pmFPAConceptGet(fpa, chip, cell, db, "CELL.YBIN"); + if (! binItem) { + psError(PS_ERR_IO, false, "Couldn't find CELL.YBIN.\n"); + } else if (binItem->type == PS_DATA_STRING) { + psString binString = binItem->data.V; // The string containing the binning + if (sscanf(binString, "%*d %d", &yBin) != 1 && + sscanf(binString, "%*d,%d", &yBin) != 1) { + psError(PS_ERR_IO, true, "Unable to read string to get y binning: %s\n", binString); + } + } else if (binItem->type == PS_TYPE_S32) { + yBin = binItem->data.S32; + } else { + psError(PS_ERR_IO, true, "Note sure how to interpret CELL.YBIN of type %x --- assuming 1.\n", + binItem->type); + } + + psMetadataAdd(cell->concepts, PS_LIST_TAIL, "CELL.YBIN", PS_TYPE_S32 | PS_META_REPLACE, + "Binning in y", yBin); + + } else if (strcmp(concept, "CELL.TIME") == 0 || strcmp(concept, "CELL.TIMESYS") == 0) { + // Do CELL.TIME and CELL.TIMESYS together + psTime *time = NULL; // The time + psTimeType timeSys = PS_TIME_UTC; // The time system + + // CELL.TIMESYS + psMetadataItem *sysItem = p_pmFPAConceptGet(fpa, chip, cell, db, "CELL.TIMESYS"); + if (! sysItem) { + psError(PS_ERR_IO, true, "Couldn't find CELL.TIMESYS --- assuming UTC.\n"); + } else if (sysItem->type != PS_DATA_STRING) { + psError(PS_ERR_IO, true, "CELL.TIMESYS isn't of type STRING --- assuming UTC.\n"); + } else { + psString sys = sysItem->data.V; // The time system string + if (strcasecmp(sys, "TAI") == 0) { + timeSys = PS_TIME_TAI; + } else if (strcasecmp(sys, "UTC") == 0) { + timeSys = PS_TIME_UTC; + } else if (strcasecmp(sys, "UT1") == 0) { + timeSys = PS_TIME_UT1; + } else if (strcasecmp(sys, "TT") == 0) { + timeSys = PS_TIME_TT; + } else { + psError(PS_ERR_IO, true, "Can't interpret CELL.TIMESYS --- assuming UTC.\n"); + } + } + psMetadataAdd(cell->concepts, PS_LIST_TAIL, "CELL.TIMESYS", PS_TYPE_S32 | PS_META_REPLACE, + "Time system", timeSys); + + psMetadataItem *timeItem = p_pmFPAConceptGet(fpa, chip, cell, db, "CELL.TIME"); + if (! timeItem) { + psError(PS_ERR_IO, false, "Couldn't find CELL.TIME.\n"); + } else { + // Get format + const psMetadata *camera = fpa->camera; // The camera configuration data + bool mdok = true; // Status of MD lookup + psMetadata *formats = psMetadataLookupMD(&mdok, camera, "FORMATS"); + if (mdok && formats) { + psString timeFormat = psMetadataLookupStr(&mdok, formats, "CELL.TIME"); + if (mdok && strlen(timeFormat) > 0) { + switch (timeItem->type) { + case PS_DATA_STRING: { + psString timeString = timeItem->data.V; // String with the time + if (strcasecmp(timeFormat, "ISO") == 0) { + // timeString contains an ISO time + time = psTimeFromISO(timeString, timeSys); + } else if (strcasecmp(timeFormat, "JD") == 0) { + double timeValue = strtod (timeString, NULL); + time = psTimeFromJD(timeValue); + } else if (strcasecmp(timeFormat, "MJD") == 0) { + double timeValue = strtod (timeString, NULL); + time = psTimeFromMJD(timeValue); + } else if (strstr(timeFormat, "SEPARATE")) { + // timeString contains headers for the date and time + psMetadata *header = NULL; // The FITS header + if (cell->hdu) { + header = cell->hdu->header; + } else if (chip->hdu) { + header = chip->hdu->header; + } else if (fpa->hdu) { + header = fpa->hdu->header; + } + if (! header) { + psError(PS_ERR_IO, true, "Unable to find FITS header!\n"); + } else { + // Get the headers + char *stuff1 = strpbrk(timeString, " ,;"); + psString dateName = psStringNCopy(timeString, + strlen(timeString) - strlen(stuff1)); + char *stuff2 = strpbrk(stuff1, "abcdefghijklmnopqrstuvwxyz" + "ABCDEFGHIJKLMNOPQRSTUVWXYZ"); + psString timeName = psStringCopy(stuff2); + + bool mdok = true; // Status of MD lookup + psString dateString = psMetadataLookupStr(&mdok, header, dateName); + psFree(dateName); + int day = 0, month = 0, year = 0; + if (sscanf(dateString, "%d-%d-%d", &day, &month, &year) != 3 && + sscanf(dateString, "%d/%d/%d", &day, &month, &year) != 3) { + psError(PS_ERR_IO, true, "Unable to read date: %s\n", dateString); + } else { + if (strstr(timeFormat, "BACKWARDS")) { + int temp = day; + day = year; + year = temp; + } + if (strstr(timeFormat, "PRE2000") || year < 2000) { + year += 2000; + } + + psMetadataItem *timeItem = psMetadataLookup(header, timeName); + if (! timeItem) { + psError(PS_ERR_IO, false, "Unable to find time header: %s\n", + timeName); + } else if (timeItem->type == PS_DATA_STRING) { + // Time is a string, in the usual way: + psStringAppend(&dateString, "T%s", timeItem->data.V); + } else { + // Assume that time is specified in Second of Day + double seconds = NAN; + switch (timeItem->type) { + case PS_TYPE_S32: + seconds = timeItem->data.S32; + break; + case PS_TYPE_F32: + seconds = timeItem->data.F32; + break; + case PS_TYPE_F64: + seconds = timeItem->data.F64; + break; + default: + psError(PS_ERR_IO, true, "Time header (%s) is not of an " + "expected type: %x\n", timeName, timeItem->type); + } + // Now print to timeString as "hh:mm:ss.ss" + int hours = seconds / 3600; + seconds -= (double)hours * 3600.0; + int minutes = seconds / 60; + seconds -= (double)minutes * 60.0; + psStringAppend(&dateString, "T%02d:%02d:%02f", hours, minutes, + seconds); + } + time = psTimeFromISO(dateString, timeSys); + } // Reading date and time + psFree(timeName); + } // Reading headers + } else { + psError(PS_ERR_IO, true, "Not sure how to parse CELL.TIME (%s) --- trying " + "ISO\n", timeString); + time = psTimeFromISO(timeString, timeSys); + } // Interpreting the time string + } + break; + case PS_TYPE_F32: { + double timeValue = (double)timeItem->data.F32; + if (strcasecmp(timeFormat, "JD") == 0) { + time = psTimeFromJD(timeValue); + } else if (strcasecmp(timeFormat, "MJD") == 0) { + time = psTimeFromMJD(timeValue); + } else { + psError(PS_ERR_IO, true, "Not sure how to parse CELL.TIME (%f) --- trying " + "JD\n", timeValue); + time = psTimeFromJD(timeValue); + } + } + break; + case PS_TYPE_F64: { + double timeValue = (double)timeItem->data.F64; + if (strcasecmp(timeFormat, "JD") == 0) { + time = psTimeFromJD(timeValue); + } else if (strcasecmp(timeFormat, "MJD") == 0) { + time = psTimeFromMJD(timeValue); + } else { + psError(PS_ERR_IO, true, "Not sure how to parse CELL.TIME (%f) --- trying " + "JD\n", timeValue); + time = psTimeFromJD(timeValue); + } + } + break; + default: + psError(PS_ERR_IO, true, "Unable to parse CELL.TIME.\n"); + } + } else { + psError(PS_ERR_IO, false, "Unable to find CELL.TIME in FORMATS.\n"); + } // Getting the format + } else { + psError(PS_ERR_IO, false, "Unable to find FORMATS in camera configuration.\n"); + } // Getting the formats + } // Getting CELL.TIME + + psMetadataAdd(cell->concepts, PS_LIST_TAIL, "CELL.TIME", PS_DATA_TIME | PS_META_REPLACE, + "Time of exposure", time); + psFree(time); + + // These are new and experimental concepts: CELL.X0 and CELL.Y0 + } else if (strcmp(concept, "CELL.X0") == 0) { + p_pmFPAConceptGetS32(fpa, chip, cell, db, cell->concepts, "CELL.X0", "Position of (0,0) on the chip"); + correctPosition(fpa, cell, "CELL.X0"); + } else if (strcmp(concept, "CELL.Y0") == 0) { + p_pmFPAConceptGetS32(fpa, chip, cell, db, cell->concepts, "CELL.Y0", "Position of (0,0) on the chip"); + correctPosition(fpa, cell, "CELL.Y0"); + } + + return true; +} + + + +// Ingest concepts for the cell +bool pmCellIngestConcepts(pmCell *cell, // The cell + psDB *db // DB handle + ) +{ + pmChip *chip = cell->parent; // The parent chip + pmFPA *fpa = chip->parent; // The parent FPA + + if (! cell->concepts) { + cell->concepts = psMetadataAlloc(); + } + + // CELL.NAME --- added by pmFPAConstruct + + p_pmCellIngestConcept(fpa, chip, cell, db, "CELL.GAIN"); + p_pmCellIngestConcept(fpa, chip, cell, db, "CELL.READNOISE"); + p_pmCellIngestConcept(fpa, chip, cell, db, "CELL.SATURATION"); + p_pmCellIngestConcept(fpa, chip, cell, db, "CELL.BAD"); + p_pmCellIngestConcept(fpa, chip, cell, db, "CELL.XPARITY"); + p_pmCellIngestConcept(fpa, chip, cell, db, "CELL.YPARITY"); + p_pmCellIngestConcept(fpa, chip, cell, db, "CELL.READDIR"); + + // These used to be pmReadoutGetExposure and pmReadoutGetDarkTime, but that doesn't really make sense at + // the moment. Maybe we need to add a "parent" link to the readouts. But then how are the exposure times + // REALLY derived? They're not in the FITS headers, because a readout is a plane in a 3D image. We'll + // have to dream up some additional suffix to specify these, but for now.... + p_pmCellIngestConcept(fpa, chip, cell, db, "CELL.EXPOSURE"); + p_pmCellIngestConcept(fpa, chip, cell, db, "CELL.DARKTIME"); + + + p_pmCellIngestConcept(fpa, chip, cell, db, "CELL.TRIMSEC"); + p_pmCellIngestConcept(fpa, chip, cell, db, "CELL.BIASSEC"); + p_pmCellIngestConcept(fpa, chip, cell, db, "CELL.TIME"); // This also does CELL.TIMESYS + p_pmCellIngestConcept(fpa, chip, cell, db, "CELL.XBIN"); + p_pmCellIngestConcept(fpa, chip, cell, db, "CELL.YBIN"); + p_pmCellIngestConcept(fpa, chip, cell, db, "CELL.X0"); + p_pmCellIngestConcept(fpa, chip, cell, db, "CELL.Y0"); + + return true; +} + + +// Retrieve a concept +psMetadataItem *pmCellGetConcept(pmCell *cell, // The cell + const char *concept // The concept + ) +{ + psMetadataItem *item = psMetadataLookup(cell->concepts, concept); + if (! item) { + pmChip *chip = cell->parent; + item = psMetadataLookup(chip->concepts, concept); + if (! item) { + pmFPA *fpa = chip->parent; + item = psMetadataLookup(fpa->concepts, concept); + } + } + return item; // item is either NULL or is what we want. +} + + +// Set up concepts for blank image +bool pmFPABlankConcepts(pmFPA *fpa // The FPA + ) +{ + assert(fpa); + + // FPA-level concepts + if (! fpa->concepts) { + fpa->concepts = psMetadataAlloc(); + } + psMetadataAddStr(fpa->concepts, PS_LIST_TAIL, "FPA.NAME", PS_META_REPLACE, "Name of FPA", ""); + psMetadataAddF32(fpa->concepts, PS_LIST_TAIL, "FPA.AIRMASS", PS_META_REPLACE, + "Airmass at boresight", NAN); + psMetadataAddStr(fpa->concepts, PS_LIST_TAIL, "FPA.FILTER", PS_META_REPLACE, "Filter used", ""); + psMetadataAddF32(fpa->concepts, PS_LIST_TAIL, "FPA.POSANGLE", PS_META_REPLACE, + "Position angle for instrument", NAN); + psMetadataAddStr(fpa->concepts, PS_LIST_TAIL, "FPA.RADECSYS", PS_META_REPLACE, + "Celestial coordinate system", ""); + psMetadataAddF64(fpa->concepts, PS_LIST_TAIL, "FPA.RA", PS_META_REPLACE, + "Right Ascension of the boresight (radians)", NAN); + psMetadataAddF64(fpa->concepts, PS_LIST_TAIL, "FPA.DEC", PS_META_REPLACE, + "Declination of the boresight (radians)", NAN); + + // Iterate through the chips + psArray *chips = fpa->chips; // Array of chips + for (int i = 0; i < chips->n; i++) { + pmChip *chip = chips->data[i]; // The chip of interest + if (! chip) { + continue; + } + + // Chip-level concepts + if (! chip->concepts) { + chip->concepts = psMetadataAlloc(); + } + // CHIP.NAME *should* have been added by pmFPAConstruct --- make sure + psMetadataItem *chipNameItem = psMetadataLookup(chip->concepts, "CHIP.NAME"); + if (! chipNameItem) { + psMetadataAddStr(fpa->concepts, PS_LIST_TAIL, "CHIP.NAME", PS_META_REPLACE, "Name of Chip", ""); + } + + // Iterate through the cells + psArray *cells = chip->cells; // Array of cells + for (int j = 0; j < cells->n; j++) { + pmCell *cell = cells->data[i]; // The cell of interest + if (! cell) { + continue; + } + + // Cell-level concepts + if (! cell->concepts) { + cell->concepts = psMetadataAlloc(); + } + // CELL.NAME *should* have been added by pmFPAConstruct --- make sure + psMetadataItem *cellNameItem = psMetadataLookup(cell->concepts, "CELL.NAME"); + if (!cellNameItem) { + psMetadataAddStr(fpa->concepts, PS_LIST_TAIL, "CELL.NAME", PS_META_REPLACE, + "Name of Cell", ""); + } + psMetadataAddF32(cell->concepts, PS_LIST_TAIL, "CELL.GAIN", PS_META_REPLACE, "CCD gain (e/count)", NAN); + psMetadataAddF32(cell->concepts, PS_LIST_TAIL, "CELL.READNOISE", PS_META_REPLACE, "CCD read noise (e)", NAN); + psMetadataAddF32(cell->concepts, PS_LIST_TAIL, "CELL.SATURATION", PS_META_REPLACE, "Saturation level (ADU)", NAN); + psMetadataAddF32(cell->concepts, PS_LIST_TAIL, "CELL.BAD", PS_META_REPLACE, "Bad level (ADU)", NAN); + psMetadataAddF32(cell->concepts, PS_LIST_TAIL, "CELL.XPARITY", PS_META_REPLACE, "Orientation in x compared to the rest of the FPA", NAN); + psMetadataAddF32(cell->concepts, PS_LIST_TAIL, "CELL.YPARITY", PS_META_REPLACE, "Orientation in x compared to the rest of the FPA", NAN); + psMetadataAddF32(cell->concepts, PS_LIST_TAIL, "CELL.READDIR", PS_META_REPLACE, "Read direction: 1=row, 2=col", NAN); + psMetadataAddF32(cell->concepts, PS_LIST_TAIL, "CELL.EXPOSURE", PS_META_REPLACE, "Exposure time (sec)", NAN); + psMetadataAddF32(cell->concepts, PS_LIST_TAIL, "CELL.DARKTIME", PS_META_REPLACE, "Time since CCD flush (sec)", NAN); + psMetadataAddS32(cell->concepts, PS_LIST_TAIL, "CELL.XBIN", PS_META_REPLACE, "Binning in x", 0); + psMetadataAddS32(cell->concepts, PS_LIST_TAIL, "CELL.YBIN", PS_META_REPLACE, "Binning in y", 0); + psMetadataAddS32(cell->concepts, PS_LIST_TAIL, "CELL.X0", PS_META_REPLACE, "Position of (0,0) on the chip", 0); + psMetadataAddS32(cell->concepts, PS_LIST_TAIL, "CELL.Y0", PS_META_REPLACE, "Position of (0,0) on the chip", 0); + + psRegion *trimsec = psAlloc(sizeof(psRegion)); // Dummy region + trimsec->x0 = NAN; + trimsec->x1 = NAN; + trimsec->y0 = NAN; + trimsec->y1 = NAN; + psMetadataAddPtr(cell->concepts, PS_LIST_TAIL, "CELL.TRIMSEC", PS_META_REPLACE, "Trim section", trimsec); + psList *biassecs = psListAlloc(NULL); // Dummy list + psMetadataAddPtr(cell->concepts, PS_LIST_TAIL, "CELL.BIASSEC", PS_META_REPLACE, "Bias section", biassecs); + psTime *time = psTimeAlloc(PS_TIME_TAI); // Dummy time + psMetadataAddPtr(cell->concepts, PS_LIST_TAIL, "CELL.TIME", PS_META_REPLACE, "Time of exposure", time); + psMetadataAddS32(cell->concepts, PS_LIST_TAIL, "CELL.TIMESYS", PS_META_REPLACE, "Time system", PS_TIME_TAI); + } + } + + return true; +} + +// Copy concepts from one FPA to another +bool pmFPACopyConcepts(pmFPA *target, // The target FPA + pmFPA *source // The target FPA + ) +{ + // Copy FPA concepts + target->concepts = pap_psMetadataCopy(target->concepts, source->concepts); + + // Copy chip concepts + psArray *targetChips = target->chips; // Chips in target + psArray *sourceChips = source->chips; // Chips in source + if (targetChips->n != sourceChips->n) { + psError(PS_ERR_IO, true, "Number of chips in target (%d) and source (%d) differ --- unable to copy " + "concepts.\n", targetChips->n, sourceChips->n); + return false; + } + for (int i = 0; i < targetChips->n; i++) { + pmChip *targetChip = targetChips->data[i]; // Target chip of interest + pmChip *sourceChip = sourceChips->data[i]; // Source chip of interest + if (! targetChip || ! sourceChip) { + continue; + } + targetChip->concepts = pap_psMetadataCopy(targetChip->concepts, sourceChip->concepts); + + // Copy cell concepts + psArray *targetCells = targetChip->cells; // Cells in target + psArray *sourceCells = sourceChip->cells; // Cells in source + if (targetCells->n != sourceCells->n) { + psError(PS_ERR_IO, true, "Number of cells in target (%d) and source (%d) differ for chip %d ---" + " unable to copy concepts.\n", targetCells->n, sourceCells->n, i); + return false; + } + for (int j = 0; j < targetCells->n; j++) { + pmCell *targetCell = targetCells->data[j]; // Target chip of interest + pmCell *sourceCell = sourceCells->data[j]; // Source chip of interest + if (! targetCell || ! sourceCell) { + continue; + } + targetCell->concepts = pap_psMetadataCopy(targetCell->concepts, sourceCell->concepts); + } + } + + return true; +} Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/astrom/pmFPAConceptsGet.h =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/astrom/pmFPAConceptsGet.h (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/astrom/pmFPAConceptsGet.h (revision 21664) @@ -0,0 +1,103 @@ +#ifndef PM_FPA_CONCEPTS_GET_H +#define PM_FPA_CONCEPTS_GET_H + +#include "pslib.h" +#include "pmAstrometry.h" +#include "psAdditionals.h" + +psMetadataItem *p_pmFPAConceptGetFromCamera(pmCell *cell, // The cell + const char *concept // Name of concept + ); +psMetadataItem *p_pmFPAConceptGetFromHeader(pmFPA *fpa, // The FPA that contains the chip + pmChip *chip, // The chip that contains the cell + pmCell *cell, // The cell + const char *concept // Name of concept + ); +psMetadataItem *p_pmFPAConceptGetFromDefault(pmFPA *fpa, // The FPA that contains the chip + pmChip *chip, // The chip that contains the cell + pmCell *cell, // The cell + const char *concept // Name of concept + ); +psMetadataItem *p_pmFPAConceptGetFromDB(pmFPA *fpa, // The FPA that contains the chip + pmChip *chip, // The chip that contains the cell + pmCell *cell, // The cell + psDB *db, // DB handle + const char *concept // Name of concept + ); +psMetadataItem *p_pmFPAConceptGet(pmFPA *fpa, // The FPA + pmChip *chip,// The chip + pmCell *cell, // The cell + psDB *db, // DB handle + const char *concept // Concept name + ); +void p_pmFPAConceptGetF32(pmFPA *fpa, // The FPA + pmChip *chip, // The chip + pmCell *cell, // The cell + psDB *db, // DB handle + psMetadata *concepts, // The concepts MD + const char *name, // Name of the concept + const char *comment // Comment for concept + ); +void p_pmFPAConceptGetF64(pmFPA *fpa, // The FPA + pmChip *chip, // The chip + pmCell *cell, // The cell + psDB *db, // DB handle + psMetadata *concepts, // The concepts MD + const char *name, // Name of the concept + const char *comment // Comment for concept + ); +void p_pmFPAConceptGetS32(pmFPA *fpa, // The FPA + pmChip *chip, // The chip + pmCell *cell, // The cell + psDB *db, // DB handle + psMetadata *concepts, // The concepts MD + const char *name, // Name of the concept + const char *comment // Comment for concept + ); +void p_pmFPAConceptGetString(pmFPA *fpa, // The FPA + pmChip *chip, // The chip + pmCell *cell, // The cell + psDB *db, // DB handle + psMetadata *concepts, // The concepts MD + const char *name, // Name of the concept + const char *comment // Comment for concept + ); + + +// Ingest a single cell concept; this is the workhorse for ingesting cell concepts +bool p_pmCellIngestConcept(pmFPA *fpa, // The FPA + pmChip *chip, // The chip + pmCell *cell, // The cell + psDB *db, // DB handle + const char *concept // Name of the concept + ); + +// Ingest concepts for the FPA +void pmFPAIngestConcepts(pmFPA *fpa, // The FPA + psDB *db // DB handle + ); +// Ingest concepts for the chip +bool pmChipIngestConcepts(pmChip *chip, // The chip + psDB *db // DB handle + ); +// Ingest concepts for the cell +bool pmCellIngestConcepts(pmCell *cell, // The cell + psDB *db // DB handle + ); + +// Set up concepts for blank image +bool pmFPABlankConcepts(pmFPA *fpa // The FPA + ); + +// Copy concepts from one FPA to another +bool pmFPACopyConcepts(pmFPA *target, // The target FPA + pmFPA *source // The target FPA + ); + +// Retrieve a concept +psMetadataItem *pmCellGetConcept(pmCell *cell, // The cell + const char *concept // The concept + ); + + +#endif Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/astrom/pmFPAConceptsSet.c =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/astrom/pmFPAConceptsSet.c (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/astrom/pmFPAConceptsSet.c (revision 21664) @@ -0,0 +1,904 @@ +#include +#include +#include "pslib.h" + +#include "pmAstrometry.h" +#include "pmFPAConceptsGet.h" +#include "pmFPAConceptsSet.h" + +////////////////////////////////////////////////////////////////////////////////////////////////////////////// +// File-static functions +////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +#define COMPARE_REGIONS(a,b) (((a)->x0 == (b)->x0 && \ + (a)->x1 == (b)->x1 && \ + (a)->y0 == (b)->y0 && \ + (a)->y1 == (b)->y1) ? true : false) + + +static bool compareConcepts(psMetadataItem *item1, // First item to compare + psMetadataItem *item2 // Second item to compare + ) +{ + // First order checks + if (! item1 || ! item2) { + return false; + } + if (strcasecmp(item1->name, item2->name) != 0) { + return false; + } + + // Check the more boring types + switch (item1->type) { + case PS_TYPE_S32: + switch (item2->type) { + case PS_TYPE_S32: + return (item1->data.S32 == item2->data.S32) ? true : false; + case PS_TYPE_F32: + return (item1->data.S32 == (int)item2->data.F32) ? true : false; + case PS_TYPE_F64: + return (item1->data.S32 == (int)item2->data.F64) ? true : false; + default: + return false; + } + case PS_TYPE_F32: + switch (item2->type) { + case PS_TYPE_S32: + return (item1->data.F32 == (float)item2->data.S32) ? true : false; + case PS_TYPE_F32: + return (item1->data.F32 == item2->data.F32) ? true : false; + case PS_TYPE_F64: + return (item1->data.F32 == (float)item2->data.F64) ? true : false; + default: + return false; + } + case PS_TYPE_F64: + switch (item2->type) { + case PS_TYPE_S32: + return (item1->data.F64 == (double)item2->data.S32) ? true : false; + case PS_TYPE_F32: + return (item1->data.F64 == (double)item2->data.F32) ? true : false; + case PS_TYPE_F64: + return (item1->data.F64 == item2->data.F64) ? true : false; + default: + return false; + } + return (item1->data.F64 == item2->data.F64) ? true : false; + case PS_DATA_STRING: + if (item2->type != PS_DATA_STRING) { + return false; + } + return (strcasecmp(item1->data.V, item2->data.V) == 0) ? true : false; + default: + return false; + } + psAbort(__func__, "Should never get here.\n"); +} + + +// Well, not really "set", but check to make sure it's there and matches +static bool setConceptInCamera(pmCell *cell, // The cell + psMetadataItem *concept // Concept + ) +{ + if (cell) { + psMetadataItem *item = psMetadataLookup(cell->camera, concept->name); // Info we want + return compareConcepts(item, concept); + } + + return false; +} + + +static bool setConceptInHeader(pmFPA *fpa, // The FPA that contains the chip + pmChip *chip, // The chip that contains the cell + pmCell *cell, // The cell + psMetadataItem *concept // Concept + ) +{ + bool mdok = true; // Status of MD lookup + bool status = false; // Status of setting header + psMetadata *translation = psMetadataLookupMD(&mdok, fpa->camera, "TRANSLATION"); // FITS translation + if (! mdok) { + psError(PS_ERR_IO, false, "Unable to find TRANSLATION in camera configuration.\n"); + return false; + } + + // Look for how to translate the concept into a FITS header name + const char *keyword = psMetadataLookupStr(&mdok, translation, concept->name); + if (mdok && strlen(keyword) > 0) { + psTrace(__func__, 6, "It's in keyword %s\n", keyword); + psMetadataItem *headerItem = NULL; // Item to add to header + // XXX: Need to expand range of types + switch (concept->type) { + case PS_DATA_STRING: + headerItem = psMetadataItemAllocStr(keyword, concept->comment, concept->data.V); + break; + case PS_DATA_S32: + headerItem = psMetadataItemAllocS32(keyword, concept->comment, concept->data.S32); + break; + case PS_DATA_F32: + headerItem = psMetadataItemAllocF32(keyword, concept->comment, concept->data.F32); + break; + case PS_DATA_F64: + headerItem = psMetadataItemAllocF64(keyword, concept->comment, concept->data.F64); + break; + default: + headerItem = psMetadataItemAlloc(keyword, concept->type, concept->comment, + concept->data.V); // Item for the header + } + + // We have a FITS header to look up --- search each level + if (cell && cell->hdu) { + psTrace(__func__, 7, "Adding to the cell level header...\n"); + psMetadataAddItem(cell->hdu->header, headerItem, PS_LIST_TAIL, PS_META_REPLACE); + status = true; + } else if (chip && chip->hdu) { + psTrace(__func__, 7, "Adding to the chip level header...\n"); + psMetadataAddItem(chip->hdu->header, headerItem, PS_LIST_TAIL, PS_META_REPLACE); + status = true; + } else if (fpa->hdu) { + psTrace(__func__, 7, "Adding to the FPA level header...\n"); + psMetadataAddItem(fpa->hdu->header, headerItem, PS_LIST_TAIL, PS_META_REPLACE); + status = true; + } else { + // In desperation, add to the PHU --- it HAS to be in the header somewhere! + if (! fpa->phu) { + fpa->phu = psMetadataAlloc(); + } + psTrace(__func__, 7, "Adding to the PHU...\n"); + psMetadataAddItem(fpa->phu, headerItem, PS_LIST_TAIL, PS_META_REPLACE); + status = true; + } + psFree(headerItem); + } + + // No header value + return status; +} + + +// Well, not really "set", but check to see if it's there, and matches +static bool setConceptInDefault(pmFPA *fpa, // The FPA that contains the chip + pmChip *chip, // The chip that contains the cell + pmCell *cell, // The cell + psMetadataItem *concept // Concept + ) +{ + bool mdOK = true; // Status of MD lookup + psMetadata *defaults = psMetadataLookupMD(&mdOK, fpa->camera, "DEFAULTS"); + if (! mdOK || ! defaults) { + psError(PS_ERR_IO, false, "Unable to find DEFAULTS in camera configuration.\n"); + return false; + } + + psMetadataItem *defItem = psMetadataLookup(defaults, concept->name); + bool status = false; // Result of checking the database + if (defItem) { + if (defItem->type == PS_DATA_METADATA) { + // A dependent default + psTrace(__func__, 7, "Evaluating dependent default....\n"); + psMetadata *dependents = defItem->data.V; // The list of dependents + // Find out what it depends on + psString dependName = psStringCopy(concept->name); + psStringAppend(&dependName, ".DEPEND"); + psString dependsOn = psMetadataLookupStr(&mdOK, defaults, dependName); + if (! mdOK) { + psError(PS_ERR_IO, false, "Unable to find %s in camera configuration for dependent default" + " --- ignored\n", dependName); + // XXX: Need to clean up before returning + return false; + } + psFree(dependName); + // Find the value of the dependent concept + psMetadataItem *depItem = p_pmFPAConceptGetFromHeader(fpa, chip, cell, dependsOn); + if (! depItem) { + psError(PS_ERR_IO, true, "Unable to find value for %s (required for %s)\n", dependsOn, + concept->name); + return false; + } + if (depItem->type != PS_DATA_STRING) { + psError(PS_ERR_IO, true, "Value of %s is not of type string, as required for dependency" + " --- ignored.\n", dependsOn); + } + + defItem = psMetadataLookup(dependents, depItem->data.V); // This is now what we were after + } + + status = compareConcepts(defItem, concept); + if (! status) { + psError(PS_ERR_IO, true, "Concept %s is specified by default in the camera configuration, " + "but doesn't match the actual value.\n", concept->name); + } + } + + // XXX: Need to clean up before returning + return status; +} + + +// XXX: Not tested at all +static bool setConceptInDB(pmFPA *fpa, // The FPA that contains the chip + pmChip *chip, // The chip that contains the cell + pmCell *cell, // The cell + psDB *db, // DB handle + psMetadataItem *concept // Concept + ) +{ + if (! db) { + // No database initialised + return false; + } + + bool mdStatus = true; // Status of MD lookup + psMetadata *database = psMetadataLookupMD(&mdStatus, fpa->camera, "DATABASE"); + if (! mdStatus) { + // No error, because not everyone needs to use the DB + return NULL; + } + + psMetadata *dbLookup = psMetadataLookupMD(&mdStatus, database, concept->name); + if (dbLookup) { + const char *tableName = psMetadataLookupStr(&mdStatus, dbLookup, "TABLE"); // Name of the table + // const char *colName = psMetadataLookupStr(&mdStatus, dbLookup, "COLUMN"); // Name of the column + const char *givenCols = psMetadataLookupStr(&mdStatus, dbLookup, "GIVENDBCOL"); // Name of "where" + // columns + const char *givenPS = psMetadataLookupStr(&mdStatus, dbLookup, "GIVENPS"); // Values for "where" + // columns + + // Now, need to get the "given"s + if (strlen(givenCols) || strlen(givenPS)) { + psList *cols = psStringSplit(givenCols, ",;"); // List of column names + psList *values = psStringSplit(givenPS, ",;"); // List of value names for the columns + psMetadata *selection = psMetadataAlloc(); // The stuff to select in the DB + if (cols->n != values->n) { + psLogMsg(__func__, PS_LOG_WARN, "The GIVENDBCOL and GIVENPS entries for %s do not have " + "the same number of entries --- ignored.\n", concept); + } else { + // Iterators for the lists + psListIterator *colsIter = psListIteratorAlloc(cols, PS_LIST_HEAD, false); + psListIterator *valuesIter = psListIteratorAlloc(values, PS_LIST_HEAD, false); + char *column = NULL; // Name of the column + while ((column = psListGetAndIncrement(colsIter))) { + char *name = psListGetAndIncrement(valuesIter); // Name for the value + if (!strlen(column) || !strlen(name)) { + psLogMsg(__func__, PS_LOG_WARN, "One of the columns or value names for %s is " + " empty --- ignored.\n", concept); + } else { + // Search for the value name + psMetadataItem *item = p_pmFPAConceptGetFromHeader(fpa, chip, cell, name); + if (! item) { + item = p_pmFPAConceptGetFromDefault(fpa, chip, cell, name); + } + if (! item) { + psLogMsg(__func__, PS_LOG_ERROR, "Unable to find the value name %s for DB " + " lookup on %s --- ignored.\n", name, concept); + } else { + // We need to create a new psMetadataItem. I don't think we can't simply hack + // the existing one, since that could conceivably cause memory leaks + psMetadataItem *newItem = psMetadataItemAlloc(concept->name, item->type, + item->comment, item->data.V); + psMetadataAddItem(selection, newItem, PS_LIST_TAIL, PS_META_REPLACE); + psFree(newItem); + } + } + psFree(name); + psFree(column); + } // Iterating through the columns + psFree(colsIter); + psFree(valuesIter); + + // Check first to make sure we're only going to touch one row + psArray *dbResult = psDBSelectRows(db, tableName, selection, 2); // Lookup result + // Note that we use limit=2 in order to test if there are multiple rows returned + if (! dbResult || dbResult->n == 0) { + psLogMsg(__func__, PS_LOG_WARN, "Unable to find any rows in DB for %s --- ignored\n", + concept->name); + return false; + } else { + if (dbResult->n > 1) { + psLogMsg(__func__, PS_LOG_WARN, "Multiple rows returned in DB lookup for %s --- " + " ignored.\n", concept->name); + } + // Update the DB + psMetadata *update = psMetadataAlloc(); + psMetadataAddItem(update, concept, PS_LIST_HEAD, 0); + psDBUpdateRows(db, tableName, selection, update); + psFree(update); + return true; + } + } + psFree(cols); + psFree(values); + } + } // Doing the "given"s. + + psAbort(__func__, "Shouldn't ever get here?\n"); + return false; +} + + +// Concept set from item +static bool setConceptItem(pmFPA *fpa, // The FPA + pmChip *chip,// The chip + pmCell *cell, // The cell + psDB *db, // DB handle + psMetadataItem *concept // Concept item + ) +{ + // Try headers, database, defaults in order + psTrace(__func__, 3, "Trying to set concept %s...\n", concept->name); + bool status = setConceptInCamera(cell, concept); // Status for return + if (! status) { + psTrace(__func__, 5, "Trying header....\n"); + status = setConceptInHeader(fpa, chip, cell, concept); + } + if (! status) { + psTrace(__func__, 5, "Trying database....\n"); + status = setConceptInDB(fpa, chip, cell, db, concept); + } + if (! status) { + psTrace(__func__, 5, "Checking defaults....\n"); + status = setConceptInDefault(fpa, chip, cell, concept); + } + + if (! status) { + psError(PS_ERR_IO, true, "Unable to set %s (%s).\n", concept->name, concept->comment); + } + + return status; +} + + +// Concept set +static bool setConcept(pmFPA *fpa, // The FPA + pmChip *chip,// The chip + pmCell *cell, // The cell + psDB *db, // DB handle + psMetadata *concepts, // Concepts MD from which to set + const char *name // Name of the concept + ) +{ + psMetadataItem *concept = psMetadataLookup(concepts, name); + if (! concept) { + psError(PS_ERR_IO, true, "No such concept as %s\n", name); + return false; + } + return setConceptItem(fpa, chip, cell, db, concept); +} + + +////////////////////////////////////////////////////////////////////////////////////////////////////////////// +// Public functions +////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +// Outget concepts from the FPA +void pmFPAOutgestConcepts(pmFPA *fpa, // The FPA + psDB *db // DB handle + ) +{ + // FPA.NAME + setConcept(fpa, NULL, NULL, db, fpa->concepts, "FPA.NAME"); + + // FPA.AIRMASS + setConcept(fpa, NULL, NULL, db, fpa->concepts, "FPA.AIRMASS"); + + // FPA.FILTER + setConcept(fpa, NULL, NULL, db, fpa->concepts, "FPA.FILTER"); + + // FPA.POSANGLE + setConcept(fpa, NULL, NULL, db, fpa->concepts, "FPA.POSANGLE"); + + // FPA.RADECSYS + setConcept(fpa, NULL, NULL, db, fpa->concepts, "FPA.RADECSYS"); + + // These take some extra work + + // FPA.RA + { + double ra = psMetadataLookupF64(NULL, fpa->concepts, "FPA.RA"); // The RA + + // How to interpret the RA + const psMetadata *camera = fpa->camera; // Camera configuration data + bool mdok = true; // Status of MD lookup + psMetadata *formats = psMetadataLookupMD(&mdok, camera, "FORMATS"); + if (mdok && formats) + { + psString raFormat = psMetadataLookupStr(&mdok, formats, "FPA.RA"); + if (mdok && strlen(raFormat) > 0) { + if (strcasecmp(raFormat, "HOURS") == 0) { + ra /= M_PI / 12.0; + } else if (strcasecmp(raFormat, "DEGREES") == 0) { + ra /= M_PI / 180.0; + } else if (strcasecmp(raFormat, "RADIANS") == 0) { + // No action required + } else { + psLogMsg(__func__, PS_LOG_WARN, "Don't understand FPA.RA in FORMATS (%s) --- assuming" + " HOURS.\n"); + ra /= M_PI / 12.0; + } + } else { + psError(PS_ERR_IO, false, "Unable to find FPA.RA in FORMATS --- assuming HOURS.\n"); + ra /= M_PI / 12.0; + } + } else + { + psError(PS_ERR_IO, false, "Unable to find FORMAT metadata in camera configuration --- " + "assuming format for FPA.RA is HOURS.\n"); + ra /= M_PI / 12.0; + } + + // We choose to write sexagesimal format + int big, medium; + float small; + big = (int)ra; + medium = (int)(60.0*(ra - (double)big)); + small = 3600.0*(ra - (double)big - 60.0 * (double)medium); + psString raString = psStringCopy(""); + psStringAppend(&raString, "%d:%d:%.2f", big, medium, small); + psMetadataItem *raItem = psMetadataItemAllocStr("FPA.RA", "Right Ascension of the boresight", + raString); + setConceptItem(fpa, NULL, NULL, db, raItem); + psFree(raItem); + psFree(raString); + } + + // FPA.DEC + { + double dec = psMetadataLookupF64(NULL, fpa->concepts, "FPA.DEC"); // The DEC + + // How to interpret the DEC + const psMetadata *camera = fpa->camera; // Camera configuration data + bool mdok = true; // Status of MD lookup + psMetadata *formats = psMetadataLookupMD(&mdok, camera, "FORMATS"); + if (mdok && formats) + { + psString decFormat = psMetadataLookupStr(&mdok, formats, "FPA.DEC"); + if (mdok && strlen(decFormat) > 0) { + if (strcasecmp(decFormat, "HOURS") == 0) { + dec /= M_PI / 12.0; + } else if (strcasecmp(decFormat, "DEGREES") == 0) { + dec /= M_PI / 180.0; + } else if (strcasecmp(decFormat, "RADIANS") == 0) { + // No action required + } else { + psLogMsg(__func__, PS_LOG_WARN, "Don't understand FPA.DEC in FORMATS (%s) --- assuming" + " DEGREES.\n"); + dec /= M_PI / 180.0; + } + } else { + psError(PS_ERR_IO, false, "Unable to find FPA.DEC in FORMATS --- assuming DEGREES.\n"); + dec /= M_PI / 180.0; + } + } else + { + psError(PS_ERR_IO, false, "Unable to find FORMAT metadata in camera configuration --- " + "assuming format for FPA.DEC is HOURS.\n"); + dec /= M_PI / 12.0; + } + + // We choose to write sexagesimal format + int big, medium; + float small; + big = (int)dec; + medium = (int)(60.0*(dec - (double)big)); + small = 3600.0*(dec - (double)big - 60.0 * (double)medium); + psString decString = psStringCopy(""); + psStringAppend(&decString, "%d:%d:%.2f", big, medium, small); + psMetadataItem *decItem = psMetadataItemAllocStr("FPA.DEC", "Right Ascension of the boresight", + decString); + setConceptItem(fpa, NULL, NULL, db, decItem); + psFree(decItem); + psFree(decString); + + } + + // Pau. +} + + +// Outgest concepts for the chip +void pmChipOutgestConcepts(pmChip *chip, // The chip + psDB *db // DB handle + ) +{ + // pmFPA *fpa = chip->parent; // The parent FPA + + // CHIP.NAME --- no need to do anything + + // Pau. +} + + +// Outgest concepts for the cell +void pmCellOutgestConcepts(pmCell *cell, // The cell + psDB *db // DB handle + ) +{ + pmChip *chip = cell->parent; // The parent chip + pmFPA *fpa = chip->parent; // The parent FPA + + // CELL.NAME --- no need to do anything + + // CELL.GAIN + setConcept(fpa, chip, cell, db, cell->concepts, "CELL.GAIN"); + + // CELL.READNOISE + setConcept(fpa, chip, cell, db, cell->concepts, "CELL.READNOISE"); + + // CELL.SATURATION + setConcept(fpa, chip, cell, db, cell->concepts, "CELL.SATURATION"); + + // CELL.BAD + setConcept(fpa, chip, cell, db, cell->concepts, "CELL.BAD"); + + // CELL.XPARITY + setConcept(fpa, chip, cell, db, cell->concepts, "CELL.XPARITY"); + + // CELL.YPARITY + setConcept(fpa, chip, cell, db, cell->concepts, "CELL.YPARITY"); + + // CELL.READDIR + setConcept(fpa, chip, cell, db, cell->concepts, "CELL.READDIR"); + + // These used to be pmReadoutGetExposure and pmReadoutGetDarkTime, but that doesn't really make sense at + // the moment. Maybe we need to add a "parent" link to the readouts. But then how are the exposure times + // REALLY derived? They're not in the FITS headers, because a readout is a plane in a 3D image. We'll + // have to dream up some additional suffix to specify these, but for now.... + + // CELL.EXPOSURE (used to be READOUT.EXPOSURE) + setConcept(fpa, chip, cell, db, cell->concepts, "CELL.EXPOSURE"); + + // CELL.DARKTIME (used to be READOUT.DARKTIME) + setConcept(fpa, chip, cell, db, cell->concepts, "CELL.DARKTIME"); + + // These take some extra work + + // CELL.TRIMSEC + { + psMetadataItem *trimsecItem = psMetadataLookup(cell->concepts, "CELL.TRIMSEC"); + psRegion *trimsec = trimsecItem->data.V; // The trimsec region + psMetadataItem *sourceItem = p_pmFPAConceptGet(fpa, chip, cell, db, "CELL.TRIMSEC.SOURCE"); + if (! sourceItem) + { + psError(PS_ERR_IO, false, "Couldn't find CELL.TRIMSEC.SOURCE.\n"); + } else if (sourceItem->type != PS_DATA_STRING) + { + psError(PS_ERR_IO, true, "CELL.TRIMSEC.SOURCE is not of type STR (%x)\n", sourceItem->type); + } else + { + psString source = sourceItem->data.V; // The source string + + if (strcasecmp(source, "VALUE") == 0) { + // Check that it's the same value as stored in the camera + psString checkString = psMetadataLookupStr(NULL, cell->camera, "CELL.TRIMSEC"); + psRegion checkRegion = psRegionFromString(checkString); + if (! COMPARE_REGIONS(&checkRegion, trimsec)) { + psError(PS_ERR_IO, true, "Target CELL.TRIMSEC is specified by value, and values don't " + "match.\n"); + } + } else if (strcasecmp(source, "HEADER") == 0) { + // psString keyword = psMetadataLookupStr(NULL, cell->camera, "CELL.TRIMSEC"); + psMetadata *header = NULL; // The FITS header + if (cell->hdu) { + header = cell->hdu->header; + } else if (chip->hdu) { + header = chip->hdu->header; + } else if (fpa->hdu) { + header = fpa->hdu->header; + } + if (! header) { + psError(PS_ERR_IO, true, "Unable to find FITS header!\n"); + } else { + psMetadataAddItem(header, trimsecItem, PS_LIST_TAIL, PS_META_REPLACE); + } + } else { + psError(PS_ERR_IO, true, "CELL.TRIMSEC.SOURCE (%s) is not HEADER or VALUE.\n", source); + } + } + } + + // CELL.BIASSEC + { + psMetadataItem *biassecItem = psMetadataLookup(cell->concepts, "CELL.BIASSEC"); + psList *biassecs = biassecItem->data.V; // The biassecs region list + psMetadataItem *sourceItem = p_pmFPAConceptGet(fpa, chip, cell, db, "CELL.BIASSEC.SOURCE"); + if (! sourceItem) + { + psError(PS_ERR_IO, false, "Couldn't find CELL.BIASSEC.SOURCE.\n"); + } else if (sourceItem->type != PS_DATA_STRING) + { + psError(PS_ERR_IO, true, "CELL.BIASSEC.SOURCE is not of type STR (%x)\n", sourceItem->type); + } else + { + psString source = sourceItem->data.V; // The source string + + if (strcasecmp(source, "VALUE") == 0) { + // Check that it's the same value as stored in the camera + psString checkString = psMetadataLookupStr(NULL, cell->camera, "CELL.BIASSEC"); + psList *checkList = psStringSplit(checkString, " ;"); + if (biassecs->n != checkList->n) { + psError(PS_ERR_IO, true, "Target CELL.BIASSEC is specified by value, but number of " + "entries doesn't match.\n"); + } else { + // We don't care if the order matches or not + psVector *check = psVectorAlloc(biassecs->n, PS_TYPE_U8); // Vector to mark regions off + for (int i = 0; i < check->n; i++) { + check->data.U8[i] = 0; + } + psListIterator *biassecsIter = psListIteratorAlloc(biassecs, PS_LIST_HEAD, + false); // Iterator + psListIterator *checkListIter = psListIteratorAlloc(checkList, PS_LIST_HEAD, false); + psRegion *biassec = NULL; // Region from iteration + while ((biassec = psListGetAndIncrement(biassecsIter))) { + psListIteratorSet(checkListIter, PS_LIST_HEAD); + psString checkRegionString = NULL; // Region string from iteration + int i = 0; // Counter + while ((checkRegionString = psListGetAndIncrement(checkListIter))) { + psRegion checkRegion = psRegionFromString(checkRegionString); + psTrace(__func__, 7, "Checking [%.0f:%.0f,%.0f:%.0f] against " + "[%.0f:%.0f,%.0f:%.0f]\n", biassec->x0, biassec->x1, biassec->y0, + biassec->y1, checkRegion.x0, checkRegion.x1, checkRegion.y0, + checkRegion.y1); + if (COMPARE_REGIONS(biassec, &checkRegion)) { + check->data.U8[i] = 1; + i++; + break; + } + i++; + } + } + for (int i = 0; i < check->n; i++) { + if (check->data.U8[i] == 0) { + psError(PS_ERR_IO, true, "Target CELL.BIASSEC is specified by value, but values " + "don't match.\n"); + break; + } + } + psFree(checkListIter); + psFree(biassecsIter); + psFree(check); + } + psFree(checkList); + } else if (strcasecmp(source, "HEADER") == 0) { + psString keywordsString = psMetadataLookupStr(NULL, cell->camera, "CELL.BIASSEC"); + psList *keywords = psStringSplit(keywordsString, " ,;"); + if (biassecs->n != keywords->n) { + psError(PS_ERR_IO, true, "Target CELL.BIASSEC is sepcified by headers, but the number " + "of headers doesn't match.\n"); + } else { + psMetadata *header = NULL; // The FITS header + if (cell->hdu) { + header = cell->hdu->header; + } else if (chip->hdu) { + header = chip->hdu->header; + } else if (fpa->hdu) { + header = fpa->hdu->header; + } + if (! header) { + psError(PS_ERR_IO, true, "Unable to find FITS header!\n"); + } else { + psListIterator *keywordsIter = psListIteratorAlloc(keywords, PS_LIST_HEAD, false); + psListIterator *biassecsIter = psListIteratorAlloc(biassecs, PS_LIST_HEAD, false); + psString keyword = NULL; // Header keyword from list + while ((keyword = psListGetAndIncrement(keywordsIter))) { + // Update the header + psRegion *biassec = psListGetAndIncrement(biassecsIter); + psString biassecString = psRegionToString(*biassec); + psMetadataAdd(header, PS_LIST_TAIL, keyword, PS_DATA_STRING | PS_META_REPLACE, + "Bias section", biassecString); + psFree(biassecString); + } + psFree(keywordsIter); + psFree(biassecsIter); + } + } + psFree(keywords); + } else { + psError(PS_ERR_IO, true, "CELL.BIASSEC.SOURCE (%s) is not HEADER or VALUE.\n", source); + } + } + } + + // CELL.XBIN and CELL.YBIN + { + psMetadataItem *xBinItem = psMetadataLookup(cell->concepts, "CELL.XBIN"); // Binning factor in x + psMetadataItem *yBinItem = psMetadataLookup(cell->concepts, "CELL.YBIN"); // Binning factor in y + + // If these are specified by the header, we need to check to see if it's the same header keyword + const psMetadata *camera = fpa->camera; + psMetadata *translation = psMetadataLookupMD(NULL, camera, "TRANSLATION"); + psString xKeyword = psMetadataLookupStr(NULL, translation, "CELL.XBIN"); + psString yKeyword = psMetadataLookupStr(NULL, translation, "CELL.YBIN"); + if (strlen(xKeyword) > 0 && strcasecmp(xKeyword, yKeyword) != 0) + { + setConceptInHeader(fpa, chip, cell, xBinItem); + xBinItem = NULL; + } + if (strlen(yKeyword) > 0 && strcasecmp(xKeyword, yKeyword) != 0) + { + setConceptInHeader(fpa, chip, cell, yBinItem); + yBinItem = NULL; + } + if (strlen(xKeyword) > 0 && strlen(yKeyword) > 0 && strcasecmp(xKeyword, yKeyword) == 0) + { + psString binString = psStringCopy(""); + psStringAppend(&binString, "%d,%d", xBinItem->data.S32, yBinItem->data.S32); + psMetadataItem *binItem = psMetadataItemAllocStr(xKeyword, "Binning factor in x and y", + binString); + psFree(binString); + psMetadata *header = NULL; // The FITS header + if (cell->hdu) { + header = cell->hdu->header; + } else if (chip->hdu) { + header = chip->hdu->header; + } else if (fpa->hdu) { + header = fpa->hdu->header; + } + if (! header) { + psError(PS_ERR_IO, true, "Unable to find FITS header!\n"); + } else { + psMetadataAddItem(header, binItem, PS_LIST_TAIL, PS_META_REPLACE); + xBinItem = NULL; + yBinItem = NULL; + } + psFree(binItem); + } + + // Do it in the usual way if we have to + if (xBinItem) + { + setConceptItem(fpa, chip, cell, db, xBinItem); + } + if (yBinItem) + { + setConceptItem(fpa, chip, cell, db, yBinItem); + } + } + + // CELL.TIMESYS + { + psMetadataItem *sysItem = psMetadataLookup(cell->concepts, "CELL.TIMESYS"); + psString sys = NULL; // String to store + switch (sysItem->data.S32) + { + case PS_TIME_TAI: + sys = psStringCopy("TAI"); + break; + case PS_TIME_UTC: + sys = psStringCopy("UTC"); + break; + case PS_TIME_UT1: + sys = psStringCopy("UT1"); + break; + case PS_TIME_TT: + sys = psStringCopy("TT"); + break; + default: + sys = psStringCopy("Unknown"); + } + psMetadataItem *newItem = psMetadataItemAllocStr("CELL.TIMESYS", "Time system", sys); + setConceptItem(fpa, chip, cell, db, newItem); + psFree(newItem); + psFree(sys); + } + + // CELL.TIME + { + psMetadataItem *timeItem = psMetadataLookup(cell->concepts, "CELL.TIME"); + psTime *time = timeItem->data.V; // The time + psString dateTimeString = psTimeToISO(time); // String representation + + psMetadata *formats = psMetadataLookupMD(NULL, fpa->camera, "FORMATS"); + psString format = psMetadataLookupStr(NULL, formats, "CELL.TIME"); + + if (strlen(format) == 0) + { + // No format specified --> do it in the usual way (maybe it's a DB lookup) + psMetadataItem *newTimeItem = psMetadataItemAllocStr("CELL.TIME", "Time of observation", + dateTimeString); + setConceptItem(fpa, chip, cell, db, newTimeItem); + psFree(newTimeItem); + } else + { + if (strcasecmp(format, "ISO") == 0) { + // dateTimeString contains an ISO time + psMetadataItem *newTimeItem = psMetadataItemAllocStr("CELL.TIME", "Time of observation", + dateTimeString); + setConceptItem(fpa, chip, cell, db, newTimeItem); + psFree(newTimeItem); + } else if (strstr(format, "SEPARATE")) { + // We're working with two separate headers + psMetadata *header = NULL; // The FITS header + if (cell->hdu) { + header = cell->hdu->header; + } else if (chip->hdu) { + header = chip->hdu->header; + } else if (fpa->hdu) { + header = fpa->hdu->header; + } + if (! header) { + psError(PS_ERR_IO, true, "Unable to find FITS header!\n"); + } else { + // Get the headers + const psMetadata *camera = fpa->camera; + psMetadata *translation = psMetadataLookupMD(NULL, camera, "TRANSLATION"); + psString keywords = psMetadataLookupStr(NULL, translation, "CELL.TIME"); + psList *dateTimeKeywords = psStringSplit(keywords, " ,;"); + psString dateKeyword = psListGet(dateTimeKeywords, PS_LIST_HEAD); + psString timeKeyword = psListGet(dateTimeKeywords, PS_LIST_TAIL); + + psList *dateTime = psStringSplit(dateTimeString, " T"); // Find the middle T + psString dateString = psListGet(dateTime, PS_LIST_HEAD); + psString timeString = psListGet(dateTime, PS_LIST_TAIL); + + // XXX: Couldn't be bothered doing these right now + if (strstr(format, "PRE2000")) { + psError(PS_ERR_IO, true, "Don't you realise it's the twenty-first century?\n"); + } + if (strstr(format, "BACKWARDS")) { + psError(PS_ERR_IO, true, "You want it BACKWARDS? Not right now, thanks.\n"); + } + + psMetadataItem *dateItem = psMetadataItemAllocStr(dateKeyword, "Date of observation", + dateString); + psMetadataItem *timeItem = psMetadataItemAllocStr(timeKeyword, "Time of observation", + timeString); + psMetadataAddItem(header, dateItem, PS_LIST_TAIL, PS_META_REPLACE); + psMetadataAddItem(header, timeItem, PS_LIST_TAIL, PS_META_REPLACE); + + psFree(dateTimeKeywords); + psFree(dateTime); + psFree(dateItem); + psFree(timeItem); + } + } else if (strcasecmp(format, "MJD") == 0) { + double mjd = psTimeToMJD(time); + psMetadataItem *newTimeItem = psMetadataItemAllocF64("CELL.TIME", "MJD of observation", mjd); + setConceptItem(fpa, chip, cell, db, newTimeItem); + psFree(newTimeItem); + } else if (strcasecmp(format, "JD") == 0) { + double jd = psTimeToMJD(time); + psMetadataItem *newTimeItem = psMetadataItemAllocF64("CELL.TIME", "JD of observation", jd); + setConceptItem(fpa, chip, cell, db, newTimeItem); + psFree(newTimeItem); + } else { + psError(PS_ERR_IO, true, "Not sure how to outgest CELL.TIME (%s) --- trying " + "ISO\n", dateTimeString); + psMetadataItem *newTimeItem = psMetadataItemAllocStr("CELL.TIME", "Time of observation", + dateTimeString); + setConceptItem(fpa, chip, cell, db, newTimeItem); + psFree(newTimeItem); + } + } + + psFree(dateTimeString); + } + + // Remove corrective + { + const psMetadata *camera = fpa->camera; + bool mdok = false; // Result of MD lookup + psMetadata *formats = psMetadataLookupMD(&mdok, camera, "FORMATS"); + if (mdok && formats) + { + psString format = psMetadataLookupStr(&mdok, formats, "CELL.X0"); + if (mdok && strlen(format) > 0 && strcasecmp(format, "FORTRAN") == 0) { + psMetadataItem *cellx0 = psMetadataLookup(cell->concepts, "CELL.X0"); + cellx0->data.S32 += 1; + } + format = psMetadataLookupStr(&mdok, formats, "CELL.Y0"); + if (mdok && strlen(format) > 0 && strcasecmp(format, "FORTRAN") == 0) { + psMetadataItem *celly0 = psMetadataLookup(cell->concepts, "CELL.Y0"); + celly0->data.S32 += 1; + } + } + } + // CELL.X0 + setConcept(fpa, chip, cell, db, cell->concepts, "CELL.X0"); + // CELL.Y0 + setConcept(fpa, chip, cell, db, cell->concepts, "CELL.Y0"); + + // Pau. +} + Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/astrom/pmFPAConceptsSet.h =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/astrom/pmFPAConceptsSet.h (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/astrom/pmFPAConceptsSet.h (revision 21664) @@ -0,0 +1,20 @@ +#ifndef PM_FPA_CONCEPTS_SET_H +#define PM_FPA_CONCEPTS_SET_H + +#include "pslib.h" +#include "pmAstrometry.h" + +void pmFPAOutgestConcepts(pmFPA *fpa, // The FPA + psDB *db // DB handle + ); +void pmChipOutgestConcepts(pmChip *chip, // The chip + psDB *db // DB handle + ); +void pmCellOutgestConcepts(pmCell *cell, // The cell + psDB *db // DB handle + ); + + + + +#endif Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/astrom/pmFPAConstruct.c =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/astrom/pmFPAConstruct.c (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/astrom/pmFPAConstruct.c (revision 21664) @@ -0,0 +1,324 @@ +#include +#include +#include "pslib.h" + +#include "pmFPA.h" +#include "pmFPAConstruct.h" +#include "psAdditionals.h" + +////////////////////////////////////////////////////////////////////////////////////////////////////////////// +// File-static functions +////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +// Read data for a particular cell from the camera configuration +static psMetadata *getCellData(const psMetadata *camera, // The camera configuration + const char *cellName // The name of the cell + ) +{ + bool status = true; // Result of MD lookup + psMetadata *cells = psMetadataLookupMD(&status, camera, "CELLS"); // The CELLS + if (! status) { + psError(PS_ERR_IO, false, "Unable to determine CELLS of camera.\n"); + return NULL; + } + + psMetadata *cellData = psMetadataLookupMD(&status, cells, cellName); // The data for the particular cell + if (! status) { + psError(PS_ERR_IO, false, "Unable to find specs for cell %s: ignored\n", cellName); + } + + #if 0 + // Need to create a new instance, so that each cell can work with its own + psMetadata *copy = psMetadataAlloc(); + psMetadataIterator *iter = psMetadataIteratorAlloc(cellData, PS_LIST_HEAD, NULL); // Iterator + psMetadataItem *item = NULL; // Item from iteration + while (item = psMetadataGetAndIncrement(iter)) { + if (item->type == PS_DATA_METADATA_MULTI || item->type == PS_DATA_METADATA) { + psLogMsg(__func__, PS_LOG_WARN, "PS_DATA_METADATA_MULTI and PS_DATA_METADATA are not supported " + "in a cell definition --- %s ignored.\n", item->name); + continue; + } + if (! psMetadataAdd(copy, PS_LIST_TAIL, item->name, item->type, item->comment, item->data.V)) { + psAbort(__func__, "Should never reach here!\n"); + } + } + psFree(iter); + + return copy; + #else + + return cellData; + #endif + +} + + +////////////////////////////////////////////////////////////////////////////////////////////////////////////// +// Public functions +////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +pmFPA *pmFPAConstruct(const psMetadata *camera // The camera configuration + ) +{ + pmFPA *fpa = pmFPAAlloc(camera); // The FPA to fill out + + bool mdStatus = true; // Status from metadata lookups + const char *phuType = psMetadataLookupStr(&mdStatus, camera, "PHU"); // What is the PHU? + const char *extType = psMetadataLookupStr(&mdStatus, camera, "EXTENSIONS"); // What's in the extns? + + if (strcasecmp(phuType, "FPA") == 0) { + // The FITS file contains an entire FPA + + psMetadata *contents = psMetadataLookupMD(&mdStatus, camera, "CONTENTS"); // The CONTENTS + if (! mdStatus) { + psError(PS_ERR_IO, false, "Unable to determine CONTENTS of camera.\n"); + psFree(fpa); + return NULL; + } + + // Set up iteration over the contents + psMetadataIterator *contentsIter = psMetadataIteratorAlloc(contents, PS_LIST_HEAD, NULL); + psMetadataItem *contentItem = NULL; // Item from the metadata + + if (strcasecmp(extType, "CHIP") == 0) { + // Extensions are chips; Content contains a list of cells + while ((contentItem = psMetadataGetAndIncrement(contentsIter))) { + psString extName = contentItem->name; // The name of the extension + pmChip *chip = pmChipAlloc(fpa, extName); // The chip + chip->hdu = p_pmHDUAlloc(extName); // Prepare chip to receive FITS data + if (contentItem->type != PS_DATA_STRING) { + psLogMsg(__func__, PS_LOG_WARN, "Type of content item (%x) is not string: ignored\n", + contentItem->type); + continue; + } + + const char *content = contentItem->data.V; // The content of the extension + psTrace(__func__, 7, "Content of %s is: %s\n", extName, content); + psList *cellNames = psStringSplit(content, " ,"); // A list of the component cells + psListIterator *cellNamesIter = psListIteratorAlloc(cellNames, PS_LIST_HEAD, NULL); + char *cellName = NULL; // The name of a cell + while ((cellName = psListGetAndIncrement(cellNamesIter))) { + // Get the cell data + psMetadata *cellData = getCellData(camera, cellName); + pmCell *cell = pmCellAlloc(chip, cellData, cellName); // The cell + psFree(cell); // Drop reference + // psFree(cellData); // Drop reference + } + psFree(cellNamesIter); + psFree(cellNames); + psFree(chip); // Drop reference + } + + } else if (strcasecmp(extType, "CELL") == 0) { + // Extensions are cells; Content contains a chip name and cell type + psMetadata *chips = psMetadataAlloc(); // Given a chip name, holds the chip number + while ((contentItem = psMetadataGetAndIncrement(contentsIter))) { + psString extName = contentItem->name; // The name of the extension + psTrace(__func__, 1, "Getting %s....\n", extName); + + if (contentItem->type != PS_DATA_STRING) { + psLogMsg(__func__, PS_LOG_WARN, "Type of content item (%x) is not string: ignored\n", + contentItem->type); + continue; + } + const char *content = contentItem->data.V; // The content of the extension + psList *contents = psStringSplit(content, ": "); // Split the name from the type + if (contents->n != 2) { + psLogMsg(__func__, PS_LOG_WARN, "Unable to read contents of %s: ignored.\n", extName); + } else { + psString chipName = psListGet(contents, 0); // The name of the chip + psString cellType = psListGet(contents, 1); // The type of cell + psTrace(__func__, 7, "Extension is cell of type %s, from chip %s\n", cellType, + chipName); + + psMetadataItem *chipItem = psMetadataLookup(chips, chipName); // Item containing the chip + pmChip *chip = NULL; // The chip + if (! chipItem) { + chip = pmChipAlloc(fpa, chipName); + psMetadataAdd(chips, PS_LIST_TAIL, chipName, PS_DATA_UNKNOWN, "", chip); + } else { + chip = psMemIncrRefCounter(chipItem->data.V); + } + // The cell + psMetadata *cellData = getCellData(camera, cellType); + pmCell *cell = pmCellAlloc(chip, cellData, extName); // The cell + // psFree(cellData); // Drop reference + cell->hdu = p_pmHDUAlloc(extName); // Prepare cell to receive FITS data + + psFree(cell); // Drop reference + psFree(chip); // Drop reference + } + psFree(contents); + } + psFree(chips); + + } else if (strcasecmp(extType, "NONE") == 0) { + // No extensions; Content contains metadata, each entry is a chip with its component cells + fpa->hdu = p_pmHDUAlloc("PHU"); // Prepare FPA to receive FITS data + while ((contentItem = psMetadataGetAndIncrement(contentsIter))) { + psString chipName = contentItem->name; // The name of the chip + + if (contentItem->type != PS_DATA_STRING) { + psLogMsg(__func__, PS_LOG_WARN, "Type of content item (%x) is not string: ignored\n", + contentItem->type); + continue; + } + psString content = contentItem->data.V; // The content of the extension + psTrace(__func__, 5, "Component cells are: %s\n", content); + pmChip *chip = pmChipAlloc(fpa, chipName); // The chip + psList *cellNames = psStringSplit(content, ", "); // Split the list of cells + psListIterator *cellNamesIter = psListIteratorAlloc(cellNames, PS_LIST_HEAD, false); + char *cellName = NULL; // Name of the cell + while ((cellName = psListGetAndIncrement(cellNamesIter))) { + psTrace(__func__, 7, "Processing cell %s....\n", cellName); + psMetadata *cellData = getCellData(camera, cellName); + pmCell *cell = pmCellAlloc(chip, cellData, cellName); // The cell + psFree(cell); // Drop reference + // psFree(cellData); // Drop reference + } + psFree(cellNamesIter); + psFree(chip); // Drop reference + } + + } else { + psError(PS_ERR_IO, false, "EXTENSIONS in camera definition is not CHIP, CELL or NONE.\n"); + psFree(fpa); + return NULL; + } // Type of extension + + psFree(contentsIter); + + } else if (strcasecmp(phuType, "CHIP") == 0) { + // The FITS file contains a single chip only + psString chipName = psStringCopy("CHIP"); // Name for chip + pmChip *chip = pmChipAlloc(fpa, chipName); // The chip + + if (strcasecmp(extType, "NONE") == 0) { + // There are no extensions --- only the PHU + chip->hdu = p_pmHDUAlloc("PHU"); + + const char *contents = psMetadataLookupStr(&mdStatus, camera, "CONTENTS"); + if (! mdStatus) { + psError(PS_ERR_IO, false, "Unable to determine CONTENTS of camera.\n"); + psFree(fpa); + return NULL; + } + psList *cellNames = psStringSplit(contents, " ,"); // Names of cells + psListIterator *cellIter = psListIteratorAlloc(cellNames, PS_LIST_HEAD, false); // Iterator + psString cellName = NULL; + while ((cellName = psListGetAndIncrement(cellIter))) { + psMetadata *cellData = getCellData(camera, cellName); + pmCell *cell = pmCellAlloc(chip, cellData, cellName); // The cell + psFree(cell); + } + psFree(cellIter); + psFree(cellNames); + + } else if (strcasecmp(extType, "CELL") == 0) { + // Extensions are cells + psMetadata *contents = psMetadataLookupMD(&mdStatus, camera, "CONTENTS"); // The CONTENTS + if (! mdStatus) { + psError(PS_ERR_IO, false, "Unable to determine CONTENTS of camera.\n"); + psFree(fpa); + return NULL; + } + + if (strcasecmp(extType, "CELL") != 0) { + psLogMsg(__func__, PS_LOG_WARN, "EXTENSIONS in camera definition is %s, but PHU is CHIP.\n" + "EXTENSIONS assumed to be CELL.\n", extType); + } + + // Iterate through the contents + psMetadataIterator *contentsIter = psMetadataIteratorAlloc(contents, PS_LIST_HEAD, NULL); + psMetadataItem *contentItem = NULL; // Item from metadata + while ((contentItem = psMetadataGetAndIncrement(contentsIter))) { + psString extName = contentItem->name; // The name of the extension + // Content is a cell type + if (contentItem->type != PS_DATA_STRING) { + psLogMsg(__func__, PS_LOG_WARN, + "CONTENT metadata for extension %s is not of type string, but %x --- ignored\n", + extName, contentItem->type); + continue; + } + const char *cellType = contentItem->data.V; // The type of cell + psTrace(__func__, 5, "Cell type is %s\n", cellType); + psMetadata *cellData = getCellData(camera, cellType); + pmCell *cell = pmCellAlloc(chip, cellData, extName); // The cell + // psFree(cellData); + cell->hdu = p_pmHDUAlloc(extName); // Prepare cell to receive FITS data + + psFree(cell); + } // Iterating through contents + psFree(contentsIter); + + } else { + psError(PS_ERR_IO, false, "EXTENSIONS in camera definition is neither CELL or NONE.\n"); + psFree(fpa); + return NULL; + } + psFree(chipName); + psFree(chip); // Drop reference + + } else { + psError(PS_ERR_IO, true, + "The PHU type specified in the camera configuration (%s) is not FPA or CHIP.\n", + phuType); + psFree(fpa); + return NULL; + } + + return fpa; +} + +// Print out the focal plane structure +void pmFPAPrint(pmFPA *fpa // FPA to print + ) +{ + psTrace(__func__, 1, "FPA:\n"); + if (fpa->hdu) { + psTrace(__func__, 2, "---> FPA is extension %s.\n", fpa->hdu->extname); + if (! fpa->hdu->images) { + psTrace(__func__, 2, "---> NO PIXELS for extension %s\n", fpa->hdu->extname); + } + } + psMetadataPrint(fpa->concepts, 2); + + psArray *chips = fpa->chips; // Array of chips + // Iterate over the FPA + for (int i = 0; i < chips->n; i++) { + psTrace(__func__, 3, "Chip: %d\n", i); + pmChip *chip = chips->data[i]; // The chip + if (chip->hdu) { + psTrace(__func__, 4, "---> Chip is extension %s.\n", chip->hdu->extname); + if (! chip->hdu->images) { + psTrace(__func__, 4, "---> NO PIXELS for extension %s\n", chip->hdu->extname); + } + } + psMetadataPrint(chip->concepts, 4); + + // Iterate over the chip + psArray *cells = chip->cells; // Array of cells + for (int j = 0; j < cells->n; j++) { + psTrace(__func__, 5, "Cell: %d\n", j); + pmCell *cell = cells->data[j]; // The cell + if (cell->hdu) { + psTrace(__func__, 6, "---> Cell is extension %s.\n", cell->hdu->extname); + if (! cell->hdu->images) { + psTrace(__func__, 6, "---> NO PIXELS for extension %s\n", cell->hdu->extname); + } + } + psMetadataPrint(cell->concepts, 6); + + psTrace(__func__, 7, "Readouts:\n"); + psArray *readouts = cell->readouts; // Array of readouts + for (int k = 0; k < readouts->n; k++) { + pmReadout *readout = readouts->data[k]; // The readout + psImage *image = readout->image; // The image + psTrace(__func__, 8, "Image: [%d:%d,%d:%d] (%dx%d)\n", image->col0, image->col0 + + image->numCols, image->row0, image->row0 + image->numRows, image->numCols, + image->numRows); + } // Iterating over cell + } // Iterating over chip + } // Iterating over FPA + +} Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/astrom/pmFPAConstruct.h =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/astrom/pmFPAConstruct.h (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/astrom/pmFPAConstruct.h (revision 21664) @@ -0,0 +1,16 @@ +#ifndef PM_FPA_CONSTRUCT_H +#define PM_FPA_CONSTRUCT_H + +#include "pslib.h" +#include "pmFPA.h" + +// Read the contents of a FITS file (format specified by the camera configuration) into memory +pmFPA *pmFPAConstruct(const psMetadata *camera // The camera configuration + ); + +// Print out the FPA +void pmFPAPrint(pmFPA *fpa // FPA to print + ); + + +#endif Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/astrom/pmFPARead.c =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/astrom/pmFPARead.c (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/astrom/pmFPARead.c (revision 21664) @@ -0,0 +1,657 @@ +#include +#include +#include +#include "pslib.h" + +#include "pmFPA.h" +#include "pmFPARead.h" +#include "pmConcepts.h" + +////////////////////////////////////////////////////////////////////////////////////////////////////////////// +// File-static functions +////////////////////////////////////////////////////////////////////////////////////////////////////////////// + + +// Read a FITS extension into a chip +static bool readExtension(p_pmHDU *hdu, // Pixel data into which to read + psFits *fits // The FITS file from which to read + ) +{ + const char *extName = hdu->extname; // Extension name + + psTrace(__func__, 7, "Moving to extension %s...\n", extName); + if (strncmp(extName, "PHU", 3) == 0) { + if (!psFitsMoveExtNum(fits, 0, false)) { + psError(PS_ERR_IO, false, "Unable to find PHU in FITS file!\n"); + return false; + } + } else if (! psFitsMoveExtName(fits, extName)) { + psError(PS_ERR_IO, false, "Unable to find extension %s in FITS file!\n", extName); + return false; + } + psTrace(__func__, 7, "Reading header....\n"); + psMetadata *header = psFitsReadHeader(NULL, fits); // Header + if (! header) { + psError(PS_ERR_IO, false, "Unable to read FITS header!\n"); + return false; + } + + psTrace(__func__, 7, "Checking NAXIS....\n"); + bool mdStatus = false; + int nAxis = psMetadataLookupS32(&mdStatus, header, "NAXIS"); + if (!mdStatus) { + psLogMsg(__func__, PS_LOG_WARN, "There is no NAXIS keyword in the FITS header of extension %s!\n", + extName); + } + if (nAxis != 2 && nAxis != 3) { + psLogMsg(__func__, PS_LOG_WARN, "Image is not 2- or 3-dimensional --- reading into a single image " + "anyway.\n"); + } + psTrace(__func__, 9, "NAXIS = %d\n", nAxis); + + int numPlanes = 1; // Number of planes + if (nAxis == 3) { + numPlanes = psMetadataLookupS32(&mdStatus, header, "NAXIS3"); + if (!mdStatus) { + psError(PS_ERR_IO, false, "Unable to read NAXIS3 for 3-dimensional image!\n"); + return false; + } + } + psRegion region = {0, 0, 0, 0}; // Region to read is everything + + // Read each plane into the array + psTrace(__func__, 7, "Reading %d planes into array....\n", numPlanes); + psArray *pixels = psArrayAlloc(numPlanes); // Array of images + for (int i = 0; i < numPlanes; i++) { + psTrace(__func__, 9, "Reading plane %d\n", i); + psMemCheckCorruption(true); + psImage *image = psFitsReadImage(NULL, fits, region, i); + + // XXX: Type conversion here to support the modules, which don't have multiple type support yet + if (image->type.type != PS_TYPE_F32) { + pixels->data[i] = psImageCopy(NULL, image, PS_TYPE_F32); + + // XXX: Temporary fix for writing images, until psFits gets cleaned up + psMetadataItem *bitpixItem = psMetadataLookup(header, "BITPIX"); + bitpixItem->data.S32 = -32; + psMetadataRemove(header, 0, "BZERO"); + psMetadataRemove(header, 0, "BSCALE"); + + psFree(image); + } else { + pixels->data[i] = image; + } + psTrace(__func__, 10, "Done\n"); + if (! pixels->data[i]) { + psError(PS_ERR_IO, false, "Unable to read image for extension %s, plane %d\n", extName, i); + return false; + } + } + + // Update the HDU with the new data + hdu->images = pixels; + hdu->header = header; + + // Mask and weight not set yet + hdu->weights = NULL; + hdu->masks = NULL; + + return true; +} + +// Portion out an image into the cell +static bool generateReadouts(pmCell *cell, // The cell that gets its bits + p_pmHDU *hdu // Pixel data, containing image, mask, weights + ) +{ + psArray *images = hdu->images; // Array of images (each of which is a readout) + + psRegion *trimsec = psMetadataLookupPtr(NULL, cell->concepts, "CELL.TRIMSEC"); + psList *biassecs = psMetadataLookupPtr(NULL, cell->concepts, "CELL.BIASSEC"); + + // Iterate over each of the image planes + for (int i = 0; i < images->n; i++) { + psImage *image = images->data[i]; // The i-th plane + pmReadout *readout = pmReadoutAlloc(cell); + + readout->image = psMemIncrRefCounter(psImageSubset(image, *trimsec)); // The image corresponding to the trim region + + // Get the list of overscans + psListIterator *iter = psListIteratorAlloc(biassecs, PS_LIST_HEAD, false); // Iterator + psRegion *biassec = NULL; // A BIASSEC region from the list + while ((biassec = psListGetAndIncrement(iter))) { + psImage *overscan = psMemIncrRefCounter(psImageSubset(image, *biassec)); + psListAdd(readout->bias, PS_LIST_TAIL, overscan); + psFree(overscan); + } + psFree(iter); + + readout->mask = NULL; + readout->weight = NULL; + + psFree(readout); // Drop reference + } + + return true; +} + +////////////////////////////////////////////////////////////////////////////////////////////////////////////// +// Public functions +////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +bool pmFPARead(pmFPA *fpa, // FPA to read into + psFits *fits, // FITS file from which to read + psMetadata *phu, // Primary header + psDB *db // Database handle, for concept ingest + ) +{ + p_pmHDU *hdu = NULL; // Pixel data from FITS file + + // Read the PHU, if required + if (! phu) { + if (! psFitsMoveExtNum(fits, 0, false)) { + psError(PS_ERR_IO, false, "Unable to find PHU in FITS file!\n"); + return false; + } + psTrace(__func__, 7, "Reading PHU....\n"); + fpa->phu = psFitsReadHeader(NULL, fits); // Primary header + } else if (! fpa->phu) { + fpa->phu = psMemIncrRefCounter(phu); + } + + // Read in.... + psTrace(__func__, 1, "Reading FPA...\n"); + if (fpa->hdu) { + hdu = fpa->hdu; + psTrace(__func__, 3, "Reading pixels from extension %s into FPA.\n", hdu->extname); + if (! readExtension(hdu, fits)) { + psError(PS_ERR_IO, false, "Unable to read pixels from extension %s\n", hdu->extname); + return false; + } + } + pmConceptsReadFPA(fpa, db); + + psArray *chips = fpa->chips; // Array of chips + // Iterate over the FPA + for (int i = 0; i < chips->n; i++) { + pmChip *chip = chips->data[i]; // The chip + + // Only read chips marked to "read" + if (! chip || ! chip->process || chip->exists) { + psTrace(__func__, 2, "Ignoring chip %d...\n", i); + continue; + } + psTrace(__func__, 2, "Reading in chip %d...\n", i); + + if (chip->hdu) { + hdu = chip->hdu; + psTrace(__func__, 3, "Reading pixels from extension %s into chip %d.\n", hdu->extname, i); + if (! readExtension(hdu, fits)) { + psError(PS_ERR_IO, false, "Unable to read pixels from extension %s\n", hdu->extname); + return false; + } + } + + pmConceptsReadChip(chip, db); + + // Iterate over the chip + psArray *cells = chip->cells; // Array of cells + for (int j = 0; j < cells->n; j++) { + pmCell *cell = cells->data[j]; // The cell + + // Only read cells marked to "read" + if (!cell || ! cell->process || cell->exists) { + psTrace(__func__, 3, "Ignoring chip %d...\n", i); + continue; + } + psTrace(__func__, 3, "Reading in cell %d...\n", j); + + if (cell->hdu) { + hdu = cell->hdu; + psTrace(__func__, 5, "Reading pixels from extension %s into cell %d.\n", hdu->extname, + j); + if (! readExtension(hdu, fits)) { + psError(PS_ERR_IO, false, "Unable to read pixels from extension %s\n", + hdu->extname); + return false; + } + } + psTrace(__func__, 5, "Reading concepts for cell %d...\n", j); + pmConceptsReadCell(cell, db); + + psTrace(__func__, 5, "Allocating readouts for chip %d cell %d...\n", i, j); + generateReadouts(cell, hdu); + + cell->exists = true; + } + chip->exists = true; + } + + psTrace(__func__, 1, "Done reading FPA...\n"); + + return true; +} + +// Translate a name from the configuration file, containing something like "%a_%d" to a real value +psString p_pmFPATranslateName(const psString name, // The name to translate + const pmCell *cell // The cell for which to translate + ) +{ + // %a is the FPA.NAME + // %b is the CHIP.NAME + // %c is the CELL.NAME + // %d is the chip number + // %e if the cell number + // %f is the extension name + + psString translation = psMemIncrRefCounter(name); // The translated string + char *temp = NULL; // Temporary string + + pmChip *chip = cell->parent; // Chip of interest + pmFPA *fpa = chip->parent; // FPA of interest + + // FPA.NAME + if ((temp = strstr(translation, "%a"))) { + // This is not particularly friendly to the memory allocation, but the cache should make it OK, + // and there's not much of it anyway... + psFree(translation); + translation = psStringNCopy(name, strlen(name) - strlen(temp)); // Copy first part of string + psString fpaName = psMetadataLookupStr(NULL, fpa->concepts, "FPA.NAME"); // The value of FPA.NAME + psStringAppend(&translation, "%s%s", fpaName, temp + 2); + // So "translation" now contains the first part, the replaced string, and the last part. + } + + // CHIP.NAME + if ((temp = strstr(translation, "%b"))) { + // This is not particularly friendly to the memory allocation, but the cache should make it OK, + // and there's not much of it anyway... + psFree(translation); + translation = psStringNCopy(name, strlen(name) - strlen(temp)); // Copy first part of string + psString chipName = psMetadataLookupStr(NULL, chip->concepts, "CHIP.NAME"); // CHIP.NAME's value + psStringAppend(&translation, "%s%s", chipName, temp + 2); + // So "translation" now contains the first part, the replaced string, and the last part. + } + + // CELL.NAME + if ((temp = strstr(translation, "%c"))) { + // This is not particularly friendly to the memory allocation, but the cache should make it OK, + // and there's not much of it anyway... + psFree(translation); + translation = psStringNCopy(name, strlen(name) - strlen(temp)); // Copy first part of string + psString cellName = psMetadataLookupStr(NULL, cell->concepts, "CELL.NAME"); // CELL.NAME's value + psStringAppend(&translation, "%s%s", cellName, temp + 2); + // So "translation" now contains the first part, the replaced string, and the last part. + } + + // Chip number + if ((temp = strstr(translation, "%d"))) { + // This is not particularly friendly to the memory allocation, but the cache should make it OK, + // and there's not much of it anyway... + psFree(translation); + translation = psStringNCopy(name, strlen(name) - strlen(temp)); // Copy first part of string + // Search for the pointer to get the chip number + int chipNum = -1; + psArray *chips = fpa->chips; // The array of chips + for (int i = 0; i < chips->n && chipNum < 0; i++) { + if (chips->data[i] == chip) { + chipNum = i; + } + } + if (chipNum < 0) { + psError(PS_ERR_IO, true, "Unable to find chip to get name: %s\n", name); + // Try to muddle on by leaving the number out + psStringAppend(&translation, "%s", temp + 2); + } else { + psStringAppend(&translation, "%d%s", chipNum, temp + 2); + } + // So "translation" now contains the first part, the replaced string, and the last part. + } + + // Cell number + if ((temp = strstr(translation, "%e"))) { + // This is not particularly friendly to the memory allocation, but the cache should make it OK, + // and there's not much of it anyway... + psFree(translation); + translation = psStringNCopy(name, strlen(name) - strlen(temp)); // Copy first part of string + // Search for the pointer to get the cell number + int cellNum = -1; + psArray *cells = chip->cells; // The array of cells + for (int i = 0; i < cells->n && cellNum < 0; i++) { + if (cells->data[i] == cell) { + cellNum = i; + } + } + if (cellNum < 0) { + psError(PS_ERR_IO, true, "Unable to find cell to get name: %s\n", name); + // Try to muddle on by leaving the number out + psStringAppend(&translation, "%s", temp + 2); + } else { + psStringAppend(&translation, "%d%s", cellNum, temp + 2); + } + // So "translation" now contains the first part, the replaced string, and the last part. + } + + // Extension name + if ((temp = strstr(translation, "%f"))) { + // This is not particularly friendly to the memory allocation, but the cache should make it OK, + // and there's not much of it anyway... + psFree(translation); + translation = psStringNCopy(name, strlen(name) - strlen(temp)); // Copy first part of string + const char *extname = NULL; + if (cell->hdu) { + extname = cell->hdu->extname; + } else if (chip->hdu) { + extname = chip->hdu->extname; + } else if (fpa->hdu) { + extname = fpa->hdu->extname; + } + psStringAppend(&translation, "%s%s", extname, temp + 2); + // So "translation" now contains the first part, the replaced string, and the last part. + } + + return translation; +} + +// Get filename and extension out of "somefile.fits:ext" +psString p_pmFPATranslateFileExt(psString *extName, // Extension name, to be returned + const psString name, // The string to be translated and then parsed + const pmCell *cell // The cell + ) +{ + psString filenameExt = p_pmFPATranslateName(name, cell); + const char *colon = strchr(filenameExt, ':'); // Pointer to a colon in the filename-extn + psString filename = NULL; // The filename + if (extName && *extName) { + psFree(*extName); + } + if (extName) { + *extName = NULL; + } + + if (colon) { + filename = psStringNCopy(filenameExt, strlen(filenameExt) - strlen(colon)); + if (strlen(colon) > 1) { + if (extName) { + *extName = psStringCopy(colon + 1); + } + } + } else { + filename = psMemIncrRefCounter(filenameExt); + } + + return filename; +} + +// Read a mask into the FPA +bool pmFPAReadMask(pmFPA *fpa, // FPA to read into + psFits *source // Source FITS file (for the original data) + ) +{ + const psMetadata *camera = fpa->camera; // Camera configuration for FPA + bool mdok = false; // Status of MD lookup + + // Get the required information from the camera configuration + psMetadata *supps = psMetadataLookupMD(&mdok, camera, "SUPPLEMENTARY"); // Rules for supplementary data + if (! mdok || ! supps) { + psError(PS_ERR_IO, false, "Unable to find SUPPLEMENTARY in camera configuration!\n"); + return false; + } + psString sourceType = psMetadataLookupStr(&mdok, supps, "MASK.SOURCE"); // Type of source: EXT | FILE + if (! mdok || strlen(sourceType) <= 0) { + psError(PS_ERR_IO, false, "Unable to find MASK.SOURCE in SUPPLEMENTARY section of camera " + "configuration!\n"); + return false; + } + psString name = psMetadataLookupStr(&mdok, supps, "MASK.NAME"); // Name of mask + if (! mdok || strlen(sourceType) <= 0) { + psError(PS_ERR_IO, false, "Unable to find MASK.NAME in SUPPLEMENTARY section of camera " + "configuration!\n"); + return false; + } + + // Go through the FPA to each cell/readout to get the mask + p_pmHDU *hdu = fpa->hdu; // The HDU into which we will read the mask + psArray *chips = fpa->chips; // Array of chips + for (int chipNum = 0; chipNum < chips->n; chipNum++) { + pmChip *chip = chips->data[chipNum]; // The current chip of interest + if (chip->process && !chip->exists) { + if (chip->hdu) { + hdu = chip->hdu; + } + psArray *cells = chip->cells; // Array of cells + for (int cellNum = 0; cellNum < cells->n; cellNum++) { + pmCell *cell = cells->data[cellNum]; // The current cell of interest + if (cell->process && !cell->exists) { + if (cell->hdu) { + hdu = cell->hdu; + } + + // Now, need to find out where to get the pixels + psFits *maskSource = psMemIncrRefCounter(source); // Source of mask image + if (strcasecmp(sourceType, "FILE") == 0) { + // Source is a file (with optional extension, e.g., "myMaskFile.fits:thisExt" + psString extname = NULL; // Extension name + psString filename = p_pmFPATranslateFileExt(&extname, name, cell); // The filename + + psFree(maskSource); + maskSource = psFitsOpen(filename, "r"); + if (extname) { + if (! psFitsMoveExtName(maskSource, extname)) { + psLogMsg(__func__, PS_LOG_WARN, "Unable to find extension %s to read mask.\n", + extname); + return false; + } + } + psFree(filename); + psFree(extname); + } else if (strncasecmp(sourceType, "EXT", 3) == 0) { + // Source is an extension in the original file + psString extname = p_pmFPATranslateName(name, cell); + psFitsMoveExtName(maskSource, extname); + } + + // We've arrived where the pixels are. Now we need to read them in. + psMetadata *header = psFitsReadHeader(NULL, maskSource); // The header + bool mdStatus = false; + int nAxis = psMetadataLookupS32(&mdStatus, header, "NAXIS"); + if (!mdStatus) { + psLogMsg(__func__, PS_LOG_WARN, "There is no NAXIS keyword in the FITS header for " + "mask (%s)!\n", name); + } + if (nAxis != 2 && nAxis != 3) { + psLogMsg(__func__, PS_LOG_WARN, "Image is not 2- or 3-dimensional --- reading into " + "a single image anyway.\n"); + } + + int numPlanes = 1; // Number of planes + if (nAxis == 3) { + numPlanes = psMetadataLookupS32(&mdStatus, header, "NAXIS3"); + if (!mdStatus) { + psError(PS_ERR_IO, false, "Unable to read NAXIS3 for 3-dimensional image!\n"); + // Try to proceed by taking only the first plane + numPlanes = 1; + } + if (numPlanes != 1 && numPlanes != cell->readouts->n) { + psError(PS_ERR_IO, false, "Number of masks (%d) does not match number of " + "readouts (%d)\n", numPlanes, cell->readouts->n); + // Try to proceed by taking only the first plane + numPlanes = 1; + } + } + + hdu->masks = psArrayAlloc(hdu->images->n); + + // Read each plane into the array + psArray *readouts = cell->readouts; // The array of readouts + for (int i = 0; i < hdu->masks->n; i++) { + psImage *mask = NULL; // The mask to be added + if (i < numPlanes) { + // Read the mask from the file + psTrace(__func__, 9, "Reading plane %d\n", i); + psRegion region = {0, 0, 0, 0}; + mask = psFitsReadImage(NULL, maskSource, region, i); + } else { + // One mask in the file is provided for all planes in the original image + psTrace(__func__, 9, "Copying plane 0 into plane %d\n", i); + psImage *original = hdu->masks->data[0]; + mask = psImageCopy(NULL, original, original->type.type); + } + hdu->masks->data[0] = mask; + pmReadout *readout = readouts->data[i]; + readout->mask = mask; + // Check the dimensions + // XXX: Perhaps this check should be against the CELL.TRIMSEC, not the image size? + if (mask->numCols < readout->image->numCols || + mask->numRows < readout->image->numRows) { + psError(PS_ERR_IO, false, "Mask size (%dx%d) not compatible with image (%dx%d)\n", + mask->numCols, mask->numRows, readout->image->numCols, + readout->image->numRows); + return false; + } + } // Iterating over readouts + psFree(maskSource); + } // Valid cells + } // Iterating over cells + } // Valid chips + } // Iterating over chips + + return true; +} + + +// Read a mask into the FPA +// This is just a copy of the above pmFPAReadMask, replacing "mask" with "weight" throughout. +bool pmFPAReadWeight(pmFPA *fpa, // FPA to read into + psFits *source // Source FITS file (for the original data) + ) +{ + const psMetadata *camera = fpa->camera; // Camera configuration for FPA + bool mdok = false; // Status of MD lookup + + // Get the required information from the camera configuration + psMetadata *supps = psMetadataLookupMD(&mdok, camera, "SUPPLEMENTARY"); // Rules for supplementary data + if (! mdok || ! supps) { + psError(PS_ERR_IO, false, "Unable to find SUPPLEMENTARY in camera configuration!\n"); + return false; + } + psString sourceType = psMetadataLookupStr(&mdok, supps, "WEIGHT.SOURCE"); // Type of source: EXT | FILE + if (! mdok || strlen(sourceType) <= 0) { + psError(PS_ERR_IO, false, "Unable to find WEIGHT.SOURCE in SUPPLEMENTARY section of camera " + "configuration!\n"); + return false; + } + psString name = psMetadataLookupStr(&mdok, supps, "WEIGHT.NAME"); // Name of weight + if (! mdok || strlen(sourceType) <= 0) { + psError(PS_ERR_IO, false, "Unable to find WEIGHT.NAME in SUPPLEMENTARY section of camera " + "configuration!\n"); + return false; + } + + // Go through the FPA to each cell/readout to get the weight + p_pmHDU *hdu = fpa->hdu; // The HDU into which we will read the weight + psArray *chips = fpa->chips; // Array of chips + for (int chipNum = 0; chipNum < chips->n; chipNum++) { + pmChip *chip = chips->data[chipNum]; // The current chip of interest + if (chip->process && !chip->exists) { + if (chip->hdu) { + hdu = chip->hdu; + } + psArray *cells = chip->cells; // Array of cells + for (int cellNum = 0; cellNum < cells->n; cellNum++) { + pmCell *cell = cells->data[cellNum]; // The current cell of interest + if (cell->process && !cell->exists) { + if (cell->hdu) { + hdu = cell->hdu; + } + + // Now, need to find out where to get the pixels + psFits *weightSource = psMemIncrRefCounter(source); // Source of weight image + if (strcasecmp(sourceType, "FILE") == 0) { + // Source is a file (with optional extension, e.g., "myWeightFile.fits:thisExt" + psString extname = NULL; // Extension name + psString filename = p_pmFPATranslateFileExt(&extname, name, cell); // The filename + + psFree(weightSource); + weightSource = psFitsOpen(filename, "r"); + if (extname) { + if (! psFitsMoveExtName(weightSource, extname)) { + psLogMsg(__func__, PS_LOG_WARN, "Unable to find extension %s to read " + "weight.\n", extname); + return false; + } + } + psFree(filename); + psFree(extname); + } else if (strncasecmp(sourceType, "EXT", 3) == 0) { + // Source is an extension in the original file + psString extname = p_pmFPATranslateName(name, cell); + psFitsMoveExtName(weightSource, extname); + } + + // We've arrived where the pixels are. Now we need to read them in. + psMetadata *header = psFitsReadHeader(NULL, weightSource); // The header + bool mdStatus = false; + int nAxis = psMetadataLookupS32(&mdStatus, header, "NAXIS"); + if (!mdStatus) { + psLogMsg(__func__, PS_LOG_WARN, "There is no NAXIS keyword in the FITS header for " + "weight (%s)!\n", name); + } + if (nAxis != 2 && nAxis != 3) { + psLogMsg(__func__, PS_LOG_WARN, "Image is not 2- or 3-dimensional --- reading into " + "a single image anyway.\n"); + } + + int numPlanes = 1; // Number of planes + if (nAxis == 3) { + numPlanes = psMetadataLookupS32(&mdStatus, header, "NAXIS3"); + if (!mdStatus) { + psError(PS_ERR_IO, false, "Unable to read NAXIS3 for 3-dimensional image!\n"); + // Try to proceed by taking only the first plane + numPlanes = 1; + } + if (numPlanes != 1 && numPlanes != cell->readouts->n) { + psError(PS_ERR_IO, false, "Number of weights (%d) does not match number of " + "readouts (%d)\n", numPlanes, cell->readouts->n); + // Try to proceed by taking only the first plane + numPlanes = 1; + } + } + + hdu->weights = psArrayAlloc(hdu->images->n); + + // Read each plane into the array + psArray *readouts = cell->readouts; // The array of readouts + for (int i = 0; i < hdu->weights->n; i++) { + psImage *weight = NULL; // The weight to be added + if (i < numPlanes) { + // Read the weight from the file + psTrace(__func__, 9, "Reading plane %d\n", i); + psRegion region = {0, 0, 0, 0}; + weight = psFitsReadImage(NULL, weightSource, region, i); + } else { + // One weight in the file is provided for all planes in the original image + psTrace(__func__, 9, "Copying plane 0 into plane %d\n", i); + psImage *original = hdu->weights->data[0]; + weight = psImageCopy(NULL, original, original->type.type); + } + hdu->weights->data[0] = weight; + pmReadout *readout = readouts->data[i]; + readout->weight = weight; + // Check the dimensions + // XXX: Perhaps this check should be against the CELL.TRIMSEC, not the image size? + if (weight->numCols < readout->image->numCols || + weight->numRows < readout->image->numRows) { + psError(PS_ERR_IO, false, "Weight size (%dx%d) not compatible with image " + "(%dx%d)\n", weight->numCols, weight->numRows, readout->image->numCols, + readout->image->numRows); + return false; + } + } // Iterating over readouts + psFree(weightSource); + } // Valid cells + } // Iterating over cells + } // Valid chips + } // Iterating over chips + + return true; +} Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/astrom/pmFPARead.h =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/astrom/pmFPARead.h (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/astrom/pmFPARead.h (revision 21664) @@ -0,0 +1,31 @@ +#ifndef PM_FPA_READ_H +#define PM_FPA_READ_H + +#include "pslib.h" +#include "pmFPA.h" + +bool pmFPARead(pmFPA *fpa, // FPA to read into + psFits *fits, // FITS file from which to read + psMetadata *phu, // Primary header + psDB *db // Database handle, for concept ingest + ); + +psString p_pmFPATranslateName(const psString name, // The name to translate + const pmCell *cell // The cell for which to translate + ); + +psString p_pmFPATranslateFileExt(psString *extName, // Extension name, to be returned + const psString filenameExt, // The string to parse into filename and ext + const pmCell *cell // The cell + ); + +bool pmFPAReadMask(pmFPA *fpa, // FPA to read into + psFits *source // Source FITS file (for the original data) + ); + +bool pmFPAReadWeight(pmFPA *fpa, // FPA to read into + psFits *source // Source FITS file (for the original data) + ); + + +#endif Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/astrom/pmFPAWrite.c =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/astrom/pmFPAWrite.c (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/astrom/pmFPAWrite.c (revision 21664) @@ -0,0 +1,259 @@ +#include +#include +#include "pslib.h" + +#include "pmFPA.h" +#include "pmFPARead.h" +#include "pmConcepts.h" + +static bool writeHDU(psFits *fits, // FITS file to which to write + p_pmHDU *hdu // Pixel data to write + ) +{ + bool status = true; // Status of write, to return + for (int i = 0; i < hdu->images->n; i++) { + status &= psFitsWriteImage(fits, hdu->header, hdu->images->data[i], i); + // XXX: Insert here the writing on mask and weight images + } + + return status; +} + + +bool pmFPAWrite(psFits *fits, // FITS file to which to write + pmFPA *fpa, // FPA to write + psDB *db // Database to update + ) +{ + bool status = true; // Status of writing, to return + + psTrace(__func__, 1, "Writing FPA...\n"); + + psTrace(__func__, 7, "Outgesting FPA concepts...\n"); + pmConceptsWriteFPA(fpa, db); + + // Write the primary header + if (fpa->phu) { + status &= psFitsMoveExtNum(fits, 0, false); + status &= psFitsWriteHeader(fpa->phu, fits); + } + + psArray *chips = fpa->chips; // Array of component chips + for (int i = 0; i < chips->n; i++) { + pmChip *chip = chips->data[i]; // The component chip + if (chip && chip->exists && chip->process) { + psTrace(__func__, 1, "Writing out chip %d...\n", i); + + pmConceptsWriteChip(chip, db); + + psArray *cells = chip->cells; // Array of component cells + for (int j = 0; j < cells->n; j++) { + pmCell *cell = cells->data[j]; // The component cell + if (cell && cell->exists && cell->process) { + psTrace(__func__, 2, "Writing out cell, %d...\n", j); + + pmConceptsWriteCell(cell, db); + + if (cell->hdu && strlen(cell->hdu->extname) > 0) { + status &= writeHDU(fits, cell->hdu); + } + } + } + + if (chip->hdu && strlen(chip->hdu->extname) > 0) { + status &= writeHDU(fits, chip->hdu); + } + } + + } + + if (fpa->hdu && strlen(fpa->hdu->extname) > 0) { + status &= writeHDU(fits, fpa->hdu); + } + + psTrace(__func__, 1, "Done writing FPA...\n"); + + return status; +} + + +bool pmFPAWriteMask(pmFPA *fpa, // FPA containing mask to write + psFits *fits // FITS file for image + ) +{ + const psMetadata *camera = fpa->camera; // Camera configuration for FPA + bool mdok = false; // Status of MD lookup + + // Get the required information from the camera configuration + psMetadata *supps = psMetadataLookupMD(&mdok, camera, "SUPPLEMENTARY"); // Rules for supplementary data + if (! mdok || ! supps) { + psError(PS_ERR_IO, false, "Unable to find SUPPLEMENTARY in camera configuration!\n"); + return false; + } + psString sourceType = psMetadataLookupStr(&mdok, supps, "MASK.SOURCE"); // Type of source: EXT | FILE + if (! mdok || strlen(sourceType) <= 0) { + psError(PS_ERR_IO, false, "Unable to find MASK.SOURCE in SUPPLEMENTARY section of camera " + "configuration!\n"); + return false; + } + psString name = psMetadataLookupStr(&mdok, supps, "MASK.NAME"); // Name of mask + if (! mdok || strlen(sourceType) <= 0) { + psError(PS_ERR_IO, false, "Unable to find MASK.NAME in SUPPLEMENTARY section of camera " + "configuration!\n"); + return false; + } + + // Go through the FPA to each cell/readout to get the mask + p_pmHDU *hdu = fpa->hdu; // The HDU into which we will read the mask + psArray *chips = fpa->chips; // Array of chips + for (int chipNum = 0; chipNum < chips->n; chipNum++) { + pmChip *chip = chips->data[chipNum]; // The current chip of interest + if (chip->exists && chip->process) { + if (chip->hdu) { + hdu = chip->hdu; + } + psArray *cells = chip->cells; // Array of cells + for (int cellNum = 0; cellNum < cells->n; cellNum++) { + pmCell *cell = cells->data[cellNum]; // The current cell of interest + if (cell->exists && cell->process) { + if (cell->hdu) { + hdu = cell->hdu; + } + + // Now, need to find out where to write the pixels + psFits *maskDest = psMemIncrRefCounter(fits); // Destination of mask image + psMetadata *header = psMetadataAlloc(); // A dummy header, containing the extension name + if (strcasecmp(sourceType, "FILE") == 0) { + // Source is a file (with optional extension, e.g., "myMaskFile.fits:thisExt" + psString extname = NULL; // Extension name + psString filename = p_pmFPATranslateFileExt(&extname, name, cell); // The filename + psFree(maskDest); + maskDest = psFitsOpen(filename, "rw"); + if (extname) { + psMetadataAddStr(header, PS_LIST_TAIL, "EXTNAME", 0, "Extension name", extname); + } + psFree(filename); + psFree(extname); + } else if (strncasecmp(sourceType, "EXT", 3) == 0) { + // Source is an extension in the original file + psString extname = p_pmFPATranslateName(name, cell); + psMetadataAddStr(header, PS_LIST_TAIL, "EXTNAME", 0, "Extension name", extname); + psFree(extname); + } + + // We've arrived where the pixels are. Now we need to write them out. + psArray *readouts = cell->readouts; // The array of readouts + for (int readNum = 0; readNum < readouts->n; readNum++) { + pmReadout *readout = readouts->data[readNum]; // The readout of interest + if (! readout->mask) { + psLogMsg(__func__, PS_LOG_WARN, "No mask to write out in %d,%d,%d\n", + chipNum, cellNum, readNum); + } else { + // XXX: Need to add the extname to the existing header + if (! psFitsWriteImage(maskDest, header, readout->mask, readNum)) { + psError(PS_ERR_IO, false, "Unable to write mask plane %d in extension %s\n", + readNum, hdu->extname); + return false; + } + } + } // Iterating over readouts + psFree(header); + psFree(maskDest); + } // Valid cells + } // Iterating over cells + } // Valid chips + } // Iterating over chips + + return true; +} + + +bool pmFPAWriteWeight(pmFPA *fpa, // FPA containing mask to write + psFits *fits // FITS file for image + ) +{ + const psMetadata *camera = fpa->camera; // Camera configuration for FPA + bool mdok = false; // Status of MD lookup + + // Get the required information from the camera configuration + psMetadata *supps = psMetadataLookupMD(&mdok, camera, "SUPPLEMENTARY"); // Rules for supplementary data + if (! mdok || ! supps) { + psError(PS_ERR_IO, false, "Unable to find SUPPLEMENTARY in camera configuration!\n"); + return false; + } + psString sourceType = psMetadataLookupStr(&mdok, supps, "WEIGHT.SOURCE"); // Type of source: EXT | FILE + if (! mdok || strlen(sourceType) <= 0) { + psError(PS_ERR_IO, false, "Unable to find WEIGHT.SOURCE in SUPPLEMENTARY section of camera " + "configuration!\n"); + return false; + } + psString name = psMetadataLookupStr(&mdok, supps, "WEIGHT.NAME"); // Name of weight + if (! mdok || strlen(sourceType) <= 0) { + psError(PS_ERR_IO, false, "Unable to find WEIGHT.NAME in SUPPLEMENTARY section of camera " + "configuration!\n"); + return false; + } + + // Go through the FPA to each cell/readout to get the weight + p_pmHDU *hdu = fpa->hdu; // The HDU into which we will read the weight + psArray *chips = fpa->chips; // Array of chips + for (int chipNum = 0; chipNum < chips->n; chipNum++) { + pmChip *chip = chips->data[chipNum]; // The current chip of interest + if (chip->exists && chip->process) { + if (chip->hdu) { + hdu = chip->hdu; + } + psArray *cells = chip->cells; // Array of cells + for (int cellNum = 0; cellNum < cells->n; cellNum++) { + pmCell *cell = cells->data[cellNum]; // The current cell of interest + if (cell->exists && cell->process) { + if (cell->hdu) { + hdu = cell->hdu; + } + + // Now, need to find out where to write the pixels + psFits *weightDest = psMemIncrRefCounter(fits); // Destination of weight image + psMetadata *header = psMetadataAlloc(); // A dummy header, containing the extension name + if (strcasecmp(sourceType, "FILE") == 0) { + // Source is a file (with optional extension, e.g., "myWeightFile.fits:thisExt" + psString extname = NULL; // Extension name + psString filename = p_pmFPATranslateFileExt(&extname, name, cell); // The filename + + psFree(weightDest); + weightDest = psFitsOpen(filename, "rw"); + if (extname) { + psMetadataAddStr(header, PS_LIST_TAIL, "EXTNAME", 0, "Extension name", extname); + } + psFree(filename); + psFree(extname); + } else if (strncasecmp(sourceType, "EXT", 3) == 0) { + // Source is an extension in the original file + psString extname = p_pmFPATranslateName(name, cell); + psMetadataAddStr(header, PS_LIST_TAIL, "EXTNAME", 0, "Extension name", extname); + psFree(extname); + } + + // We've arrived where the pixels are. Now we need to write them out. + psArray *readouts = cell->readouts; // The array of readouts + for (int readNum = 0; readNum < readouts->n; readNum++) { + pmReadout *readout = readouts->data[readNum]; // The readout of interest + if (! readout->weight) { + psLogMsg(__func__, PS_LOG_WARN, "No weight image to write out in %d,%d,%d\n", + chipNum, cellNum, readNum); + } else { + if (! psFitsWriteImage(weightDest, header, readout->weight, readNum)) { + psError(PS_ERR_IO, false, "Unable to write weight plane %d in extension %s\n", + readNum, hdu->extname); + return false; + } + } + } // Iterating over readouts + psFree(header); + psFree(weightDest); + } // Valid cells + } // Iterating over cells + } // Valid chips + } // Iterating over chips + + return true; +} Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/astrom/pmFPAWrite.h =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/astrom/pmFPAWrite.h (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/astrom/pmFPAWrite.h (revision 21664) @@ -0,0 +1,21 @@ +#ifndef PM_FPA_WRITE_H +#define PM_FPA_WRITE_H + +#include "pslib.h" +#include "pmFPA.h" + +bool pmFPAWrite(psFits *fits, // FITS file to which to write + pmFPA *fpa, // FPA to write + psDB *db // Database to update + ); + +bool pmFPAWriteMask(pmFPA *fpa, // FPA containing mask to write + psFits *fits // FITS file for image + ); + +bool pmFPAWriteWeight(pmFPA *fpa, // FPA containing mask to write + psFits *fits // FITS file for image + ); + + +#endif Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/astrom/pmReadout.c =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/astrom/pmReadout.c (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/astrom/pmReadout.c (revision 21664) @@ -0,0 +1,26 @@ +#include +#include "pslib.h" + +#include "pmFPA.h" + +// Get the bias images for a readout, using the CELL.BIASSEC +psList *pmReadoutGetBias(pmReadout *readout // Readout for which to get the bias sections + ) +{ + pmCell *cell = readout->parent; // The parent cell + psList *sections = (psList*)psMetadataLookupPtr(NULL, cell->concepts, "CELL.BIASSEC"); // CELL.BIASSEC + + psImage *image = readout->image; // The image that contains both the biassec and the trimsec + + psList *images = psListAlloc(NULL); // List of images from bias sections + psListIterator *sectionsIter = psListIteratorAlloc(sections, PS_LIST_HEAD, true); // Iterator + psRegion *region = NULL; // Bias region from list + while ((region = psListGetAndIncrement(sectionsIter))) { + psImage *bias = psMemIncrRefCounter(psImageSubset(image, *region)); // Image from bias section + psListAdd(images, PS_LIST_TAIL, bias); + psFree(bias); + } + psFree(sectionsIter); + + return images; +} Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/astrom/pmReadout.h =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/astrom/pmReadout.h (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/astrom/pmReadout.h (revision 21664) @@ -0,0 +1,12 @@ +#ifndef PM_READOUT_H +#define PM_READOUT_H + +#include "pslib.h" +#include "pmFPA.h" + +// Get the bias sections for a specific readout +psList *pmReadoutGetBias(pmReadout *readout // Readout for which to get the bias sections + ); + + +#endif Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/astrom/psAdditionals.c =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/astrom/psAdditionals.c (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/astrom/psAdditionals.c (revision 21664) @@ -0,0 +1,169 @@ +#include +#include +#include "pslib.h" + +#include "psAdditionals.h" + + +psMetadata *pap_psMetadataCopy(psMetadata *out, + const psMetadata *in) +{ + PS_ASSERT_PTR_NON_NULL(in,NULL); + if (out == NULL) { + out = psMetadataAlloc(); + } + psMetadataItem *inItem = NULL; + psMetadataIterator *iter = psMetadataIteratorAlloc(*(psMetadata**)&in, PS_LIST_HEAD, NULL); + unsigned long numPointers = 0; // Number of pointers we were forced to copy + while ((inItem = psMetadataGetAndIncrement(iter))) { + // Need to look for MULTI, which won't be picked up using the iterator. + psMetadataItem *multiCheckItem = psMetadataLookup(in, inItem->name); + unsigned int flag = PS_META_REPLACE; // Flag to indicate MULTI; otherwise, replace + if (multiCheckItem->type == PS_DATA_METADATA_MULTI) { + psTrace(__func__, 10, "MULTI: %s (%s)\n", inItem->name, inItem->comment); + flag = PS_DATA_METADATA_MULTI; + } + + psTrace(__func__, 5, "Copying %s (%s)...\n", inItem->name, inItem->comment); + + #define PS_METADATA_COPY_CASE(NAME,TYPE) \ + case PS_TYPE_##NAME: \ + if (! psMetadataAdd(out, PS_LIST_TAIL, inItem->name, PS_TYPE_##NAME | flag, inItem->comment, \ + inItem->data.TYPE)) { \ + psErrorStackPrint(stderr, "Error copying %s (%s) in the metadata\n", inItem->name, \ + inItem->comment); \ + } \ + break; + + switch (inItem->type) { + // Numerical types + PS_METADATA_COPY_CASE(BOOL,B); + PS_METADATA_COPY_CASE(S8,S8); + PS_METADATA_COPY_CASE(S16,S16); + PS_METADATA_COPY_CASE(S32,S32); + PS_METADATA_COPY_CASE(U8,U8); + PS_METADATA_COPY_CASE(U16,U16); + PS_METADATA_COPY_CASE(U32,U32); + PS_METADATA_COPY_CASE(F32,F32); + PS_METADATA_COPY_CASE(F64,F64); + + // String: relying on the fact that this will copy the string, not point at it. + case PS_DATA_STRING: + psMetadataAdd(out, PS_LIST_TAIL, inItem->name, PS_DATA_STRING | flag, inItem->comment, + inItem->data.V); + break; + + // Metadata: copy the next level and stuff that in too + case PS_DATA_METADATA: { + psMetadata *metadata = pap_psMetadataCopy(NULL, inItem->data.md); + psMetadataAdd(out, PS_LIST_TAIL, inItem->name, PS_DATA_METADATA | flag, inItem->comment, + metadata); + break; + } + // Other kinds of pointers + default: + numPointers++; + psTrace(__func__, 10, "Copying a pointer in the metadata: %x\n", inItem->type); + psMetadataAdd(out, PS_LIST_TAIL, inItem->name, inItem->type | flag, inItem->comment, + inItem->data.V); + break; + } + } + psFree(iter); + + if (numPointers > 0) { + psLogMsg(__func__, PS_LOG_WARN, "Forced to copy %d pointers when copying metadata. Updating the " + "copied psMetadata will affect the original!\n", numPointers); + } + + return out; +} + + +void psMetadataPrint(psMetadata *md, int level) +{ + psMetadataIterator *iter = psMetadataIteratorAlloc(md, PS_LIST_HEAD, NULL); // Iterator + psMetadataItem *item = NULL; // Item from metadata + while ((item = psMetadataGetAndIncrement(iter))) { + // Indent... + for (int i = 0; i < level; i++) { + printf(" "); + } + printf("%s", item->name); + if (item->comment && strlen(item->comment) > 0) { + printf(" (%s)", item->comment); + } + printf(": "); + switch (item->type) { + case PS_DATA_STRING: + printf("%s", (char*)item->data.V); + break; + case PS_DATA_BOOL: + if (item->data.B) { + printf("True"); + } else { + printf("False"); + } + break; + case PS_DATA_S32: + printf("%d", item->data.S32); + break; + case PS_DATA_F32: + printf("%f", item->data.F32); + break; + case PS_DATA_F64: + printf("%f", item->data.F64); + break; + case PS_DATA_METADATA: + printf("\n"); + psMetadataPrint(item->data.V, level + 1); + break; + default: + printf("\n"); + psError(PS_ERR_IO, false, "Non-printable metadata type: %x\n", item->type); + } + printf("\n"); + } + psFree(iter); + + return; +} + +// XXX: This should probably be implemented using strpbrk +psList *psStringSplit(const char *string, + const char *splitters) +{ + psList *values = psListAlloc(NULL); // The list of values to return + unsigned int length = strlen(string); // The length of the string + unsigned int numSplitters = strlen(splitters); // Number of characters that might split + unsigned int start = 0; // The position of the start of a word + for (int i = 1; i < length; i++) { + bool split = false; // Is this character a splitter? + for (int j = 0; j < numSplitters && ! split; j++) { + if (string[i] == splitters[j]) { + split = true; + } + } + if (split) { + if (i == start) { + // Some idiot put in two spaces, or two commas or something + start++; + } else { + // We're at the end of the word + psString word = psStringNCopy(&string[start], i - start); + (void)psListAdd(values, PS_LIST_TAIL, word); + start = i + 1; + psFree(word); + } + } + } + if (start < length) { + // Copy the last word + psString word = psStringNCopy(&string[start], length - start); + (void)psListAdd(values, PS_LIST_TAIL, word); + psFree(word); + } + + return values; +} + Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/astrom/psAdditionals.h =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/astrom/psAdditionals.h (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/astrom/psAdditionals.h (revision 21664) @@ -0,0 +1,25 @@ +// Functions that should go into psLib. + + +#ifndef PS_ADDITIONALS_H +#define PS_ADDITIONALS_H + +#include "pslib.h" + +// Deep copy of metadata +// Corrected version of MHPCC code in psLib at the moment +psMetadata *pap_psMetadataCopy(psMetadata *out, // Target, to which the copy is made + const psMetadata *in // Source, from which the copy is made + ); + +// Print out the metadata +void psMetadataPrint(psMetadata *md, // Metadata to print + int level // Indent level + ); + +// Split string on given characters +psList *psStringSplit(const char *string, // String to split + const char *splitters // Characters on which to split + ); + +#endif Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/camera/.cvsignore =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/camera/.cvsignore (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/camera/.cvsignore (revision 21664) @@ -0,0 +1,6 @@ +.deps +.libs +Makefile +Makefile.in +*.la +*.lo Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/camera/Makefile.am =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/camera/Makefile.am (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/camera/Makefile.am (revision 21664) @@ -0,0 +1,22 @@ +noinst_LTLIBRARIES = libpsmodulecamera.la + +libpsmodulecamera_la_CPPFLAGS = $(SRCINC) $(PSMODULE_CFLAGS) +libpsmodulecamera_la_LDFLAGS = -release $(PACKAGE_VERSION) +libpsmodulecamera_la_SOURCES = \ + pmChipMosaic.c \ + pmFPAConceptsGet.c \ + pmFPAConceptsSet.c \ + pmFPAConstruct.c \ + pmFPAMorph.c \ + pmFPARead.c \ + pmFPAWrite.c + +psmoduleincludedir = $(includedir) +psmoduleinclude_HEADERS = \ + pmChipMosaic.h \ + pmFPAConceptsGet.h \ + pmFPAConceptsSet.h \ + pmFPAConstruct.h \ + pmFPAMorph.h \ + pmFPARead.h \ + pmFPAWrite.h Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/config/.cvsignore =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/config/.cvsignore (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/config/.cvsignore (revision 21664) @@ -0,0 +1,6 @@ +.deps +.libs +Makefile +Makefile.in +*.la +*.lo Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/config/Makefile.am =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/config/Makefile.am (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/config/Makefile.am (revision 21664) @@ -0,0 +1,10 @@ +noinst_LTLIBRARIES = libpsmoduleconfig.la + +libpsmoduleconfig_la_CPPFLAGS = $(SRCINC) $(PSMODULE_CFLAGS) +libpsmoduleconfig_la_LDFLAGS = -release $(PACKAGE_VERSION) +libpsmoduleconfig_la_SOURCES = \ + pmConfig.c + +psmoduleincludedir = $(includedir) +psmoduleinclude_HEADERS = \ + pmConfig.h Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/config/pmConfig.c =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/config/pmConfig.c (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/config/pmConfig.c (revision 21664) @@ -0,0 +1,453 @@ +/** @file pmConfig.h + * + * @author PAP, IfA + * + * @version $Revision: 1.5.4.2 $ $Name: not supported by cvs2svn $ + * @date $Date: 2006-01-20 03:54:44 $ + * + * Copyright 2004 Maui High Performance Computing Center, University of Hawaii + * + */ +#include +#include +#include "pslib.h" +#include "pmConfig.h" + +#define PS_SITE "PS_SITE" // Name of the environment variable containing the site config file +#define PS_DEFAULT_SITE "ipprc.config" // Default site config file + +/** readConfig + * + * This function attempts to open the file specified in the parameter list + * parse it into metadata, then return it as a psMetaData table. + * + */ +static bool readConfig( + psMetadata **config, // Config to output + const char *name, // Name of file + const char *description) // Description of file +{ + unsigned int numBadLines = 0; + + psLogMsg(__func__, PS_LOG_INFO, "Loading %s configuration from file %s\n", + description, name); + *config = psMetadataConfigParse(NULL, &numBadLines, name, true); + if (numBadLines > 0) { + psLogMsg(__func__, PS_LOG_WARN, "%d bad lines in %s configuration file (%s)\n", + description, name); + } + if (!*config) { + psError(PS_ERR_IO, false, "Unable to read %s configuration from %s\n", + description, name); + return false; + } + + return true; +} + + +/****************************************************************************** +pmConfigRead(**site, **camera, **recipe, *argc, **argv, char *recipeName) + +XXX: The log/trace command line options (as processed by psArgumentVerbosity) +must take precedence override the values set here. This must be, somehow, +coded. + +XXX: Must load camera and recipe configuration if specified in the command line. + *****************************************************************************/ +bool pmConfigRead( + psMetadata **site, + psMetadata **camera, + psMetadata **recipe, + int *argc, + char **argv, + const char *recipeName) +{ + PS_ASSERT_PTR_NON_NULL(site, false); + // PS_ASSERT_PTR_NON_NULL(*site, false); + PS_ASSERT_PTR_NON_NULL(camera, false); + // PS_ASSERT_PTR_NON_NULL(*camera, false); + PS_ASSERT_PTR_NON_NULL(recipe, false); + // PS_ASSERT_PTR_NON_NULL(*recipe, false); + PS_ASSERT_INT_POSITIVE(*argc, false); + PS_ASSERT_PTR_NON_NULL(argv, false); + + // + // The following section of code attempts to determine which file is + // the configuration file. At the end of this code block, the siteName + // variable will contain the name of the configuration file. + // + char *siteName = NULL; + // + // First, try command line + // + psS32 argNum = psArgumentGet(*argc, argv, "-site"); + if (argNum != 0) { + // + // We remove the "-site" argument from argv. Then + // we look for the next argument, which should be the filename, and + // remove it as well. + // + psArgumentRemove(argNum, argc, argv); + if (argNum >= *argc) { + psLogMsg(__func__, PS_LOG_WARN, + "-site command-line switch provided without the required filename --- ignored.\n"); + } else { + siteName = argv[argNum]; + psArgumentRemove(argNum, argc, argv); + } + } + // + // Next, try environment variable + // + if (!siteName) { + siteName = getenv(PS_SITE); + } + + // + // Last chance is ~/.ipprc + // + bool cleanupSiteName = false; // Do I have to psFree siteName? + if (!siteName) { + siteName = psStringCopy(PS_DEFAULT_SITE); + cleanupSiteName = true; + } + + // + // We have the connfiguration filename; now we read and parse the config + // file and store in psMetadata struct site. + // + + if (!readConfig(site, siteName, "site")) { + return false; + } + if (cleanupSiteName) { + psFree(siteName); + } + + + // + // Next, we do a similar thing for the recipe configuration file. The + // file is read and parsed into psMetadata struct "recipe". + // + // + argNum = psArgumentGet(*argc, argv, "-recipe"); + if (argNum > 0) { + psArgumentRemove(argNum, argc, argv); + if (argNum >= *argc) { + psLogMsg(__func__, PS_LOG_WARN, + "-recipe command-line switch provided without the required filename --- ignored.\n"); + } else { + psArgumentRemove(argNum, argc, argv); + readConfig(recipe, argv[argNum], "recipe"); + } + } + // Or, load the recipe from the camera file, if appropriate + if (! *recipe && *camera && recipeName) { + *recipe = pmConfigRecipeFromCamera(*camera, recipeName); + } + + + // + // Next, we do a similar thing for the camera configuration file. The + // file is read and parsed into psMetadata struct "camera". + // + argNum = psArgumentGet(*argc, argv, "-camera"); + if (argNum > 0) { + psArgumentRemove(argNum, argc, argv); + if (argNum >= *argc) { + psLogMsg(__func__, PS_LOG_WARN, + "-camera command-line switch provided without the required filename --- ignored.\n"); + } else { + psArgumentRemove(argNum, argc, argv); + readConfig(camera, argv[argNum], "camera"); + } + } else { + // XXX: Not sure is this is correct. + *camera = NULL; + } + + + // + // We now have the config, camera, and recipe files parsed and stored in + // metadata. Now, we can look into the site configuration and do + // the required stuff. + // + bool mdok = true; // Status of MD lookup result + + // + // If TIME is specified in the configuration file, then we must initialize + // with a call to psTimeInitialize. + // + psString timeName = psMetadataLookupStr(&mdok, *site, "TIME"); + if (mdok && timeName) { + psTrace(__func__, 7, "Initialising psTime with file %s\n", timeName); + // XXX: PAP had a call to psLibInit is PRODUCTION not set. Why? + psTimeInitialize(timeName); + } + + + // + // If LOGLEVEL is specified in the configuration file, then we must initialize + // with a call to psLogSetLevel(). + // + int logLevel = psMetadataLookupS32(&mdok, *site, "LOGLEVEL"); + if (mdok && logLevel >= 0) { + psTrace(__func__, 7, "Setting log level to %d\n", logLevel); + psLogSetLevel(logLevel); + } + + + // + // If LOGFORMAT is specified in the configuration file, then we must initialize + // with a call to psLogSetFormat(). + // + psString logFormat = psMetadataLookupStr(&mdok, *site, "LOGFORMAT"); + if (mdok && logFormat) { + psTrace(__func__, 7, "Setting log format to %s\n", logFormat); + psLogSetFormat(logFormat); + } + + + // + // If LOGDEST is specified in the configuration file, then we must initialize + // with a call to psLogSetDestination(). + // XXX: This is not spec'ed in the SDRS. + // + psString logDest = psMetadataLookupStr(&mdok, *site, "LOGDEST"); + if (mdok && logDest) { + // XXX: Only stdout is provided for now; this section should be + // expanded in the future to do files, and perhaps even sockets. + if (strcasecmp(logDest, "STDOUT") != 0) { + psLogMsg(__func__, PS_LOG_WARN, "Only STDOUT is currently supported as a log destination.\n"); + } + psTrace(__func__, 7, "Setting log destination to STDOUT.\n"); + // XXX: Use something other than "1" + psLogSetDestination(1); + } + + + // + // If TRACE is specified in the configuration file, then we must initialize + // with a call to psTraceSetLevel(). + // XXX: This is not spec'ed in the SDRS. + // + psMetadata *trace = psMetadataLookupMD(&mdok, *site, "TRACE"); + if (mdok && trace) { + psMetadataIterator *traceIter = psMetadataIteratorAlloc(trace, PS_LIST_HEAD, NULL); // Iterator + psMetadataItem *traceItem = NULL; // Item from MD iteration + while ((traceItem = psMetadataGetAndIncrement(traceIter))) { + if (traceItem->type != PS_DATA_S32) { + psLogMsg(__func__, PS_LOG_WARN, "The level for trace component %s is not of type S32 (%x)\n", + traceItem->name, traceItem->type); + continue; + } + psTrace(__func__, 7, "Setting trace level for %s to %d\n", traceItem->name, traceItem->data.S32); + psTraceSetLevel(traceItem->name, traceItem->data.S32); + } + psFree(traceIter); + } + + // + // Allow command line options to override defaults for logging. + // XXX: Is it appropriate to use the ArgVerbosity function for this? + // A: it removes the options from the command line. + // B: will the pmConfigRead function always be called on initialization. + // + psS32 saveLogLevel = psLogGetLevel(); + psArgumentVerbosity(argc, argv); + // XXX: substitute the string for the default log level for "2". + if (2 == psLogGetLevel()) { + psLogSetLevel(saveLogLevel); + } + return(true); +} + + +// XXX EAM : was trying headerItem when it was NULL +// XXX EAM : should just free & return on first failure +bool pmConfigValidateCamera( + const psMetadata *camera, + const psMetadata *header) +{ + // Read the rule for that camera + bool mdStatus = true; + psMetadata *rule = psMetadataLookupMD(&mdStatus, camera, "RULE"); + if (! mdStatus || ! rule) { + psLogMsg(__func__, PS_LOG_WARN, "Unable to read rule for camera.\n"); + return false; + } + + // Apply the rules + psMetadataIterator *ruleIter = psMetadataIteratorAlloc(rule, PS_LIST_HEAD, NULL); // Rule iterator + psMetadataItem *ruleItem = NULL; // Item from the metadata + bool match = true; // Does it match? + while ((ruleItem = psMetadataGetAndIncrement(ruleIter)) && match) { + // Check for the existence of the rule + psMetadataItem *headerItem = psMetadataLookup((psMetadata*)header, ruleItem->name); + if (! headerItem || headerItem->type != ruleItem->type) { + psFree(ruleIter); + return false; + } + + // Check to see if the rule works + switch (ruleItem->type) { + case PS_DATA_STRING: + psTrace(__func__, 8, "Matching %s: '%s' vs '%s'\n", ruleItem->name, + ruleItem->data.V, headerItem->data.V); + if (strncmp(ruleItem->data.V, headerItem->data.V, + strlen(ruleItem->data.V)) != 0) { + psFree(ruleIter); + return false; + } + break; + case PS_DATA_S32: + case PS_DATA_BOOL: + psTrace(__func__, 8, "Matching %s: %d vs %d\n", ruleItem->name, + ruleItem->data.S32, headerItem->data.S32); + if (ruleItem->data.S32 != headerItem->data.S32) { + psFree(ruleIter); + return false; + } + break; + case PS_DATA_F32: + psTrace(__func__, 8, "Matching %s: %f vs %f\n", ruleItem->name, + ruleItem->data.F32, headerItem->data.F32); + if (ruleItem->data.F32 != headerItem->data.F32) { + psFree(ruleIter); + return false; + } + break; + case PS_DATA_F64: + psTrace(__func__, 8, "Matching %s: %g vs %g\n", ruleItem->name, + ruleItem->data.F64, headerItem->data.F64); + if (ruleItem->data.F64 != headerItem->data.F64) { + psFree(ruleIter); + return false; + } + break; + default: + psLogMsg(__func__, PS_LOG_WARN, "Ignoring invalid type in metadata: %x\n", + ruleItem->type); + } + } // Iterating through the RULEs + + psFree(ruleIter); + return match; +} + + + +// Work out what camera we have, based on the FITS header and a set of +// rules specified in the IPP configuration; return the camera configuration +psMetadata *pmConfigCameraFromHeader( + const psMetadata *ipprc, // The IPP configuration + const psMetadata *header) // The FITS header +{ + bool mdStatus = false; // Metadata lookup status + psMetadata *cameras = psMetadataLookupMD(&mdStatus, ipprc, "CAMERAS"); + if (! mdStatus) { + psError(PS_ERR_IO, false, "Unable to find CAMERAS in the configuration.\n"); + return NULL; + } + psMetadata *winner = NULL; // The camera configuration whose rule first matches + // the supplied header + // Iterate over the cameras + psMetadataIterator *iterator = psMetadataIteratorAlloc(cameras, PS_LIST_HEAD, NULL); + psMetadataItem *cameraItem = NULL; // Item from the metadata + + while ((cameraItem = psMetadataGetAndIncrement(iterator))) { + // Open the camera information + psTrace(__func__, 3, "Inspecting camera %s (%s)\n", cameraItem->name, + cameraItem->comment); + psMetadata *camera = NULL; // The camera metadata + if (cameraItem->type == PS_DATA_METADATA) { + camera = psMemIncrRefCounter(cameraItem->data.md); + } else if (cameraItem->type == PS_DATA_STRING) { + psTrace(__func__, 5, "Reading camera configuration for %s...\n", cameraItem->name); + unsigned int badLines = 0; // Number of bad lines in reading camera configuration + camera = psMetadataConfigParse(NULL, &badLines, cameraItem->data.V, true); + if (badLines > 0) { + psLogMsg(__func__, PS_LOG_WARN, "%d bad lines encountered while reading camera" + "configuration %s\n", badLines, cameraItem->name); + } + } + + if (! camera) { + psLogMsg(__func__, PS_LOG_WARN, "Unable to interpret camera configuration for %s (%s)\n", + cameraItem->name, cameraItem->comment); + continue; + } + + if (pmConfigValidateCamera(camera, header)) { + if (! winner) { + // This is the first match + winner = psMemIncrRefCounter(camera); + psLogMsg(__func__, PS_LOG_INFO, "FITS header matches camera %s\n", + cameraItem->name); + } else { + // We have a duplicate match + psLogMsg(__func__, PS_LOG_WARN, "Additional camera found that matches the rules: %s\n", + cameraItem->name); + } + } // Done inspecting the camera + + psFree(camera); + + } // Done looking at all cameras + if (! winner) { + psError(PS_ERR_IO, true, "Unable to find an camera that matches input FITS header!\n"); + } + + psFree(iterator); + return winner; +} + +psMetadata *pmConfigRecipeFromCamera( + const psMetadata *camera, + const char *recipeName) +{ + PS_ASSERT_PTR_NON_NULL(camera, false); + PS_ASSERT_PTR_NON_NULL(recipeName, false); + + psMetadata *recipe = NULL; // Recipe to read + bool mdok = true; // Status of MD lookup + psMetadata *recipes = psMetadataLookupMD(&mdok, camera, "RECIPES"); // The list of recipes + if (! mdok || ! recipes) { + psLogMsg(__func__, PS_LOG_WARN, "RECIPES in the camera configuration file is not of type METADATA\n"); + } else { + psString recipeFileName = psMetadataLookupStr(&mdok, recipes, recipeName); + (void)readConfig(&recipe, recipeFileName, "recipe"); + } + + return recipe; +} + +/****************************************************************************** +pmConfigDB(*site) + +XXX: this should allow the option of having NO database server, if chosen by config +XXX: What should we use for the Database namespace in the call to psDBInit()? +This is currently NULL. + *****************************************************************************/ + +psDB *pmConfigDB( + psMetadata *site) +{ + PS_ASSERT_PTR_NON_NULL(site, NULL); + psBool mdStatus01 = false; + psBool mdStatus02 = false; + psBool mdStatus03 = false; + + // XXX leaky strings + psString dbServer = psMetadataLookupStr(&mdStatus01, site, "DBSERVER"); + psString dbUsername = psMetadataLookupStr(&mdStatus02, site, "DBUSER"); + psString dbPassword = psMetadataLookupStr(&mdStatus03, site, "DBPASSWORD"); + psString dbName = psMetadataLookupStr(&mdStatus01, site, "DBNAME"); + if (!(mdStatus01 & mdStatus02 & mdStatus03)) { + psLogMsg(__func__, PS_LOG_WARN, "Could not determine database server name, userID, and password from site metadata.\n"); + return(NULL); + } + + return(psDBInit(dbServer, dbUsername, dbPassword, dbName)); +} Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/config/pmConfig.h =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/config/pmConfig.h (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/config/pmConfig.h (revision 21664) @@ -0,0 +1,98 @@ +/** @file pmConfig.h + * + * @author PAP, IfA + * + * @version $Revision: 1.2 $ $Name: not supported by cvs2svn $ + * @date $Date: 2005-10-20 23:06:24 $ + * + * Copyright 2004 Maui High Performance Computing Center, University of Hawaii + * + */ +#ifndef PM_CONFIG_H +#define PM_CONFIG_H + +#include "pslib.h" + + + +/** pmConfigRead + * + * pmConfigRead shall load the site configuration (according to the above rule + * for determining the source). The camera configuration shall also be loaded if + * it is specified on the command line (argc, argv); otherwise it shall be set to + * NULL. The recipe shall also be loaded from the command line (if specified) or, + * if the camera configuration has been loaded, from the camera configuration and + * recipe specification therein (see below). In dealing with the command line + * parameters, the functions shall use the appropriate functions in psLib to + * retrieve and remove the relevant options from the argument list; this + * simplifies assignment of the mandatory arguments, since all the optional + * command line arguments are removed leaving only the mandatory arguments. The + * following psLib setups shall also be performed if they are specified in the + * site configuration: + * + */ +bool pmConfigRead( + psMetadata **site, + psMetadata **camera, + psMetadata **recipe, + int *argc, + char **argv, + const char *recipeName +); + + + +/** pmConfigValidateCamera + * + * This function, used by pmConfigCameraFromHeader, shall return true if the + * FITS header matches the rule contained in the camera configuration (see + * x2.2.2.3); otherwise it shall return false. + * + */ +bool pmConfigValidateCamera( + const psMetadata *camera, + const psMetadata *header +); + + + +/** pmConfigCameraFromHeader + * + * pmConfigCameraFromHeader shall load the camera configuration based on the + * contents of the FITS header, using the list of known cameras contained in the + * site configuration. If more than one camera matches the FITS header, a warning + * shall be generated and the first matching camera returned. + * + */ +psMetadata *pmConfigCameraFromHeader( + const psMetadata *site, + const psMetadata *header +); + + + +/** pmConfigRecipeFromCamera + * + * pmConfigRecipeFromCamera shall load the recipe configuration based on the + * recipeName and the list of known recipes contained in the camera + * configuration. + * + */ +psMetadata *pmConfigRecipeFromCamera( + const psMetadata *camera, + const char *recipeName +); + +/** pmConfigDB + * + * pmConfigDB shall use the site configuration data to open a database handle. + * This is fairly straightforward at the moment, but will change when we beef up + * security. (TBD) + * + */ +psDB *pmConfigDB( + psMetadata *site +); + + +#endif Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/detrend/.cvsignore =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/detrend/.cvsignore (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/detrend/.cvsignore (revision 21664) @@ -0,0 +1,6 @@ +.deps +.libs +Makefile +Makefile.in +*.la +*.lo Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/detrend/Makefile.am =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/detrend/Makefile.am (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/detrend/Makefile.am (revision 21664) @@ -0,0 +1,17 @@ +noinst_LTLIBRARIES = libpsmoduledetrend.la + +libpsmoduledetrend_la_CPPFLAGS = $(SRCINC) $(PSMODULE_CFLAGS) +libpsmoduledetrend_la_LDFLAGS = -release $(PACKAGE_VERSION) +libpsmoduledetrend_la_SOURCES = pmFlatField.c \ + pmMaskBadPixels.c \ + pmNonLinear.c + +psmoduleincludedir = $(includedir) +psmoduleinclude_HEADERS = \ + pmFlatField.h \ + pmFlatFieldErrors.h \ + pmMaskBadPixelsErrors.h \ + pmMaskBadPixels.h \ + pmNonLinear.h + +EXTRA_DIST = pmFlatFieldErrors.dat pmMaskBadPixelsErrors.dat Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/detrend/pmFlatField.c =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/detrend/pmFlatField.c (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/detrend/pmFlatField.c (revision 21664) @@ -0,0 +1,191 @@ +////////////////////////////////////////////////////////////////////////////////////////////////////////////// +// XXX WARNING: I have completely replaced this file with an OLD VERSION (that works) instead of the +// one that was being worked on. +////////////////////////////////////////////////////////////////////////////////////////////////////////////// + + +/** @file pmFlatField.c + * + * @brief Given an input image and a flat field image, pmFlatField shall divide the input image by the flat + * field image. + * + * The input image, in, and the flat field image, flat, need not be the same size, since the input image may + * already have been trimmed (following overscan subtraction), but the function shall use the offsets in the + * image (in->x0 and in->y0) to determine the appropriate offsets to obtain the correct pixel on the flat + * field. In the event that the flat image is too small (i.e., pixels on the input image refer to pixels + * outside the range of the flat image), the function shall generate an error. Pixels which are negative or + * zero in the flat shall be masked in the input image with the value PM_MASK_FLAT. Negative pixels in the + * flat may be set to zero so that they are treated identically to zeroes. Any pixels masked in the flat + * shall be masked with corresponding values in the output. The function shall not normalize the flat; this + * responsibility is left to the caller. This function is basically equivalent to a divide (with psImageOp), + * but with care for the region that is divided, checking for negative pixels, and copying of the mask from + * the flat to the output. + * + * @author Ross Harman, MHPCC + * + * @version $Revision: 1.4.8.1.2.4 $ $Name: not supported by cvs2svn $ + * @date $Date: 2006-02-09 23:58:21 $ + * + * Copyright 2004 Maui High Performance Computing Center, University of Hawaii + */ + +#if HAVE_CONFIG_H +#include +#endif + +#include +#include +#include + +#include "pslib.h" +#include "pmFlatField.h" +#include "pmMaskBadPixels.h" +#include "pmFlatFieldErrors.h" + + +bool pmFlatField(pmReadout *in, const pmReadout *flat) +{ + int i = 0; + int j = 0; + int totOffCol = 0; + int totOffRow = 0; + psElemType inType; + psElemType flatType; + psElemType maskType; + + // Check for nulls + if (in == NULL) { + return true; // Readout may not have data in it + } else if(flat==NULL) { + psError( PS_ERR_BAD_PARAMETER_NULL, true, + PS_ERRORTEXT_pmFlatField_NULL_FLAT_READOUT); + return false; + } + + psImage *inImage = in->image; // Input image + psImage *inMask = in->mask; // Mask for input image + psImage *flatImage = flat->image; // Flat-field image + + // Offsets on the chip + int x0in = psMetadataLookupS32(NULL, in->parent->concepts, "CELL.X0"); + int y0in = psMetadataLookupS32(NULL, in->parent->concepts, "CELL.Y0"); + int x0flat = psMetadataLookupS32(NULL, flat->parent->concepts, "CELL.X0"); + int y0flat = psMetadataLookupS32(NULL, flat->parent->concepts, "CELL.Y0"); + + if (inImage == NULL) { + psError( PS_ERR_BAD_PARAMETER_NULL, true, + PS_ERRORTEXT_pmFlatField_NULL_INPUT_IMAGE); + return false; + } else if(flatImage == NULL) { + psError( PS_ERR_BAD_PARAMETER_NULL, true, + PS_ERRORTEXT_pmFlatField_NULL_FLAT_IMAGE); + return false; + } + + // Check input image and its mask are not larger than flat image + + if (inImage->numRows>flatImage->numRows || inImage->numCols>flatImage->numCols) { + psError( PS_ERR_BAD_PARAMETER_SIZE, true, + PS_ERRORTEXT_pmFlatField_SIZE_INPUT_IMAGE, + inImage->numRows, inImage->numCols, flatImage->numRows, flatImage->numCols); + return false; + } + if (inMask && (inMask->numRows > flatImage->numRows || inMask->numCols > flatImage->numCols)) { + psError( PS_ERR_BAD_PARAMETER_SIZE, true, + PS_ERRORTEXT_pmFlatField_SIZE_MASK_IMAGE, + inMask->numRows, inMask->numCols, flatImage->numRows, flatImage->numCols); + return false; + } + + // Determine total offset based on image offset with chip offset + totOffCol = inImage->col0 + y0in - flatImage->col0 - y0flat; + totOffRow = inImage->row0 + x0in - flatImage->row0 - x0flat; + + // Check that offsets are within image limits + if(totOffRow>=flatImage->numRows || totOffCol>=flatImage->numCols) { + psError( PS_ERR_BAD_PARAMETER_SIZE, true, + PS_ERRORTEXT_pmFlatField_OFFSET_FLAT_IMAGE, + totOffRow, totOffCol, flatImage->numRows, flatImage->numCols); + return false; + } else if(totOffRow>=inImage->numRows || totOffCol>=inImage->numCols) { + psError( PS_ERR_BAD_PARAMETER_SIZE, true, + PS_ERRORTEXT_pmFlatField_OFFSET_INPUT_IMAGE, + totOffRow, totOffCol, inImage->numRows, inImage->numCols); + return false; + } else if(inMask && (totOffRow>=inMask->numRows || totOffCol>=inMask->numCols)) { + psError( PS_ERR_BAD_PARAMETER_SIZE, true, + PS_ERRORTEXT_pmFlatField_OFFSET_MASK_IMAGE, + totOffRow, totOffCol, inMask->numRows, inMask->numCols); + return false; + } + + // Check for incorrect types + inType = inImage->type.type; + flatType = flatImage->type.type; + maskType = inMask->type.type; + if(PS_IS_PSELEMTYPE_COMPLEX(inType)) { + psError( PS_ERR_BAD_PARAMETER_TYPE, true, + PS_ERRORTEXT_pmFlatField_TYPE_INPUT_IMAGE, + inType); + return false; + } else if(PS_IS_PSELEMTYPE_COMPLEX(flatType)) { + psError( PS_ERR_BAD_PARAMETER_TYPE, true, + PS_ERRORTEXT_pmFlatField_TYPE_FLAT_IMAGE, + flatType); + return false; + } else if(inMask && inMask->type.type != PS_TYPE_MASK) { + psError( PS_ERR_BAD_PARAMETER_TYPE, true, + PS_ERRORTEXT_pmFlatField_TYPE_MASK_IMAGE, + maskType); + return false; + } else if(inType != flatType) { + psError( PS_ERR_BAD_PARAMETER_TYPE, true, + PS_ERRORTEXT_pmFlatField_TYPE_MISMATCH, + inType, flatType); + return false; + } + + // Macro for all PS types + #define PM_FLAT_DIVISION(TYPE) \ +case PS_TYPE_##TYPE: \ + /* Per Eugene's request, use two sets of loops: first to fill mask, second to avoid div with bad pix */ \ + for(j = totOffRow; j < inImage->numRows; j++) { \ + for(i = totOffCol; i < inImage->numCols; i++) { \ + if(flatImage->data.TYPE[j][i] <= 0.0) { \ + /* Negative or zero flat pixels shall be masked in input image as PM_MASK_FLAT */ \ + if (inMask) { \ + inMask->data.PS_TYPE_MASK_DATA[j][i] |= PM_MASK_FLAT; \ + } \ + flatImage->data.TYPE[j][i] = 0.0; \ + } \ + } \ + } \ + for(j = totOffRow; j < inImage->numRows; j++) { \ + for(i = totOffCol; i < inImage->numCols; i++) { \ + if(inMask && !inMask->data.PS_TYPE_MASK_DATA[j][i]) { \ + /* Module shall divide the input image by the flat-fielded image */ \ + inImage->data.TYPE[j][i] /= flatImage->data.TYPE[j][i]; \ + } \ + } \ + } \ + break; + + switch(inType) { + PM_FLAT_DIVISION(U8); + PM_FLAT_DIVISION(U16); + PM_FLAT_DIVISION(U32); + PM_FLAT_DIVISION(U64); + PM_FLAT_DIVISION(S8); + PM_FLAT_DIVISION(S16); + PM_FLAT_DIVISION(S32); + PM_FLAT_DIVISION(S64); + PM_FLAT_DIVISION(F32); + PM_FLAT_DIVISION(F64); + default: + psError( PS_ERR_BAD_PARAMETER_TYPE, true, + PS_ERRORTEXT_pmFlatField_TYPE_UNSUPPORTED, + inType); + } + + return true; +} Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/detrend/pmFlatField.h =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/detrend/pmFlatField.h (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/detrend/pmFlatField.h (revision 21664) @@ -0,0 +1,47 @@ +////////////////////////////////////////////////////////////////////////////////////////////////////////////// +// XXX WARNING: I have completely replaced this file with an OLD VERSION (that works) instead of the +// one that was being worked on. +////////////////////////////////////////////////////////////////////////////////////////////////////////////// + + +/** @file pmFlatField.h + * + * @brief Given an input image and a flat field image, pmFlatField shall divide the input image by the flat + * field image. + * + * The input image, in, and the flat field image, flat, need not be the same size, since the input image may + * already have been trimmed (following overscan subtraction), but the function shall use the offsets in the + * image (in->x0 and in->y0) to determine the appropriate offsets to obtain the correct pixel on the flat + * field. In the event that the flat image is too small (i.e., pixels on the input image refer to pixels + * outside the range of the flat image), the function shall generate an error. Pixels which are negative or + * zero in the flat shall be masked in the input image with the value PM_MASK_FLAT. Negative pixels in the + * flat may be set to zero so that they are treated identically to zeroes. Any pixels masked in the flat + * shall be masked with corresponding values in the output. The function shall not normalize the flat; this + * responsibility is left to the caller. This function is basically equivalent to a divide (with psImageOp), + * but with care for the region that is divided, checking for negative pixels, and copying of the mask from + * the flat to the output. + * + * @author Ross Harman, MHPCC + * + * @version $Revision: 1.2.8.1.2.1 $ $Name: not supported by cvs2svn $ + * @date $Date: 2006-01-20 02:38:28 $ + * + * Copyright 2004 Maui High Performance Computing Center, University of Hawaii + */ + +#include "pslib.h" +#include "pmFPA.h" + + +/** Execute flat field module. + * + * Given an input image and a flat-field image, pmFlatField shall divide the input image by the flat field + * image. + * + * @return bool: True or false for success or failure + */ +bool pmFlatField( + pmReadout *in, ///< Readout with input image + const pmReadout *flat ///< Readout with flat image +); + Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/detrend/pmFlatFieldErrors.dat =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/detrend/pmFlatFieldErrors.dat (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/detrend/pmFlatFieldErrors.dat (revision 21664) @@ -0,0 +1,22 @@ +# +# This file is used to generate pmFlatFieldErrors.h content +# +# Format is: +# ERRORNAME(one word) ERRORTEXT +# +# N.B. in code, the ERRORNAME appears as PS_ERRORTEXT_ERRORNAME +#################################################################### +# +pmFlatField_NULL_FLAT_READOUT Null not allowed for flat readout. +pmFlatField_NULL_INPUT_IMAGE Null not allowed for input image. +pmFlatField_NULL_FLAT_IMAGE Null not allowed for flat image. +pmFlatField_SIZE_INPUT_IMAGE Input image size exceeds that of flat image: (%d, %d) vs (%d, %d) +pmFlatField_SIZE_MASK_IMAGE Input image mask size exceeds that of flat image: (%d, %d) vs (%d, %d) +pmFlatField_OFFSET_FLAT_IMAGE Total offset >= flat image size: (%d, %d) vs (%d, %d) +pmFlatField_OFFSET_INPUT_IMAGE Total offset >= input image: (%d, %d) vs (%d, %d) +pmFlatField_OFFSET_MASK_IMAGE Total offset >= input image mask: (%d, %d) vs (%d, %d) +pmFlatField_TYPE_INPUT_IMAGE Complex types not allowed for input image. Type: %d +pmFlatField_TYPE_FLAT_IMAGE Complex types not allowed for flat image. Type: %d +pmFlatField_TYPE_MASK_IMAGE Mask must be PS_TYPE_MASK type. Type: %d +pmFlatField_TYPE_MISMATCH Input and flat image types differ: (%d vs %d) +pmFlatField_TYPE_UNSUPPORTED Unsupported image datatype. Type: %d Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/detrend/pmFlatFieldErrors.h =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/detrend/pmFlatFieldErrors.h (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/detrend/pmFlatFieldErrors.h (revision 21664) @@ -0,0 +1,47 @@ +/** @file pmFlatFieldErrors.h + * + * @brief Contains the error text for the flat field module + * + * @ingroup ErrorHandling + * + * @author Ross Harman, MHPCC + * + * @version $Revision: 1.1 $ $Name: not supported by cvs2svn $ + * @date $Date: 2005-09-28 20:43:52 $ + * + * Copyright 2004 Maui High Performance Computing Center, University of Hawaii + */ + +#ifndef PM_FLATFIELD_ERRORS_H +#define PM_FLATFIELD_ERRORS_H + +/* N.B., lines between '//~Start' and '//~End' are automatic generated from + * the template following the '//~Start'. The template is used to generate + * the other lines by, for each error text in psDataManipErrors.dat, the following + * substitutions are made: + * $1 The error text macro name (first word in the psFlatFieldErrors.h lines) + * $2 The error text (rest of the line in psFlatFieldErrors.h) + * $n The order of the source line in psFlatFieldErrors.h (comments excluded) + * + * DO NOT EDIT THE LINES BETWEEN //~Start and //~End! ANY CHANGES WILL BE OVERWRITTEN. + */ + +#define PS_ERRORNAME_DOMAIN "psModule.src." + +//~Start #define PS_ERRORTEXT_$1 "$2" +#define PS_ERRORTEXT_pmFlatField_NULL_FLAT_READOUT "Null not allowed for flat readout." +#define PS_ERRORTEXT_pmFlatField_NULL_INPUT_IMAGE "Null not allowed for input image." +#define PS_ERRORTEXT_pmFlatField_NULL_FLAT_IMAGE "Null not allowed for flat image." +#define PS_ERRORTEXT_pmFlatField_SIZE_INPUT_IMAGE "Input image size exceeds that of flat image: (%d, %d) vs (%d, %d)" +#define PS_ERRORTEXT_pmFlatField_SIZE_MASK_IMAGE "Input image mask size exceeds that of flat image: (%d, %d) vs (%d, %d)" +#define PS_ERRORTEXT_pmFlatField_OFFSET_FLAT_IMAGE "Total offset >= flat image size: (%d, %d) vs (%d, %d)" +#define PS_ERRORTEXT_pmFlatField_OFFSET_INPUT_IMAGE "Total offset >= input image: (%d, %d) vs (%d, %d)" +#define PS_ERRORTEXT_pmFlatField_OFFSET_MASK_IMAGE "Total offset >= input image mask: (%d, %d) vs (%d, %d)" +#define PS_ERRORTEXT_pmFlatField_TYPE_INPUT_IMAGE "Complex types not allowed for input image. Type: %d" +#define PS_ERRORTEXT_pmFlatField_TYPE_FLAT_IMAGE "Complex types not allowed for flat image. Type: %d" +#define PS_ERRORTEXT_pmFlatField_TYPE_MASK_IMAGE "Mask must be PS_TYPE_MASK type. Type: %d" +#define PS_ERRORTEXT_pmFlatField_TYPE_MISMATCH "Input and flat image types differ: (%d vs %d)" +#define PS_ERRORTEXT_pmFlatField_TYPE_UNSUPPORTED "Unsupported image datatype. Type: %d" +//~End + +#endif Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/detrend/pmMaskBadPixels.c =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/detrend/pmMaskBadPixels.c (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/detrend/pmMaskBadPixels.c (revision 21664) @@ -0,0 +1,188 @@ +////////////////////////////////////////////////////////////////////////////////////////////////////////////// +// XXX WARNING: I have completely replaced this file with an OLD VERSION (that works) instead of the +// one that was being worked on. +////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +/** @file pmMaskBadPixels.c + * + * @brief Given an input image, a bad pixel mask, a corresponding value in the bad pixel mask to mask, a + * saturation level, and a growing radius, mask in the input image those pixels in the bad pixel mask that + * match the value to mask. + * + * Given an input image, in, a bad pixel mask, a corresponding value in the bad pixel mask to mask in the + * input image, maskVal, a saturation level, and a growing radius, pmMaskBadPixels shall mask in the input + * image those pixels in the bad pixel mask that match the value to mask. Note that the input image, in, is + * modified in-place. All pixels in the mask which satisfy the maskVal shall have their corresponding pixels + * masked in the input image, in. All pixels which satisfy the growVal shall have their corresponding + * pixels, along with all pixels within the grow radius masked. Pixels which have flux greater than sat shall + * also be masked, but not grown. Note that the input image, in, and the mask need not be the same size, since + * the input image may already have been trimmed (following overscan subtraction), but the function shall use + * the offsets in the image (in->x0 and in->y0) to determine the appropriate offsets to obtain the correct + * pixel on the mask. In the event that the mask image is too small (i.e., pixels on the input image refer to + * pixels outside the range of the mask image), the function shall generate an error. + + * @author Ross Harman, MHPCC + * + * @version $Revision: 1.3.8.1 $ $Name: not supported by cvs2svn $ + * @date $Date: 2005-12-17 03:18:39 $ + * + * Copyright 2004 Maui High Performance Computing Center, University of Hawaii + */ + +#if HAVE_CONFIG_H +#include +#endif + +#include +#include +#include + +#include "pmMaskBadPixels.h" +#include "pmMaskBadPixelsErrors.h" + +bool pmMaskBadPixels(pmReadout *in, const psImage *mask, unsigned int maskVal, float sat, + unsigned int growVal, int grow) +{ + int i = 0; + int j = 0; + int jj = 0; + int ii = 0; + int rRound = 0; + int rowMin = 0; + int rowMax = 0; + int colMin = 0; + int colMax = 0; + int totOffCol = 0; + int totOffRow = 0; + float r = 0.0f; + psElemType inType; + psElemType maskType; + psImage *inImage = NULL; + psImage *inMask = NULL; + + + // Check for nulls + if (in == NULL) { + return true; // Readout may not have data in it + } else if(mask==NULL) { + psError( PS_ERR_BAD_PARAMETER_NULL, true, + PS_ERRORTEXT_pmMaskBadPixels_NULL_MASK_IMAGE); + return false; + } + + inImage = in->image; + if (inImage == NULL) { + psError( PS_ERR_BAD_PARAMETER_NULL, true, + PS_ERRORTEXT_pmMaskBadPixels_NULL_INPUT_IMAGE); + return false; + } else if(in->mask == NULL) { + in->mask = psImageAlloc(inImage->numCols, inImage->numRows, PS_TYPE_MASK); + memset(in->mask->data.V[0], 0, inImage->numCols*inImage->numRows*PSELEMTYPE_SIZEOF(PS_TYPE_MASK)); + } + inMask = in->mask; + + // Check input image and its mask are not larger than mask + if(inImage->numRows > mask->numRows || inImage->numCols > mask->numCols) { + psError( PS_ERR_BAD_PARAMETER_SIZE, true, + PS_ERRORTEXT_pmMaskBadPixels_SIZE_INPUT_IMAGE, + inImage->numRows, inImage->numCols, mask->numRows, mask->numCols); + return false; + } else if(inMask->numRows>mask->numRows || inMask->numCols>mask->numCols) { + psError( PS_ERR_BAD_PARAMETER_SIZE, true, + PS_ERRORTEXT_pmMaskBadPixels_SIZE_MASK_IMAGE, + inMask->numRows, inMask->numCols, mask->numRows, mask->numCols); + return false; + } + + // Determine total offset based on image offset with chip offset + totOffCol = inImage->col0 + in->col0; + totOffRow = inImage->row0 + in->row0; + + // Check that offsets are within image limits + if(totOffRow>=mask->numRows || totOffCol>=mask->numCols) { + psError( PS_ERR_BAD_PARAMETER_SIZE, true, + PS_ERRORTEXT_pmMaskBadPixels_OFFSET_MASK_IMAGE, + totOffRow, totOffCol, mask->numRows, mask->numCols); + return false; + } else if(totOffRow>=inImage->numRows || totOffCol>=inImage->numCols) { + psError( PS_ERR_BAD_PARAMETER_SIZE, true, + PS_ERRORTEXT_pmMaskBadPixels_OFFSET_INPUT_IMAGE, + totOffRow, totOffCol, inImage->numRows, inImage->numCols); + return false; + } else if(totOffRow>=inMask->numRows || totOffCol>=inMask->numCols) { + psError( PS_ERR_BAD_PARAMETER_SIZE, true, + PS_ERRORTEXT_pmMaskBadPixels_OFFSET_INPUT_IMAGE_MASK, + totOffRow, totOffCol, inMask->numRows, inMask->numCols); + return false; + } + + // Check for incorrect types + inType = inImage->type.type; + maskType = mask->type.type; + if(PS_IS_PSELEMTYPE_COMPLEX(inType)) { + psError( PS_ERR_BAD_PARAMETER_TYPE, true, + PS_ERRORTEXT_pmMaskBadPixels_TYPE_INPUT_IMAGE, + inType); + return false; + } else if(maskType!=PS_TYPE_MASK) { + psError( PS_ERR_BAD_PARAMETER_TYPE, true, + PS_ERRORTEXT_pmMaskBadPixels_TYPE_MASK_IMAGE, + maskType); + return false; + } + + // Macro for all PS types + #define PM_BAD_PIXELS(TYPE) \ +case PS_TYPE_##TYPE: \ + for(j=totOffRow; jnumRows; j++) { \ + for(i=totOffCol; inumCols; i++) { \ + \ + /* Pixels with flux greater than sat shall be masked */ \ + if(inImage->data.TYPE[j][i] > sat) { \ + inMask->data.PS_TYPE_MASK_DATA[j][i] |= PM_MASK_SAT; \ + } \ + \ + /* Pixels which satisfy maskVal shall be masked */ \ + inMask->data.PS_TYPE_MASK_DATA[j][i] |= (mask->data.PS_TYPE_MASK_DATA[j][i]&maskVal); \ + \ + /* Pixels which satisfy growVal and within the grow radius shall be masked */ \ + if(mask->data.PS_TYPE_MASK_DATA[j][i] & growVal) { \ + rowMin = MAX(j-grow, 0); \ + rowMax = MIN(j+grow+1, inImage->numRows); \ + colMin = MAX(i-grow, 0); \ + colMax = MIN(i+grow+1, inImage->numCols); \ + for(jj=rowMin; jjdata.PS_TYPE_MASK_DATA[jj][ii] |= \ + (mask->data.PS_TYPE_MASK_DATA[j][i]&growVal); \ + } \ + } \ + } \ + } \ + } \ + } \ + break; + + // Switch to call bad pixel masking macro defined above + switch(inType) { + PM_BAD_PIXELS(U8); + PM_BAD_PIXELS(U16); + PM_BAD_PIXELS(U32); + PM_BAD_PIXELS(U64); + PM_BAD_PIXELS(S8); + PM_BAD_PIXELS(S16); + PM_BAD_PIXELS(S32); + PM_BAD_PIXELS(S64); + PM_BAD_PIXELS(F32); + PM_BAD_PIXELS(F64); + default: + psError( PS_ERR_BAD_PARAMETER_TYPE, true, + PS_ERRORTEXT_pmMaskBadPixels_TYPE_UNSUPPORTED, + inType); + } + + return false; +} Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/detrend/pmMaskBadPixels.h =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/detrend/pmMaskBadPixels.h (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/detrend/pmMaskBadPixels.h (revision 21664) @@ -0,0 +1,67 @@ +////////////////////////////////////////////////////////////////////////////////////////////////////////////// +// XXX WARNING: I have completely replaced this file with an OLD VERSION (that works) instead of the +// one that was being worked on. +////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +/** @file pmMaskBadPixels.h + * + * @brief Given an input image, a bad pixel mask, a corresponding value in the bad pixel mask to mask, a + * saturation level, and a growing radius, mask in the input image those pixels in the bad pixel mask that + * match the value to mask. + * + * Given an input image, in, a bad pixel mask, a corresponding value in the bad pixel mask to mask in the + * input image, maskVal, a saturation level, and a growing radius, pmMaskBadPixels shall mask in the input + * image those pixels in the bad pixel mask that match the value to mask. Note that the input image, in, is + * modified in-place. All pixels in the mask which satisfy the maskVal shall have their corresponding pixels + * masked in the input image, in. All pixels which satisfy the growVal shall have their corresponding + * pixels, along with all pixels within the grow radius masked. Pixels which have flux greater than sat shall + * also be masked, but not grown. Note that the input image, in, and the mask need not be the same size, + * since the input image may already have been trimmed (following overscan subtraction), but the function + * shall use the offsets in the image (in->x0 and in->y0) to determine the appropriate offsets to obtain the + * correct pixel on the mask. In the event that the mask image is too small (i.e., pixels on the input image + * refer to pixels outside the range of the mask image), the function shall generate an error. + * + * @author Ross Harman, MHPCC + * + * @version $Revision: 1.2.8.1.2.2 $ $Name: not supported by cvs2svn $ + * @date $Date: 2006-01-20 09:47:06 $ + * + * Copyright 2004 Maui High Performance Computing Center, University of Hawaii + */ + +#include "pslib.h" +#include "pmFPA.h" + +/** Mask values */ +typedef enum { + PM_MASK_TRAP = 0x0001, ///< The pixel is a charge trap. + PM_MASK_BADCOL = 0x0002, ///< The pixel is a bad column. + PM_MASK_SAT = 0x0004, ///< The pixel is saturated. + PM_MASK_BAD = 0x0008, ///< The pixel is low + PM_MASK_FLAT = 0x0010 ///< The pixel is non-positive in the flat-field. +} pmMaskValue; + +/** Macro to find maximum of two numbers */ +#define MAX(A,B)((A)>=(B)?(A):(B)) + +/** Macro to find minimum of two numbers */ +#define MIN(A,B)((A)<=(B)?(A):(B)) + + +/** Execute bad pixels module. + * + * Given an input image, a bad pixel mask, a corresponding value in the bad pixel mask to mask, a + * saturation level, and a growing radius, mask in the input image those pixels in the bad pixel mask that + * match the value to mask. + * + * @return bool: True or false for success or failure + */ +bool pmMaskBadPixels( + pmReadout *in, ///< Readout containing input image data. + const psImage *mask, ///< Mask data to be added to readout mask data. + unsigned int maskVal, ///< Mask value to determine what to add to input mask. + float sat, ///< Saturation limit to mask bad pixels. + unsigned int growVal, ///< Mask data to determine if a circurlar area should be masked. + int grow ///< Radius of mask to apply around pixel. +); + Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/detrend/pmMaskBadPixelsErrors.dat =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/detrend/pmMaskBadPixelsErrors.dat (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/detrend/pmMaskBadPixelsErrors.dat (revision 21664) @@ -0,0 +1,20 @@ +# +# This file is used to generate pmMaskBadPixelsErrors.h content +# +# Format is: +# ERRORNAME(one word) ERRORTEXT +# +# N.B. in code, the ERRORNAME appears as PS_ERRORTEXT_ERRORNAME +#################################################################### +# +pmMaskBadPixels_NULL_MASK_IMAGE Null not allowed for mask image. +pmMaskBadPixels_NULL_INPUT_IMAGE Null not allowed for input image. +pmMaskBadPixels_SIZE_INPUT_IMAGE Input image size exceeds that of mask image: (%d, %d) vs (%d, %d) +pmMaskBadPixels_SIZE_MASK_IMAGE Input image mask size exceeds that of mask image: (%d, %d) vs (%d, %d) +pmMaskBadPixels_OFFSET_MASK_IMAGE Total offset >= mask image: (%d, %d) vs (%d, %d) +pmMaskBadPixels_OFFSET_INPUT_IMAGE Total offset >= input image: (%d, %d) vs (%d, %d) +pmMaskBadPixels_OFFSET_INPUT_IMAGE_MASK Total offset >= input image mask: (%d, %d) vs (%d, %d) +pmMaskBadPixels_TYPE_INPUT_IMAGE Complex types not allowed for input image. Type: %d +pmMaskBadPixels_TYPE_MASK_IMAGE Mask must be PS_TYPE_MASK type. Type: %d +pmMaskBadPixels_TYPE_MISMATCH Input and flat image types differ: (%d vs %d) +pmMaskBadPixels_TYPE_UNSUPPORTED Unsupported image datatype. Type: %d Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/detrend/pmMaskBadPixelsErrors.h =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/detrend/pmMaskBadPixelsErrors.h (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/detrend/pmMaskBadPixelsErrors.h (revision 21664) @@ -0,0 +1,50 @@ +////////////////////////////////////////////////////////////////////////////////////////////////////////////// +// XXX WARNING: I have completely replaced this file with an OLD VERSION (that works) instead of the +// one that was being worked on. +////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +/** @file pmMaskBadPixelsErrors.h + * + * @brief Contains the error text for the mask bad pixels module + * + * @ingroup ErrorHandling + * + * @author Ross Harman, MHPCC + * + * @version $Revision: 1.1.16.1 $ $Name: not supported by cvs2svn $ + * @date $Date: 2005-12-17 03:18:39 $ + * + * Copyright 2004 Maui High Performance Computing Center, University of Hawaii + */ + +#ifndef PM_FLATFIELD_ERRORS_H +#define PM_FLATFIELD_ERRORS_H + +/* N.B., lines between '//~Start' and '//~End' are automatic generated from + * the template following the '//~Start'. The template is used to generate + * the other lines by, for each error text in pmMaskBadPixelsErrors.dat, the following + * substitutions are made: + * $1 The error text macro name (first word in the pmMaskBadPixelsErrors.h lines) + * $2 The error text (rest of the line in pmMaskBadPixelsErrors.h) + * $n The order of the source line in pmMaskBadPixelsErrors.h (comments excluded) + * + * DO NOT EDIT THE LINES BETWEEN //~Start and //~End! ANY CHANGES WILL BE OVERWRITTEN. + */ + +#define PS_ERRORNAME_DOMAIN "psModule.src." + +//~Start #define PS_ERRORTEXT_$1 "$2" +#define PS_ERRORTEXT_pmMaskBadPixels_NULL_MASK_IMAGE "Null not allowed for mask image." +#define PS_ERRORTEXT_pmMaskBadPixels_NULL_INPUT_IMAGE "Null not allowed for input image." +#define PS_ERRORTEXT_pmMaskBadPixels_SIZE_INPUT_IMAGE "Input image size exceeds that of mask image: (%d, %d) vs (%d, %d)" +#define PS_ERRORTEXT_pmMaskBadPixels_SIZE_MASK_IMAGE "Input image mask size exceeds that of mask image: (%d, %d) vs (%d, %d)" +#define PS_ERRORTEXT_pmMaskBadPixels_OFFSET_MASK_IMAGE "Total offset >= mask image: (%d, %d) vs (%d, %d)" +#define PS_ERRORTEXT_pmMaskBadPixels_OFFSET_INPUT_IMAGE "Total offset >= input image: (%d, %d) vs (%d, %d)" +#define PS_ERRORTEXT_pmMaskBadPixels_OFFSET_INPUT_IMAGE_MASK "Total offset >= input image mask: (%d, %d) vs (%d, %d)" +#define PS_ERRORTEXT_pmMaskBadPixels_TYPE_INPUT_IMAGE "Complex types not allowed for input image. Type: %d" +#define PS_ERRORTEXT_pmMaskBadPixels_TYPE_MASK_IMAGE "Mask must be PS_TYPE_MASK type. Type: %d" +#define PS_ERRORTEXT_pmMaskBadPixels_TYPE_MISMATCH "Input and flat image types differ: (%d vs %d)" +#define PS_ERRORTEXT_pmMaskBadPixels_TYPE_UNSUPPORTED "Unsupported image datatype. Type: %d" +//~End + +#endif Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/detrend/pmNonLinear.c =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/detrend/pmNonLinear.c (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/detrend/pmNonLinear.c (revision 21664) @@ -0,0 +1,128 @@ +////////////////////////////////////////////////////////////////////////////////////////////////////////////// +// XXX WARNING: I have completely replaced this file with an OLD VERSION (that works) instead of the +// one that was being worked on. +////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +/** @file pmNonLinear.c + * + * Provides polynomial or table lookup non-linearity corrections to readouts. + * + * @author GLG, MHPCC + * + * @version $Revision: 1.5.8.1 $ $Name: not supported by cvs2svn $ + * @date $Date: 2005-12-17 03:18:39 $ + * + * Copyright 2004 Maui High Performance Computing Center, University of Hawaii + * + * XXX: The SDR is silent about image types. Only F32 was implemented. + * + */ + +#if HAVE_CONFIG_H +#include +#endif + +#include +#include + +#include "pmNonLinear.h" + +/****************************************************************************** +pmNonLinearityLookup(): This routine will take an pmReadout image as input +and a 1-D polynomial. For each pixel in the input image, the polynomial will +be evaluated at that pixels value, and the image pixel will then be set to +that value. + *****************************************************************************/ + +pmReadout *pmNonLinearityPolynomial(pmReadout *inputReadout, + const psPolynomial1D *input1DPoly) +{ + PS_ASSERT_PTR_NON_NULL(inputReadout, NULL); + PS_ASSERT_PTR_NON_NULL(inputReadout->image, NULL); + PS_ASSERT_IMAGE_TYPE(inputReadout->image, PS_TYPE_F32, NULL); + PS_ASSERT_PTR_NON_NULL(input1DPoly, NULL); + + psS32 i; + psS32 j; + + for (i=0;iimage->numRows;i++) { + for (j=0;jimage->numCols;j++) { + inputReadout->image->data.F32[i][j] = psPolynomial1DEval(input1DPoly, inputReadout->image->data.F32[i][j]); + } + } + return(inputReadout); +} + + +/****************************************************************************** +pmNonLinearityLookup(): This routine will take an pmReadout image as input +and two input vectors, which constitute a lookup table. For each pixel in +the input image, that pixels value will be determined in the input vector +inFluxe, and the corresponding value in outFlux. The image pixel will then +be set to the value from outFlux. + *****************************************************************************/ +pmReadout *pmNonLinearityLookup(pmReadout *inputReadout, + const psVector *inFlux, + const psVector *outFlux) +{ + PS_ASSERT_PTR_NON_NULL(inputReadout,NULL); + PS_ASSERT_PTR_NON_NULL(inputReadout->image,NULL); + PS_ASSERT_IMAGE_TYPE(inputReadout->image, PS_TYPE_F32, NULL); + PS_ASSERT_PTR_NON_NULL(inFlux,NULL); + if (inFlux->n < 2) { + psError(PS_ERR_UNKNOWN,true, "pmNonLinearityLookup(): input vector less than 2 elements. Returning inputReadout image."); + return(inputReadout); + } + PS_ASSERT_PTR_NON_NULL(outFlux,NULL); + psS32 tableSize = inFlux->n; + if (inFlux->n != outFlux->n) { + tableSize = PS_MIN(inFlux->n, outFlux->n); + psLogMsg(__func__, PS_LOG_WARN, + "WARNING: pmNonLinear.c: pmNonLinearityLookup(): input vectors have different sizes (%d, %d)\n", inFlux->n, outFlux->n); + } + PS_ASSERT_VECTOR_TYPE(inFlux, PS_TYPE_F32, NULL); + PS_ASSERT_VECTOR_TYPE(outFlux, PS_TYPE_F32, NULL); + + psS32 i; + psS32 j; + psS32 binNum; + psScalar x; + psS32 numPixels = 0; + psF32 slope; + + x.type.type = PS_TYPE_F32; + for (i=0;iimage->numRows;i++) { + for (j=0;jimage->numCols;j++) { + x.data.F32 = inputReadout->image->data.F32[i][j]; + binNum = p_psVectorBinDisect((psVector *)inFlux, &x); + + if (binNum == -2) { + // We get here if x is below the table lookup range. + inputReadout->image->data.F32[i][j] = outFlux->data.F32[0]; + numPixels++; + + } else if (binNum == -1) { + // We get here if x is above the table lookup range. + inputReadout->image->data.F32[i][j] = outFlux->data.F32[tableSize-1]; + numPixels++; + + } else if (binNum < -2) { + // We get here if there was some other problem. + psError(PS_ERR_UNKNOWN,true, "pmNonLinearityLookup(): Could not perform p_psVectorBinDisect(). Returning inputReadout image."); + return(inputReadout); + numPixels++; + } else { + // Perform linear interpolation. + slope = (outFlux->data.F32[binNum+1] - outFlux->data.F32[binNum]) / + (inFlux->data.F32[binNum+1] - inFlux->data.F32[binNum]); + inputReadout->image->data.F32[i][j] = outFlux->data.F32[binNum] + + ((x.data.F32 - inFlux->data.F32[binNum]) * slope); + } + } + } + if (numPixels > 0) { + psLogMsg(__func__, PS_LOG_WARN, + "WARNING: pmNonLinear.c: pmNonLinearityLookup(): %d pixels outside table.", numPixels); + } + return(inputReadout); +} Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/detrend/pmNonLinear.h =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/detrend/pmNonLinear.h (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/detrend/pmNonLinear.h (revision 21664) @@ -0,0 +1,32 @@ +////////////////////////////////////////////////////////////////////////////////////////////////////////////// +// XXX WARNING: I have completely replaced this file with an OLD VERSION (that works) instead of the +// one that was being worked on. +////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +/** @file pmNonLinear.h + * + * Provides polynomial or table lookup non-linearity corrections to readouts. + * + * @author GLG, MHPCC + * + * @version $Revision: 1.2.8.1.2.1 $ $Name: not supported by cvs2svn $ + * @date $Date: 2006-01-20 02:38:28 $ + * + * Copyright 2004 Maui High Performance Computing Center, University of Hawaii + * + */ + +#if !defined(PM_NON_LINEAR_H) +#define PM_NON_LINEAR_H + +#include "pslib.h" +#include "pmFPA.h" + +pmReadout *pmNonLinearityPolynomial(pmReadout *in, + const psPolynomial1D *coeff); + +pmReadout *pmNonLinearityLookup(pmReadout *in, + const psVector *inFlux, + const psVector *outFlux); + +#endif Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/imcombine/.cvsignore =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/imcombine/.cvsignore (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/imcombine/.cvsignore (revision 21664) @@ -0,0 +1,6 @@ +.deps +.libs +Makefile +Makefile.in +*.la +*.lo Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/imcombine/Makefile.am =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/imcombine/Makefile.am (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/imcombine/Makefile.am (revision 21664) @@ -0,0 +1,11 @@ +noinst_LTLIBRARIES = libpsmoduleimcombine.la + +libpsmoduleimcombine_la_CPPFLAGS = $(SRCINC) $(PSMODULE_CFLAGS) +libpsmoduleimcombine_la_LDFLAGS = -release $(PACKAGE_VERSION) +libpsmoduleimcombine_la_SOURCES = pmImageCombine.c \ + pmReadoutCombine.c + +psmoduleincludedir = $(includedir) +psmoduleinclude_HEADERS = \ + pmImageCombine.h \ + pmReadoutCombine.h Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/imcombine/pmImageCombine.c =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/imcombine/pmImageCombine.c (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/imcombine/pmImageCombine.c (revision 21664) @@ -0,0 +1,666 @@ +/** @file pmImageCombine.c + * + * This file will perform image combination of several images of the + * same field, produce a list of questionable pixels, then tag some + * of those pixels as cosmic rays. + * + * @author Paul Price, IfA (original prototype) + * @author GLG, MHPCC + * + * @version $Revision: 1.2 $ $Name: not supported by cvs2svn $ + * @date $Date: 2005-12-08 00:29:53 $ + * + * XXX: pmRejectPixels() has a known bug with the pmImageTransform() call. + * + * Copyright 2004 Maui High Performance Computing Center, University of Hawaii + * + */ + +#include +#include +#include +#include "pslib.h" + +// +// The following macros define how big the initial pixel list will be, and +// how much it should be incremented when realloc'ed. +// +#define PS_COMBINE_IMAGE_INITIAL_PIXEL_LIST_LENGTH 100 +#define PS_COMBINE_IMAGE_INITIAL_PIXEL_LIST_LENGTH_INC 100 +#define PS_COMBINE_IMAGE_MAX_QUESTIONABLE_PIXELS 1000 +/****************************************************************************** +pmCombineImages(combine, questionablePixels, images, errors, masks, maskVal, + pixels, numIter, sigmaClip, stats) + +XXX: Allocate a dummy psStats structure so that we don't destroy away its data. + *****************************************************************************/ +psImage *pmCombineImages( + psImage *combine, ///< Combined image (output) + psArray **questionablePixels, ///< Array of rejection masks + const psArray *images, ///< Array of input images + const psArray *errors, ///< Array of input error images + const psArray *masks, ///< Array of input masks + psU32 maskVal, ///< Mask value + const psPixels *pixels, ///< Pixels to combine + psS32 numIter, ///< Number of rejection iterations + psF32 sigmaClip, ///< Number of standard deviations at which to reject + const psStats *stats) ///< Statistics to use in the combination +{ + + PS_ASSERT_PTR_NON_NULL(images, combine); + psU32 numImages = images->n; + psTrace("ImageCombine.pmCombineImages", 3, "Calling pmCombineImages(%d)\n", images->n); + + if (errors != NULL) { + if (images->n != errors->n) { + psError(PS_ERR_UNKNOWN, true, "images and errors args must have same length (%d != %d)\n", + images->n, errors->n); + return(combine); + } + } + if (masks != NULL) { + if (images->n != masks->n) { + psError(PS_ERR_UNKNOWN, true, "images and masks args must have same length (%d != %d)\n", + images->n, masks->n); + return(combine); + } + } + + psImage *tmpImg = (psImage *) images->data[0]; + psU32 numRows = tmpImg->numRows; + psU32 numCols = tmpImg->numCols; + + // + // Check that all images have the appropriate size and type. + // + for (psS32 i = 0 ; i < numImages ; i++) { + psImage *tmpDataImg = (psImage *) images->data[i]; + PS_ASSERT_IMAGE_NON_NULL(tmpDataImg, combine); + PS_ASSERT_IMAGE_TYPE(tmpDataImg, PS_TYPE_F32, combine); + if ((tmpDataImg->numRows != numRows) || (tmpDataImg->numCols != numCols)) { + psError(PS_ERR_UNKNOWN, true, "image %d has size (%d, %d); should be (%d, %d).\n", + i, tmpDataImg->numRows, tmpDataImg->numCols, numRows, numCols); + } + + if (errors != NULL) { + psImage *tmpErrorImg = (psImage *) errors->data[i]; + PS_ASSERT_IMAGE_NON_NULL(tmpErrorImg, combine); + PS_ASSERT_IMAGE_TYPE(tmpErrorImg, PS_TYPE_F32, combine); + PS_ASSERT_IMAGES_SIZE_EQUAL(tmpDataImg, tmpErrorImg, NULL); + } + + if (masks != NULL) { + psImage *tmpMaskImg = (psImage *) masks->data[i]; + PS_ASSERT_IMAGE_NON_NULL(tmpMaskImg, combine); + PS_ASSERT_IMAGE_TYPE(tmpMaskImg, PS_TYPE_U8, combine); + PS_ASSERT_IMAGES_SIZE_EQUAL(tmpDataImg, tmpMaskImg, NULL); + } + } + PS_ASSERT_PTR_NON_NULL(stats, combine); + + // Allocate and initialize the combined image, if necessary. + if (combine == NULL) { + combine = psImageAlloc(numCols, numRows, PS_TYPE_F32); + if (pixels != NULL) { + PS_IMAGE_SET_F32(combine, 0.0); + } + } + + // + // Allocate the questionablePixels psArray, if necesssary, then create a psPixels + // struct for each image. + // + if (*questionablePixels == NULL) { + *questionablePixels = psArrayAlloc(numImages); + } else if ((*questionablePixels)->n != numImages) { + *questionablePixels = psArrayRealloc(*questionablePixels, numImages); + } + for (psS32 im = 0 ; im < numImages ; im++) { + psFree((*questionablePixels)->data[im]); + ((*questionablePixels)->data[im]) = (psPtr *) psPixelsAlloc(PS_COMBINE_IMAGE_INITIAL_PIXEL_LIST_LENGTH); + ((psPixels *) ((*questionablePixels)->data[im]))->n = 0; + } + // + // qpPtr is used to maintain a count of the questionable pixels for each image. + // + psVector *qpPtr = psVectorAlloc(numImages, PS_TYPE_S32); + PS_VECTOR_SET_S32(qpPtr, 0); + + // + // Allocate the necessary psVectors for the call to psVectorStats(). + // These vectors will be used whether we are combining a list of pixels, + // or every pixel in the input images. + // + psVector *pixelData = psVectorAlloc(numImages, PS_TYPE_F32); + + psVector *pixelMask = NULL; + if (masks != NULL) { + pixelMask = psVectorAlloc(numImages, PS_TYPE_U8); + PS_VECTOR_SET_U8(pixelMask, 0); + } + + psVector *pixelErrors = NULL; + if (errors != NULL) { + pixelErrors = psVectorAlloc(numImages, PS_TYPE_F32); + PS_VECTOR_SET_F32(pixelErrors, 1.0); + } + + if (pixels != NULL) { + // Only those specified pixels should be combined. + + psStats *stdevStats = psStatsAlloc(PS_STAT_SAMPLE_STDEV); + + for (psS32 p = 0 ; p < pixels->n ; p++) { + // Must initialize the mask to 0 for every pixel. + PS_VECTOR_SET_U8(pixelMask, 0); + psS32 col = (pixels->data[p]).x; + psS32 row = (pixels->data[p]).y; + + // + // Loop through each image, extract the pixel/mask/error data + // into psVectors. + // + for (psS32 im = 0 ; im < numImages ; im++) { + // Set the pixel data + pixelData->data.F32[im] = ((psImage *) images->data[im])->data.F32[row][col]; + // Set the pixel mask data, if necessary + if (masks != NULL) { + pixelMask->data.U8[im] = ((psImage *) masks->data[im])->data.F32[row][col]; + } + + // Set the pixel error data, if necessary + if (errors != NULL) { + pixelErrors->data.F32[im] = ((psImage *) errors->data[im])->data.F32[row][col]; + } + } + + // + // Iterate on the pixels, rejecting outliers + // + for (psS32 iter = 0 ; iter < numIter ; iter++) { + // Combine all the pixels, using the specified stat. + + stats = psVectorStats((psStats *) stats, pixelData, pixelErrors, pixelMask, maskVal); + psF64 combinedPixel; + psBool rc = p_psGetStatValue(stats, &combinedPixel); + if (rc != true) { + psLogMsg(__func__, PS_LOG_WARN, "WARNING: could not combine pixels (%d, %d) with the specified stat.\n", row, col); + } + if (iter == 0) { + combine->data.F32[row][col] = (psF32) combinedPixel; + } + + // + // Reject all pixels that lie more that sigmaClip standard deviations from + // the combined pixel value. + // + psS32 numRejects = 0; + for (psS32 im = 0 ; im < numImages ; im++) { + stdevStats = psVectorStats(stdevStats, pixelData, pixelErrors, pixelMask, maskVal); + psF64 stdev; + psBool rc = p_psGetStatValue(stdevStats, &stdev); + if (rc != true) { + psLogMsg(__func__, PS_LOG_WARN, "WARNING: could not compute the standard deviation of pixel (%d, %d).\n", row, col); + psLogMsg(__func__, PS_LOG_WARN, "WARNING: could not combine pixels (%d, %d) with the specified stat.\n", row, col); + } + + if (!(pixelMask->data.U8[im] & maskVal)) { + if (fabs(pixelData->data.F32[im]) > + (fabs(sigmaClip * stdev) + fabs(combinedPixel))) { + numRejects++; + pixelMask->data.U8[im] = maskVal; + // + // XXX: These data structures indirections are getting complicated. + // + psS32 ptr = qpPtr->data.S32[im]; + psPixels *pixelListPtr = ((psPixels *) ((*questionablePixels)->data[im])); + + if (ptr >= pixelListPtr->nalloc) { + (*questionablePixels)->data[im] = + (psPtr *) psPixelsRealloc(((psPixels *) ((*questionablePixels)->data[im])), + ((((psPixels *) ((*questionablePixels)->data[im]))->nalloc) + + PS_COMBINE_IMAGE_INITIAL_PIXEL_LIST_LENGTH_INC)); + // XXX: Can the realloc() fail? Must we check for NULL? + } + ((psPixels *) ((*questionablePixels)->data[im]))->data[ptr].x = col; + ((psPixels *) ((*questionablePixels)->data[im]))->data[ptr].y = row; + (qpPtr->data.S32[im])++; + // XXX: this pixel ->n increment is wierd + ((psPixels *) ((*questionablePixels)->data[im]))->n = qpPtr->data.S32[im]; + } + } + } + + // + // If the number of rejected pixels is zero, then there's no point + // continuing the loop. + // + if (numRejects == 0) { + break; + } + psS32 totalRejects = 0; + for (psS32 im = 0 ; im < numImages ; im++) { + if (pixelMask->data.U8[im] & maskVal) { + totalRejects++; + } + } + + // + // XXX: Is it possible to have all pixels rejected? If so, we should + // exit the loop. + // + if (totalRejects == numImages) { + break; + } + } + } + psFree(stdevStats); + } else { + // + // We get here if there is a NULL list of pixels to combine. + // Therefore, we combine all pixels in all images. + // + + // + // Loop over all pixels in all images, set the appropriate data, mask, + // error vectors, call psVectorStats(), and set the result in the + // combine image. + // + for (psS32 row = 0 ; row < numRows ; row++) { + for (psS32 col = 0 ; col < numCols ; col++) { + for (psS32 im = 0 ; im < numImages ; im++) { + // Set the pixel data + pixelData->data.F32[im] = ((psImage *) images->data[im])->data.F32[row][col]; + + // Set the pixel mask data, if necessary + if (masks != NULL) { + pixelMask->data.U8[im] = ((psImage *) masks->data[im])->data.F32[row][col]; + } + + // Set the pixel error data, if necessary + if (errors != NULL) { + pixelErrors->data.F32[im] = ((psImage *) errors->data[im])->data.F32[row][col]; + } + + } + // Combine all the pixels, using the specified stat. + stats = psVectorStats((psStats *) stats, pixelData, pixelErrors, pixelMask, maskVal); + psF64 tmpF64; + psBool rc = p_psGetStatValue(stats, &tmpF64); + combine->data.F32[row][col] = (psF32) tmpF64; + if (rc != true) { + psLogMsg(__func__, PS_LOG_WARN, "WARNING: could not combine pixels (%d, %d) with the specified stat.\n", row, col); + } + } + } + } + + psFree(pixelData); + psFree(pixelMask); + psFree(pixelErrors); + psFree(qpPtr); + + psTrace("ImageCombine.pmCombineImages", 3, "Exiting pmCombineImages(%d)\n", images->n); + return(combine); +} + + +/****************************************************************************** +XXX: Directly from Paul Price + *****************************************************************************/ +static psF32 CalcGradient( + psImage *image, + psImage *imageMask, + psS32 x, + psS32 y +) +{ + psTrace("ImageCombine.CalcGradient", 4, "Calling CalcGradient(%d, %d)\n", x, y); + int num = 0; + psVector *pixels = psVectorAlloc(8, PS_TYPE_F32); // Array of pixels + psVector *mask = psVectorAlloc(8, PS_TYPE_U8); // Corresponding mask + + // Get limits + int xMin = PS_MAX(x - 1, 0); + int xMax = PS_MIN(x + 1, image->numCols - 1); + int yMin = PS_MAX(y - 1, 0); + int yMax = PS_MIN(y + 1, image->numRows - 1); + if (imageMask != NULL) { + for (int j = yMin; j <= yMax; j++) { + for (int i = xMin; i <= xMax; i++) { + if ((i != x) && (j != y) && (0 == imageMask->data.U8[j][i])) { + pixels->data.F32[num] = image->data.F32[j][i]; + mask->data.U8[num] = 0; + num++; + } else { + mask->data.U8[num] = 1; + } + } + } + } else { + // + // This code is simply the previous loop without the imageMask. + // XXX: Consider restructuring this. + // + for (int j = yMin; j <= yMax; j++) { + for (int i = xMin; i <= xMax; i++) { + if ((i != x) && (j != y)) { + pixels->data.F32[num] = image->data.F32[j][i]; + mask->data.U8[num] = 0; + num++; + } else { + mask->data.U8[num] = 1; + } + } + } + } + + pixels->n = num; + mask->n = num; + + // Get the median + psStats *stats = psStatsAlloc(PS_STAT_SAMPLE_MEDIAN); + (void)psVectorStats(stats, pixels, NULL, mask, 1); + float median = stats->sampleMedian; + psFree(stats); + psFree(pixels); + psFree(mask); + + psTrace("ImageCombine.CalcGradient", 4, "Exiting CalcGradient(%d, %d)\n", x, y); + return(median / image->data.F32[y][x]); +} + +/****************************************************************************** +DetermineRegion(image, myOutToIn): for a psImage and a psPlaneTransform to that +image, this routine determines the size of the input image which maps to that +image, and returns the result in a psRegion struct. + +XXX: Basically, this routine is only guaranteed to work if the transform is +linear. + +XXX: Shouldn't this functionality be part of psImageTransform()? + *****************************************************************************/ +static psRegion DetermineRegion(psImage *image, + psPlaneTransform *myOutToIn) +{ + psTrace("ImageCombine.DetermineRegion", 4, "Calling DetermineRegion()\n"); + psRegion myRegion; + myRegion.x0 = PS_MAX_F32; + myRegion.x1 = PS_MIN_F32; + myRegion.y0 = PS_MAX_F32; + myRegion.y1 = PS_MIN_F32; + psPlane in; + psPlane out; + + in.x = 0.0; + in.y = 0.0; + + psPlaneTransformApply(&out, myOutToIn, &in); + if (out.x < myRegion.x0) { + myRegion.x0 = out.x; + } + if (out.x > myRegion.x1) { + myRegion.x1 = out.x; + } + if (out.y < myRegion.y0) { + myRegion.y0 = out.y; + } + if (out.y > myRegion.y1) { + myRegion.y1 = out.y; + } + + in.x = (psF32) (image->numCols); + in.y = 0.0; + psPlaneTransformApply(&out, myOutToIn, &in); + if (out.x < myRegion.x0) { + myRegion.x0 = out.x; + } + if (out.x > myRegion.x1) { + myRegion.x1 = out.x; + } + if (out.y < myRegion.y0) { + myRegion.y0 = out.y; + } + if (out.y > myRegion.y1) { + myRegion.y1 = out.y; + } + + in.x = (psF32) (image->numCols); + ; + in.y = 0.0; + psPlaneTransformApply(&out, myOutToIn, &in); + if (out.x < myRegion.x0) { + myRegion.x0 = out.x; + } + if (out.x > myRegion.x1) { + myRegion.x1 = out.x; + } + if (out.y < myRegion.y0) { + myRegion.y0 = out.y; + } + if (out.y > myRegion.y1) { + myRegion.y1 = out.y; + } + + in.x = (psF32) (image->numCols); + in.y = (psF32) (image->numRows); + psPlaneTransformApply(&out, myOutToIn, &in); + if (out.x < myRegion.x0) { + myRegion.x0 = out.x; + } + if (out.x > myRegion.x1) { + myRegion.x1 = out.x; + } + if (out.y < myRegion.y0) { + myRegion.y0 = out.y; + } + if (out.y > myRegion.y1) { + myRegion.y1 = out.y; + } + + psTrace("ImageCombine.DetermineRegion", 4, "Exiting DetermineRegion()\n"); + return(myRegion); +} + +/****************************************************************************** +XXX: Don't we have a psLib function for this? + *****************************************************************************/ +static psImage *ImageConvertF32(psImage *image) +{ + psTrace("ImageCombine.ImageConvertF32", 4, "Calling ImageConvertF32()\n"); + psImage *imgF32 = psImageAlloc(image->numCols, image->numRows, PS_TYPE_F32); + + for (psS32 i = 0 ; i < image->numRows ; i++) { + for (psS32 j = 0 ; j < image->numCols ; j++) { + imgF32->data.F32[i][j] = (psF32) image->data.U8[i][j]; + } + } + + psTrace("ImageCombine.ImageConvertF32", 4, "Exiting ImageConvertF32()\n"); + return(imgF32); +} + + +// +// The following macros define how big the initial pixel list will be, and +// how much it should be incremented when realloc'ed. +// +#define PS_REJECT_PIXEL_INITIAL_PIXEL_LIST_LENGTH 100 +#define PS_REJECT_PIXEL_INITIAL_PIXEL_LIST_LENGTH_INC 100 +/****************************************************************************** +pmRejectPixels(images, errors, inToOut, outToIn, rejThreshold, +gradLimit) + +XXX: Optimization: we don't need to transform the entire mask image. +XXX: The inToOut and outToIn transforms are confusing. Verify that what + I think they mean syncs with PWP. + *****************************************************************************/ +psArray *pmRejectPixels( + const psArray *images, ///< Array of input images + const psArray *masks, ///< Array of input image masks + const psArray *errors, ///< The pixels which were rejected in the combination + const psArray *inToOut, ///< Transformation from input to output system + const psArray *outToIn, ///< Transformation from output to input system + psF32 rejThreshold, ///< Rejection threshold + psF32 gradLimit ///< Gradient limit +) +{ + psTrace("ImageCombine.pmRejectPixels", 3, "Calling pmRejectPixels()\n"); + PS_ASSERT_PTR_NON_NULL(images, NULL); + for (psS32 im = 0 ; im < images->n ; im++) { + psImage *tmpImage = (psImage *) images->data[im]; + PS_ASSERT_IMAGE_NON_NULL(tmpImage, NULL); + PS_ASSERT_IMAGE_NON_EMPTY(tmpImage, NULL); + PS_ASSERT_IMAGE_TYPE(tmpImage, PS_TYPE_F32, NULL); + if (masks != NULL) { + PS_ASSERT_INT_EQUAL(images->n, masks->n, NULL); + psImage *tmpMask = (psImage *) masks->data[im]; + PS_ASSERT_IMAGE_NON_NULL(tmpMask, NULL); + PS_ASSERT_IMAGE_NON_EMPTY(tmpMask, NULL); + PS_ASSERT_IMAGE_TYPE(tmpMask, PS_TYPE_F32, NULL); + PS_ASSERT_IMAGES_SIZE_EQUAL(tmpImage, tmpMask, NULL); + } + PS_ASSERT_IMAGES_SIZE_EQUAL(((psImage *) images->data[0]), tmpImage, NULL); + } + PS_ASSERT_PTR_NON_NULL(errors, NULL); + PS_ASSERT_PTR_NON_NULL(inToOut, NULL); + PS_ASSERT_PTR_NON_NULL(outToIn, NULL); + // Ensure that the psArray parameters have an element for each image. + psS32 numImages = images->n; + PS_ASSERT_INT_EQUAL(numImages, errors->n, NULL); + PS_ASSERT_INT_EQUAL(numImages, inToOut->n, NULL); + PS_ASSERT_INT_EQUAL(numImages, outToIn->n, NULL); + + // + // Create the psArray of psPixelLists, one for each image, for rejected pixels. + // + psArray *rejects = psArrayAlloc(numImages); + for (psS32 im = 0 ; im < numImages ; im++) { + rejects->data[im] = (psPtr *) psPixelsAlloc(PS_REJECT_PIXEL_INITIAL_PIXEL_LIST_LENGTH); + psPixels *pixels = (psPixels *) rejects->data[im]; + pixels->n = 0; + } + // + // rPtr is used to maintain a count of the questionable pixels for each image. + // + psVector *rPtr = psVectorAlloc(numImages, PS_TYPE_S32); + PS_VECTOR_SET_S32(rPtr, 0); + + psS32 numCols = ((psImage *) images->data[0])->numCols; + psS32 numRows = ((psImage *) images->data[0])->numRows; + psRegion myRegion = psRegionSet(0, numCols-1, 0, numRows-1); + psU32 maskVal = 1; // XXX: Is this appropriate? + + psPlane *inCoords = psAlloc(sizeof(psPlane)); + psPlane *outCoords = psAlloc(sizeof(psPlane)); + + for (psS32 im = 0 ; im < numImages ; im++) { + // + // Extract data from psArrays. + // + psPixels *pixelList = (psPixels *) errors->data[im]; + + psImage *currImage = (psImage *) images->data[im]; + myRegion.x0 = 0; + myRegion.x1 = currImage->numCols; + myRegion.y0 = 0; + myRegion.y1 = currImage->numRows; + psPlaneTransform *myInToOut = (psPlaneTransform *) inToOut->data[im]; + psPlaneTransform *myOutToIn = (psPlaneTransform *) outToIn->data[im]; + + // + // Create a psU8 mask image from the list of cosmic pixels. + // + psImage *maskImage = NULL; + maskImage = psPixelsToMask(maskImage, pixelList, myRegion, maskVal); + psImage *maskImageF32 = ImageConvertF32(maskImage); + + // + // Transform that mask image into detector coordinate space + // + psRegion myRegionXForm = DetermineRegion(maskImageF32, myOutToIn); + psImage *transformedImage = psImageTransform(NULL, NULL, maskImageF32, NULL, + 0, myOutToIn, myRegionXForm, NULL, + PS_INTERPOLATE_BILINEAR, 0); + + // + // Loop over all cosmic pixels. Transform their coords to detector space. + // If the value of the transformed mask is larger than rejThreshold, then + // this might be a cosmic ray pixel. We then calculate the mean gradient + // in other images. + // + for (psS32 p = 0 ; p < pixelList->n ; p++) { + inCoords->x = 0.5 + (psF32) (pixelList->data[p]).x; + inCoords->y = 0.5 + (psF32) (pixelList->data[p]).y; + psPlaneTransformApply(outCoords, myInToOut, inCoords); + psF32 maskVal = (psF32) psImagePixelInterpolate(transformedImage, outCoords->x, outCoords->y, + NULL, 0, 0.0, PS_INTERPOLATE_BILINEAR); + if (maskVal > rejThreshold) { + + // This is a possible cosmic array pixel. We must calculate the gradient + // at this location in all input images. + psF32 meanGrads = 0.0; + psS32 numGrads = 0; + // + // Loop through all other images, calculate their mean gradient. + // + for (psS32 otherImg = 0 ; otherImg < numImages ; otherImg++) { + if (im != otherImg) { + // Map the outCoords to inCoords that for otherImg space. + psImage *tmpMask = NULL; + if (masks != NULL) { + tmpMask = masks->data[otherImg]; + } + psPlaneTransformApply(inCoords, + (psPlaneTransform * )outToIn->data[otherImg], + outCoords); + psS32 xPix = (int)(inCoords->x + 0.5); + psS32 yPix = (int)(inCoords->y + 0.5); + if ((xPix >= 0) && (xPix <= ((psImage*)(images->data[otherImg]))->numCols - 1) && + (yPix >= 0) && (yPix <= ((psImage*)(images->data[otherImg]))->numRows - 1)) { + meanGrads += CalcGradient(images->data[otherImg], tmpMask, xPix, yPix); + numGrads++; + } + } + } + if (numGrads > 0) { + meanGrads /= (psF32) numGrads; + } else { + // XXX: my idea. Verify with PWP: + meanGrads = 1.0 + gradLimit; + } + + // XXX: The SDRS and the prototype code differ significantly here: + // if (CalcGradient(inputs->data[i], pixelList->data.x, pixelList->data.y) < (gradLimit * meanGrads)) { + if (meanGrads < gradLimit) { + // + // Add this to the list of questionable pixels. We must ensure that the + // pixelList is large enough; if not, we realloc() + // + psS32 ptr = rPtr->data.S32[im]; + psPixels *pixelListPtr = (psPixels *) rejects->data[im]; + if (ptr >= pixelListPtr->nalloc) { + rejects->data[im] = (psPtr *) psPixelsRealloc(((psPixels *) rejects->data[im]), + ((((psPixels *) rejects->data[im])->nalloc) + PS_REJECT_PIXEL_INITIAL_PIXEL_LIST_LENGTH_INC)); + // XXX: Can the realloc() fail? Must we check for NULL? + } + + ((psPixels *) rejects->data[im])->data[ptr].x = (pixelList->data[p]).x; + ((psPixels *) rejects->data[im])->data[ptr].y = (pixelList->data[p]).y; + (rPtr->data.S32[im])++; + // XXX: this pixel ->n increment is wierd + (((psPixels *) rejects->data[im])->n)++; + } + } + } + + psFree(maskImage); + psFree(maskImageF32); + psFree(transformedImage); + } + + psFree(inCoords); + psFree(outCoords); + psTrace("ImageCombine.pmRejectPixels", 3, "Exiting pmRejectPixels()\n"); + return(rejects); +} Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/imcombine/pmImageCombine.h =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/imcombine/pmImageCombine.h (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/imcombine/pmImageCombine.h (revision 21664) @@ -0,0 +1,50 @@ +/** @file pmImageCombine.h + * + * This file will perform image combination of several images of the + * same field, produce a list of questionable pixels, then tag some + * of those pixels as cosmic rays. + * + * @author Paul Price, IfA (original prototype) + * @author GLG, MHPCC + * + * @version $Revision: 1.1 $ $Name: not supported by cvs2svn $ + * @date $Date: 2005-09-28 20:43:52 $ + * + * Copyright 2004 Maui High Performance Computing Center, University of Hawaii + * + */ + +#if !defined(PM_IMAGE_COMBINE_H) +#define PM_IMAGE_COMBINE_H + +#if HAVE_CONFIG_H +#include +#endif + +#include +#include +#include "pslib.h" + +psImage *pmCombineImages( + psImage *combine, ///< Combined image (output) + psArray **questionablePixels, ///< Array of rejection masks + const psArray *images, ///< Array of input images + const psArray *errors, ///< Array of input error images + const psArray *masks, ///< Array of input masks + psU32 maskVal, ///< Mask value + const psPixels *pixels, ///< Pixels to combine + psS32 numIter, ///< Number of rejection iterations + psF32 sigmaClip, ///< Number of standard deviations at which to reject + const psStats *stats ///< Statistics to use in the combination +); + +psArray *pmRejectPixels( + const psArray *images, ///< Array of input images + const psArray *masks, ///< Array of input image masks + const psArray *errors, ///< The pixels which were rejected in the combination + const psArray *inToOut, ///< Transformation from input to output system + const psArray *outToIn, ///< Transformation from output to input system + psF32 rejThreshold, ///< Rejection threshold + psF32 gradLimit ///< Gradient limit +); +#endif Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/imcombine/pmReadoutCombine.c =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/imcombine/pmReadoutCombine.c (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/imcombine/pmReadoutCombine.c (revision 21664) @@ -0,0 +1,734 @@ +/** @file pmReadoutCombine.c + * + * This file will contain a module which will combine multiple readout images. + * + * @author GLG, MHPCC + * + * @version $Revision: 1.2.10.3 $ $Name: not supported by cvs2svn $ + * @date $Date: 2006-02-17 02:47:26 $ + * + * Copyright 2004 Maui High Performance Computing Center, University of Hawaii + * + */ + +#include +#include +#include "pslib.h" +#include "pmReadoutCombine.h" + +/****************************************************************************** +DetermineNumBits(data): This routine takes an enum psStatsOptions as an +argument and returns the number of non-zero bits. + *****************************************************************************/ +static psS32 DetermineNumBits(psStatsOptions data) +{ + psS32 i; + psU64 tmpData = data; + psS32 numBits = 0; + + for (i=0;i<(8 * sizeof(psStatsOptions));i++) { + if (0x0001 & tmpData) { + numBits++; + } + tmpData = tmpData >> 1; + } + return(numBits); +} + +static void pmCombineParamsFree (pmCombineParams *params) +{ + + if (params == NULL) + return; + + psFree (params->stats); + return; +} + +pmCombineParams *pmCombineParamsAlloc (psStatsOptions statsOptions) +{ + + pmCombineParams *params = psAlloc (sizeof(pmCombineParams)); + psMemSetDeallocator(params, (psFreeFunc) pmCombineParamsFree); + + params->stats = psStatsAlloc (statsOptions); + params->maskVal = 0; + params->fracHigh = 0.25; + params->fracHigh = 0.25; + params->nKeep = 3; + + return (params); +} + +/****************************************************************************** +XXX: Must add support for S16 and S32 types. F32 currently supported. + *****************************************************************************/ +psImage *pmReadoutCombine(psImage *output, + const psArray *inputs, + const psVector *zero, + const psVector *scale, + pmCombineParams *params, + bool applyZeroScale, + psF32 gain, + psF32 readnoise) +{ + PS_ASSERT_PTR_NON_NULL(inputs, NULL); + PS_ASSERT_PTR_NON_NULL(params, NULL); + PS_ASSERT_PTR_NON_NULL(params->stats, NULL); + if (zero != NULL) { + PS_ASSERT_VECTOR_TYPE(zero, PS_TYPE_F32, NULL); + // PS_ASSERT_VECTOR_TYPE_S16_S32_F32(zero, NULL); + } + if (scale != NULL) { + PS_ASSERT_VECTOR_TYPE(scale, PS_TYPE_F32, NULL); + // PS_ASSERT_VECTOR_TYPE_S16_S32_F32(scale, NULL); + } + if ((zero != NULL) && (scale != NULL)) { + PS_ASSERT_VECTOR_TYPE_EQUAL(zero, scale, NULL); + // PS_ASSERT_VECTOR_TYPE_S16_S32_F32(scale, NULL); + } + + psStats *stats = params->stats; + psS32 maxInputCols = 0; + psS32 maxInputRows = 0; + psS32 minInputCols = PS_MAX_S32; + psS32 minInputRows = PS_MAX_S32; + pmReadout *tmpReadout = NULL; + psS32 tmpI; + psElemType outputType = PS_TYPE_F32; + + if (DetermineNumBits(stats->options) != 1) { + psError(PS_ERR_UNKNOWN, true, + "Multiple statistical options have been requested. Returning NULL.\n"); + return(NULL); + } + + // We step through each readout in the input image list. If any readout is + // NULL, empty, or has the wrong type, we generate an error and return + // NULL. We determine how big of an output image is needed to combine + // these input images. We do this by taking the + // max(readout->col0 + readout->numCols + image->col0 + image->numCols) + // max(readout->row0 + readout->numRows + image->row0 + image->numRows) + // + for (int i = 0; i < inputs->n; i++) { + tmpReadout = inputs->data[i]; + PS_ASSERT_READOUT_NON_NULL(tmpReadout, output); + PS_ASSERT_READOUT_NON_EMPTY(tmpReadout, output); + PS_ASSERT_READOUT_TYPE(tmpReadout, PS_TYPE_F32, output); + + minInputRows = PS_MIN(minInputRows, (tmpReadout->row0 + tmpReadout->image->row0)); + tmpI = tmpReadout->row0 + + tmpReadout->image->row0 + + tmpReadout->image->numRows; + maxInputRows = PS_MAX(maxInputRows, tmpI); + + minInputCols = PS_MIN(minInputCols, (tmpReadout->col0 + tmpReadout->image->col0)); + tmpI = tmpReadout->col0 + + tmpReadout->image->col0 + + tmpReadout->image->numCols; + maxInputCols = PS_MAX(maxInputCols, tmpI); + } + + // We ensure that the zero vector is of the proper size. + if (zero != NULL) { + PS_ASSERT_VECTOR_TYPE(zero, PS_TYPE_F32, NULL); + if (zero->n < inputs->n) { + psError(PS_ERR_UNKNOWN, true, "zero vector has incorrect size (%d). Returning NULL.\n", zero->n); + return(NULL); + } else if (zero->n > inputs->n) { + // XXX EAM : abort on this condition? is probably an error + psLogMsg(__func__, PS_LOG_WARN, + "WARNING: the zero vector too many elements (%d)\n", zero->n); + } + } + + // We ensure that the scale vector is of the proper size. + if (scale != NULL) { + PS_ASSERT_VECTOR_TYPE(scale, PS_TYPE_F32, NULL); + if (scale->n < inputs->n) { + psError(PS_ERR_UNKNOWN, true, "scale vector has incorrect size (%d). Returning NULL.\n", scale->n); + return(NULL); + } else if (scale->n > inputs->n) { + // XXX EAM : abort on this condition? is probably an error + psLogMsg(__func__, PS_LOG_WARN, + "WARNING: the scale vector has too many elements (%d)\n", scale->n); + } + } + + // At this point, the following variables have been computed: + // maxInputRows: the largest input row value, in output image space. + // maxInputCols: the largest input column value, in output image space. + // minInputRows: the smallest input row value, in output image space. + // minInputCols: the smallest input column value, in output image space. + // + if (output == NULL) { + output = psImageAlloc(maxInputCols-minInputCols, maxInputRows-minInputRows, outputType); + *(psS32 *) &(output->col0) = minInputCols; + *(psS32 *) &(output->row0) = minInputRows; + } else { + + // XXX EAM : recycle the existing output image? why would we care about the existing pixels? + PS_ASSERT_IMAGE_TYPE(output, PS_TYPE_F32, NULL); + if (((output->col0 + output->numCols) < maxInputCols) || + ((output->row0 + output->numRows) < maxInputRows)) { + psError(PS_ERR_UNKNOWN, true, + "Output image (%d, %d) is too small to hold combined images. Returning NULL.\n", + output->row0 + output->numRows, + output->col0 + output->numCols); + return(NULL); + } + + // reset output origin using logic of above + *(psS32 *) &(output->col0) = minInputCols; + *(psS32 *) &(output->row0) = minInputRows; + } + + psVector *tmpPixels = psVectorAlloc(inputs->n, PS_TYPE_F32); + psVector *tmpPixelsKeep = psVectorAlloc(inputs->n, PS_TYPE_F32); + psVector *outRowLower = psVectorAlloc(inputs->n, PS_TYPE_U32); + psVector *outRowUpper = psVectorAlloc(inputs->n, PS_TYPE_U32); + psVector *outColLower = psVectorAlloc(inputs->n, PS_TYPE_U32); + psVector *outColUpper = psVectorAlloc(inputs->n, PS_TYPE_U32); + + // For each input readout, we store the min/max pixel indices for that readout, in detector coordinates, + // in the psVectors (outRowLower, outColLower, outRowUpper, outColUpper). + for (int i = 0; i < inputs->n; i++) { + tmpReadout = (pmReadout *) inputs->data[i]; + outRowLower->data.U32[i] = tmpReadout->row0 + tmpReadout->image->row0; + outColLower->data.U32[i] = tmpReadout->col0 + tmpReadout->image->col0; + outRowUpper->data.U32[i] = tmpReadout->row0 + + tmpReadout->image->row0 + + tmpReadout->image->numRows; + outColUpper->data.U32[i] = tmpReadout->col0 + + tmpReadout->image->col0 + + tmpReadout->image->numCols; + } + + // We loop through each pixel in the output image. We loop through each + // input readout. We determine if that output pixel is contained in the + // image from that readout. If so, we save it in psVector tmpPixels. + // If not, we set a mask for that element in tmpPixels. Then, we mask off + // pixels not between fracLow and fracHigh. Then we call the vector + // stats routine on those pixels/mask. Then we set the output pixel value + // to the result of the stats call. + + int nx, ny; + int nKeep, nMin; + float keepFrac = 1.0 - params->fracLow - params->fracHigh; + float value = 0; + psF32 *saveVector = tmpPixelsKeep->data.F32; + + for (int j = output->row0; j < (output->row0 + output->numRows) ; j++) { + if (j % 10 == 0) + fprintf (stderr, "."); + for (int i = output->col0; i < (output->col0 + output->numCols) ; i++) { + int nPix = 0; + for (int r = 0; r < inputs->n; r++) { + tmpReadout = (pmReadout *) inputs->data[r]; + + // psTrace (__func__, 6, "[%d][%d]: [%d][%d] to [%d][%d]\n", i, j, outColLower->data.U32[r], outRowLower->data.U32[r], outColUpper->data.U32[r], outRowUpper->data.U32[r]); + if (i < outColLower->data.U32[r]) + continue; + if (i >= outColUpper->data.U32[r]) + continue; + if (j < outRowLower->data.U32[r]) + continue; + if (j >= outRowUpper->data.U32[r]) + continue; + + nx = i - (tmpReadout->col0 + tmpReadout->image->col0); + ny = j - (tmpReadout->row0 + tmpReadout->image->row0); + + if (tmpReadout->mask != NULL) { + if (tmpReadout->mask->data.U8[ny][nx] && params->maskVal) + continue; + } + + tmpPixels->data.F32[nPix] = tmpReadout->image->data.F32[ny][nx]; + // psTrace (__func__, 6, "readout[%d], image [%d][%d] is %f\n", r, i, j, tmpPixels->data.F32[nPix]); + nPix ++; + } + tmpPixels->n = nPix; + + // are there enough valid pixels to apply fracLow,fracHigh? + nKeep = nPix * keepFrac; + if (nKeep >= params->nKeep) { + psVectorSort (tmpPixels, tmpPixels); + nMin = nPix * params->fracLow; + tmpPixelsKeep->data.F32 = &tmpPixels->data.F32[nMin]; + tmpPixelsKeep->n = nKeep; + } else { + tmpPixelsKeep->data.F32 = tmpPixels->data.F32; + tmpPixelsKeep->n = nPix; + } + + // tmpPixelsKeep is already sorted. sample mean and median are very easy + if (stats->options & PS_STAT_SAMPLE_MEAN) { + value = 0; + for (int r = 0; r < tmpPixelsKeep->n; r++) { + value += tmpPixelsKeep->data.F32[r]; + } + if (tmpPixelsKeep->n == 0) { + value = 0; + } else { + value = value / tmpPixelsKeep->n; + } + } + if (stats->options & PS_STAT_SAMPLE_MEDIAN) { + int r = tmpPixelsKeep->n / 2; + if (tmpPixelsKeep->n == 0) { + value = 0; + goto got_value; + } + if (tmpPixelsKeep->n % 2 == 1) { + int r = 0.5*tmpPixelsKeep->n; + value = tmpPixelsKeep->data.F32[r]; + goto got_value; + } + if (tmpPixelsKeep->n % 2 == 0) { + value = 0.5*(tmpPixelsKeep->data.F32[r] + + tmpPixelsKeep->data.F32[r-1]); + goto got_value; + } + } +got_value: + output->data.F32[j-output->row0][i-output->col0] = value; + } + } + tmpPixelsKeep->data.F32 = saveVector; + + psFree(tmpPixels); + psFree(tmpPixelsKeep); + psFree(outRowLower); + psFree(outRowUpper); + psFree(outColLower); + psFree(outColUpper); + + return(output); +} + +/****************************************************************************** +XXX: Must add support for S16 and S32 types. F32 currently supported. + *****************************************************************************/ +psImage *pmReadoutCombine_OLD(psImage *output, + const psList *inputs, + pmCombineParams *params, + const psVector *zero, + const psVector *scale, + bool applyZeroScale, + psF32 gain, + psF32 readnoise) +{ + PS_ASSERT_PTR_NON_NULL(inputs, NULL); + PS_ASSERT_PTR_NON_NULL(params, NULL); + PS_ASSERT_PTR_NON_NULL(params->stats, NULL); + if (zero != NULL) { + PS_ASSERT_VECTOR_TYPE(zero, PS_TYPE_F32, NULL); + // PS_ASSERT_VECTOR_TYPE_S16_S32_F32(zero, NULL); + } + if (scale != NULL) { + PS_ASSERT_VECTOR_TYPE(scale, PS_TYPE_F32, NULL); + // PS_ASSERT_VECTOR_TYPE_S16_S32_F32(scale, NULL); + } + if ((zero != NULL) && (scale != NULL)) { + PS_ASSERT_VECTOR_TYPE_EQUAL(zero, scale, NULL); + // PS_ASSERT_VECTOR_TYPE_S16_S32_F32(scale, NULL); + } + + psStats *stats = params->stats; + psS32 i; + psS32 j; + psS32 maxInputCols = 0; + psS32 maxInputRows = 0; + psS32 minInputCols = PS_MAX_S32; + psS32 minInputRows = PS_MAX_S32; + psListElem *tmpInput = NULL; + pmReadout *tmpReadout = NULL; + psS32 numInputs = 0; + psS32 tmpI; + psElemType outputType = PS_TYPE_F32; + + if (1 < DetermineNumBits(params->stats->options)) { + psError(PS_ERR_UNKNOWN, true, + "Multiple statistical options have been requested. Returning NULL.\n"); + return(NULL); + } + + // + // We step through each readout in the input image list. If any readout is + // NULL, empty, or has the wrong type, we generate an error and return + // NULL. We determine how big of an output image is needed to combine + // these input images. We do this by taking the + // max(readout->col0 + readout->numCols + image->col0 + image->numCols) + // max(readout->row0 + readout->numRows + image->row0 + image->numRows) + // We then compare that to + // output->col0 + output->numCols + // output->row0 + output->numRows + // to determine if the output image actually stores that pixel. A similar + // thing is done for the minimum row and column. + // + tmpInput = (psListElem *) inputs->head; + while (NULL != tmpInput) { + tmpReadout = (pmReadout *) tmpInput->data; + PS_ASSERT_READOUT_NON_NULL(tmpReadout, output); + PS_ASSERT_READOUT_NON_EMPTY(tmpReadout, output); + PS_ASSERT_READOUT_TYPE(tmpReadout, PS_TYPE_F32, output); + + outputType = tmpReadout->image->type.type; + + minInputRows = PS_MIN(minInputRows, + (tmpReadout->row0 + tmpReadout->image->row0)); + tmpI = tmpReadout->row0 + + tmpReadout->image->row0 + + tmpReadout->image->numRows; + maxInputRows = PS_MAX(maxInputRows, tmpI); + + minInputCols = PS_MIN(minInputCols, + (tmpReadout->col0 + tmpReadout->image->col0)); + tmpI = tmpReadout->col0 + + tmpReadout->image->col0 + + tmpReadout->image->numCols; + maxInputCols = PS_MAX(maxInputCols, tmpI); + tmpInput = tmpInput->next; + numInputs++; + } + + // We ensure that the zero vector is of the proper size. + if (zero != NULL) { + PS_ASSERT_VECTOR_TYPE(zero, PS_TYPE_F32, NULL); + if (numInputs > zero->n) { + psError(PS_ERR_UNKNOWN, true, "zero vector has incorrect size (%d). Returning NULL.\n", zero->n); + return(NULL); + } else if (numInputs < zero->n) { + psLogMsg(__func__, PS_LOG_WARN, + "WARNING: the zero vector too many elements (%d)\n", zero->n); + } + } + + // We ensure that the scale vector is of the proper size. + if (scale != NULL) { + PS_ASSERT_VECTOR_TYPE(scale, PS_TYPE_F32, NULL); + if (numInputs > scale->n) { + psError(PS_ERR_UNKNOWN, true, "scale vector has incorrect size (%d). Returning NULL.\n", scale->n); + return(NULL); + } else if (numInputs < scale->n) { + psLogMsg(__func__, PS_LOG_WARN, + "WARNING: the scale vector has too many elements (%d)\n", scale->n); + } + } + + // At this point, the following variables have been computed: + // maxInputRows: the largest input row value, in output image space. + // maxInputCols: the largest input column value, in output image space. + // minInputRows: the smallest input row value, in output image space. + // minInputCols: the smallest input column value, in output image space. + // + if (output == NULL) { + output = psImageAlloc(maxInputCols-minInputCols, + maxInputRows-minInputRows, outputType); + *(psS32 *) &(output->col0) = minInputCols; + *(psS32 *) &(output->row0) = minInputRows; + } else { + PS_ASSERT_IMAGE_TYPE(output, PS_TYPE_F32, NULL); + if (((output->col0 + output->numCols) < maxInputCols) || + ((output->row0 + output->numRows) < maxInputRows)) { + psError(PS_ERR_UNKNOWN, true, + "Output image (%d, %d) is too small to hold combined images. Returning NULL.\n", + output->row0 + output->numRows, + output->col0 + output->numCols); + return(NULL); + } + + if ((output->col0 > minInputCols) || (output->row0 > minInputRows)) { + psError(PS_ERR_UNKNOWN, true, + "Output image offset is larger then input image offset. Returning NULL.\n"); + return(NULL); + } + } + + psVector *tmpPixels = psVectorAlloc(numInputs, PS_TYPE_F32); + psVector *tmpPixelErrors = psVectorAlloc(numInputs, PS_TYPE_F32); + psVector *tmpPixelMask = psVectorAlloc(numInputs, PS_TYPE_U8); + psVector *tmpPixelMaskNKeep = psVectorAlloc(numInputs, PS_TYPE_U8); + psVector *outRowLower = psVectorAlloc(numInputs, PS_TYPE_U32); + psVector *outRowUpper = psVectorAlloc(numInputs, PS_TYPE_U32); + psVector *outColLower = psVectorAlloc(numInputs, PS_TYPE_U32); + psVector *outColUpper = psVectorAlloc(numInputs, PS_TYPE_U32); + pmReadout **tmpReadouts = (pmReadout **) psAlloc(numInputs * sizeof(pmReadout *)); + + // For each input readout, we create a pointer to that readout in + // "tmpReadouts[]", and we store the min/max pixel indices for that + // readout, in output image coordinates, in the psVectors + // (outRowLower, outColLower, outRowUpper, outColUpper). + i = 0; + tmpInput = (psListElem *) inputs->head; + while (NULL != tmpInput) { + tmpReadouts[i] = (pmReadout *) tmpInput->data; + outRowLower->data.U32[i] = tmpReadouts[i]->row0 + tmpReadouts[i]->image->row0; + outColLower->data.U32[i] = tmpReadouts[i]->col0 + tmpReadouts[i]->image->col0; + outRowUpper->data.U32[i] = tmpReadouts[i]->row0 + + tmpReadouts[i]->image->row0 + + tmpReadouts[i]->image->numRows; + outColUpper->data.U32[i] = tmpReadouts[i]->col0 + + tmpReadouts[i]->image->col0 + + tmpReadouts[i]->image->numCols; + tmpInput = tmpInput->next; + i++; + } + + // We loop through each pixel in the output image. We loop through each + // input readout. We determine if that output pixel is contained in the + // image from that readout. If so, we save it in psVector tmpPixels. + // If not, we set a mask for that element in tmpPixels. Then, we mask off + // pixels not between fracLow and fracHigh. Then we call the vector + // stats routine on those pixels/mask. Then we set the output pixel value + // to the result of the stats call. + + for (i = output->row0; i < (output->row0 + output->numRows) ; i++) { + for (j = output->col0; j < (output->col0 + output->numCols) ; j++) { + for (psS32 r = 0; r < numInputs ; r++) { + // printf("[%d][%d]: [%d][%d] to [%d][%d]\n", i, j, outRowLower->data.U32[r], outColLower->data.U32[r], outRowUpper->data.U32[r], outColUpper->data.U32[r]); + if ((outRowLower->data.U32[r] <= i) && + (outColLower->data.U32[r] <= j) && + (outRowUpper->data.U32[r] > i) && + (outColUpper->data.U32[r] > j)) { + + psS32 imageRow = i - (tmpReadouts[r]->row0 + + tmpReadouts[r]->image->row0); + psS32 imageCol = j - (tmpReadouts[r]->col0 + + tmpReadouts[r]->image->col0); + + if ((NULL == tmpReadouts[r]->mask) || + !(params->maskVal && tmpReadouts[r]->mask->data.U8[imageRow][imageCol])) { + tmpPixels->data.F32[r] = tmpReadouts[r]->image->data.F32[imageRow][imageCol]; + tmpPixelMask->data.U8[r] = 0; + } else { + tmpPixels->data.F32[r] = 0.0; + tmpPixelMask->data.U8[r] = 1; + } + } else { + tmpPixels->data.F32[r] = 0.0; + tmpPixelMask->data.U8[r] = 1; + } + // printf("readout[%d], image [%d][%d] is %f\n", r, i, j, tmpPixels->data.F32[r]); + } + // At this point, we have scanned all input readouts for this + // one output pixel. + // for (psS32 r = 0; r < numInputs ; r++) printf("(0)tmpPixels->data.F32[%d] is %f\n", r, tmpPixels->data.F32[r]); + + // Determine how many pixels lie between fracLow and fracHigh. + psS32 pixelCount = 0; + for (psS32 r = 0; r < numInputs ; r++) { + if (tmpPixelMask->data.U8[r] == 0) { + if ((params->fracLow <= tmpPixels->data.F32[r]) && + (params->fracHigh >= tmpPixels->data.F32[r])) { + pixelCount++; + } + } + } + + // If more than params->nKeep pixels lie between the valid range, + // then loop through the pixels, and mask away any pixels outside + // that range. + if (pixelCount >= params->nKeep) { + for (psS32 r = 0; r < numInputs ; r++) { + if (tmpPixelMask->data.U8[r] == 0) { + if ((params->fracLow <= tmpPixels->data.F32[r]) && + (params->fracHigh >= tmpPixels->data.F32[r])) { + tmpPixelMaskNKeep->data.U8[r] = 0; + } else { + tmpPixelMaskNKeep->data.U8[r] = 1; + } + } + } + } + + if ((gain > 0.0) && (readnoise >= 0.0)) { + psF32 x; + psF32 sigma; + if (applyZeroScale == true) { + for (psS32 r = 0; r < numInputs ; r++) { + if (zero != NULL) { + x = zero->data.F32[r]; + } else { + x = 0.0; + } + if (scale != NULL) { + x+= tmpPixels->data.F32[r] * scale->data.F32[r]; + } else { + x+= tmpPixels->data.F32[r]; + } + sigma = sqrtf((readnoise*readnoise) + gain * x) / gain; + + tmpPixelErrors->data.F32[r] = sigma; + tmpPixels->data.F32[r]= x; + } + } else { + for (psS32 r = 0; r < numInputs ; r++) { + x= tmpPixels->data.F32[r]; + + if (zero != NULL) { + sigma = zero->data.F32[r]; + } else { + sigma = 0.0; + } + if (scale != NULL) { + sigma+= tmpPixels->data.F32[r] * scale->data.F32[r]; + } else { + sigma+= tmpPixels->data.F32[r]; + } + sigma = sqrtf((readnoise*readnoise) + (gain * sigma)) / gain; + + tmpPixelErrors->data.F32[r] = sigma; + tmpPixels->data.F32[r]= x; + } + } + // Calculate the specified statistic on the stack of pixels. + // for (psS32 r = 0; r < numInputs ; r++) printf("(1)tmpPixels->data.F32[%d] is %f\n", r, tmpPixels->data.F32[r]); + psStats *rc = psVectorStats(stats, + tmpPixels, + tmpPixelErrors, + tmpPixelMaskNKeep, + 1); + if (rc == NULL) { + psError(PS_ERR_UNKNOWN, false, "psVectorStats(): could not perform requested statistical operation. Returning NULL.\n"); + return(NULL); + } + } else { + if (scale != NULL) { + for (psS32 r = 0; r < numInputs ; r++) { + tmpPixels->data.F32[r]*= scale->data.F32[r]; + } + } + + // We add the zero vector, if non-NULL. + if (zero != NULL) { + for (psS32 r = 0; r < numInputs ; r++) { + tmpPixels->data.F32[r]+= zero->data.F32[r]; + } + } + + // Calculate the specified statistic on the stack of pixels. + // for (psS32 r = 0; r < numInputs ; r++) printf("(2)tmpPixels->data.F32[%d] is %f\n", r, tmpPixels->data.F32[r]); + psStats *rc = psVectorStats(stats, + tmpPixels, + NULL, + tmpPixelMaskNKeep, + 1); + if (rc == NULL) { + psError(PS_ERR_UNKNOWN, false, "psVectorStats(): could not perform requested statistical operation. Returning NULL.\n"); + return(NULL); + } + } + + + // Set the pixel value in the output image to the stat value. + double statValue; + if (!p_psGetStatValue(stats, &statValue)) { + psError(PS_ERR_UNKNOWN, true, "Could not determine stats value. Returning NULL.\n"); + return(NULL); + } else { + output->data.F32[i-output->row0][j-output->col0] = (psF32) statValue; + } + } + } + + psFree(tmpPixels); + psFree(tmpPixelErrors); + psFree(tmpPixelMask); + psFree(tmpPixelMaskNKeep); + psFree(outRowLower); + psFree(outRowUpper); + psFree(outColLower); + psFree(outColUpper); + psFree(tmpReadouts); + + return(output); +} + + +/* This function measures the robust median at each of the minimum and maximum + * coordinates and determines the difference and mean of the two values. The size + * of the box used to make the measurement at each point is specified by the + * configuration variable FRINGE_SQUARE_RADIUS. From the collection of + * differences, the robust median is calculated, and returned as part of the + * fringe statistics. For each fringe point, the values of delta and midValue are + * also assigned and available to the user on return. + */ + +psStats *pmFringeStats( + psArray *fringePoints, + psImage *image, + psMetadata *config) +{ + PS_ASSERT_PTR_NON_NULL(fringePoints, NULL); + // for (psS32 i = 0 ; i < fringePoints->n ; i++) { + // if (!psMemCheckFringePoint((pmFringePoint *) fringePoints->data[i])) { + // psError(PS_ERR_UNKNOWN, true, "fringePoints->data[%d] is not of type pmFringePoint.\n"); + // return(NULL); + // } + // } + PS_ASSERT_IMAGE_NON_NULL(image, NULL); + PS_ASSERT_IMAGE_NON_EMPTY(image, NULL); + PS_ASSERT_IMAGE_TYPE(image, PS_TYPE_F32, NULL); + PS_ASSERT_PTR_NON_NULL(config, NULL); + + psBool rc; + psF32 frSquareRadius = psMetadataLookupF32(&rc, config, "FRINGE_SQUARE_RADIUS"); + if (!rc) { + psError(PS_ERR_UNKNOWN, true, "Could not determing the fringe radius from the metadata.\n"); + } + + psRegion minRegion; + psRegion maxRegion; + psStats *minStats = psStatsAlloc(PS_STAT_ROBUST_MEDIAN); + psStats *maxStats = psStatsAlloc(PS_STAT_ROBUST_MEDIAN); + psStats *diffStats = psStatsAlloc(PS_STAT_ROBUST_MEDIAN); + psVector *diffs = psVectorAlloc(fringePoints->n, PS_TYPE_F32); + + // + // Loop through each fringe point. Determine the robust mean around + // the min and max for that fringe point. Save the difference between + // those two numbers in psVector diffs. + // + // XXX: Ensure you have the radius correct. (add 1 to x1 and y1?) + // + for (psS32 i = 0 ; i < fringePoints->n ; i++) { + pmFringePoint *fp = (pmFringePoint *) fringePoints->data[i]; + minRegion.x0 = fp->xMin - frSquareRadius; + minRegion.x1 = fp->xMin + frSquareRadius; + minRegion.y0 = fp->yMin - frSquareRadius; + minRegion.y1 = fp->yMin + frSquareRadius; + psImage *minSubImage = psImageSubset(image, minRegion); + minStats = psImageStats(minStats, minSubImage, NULL, 0); + + maxRegion.x0 = fp->xMax - frSquareRadius; + maxRegion.x1 = fp->xMax + frSquareRadius; + maxRegion.y0 = fp->yMax - frSquareRadius; + maxRegion.y1 = fp->yMax + frSquareRadius; + psImage *maxSubImage = psImageSubset(image, maxRegion); + maxStats = psImageStats(maxStats, maxSubImage, NULL, 0); + + if ((minStats == NULL) || (maxStats == NULL)) { + psError(PS_ERR_UNKNOWN, true, "Could not determine robust mean on subimage.\n"); + psFree(minStats); + psFree(maxStats); + return(NULL); + } + + fp->midValue = 0.5 * (maxStats->robustMedian + minStats->robustMedian); + fp->delta = maxStats->robustMedian - minStats->robustMedian; + diffs->data.F32[i] = fp->delta; + } + psFree(minStats); + psFree(maxStats); + + diffStats = psVectorStats(diffStats, diffs, NULL, NULL, 0); + psFree(diffs); + if (diffStats == NULL) { + psError(PS_ERR_UNKNOWN, true, "Could not determine robust median of the differences.\n"); + return(NULL); + } + return(diffStats); +} + Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/imcombine/pmReadoutCombine.h =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/imcombine/pmReadoutCombine.h (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/imcombine/pmReadoutCombine.h (revision 21664) @@ -0,0 +1,76 @@ +/** @file pmReadoutCombine.h + * + * This file will contain a module which will combine multiple readout images. + * + * @author GLG, MHPCC + * + * @version $Revision: 1.2.10.2 $ $Name: not supported by cvs2svn $ + * @date $Date: 2006-01-20 02:38:28 $ + * + * Copyright 2004 Maui High Performance Computing Center, University of Hawaii + * + */ + +#if !defined(PM_READOUT_COMBINE_H) +#define PM_READOUT_COMBINE_H + +#if HAVE_CONFIG_H +#include +#endif + +#include +#include +#include "pslib.h" +#include "psConstants.h" +#include "pmFPA.h" + +typedef struct +{ + psStats *stats; + unsigned int maskVal; + float fracHigh; + float fracLow; + int nKeep; +} +pmCombineParams; + +pmCombineParams *pmCombineParamsAlloc (psStatsOptions statsOptions); + +psImage *pmReadoutCombine(psImage *output, + const psArray *inputs, + const psVector *zero, + const psVector *scale, + pmCombineParams *params, + bool applyZeroScale, + float gain, + float readnoise); + +/** + * + * This function measures the robust median at each of the minimum and maximum + * coordinates and determines the difference and mean of the two values. The size + * of the box used to make the measurement at each point is specified by the + * configuration variable FRINGE_SQUARE_RADIUS. From the collection of + * differences, the robust median is calculated, and returned as part of the + * fringe statistics. For each fringe point, the values of delta and midValue are + * also assigned and available to the user on return. + * + */ +psStats *pmFringeStats( + psArray *fringePoints, + psImage *image, + psMetadata *config +); + +typedef struct +{ + psF64 xMin; + psF64 yMin; + psF64 xMax; + psF64 yMax; + psF64 delta; + psF64 midValue; +} +pmFringePoint; + +#endif Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/imsubtract/.cvsignore =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/imsubtract/.cvsignore (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/imsubtract/.cvsignore (revision 21664) @@ -0,0 +1,6 @@ +.deps +.libs +Makefile +Makefile.in +*.la +*.lo Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/imsubtract/Makefile.am =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/imsubtract/Makefile.am (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/imsubtract/Makefile.am (revision 21664) @@ -0,0 +1,13 @@ +noinst_LTLIBRARIES = libpsmoduleimsubtract.la + +libpsmoduleimsubtract_la_CPPFLAGS = $(SRCINC) $(PSMODULE_CFLAGS) +libpsmoduleimsubtract_la_LDFLAGS = -release $(PACKAGE_VERSION) +libpsmoduleimsubtract_la_SOURCES = pmImageSubtract.c \ + pmSubtractBias.c +# pmSubtractSky.c + +psmoduleincludedir = $(includedir) +psmoduleinclude_HEADERS = \ + pmImageSubtract.h \ + pmSubtractBias.h +# pmSubtractSky.h Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/imsubtract/pmImageSubtract.c =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/imsubtract/pmImageSubtract.c (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/imsubtract/pmImageSubtract.c (revision 21664) @@ -0,0 +1,1390 @@ +/** @file ImageSubtract.c + * + * This file will contain code which creates a set of kernel basis + * functions, solves for their solution, and applies them to an image. + * + * @author Paul Price, IfA (original prototype) + * @author GLG, MHPCC + * + * @version $Revision: 1.1 $ $Name: not supported by cvs2svn $ + * @date $Date: 2005-09-28 20:43:52 $ + * + * Copyright 2004 Maui High Performance Computing Center, University of Hawaii + * + * XXX: sync with IfA on this: + * The (x, y) (row, col) issue is becoming a problem. In this file, and I + * think, the rest of psLib and psModules, the following conventions are used: + * + * 1) x will correspond to the column, and y will correspond to the row. + * 2) When used in function prototypes, the column (and hence x) appears + * first. + * 3) When used to index 2-D arrays, obviously, the row (and hence, y) + * appears first. (2 and 3 are the source of confusion). + * 4) When (u, v) are used in certain structures. + * u corresponds to x + * v corresponds to y + * 5) When element (a, b) is casually referred to in comments, or + * documentation it is unclear where a is the row, or the column. + * 6) A convention on loop index variables (i, j) would be convenient. + * Currently, sometimes i corresponds to the column (x), + * usually it corresponds to the row (y). + * + * XXX: The following variables are used an interpreted this way: + * kernelSize: Means that the actual kernel is a square (1 + 2 * kernelSize) per side. + * border: When accessing an image, a swath of pixels this wide is ignored. + * footprint: When accessing a stample, a square of pixels, footprint pixels per side, + * are looked at. We must ensure that (footprint+kernelSize) pixels exist + * around the center. + */ + +#include +#include +#include "pslib.h" +#include "psConstants.h" +#include "pmImageSubtract.h" + +/******************************************************************************* + Private alloc/free functions. +XXX: It's not clear if the SubtractionKernels alloc/free functions are feasable. + ******************************************************************************/ +void p_pmStampFree(pmStamp *stamp) +{ + psFree(stamp->matrix); + psFree(stamp->vector); +} + +pmStamp *p_pmStampAlloc(pmStampStatus status) +{ + pmStamp *stamp = (pmStamp*)psAlloc(sizeof(pmStamp)); + stamp->x = 0; + stamp->p_xSize = 0; + stamp->y = 0; + stamp->p_ySize = 0; + stamp->matrix = NULL; + stamp->vector = NULL; + stamp->status = status; + + psMemSetDeallocator(stamp, (psFreeFunc)p_pmStampFree); + + return(stamp); +} + +void p_pmSubtractionKernelsFree(psSubtractionKernels *kernels) +{ + psFree(kernels->u); + psFree(kernels->v); + psFree(kernels->sigma); + psFree(kernels->xOrder); + psFree(kernels->yOrder); + psFree(kernels->preCalc); + + psFree(kernels); +} + +psSubtractionKernels *p_pmSubtractionKernelsAlloc(int numBasisFunctions, + pmSubtractionKernelsType type) +{ + psSubtractionKernels *tmp = (psSubtractionKernels *) psAlloc(sizeof(psSubtractionKernels)); + + tmp->type = type; + psMemSetDeallocator(tmp, (psFreeFunc) p_pmSubtractionKernelsFree); + return(tmp); +} + +/******************************************************************************* +psSubtractionKernels struct. + ******************************************************************************/ +psSubtractionKernels *pmSubtractionKernelsAllocPOIS(int size, + int spatialOrder) +{ + psTrace("ImageSubtract.pmSubtractionKernelsAllocPOIS", 3, + "Calling pmSubtractionKernelsAllocPOIS(%d, %d)\n", size, spatialOrder); + PS_ASSERT_INT_POSITIVE(size, NULL); + PS_ASSERT_INT_POSITIVE(spatialOrder, NULL); + // + // Calculate the number of basis functions (nBF) + // + psS32 xKernelHalfSize = size; + psS32 yKernelHalfSize = size; + psS32 nBF = (2 * xKernelHalfSize + 1) * + (2 * yKernelHalfSize + 1) * + (spatialOrder + 1) * + (spatialOrder + 2) / 2; + + // + // Generate the new psSubtractionKernels data structure: + // + psSubtractionKernels *tmp = (psSubtractionKernels *) psAlloc(sizeof(psSubtractionKernels)); + tmp->type = PM_SUBTRACTION_KERNEL_POIS; + tmp->u = psVectorAlloc(nBF, PS_TYPE_F32); + tmp->v = psVectorAlloc(nBF, PS_TYPE_F32); + tmp->sigma = NULL; + tmp->xOrder = psVectorAlloc(nBF, PS_TYPE_F32); + tmp->yOrder = psVectorAlloc(nBF, PS_TYPE_F32); + tmp->subIndex = 0; + tmp->preCalc = NULL; + tmp->size = size; + tmp->spatialOrder = spatialOrder; + + // + // This corresponds to the Kernel Basis Function with (u, v) = (0, 0) + // + // Put the (u,v) = (0,0) component right at the start of the list + // for convenience. + // + psS32 ptr = 0; + for (psS32 order = 0; order <= spatialOrder; order++) { + for (psS32 xOrder = 0; xOrder <= order; xOrder++) { + psS32 yOrder = order - xOrder; + tmp->u->data.F32[ptr] = 0; + tmp->v->data.F32[ptr] = 0; + tmp->xOrder->data.F32[ptr] = xOrder; + tmp->yOrder->data.F32[ptr] = yOrder; + ptr++; + } + } + + // + // Iterate over (u,v). Generate a set of kernels for each (u, v). + // + for (psS32 v = -yKernelHalfSize; v <= yKernelHalfSize; v++) { + for (psS32 u = -xKernelHalfSize; u <= xKernelHalfSize; u++) { + // Already did (u,v) = (0,0): it's at the start, so skip it now. + if ((u != 0) || (v != 0)) { + // + // Iterate over spatial order. This loop creates the terms for + // x^xOrder * y^yOrder such that (xOrder+yOrder) <= spatialOrder. + // + for (psS32 order = 0; order <= spatialOrder; order++) { + for (psS32 xOrder = 0; xOrder <= order; xOrder++) { + psS32 yOrder = order - xOrder; + tmp->u->data.F32[ptr] = u; + tmp->v->data.F32[ptr] = v; + tmp->xOrder->data.F32[ptr] = xOrder; + tmp->yOrder->data.F32[ptr] = yOrder; + ptr++; + } + } + } + } + } + + psTrace("ImageSubtract.pmSubtractionKernelsAllocPOIS", 3, + "Exiting pmSubtractionKernelsAllocPOIS(%d, %d)\n", size, spatialOrder); + return(tmp); +} + +/******************************************************************************* +XXX: Get the types correct (u, v, xOrder, yOrder). + +XXX: Code review this. + ******************************************************************************/ +psSubtractionKernels *pmSubtractionKernelsAllocISIS(const psVector *sigmas, + const psVector *orders, + int size, + int spatialOrder) +{ + PS_ASSERT_VECTOR_NON_NULL(sigmas, NULL); + PS_ASSERT_VECTOR_NON_NULL(orders, NULL); + psTrace("ImageSubtract.pmSubtractionKernelsAllocISIS", 3, + "Calling pmSubtractionKernelsAllocISIS(%d, %d, %d, %d)\n", + sigmas->n, orders->n, size, spatialOrder); + PS_ASSERT_INT_POSITIVE(size, NULL); + PS_ASSERT_INT_POSITIVE(spatialOrder, NULL); + PS_ASSERT_VECTOR_TYPE(sigmas, PS_TYPE_F32, NULL); + PS_ASSERT_VECTOR_TYPE(orders, PS_TYPE_S32, NULL); + // + // Calculate the number of basis functions (nBF). + // + psS32 numSigmas = sigmas->n; + + // XXX: Get rid of the sigma loop? We merely multiple nBF by numSigmas? + // XXX: Verify that all this is correct. + psS32 nBF = 0; + for (psS32 s = 0 ; s < numSigmas ; s++) { + for (psS32 o = 0 ; o < orders->n ; o++) { + nBF+=((orders->data.S32[o] + 1) * (orders->data.S32[o] + 2) / 2); + } + } + nBF*= ((spatialOrder + 1) * (spatialOrder + 2) / 2); + + // + // Generate the new psSubtractionKernels data structure: + // + psSubtractionKernels *tmp = (psSubtractionKernels *) psAlloc(sizeof(psSubtractionKernels)); + tmp->type = PM_SUBTRACTION_KERNEL_ISIS; + tmp->u = psVectorAlloc(nBF, PS_TYPE_F32); + tmp->v = psVectorAlloc(nBF, PS_TYPE_F32); + tmp->sigma = psVectorAlloc(nBF, PS_TYPE_F32); + tmp->xOrder = psVectorAlloc(nBF, PS_TYPE_F32); + tmp->yOrder = psVectorAlloc(nBF, PS_TYPE_F32); + tmp->subIndex = 0; + tmp->size = size; + tmp->spatialOrder = spatialOrder; + tmp->preCalc = psArrayAlloc(nBF); + + // + // We loop through all combinations of sigmas and polynomial orders + // creating the kernel basis functions. + // + psS32 ptr = 0; + for (psS32 sigPtr = 0 ; sigPtr < numSigmas ; sigPtr++) { + tmp->sigma->data.F32[sigPtr] = sigmas->data.F32[sigPtr]; + // + // (xOrderP, yOrderP) are the order of the polynomial that modify the + // gaussian in the kernel. They correspond to (j, k) in equation (5) + // from the psModules SDRS. + // + for (psS32 o = 0 ; o < orders->n ; o++) { + for (psS32 orderP = 0 ; orderP <= orders->data.S32[o] ; orderP++) { + for (psS32 xOrderP = 0 ; xOrderP <= orderP ; xOrderP++) { + psS32 yOrderP = orderP - xOrderP; + + psImage *currPreCalc = psImageAlloc(1 + (2 * size), 1 + (2 * size), PS_TYPE_F32); + PS_IMAGE_SET_F32(currPreCalc, 0.0); + psBool setPreCalc = true; + // + // We loop through all spatial orders. Since they have no effect on + // the preCalc images, we only calculate them once, and store pointers + // in tmp->preCalc->data[ptr] for other spatial orders. + // + for (psS32 order = 0; order <= spatialOrder; order++) { + for (psS32 orderXTerm = 0; orderXTerm <= order; orderXTerm++) { + PS_ASSERT_INT_LESS_THAN(ptr, nBF, NULL); + + psS32 orderYTerm = order - orderXTerm; + + tmp->u->data.F32[ptr] = xOrderP; + tmp->v->data.F32[ptr] = yOrderP; + tmp->xOrder->data.F32[ptr] = orderXTerm; + tmp->yOrder->data.F32[ptr] = orderYTerm; + tmp->sigma->data.F32[ptr] = sigmas->data.F32[sigPtr]; + tmp->preCalc->data[ptr] = (psPtr *) currPreCalc; + + // + // We calculate the preCalc image only the first time through + // this loop. Otherwise, we increment the memory reference + // counter. + // + if (setPreCalc == true) { + for (psS32 v = -size; v <= size; v++) { + for (psS32 u = -size; u <= size; u++) { + // Scale the (u,v) coordinates in kernel space to [-1.0:1.0]. + psF32 uScaled = ((psF32) u) / ((psF32) size); + psF32 vScaled = ((psF32) v) / ((psF32) size); + + // Compute the value of the kernel at location (u, v): + psF32 exponent = (PS_SQR(uScaled) + PS_SQR(vScaled)) / + (2.0 * PS_SQR(sigmas->data.F32[sigPtr])); + currPreCalc->data.F32[v+size][u+size] = + exp(-exponent) * + pow(uScaled, orderXTerm) * + pow(vScaled, orderYTerm); + } + } + setPreCalc = false; + } else { + psMemIncrRefCounter(currPreCalc); + } + ptr++; + } + } + } + } + } + } + + psTrace("ImageSubtract.pmSubtractionKernelsAllocISIS", 3, + "Exiting pmSubtractionKernelsAllocISIS(%d, %d, %d, %d)\n", + sigmas->n, orders->n, size, spatialOrder); + return(tmp); +} + +/******************************************************************************* +pmSubtractionFindStamps(stamps, image, mask, maskVal, threshold, xNum, yNum, border) + +XXX: The SDRS and the proptotype code differ significantly. + Prototype: When a maximum pixel is found within a stamp, an area of size + 2*footprint is searched around that pixel looking for masked pixels. + SDRS: none of that is required. + +XXX: Do we need to care about case where yNum/xNum does not evenly divide the +nnumber of rows/columns in the image? + ******************************************************************************/ +psArray *pmSubtractionFindStamps(psArray *stamps, ///< Output stamps, or NULL + const psImage *image, ///< Image for which to find stamps + const psImage *mask, ///< Mask + psU32 maskVal, ///< Value for mask + psF32 threshold, ///< Threshold for stamps in the image + psS32 xNum, ///< Number of stamps in x + psS32 yNum, ///< Number of stamps in y + psS32 border ///< Border around image to ignore (should be size of kernel or larger) + ) +{ + psTrace("ImageSubtract.pmSubtractionFindStamps", 3, + "Calling pmSubtractionFindStamps(%d, %f, %d, %d, %d)\n", + maskVal, threshold, xNum, yNum, border); + PS_ASSERT_IMAGE_NON_NULL(image, NULL); + PS_ASSERT_IMAGE_NON_EMPTY(image, NULL); + PS_ASSERT_IMAGE_TYPE(image, PS_TYPE_F32, NULL); + if (mask != NULL) { + PS_ASSERT_IMAGES_SIZE_EQUAL(image, mask, NULL); + PS_ASSERT_IMAGE_TYPE(mask, PS_TYPE_U8, NULL); + } + PS_ASSERT_INT_POSITIVE(xNum, NULL); + PS_ASSERT_INT_POSITIVE(yNum, NULL); + PS_ASSERT_INT_POSITIVE(border, NULL); + PS_ASSERT_INT_LARGER_THAN(image->numCols, xNum, NULL); + PS_ASSERT_INT_LARGER_THAN(image->numRows, yNum, NULL); + PS_ASSERT_INT_LARGER_THAN(image->numCols, (2 * border), NULL); + PS_ASSERT_INT_LARGER_THAN(image->numRows, (2 * border), NULL); + + if (stamps != NULL) { + PS_ASSERT_INT_EQUAL(stamps->n, (xNum * yNum), NULL); + // + // Ensure that a pmStamp struct exists at each psArray location. + // + for (psS32 s = 0 ; s < (xNum * yNum) ; s++) { + if (NULL == stamps->data[s]) { + stamps->data[s] = (psPtr *) p_pmStampAlloc(PM_STAMP_REJECTED); + } + } + } else { + stamps = (psArray *) psArrayAlloc(xNum * yNum); + for (psS32 s = 0 ; s < (xNum * yNum) ; s++) { + stamps->data[s] = (psPtr *) p_pmStampAlloc(PM_STAMP_REJECTED); + } + } + psS32 numRows = image->numRows; + psS32 numCols = image->numCols; + + // + // Iterate over the image sections + // + // XXX: Must handle cases where image size is not an even multiple of xNum or yNum + // they are currently ignored. + // + psS32 num = 0; + for (psS32 j = 0; j < yNum; j++) { + for (psS32 i = 0; i < xNum; i++) { + pmStamp *stamp = (pmStamp *) stamps->data[num]; + // + // Only find a new stamp if we need to + // + if (stamp->status == PM_STAMP_REJECTED) { + // + // Find maximum non-masked value in the image section, + // but don't include a footprint around the edge + // + psF32 max = -INFINITY; + psS32 bestx = 0; + psS32 besty = 0; + // + // The following nested loop iterates over every pixel in the mask + // associated with this (i, j). It ignores pixels within a + // border of pixels from the image edge. + // + // XXX: verify (numX, numY), then get rid of it. + // + psS32 numX = xNum; + psS32 numY = yNum; + psS32 yMin = border + j * (numCols - 2.0 * border) / numY; + psS32 yMax = (border + (j + 1) * (numCols - 2.0 * border) / numY) - 1; + psS32 xMin = border + i * (numRows - 2.0 * border) / numX; + psS32 xMax = (border + (i + 1) * (numRows - 2.0 * border) / numX) - 1; + + if ((yMax >= image->numRows) || + (xMax >= image->numCols) || + (yMin < 0) || + (xMin < 0)) { + // XXX: We skip this stamp since its borders extends beyond the image. + // XXX: This is here mainly as a safeguard. We need to redefine the above + // min/max pixels calculation to ensure that all stamps are legitimate. + + stamp->x = -1; + stamp->y = -1; + stamp->status = PM_STAMP_NONE; + } else { + stamp->p_xSize = 1 + (xMax - xMin); + stamp->p_ySize = 1 + (yMax - yMin); + stamp->p_xMin = xMin; + stamp->p_xMax = xMax; + stamp->p_yMin = yMin; + stamp->p_yMax = yMax; + + for (psS32 y = yMin; y <= yMax ; y++) { + for (psS32 x = xMin; x <= xMax ; x++) { + // Determine if this pixel is larger than the max, and unmasked. + if (image->data.F32[y][x] > max) { + if ((mask == NULL) || !((mask->data.U8[y][x]) & maskVal)) { + max = image->data.F32[y][x]; + bestx = x; + besty = y; + } + } + } + } + + // + // If the max pixel is larger than the threshold, we keep this stamp. + // Otherwise, mark the stamp as PM_STAMP_NONE + // + if (image->data.F32[besty][bestx] >= threshold) { + stamp->x = bestx; + stamp->y = besty; + stamp->status = PM_STAMP_RECALC; + } else { + stamp->x = bestx; + stamp->y = besty; + stamp->status = PM_STAMP_NONE; + } + } + } + num++; + } + } + psTrace("ImageSubtract.pmSubtractionFindStamps", 3, + "Exiting pmSubtractionFindStamps(%d, %f, %d, %d, %d)\n", + maskVal, threshold, xNum, yNum, border); + return(stamps); +} + +/******************************************************************************* +GenSpatialOrder(spatialOrder, x, y): generates and returns a psImage in which +the [i][j] location is calculated as (x^i * y^j). + +XXX: Modify loop so that terms higher than spatialOrder are not computed. + +XXX: Modify this so that [i][j] location is calculated as (x^j * y^i)? + ******************************************************************************/ +static psImage *GenSpatialOrder(psS32 spatialOrder, + psF32 x, + psF32 y) +{ + psTrace("ImageSubtract.GenSpatialOrder", 4, + "Calling GenSpatialOrder(%d, %f, %f)\n", spatialOrder, x, y); + + psImage *polyValues = psImageAlloc(spatialOrder+1, spatialOrder+1, PS_TYPE_F64); + + psF64 xSum = 1.0; + psF64 ySum = 1.0; + for (psS32 i = 0; i < spatialOrder + 1; i++) { + ySum = xSum; + for (psS32 j = 0; j < spatialOrder + 1; j++) { + polyValues->data.F64[i][j] = ySum; + ySum*= y; + } + xSum*= x; + } + + psTrace("ImageSubtract.GenSpatialOrder", 4, + "Exiting GenSpatialOrder(%d, %f, %f)\n", spatialOrder, x, y); + + return(polyValues); +} + + +/******************************************************************************* +IsisKernelConvolve(input, kernels, kernelID, col, row): This routine +convolves a single kernel basis function with a pixel in an image. + ******************************************************************************/ +static psF32 IsisKernelConvolve(const psImage *input, + const psSubtractionKernels *kernels, + psS32 kernelID, + psS32 col, + psS32 row) +{ + + + psTrace("ImageSubtract.IsisKernelConvolve", 4, + "Calling IsisKernelConvolve(%d, %d, %d)\n", kernelID, col, row); + psS32 spatialOrder = kernels->spatialOrder; + psS32 kernelSize = kernels->size; + psS32 xOrder = (psS32) kernels->xOrder->data.F32[kernelID]; + psS32 yOrder = (psS32) kernels->yOrder->data.F32[kernelID]; + psF32 numColsHalf = 0.5 * (psF32) input->numCols; + psF32 numRowsHalf = 0.5 * (psF32) input->numRows; + psF32 imageX = (((psF32) col) - numColsHalf) / numColsHalf; // Normalised position + psF32 imageY = (((psF32) row) - numRowsHalf) / numRowsHalf; // Normalised position + + psImage *polyValues = GenSpatialOrder(spatialOrder, imageX, imageY); + + psF64 polyVal = polyValues->data.F64[yOrder][xOrder]; + + psImage *preCalc = (psImage *) kernels->preCalc->data[kernelID]; + + // XXX: Are the following asserts really necessary? + PS_ASSERT_INT_LARGER_THAN_OR_EQUAL(row-kernelSize, 0, NAN); + PS_ASSERT_INT_LESS_THAN(row+kernelSize, input->numRows, NAN); + PS_ASSERT_INT_LARGER_THAN_OR_EQUAL(col-kernelSize, 0, NAN); + PS_ASSERT_INT_LESS_THAN(col+kernelSize, input->numCols, NAN); + psF32 conv = 0.0; + for (psS32 yy = -kernelSize ; yy < kernelSize ; yy++) { + for (psS32 xx = -kernelSize ; xx < kernelSize ; xx++) { + conv += input->data.F32[yy+row][xx+col] * + preCalc->data.F32[yy+kernelSize][xx+kernelSize] * + polyVal; + } + } + psFree(polyValues); + + psTrace("ImageSubtract.IsisKernelConvolve", 4, + "Exiting IsisKernelConvolve(%d, %d, %d)\n", kernelID, col, row); + return(conv); +} + +/******************************************************************************* +ConvolvePixelPois(input, mask, badStampMaskVal, solution, kernels, col, row): + +This routine takes a single pixel in the psImage input and convolves it with +the set of kernel basis functions and their appropriate weights in solution. +It returns the value of the convolved pixel. + +XXX: Static structure for polyValues? + ******************************************************************************/ +static psF32 ConvolvePixelPois(const psImage *input, + const psImage *mask, + psU32 badStampMaskVal, + const psVector *solution, + const psSubtractionKernels *kernels, + psS32 col, + psS32 row) +{ + psTrace("ImageSubtract.ConvolvePixelPois", 4, + "Calling ConvolvePixelPois(%d, %d)\n", col, row); + psS32 nBF = kernels->u->n; + psF32 numColsHalf = 0.5 * (psF32) input->numCols; + psF32 numRowsHalf = 0.5 * (psF32) input->numRows; + psF32 background = solution->data.F64[solution->n-1]; + psS32 spatialOrder = kernels->spatialOrder; + psF32 conv = background; // Initial convolved value + + if ((mask == NULL) || !(mask->data.U8[row][col] & badStampMaskVal)) { + psF32 imageX = (((psF32) col) - numColsHalf) / numColsHalf; // Normalised position + psF32 imageY = (((psF32) row) - numRowsHalf) / numRowsHalf; // Normalised position + psImage *polyValues = GenSpatialOrder(spatialOrder, imageX, imageY); + + // Iterate over the kernel basis functions + for (psS32 k = 0; k < nBF; k++) { + psS32 u = (psS32) kernels->u->data.F32[k]; + psS32 v = (psS32) kernels->v->data.F32[k]; + + // XXX: What's the story with this? + #if 0 + + psS32 xOrder = (psS32) kernels->xOrder->data.F32[k]; + psS32 yOrder = (psS32) kernels->yOrder->data.F32[k]; + psF64 polyVal = polyValues->data.F64[yOrder][xOrder]; + #else + + psF32 polyVal = 1.0; + #endif + + // XXX: Why this? + if (k == 0) { + conv += solution->data.F64[k] * input->data.F32[row - v][col - u] * polyVal; + } else { + conv += solution->data.F64[k] * + (input->data.F32[row - v][col - u] * polyVal - input->data.F32[row][col]); + } + } + psFree(polyValues); + } + + psTrace("ImageSubtract.ConvolvePixelPois", 4, + "Exiting ConvolvePixelPois(%d, %d)\n", col, row); + return(conv); +} + + + +/******************************************************************************* +ConvolvePixelIsis(input, mask, badStampMaskVal, solution, kernels, col, row): + +This routine takes a single pixel in the psImage input and convolves it with +the set of kernel basis functions and their appropriate weights in solution. +It returns the value of the convolved pixel. + +XXX: Static structure for polyValues? + ******************************************************************************/ +static psF32 ConvolvePixelIsis(const psImage *input, + const psImage *mask, + psU32 badStampMaskVal, + const psVector *solution, + const psSubtractionKernels *kernels, + psS32 col, + psS32 row) +{ + psTrace("ImageSubtract.ConvolvePixelIsis", 4, + "Calling ConvolvePixelIsis(%d, %d)\n", col, row); + psF32 background = solution->data.F64[solution->n-1]; + psF32 conv = background; // Initial convolved value + + if ((mask == NULL) || !(mask->data.U8[row][col] & badStampMaskVal)) { + // Iterate over the kernel basis functions + for (psS32 k = 0; k < kernels->u->n; k++) { + conv += IsisKernelConvolve(input, kernels, k, col, row); + } + } + + psTrace("ImageSubtract.ConvolvePixelIsis", 4, + "Exiting ConvolvePixelIsis(%d, %d)\n", col, row); + return(conv); +} + +/******************************************************************************* +ConvolveImage(input, mask, badStampMaskVal, solution, kernels): convolves an +arbitrary image with either an ISIS or POIS set of kernel basis functions. + ******************************************************************************/ +static psImage *ConvolveImage(const psImage *input, + const psImage *mask, + psU32 badStampMaskVal, + const psVector *solution, + const psSubtractionKernels *kernels) +{ + psTrace("ImageSubtract.ConvolveImage", 4, "Calling ConvolveImage()\n"); + PS_ASSERT_IMAGE_NON_NULL(input, NULL); + PS_ASSERT_IMAGE_NON_EMPTY(input, NULL); + PS_ASSERT_IMAGE_TYPE(input, PS_TYPE_F32, NULL); + if (mask != NULL) { + PS_ASSERT_IMAGES_SIZE_EQUAL(input, mask, NULL); + PS_ASSERT_IMAGE_TYPE(mask, PS_TYPE_U8, NULL); + } + PS_ASSERT_VECTOR_NON_NULL(solution, NULL); + PS_ASSERT_VECTOR_TYPE(solution, PS_TYPE_F64, NULL); + PS_ASSERT_PTR_NON_NULL(kernels, NULL); + PS_ASSERT_VECTORS_SIZE_EQUAL(kernels->u, kernels->v, NULL); + PS_ASSERT_VECTORS_SIZE_EQUAL(kernels->u, kernels->xOrder, NULL); + PS_ASSERT_VECTORS_SIZE_EQUAL(kernels->u, kernels->yOrder, NULL); + if (kernels->preCalc != NULL) { + PS_ASSERT_VECTORS_SIZE_EQUAL(kernels->u, kernels->preCalc, NULL); + } else { + if (kernels->type != PM_SUBTRACTION_KERNEL_POIS) { + psError(PS_ERR_BAD_PARAMETER_NULL, true, + "Unallowable operation: kernels->preCalc == NULL and kernels->type != PM_SUBTRACTION_KERNEL_POIS.\n"); + return(NULL); + } + } + psS32 nBF = kernels->u->n; + PS_ASSERT_VECTOR_SIZE(solution, nBF+1, NULL); + + psS32 numCols = input->numCols; + psS32 numRows = input->numRows; + psS32 kernelSize = kernels->size; + + psImage *convolved = psImageAlloc(numCols, numRows, PS_TYPE_F32); + + for (psS32 y = kernelSize; y < numRows - kernelSize; y++) { + for (psS32 x = kernelSize; x < numCols - kernelSize; x++) { + if (kernels->type == PM_SUBTRACTION_KERNEL_POIS) { + convolved->data.F32[y][x] = ConvolvePixelPois(input, mask, badStampMaskVal, + solution, kernels, x, y); + } else if (kernels->type == PM_SUBTRACTION_KERNEL_ISIS) { + convolved->data.F32[y][x] = ConvolvePixelIsis(input, mask, badStampMaskVal, + solution, kernels, x, y); + } else { + psLogMsg(__func__, PS_LOG_WARN, "WARNING: unknown kernel type. Returning NULL\n"); + return(NULL); + } + } + } + + // + // Pad the rest of the convolved image with 0.0 + // + for (psS32 y = kernelSize; y < numRows - kernelSize; y++) { + for (psS32 x = 0; x < kernelSize; x++) { + convolved->data.F32[y][x] = 0.0; + } + for (psS32 x = numCols - kernelSize; x < numCols; x++) { + convolved->data.F32[y][x] = 0.0; + } + } + for (psS32 y = 0; y < kernelSize; y++) { + for (psS32 x = 0; x < numCols; x++) { + convolved->data.F32[y][x] = 0.0; + } + } + for (psS32 y = numRows - kernelSize; y < numRows; y++) { + for (psS32 x = 0; x < numCols; x++) { + convolved->data.F32[y][x] = 0.0; + } + } + + psTrace("ImageSubtract.ConvolveImage", 4, "Exiting ConvolveImage()\n"); + return convolved; +} + + + + + +/******************************************************************************* +XXX: We should assert that the (footprint, kernelSize, imageSize) stuff +ensures that all data is accessed in bounds? + ******************************************************************************/ +bool pmSubtractionCalculateEquation(psArray *stamps, ///< The stamps for which to calculate the equation, + const psImage *reference, ///< Reference image + const psImage *input, ///< Input image + const psSubtractionKernels *kernels, ///< The kernel basis functions + psS32 footprint ///< Half-size of region over which to calculate equation + ) +{ + psTrace("ImageSubtract.pmSubtractionCalculateEquation", 3, + "Calling pmSubtractionCalculateEquation()\n"); + PS_ASSERT_PTR_NON_NULL(stamps, false); + PS_ASSERT_IMAGE_NON_NULL(reference, false); + PS_ASSERT_IMAGE_NON_EMPTY(reference, false); + PS_ASSERT_IMAGE_NON_NULL(input, false); + PS_ASSERT_IMAGE_NON_EMPTY(input, false); + PS_ASSERT_IMAGES_SIZE_EQUAL(reference, input, false); + PS_ASSERT_PTR_NON_NULL(kernels, false); + PS_ASSERT_VECTORS_SIZE_EQUAL(kernels->u, kernels->v, false); + PS_ASSERT_VECTORS_SIZE_EQUAL(kernels->u, kernels->xOrder, false); + PS_ASSERT_VECTORS_SIZE_EQUAL(kernels->u, kernels->yOrder, false); + if (kernels->type == PM_SUBTRACTION_KERNEL_ISIS) { + PS_ASSERT_VECTORS_SIZE_EQUAL(kernels->u, kernels->preCalc, false); + } + psS32 kernelSize = kernels->size; + PS_ASSERT_INT_NONNEGATIVE(footprint, false); + // + // For each legitimate stamp, ensure that the footprint is small enough to perform + // the full calculation. + // + // XXX: Verify with IfA that this is a reasonable action. + // + for (psS32 s = 0; s < stamps->n; s++) { + pmStamp *stamp = (pmStamp *) stamps->data[s]; + if (stamp->status == PM_STAMP_RECALC) { + // XXX: trace message + // printf("stamp %d (x, y) is (%d, %d). Footprint is %d. kernelSize is %d.\n", s, stamp->x, stamp->y, footprint, kernelSize); + if (((stamp->y - (footprint + kernelSize)) < 0) || + ((stamp->x - (footprint + kernelSize)) < 0) || + ((stamp->y + footprint + kernelSize) >= input->numRows) || + ((stamp->x + footprint + kernelSize) >= input->numCols)) { + stamp->status = PM_STAMP_NONE; + psLogMsg(__func__, PS_LOG_WARN, + "WARNING: stamp %d will be ignored. It exceeds image size: access columns (%d to %d) and rows (%d to %d)\n", + s, + stamp->x - (footprint + kernelSize), + (stamp->x + footprint + kernelSize) - 1, + stamp->y - (footprint + kernelSize), + (stamp->y + footprint + kernelSize) - 1); + } + } + } + + psS32 numHalfRows = reference->numRows; + psS32 numHalfCols = reference->numCols; + psS32 spatialOrder = kernels->spatialOrder; + + // + // The numSolveParams incorporates the additional parameter for the + // background value, which we must solve for. + // + psS32 numKernels = kernels->u->n; + int numSolveParams = numKernels + 1; + int bgIndex = numKernels; // Index in matrix for the background + + // + // We iterate over each stamp, allocate the matrix and vectors if + // necessary, and then calculate those matrix/vectors. + // + for (psS32 s = 0; s < stamps->n; s++) { + pmStamp *stamp = (pmStamp *) stamps->data[s]; + psTrace("pmSubtractionCalculateEquation", 6, "subCalcEqn(): stamp %d\n", s); + if (stamp->status == PM_STAMP_RECALC) { + psTrace("pmSubtractionCalculateEquation", 6, "subCalcEqn(): stamp %d: status is PM_STAMP_RECALC.\n", s); + psImage *stampMatrix = stamp->matrix; + psVector *stampVector = stamp->vector; + + if (stampMatrix == NULL) { + stampMatrix = psImageAlloc(numSolveParams, numSolveParams, PS_TYPE_F64); + stamp->matrix = stampMatrix; + } else { + PS_ASSERT_IMAGE_TYPE(stampMatrix, PS_TYPE_F64, false); + PS_ASSERT_IMAGE_SIZE(stampMatrix, numSolveParams, numSolveParams, false); + } + PS_IMAGE_SET_F64(stampMatrix, 0.0); + + if (stampVector == NULL) { + stampVector = psVectorAlloc(numSolveParams, PS_TYPE_F64); + stamp->vector = stampVector; + } else { + PS_ASSERT_VECTOR_TYPE(stampVector, PS_TYPE_F64, false); + PS_ASSERT_VECTOR_SIZE(stampVector, numSolveParams, false); + } + PS_VECTOR_SET_F64(stampVector, 0.0); + psTrace("pmSubtractionCalculateEquation", 6, "subCalcEqn(): stamp %d: allocate matrix and vector.\n", s); + + // + // Evaluate the spatial-order polynomial. The [i][j]-th element of + // the psImage polyValues will hold (x^i * y^j) for the stamp. The + // (x, y) value are scaled to [-1:1] + // + psImage *polyValues = GenSpatialOrder(spatialOrder, + ((psF64) (stamp->x - numHalfCols)) / ((psF64) numHalfCols), + ((psF64) (stamp->y - numHalfRows)) / ((psF64) numHalfRows)); + + psTrace("pmSubtractionCalculateEquation", 6, "subCalcEqn(): stamp %d: generated spatial order terms.\n", s); + + if (kernels->type == PM_SUBTRACTION_KERNEL_POIS) { + // + // Iterate over all pixels surrounding this stamp. + // + for (psS32 y = stamp->y - footprint; y < stamp->y + footprint; y++) { + for (psS32 x = stamp->x - footprint; x < stamp->x + footprint; x++) { + psTrace("pmSubtractionCalculateEquation", 6, "subCalcEqn(): pixel (%d, %d).\n", y, x); + + // The inverse of the noise, squared. + psF32 invNoise2 = 1.0/reference->data.F32[y][x]; + + // + // Iterate over the first convolution */ + // + for (psS32 k1 = 0; k1 < numKernels; k1++) { + psS32 u1 = kernels->u->data.F32[k1]; // Offset in x + psS32 v1 = kernels->v->data.F32[k1]; // Offset in y + psS32 i1 = kernels->xOrder->data.F32[k1]; // Polynomial order in x + psS32 j1 = kernels->yOrder->data.F32[k1]; // Polynomial order in y + + // + // First convolution. This will set the value for the stampVector. + // + // XXX: verify the [y-v2][x-u2] subscript. This generated errors in + // testing, depending on kernel size and footprint. + // + psF32 conv1 = polyValues->data.F64[j1][i1] * reference->data.F32[y - v1][x - u1]; + + // + // Assuming that the first kernel component is 0 order in x and y, and 0 offset + // XXX: I don't understand this: + // + if (k1 != 0) { + conv1 -= reference->data.F32[y][x]; + } + + // + // Iterate over the second convolution + // + for (psS32 k2 = k1; k2 < numKernels; k2++) { + psS32 u2 = (psS32) kernels->u->data.F32[k2]; // Offset in x + psS32 v2 = (psS32) kernels->v->data.F32[k2]; // Offset in y + psS32 i2 = (psS32) kernels->xOrder->data.F32[k2]; // Polynomial order in x + psS32 j2 = (psS32) kernels->yOrder->data.F32[k2]; // Polynomial order in y + // + // XXX: verify the [y-v2][x-u2] subscript. This generated errors in + // testing, depending on kernel size and footprint. + // + // Second convolution + // + psF32 conv2 = polyValues->data.F64[j2][i2] * + reference->data.F32[y-v2][x-u2]; + // + // Assuming that the first kernel component is 0 order in x and y, and 0 offset + // XXX: I don't understand this: + if (k2 != 0) { + // + conv2 -= reference->data.F32[y][x]; + } + + // Add into the matrix element + stampMatrix->data.F64[k1][k2] += conv1 * conv2 * invNoise2; + + } // Iteration on second convolution + + // Add into the vector element + stampVector->data.F64[k1] += input->data.F32[y][x] * conv1 * invNoise2; + + /* Background term */ + stampMatrix->data.F64[k1][bgIndex] += conv1 * invNoise2; + + } // Iteration on first convolution + + // + // Background only terms. + // XXX: understand this. + // + stampMatrix->data.F64[bgIndex][bgIndex] += invNoise2; + stampVector->data.F64[bgIndex] += input->data.F32[y][x] * invNoise2; + } + } + } else if (kernels->type == PM_SUBTRACTION_KERNEL_ISIS) { + // + // Iterate over all pixels surrounding this stamp. + // + // XXX: Why isn't there a polyValues term here? + // + + for (psS32 y = stamp->y - footprint; y < stamp->y + footprint; y++) { + for (psS32 x = stamp->x - footprint; x < stamp->x + footprint; x++) { + psTrace("pmSubtractionCalculateEquation", 6, "subCalcEqn(): pixel (%d, %d).\n", y, x); + psF32 invNoise2 = 1.0/reference->data.F32[y][x]; // The inverse of the noise, squared. + + for (psS32 k1 = 0; k1 < numKernels; k1++) { + psF32 conv1 = IsisKernelConvolve(reference, kernels, k1, x, y); + + for (psS32 k2 = k1; k2 < numKernels; k2++) { + //printf("(k1, k2) is (%d, %d)\n", k1, k2); + psF32 conv2 = IsisKernelConvolve(reference, kernels, k2, x, y); + stampMatrix->data.F64[k1][k2]+= conv1 * conv2 * invNoise2; + } + stampVector->data.F64[k1]+= input->data.F32[y][x] * conv1 * invNoise2; + stampMatrix->data.F64[k1][bgIndex] += conv1 * invNoise2; + } + stampMatrix->data.F64[bgIndex][bgIndex] += invNoise2; + stampVector->data.F64[bgIndex] += input->data.F32[y][x] * invNoise2; + } + } + } else { + psLogMsg(__func__, PS_LOG_WARN, "WARNING: unknown kernel->type.\n"); + return(false); + } + psFree(polyValues); + + // XXX: Generate psTrace() + if (0) { + for (psS32 s = 0; s < stamps->n; s++) { + pmStamp *stamp = (pmStamp *) stamps->data[s]; + if (stamp->status == PM_STAMP_RECALC) { + psVector *stampVector = stamp->vector; + printf("STAMP: stamp %d vector:\n", s); + PS_VECTOR_PRINT_F64(stampVector); + } + } + } + + // + // Fill in other side of symmetric matrix + // + // XXX: understand this. + // XXX: Why aren't they using numSolveParams instead of numKernels? + // XXX: is this POIS specific? + // + for (psS32 k1 = 0; k1 < numKernels; k1++) { + for (psS32 k2 = 0; k2 < k1; k2++) { + stampMatrix->data.F64[k1][k2] = stampMatrix->data.F64[k2][k1]; + } + stampMatrix->data.F64[bgIndex][k1] = stampMatrix->data.F64[k1][bgIndex]; + } + + // + // XXX: Why aren't they using numSolveParams instead of numKernels? + // XXX: is this POIS specific? + // + #define XXX_CONFIG_PENALTY 1.0 + for (psS32 k = 0; k < numKernels; k++) + { + psS32 u = kernels->u->data.F32[k]; // Offset in x + psS32 v = kernels->v->data.F32[k]; // Offset in y + stampMatrix->data.F64[k][k] += XXX_CONFIG_PENALTY * (psF32)(u*u + v*v); + } + stamp->status = PM_STAMP_USED; + } else { + // Stamp is ignored since it's not PM_STAMP_RECALC + } + } + psTrace("ImageSubtract.pmSubtractionCalculateEquation", 3, + "Exiting pmSubtractionCalculateEquation()\n"); + return(true); +} + + + + +/******************************************************************************* + ******************************************************************************/ +psVector *pmSubtractionSolveEquation(psVector *solution, ///< Solution vector, or NULL + const psArray *stamps ///< Array of stamps + ) +{ + psTrace("ImageSubtract.pmSubtractionSolveEquation", 3, + "Calling pmSubtractionSolveEquation()\n"); + PS_ASSERT_PTR_NON_NULL(stamps, NULL); + psS32 size = -1; + psS32 s = 0; + + // + // Determine the size of the stamp vectors and matrix. + // We iterate until we find the first acceptable stamp. + // + while ((size == -1) && (s < stamps->n)) { + pmStamp *stamp = (pmStamp *) stamps->data[s]; + PS_ASSERT_PTR_NON_NULL(stamp, NULL); + if (stamp->status == PM_STAMP_USED) { + size = ((pmStamp *) stamps->data[s])->vector->n; + PS_ASSERT_INT_POSITIVE(size, NULL); + } + s++; + } + if (size == -1) { + psLogMsg(__func__, PS_LOG_WARN, "WARNING: no acceptable stamps. Returning NULL\n"); + return(NULL); + } + + if (solution != NULL) { + PS_ASSERT_VECTOR_TYPE(solution, PS_TYPE_F64, NULL); + PS_ASSERT_VECTOR_SIZE(solution, size, NULL); + } else { + solution = psVectorAlloc(size, PS_TYPE_F64); + } + + // + // Create the solution matrix and vector. + // + // XXX: Test these functions with size=-1. This caused seg faults during test. + // This should be done in the psImage.c and psVector.c test files. It + // should never occur here. + // + psImage *sumMatrix = psImageAlloc(size, size, PS_TYPE_F64); + psVector *sumVector = psVectorAlloc(size, PS_TYPE_F64); + PS_VECTOR_SET_F64(sumVector, 0.0); + PS_IMAGE_SET_F64(sumMatrix, 0.0); + + // + // Verify that all stamps have similar sizes. + // Compute the sum matrix and vector. + // + for (psS32 s = 0; s < stamps->n; s++) { + pmStamp *stamp = (pmStamp *) stamps->data[s]; + + if (stamp->status == PM_STAMP_USED) { + PS_ASSERT_INT_EQUAL(((pmStamp *) stamps->data[s])->vector->n, size, NULL); + + psImage *stampMatrix = stamp->matrix; + psVector *stampVector = stamp->vector; + PS_ASSERT_VECTOR_TYPE(stampVector, PS_TYPE_F64, NULL); + PS_ASSERT_VECTOR_SIZE(stampVector, size, NULL); + PS_ASSERT_IMAGE_TYPE(stampMatrix, PS_TYPE_F64, NULL); + PS_ASSERT_IMAGE_SIZE(stampMatrix, size, size, NULL); + + (void)psBinaryOp(sumMatrix, sumMatrix, "+", stampMatrix); + (void)psBinaryOp(sumVector, sumVector, "+", stampVector); + } + } + psVector *permutation = NULL; + // XXX: Check output from these routines. + + // XXX: psTrace() + if (0) { + PS_IMAGE_PRINT_F64(sumMatrix); + } + + psImage *luMatrix = psMatrixLUD(NULL, &permutation, sumMatrix); + if (luMatrix == NULL) { + psError(PS_ERR_UNKNOWN, true, "Failed to LU-Decompose the matrix.\n"); + psFree(sumMatrix); + psFree(sumVector); + psFree(luMatrix); + psFree(permutation); + return(NULL); + } + // XXX: psTrace() + if (0) { + PS_IMAGE_PRINT_F64(luMatrix); + } + + solution = psMatrixLUSolve(solution, luMatrix, sumVector, permutation); + // XXX: psTrace() + // XXX: should we be checking for NAN's in the solution vector? + if (0) { + PS_VECTOR_PRINT_F64(solution); + } + if (solution == NULL) { + psError(PS_ERR_UNKNOWN, true, "Failed to solve the matrix.\n"); + psFree(sumMatrix); + psFree(sumVector); + psFree(luMatrix); + psFree(permutation); + return(NULL); + } + + psFree(sumMatrix); + psFree(sumVector); + psFree(luMatrix); + psFree(permutation); + + psTrace("ImageSubtract.pmSubtractionSolveEquation", 3, + "Exiting pmSubtractionSolveEquation()\n"); + return(solution); +} + + +/******************************************************************************* + ******************************************************************************/ +static psVector *CalculateDeviations(psVector *deviations, + psArray *stamps, + psS32 footprint, + const psImage *refImage, + const psImage *inImage, + const psImage *mask, + psU32 badStampMaskVal, + const psSubtractionKernels *kernels, + const psVector *solution) +{ + psTrace("ImageSubtract.CalculateDeviations", 4, + "Calling CalculateDeviations()\n"); + PS_ASSERT_PTR_NON_NULL(stamps, NULL); + if (deviations != NULL) { + PS_ASSERT_VECTOR_TYPE(deviations, PS_TYPE_F32, NULL); + PS_ASSERT_VECTORS_SIZE_EQUAL(deviations, stamps, NULL); + } else { + deviations = psVectorAlloc(stamps->n, PS_TYPE_F32); + // XXX: Probably not necessary. + PS_VECTOR_SET_F32(deviations, 0.0); + } + PS_ASSERT_IMAGE_NON_NULL(refImage, NULL); + PS_ASSERT_IMAGE_NON_EMPTY(refImage, NULL); + PS_ASSERT_IMAGE_TYPE(refImage, PS_TYPE_F32, NULL); + PS_ASSERT_IMAGE_NON_NULL(inImage, NULL); + PS_ASSERT_IMAGE_NON_EMPTY(inImage, NULL); + PS_ASSERT_IMAGE_TYPE(inImage, PS_TYPE_F32, NULL); + PS_ASSERT_IMAGES_SIZE_EQUAL(refImage, inImage, NULL); + PS_ASSERT_IMAGE_NON_NULL(mask, NULL); + PS_ASSERT_IMAGE_NON_EMPTY(mask, NULL); + PS_ASSERT_IMAGE_TYPE(mask, PS_TYPE_U8, NULL); + PS_ASSERT_IMAGES_SIZE_EQUAL(refImage, mask, NULL); + PS_ASSERT_VECTOR_NON_NULL(solution, NULL); + PS_ASSERT_VECTOR_TYPE(solution, PS_TYPE_F64, NULL); + PS_ASSERT_PTR_NON_NULL(kernels, NULL); + PS_ASSERT_VECTORS_SIZE_EQUAL(kernels->u, kernels->v, NULL); + PS_ASSERT_VECTORS_SIZE_EQUAL(kernels->u, kernels->xOrder, NULL); + PS_ASSERT_VECTORS_SIZE_EQUAL(kernels->u, kernels->yOrder, NULL); + if (kernels->preCalc != NULL) { + PS_ASSERT_VECTORS_SIZE_EQUAL(kernels->u, kernels->preCalc, NULL); + } else { + if (kernels->type != PM_SUBTRACTION_KERNEL_POIS) { + psError(PS_ERR_BAD_PARAMETER_NULL, true, + "Unallowable operation: kernels->preCalc == NULL and kernels->type != PM_SUBTRACTION_KERNEL_POIS.\n"); + return(NULL); + } + } + psS32 nBF = kernels->u->n; + PS_ASSERT_VECTOR_SIZE(solution, nBF+1, NULL); + + psS32 kernelSize = kernels->size; + int xSize = footprint + kernelSize; + int ySize = footprint + kernelSize; + psStats *stats = psStatsAlloc(PS_STAT_SAMPLE_MEAN); // Statistics + psImage *subStamp = psImageAlloc(2 * xSize, 2 * ySize, PS_TYPE_F32); // Subtraction of stamp + for (psS32 s = 0; s < stamps->n; s++) { + pmStamp *stamp = stamps->data[s]; // The coordinates of the stamp of interest + psS32 x = stamp->x; // Stamp x coord + psS32 y = stamp->y; // Stamp y coord + if (stamp->status == PM_STAMP_USED) { + + psRegion myReg = psRegionSet(x - xSize, x + xSize, y - ySize, y + ySize); + psImage *refStamp = psImageSubset((psImage *) refImage, myReg); + psImage *inStamp = psImageSubset((psImage *) inImage, myReg); + psImage *maskStamp = psImageSubset((psImage *) mask, myReg); + psImage *convRefStamp = ConvolveImage(refStamp, maskStamp, badStampMaskVal, solution, kernels); + + // Calculate chi^2 + (void)psBinaryOp(subStamp, inStamp, "-", convRefStamp); + (void)psBinaryOp(subStamp, subStamp, "/", inStamp); + (void)psBinaryOp(subStamp, subStamp, "*", subStamp); + myReg = psRegionSet(kernelSize, kernelSize + 2 * footprint, + kernelSize, kernelSize + 2 * footprint); + psImage *subStampTrim = psImageSubset((psImage *) subStamp, myReg); + psImage *maskStampTrim = psImageSubset((psImage *) maskStamp, myReg); + psImageStats(stats, subStampTrim, maskStampTrim, badStampMaskVal); + + deviations->data.F32[s] = stats->sampleMean * (psF32)footprint * (psF32)footprint * 4.0; + // XXX: Allocate and free these elsewhere. + psFree(refStamp); + psFree(inStamp); + psFree(maskStamp); + psFree(convRefStamp); + psFree(subStampTrim); + psFree(maskStampTrim); + } + } + + psFree(stats); + psFree(subStamp); + + psTrace("ImageSubtract.CalculateDeviations", 4, + "Exiting CalculateDeviations()\n"); + return deviations; +} + +/******************************************************************************* + ******************************************************************************/ +bool pmSubtractionRejectStamps(psArray *stamps, ///< Array of stamps to check for rejection + psImage *mask, ///< Mask image + psU32 badStampMaskVal, ///< Value to use in mask for bad stamp + psS32 footprint, ///< Region to mask if stamp is bad + psF32 sigmaRej, ///< Number of RMS deviations above zero at which to reject + const psImage *refImage, ///< Reference image + const psImage *inImage, ///< Input image + const psVector *solution, ///< Solution vector + const psSubtractionKernels *kernels ///< Array of kernel parameters + ) +{ + psTrace("ImageSubtract.pmSubtractionRejectStamps", 3, + "Calling pmSubtractionRejectStamps()\n"); + PS_ASSERT_PTR_NON_NULL(stamps, false); + PS_ASSERT_IMAGE_NON_NULL(refImage, false); + PS_ASSERT_IMAGE_NON_EMPTY(refImage, false); + PS_ASSERT_IMAGE_TYPE(refImage, PS_TYPE_F32, false); + PS_ASSERT_IMAGE_NON_NULL(inImage, false); + PS_ASSERT_IMAGE_NON_EMPTY(inImage, false); + PS_ASSERT_IMAGE_TYPE(inImage, PS_TYPE_F32, false); + PS_ASSERT_IMAGES_SIZE_EQUAL(refImage, inImage, false); + PS_ASSERT_IMAGE_NON_NULL(mask, false); + PS_ASSERT_IMAGE_NON_EMPTY(mask, false); + PS_ASSERT_IMAGE_TYPE(mask, PS_TYPE_U8, false); + PS_ASSERT_IMAGES_SIZE_EQUAL(refImage, mask, false); + PS_ASSERT_VECTOR_NON_NULL(solution, false); + PS_ASSERT_VECTOR_TYPE(solution, PS_TYPE_F64, false); + PS_ASSERT_PTR_NON_NULL(kernels, false); + PS_ASSERT_VECTORS_SIZE_EQUAL(kernels->u, kernels->v, false); + PS_ASSERT_VECTORS_SIZE_EQUAL(kernels->u, kernels->xOrder, false); + PS_ASSERT_VECTORS_SIZE_EQUAL(kernels->u, kernels->yOrder, false); + if (kernels->preCalc != NULL) { + PS_ASSERT_VECTORS_SIZE_EQUAL(kernels->u, kernels->preCalc, false); + } else { + if (kernels->type != PM_SUBTRACTION_KERNEL_POIS) { + psError(PS_ERR_BAD_PARAMETER_NULL, true, + "Unallowable operation: kernels->preCalc == NULL and kernels->type != PM_SUBTRACTION_KERNEL_POIS.\n"); + return(false); + } + } + + psS32 nBF = kernels->u->n; + PS_ASSERT_VECTOR_SIZE(solution, nBF+1, false); + + psVector *deviations = CalculateDeviations(NULL, + stamps, + footprint, + refImage, + inImage, + mask, + badStampMaskVal, + kernels, + solution); + // + // Calculate the deviation from zero. + // + psF64 meanDev = 0.0; + psS32 numDev = 0; + for (psS32 i = 0; i < deviations->n; i++) { + pmStamp *stamp = stamps->data[i]; + if (stamp->status == PM_STAMP_USED) { + meanDev += PS_SQR(deviations->data.F32[i]); + numDev++; + } + } + psF32 rmsDev = sqrtf(meanDev / (psF64)(numDev - 1)); + psF32 limit = rmsDev * sigmaRej; + + for (psS32 s = 0; s < stamps->n; s++) { + pmStamp *stamp = (pmStamp *) stamps->data[s]; + if (stamp->status == PM_STAMP_USED && fabsf(deviations->data.F32[s]) > limit) { + // Mask out the stamp in the image so you don't find it again + for (psS32 y = stamp->y - footprint; y < stamp->y + footprint; y++) { + for (psS32 x = stamp->x - footprint; x < stamp->x + footprint; x++) { + mask->data.U8[y][x] |= badStampMaskVal; + } + } + + // Set stamp for replacement + stamp->x = 0; + stamp->y = 0; + stamp->status = PM_STAMP_REJECTED; + } + } + + psFree(deviations); + psTrace("ImageSubtract.pmSubtractionRejectStamps", 3, + "Exiting pmSubtractionRejectStamps()\n"); + return(true); +} + +/******************************************************************************* + ******************************************************************************/ +psImage *pmSubtractionKernelImage(psImage *out, + const psVector *solution, + const psSubtractionKernels *kernels, + psF32 x, + psF32 y + ) +{ + psTrace("ImageSubtract.pmSubtractionKernelImage", 3, + "Calling pmSubtractionKernelImage()\n"); + PS_ASSERT_VECTOR_NON_NULL(solution, NULL); + PS_ASSERT_PTR_NON_NULL(kernels, NULL); + PS_ASSERT_FLOAT_WITHIN_RANGE(x, -1.0, 1.0, NULL); + PS_ASSERT_FLOAT_WITHIN_RANGE(y, -1.0, 1.0, NULL); + PS_ASSERT_VECTORS_SIZE_EQUAL(kernels->u, kernels->v, NULL); + PS_ASSERT_VECTORS_SIZE_EQUAL(kernels->u, kernels->xOrder, NULL); + PS_ASSERT_VECTORS_SIZE_EQUAL(kernels->u, kernels->yOrder, NULL); + if (kernels->preCalc != NULL) { + PS_ASSERT_VECTORS_SIZE_EQUAL(kernels->u, kernels->preCalc, NULL); + } else { + if (kernels->type != PM_SUBTRACTION_KERNEL_POIS) { + psError(PS_ERR_BAD_PARAMETER_NULL, true, + "Unallowable operation: kernels->preCalc == NULL and kernels->type != PM_SUBTRACTION_KERNEL_POIS.\n"); + return(NULL); + } + } + PS_ASSERT_INT_EQUAL(1+kernels->u->n, solution->n, NULL); + + psS32 nBF = kernels->u->n; + psS32 spatialOrder = kernels->spatialOrder; + psS32 kernelSize = kernels->size; + + if (out != NULL) { + if ((out->numCols < (1+2*kernelSize)) || (out->numRows < (1+2*kernelSize))) { + psLogMsg(__func__, PS_LOG_WARN, "WARNING: out image is not large enough.\n"); + return(out); + } + } else { + out = psImageAlloc(1+2*kernelSize, 1+2*kernelSize, PS_TYPE_F32); + } + PS_IMAGE_SET_F32(out, 0.0); + + // + // Generate the spatial-order polynomial. The [i][j]-th element of + // the psImage polyValues will hold (x^i * y^j) for the stamp. + // + psImage *polyValues = GenSpatialOrder(spatialOrder, x, y); + + // XXX: switch (i, j) so they correspond to (x, y). + if (kernels->type == PM_SUBTRACTION_KERNEL_ISIS) { + for (psS32 k = 0 ; k < nBF ; k++) { + psS32 xOrder = (psS32) kernels->xOrder->data.F32[k]; + psS32 yOrder = (psS32) kernels->yOrder->data.F32[k]; + psF64 polyVal = polyValues->data.F64[yOrder][xOrder]; + + // XXX: Verify that this is correct. + for (psS32 i = -kernelSize ; i <= kernelSize ; i++) { + for (psS32 j = -kernelSize ; j <= kernelSize ; j++) { + psImage *preCalc = (psImage *) kernels->preCalc->data[k]; + out->data.F32[i+kernelSize][j+kernelSize]+= + solution->data.F64[k] * + preCalc->data.F32[i+kernelSize][j+kernelSize] * + polyVal; + } + } + } + } else if (kernels->type == PM_SUBTRACTION_KERNEL_POIS) { + for (psS32 k = 0 ; k < nBF ; k++) { + // XXX: Why don't we have compilation warnings on type here (if + // we remove the (psS32) cast)? + psS32 u = (psS32) kernels->u->data.F32[k]; + psS32 v = (psS32) kernels->v->data.F32[k]; + psS32 xOrder = (psS32) kernels->xOrder->data.F32[k]; + psS32 yOrder = (psS32) kernels->yOrder->data.F32[k]; + // XXX: Verify that this is correct. + + out->data.F32[kernelSize - v][kernelSize - u]+= + solution->data.F64[k] * polyValues->data.F64[yOrder][xOrder]; + } + } + psFree(polyValues); + + psTrace("ImageSubtract.pmSubtractionKernelImage", 3, + "Exiting pmSubtractionKernelImage()\n"); + return(out); +} Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/imsubtract/pmImageSubtract.h =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/imsubtract/pmImageSubtract.h (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/imsubtract/pmImageSubtract.h (revision 21664) @@ -0,0 +1,127 @@ +/** @file ImageSubtract.h + * + * This file will contain code which creates a set of kernel basis + * functions, solves for their solution, and applies them to an image. + * + * @author Paul Price, IfA (original prototype) + * @author GLG, MHPCC + * + * @version $Revision: 1.1 $ $Name: not supported by cvs2svn $ + * @date $Date: 2005-09-28 20:43:52 $ + * + * Copyright 2004 Maui High Performance Computing Center, University of Hawaii + * + */ + +#if !defined(PM_IMAGE_COMBINE_H) +#define PM_IMAGE_COMBINE_H + +#if HAVE_CONFIG_H +#include +#endif + +#include +#include +#include "pslib.h" +#include "psConstants.h" + +typedef enum { + PM_SUBTRACTION_KERNEL_POIS, ///< POIS kernel --- delta functions + PM_SUBTRACTION_KERNEL_ISIS ///< ISIS kernel --- gaussians modified by polynomials +} pmSubtractionKernelsType; + +typedef struct +{ + pmSubtractionKernelsType type; ///< Type ofKernels --- allowing the use of multiple kernels + psVector *u, *v; ///< Offset (for POIS) or polynomial order (for ISIS) + psVector *sigma; ///< Width of Gaussian (for ISIS) + psVector *xOrder, *yOrder; ///< Spatial Polynomial order (for all) + int subIndex; ///< Index of kernel to be subtracted to maintain flux conservation + psArray *preCalc; ///< Array of images containing pre-calculated kernel (to + ///< accelerate ISIS; don't use for POIS) + psS32 size; ///< The halfsize of the kernel + psS32 spatialOrder; ///< The spatial order of the kernels +} +psSubtractionKernels; + +psSubtractionKernels *pmSubtractionKernelsAllocPOIS( + int size, + int SpatialOrder +); + +psSubtractionKernels *pmSubtractionKernelsAllocISIS( + const psVector *sigmas, + const psVector *orders, + int size, + int SpatialOrder +); + +typedef enum { + PM_STAMP_INIT, ///< Initial state + PM_STAMP_USED, ///< Use this stamp + PM_STAMP_REJECTED, ///< This stamp has been rejected + PM_STAMP_RECALC, ///< Having been reset, this stamp is to be recalculated + PM_STAMP_NONE ///< No stamp in this region +} pmStampStatus; + +typedef struct +{ + int x, y; ///< Position + int p_xSize; + int p_ySize; + int p_xMin; + int p_xMax; + int p_yMin; + int p_yMax; + psImage *matrix; ///< Associated matrix + psVector *vector; ///< Assoicated vector + pmStampStatus status; ///< Status ofstamp +} +pmStamp; + +psArray *pmSubtractionFindStamps( + psArray *stamps, ///< Output stamps, or NULL + const psImage *image, ///< Image for which to find stamps + const psImage *mask, ///< Mask + psU32 maskVal, ///< Value for mask + psF32 threshold, ///< Threshold for stamps in the image + psS32 xNum, ///< Number of stamps in x + psS32 yNum, ///< Number of stamps in y + psS32 border ///< Border around image to ignore (should be size of kernel) +); + +bool pmSubtractionCalculateEquation( + psArray *stamps, ///< The stamps for which to calculate the equation, + const psImage *reference, ///< Reference image + const psImage *input, ///< Input image + const psSubtractionKernels *kernels,///< The kernel basis functions + psS32 footprint ///< Half-size of region over which to calculate equation +); + + +psVector *pmSubtractionSolveEquation( + psVector *solution, ///< Solution vector, or NULL + const psArray *stamps ///< Array of stamps +); + +bool pmSubtractionRejectStamps( + psArray *stamps, ///< Array of stamps to check for rejection + psImage *mask, ///< Mask image + psU32 badStampMaskVal, ///< Value to use in mask for bad stamp + psS32 footprint, ///< Region to mask if stamp is bad + psF32 sigmaRej, ///< Number of RMS deviations above zero at which to reject + const psImage *refImage, ///< Reference image + const psImage *inImage, ///< Input image + const psVector *solution, ///< Solution vector + const psSubtractionKernels *kernels ///< Array of kernel parameters +); + +psImage *pmSubtractionKernelImage( + psImage *out, + const psVector *solution, + const psSubtractionKernels *kernels, + psF32 x, + psF32 y +); + +#endif Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/imsubtract/pmSubtractBias.c =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/imsubtract/pmSubtractBias.c (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/imsubtract/pmSubtractBias.c (revision 21664) @@ -0,0 +1,577 @@ +////////////////////////////////////////////////////////////////////////////////////////////////////////////// +// XXX WARNING: I have completely replaced this file with an OLD VERSION (that works) instead of the +// one that was being worked on. +////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +/** @file pmSubtractBias.c + * + * This file will contain a module which will subtract the detector bias + * in place from an input image. + * + * @author GLG, MHPCC + * + * @version $Revision: 1.6.8.1.2.8 $ $Name: not supported by cvs2svn $ + * @date $Date: 2006-02-17 02:47:35 $ + * + * Copyright 2004 Maui High Performance Computing Center, University of Hawaii + * + */ + +#if HAVE_CONFIG_H +#include +#endif + +#include +#include "pmSubtractBias.h" + +#define PM_SUBTRACT_BIAS_POLYNOMIAL_ORDER 2 +#define PM_SUBTRACT_BIAS_SPLINE_ORDER 3 + + +#define MAX(a,b) ((a) > (b) ? (a) : (b)) +#define MIN(a,b) ((a) < (b) ? (a) : (b)) + + +// XXX: put these in psConstants.h +void PS_POLY1D_PRINT(psPolynomial1D *poly) +{ + printf("-------------- PS_POLY1D_PRINT() --------------\n"); + printf("poly->nX is %d\n", poly->nX); + for (psS32 i = 0 ; i < (1 + poly->nX) ; i++) { + printf("poly->coeff[%d] is %f\n", i, poly->coeff[i]); + } +} + +void PS_PRINT_SPLINE(psSpline1D *mySpline) +{ + printf("-------------- PS_PRINT_SPLINE() --------------\n"); + printf("mySpline->n is %d\n", mySpline->n); + for (psS32 i = 0 ; i < mySpline->n ; i++) { + PS_POLY1D_PRINT(mySpline->spline[i]); + } + PS_VECTOR_PRINT_F32(mySpline->knots); +} + +#define PS_IMAGE_PRINT_F32_HIDEF(NAME) \ +printf("======== printing %s ========\n", #NAME); \ +for (int i = 0 ; i < (NAME)->numRows ; i++) { \ + for (int j = 0 ; j < (NAME)->numCols ; j++) { \ + printf("%.5f ", (NAME)->data.F32[i][j]); \ + } \ + printf("\n"); \ +}\ + + +void overscanOptionsFree(pmOverscanOptions *options) +{ + psFree(options->stat); + psFree(options->poly); + psFree(options->spline); +} + +pmOverscanOptions *pmOverscanOptionsAlloc(bool single, pmFit fitType, unsigned int order, psStats *stat) +{ + pmOverscanOptions *opts = psAlloc(sizeof(pmOverscanOptions)); + psMemSetDeallocator(opts, (psFreeFunc)overscanOptionsFree); + + // Inputs + opts->single = single; + opts->fitType = fitType; + opts->order = order; + opts->stat = psMemIncrRefCounter(stat); + + // Outputs + opts->poly = NULL; + opts->spline = NULL; + + return opts; +} + + +/****************************************************************************** +psSubtractFrame(): this routine will take as input a readout for the input +image and a readout for the bias image. The bias image is subtracted in +place from the input image. +*****************************************************************************/ +static bool SubtractFrame(pmReadout *in,// Input readout + const pmReadout *sub, // Readout to be subtracted from input + float scale // Scale to apply before subtracting + ) +{ + assert(in); + assert(sub); + + psImage *inImage = in->image; // The input image + psImage *inMask = in->mask; // The input mask + psImage *subImage = sub->image; // The image to be subtracted + psImage *subMask = sub->mask; // The mask for the subtraction image + + // Offsets of the cells + int x0in = psMetadataLookupS32(NULL, in->parent->concepts, "CELL.X0"); + int y0in = psMetadataLookupS32(NULL, in->parent->concepts, "CELL.Y0"); + int x0sub = psMetadataLookupS32(NULL, sub->parent->concepts, "CELL.X0"); + int y0sub = psMetadataLookupS32(NULL, sub->parent->concepts, "CELL.Y0"); + + if ((inImage->numCols + x0in - x0sub) > subImage->numCols) { + psError(PS_ERR_UNKNOWN, true, "Image does not have enough columns for subtraction.\n"); + return false; + } + if ((inImage->numRows + y0in - y0sub) > subImage->numRows) { + psError(PS_ERR_UNKNOWN, true, "Image does not have enough rows for subtraction.\n"); + return false; + } + + if (scale == 1.0) { + for (int i = 0; i < inImage->numRows; i++) { + for (int j = 0; j < inImage->numCols; j++) { + inImage->data.F32[i][j] -= subImage->data.F32[i+y0in-y0sub][j+x0in-x0sub]; + if (inMask && subMask) { + inMask->data.U8[i][j] |= subMask->data.U8[i+y0in-y0sub][j+x0in-x0sub]; + } + } + } + } else { + for (int i = 0; i < inImage->numRows; i++) { + for (int j = 0; j < inImage->numCols; j++) { + inImage->data.F32[i][j] -= subImage->data.F32[i+y0in-y0sub][j+x0in-x0sub] * scale; + if (inMask && subMask) { + inMask->data.U8[i][j] |= subMask->data.U8[i+y0in-y0sub][j+x0in-x0sub]; + } + } + } + } + + return true; +} + + +#if 0 +/****************************************************************************** +ImageSubtractScalar(): subtract a scalar from the input image. + +XXX: Use a psLib function for this. + +XXX: This should + *****************************************************************************/ +static psImage *ImageSubtractScalar(psImage *image, + psF32 scalar) +{ + for (psS32 i=0;inumRows;i++) { + for (psS32 j=0;jnumCols;j++) { + image->data.F32[i][j]-= scalar; + } + } + return(image); +} +#endif + +/****************************************************************************** +GenNewStatOptions(): this routine will take as input the options member of the +stat data structure, determine if multiple options have been specified, issue +a warning message if so, and return the highest priority option (according to +the order of the if-statements in this code). The higher priority options are +listed lower in the code. + *****************************************************************************/ +static psStatsOptions GenNewStatOptions(const psStats *stat) +{ + psS32 numOptions = 0; + psStatsOptions opt = 0; + + if (stat->options & PS_STAT_ROBUST_MEDIAN) { + if (numOptions == 0) { + opt = PS_STAT_ROBUST_MEDIAN; + } + numOptions++; + } + + if (stat->options & PS_STAT_CLIPPED_MEAN) { + if (numOptions == 0) { + opt = PS_STAT_CLIPPED_MEAN; + } + numOptions++; + } + + if (stat->options & PS_STAT_SAMPLE_MEDIAN) { + if (numOptions == 0) { + opt = PS_STAT_SAMPLE_MEDIAN; + } + numOptions++; + } + + if (stat->options & PS_STAT_SAMPLE_MEAN) { + numOptions++; + opt = PS_STAT_SAMPLE_MEAN; + } + + + if (numOptions == 0) { + psError(PS_ERR_UNKNOWN,true, "No statistics options have been specified.\n"); + } + if (numOptions != 1) { + psLogMsg(__func__, PS_LOG_WARN, + "WARNING: pmSubtractBias.c: GenNewStatOptions(): Too many statistics options have been specified\n"); + } + return(opt); +} + + + +#if 0 +/****************************************************************************** +ScaleOverscanVector(): this routine takes as input an arbitrary vector, +creates a new vector of length n, and fills the new vector with the +interpolated values of the old vector. The type of interpolation is: + PM_FIT_POLYNOMIAL: fit a polynomial to the entire input vector data. + PM_FIT_SPLINE: fit splines to the input vector data. +XXX: Doesn't it make more sense to do polynomial interpolation on a few +elements of the input vector, rather than fit a polynomial to the entire +vector? + *****************************************************************************/ +static psVector *ScaleOverscanVector(psVector *overscanVector, + psS32 n, + void *fitSpec, + pmFit fit) +{ + psTrace(".psModule.pmSubtracBias.ScaleOverscanVector", 4, + "---- ScaleOverscanVector() begin (%d -> %d) ----\n", overscanVector->n, n); + // PS_VECTOR_PRINT_F32(overscanVector); + + if (NULL == overscanVector) { + return(overscanVector); + } + + // Allocate the new vector. + psVector *newVec = psVectorAlloc(n, PS_TYPE_F32); + + // + // If the new vector is the same size as the old, simply copy the data. + // + if (n == overscanVector->n) { + for (psS32 i = 0 ; i < n ; i++) { + newVec->data.F32[i] = overscanVector->data.F32[i]; + } + return(newVec); + } + psPolynomial1D *myPoly; + psSpline1D *mySpline; + psF32 x; + psS32 i; + if (fit == PM_FIT_POLYNOMIAL) { + // Fit a polynomial to the old overscan vector. + myPoly = (psPolynomial1D *) fitSpec; + PS_ASSERT_POLY_NON_NULL(myPoly, NULL); + myPoly = psVectorFitPolynomial1D(myPoly, NULL, 0, overscanVector, NULL, NULL); + if (myPoly == NULL) { + psError(PS_ERR_UNKNOWN, false, "ScaleOverscanVector()(1): Could not fit a polynomial to the psVector.\n"); + return(NULL); + } + + // For each element of the new vector, convert the x-ordinate to that + // of the old vector, use the fitted polynomial to determine the + // interpolated value at that point, and set the new vector. + for (i=0;in) / ((psF32) n); + newVec->data.F32[i] = psPolynomial1DEval(myPoly, x); + } + } else if (fit == PM_FIT_SPLINE) { + psS32 mustFreeSpline = 0; + // Fit a spline to the old overscan vector. + mySpline = (psSpline1D *) fitSpec; + // XXX: Does it make any sense to have a psSpline argument? + if (mySpline == NULL) { + mustFreeSpline = 1; + } + + // + // NOTE: Since the X arg in the psVectorFitSpline1D() function is NULL, + // splines endpoints will be from 0.0 to overscanVector->n-1. Must scale + // properly when doing the spline eval. + // + // mySpline = psVectorFitSpline1D(mySpline, NULL, overscanVector, NULL); + mySpline = psVectorFitSpline1D(NULL, overscanVector); + if (mySpline == NULL) { + psError(PS_ERR_UNKNOWN, false, "ScaleOverscanVector()(2): Could not fit a spline to the psVector.\n"); + return(NULL); + } + // PS_PRINT_SPLINE(mySpline); + + // For each element of the new vector, convert the x-ordinate to that + // of the old vector, use the fitted polynomial to determine the + // interpolated value at that point, and set the new vector. + for (i=0;in - 1] + x = ((psF32) i) * ((psF32) (overscanVector->n-1)) / ((psF32) n); + newVec->data.F32[i] = psSpline1DEval(mySpline, x); + } + if (mustFreeSpline ==1) { + psFree(mySpline); + } + // PS_VECTOR_PRINT_F32(newVec); + + + } else { + psError(PS_ERR_UNKNOWN, true, "unknown fit type. Returning NULL.\n"); + psFree(newVec); + return(NULL); + } + + psTrace(".psModule.pmSubtracBias.ScaleOverscanVector", 4, + "---- ScaleOverscanVector() exit ----\n"); + return(newVec); +} + +#endif + +// Produce an overscan vector from an array of pixels +static psVector *overscanVector(pmOverscanOptions *overscanOpts, // Overscan options + const psArray *pixels, // Array of vectors containing the pixel values + psStats *myStats // Statistic to use in reducing the overscan + ) +{ + // Reduce the overscans + psVector *reduced = psVectorAlloc(pixels->n, PS_TYPE_F32); // Overscan for each row + psVector *ordinate = psVectorAlloc(pixels->n, PS_TYPE_F32); // Ordinate + psVector *mask = psVectorAlloc(pixels->n, PS_TYPE_U8); // Mask for fitting + for (int i = 0; i < pixels->n; i++) { + psVector *values = pixels->data[i]; // Vector with overscan values + if (values->n > 0) { + mask->data.U8[i] = 0; + ordinate->data.F32[i] = 2.0*(float)i/(float)pixels->n - 1.0; // Scale to [-1,1] + psVectorStats(myStats, values, NULL, NULL, 0); + double reducedVal = NAN; // Result of statistics + if (! p_psGetStatValue(myStats, &reducedVal)) { + psError(PS_ERR_UNKNOWN, false, "p_psGetStatValue(): could not determine result " + "of statistics on row %d.\n", i); + return NULL; + } + reduced->data.F32[i] = reducedVal; + } else if (overscanOpts->fitType == PM_FIT_NONE) { + psError(PS_ERR_UNKNOWN, true, "The overscan is not supplied for all points on the " + "image, and no fit is requested.\n"); + return NULL; + } else { + // We'll fit this one out + mask->data.U8[i] = 1; + } + } + + // Fit the overscan, if required + switch (overscanOpts->fitType) { + case PM_FIT_NONE: + // No fitting --- that's easy. + break; + case PM_FIT_POLY_ORD: + if (overscanOpts->poly && (overscanOpts->poly->nX != overscanOpts->order || + overscanOpts->poly->type != PS_POLYNOMIAL_ORD)) { + psFree(overscanOpts->poly); + overscanOpts->poly = NULL; + } + if (! overscanOpts->poly) { + overscanOpts->poly = psPolynomial1DAlloc(PS_POLYNOMIAL_ORD, overscanOpts->order); + } + psVectorFitPolynomial1D(overscanOpts->poly, mask, 1, reduced, NULL, ordinate); + psFree(reduced); + reduced = psPolynomial1DEvalVector(overscanOpts->poly, ordinate); + break; + case PM_FIT_POLY_CHEBY: + if (overscanOpts->poly && (overscanOpts->poly->nX != overscanOpts->order || + overscanOpts->poly->type != PS_POLYNOMIAL_CHEB)) { + psFree(overscanOpts->poly); + overscanOpts->poly = NULL; + } + if (! overscanOpts->poly) { + overscanOpts->poly = psPolynomial1DAlloc(PS_POLYNOMIAL_CHEB, overscanOpts->order); + } + psVectorFitPolynomial1D(overscanOpts->poly, mask, 1, reduced, NULL, ordinate); + psFree(reduced); + reduced = psPolynomial1DEvalVector(overscanOpts->poly, ordinate); + break; + case PM_FIT_SPLINE: + // XXX I don't think psSpline1D is up to scratch yet --- it has no mask, and requires an + // input spline + overscanOpts->spline = psVectorFitSpline1D(reduced, ordinate); + psFree(reduced); + reduced = psSpline1DEvalVector(overscanOpts->spline, ordinate); + break; + default: + psError(PS_ERR_UNKNOWN, true, "Unknown value for the fitting type: %d\n", overscanOpts->fitType); + return NULL; + break; + } + + psFree(ordinate); + psFree(mask); + + return reduced; +} + + + +/****************************************************************************** +XXX: The SDRS does not specify type support. F32 is implemented here. + *****************************************************************************/ +pmReadout *pmSubtractBias(pmReadout *in, pmOverscanOptions *overscanOpts, + const pmReadout *bias, const pmReadout *dark) +{ + psTrace(".psModule.pmSubtracBias.pmSubtractBias", 4, + "---- pmSubtractBias() begin ----\n"); + PS_ASSERT_READOUT_NON_NULL(in, NULL); + PS_ASSERT_READOUT_NON_EMPTY(in, NULL); + PS_ASSERT_READOUT_TYPE(in, PS_TYPE_F32, NULL); + + psImage *image = in->image; // The input image + + // Overscan processing + if (overscanOpts) { + // Check for an unallowable pmFit. + if (overscanOpts->fitType != PM_FIT_NONE && overscanOpts->fitType != PM_FIT_POLY_ORD && + overscanOpts->fitType != PM_FIT_POLY_CHEBY && overscanOpts->fitType != PM_FIT_SPLINE) { + psError(PS_ERR_UNKNOWN, true, "Invalid fit type (%d). Returning original image.\n", overscanOpts->fitType); + return(in); + } + + psList *overscans = in->bias; // List of the overscan images + + psStats *myStats = psStatsAlloc(PS_STAT_SAMPLE_MEAN); // A new psStats, to avoid clobbering original + myStats->options = GenNewStatOptions(overscanOpts->stat); + + // Reduce all overscan pixels to a single value + if (overscanOpts->single) { + psVector *pixels = psVectorAlloc(0, PS_TYPE_F32); + pixels->n = 0; + psListIterator *iter = psListIteratorAlloc(overscans, PS_LIST_HEAD, false); // Iterator + psImage *overscan = NULL; // Overscan image from iterator + while ((overscan = psListGetAndIncrement(iter))) { + int index = pixels->n; // Index + pixels = psVectorRealloc(pixels, pixels->n + overscan->numRows * overscan->numCols); + // XXX Reimplement with memcpy + for (int i = 0; i < overscan->numRows; i++) { + for (int j = 0; j < overscan->numCols; j++) { + pixels->data.F32[index++] = overscan->data.F32[i][j]; + } + } + + } + psFree(iter); + + (void)psVectorStats(myStats, pixels, NULL, NULL, 0); + double reduced = NAN; // Result of statistics + if (! p_psGetStatValue(myStats, &reduced)) { + psError(PS_ERR_UNKNOWN, false, "p_psGetStatValue(): could not determine result from requested statistical operation. Returning input image.\n"); + return(in); + } + (void)psBinaryOp(image, image, "-", psScalarAlloc((float)reduced, PS_TYPE_F32)); + } else { + + // We do the regular overscan subtraction + + bool readRows = psMetadataLookupBool(NULL, in->parent->concepts, "CELL.READDIR");// Read direction + + if (readRows) { + // The read direction is rows + psArray *pixels = psArrayAlloc(image->numRows); // Array of vectors containing pixels + for (int i = 0; i < pixels->n; i++) { + psVector *values = psVectorAlloc(0, PS_TYPE_F32); + values->n = 0; + pixels->data[i] = values; + } + + // Pull the pixels out into the vectors + psListIterator *iter = psListIteratorAlloc(overscans, PS_LIST_HEAD, false); // Iterator + psImage *overscan = NULL; // Overscan image from iterator + while ((overscan = psListGetAndIncrement(iter))) { + int diff = image->row0 - overscan->row0; // Offset between the two regions + for (int i = MAX(0,diff); i < MIN(image->numRows, overscan->numRows + diff); i++) { + // i is row on overscan + // XXX Reimplement with memcpy + psVector *values = pixels->data[i]; + int index = values->n; // Index in the vector + values = psVectorRealloc(values, values->n + overscan->numCols); + for (int j = 0; j < overscan->numCols; j++) { + values->data.F32[index++] = overscan->data.F32[i][j]; + } + values->n += overscan->numCols; + pixels->data[i] = values; // Update the pointer in case it's moved + } + } + psFree(iter); + + // Reduce the overscans + psVector *reduced = overscanVector(overscanOpts, pixels, myStats); + psFree(pixels); + if (! reduced) { + return in; + } + + // Subtract row by row + for (int i = 0; i < image->numRows; i++) { + for (int j = 0; j < image->numCols; j++) { + image->data.F32[i][j] -= reduced->data.F32[i]; + } + } + psFree(reduced); + + } else { + // The read direction is columns + psArray *pixels = psArrayAlloc(image->numCols); // Array of vectors containing pixels + for (int i = 0; i < pixels->n; i++) { + psVector *values = psVectorAlloc(0, PS_TYPE_F32); + values->n = 0; + pixels->data[i] = values; + } + + // Pull the pixels out into the vectors + psListIterator *iter = psListIteratorAlloc(overscans, PS_LIST_HEAD, false); // Iterator + psImage *overscan = NULL; // Overscan image from iterator + while ((overscan = psListGetAndIncrement(iter))) { + int diff = image->col0 - overscan->col0; // Offset between the two regions + for (int i = MAX(0,diff); i < MIN(image->numCols, overscan->numCols + diff); i++) { + // i is column on overscan + // XXX Reimplement with memcpy + psVector *values = pixels->data[i]; + int index = values->n; // Index in the vector + values = psVectorRealloc(values, values->n + overscan->numRows); + for (int j = 0; j < overscan->numRows; j++) { + values->data.F32[index++] = overscan->data.F32[i][j]; + } + values->n += overscan->numRows; + pixels->data[i] = values; // Update the pointer in case it's moved + } + } + psFree(iter); + + // Reduce the overscans + psVector *reduced = overscanVector(overscanOpts, pixels, myStats); + psFree(pixels); + if (! reduced) { + return in; + } + + // Subtract column by column + for (int i = 0; i < image->numCols; i++) { + for (int j = 0; j < image->numRows; j++) { + image->data.F32[j][i] -= reduced->data.F32[i]; + } + } + psFree(reduced); + } + } + psFree(myStats); + } // End of overscan subtraction + + // Bias frame subtraction + if (bias) { + SubtractFrame(in, bias, 1.0); + } + + if (dark) { + // Get the scaling + float inTime = psMetadataLookupF32(NULL, in->parent->concepts, "CELL.DARKTIME"); + float darkTime = psMetadataLookupF32(NULL, dark->parent->concepts, "CELL.DARKTIME"); + SubtractFrame(in, dark, inTime/darkTime); + } + + return in; +} + + Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/imsubtract/pmSubtractBias.h =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/imsubtract/pmSubtractBias.h (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/imsubtract/pmSubtractBias.h (revision 21664) @@ -0,0 +1,77 @@ +////////////////////////////////////////////////////////////////////////////////////////////////////////////// +// XXX WARNING: I have completely replaced this file with an OLD VERSION (that works) instead of the +// one that was being worked on. +////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +/** @file pmSubtractBias.h + * + * This file will contain a module which will subtract the detector bias + * in place from an input image. + * + * @author GLG, MHPCC + * + * @version $Revision: 1.4.8.1.2.2 $ $Name: not supported by cvs2svn $ + * @date $Date: 2006-01-20 02:38:28 $ + * + * Copyright 2004 Maui High Performance Computing Center, University of Hawaii + * + */ + +#if !defined(PM_SUBTRACT_BIAS_H) +#define PM_SUBTRACT_BIAS_H + +#if HAVE_CONFIG_H +#include +#endif + +#include +#include +#include "pslib.h" + +#include "pmFPA.h" + +typedef enum { + PM_OVERSCAN_NONE, ///< No overscan subtraction + PM_OVERSCAN_EDGE, ///< Subtract the statistic of pixels along the to-be-determined readout direction + PM_OVERSCAN_ROWS, ///< Subtract rows + PM_OVERSCAN_COLUMNS, ///< Subtract columns + PM_OVERSCAN_ALL ///< Subtract the statistic of all pixels in overscan region +} pmOverscanAxis; + +typedef enum { + PM_FIT_NONE, ///< No fit + PM_FIT_POLY_ORD, ///< Fit ordinary polynomial + PM_FIT_POLY_CHEBY, ///< Fit Chebyshev polynomial + PM_FIT_SPLINE ///< Fit cubic splines +} pmFit; + +typedef struct +{ + // Inputs + bool single; // Reduce all overscan regions to a single value? + pmFit fitType; // Type of fit to overscan + unsigned int order; // Order of polynomial, or number of spline pieces + psStats *stat; // Statistic to use when reducing the minor direction + // Outputs + psPolynomial1D *poly; // Result of polynomial fit + psSpline1D *spline; // Result of spline fit +} +pmOverscanOptions; + +pmOverscanOptions *pmOverscanOptionsAlloc(bool single, pmFit fitType, unsigned int order, psStats *stat); + +pmReadout *pmSubtractBias(pmReadout *in, pmOverscanOptions *overscanOpts, + const pmReadout *bias, const pmReadout *dark); + +#if 0 +pmReadout *pmSubtractBias(pmReadout *in, ///< The input pmReadout image + void *fitSpec, ///< A polynomial or spline, defining the fit type. + const psList *overscans, ///< A psList of overscan images + pmOverscanAxis overScanAxis, ///< Defines how overscans are applied + psStats *stat, ///< The statistic to be used in combining overscan data + int nBin, ///< The amount of binning to be done image pixels. + pmFit fit, ///< PM_FIT_SPLINE, PM_FIT_POLYNOMIAL, or PM_FIT_NONE + const pmReadout *bias); ///< A possibly NULL bias pmReadout which is to be subtracted +#endif + +#endif Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/imsubtract/pmSubtractSky.c =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/imsubtract/pmSubtractSky.c (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/imsubtract/pmSubtractSky.c (revision 21664) @@ -0,0 +1,737 @@ +/** @file pmSubtractSky.c + * + * This file will contain a module which will create a model of the + * background sky and subtract that from the input image. + * + * @author GLG, MHPCC + * + * @version $Revision: 1.3 $ $Name: not supported by cvs2svn $ + * @date $Date: 2005-11-15 20:09:03 $ + * + * Copyright 2004 Maui High Performance Computing Center, University of Hawaii + * + * + * + */ + +#include +#include +#include "pslib.h" +#include "pmSubtractSky.h" + +// XXX: Get rid of the. Create pmUtils.h +psImage *p_psDetermineTrimmedImage( + pmReadout *in +); + +/****************************************************************************** +DetermineNumBits(data): This routine takes an enum psStatsOptions as an +argument and returns the number of non-zero bits. + +XXX: This code is duplicated in the ReadoutCombine file. + *****************************************************************************/ +static psS32 DetermineNumBits(psStatsOptions data) +{ + psTrace("SubtractSky.DetermineNumBits", 4, "Calling DetermineNumBits(0x%x)\n", data); + + psS32 i; + psU64 tmpData = data; + psS32 numBits = 0; + + for (i=0;i<(8 * sizeof(psStatsOptions));i++) { + if (0x0001 & tmpData) { + numBits++; + } + tmpData = tmpData >> 1; + } + + psTrace("SubtractSky.DetermineNumBits", 4, + "Calling DetermineNumBits(0x%x) -> %d\n", data, numBits); + return(numBits); +} + +/****************************************************************************** +getHighestPriorityStatOption(statOptions): this routine takes as input a +psStats->options with multiple options set and returns one with a single +option set according to the precedence set in the SDRS. + *****************************************************************************/ +static psU64 getHighestPriorityStatOption(psU64 statOptions) +{ + psTrace("SubtractSky.getHighestPriorityStatOption", 4, + "Calling getHighestPriorityStatOption(0x%x)\n", statOptions); + + if (statOptions & PS_STAT_SAMPLE_MEAN) { + return(PS_STAT_SAMPLE_MEAN); + } else if (statOptions & PS_STAT_SAMPLE_MEDIAN) { + return(PS_STAT_SAMPLE_MEDIAN); + } else if (statOptions & PS_STAT_CLIPPED_MEAN) { + return(PS_STAT_CLIPPED_MEAN); + } else if (statOptions & PS_STAT_ROBUST_MEAN) { + return(PS_STAT_ROBUST_MEAN); + } else if (statOptions & PS_STAT_ROBUST_MEDIAN) { + return(PS_STAT_ROBUST_MEDIAN); + } else if (statOptions & PS_STAT_ROBUST_MODE) { + return(PS_STAT_ROBUST_MODE); + } + psError(PS_ERR_UNKNOWN, true, "Unallowable option requested for statistically binning image pixels.\n"); + return(-1); +} + +/****************************************************************************** +psImage *binImage(origImage, binFactor, statOptions): This routine takes an +input psImage and scales it smaller by a factor of binFactor. The statistic +used in combining input pixels is specified in statOptions. + +XXX: use static vectors for myStats, binVector and binMask. +XXX: I coded this before I was aware of a psLib reBin function. I don't +use this function in this module. I'm keeping it here in the event that +requirements change and we might need a custom reBin function. + *****************************************************************************/ +/* +static psImage *binImage(psImage *origImage, + int binFactor, + psStatsOptions statOptions) +{ + psTrace("SubtractSky.binImage", 4, "Calling binImage(%d)\n", binFactor); + + if (binFactor <= 0) { + psLogMsg(__func__, PS_LOG_WARN, + "WARNING: binImage(): binFactor is %d\n", binFactor); + return(origImage); + } + if (binFactor == 1) { + return(origImage); + } + + psVector *binVector = psVectorAlloc(binFactor * binFactor, PS_TYPE_F32); + psVector *binMask = psVectorAlloc(binFactor * binFactor, PS_TYPE_U8); + psStats *myStats = psStatsAlloc(statOptions); + + for (psS32 row = 0; row < origImage->numRows ; row+=binFactor) { + for (psS32 col = 0; col < origImage->numCols ; col+=binFactor) { + psS32 count = 0; + for (psS32 binRow = 0; binRow <= binFactor ; binRow++) { + for (psS32 binCol = 0; binCol <= binFactor ; binCol++) { + if (((row + binRow) < origImage->numRows) && + ((col + binCol) < origImage->numCols)) { + binVector->data.F32[count] = + origImage->data.F32[row + binRow][col + binCol]; + binMask->data.U8[count] = 0; + } else { + binVector->data.F32[count] = 0.0; + binMask->data.U8[count] = 1; + } + count++; + } + } + psStats *rc1 = psVectorStats(myStats, binVector, NULL, binMask, 1); + if (rc1 == NULL) { + psError(PS_ERR_UNKNOWN, false, "psVectorStats(): could not perform requested statistical operation. Returning in image.\n"); + return(origImage); + } + psF64 statValue; + psBool rc = p_psGetStatValue(rc1, &statValue); + + if (rc == true) { + origImage->data.F32[row][col] = (psF32) statValue; + } else { + origImage->data.F32[row][col] = 0.0; + psLogMsg(__func__, PS_LOG_WARN, + "WARNING: pmSubtractSky(), binImage(): p_psGetStatValue() was FALSE\n"); + } + } + } + psFree(binVector); + psFree(binMask); + psFree(myStats); + + psTrace("SubtractSky.binImage", 4, "Exiting binImage(%d)\n", binFactor); + return(origImage); +} +*/ + +/****************************************************************************** +CalculatePolyTerms(xOrder, yOrder): this routine will calculate the number of +coefficients (or terms) in a 2-D polynomial of order (xOrder, yOrder). + +XXX: Use your brain and figure out the analytical expression. + +XXX: Why isn't it simply (xOrder+1) * (yOrder+1)? + *****************************************************************************/ +static psS32 CalculatePolyTerms(psS32 xOrder, psS32 yOrder) +{ + psTrace("SubtractSky.CalculatePolyTerms", 4, + "Calling CalculatePolyTerms(%d, %d)\n", xOrder, yOrder); + + psS32 maxOrder = PS_MAX(xOrder, yOrder); + psS32 localPolyTerms = 0; + psS32 order = 0; + psS32 num=0; + + for (order=0;order<=maxOrder;order++) { + for (num=0;num<=order;num++) { + if (((order-num) <= xOrder) && (num <= yOrder)) { + localPolyTerms++; + } + } + } + psTrace("SubtractSky.CalculatePolyTerms", 4, + "Exiting CalculatePolyTerms(%d, %d) -> %d\n", xOrder, yOrder, localPolyTerms); + return(localPolyTerms); + + // return((xOrder+1) * (yOrder+1)); +} + +/****************************************************************************** +buildPolyTerms(): this routine computes a 2-D array polyTerms[][] that holds +terms for the polynomial that is used to model the sky background. We use +this array primarily for convenience in computations involving sky model +polynomials. It is defined as: + polyTerms[i][0] = the power to which X is raised in the i-th term of in an + poly-order sky background polynomial. + + polyTerms[i][1] = the power to which Y is raised in the i-th term of in an + poly-order sky background polynomial. + *****************************************************************************/ +static psS32 **buildPolyTerms(psS32 xOrder, psS32 yOrder) +{ + psTrace("SubtractSky.buildPolyTerms", 4, + "Calling buildPolyTerms(%d, %d)\n", xOrder, yOrder); + + psS32 i=0; + psS32 order = 0; + psS32 num=0; + psS32 localPolyTerms = CalculatePolyTerms(xOrder, yOrder); + psS32 maxOrder = PS_MAX(xOrder, yOrder); + + // Create the data structure which we hold the xy order of each coeff. + psS32 **polyTerms = (psS32 **) psAlloc(localPolyTerms * sizeof(psS32 *)); + for (i=0; i < localPolyTerms ; i++) { + polyTerms[i] = (psS32 *) psAlloc(2 * sizeof(psS32)); + } + + i=0; + // This code segment loops through each term i in the polynomial and + // calculates the power to which x/y are raised in that i-th term. + // We first do the 0-order terms, then the 1-order terms, etc. + for (order=0;order<=maxOrder;order++) { + for (num=0;num<=order;num++) { + if (((order-num) <= xOrder) && (num <= yOrder)) { + polyTerms[i][0] = order-num; + polyTerms[i][1] = num; + i++; + } + } + } + + if (psTraceGetLevel(".psModule.pmSubtractSky.buildPolyTerms") >= 10) { + for (i=0; i < localPolyTerms ; i++) { + printf("x^%d * y^%d\n", polyTerms[i][0], polyTerms[i][1]); + } + } + + psTrace("SubtractSky.buildPolyTerms", 4, + "Exiting buildPolyTerms(%d, %d)\n", xOrder, yOrder); + return(polyTerms); +} + +/****************************************************************************** +This procedure calculates various combinations of powers of x and y and stores +them in the data structure p_psPolySums[][]. After it completes: + + p_psPolySums[i][j] == x^i * y^j + +XXX: Use a psImage for the p_psPolySums data structure? +XXX: p_psPolySums: should this be a global? Did you get the storage classifier + and name correct? +XXX: Use variable size arrays for p_psPolySums[][]. +XXX: Must initialize p_psPolySums[][]? + *****************************************************************************/ +#define PS_MAX_POLYNOMIAL_ORDER 20 + +psF64 p_psPolySums[PS_MAX_POLYNOMIAL_ORDER+1][PS_MAX_POLYNOMIAL_ORDER+1]; +static void buildSums(psF64 x, + psF64 y, + psS32 xOrder, + psS32 yOrder) +{ + psTrace("SubtractSky.buildPolyTerms", 4, + "Calling buildPolyTerms(%d, %d)\n", xOrder, yOrder); + + psS32 i = 0; + psS32 j = 0; + psF64 xSum = 0.0; + psF64 ySum = 0.0; + + xSum = 1.0; + ySum = 1.0; + for(i=0;i<=xOrder;i++) { + ySum = xSum; + for(j=0;j<=yOrder;j++) { + p_psPolySums[i][j] = ySum; + ySum*= y; + } + xSum*= x; + } + psTrace("SubtractSky.buildPolyTerms", 4, + "Exiting buildPolyTerms(%d, %d)\n", xOrder, yOrder); +} + +/****************************************************************************** +ImageFitPolynomial(myPoly, dataImage, maskImage): this private routine takes +an input image along with a mask and fits a polynomial to it. The degree of +the polynomial is specified by input parameter myPoly, and need not be +symmetrical in orders of X and Y. The polynomial must be type +PS_POLYNOMIAL_ORD. If there are not enough rows or columns in the input image +for the order of the polynomial, then that order is reduced. The algorithm +used in this routine is based on that of the pilot project ADD, but is not +documented anywhere. + +XXX: Different trace message facilities in use here. + *****************************************************************************/ +static psPolynomial2D *ImageFitPolynomial( + psPolynomial2D *myPoly, + psImage *dataImage, + psImage *maskImage) +{ + psTrace("SubtractSky.ImageFitPolynomial", 4, + "Calling ImageFitPolynomial()\n"); + PS_ASSERT_POLY_NON_NULL(myPoly, NULL); + PS_ASSERT_POLY_TYPE(myPoly, PS_POLYNOMIAL_ORD, NULL); + PS_ASSERT_IMAGE_NON_NULL(dataImage, NULL); + PS_ASSERT_IMAGE_NON_EMPTY(dataImage, NULL); + PS_ASSERT_IMAGE_TYPE(dataImage, PS_TYPE_F32, NULL); + PS_ASSERT_IMAGE_NON_NULL(maskImage, NULL); + PS_ASSERT_IMAGE_NON_EMPTY(maskImage, NULL); + PS_ASSERT_IMAGE_TYPE(maskImage, PS_TYPE_U8, NULL); + PS_ASSERT_IMAGES_SIZE_EQUAL(dataImage, maskImage, NULL); + psS32 oldPolyX = -1; + psS32 oldPolyY = -1; + + // The matrix equations become singular if there are more powers of X + // in myPoly then there are rows of the image. I think. Similarly for + // powers of Y and columns. So. Here we reduce the complexity of the + // polynomial if there are not enough rows/columns in the input image. + + if ((myPoly->nX + 1) > dataImage->numRows) { + psLogMsg(__func__, PS_LOG_WARN, + "WARNING: ImageFitPolynomial(): Reducing polynomial complexity in x-dimension.\n"); + oldPolyX = myPoly->nX; + myPoly->nX = dataImage->numRows - 1; + } + if ((myPoly->nY + 1) > dataImage->numCols) { + psLogMsg(__func__, PS_LOG_WARN, + "WARNING: ImageFitPolynomial(): Reducing polynomial complexity in y-dimension.\n"); + oldPolyY = myPoly->nY; + myPoly->nY = dataImage->numCols - 1; + } + psS32 i; + psS32 j; + psS32 x; + psS32 y; + psS32 aRow; + psS32 aCol; + psS32 **polyTerms = buildPolyTerms(myPoly->nX, myPoly->nY); + // We determine how many coefficients will be in the polynomial that we + // are fitting to this image. + psS32 localPolyTerms = CalculatePolyTerms(myPoly->nX, myPoly->nY); + psImage *A = psImageAlloc(localPolyTerms, localPolyTerms, PS_TYPE_F64); + psImage *Aout = psImageAlloc(localPolyTerms, localPolyTerms, PS_TYPE_F64); + psVector *B = psVectorAlloc(localPolyTerms, PS_TYPE_F64); + psVector *outPerm = NULL; + + // + // Initialize A matrix and B vector. + // + PS_IMAGE_SET_F64(A, 0.0); + PS_VECTOR_SET_F64(B, 0.0); + + // + // We build the A matrix and B vector. + // + for (x=0;xnumRows;x++) { + for (y=0;ynumCols;y++) { + if (maskImage->data.U8[x][y] == 0) { + buildSums((psF64) x, (psF64) y, myPoly->nX, myPoly->nY); + + /************************************************************ + This code dervies from equation (7) of the pilot ADD. However, + it is not exactly the same in that the order of the polynomial + may be different in X And Y. + + Equation (7) from the pilot ADD describes 16 linear equations. + The i-th equation is simply the partial derivative of the + sky background polynomial (1) w.r.t. to the i-th term in + that polynomial. The i-th equation is stored in row i of + matrix A[][] (matrix A[][] has origin (1,1), not (0,0)). To + compute A[i][j] we simply multiply the j-th term of the Sky + Background Polynomial (SBP) by the i-th term of SBP. + ************************************************************/ + for (aRow=0;aRowdata.F64[aRow][aCol]+= + (p_psPolySums[ polyTerms[aCol][0] ][ polyTerms[aCol][1] ] * + p_psPolySums[ polyTerms[aRow][0] ][ polyTerms[aRow][1] ]); + } + } + // Build the B[] vector, which is the right-hand side of (7). + for (i=0;idata.F64[i]+= dataImage->data.F32[x][y] * + p_psPolySums[ polyTerms[i][0] ][ polyTerms[i][1] ]; + } + } + } + } + + if (psTraceGetLevel(".psModule.pmSubtractSky.ImageFitPolynomial") >= 8) { + for (aRow=0;aRowdata.F64[aRow][aCol]); + } + } + + for (i=0;i<=localPolyTerms;i++) { + printf("B[%d] is %f\n", i, B->data.F64[i]); + } + } + + // + // Solve the matrix equations for the polynomial coefficients C. + // XXX: How do we know if these matrix operations were successful? + // + Aout = psMatrixLUD(Aout, &outPerm, A); + PS_ASSERT_IMAGE_NON_NULL(Aout, NULL); + PS_ASSERT_IMAGE_NON_EMPTY(Aout, NULL); + psVector *C = psVectorAlloc(localPolyTerms, PS_TYPE_F64); + psMatrixLUSolve(C, Aout, B, outPerm); + + // + // Set the appropriate coefficients in the myPoly structure. + // + for (i=0;icoeff[ polyTerms[i][0] ][ polyTerms[i][1] ] = C->data.F64[i]; + psTrace(".psModule.pmSubtractSky.ImageFitPolynomial", 6, + "myPoly->coeff[%d][%d] is %f\n", polyTerms[i][0], polyTerms[i][1], myPoly->coeff[ polyTerms[i][0] ][ polyTerms[i][1] ]); + } + + // + // Free data structures that were allocated in this module. + // + for (i=0;inX = oldPolyX; + for (i=oldPolyX ; i < (1 + myPoly->nX) ; i++) { + for (j=0;j<(1 + myPoly->nY) ; j++) { + myPoly->coeff[i][j] = 0.0; + } + } + } + if (oldPolyY != -1) { + myPoly->nY = oldPolyY; + for (i=0 ; i < (1 + myPoly->nX) ; i++) { + for (j=oldPolyY;j < (1 + myPoly->nY) ; j++) { + myPoly->coeff[i][j] = 0.0; + } + } + } + + psTrace("SubtractSky.ImageFitPolynomial", 4, + "Exiting ImageFitPolynomial()\n"); + // psTrace(".psModule.pmSubtractSky.ImageFitPolynomial", 4, + // "---- ImageFitPolynomial() end successfully ----\n"); + return(myPoly); +} + + +/****************************************************************************** +pmReadout pmSubtractSky(): + +XXX: use static vectors for myStats, and the binned image + +XXX: The SDR is silent about types. PS_TYPE_F32 is implemented here. + +XXX: Sync the psTrace message facilities. + *****************************************************************************/ +pmReadout *pmSubtractSky(pmReadout *in, + void *fitSpec, + psFit fit, + psS32 binFactor, + psStats *stats, + psF32 clipSD) +{ + PS_ASSERT_READOUT_NON_NULL(in, NULL); + PS_ASSERT_READOUT_NON_EMPTY(in, NULL); + PS_ASSERT_READOUT_TYPE(in, PS_TYPE_F32, NULL); + PS_WARN_PTR_NON_NULL(in->parent); + if (in->parent != NULL) { + PS_WARN_PTR_NON_NULL(in->parent->concepts); + } + psTrace(".psModule.pmSubtractSky", 4, + "---- pmSubtractSky() begin ----\n"); + + if ((fit != PM_FIT_NONE) && + (fit != PM_FIT_POLYNOMIAL) && + (fit != PM_FIT_SPLINE)) { + psError(PS_ERR_UNKNOWN, true, "psFit is unallowable (%d). Returning in image.\n", fit); + return(in); + } + + psStatsOptions statOptions = 0; + + // + // Return the original input readout if the fit specs are poorly defined. + // No warning or error messages should be generated. + // + if ((fitSpec == NULL) || + ((fit == PM_FIT_NONE) || (fit == PM_FIT_SPLINE))) { + // psLogMsg(__func__, PS_LOG_WARN, "Fit specs are poorly defined. Returning in image.\n"); + return(in); + } + + // + // Determine trimmed image from metadata. + // + + psImage *trimmedImg = p_psDetermineTrimmedImage(in); + psImage *binnedImage = NULL; + psPolynomial2D *myPoly = NULL; + psImage *binnedMaskImage = NULL; + psU32 oldStatOptions = 0; + + // + // Determine which statistic to use when binning pixels, if any. + // + if (stats != NULL) { + statOptions = stats->options; + if (1 < DetermineNumBits(statOptions)) { + psLogMsg(__func__, PS_LOG_WARN, "WARNING: Multiple statistical options have been requested.\n"); + statOptions = getHighestPriorityStatOption(statOptions); + if (statOptions == -1) { + psError(PS_ERR_UNKNOWN, true, "Not allowable stats->option was specified. Returning in image.\n"); + return(in); + } + // Save old input "stats" parameter. + oldStatOptions = stats->options; + stats->options = statOptions; + } + if (0 == DetermineNumBits(statOptions)) { + psLogMsg(__func__, PS_LOG_WARN, + "WARNING: pmSubtractSky(): no stats->options was requested\n"); + } + } + + // + // Generate required warning messages. + // + if (binFactor <= 0) { + psLogMsg(__func__, PS_LOG_WARN, + "WARNING: pmSubtractSky(): binFactor is %d\n", binFactor); + } + if (stats == NULL) { + psLogMsg(__func__, PS_LOG_WARN, + "WARNING: pmSubtractSky(): input parameter stats is NULL\n"); + } + + // + // Bin the input image according to input parameters. + // Create a new binned image mask. + // + if ((binFactor <= 1) || (stats == NULL) || (0 == DetermineNumBits(statOptions))) { + // No binning is required here. Simply create a copy of the image + // and a mask. + binnedImage = psImageCopy(binnedImage, trimmedImg, PS_TYPE_F32); + if (binnedImage == NULL) { + psError(PS_ERR_UNKNOWN, false, "psImageCopy() returned NULL. Returning in image.\n"); + return(in); + } + + if (in->mask != NULL) { + binnedMaskImage = psImageCopy(binnedMaskImage, in->mask, PS_TYPE_U8); + if (binnedMaskImage == NULL) { + psError(PS_ERR_UNKNOWN, false, "psImageCopy() returned NULL. Returning in image.\n"); + psFree(binnedImage); + return(in); + } + } else { + binnedMaskImage = psImageAlloc(binnedImage->numCols, + binnedImage->numRows, + PS_TYPE_U8); + PS_IMAGE_SET_U8(binnedMaskImage, 0); + } + } else { + binnedImage = psImageRebin(NULL, trimmedImg, in->mask, 0, binFactor, stats); + if (binnedImage == NULL) { + psError(PS_ERR_UNKNOWN, false, "psImageRebin() returned NULL. Returning in image.\n"); + return(in); + } + binnedMaskImage = psImageAlloc(binnedImage->numCols, + binnedImage->numRows, + PS_TYPE_U8); + PS_IMAGE_SET_U8(binnedMaskImage, 0); + } + psTrace(".psModule.pmSubtractSky", 4, + "binnedImage size is (%d, %d)\n", binnedImage->numRows, binnedImage->numCols); + + // + // Clip pixels that are outside the acceptable range. + // + if (clipSD <= 0.0) { + psLogMsg(__func__, PS_LOG_WARN, + "WARNING: pmSubtractSky(): clipSD is %f\n", clipSD); + } else { + // Determine the mean and standard deviation of the binned image. + psF64 binnedMean; + psF64 binnedStdev; + psStats *myStats = psStatsAlloc(PS_STAT_SAMPLE_MEAN); + psStats *rc = psImageStats(myStats, binnedImage, NULL, 0); + if (rc == NULL) { + psError(PS_ERR_UNKNOWN, false, "psImageStats(): could not perform requested statistical operation. Returning in image.\n"); + return(in); + } + if (false == p_psGetStatValue(rc, &binnedMean)) { + psError(PS_ERR_UNKNOWN, false, "p_psGetStatValue(): could not determine requested statistical operation. Returning in image.\n"); + return(in); + } + psTrace(".psModule.pmSubtractSky", 6, + "binned Mean is %f\n", binnedMean); + + myStats->options = PS_STAT_SAMPLE_STDEV; + rc = psImageStats(myStats, binnedImage, NULL, 0); + if (rc == NULL) { + psError(PS_ERR_UNKNOWN, false, "psImageStats(): could not perform requested statistical operation. Returning in image.\n"); + return(in); + } + if (false == p_psGetStatValue(myStats, &binnedStdev)) { + psError(PS_ERR_UNKNOWN, false, "p_psGetStatValue(): could not determine requested statistical operation. Returning in image.\n"); + return(in); + } + psFree(myStats); + psTrace(".psModule.pmSubtractSky", 6, + "binned StDev is %f\n", binnedStdev); + + // Clip all pixels which are more than clipSD sigmas from the mean. + psTrace(".psModule.pmSubtractSky", 6, + "clipSD is %f\n", clipSD); + + for (psS32 row = 0; row < binnedImage->numRows ; row++) { + for (psS32 col = 0; col < binnedImage->numCols ; col++) { + if (fabs(binnedImage->data.F32[row][col] - binnedMean) > + (clipSD * binnedStdev)) { + binnedMaskImage->data.U8[row][col] = 1; + } + } + } + } + + // + // Fit the polynomial to the binned image + // + if (fit == PM_FIT_POLYNOMIAL) { + myPoly = (psPolynomial2D *) fitSpec; + PS_ASSERT_POLY_NON_NULL(myPoly, NULL); + PS_ASSERT_POLY_TYPE(myPoly, PS_POLYNOMIAL_ORD, NULL); + + myPoly = ImageFitPolynomial(myPoly, binnedImage, binnedMaskImage); + + if (myPoly != NULL) { + // Set the pixels in the binned image to that of the polynomial. + binnedImage = psImageEvalPolynomial(binnedImage, myPoly); + if (binnedImage == NULL) { + psError(PS_ERR_UNKNOWN, false, "psImageEvalPolynomial() returned NULL. Returning in image.\n"); + psFree(binnedMaskImage); + if (!((binFactor <= 1) || (stats == NULL))) { + psFree(binnedImage); + } + if (oldStatOptions != 0) { + stats->options = statOptions; + } + return(in); + } + } else { + psLogMsg(__func__, PS_LOG_WARN, + "WARNING: pmSubtractSky(): could not model sky with a polynomial.\n"); + psFree(binnedMaskImage); + if (!((binFactor <= 1) || (stats == NULL))) { + psFree(binnedImage); + } + if (oldStatOptions != 0) { + stats->options = statOptions; + } + return(in); + } + } else { + // We shouldn't get here since we check this above. + psError(PS_ERR_UNKNOWN, true, "Unallowable fit type. Returning in image.\n"); + psFree(binnedMaskImage); + if (!((binFactor <= 1) || (stats == NULL))) { + psFree(binnedImage); + } + if (oldStatOptions != 0) { + stats->options = statOptions; + } + return(in); + } + + // + //Subtract the polynomially fitted image from the original image + // + if (binFactor <= 1) { + // The binned image is the same size as the original image. + for (psS32 row = 0; row < trimmedImg->numRows ; row++) { + for (psS32 col = 0; col < trimmedImg->numCols ; col++) { + trimmedImg->data.F32[row][col]-= binnedImage->data.F32[row][col]; + } + } + } else { + for (psS32 row = 0; row < trimmedImg->numRows ; row++) { + for (psS32 col = 0; col < trimmedImg->numCols ; col++) { + // We calculate the F32 value of the pixel coordinates in the + // binned image and then use a pixel interpolation routine to + // determine the value of the pixel at that location. + psF32 binRowF64 = ((psF32) row) / ((psF32) binFactor); + psF32 binColF64 = ((psF32) col) / ((psF32) binFactor); + + // We add 0.5 to the pixel locations since the pixel + // interpolation routine defines the location of pixel + // (i, j) as (i+0.5, j+0.5). + binRowF64+= 0.5; + binColF64+= 0.5; + + psF32 binPixel = (psF32) psImagePixelInterpolate( + binnedImage, binColF64, binRowF64, + NULL, 0, 0.0, PS_INTERPOLATE_BILINEAR); + trimmedImg->data.F32[row][col]-= binPixel; + + psTrace(".psModule.pmSubtractSky", 8, + "image[%d][%d] <--> binnedImage[%.2f][%.2f]: %f\n", + row, col, binRowF64-0.5, binColF64-0.5, binPixel); + } + } + + } + psFree(binnedMaskImage); + psFree(binnedImage); + if (oldStatOptions != 0) { + stats->options = statOptions; + } + + psTrace(".psModule.pmSubtractSky", 4, + "---- pmSubtractSky() exit successfully ----\n"); + return(in); +} Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/imsubtract/pmSubtractSky.h =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/imsubtract/pmSubtractSky.h (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/imsubtract/pmSubtractSky.h (revision 21664) @@ -0,0 +1,40 @@ +/** @file pmSubtractSky.h + * + * This file will contain a module which will create a model of the + * background sky and subtract that from the input image. + * + * @author GLG, MHPCC + * + * @version $Revision: 1.1.18.1 $ $Name: not supported by cvs2svn $ + * @date $Date: 2006-01-20 02:38:28 $ + * + * Copyright 2004 Maui High Performance Computing Center, University of Hawaii + * + */ + +#if !defined(PM_SUBTRACT_SKY_H) +#define PM_SUBTRACT_SKY_H + +#if HAVE_CONFIG_H +#include +#endif + +#include +#include +#include "pslib.h" +#include "pmFPA.h" + +// XXX: this is pmFit in pmSubtractBias.c, named psFit here. +typedef enum { + PM_FIT_NONE, ///< No fit + PM_FIT_POLYNOMIAL, ///< Fit polynomial + PM_FIT_SPLINE ///< Fit cubic splines +} psFit; + +pmReadout *pmSubtractSky(pmReadout *in, + void *fitSpec, + psFit fit, + int binFactor, + psStats *stats, + float clipSD); +#endif Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/mainpage.dox =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/mainpage.dox (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/mainpage.dox (revision 21664) @@ -0,0 +1,127 @@ +/** @mainpage psModule Image Processing Library + + +@section intro Introduction +This library contains the Pan-STARRS Image Processing Pipeline (IPP) modules (psModule). These modules +use the functionality of the Pan-STARRS Library (psLib) to perform more complex tasks associated with image +processing. Modules were constructed to support each of the required processing stages and are listed according +to the particular processing stage for which they will primarily be used. To preserve namespace, globally-visible +structures and functions are prefixed with pm, an abbreviation for Pan-STARRS Modules. + +The capabilities provided by psModule are grouped into the following areas which are +also reflected in the file system directory structure: + - Configuration + - Astrometry, Focal Plane + - Photometry + - Basic Image Detrending + - Object Detection and Classification + - Image Combination + - Image Subtraction + +The installed code for psModule consists of header files and a binary library. + +@section extinstall Required external Libraries + +Before building psLib from source, several external software libraries must +be installed. These include: + - Pan-STARRS Library (psLib) + - Available from the Maui High Performance Computiong Center (MHPCC) at https://mhpcc.pan-starrs.org/code/releases + - Compatibility tested with rel5 + - Note, psLib itself has many external library dependencies. + - Doxygen Documentation System + - Only needed if code documentation is to be made + - 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 + +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 +and psModule. Though it is quite possible that later versions of the libraries +listed will also work, 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 psModule are put into a tar file and can be downloaded from: + +https://mhpcc.pan-starrs.org/code/releases + +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 psModule
+
+where: + - USERNAME is your login name on the server + - RELEASEBRANCH is the desired release branch, e.g. rel7. + + +@section build How to Build and Test the psModule Library. + +The psModule library and associated tests are made via the GNU autoconf/automake system. + +The source should build using the configure script in the psModule directory. The +recommended steps are: +
+$ cd psModule
+$ ./configure
+$ make
+$ make check
+$ make install
+
+Unless otherwise specified, the library is installed with PREFIX of the current directory. + +If the code was retrieved from CVS, you will need to substitute 'autogen.sh' for 'configure' in +above example. + +Other configuration options, such as location of external libraries, are also available. +To get a list of options, type the following in the top psModule directory. +
+$ configure --help
+
+A likely option needed is '--with-pslib-config', which specifies the location of +the configuration script for psLib. By default, configure searches for it using PATH, but that +is not always sufficient. + +@section install How to Install + +To install the library using the prefix given in the configure step, execute in +the top build directory: +
+$ make install
+
+ + +@section usage Building and Linking your code to the psModule library + +To assist the use of the library with your own code, a configuration tool is part +of the psModule library package. This tool, psmodule-config, is installed in the BIN +directory, according to the options given to the configure script. + +The required CFLAG options for the compiler stage of code that uses psModule can be +obtained via 'psmodule-config --cflags'. This outputs the cc options that supplies +include path(s) required to find the psModule headers. + +The required linking options, can be obtained via 'psmodule-config --libs'. This +outputs the ld options that supplies the library paths and files required to +link to the psModule library. + +Note: psmodule-config usage above refers to the install locations of the library. + +@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 psModule
+$ make docs
+
+This places documentation in PREFIX/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: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/objects/.cvsignore =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/objects/.cvsignore (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/objects/.cvsignore (revision 21664) @@ -0,0 +1,6 @@ +.deps +.libs +Makefile +Makefile.in +*.la +*.lo Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/objects/Makefile.am =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/objects/Makefile.am (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/objects/Makefile.am (revision 21664) @@ -0,0 +1,26 @@ +noinst_LTLIBRARIES = libpsmoduleobjects.la + +libpsmoduleobjects_la_CPPFLAGS = $(SRCINC) $(PSMODULE_CFLAGS) +libpsmoduleobjects_la_LDFLAGS = -release $(PACKAGE_VERSION) +libpsmoduleobjects_la_SOURCES = \ + pmObjects.c \ + pmPSF.c \ + pmPSFtry.c \ + pmModelGroup.c \ + pmGrowthCurve.c \ + psEllipse.c + +EXTRA_DIST = \ + models/pmModel_GAUSS.c \ + models/pmModel_PGAUSS.c \ + models/pmModel_QGAUSS.c \ + models/pmModel_SGAUSS.c + +psmoduleincludedir = $(includedir) +psmoduleinclude_HEADERS = \ + pmObjects.h \ + pmPSF.h \ + pmPSFtry.h \ + pmModelGroup.h \ + pmGrowthCurve.h \ + psEllipse.h Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/objects/models/pmModel_GAUSS.c =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/objects/models/pmModel_GAUSS.c (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/objects/models/pmModel_GAUSS.c (revision 21664) @@ -0,0 +1,164 @@ + +/****************************************************************************** + params->data.F32[0] = So; + params->data.F32[1] = Zo; + params->data.F32[2] = Xo; + params->data.F32[3] = Yo; + params->data.F32[4] = sqrt(2.0) / SigmaX; + params->data.F32[5] = sqrt(2.0) / SigmaY; + params->data.F32[6] = Sxy; +*****************************************************************************/ + +psF32 pmModelFunc_GAUSS(psVector *deriv, + const psVector *params, + const psVector *x) +{ + psF32 X = x->data.F32[0] - params->data.F32[2]; + psF32 Y = x->data.F32[1] - params->data.F32[3]; + psF32 px = params->data.F32[4]*X; + psF32 py = params->data.F32[5]*Y; + psF32 z = 0.5*PS_SQR(px) + 0.5*PS_SQR(py) + params->data.F32[6]*X*Y; + psF32 r = exp(-z); + psF32 q = params->data.F32[1]*r; + psF32 f = q + params->data.F32[0]; + + if (deriv != NULL) { + deriv->data.F32[0] = +1.0; + deriv->data.F32[1] = +r; + deriv->data.F32[2] = q*(2*px*params->data.F32[4] + params->data.F32[6]*Y); + deriv->data.F32[3] = q*(2*py*params->data.F32[5] + params->data.F32[6]*X); + deriv->data.F32[4] = -2.0*q*px*X; + deriv->data.F32[5] = -2.0*q*py*Y; + deriv->data.F32[6] = -q*X*Y; + } + return(f); +} + +psF64 pmModelFlux_GAUSS(const psVector *params) +{ + psF64 A1 = PS_SQR(params->data.F32[4]); + psF64 A2 = PS_SQR(params->data.F32[5]); + psF64 A3 = PS_SQR(params->data.F32[6]); + psF64 Area = 2.0 * M_PI / sqrt(A1*A2 - A3); + // Area is equivalent to 2 pi sigma^2 + + psF64 Flux = params->data.F32[1] * Area; + + return(Flux); +} + +// return the radius which yields the requested flux +psF64 pmModelRadius_GAUSS (const psVector *params, psF64 flux) +{ + + if (flux <= 0) + return (1.0); + if (params->data.F32[1] <= 0) + return (1.0); + if (flux >= params->data.F32[1]) + return (1.0); + + psF64 sigma = sqrt(2.0) * hypot (1.0 / params->data.F32[4], 1.0 / params->data.F32[5]); + psF64 radius = sigma * sqrt (2.0 * log(params->data.F32[1] / flux)); + return (radius); +} + +// define the parameter limits +bool pmModelLimits_GAUSS (psVector **beta_lim, psVector **params_min, psVector **params_max) +{ + + *beta_lim = psVectorAlloc (7, PS_TYPE_F32); + *params_min = psVectorAlloc (7, PS_TYPE_F32); + *params_max = psVectorAlloc (7, PS_TYPE_F32); + + beta_lim[0][0].data.F32[0] = 1000; + beta_lim[0][0].data.F32[1] = 10000; + beta_lim[0][0].data.F32[2] = 5; + beta_lim[0][0].data.F32[3] = 5; + beta_lim[0][0].data.F32[4] = 0.5; + beta_lim[0][0].data.F32[5] = 0.5; + beta_lim[0][0].data.F32[6] = 0.5; + + params_min[0][0].data.F32[0] = -1000; + params_min[0][0].data.F32[1] = 0; + params_min[0][0].data.F32[2] = -100; + params_min[0][0].data.F32[3] = -100; + params_min[0][0].data.F32[4] = 0.01; + params_min[0][0].data.F32[5] = 0.01; + params_min[0][0].data.F32[6] = -5.0; + + params_max[0][0].data.F32[0] = 1e5; + params_max[0][0].data.F32[1] = 1e6; + params_max[0][0].data.F32[2] = 1e4; // this should be set by image dimensions! + params_max[0][0].data.F32[3] = 1e4; // this should be set by image dimensions! + params_max[0][0].data.F32[4] = 2.0; + params_max[0][0].data.F32[5] = 2.0; + params_max[0][0].data.F32[6] = +5.0; + + return (TRUE); +} + +// make an initial guess for parameters +bool pmModelGuess_GAUSS (pmModel *model, pmSource *source) +{ + + pmMoments *moments = source->moments; + psF32 *params = model->params->data.F32; + + params[0] = moments->Sky; + params[1] = moments->Peak - moments->Sky; + params[2] = moments->x; + params[3] = moments->y; + params[4] = 1.2 / moments->Sx; + params[5] = 1.2 / moments->Sy; + params[6] = 0.0; + return(true); +} + +// construct the PSF model from the FLT model and the psf +bool pmModelFromPSF_GAUSS (pmModel *modelPSF, pmModel *modelFLT, pmPSF *psf) +{ + + psF32 *out = modelPSF->params->data.F32; + psF32 *in = modelFLT->params->data.F32; + + out[0] = in[0]; + out[1] = in[1]; + out[2] = in[2]; + out[3] = in[3]; + + for (int i = 4; i < 7; i++) { + psPolynomial2D *poly = psf->params->data[i-4]; + // XXX: be wary of a bug here. EAM had his own version of psPolynomial2DEval(). + // I think the reason was that hewas using nX=xOrder. Not sure. I changed this + // without verifying. + // out[i] = Polynomial2DEval_EAM (poly, out[2], out[3]); + out[i] = psPolynomial2DEval(poly, out[2], out[3]); + } + return(true); +} + +// check the status of the fitted model +bool pmModelFitStatus_GAUSS (pmModel *model) +{ + + psF32 dP; + bool status; + + psF32 *PAR = model->params->data.F32; + psF32 *dPAR = model->dparams->data.F32; + + dP = 0; + dP += PS_SQR(dPAR[4] / PAR[4]); + dP += PS_SQR(dPAR[5] / PAR[5]); + dP = sqrt (dP); + + status = true; + status &= (dP < 0.5); + status &= (PAR[1] > 0); + status &= ((dPAR[1]/PAR[1]) < 0.5); + + if (status) + return true; + return false; +} Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/objects/models/pmModel_PGAUSS.c =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/objects/models/pmModel_PGAUSS.c (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/objects/models/pmModel_PGAUSS.c (revision 21664) @@ -0,0 +1,177 @@ + +/****************************************************************************** + params->data.F32[0] = So; + params->data.F32[1] = Zo; + params->data.F32[2] = Xo; + params->data.F32[3] = Yo; + params->data.F32[4] = sqrt(2.0) / SigmaX; + params->data.F32[5] = sqrt(2.0) / SigmaY; + params->data.F32[6] = Sxy; +*****************************************************************************/ + +psF32 pmModelFunc_PGAUSS(psVector *deriv, + const psVector *params, + const psVector *x) +{ + psF32 *PAR = params->data.F32; + + psF32 X = x->data.F32[0] - PAR[2]; + psF32 Y = x->data.F32[1] - PAR[3]; + psF32 px = PAR[4]*X; + psF32 py = PAR[5]*Y; + psF32 z = 0.5*PS_SQR(px) + 0.5*PS_SQR(py) + PAR[6]*X*Y; + psF32 t = 1 + z + z*z/2.0; + psF32 r = 1.0 / (t + z*z*z/6.0); /* exp (-Z) */ + psF32 f = PAR[1]*r + PAR[0]; + + if (deriv != NULL) { + psF32 *dPAR = deriv->data.F32; + psF32 q = PAR[1]*r*r*t; + dPAR[0] = +1.0; + dPAR[1] = +r; + dPAR[2] = q*(2.0*px*PAR[4] + PAR[6]*Y); + dPAR[3] = q*(2.0*py*PAR[5] + PAR[6]*X); + dPAR[4] = -2.0*q*px*X; + dPAR[5] = -2.0*q*py*Y; + dPAR[6] = -q*X*Y; + } + return(f); +} + +bool pmModelLimits_PGAUSS (psVector **beta_lim, psVector **params_min, psVector **params_max) +{ + + *beta_lim = psVectorAlloc (7, PS_TYPE_F32); + *params_min = psVectorAlloc (7, PS_TYPE_F32); + *params_max = psVectorAlloc (7, PS_TYPE_F32); + + beta_lim[0][0].data.F32[0] = 1000; + beta_lim[0][0].data.F32[1] = 3e6; + beta_lim[0][0].data.F32[2] = 5; + beta_lim[0][0].data.F32[3] = 5; + beta_lim[0][0].data.F32[4] = 0.5; + beta_lim[0][0].data.F32[5] = 0.5; + beta_lim[0][0].data.F32[6] = 0.5; + + params_min[0][0].data.F32[0] = -1000; + params_min[0][0].data.F32[1] = 0; + params_min[0][0].data.F32[2] = -100; + params_min[0][0].data.F32[3] = -100; + params_min[0][0].data.F32[4] = 0.01; + params_min[0][0].data.F32[5] = 0.01; + params_min[0][0].data.F32[6] = -5.0; + + params_max[0][0].data.F32[0] = 1e5; + params_max[0][0].data.F32[1] = 1e8; + params_max[0][0].data.F32[2] = 1e4; // this should be set by image dimensions! + params_max[0][0].data.F32[3] = 1e4; // this should be set by image dimensions! + params_max[0][0].data.F32[4] = 2.0; + params_max[0][0].data.F32[5] = 2.0; + params_max[0][0].data.F32[6] = +5.0; + + return (TRUE); +} + +psF64 pmModelFlux_PGAUSS(const psVector *params) +{ + float f, norm, z; + + psF32 *PAR = params->data.F32; + + psF64 A1 = PS_SQR(PAR[4]); + psF64 A2 = PS_SQR(PAR[5]); + psF64 A3 = PS_SQR(PAR[6]); + psF64 Area = 2.0 * M_PI / sqrt(A1*A2 - A3); + // Area is equivalent to 2 pi sigma^2 + + // the area needs to be multiplied by the integral of f(z) + norm = 0.0; + for (z = 0.005; z < 50; z += 0.01) { + f = 1.0 / (1 + z + z*z/2 + z*z*z/6); + norm += f; + } + norm *= 0.01; + + psF64 Flux = params->data.F32[1] * Area * norm; + + return(Flux); +} + +// define this function so it never returns Inf or NaN +// return the radius which yields the requested flux +psF64 pmModelRadius_PGAUSS (const psVector *params, psF64 flux) +{ + if (flux <= 0) + return (1.0); + if (params->data.F32[1] <= 0) + return (1.0); + if (flux >= params->data.F32[1]) + return (1.0); + + psF64 sigma = sqrt(2.0) * hypot (1.0 / params->data.F32[4], 1.0 / params->data.F32[5]); + psF64 radius = sigma * sqrt (2.0 * log(params->data.F32[1] / flux)); + if (isnan(radius)) { + fprintf (stderr, "error in code\n"); + } + return (radius); +} + +bool pmModelGuess_PGAUSS (pmModel *model, pmSource *source) +{ + + pmMoments *moments = source->moments; + psF32 *params = model->params->data.F32; + + params[0] = moments->Sky; + params[1] = moments->Peak - moments->Sky; + params[2] = moments->x; + params[3] = moments->y; + params[4] = 1.2 / moments->Sx; + params[5] = 1.2 / moments->Sy; + params[6] = 0.0; + + return(true); +} + +bool pmModelFromPSF_PGAUSS (pmModel *modelPSF, pmModel *modelFLT, pmPSF *psf) +{ + + psF32 *out = modelPSF->params->data.F32; + psF32 *in = modelFLT->params->data.F32; + + out[0] = in[0]; + out[1] = in[1]; + out[2] = in[2]; + out[3] = in[3]; + + for (int i = 4; i < 7; i++) { + psPolynomial2D *poly = psf->params->data[i-4]; + // XXX: Verify this (from EAM change) + out[i] = psPolynomial2DEval(poly, out[2], out[3]); + } + return(true); +} + +bool pmModelFitStatus_PGAUSS (pmModel *model) +{ + + psF32 dP; + bool status; + + psF32 *PAR = model->params->data.F32; + psF32 *dPAR = model->dparams->data.F32; + + dP = 0; + dP += PS_SQR(dPAR[4] / PAR[4]); + dP += PS_SQR(dPAR[5] / PAR[5]); + dP = sqrt (dP); + + status = true; + status &= (dP < 0.5); + status &= (PAR[1] > 0); + status &= ((dPAR[1]/PAR[1]) < 0.5); + + if (status) + return true; + return false; +} Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/objects/models/pmModel_QGAUSS.c =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/objects/models/pmModel_QGAUSS.c (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/objects/models/pmModel_QGAUSS.c (revision 21664) @@ -0,0 +1,205 @@ + +/****************************************************************************** + one component, two slopes: + 1 / (1 + z^M + z^N) + + params->data.F32[0] = So; + params->data.F32[1] = Zo; + params->data.F32[2] = Xo; + params->data.F32[3] = Yo; + params->data.F32[4] = sqrt(2.0) / SigmaX; + params->data.F32[5] = sqrt(2.0) / SigmaY; + params->data.F32[6] = Sxy; + params->data.F32[7] = + params->data.F32[8] = +*****************************************************************************/ + +psF32 pmModelFunc_QGAUSS(psVector *deriv, + const psVector *params, + const psVector *x) +{ + psF32 *PAR = params->data.F32; + + psF32 X = x->data.F32[0] - PAR[2]; + psF32 Y = x->data.F32[1] - PAR[3]; + psF32 px = PAR[4]*X; + psF32 py = PAR[5]*Y; + psF32 z = 0.5*PS_SQR(px) + 0.5*PS_SQR(py) + PAR[6]*X*Y; + + psF32 r = 1.0 / (1 + PAR[7]*z + pow(z, 2.25)); + psF32 f = PAR[1]*r + PAR[0]; + + if (deriv != NULL) { + psF32 *dPAR = deriv->data.F32; + + // note difference from a pure gaussian: q = params->data.F32[1]*r + psF32 t = PAR[1]*r*r; + psF32 q = t*(PAR[7] + 2.25*pow(z, 1.25)); + + dPAR[0] = +1.0; + dPAR[1] = +r; + dPAR[2] = q*(2.0*px*PAR[4] + PAR[6]*Y); + dPAR[3] = q*(2.0*py*PAR[5] + PAR[6]*X); + dPAR[4] = -2.0*q*px*X; + dPAR[5] = -2.0*q*py*Y; + dPAR[6] = -q*X*Y; + dPAR[7] = -t*z; + } + return(f); +} + +bool pmModelLimits_QGAUSS (psVector **beta_lim, psVector **params_min, psVector **params_max) +{ + + *beta_lim = psVectorAlloc (8, PS_TYPE_F32); + *params_min = psVectorAlloc (8, PS_TYPE_F32); + *params_max = psVectorAlloc (8, PS_TYPE_F32); + + beta_lim[0][0].data.F32[0] = 1000; + beta_lim[0][0].data.F32[1] = 3e6; + beta_lim[0][0].data.F32[2] = 5; + beta_lim[0][0].data.F32[3] = 5; + beta_lim[0][0].data.F32[4] = 0.5; + beta_lim[0][0].data.F32[5] = 0.5; + beta_lim[0][0].data.F32[6] = 0.5; + beta_lim[0][0].data.F32[7] = 0.5; + + params_min[0][0].data.F32[0] = -1000; + params_min[0][0].data.F32[1] = 0; + params_min[0][0].data.F32[2] = -100; + params_min[0][0].data.F32[3] = -100; + params_min[0][0].data.F32[4] = 0.01; + params_min[0][0].data.F32[5] = 0.01; + params_min[0][0].data.F32[6] = -5.0; + params_min[0][0].data.F32[7] = 0.1; + + params_max[0][0].data.F32[0] = 1e5; + params_max[0][0].data.F32[1] = 1e8; + params_max[0][0].data.F32[2] = 1e4; // this should be set by image dimensions! + params_max[0][0].data.F32[3] = 1e4; // this should be set by image dimensions! + params_max[0][0].data.F32[4] = 2.0; + params_max[0][0].data.F32[5] = 2.0; + params_max[0][0].data.F32[6] = +5.0; + params_max[0][0].data.F32[7] = 10.0; + + return (TRUE); +} + +bool pmModelGuess_QGAUSS (pmModel *model, pmSource *source) +{ + + pmMoments *moments = source->moments; + pmPeak *peak = source->peak; + psF32 *params = model->params->data.F32; + + params[0] = moments->Sky; + params[1] = moments->Peak - moments->Sky; + params[2] = peak->x; + params[3] = peak->y; + params[4] = 1.2 / moments->Sx; + params[5] = 1.2 / moments->Sy; + params[6] = 0.0; + params[7] = 1.0; + return(true); +} + +psF64 pmModelFlux_QGAUSS(const psVector *params) +{ + float f, norm, z; + + psF32 *PAR = params->data.F32; + + psF64 A1 = PS_SQR(PAR[4]); + psF64 A2 = PS_SQR(PAR[5]); + psF64 A3 = PS_SQR(PAR[6]); + psF64 Area = 2.0 * M_PI / sqrt(A1*A2 - A3); + // Area is equivalent to 2 pi sigma^2 + + // the area needs to be multiplied by the integral of f(z) + norm = 0.0; + for (z = 0.005; z < 50; z += 0.01) { + f = 1.0 / (1 + PAR[7]*z + pow(z, 2.25)); + norm += f; + } + norm *= 0.01; + + psF64 Flux = PAR[1] * Area * norm; + + return(Flux); +} + +// define this function so it never returns Inf or NaN +// return the radius which yields the requested flux +psF64 pmModelRadius_QGAUSS (const psVector *params, psF64 flux) +{ + psF64 z, f; + psF32 *PAR = params->data.F32; + + if (flux <= 0) + return (1.0); + if (PAR[1] <= 0) + return (1.0); + if (flux >= PAR[1]) + return (1.0); + + // if Sx == Sy, sigma = Sx == Sy + psF64 sigma = hypot (1.0 / PAR[4], 1.0 / PAR[5]) / sqrt(2.0); + psF64 dz = 1.0 / (2.0 * sigma*sigma); + psF64 limit = flux / PAR[1]; + + // we can do this much better with intelligent choices here + for (z = 0.0; z < 30.0; z += dz) { + f = 1.0 / (1 + PAR[7]*z + pow(z, 2.25)); + if (f < limit) + break; + } + psF64 radius = sigma * sqrt (2.0 * z); + if (isnan(radius)) { + fprintf (stderr, "error in code\n"); + } + return (radius); +} + +bool pmModelFromPSF_QGAUSS (pmModel *modelPSF, pmModel *modelFLT, pmPSF *psf) +{ + + psF32 *out = modelPSF->params->data.F32; + psF32 *in = modelFLT->params->data.F32; + + out[0] = in[0]; + out[1] = in[1]; + out[2] = in[2]; + out[3] = in[3]; + + for (int i = 4; i < 8; i++) { + psPolynomial2D *poly = psf->params->data[i-4]; + // XXX: Verify this (from EAM change) + //out[i] = Polynomial2DEval_EAM(poly, out[2], out[3]); + out[i] = psPolynomial2DEval(poly, out[2], out[3]); + } + return(true); +} + +bool pmModelFitStatus_QGAUSS (pmModel *model) +{ + + psF32 dP; + bool status; + + psF32 *PAR = model->params->data.F32; + psF32 *dPAR = model->dparams->data.F32; + + dP = 0; + dP += PS_SQR(dPAR[4] / PAR[4]); + dP += PS_SQR(dPAR[5] / PAR[5]); + dP = sqrt (dP); + + status = true; + status &= (dP < 0.5); + status &= (PAR[1] > 0); + status &= ((dPAR[1]/PAR[1]) < 0.5); + + if (!status) + return false; + return true; +} Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/objects/models/pmModel_RGAUSS.c =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/objects/models/pmModel_RGAUSS.c (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/objects/models/pmModel_RGAUSS.c (revision 21664) @@ -0,0 +1,157 @@ + +/****************************************************************************** + one component, two slopes: + 1 / (1 + z + z^Npow) + + params->data.F32[0] = So; + params->data.F32[1] = Zo; + params->data.F32[2] = Xo; + params->data.F32[3] = Yo; + params->data.F32[4] = 1 / SigmaX; + params->data.F32[5] = 1 / SigmaY; + params->data.F32[6] = Sxy; + params->data.F32[7] = Npow +*****************************************************************************/ + +psF64 psModelFunc_RGAUSS(psVector *deriv, + const psVector *params, + const psVector *x) +{ + psF32 *PAR = params->data.F32; + + psF32 X = x->data.F32[0] - PAR[2]; + psF32 Y = x->data.F32[1] - PAR[3]; + psF32 px = PAR[4]*X; + psF32 py = PAR[5]*Y; + psF32 z = 0.5*PS_SQR(px) + 0.5*PS_SQR(py) + PAR[6]*X*Y; + + // psF32 FACT = 1 + 5*exp(-5*PAR[7]); + + psF32 p = pow(z, PAR[7] - 1.0); + psF32 r = 1.0 / (1 + z + z*p); + psF32 f = PAR[1]*r + PAR[0]; + + if (deriv != NULL) { + // note difference from a pure gaussian: q = params->data.F32[1]*r + psF32 t = PAR[1]*r*r; + psF32 q = t*(1 + PAR[7]*p); + + deriv->data.F32[0] = +1.0; + deriv->data.F32[1] = +r; + deriv->data.F32[2] = q*(2.0*px*PAR[4] + PAR[6]*Y); + deriv->data.F32[3] = q*(2.0*py*PAR[5] + PAR[6]*X); + deriv->data.F32[4] = -q*px*X*2; + deriv->data.F32[5] = -q*py*Y*2; + deriv->data.F32[6] = -q*X*Y; + deriv->data.F32[7] = -5.0*t*log(z)*p*z; + + // deriv->data.F32[4] = -1.8*q*px*X*2; + // deriv->data.F32[5] = -1.8*q*py*Y*2; + // deriv->data.F32[6] = -1.5*q*X*Y; + // deriv->data.F32[7] = -5.0*t*log(z)*p*z; + } + return(f); +} + +psF64 psModelFlux_RGAUSS(const psVector *params) +{ + float f, norm, z; + + psF32 *PAR = params->data.F32; + + psF64 A1 = PS_SQR(PAR[4]); + psF64 A2 = PS_SQR(PAR[5]); + psF64 A3 = PS_SQR(PAR[6]); + psF64 Area = 2.0 * M_PI / sqrt(A1*A2 - A3); + // Area is equivalent to 2 pi sigma^2 + + // the area needs to be multiplied by the integral of f(z) + norm = 0.0; + for (z = 0.005; z < 50; z += 0.01) { + f = 1.0 / (1 + z + pow(z, PAR[7])); + norm += f; + } + norm *= 0.01; + + psF64 Flux = params->data.F32[1] * Area * norm; + + return(Flux); +} + +// define this function so it never returns Inf or NaN +// return the radius which yields the requested flux +psF64 psModelRadius_RGAUSS (const psVector *params, psF64 flux) +{ + psF64 z, f, p; + psF32 *PAR = params->data.F32; + + if (flux <= 0) + return (1.0); + if (PAR[1] <= 0) + return (1.0); + if (flux >= PAR[1]) + return (1.0); + + // if Sx == Sy, sigma = Sx == Sy + psF64 sigma = hypot (1.0 / PAR[4], 1.0 / PAR[5]) / sqrt(2.0); + psF64 dz = 1.0 / (2.0 * sigma*sigma); + psF64 limit = flux / PAR[1]; + + // we can do this much better with intelligent choices here + for (z = 0.0; z < 20.0; z += dz) { + p = pow(z, PAR[7]); + f = 1.0 / (1 + z + p); + if (f < limit) + break; + } + psF64 radius = sigma * sqrt (2.0 * z); + if (isnan(radius)) { + fprintf (stderr, "error in code\n"); + } + return (radius); +} + +bool psModelGuess_RGAUSS (psModel *model, psSource *source) +{ + + psVector *params = model->params; + + EllipseAxes axes; + EllipseShape shape; + EllipseMoments moments; + + moments.x2 = PS_SQR(source->moments->Sx); + moments.y2 = PS_SQR(source->moments->Sy); + moments.xy = source->moments->Sxy; + + axes = EllipseMomentsToAxes(moments); + shape = EllipseAxesToShape(axes); + + params->data.F32[0] = source->moments->Sky; + params->data.F32[1] = source->peak->counts - source->moments->Sky; + params->data.F32[2] = source->moments->x; + params->data.F32[3] = source->moments->y; + params->data.F32[4] = 1.0 / shape.sx; + params->data.F32[5] = 1.0 / shape.sy; + params->data.F32[6] = shape.sxy; + params->data.F32[7] = 2.0; + return(true); +} + +bool psModelFromPSF_RGAUSS (psModel *modelPSF, psModel *modelFLT, pmPSF *psf) +{ + + psF32 *out = modelPSF->params->data.F32; + psF32 *in = modelFLT->params->data.F32; + + out[0] = in[0]; + out[1] = in[1]; + out[2] = in[2]; + out[3] = in[3]; + + for (int i = 4; i < 8; i++) { + psPolynomial2D *poly = psf->params->data[i-4]; + out[i] = Polynomial2DEval (poly, out[2], out[3]); + } + return(true); +} Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/objects/models/pmModel_SGAUSS.c =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/objects/models/pmModel_SGAUSS.c (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/objects/models/pmModel_SGAUSS.c (revision 21664) @@ -0,0 +1,357 @@ + + +/****************************************************************************** + one component, two slopes: + 1 / (1 + z^Npow + St*z^Ntide) + + params->data.F32[0] = So; + params->data.F32[1] = Zo; + params->data.F32[2] = Xo; + params->data.F32[3] = Yo; + params->data.F32[4] = 1 / SigmaX; + params->data.F32[5] = 1 / SigmaY; + params->data.F32[6] = Sxy; + params->data.F32[7] = Npow + params->data.F32[8] = St +*****************************************************************************/ + +# define SQ(A)((A)*(A)) +psF64 psImageEllipseContour (EllipseAxes axes, double xc, double yc, psImage *image); +psF64 p_psImageGetElementF64(psImage *a, int i, int j); + +psF32 pmModelFunc_SGAUSS(psVector *deriv, + const psVector *params, + const psVector *x) +{ + psF32 *PAR = params->data.F32; + + psF32 X = x->data.F32[0] - PAR[2]; + psF32 Y = x->data.F32[1] - PAR[3]; + psF32 px = PAR[4]*X; + psF32 py = PAR[5]*Y; + psF32 z = PS_MAX((0.5*PS_SQR(px) + 0.5*PS_SQR(py) + PAR[6]*X*Y), 1e-8); + // note that if z -> 0, dPAR[7] -> -inf + // also z^(PAR[7]-1) -> Inf + + psF32 pr = z*PAR[8]; + psF32 pr3 = pr*pr*pr; + psF32 p = pow(z, PAR[7] - 1.0); + psF32 r = 1.0 / (1 + z*p + pr*pr3); + psF32 f = PAR[1]*r + PAR[0]; + + if (deriv != NULL) { + // note difference from a pure gaussian: q = params->data.F32[1]*r + psF32 t = PAR[1]*r*r; + psF32 q = t*(PAR[7]*p + 4*PAR[8]*pr3); + + deriv->data.F32[0] = +1.0; + deriv->data.F32[1] = +r; + deriv->data.F32[2] = q*(2.0*px*PAR[4] + PAR[6]*Y); + deriv->data.F32[3] = q*(2.0*py*PAR[5] + PAR[6]*X); + deriv->data.F32[4] = -2.0*q*px*X; + deriv->data.F32[5] = -2.0*q*py*Y; + deriv->data.F32[6] = -q*X*Y; + deriv->data.F32[7] = -2*t*log(z)*z*p; + deriv->data.F32[8] = -2*t*4*z*pr3; + } + return(f); +} + +bool pmModelLimits_SGAUSS (psVector **beta_lim, psVector **params_min, psVector **params_max) +{ + + *beta_lim = psVectorAlloc (9, PS_TYPE_F32); + *params_min = psVectorAlloc (9, PS_TYPE_F32); + *params_max = psVectorAlloc (9, PS_TYPE_F32); + + beta_lim[0][0].data.F32[0] = 1000; + beta_lim[0][0].data.F32[1] = 10000; + beta_lim[0][0].data.F32[2] = 5; + beta_lim[0][0].data.F32[3] = 5; + beta_lim[0][0].data.F32[4] = 0.5; + beta_lim[0][0].data.F32[5] = 0.5; + beta_lim[0][0].data.F32[6] = 0.5; + beta_lim[0][0].data.F32[7] = 0.5; + beta_lim[0][0].data.F32[8] = 0.05; + + params_min[0][0].data.F32[0] = -1000; + params_min[0][0].data.F32[1] = 0; + params_min[0][0].data.F32[2] = -100; + params_min[0][0].data.F32[3] = -100; + params_min[0][0].data.F32[4] = 0.01; + params_min[0][0].data.F32[5] = 0.01; + params_min[0][0].data.F32[6] = -5.0; + params_min[0][0].data.F32[7] = 0.5; + params_min[0][0].data.F32[8] = 0.001; + + params_max[0][0].data.F32[0] = 1e5; + params_max[0][0].data.F32[1] = 1e6; + params_max[0][0].data.F32[2] = 1e4; // this should be set by image dimensions! + params_max[0][0].data.F32[3] = 1e4; // this should be set by image dimensions! + params_max[0][0].data.F32[4] = 2.0; + params_max[0][0].data.F32[5] = 2.0; + params_max[0][0].data.F32[6] = +3.0; + params_max[0][0].data.F32[7] = 5.0; + params_max[0][0].data.F32[8] = 0.5; + + return (TRUE); +} + +// measure the flux for the elliptical contour +psF64 psImageEllipseContour (EllipseAxes axes, double xc, double yc, psImage *image) +{ + + double t, dt, ct, st, xo, yo, value; + int N, Nt, x, y; + + // choose dt to uniformly divide contour, with ~1 pix spacing at most + dt = asin (1 / axes.minor); + Nt = (int)(2*M_PI / dt) + 1; + dt = 2*M_PI / Nt; + + ct = cos(axes.theta); + st = sin(axes.theta); + xo = xc - image->col0; + yo = yc - image->row0; + + psVector *contour = psVectorAlloc (Nt, PS_TYPE_F32); + for (t = 0, N = 0; (t < 2*M_PI) && (N < Nt); t += dt) { + x = ct*axes.major*cos(t) + st*axes.minor*sin(t) + xo; + y = ct*axes.minor*sin(t) + st*axes.major*cos(t) + yo; + value = p_psImageGetElementF64(image, x, y); + if (isfinite(value)) { + contour->data.F32[N] = value; + N++; + } + } + contour->n = N; + // accept every pixel: double counting is not so problematic here... + + psStats *stats = psStatsAlloc (PS_STAT_SAMPLE_MEDIAN); + psVectorStats (stats, contour, NULL, NULL, 0); + value = stats->sampleMedian; + + psFree (stats); + psFree (contour); + + return (value); +} + +bool pmModelGuess_SGAUSS (pmModel *model, pmSource *source) +{ + + pmMoments *sMoments = source->moments; + pmPeak *peak = source->peak; + psF32 *params = model->params->data.F32; + + EllipseAxes axes; + EllipseShape shape; + EllipseMoments moments; + + moments.x2 = PS_SQR(sMoments->Sx); + moments.y2 = PS_SQR(sMoments->Sy); + moments.xy = sMoments->Sxy; + + // solve the math to go from Moments To Shape + axes = EllipseMomentsToAxes(moments); + shape = EllipseAxesToShape(axes); + + params[0] = sMoments->Sky; + params[1] = sMoments->Peak - sMoments->Sky; + params[2] = peak->x; + params[3] = peak->y; + params[4] = 1.0 / shape.sx; + params[5] = 1.0 / shape.sy; + params[6] = shape.sxy; + + # if (0) + + f1 = psImageEllipseContour (axes, peak->x, peak->y, source->pixels); + axes.major *= 2.0; + axes.minor *= 2.0; + f2 = psImageEllipseContour (axes, peak->x, peak->y, source->pixels); + + if (f1 > f2) { + params[7] = PS_MIN (3.0, PS_MAX (0.5, log(2.0*(f1/f2) - 1.0) / log(2.0))); + } else { + params[7] = 0.5; + } + # endif + + params[7] = 1.8; + params[8] = 0.1; + + + return(true); +} + +// XXX EAM : test version using flux contours to guess slope +bool pmModelGuess_SGAUSS_HARD (pmModel *model, pmSource *source) +{ + + pmMoments *sMoments = source->moments; + pmPeak *peak = source->peak; + psF32 *params = model->params->data.F32; + float f1, f2; + + EllipseAxes axes; + EllipseShape shape; + EllipseMoments moments; + + moments.x2 = PS_SQR(sMoments->Sx); + moments.y2 = PS_SQR(sMoments->Sy); + moments.xy = sMoments->Sxy; + + // solve the math to go from Moments To Shape + axes = EllipseMomentsToAxes(moments); + shape = EllipseAxesToShape(axes); + + params[0] = sMoments->Sky; + params[1] = sMoments->Peak - sMoments->Sky; + params[2] = peak->x; + params[3] = peak->y; + params[4] = 1.0 / shape.sx; + params[5] = 1.0 / shape.sy; + params[6] = shape.sxy; + + f1 = psImageEllipseContour (axes, peak->x, peak->y, source->pixels); + axes.major *= 2.0; + axes.minor *= 2.0; + f2 = psImageEllipseContour (axes, peak->x, peak->y, source->pixels); + + if (f1 > f2) { + params[7] = PS_MIN (3.0, PS_MAX (0.5, log(2.0*(f1/f2) - 1.0) / log(2.0))); + } else { + params[7] = 0.5; + } + params[8] = 0.1; + + return(true); +} + +psF64 pmModelFlux_SGAUSS(const psVector *params) +{ + float f, norm, z; + + psF32 *PAR = params->data.F32; + + psF64 A1 = PS_SQR(PAR[4]); + psF64 A2 = PS_SQR(PAR[5]); + psF64 A3 = PS_SQR(PAR[6]); + psF64 Area = 2.0 * M_PI / sqrt(A1*A2 - A3); + // Area is equivalent to 2 pi sigma^2 + + // the area needs to be multiplied by the integral of f(z) + norm = 0.0; + for (z = 0.005; z < 50; z += 0.01) { + psF32 pr = PAR[8]*z; + f = 1.0 / (1 + pow(z, PAR[7]) + SQ(SQ(pr))); + norm += f; + } + norm *= 0.01; + + psF64 Flux = PAR[1] * Area * norm; + + return(Flux); +} + +// XXX need to define the radius along the major axis +// define this function so it never returns Inf or NaN +// return the radius which yields the requested flux +psF64 pmModelRadius_SGAUSS (const psVector *params, psF64 flux) +{ + psF64 r, z = 0.0, pr, f; + psF32 *PAR = params->data.F32; + + EllipseAxes axes; + EllipseShape shape; + + if (flux <= 0) + return (1.0); + if (PAR[1] <= 0) + return (1.0); + if (flux >= PAR[1]) + return (1.0); + + // convert Sx,Sy,Sxy to major/minor axes + shape.sx = 1.0 / PAR[4]; + shape.sy = 1.0 / PAR[5]; + shape.sxy = PAR[6]; + + axes = EllipseShapeToAxes (shape); + psF64 dr = 1.0 / axes.major; + psF64 limit = flux / PAR[1]; + + // XXX : we can do this faster with an intelligent starting choice + for (r = 0.0; r < 20.0; r += dr) { + z = SQ(r); + pr = PAR[8]*z; + f = 1.0 / (1 + pow(z, PAR[7]) + SQ(SQ(pr))); + if (f < limit) + break; + } + psF64 radius = 2.0 * axes.major * sqrt (z); + if (isnan(radius)) { + fprintf (stderr, "error in code\n"); + } + return (radius); +} + +bool pmModelFromPSF_SGAUSS (pmModel *modelPSF, pmModel *modelFLT, pmPSF *psf) +{ + + psF32 *out = modelPSF->params->data.F32; + psF32 *in = modelFLT->params->data.F32; + + out[0] = in[0]; + out[1] = in[1]; + out[2] = in[2]; + out[3] = in[3]; + + for (int i = 4; i < 9; i++) { + psPolynomial2D *poly = psf->params->data[i-4]; + // XXX: Verify this (from EAM change) + //out[i] = Polynomial2DEval_EAM(poly, out[2], out[3]); + out[i] = psPolynomial2DEval(poly, out[2], out[3]); + } + return(true); +} + +bool pmModelFitStatus_SGAUSS (pmModel *model) +{ + + psF32 dP; + bool status; + EllipseAxes axes; + EllipseShape shape; + + psF32 *PAR = model->params->data.F32; + psF32 *dPAR = model->dparams->data.F32; + + shape.sx = 1.0 / PAR[4]; + shape.sy = 1.0 / PAR[5]; + shape.sxy = PAR[6]; + + axes = EllipseShapeToAxes (shape); + + dP = 0; + dP += PS_SQR(dPAR[4] / PAR[4]); + dP += PS_SQR(dPAR[5] / PAR[5]); + dP += PS_SQR(dPAR[7] / PAR[7]); + dP = sqrt (dP); + + status = true; + status &= (dP < 0.5); + status &= (PAR[1] > 0); + status &= ((dPAR[1]/PAR[1]) < 0.5); + status &= (fabs(PAR[8]) < 0.5); + status &= (dPAR[8] < 0.1); + status &= (axes.major > 1.41); + status &= (axes.minor > 1.41); + status &= ((axes.major / axes.minor) < 5.0); + status &= (PAR[7] > 0.5); + + if (status) + return true; + return false; +} Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/objects/models/pmModel_TGAUSS.c =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/objects/models/pmModel_TGAUSS.c (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/objects/models/pmModel_TGAUSS.c (revision 21664) @@ -0,0 +1,114 @@ + +/****************************************************************************** + one component, two slopes: + 1 / (1 + z^M + z^N) + + params->data.F32[0] = So; + params->data.F32[1] = Zo; + params->data.F32[2] = Xo; + params->data.F32[3] = Yo; + params->data.F32[4] = sqrt(2.0) / SigmaX; + params->data.F32[5] = sqrt(2.0) / SigmaY; + params->data.F32[6] = Sxy; + params->data.F32[7] = +*****************************************************************************/ + +psF64 psModelFunc_TGAUSS(psVector *deriv, + const psVector *params, + const psVector *x) +{ + psF32 *PAR = params->data.F32; + + psF32 X = x->data.F32[0] - PAR[2]; + psF32 Y = x->data.F32[1] - PAR[3]; + psF32 px = PAR[4]*X; + psF32 py = PAR[5]*Y; + psF32 z = 0.5*PS_SQR(px) + 0.5*PS_SQR(py) + PAR[6]*X*Y; + + psF32 p = pow(z, 1.2); + psF32 r = 1.0 / (1 + z + PAR[7]*z*p); + psF32 f = PAR[1]*r + PAR[0]; + + if (deriv != NULL) { + // note difference from a pure gaussian: q = params->data.F32[1]*r + psF32 t = PAR[1]*r*r; + psF32 q = t*(1 + PAR[7]*2.2*p); + + deriv->data.F32[0] = +1.0; + deriv->data.F32[1] = +r; + deriv->data.F32[2] = q*(2.0*px*PAR[4] + PAR[6]*Y); + deriv->data.F32[3] = q*(2.0*py*PAR[5] + PAR[6]*X); + deriv->data.F32[4] = -2.0*q*px*X; + deriv->data.F32[5] = -2.0*q*py*Y; + deriv->data.F32[6] = -q*X*Y; + deriv->data.F32[7] = -t*z*p; + } + return(f); +} + +psF64 psModelFlux_TGAUSS(const psVector *params) +{ + psF64 A1 = 1 / PS_SQR(params->data.F32[4]); + psF64 A2 = 1 / PS_SQR(params->data.F32[5]); + psF64 A3 = params->data.F32[6]; + psF64 Area = 2.0 * M_PI / sqrt(A1*A2 - PS_SQR(A3)); + // Area is equivalent to 2 pi sigma^2 + + psF64 Flux = params->data.F32[1] * Area; + + return(Flux); +} + +// define this function so it never returns Inf or NaN +// return the radius which yields the requested flux +psF64 psModelRadius_TGAUSS (const psVector *params, psF64 flux) +{ + if (flux <= 0) + return (1.0); + if (params->data.F32[1] <= 0) + return (1.0); + if (flux >= params->data.F32[1]) + return (1.0); + + psF64 sigma = sqrt(2.0) * hypot (1.0 / params->data.F32[4], 1.0 / params->data.F32[5]); + psF64 radius = sigma * sqrt (2.0 * log(params->data.F32[1] / flux)); + if (isnan(radius)) { + fprintf (stderr, "error in code\n"); + } + return (radius); +} + +bool psModelGuess_TGAUSS (psModel *model, psSource *source) +{ + + psVector *params = model->params; + + params->data.F32[0] = source->moments->Sky; + params->data.F32[1] = source->peak->counts - source->moments->Sky; + params->data.F32[2] = source->moments->x; + params->data.F32[3] = source->moments->y; + params->data.F32[4] = 1.0/source->moments->Sx; + params->data.F32[5] = 1.0/source->moments->Sy; + // params->data.F32[6] = source->moments->Sxy; + params->data.F32[6] = 0.0; + params->data.F32[7] = 5.0; + return(true); +} + +bool psModelFromPSF_TGAUSS (psModel *modelPSF, psModel *modelFLT, pmPSF *psf) +{ + + psF32 *out = modelPSF->params->data.F32; + psF32 *in = modelFLT->params->data.F32; + + out[0] = in[0]; + out[1] = in[1]; + out[2] = in[2]; + out[3] = in[3]; + + for (int i = 4; i < 8; i++) { + psPolynomial2D *poly = psf->params->data[i-4]; + out[i] = Polynomial2DEval (poly, out[2], out[3]); + } + return(true); +} Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/objects/models/pmModel_WAUSS.c =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/objects/models/pmModel_WAUSS.c (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/objects/models/pmModel_WAUSS.c (revision 21664) @@ -0,0 +1,105 @@ + +/****************************************************************************** + params->data.F32[0] = So; + params->data.F32[1] = Zo; + params->data.F32[2] = Xo; + params->data.F32[3] = Yo; + params->data.F32[4] = sqrt(2.0) / SigmaX; + params->data.F32[5] = sqrt(2.0) / SigmaY; + params->data.F32[6] = Sxy; +*****************************************************************************/ + +psF64 psModelFunc_WAUSS(psVector *deriv, + const psVector *params, + const psVector *x) +{ + psF32 X = x->data.F32[0] - params->data.F32[2]; + psF32 Y = x->data.F32[1] - params->data.F32[2]; + psF32 px = params->data.F32[4]*X; + psF32 py = params->data.F32[5]*Y; + psF32 z = 0.5*PS_SQR(px) + 0.5*PS_SQR(py) + params->data.F32[6]*X*Y; + psF32 t = 0.5*z*z*(1.0 + params->data.F32[8]*z/3.0); + psF32 r = 1.0 / (1.0 + z + params->data.F32[7]*t); /* exp (-Z) */ + psF32 f = params->data.F32[1]*r + params->data.F32[0]; + + if (deriv != NULL) { + // note difference from gaussian: q = params->data.F32[1]*r + psF32 q = params->data.F32[1]*r*r*(1.0 + params->data.F32[7]*z*(1.0 + params->data.F32[8]*z/2.0)); + deriv->data.F32[0] = +1.0; + deriv->data.F32[1] = +r; + deriv->data.F32[2] = q*(2.0*px*params->data.F32[4] + params->data.F32[6]*Y); + deriv->data.F32[3] = q*(2.0*py*params->data.F32[5] + params->data.F32[6]*X); + deriv->data.F32[4] = -2.0*q*px*X; + deriv->data.F32[5] = -2.0*q*py*Y; + deriv->data.F32[6] = -q*X*Y; + deriv->data.F32[7] = -100.0*params->data.F32[1]*r*r*t; + deriv->data.F32[8] = -100.0*params->data.F32[1]*r*r*params->data.F32[7]*(z*z*z)/6.0; + // The values of 100 dampen the swing of params->data.F32[7,8] */ + } + return(f); +} + +// this is probably wrong since it uses the gauss integral 2 pi sigma^2 +psF64 psModelFlux_WAUSS(const psVector *params) +{ + psF64 A1 = 1 / PS_SQR(params->data.F32[4]); + psF64 A2 = 1 / PS_SQR(params->data.F32[5]); + psF64 A3 = params->data.F32[6]; + psF64 Area = 2.0 * M_PI / sqrt(A1*A2 - PS_SQR(A3)); + // Area is equivalent to 2 pi sigma^2 + + psF64 Flux = params->data.F32[1] * Area; + + return(Flux); +} + +// return the radius which yields the requested flux +psF64 psModelRadius_WAUSS (const psVector *params, psF64 flux) +{ + if (flux <= 0) + return (1.0); + if (params->data.F32[1] <= 0) + return (1.0); + if (flux >= params->data.F32[1] <= 0) + return (1.0); + + psF64 sigma = sqrt(2.0) * hypot (1.0 / params->data.F32[4], 1.0 / params->data.F32[5]); + psF64 radius = sigma * sqrt (2.0 * log(params->data.F32[1] / flux)); + return (radius); +} + +bool psModelGuess_WAUSS (psModel *model, psSource *source) +{ + + psVector *params = model->params; + + params->data.F32[0] = source->moments->Sky; + params->data.F32[1] = source->peak->counts - source->moments->Sky; + params->data.F32[2] = source->moments->x; + params->data.F32[3] = source->moments->y; + params->data.F32[4] = sqrt(2.0) / source->moments->Sx; + params->data.F32[5] = sqrt(2.0) / source->moments->Sy; + params->data.F32[6] = source->moments->Sxy; + // XXX: What are these? + // params->data.F32[7] = B2; + // params->data.F32[8] = B3; + return(true); +} + +bool psModelFromPSF_WAUSS (psModel *modelPSF, psModel *modelFLT, pmPSF *psf) +{ + + psF32 *out = modelPSF->params->data.F32; + psF32 *in = modelFLT->params->data.F32; + + out[0] = in[0]; + out[1] = in[1]; + out[2] = in[2]; + out[3] = in[3]; + + for (int i = 4; i < 9; i++) { + psPolynomial2D *poly = psf->params->data[i-4]; + out[i] = Polynomial2DEval (poly, out[2], out[3]); + } + return(true); +} Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/objects/models/pmModel_ZGAUSS.c =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/objects/models/pmModel_ZGAUSS.c (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/objects/models/pmModel_ZGAUSS.c (revision 21664) @@ -0,0 +1,164 @@ + +/****************************************************************************** + one component, two slopes: + 1 / (1 + z^Npow + PAR8*z^4) + + params->data.F32[0] = So; + params->data.F32[1] = Zo; + params->data.F32[2] = Xo; + params->data.F32[3] = Yo; + params->data.F32[4] = 1 / SigmaX; + params->data.F32[5] = 1 / SigmaY; + params->data.F32[6] = Sxy; + params->data.F32[7] = Npow +*****************************************************************************/ + +# define SQ(A)((A)*(A)) +# define PAR8 0.1 + +psF64 psModelFunc_ZGAUSS(psVector *deriv, + const psVector *params, + const psVector *x) +{ + psF32 *PAR = params->data.F32; + + psF32 X = x->data.F32[0] - PAR[2]; + psF32 Y = x->data.F32[1] - PAR[3]; + psF32 px = PAR[4]*X; + psF32 py = PAR[5]*Y; + psF32 z = 0.5*PS_SQR(px) + 0.5*PS_SQR(py) + PAR[6]*X*Y; + + psF32 pr = PAR8*z; + psF32 p = pow(z, PAR[7] - 1.0); + psF32 r = 1.0 / (1 + z*p + SQ(SQ(pr))); + psF32 f = PAR[1]*r + PAR[0]; + + if (deriv != NULL) { + // note difference from a pure gaussian: q = params->data.F32[1]*r + psF32 t = PAR[1]*r*r; + psF32 q = t*(PAR[7]*p + 4*PAR8*pr*pr*pr); + + deriv->data.F32[0] = +1.0; + deriv->data.F32[1] = +r; + deriv->data.F32[2] = q*(2.0*px*PAR[4] + PAR[6]*Y); + deriv->data.F32[3] = q*(2.0*py*PAR[5] + PAR[6]*X); + deriv->data.F32[4] = -q*px*X; + deriv->data.F32[5] = -q*py*Y; + deriv->data.F32[6] = -q*X*Y; + deriv->data.F32[7] = -t*log(z)*z*p; + } + return(f); +} + +psF64 psModelFlux_ZGAUSS(const psVector *params) +{ + float f, norm, z; + + psF32 *PAR = params->data.F32; + + psF64 A1 = PS_SQR(PAR[4]); + psF64 A2 = PS_SQR(PAR[5]); + psF64 A3 = PS_SQR(PAR[6]); + psF64 Area = 2.0 * M_PI / sqrt(A1*A2 - A3); + // Area is equivalent to 2 pi sigma^2 + + // the area needs to be multiplied by the integral of f(z) + norm = 0.0; + psF32 pr = PAR8*z; + for (z = 0.005; z < 50; z += 0.01) { + f = 1.0 / (1 + pow(z, PAR[7]) + SQ(SQ(pr))); + norm += f; + } + norm *= 0.01; + + psF64 Flux = PAR[1] * Area * norm; + + return(Flux); +} + +// XXX need to define the radius along the major axis +// define this function so it never returns Inf or NaN +// return the radius which yields the requested flux +psF64 psModelRadius_ZGAUSS (const psVector *params, psF64 flux) +{ + psF64 r, z, pr, f; + psF32 *PAR = params->data.F32; + + EllipseAxes axes; + EllipseShape shape; + + if (flux <= 0) + return (1.0); + if (PAR[1] <= 0) + return (1.0); + if (flux >= PAR[1]) + return (1.0); + + // convert Sx,Sy,Sxy to major/minor axes + shape.sx = 1.0 / PAR[4]; + shape.sy = 1.0 / PAR[5]; + shape.sxy = PAR[6]; + + axes = EllipseShapeToAxes (shape); + psF64 dr = 1.0 / axes.major; + psF64 limit = flux / PAR[1]; + + // XXX : we can do this faster with an intelligent starting choice + for (r = 0.0; r < 20.0; r += dr) { + z = SQ(r); + pr = PAR8*z; + f = 1.0 / (1 + pow(z, PAR[7]) + SQ(SQ(pr))); + if (f < limit) + break; + } + psF64 radius = 2.0 * axes.major * sqrt (z); + if (isnan(radius)) { + fprintf (stderr, "error in code\n"); + } + return (radius); +} + +bool psModelGuess_ZGAUSS (psModel *model, psSource *source) +{ + + psVector *params = model->params; + + EllipseAxes axes; + EllipseShape shape; + EllipseMoments moments; + + moments.x2 = PS_SQR(source->moments->Sx); + moments.y2 = PS_SQR(source->moments->Sy); + moments.xy = source->moments->Sxy; + + axes = EllipseMomentsToAxes(moments); + shape = EllipseAxesToShape(axes); + + params->data.F32[0] = source->moments->Sky; + params->data.F32[1] = source->peak->counts - source->moments->Sky; + params->data.F32[2] = source->moments->x; + params->data.F32[3] = source->moments->y; + params->data.F32[4] = 1.0 / shape.sx; + params->data.F32[5] = 1.0 / shape.sy; + params->data.F32[6] = shape.sxy; + params->data.F32[7] = 1.9; + return(true); +} + +bool psModelFromPSF_ZGAUSS (psModel *modelPSF, psModel *modelFLT, pmPSF *psf) +{ + + psF32 *out = modelPSF->params->data.F32; + psF32 *in = modelFLT->params->data.F32; + + out[0] = in[0]; + out[1] = in[1]; + out[2] = in[2]; + out[3] = in[3]; + + for (int i = 4; i < 8; i++) { + psPolynomial2D *poly = psf->params->data[i-4]; + out[i] = Polynomial2DEval (poly, out[2], out[3]); + } + return(true); +} Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/objects/pmGrowthCurve.c =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/objects/pmGrowthCurve.c (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/objects/pmGrowthCurve.c (revision 21664) @@ -0,0 +1,116 @@ +#include +# include "pmGrowthCurve.h" + +static void pmGrowthCurveFree (pmGrowthCurve *growth) +{ + + if (growth == NULL) + return; + + psFree (growth->radius); + psFree (growth->apMag); + return; +} + +pmGrowthCurve *pmGrowthCurveAlloc (psF32 minRadius, psF32 maxRadius, psF32 dRadius) +{ + + pmGrowthCurve *growth = psAlloc (sizeof(pmGrowthCurve)); + psMemSetDeallocator(growth, (psFreeFunc) pmGrowthCurveFree); + + growth->radius = psVectorCreate (NULL, minRadius, maxRadius, dRadius, PS_TYPE_F32); + growth->apMag = psVectorAlloc (growth->radius->n, PS_TYPE_F32); + + // XXX may want to extend this to allow for a different refRadius; + growth->refRadius = maxRadius; + growth->maxRadius = maxRadius; + growth->apLoss = 0.0; + growth->fitMag = 0.0; + return growth; +} + +psF32 pmGrowthCurveCorrect (pmGrowthCurve *growth, psF32 radius) +{ + + float apRad = psVectorInterpolate (growth->radius, growth->apMag, radius); + float apCor = growth->apRef - apRad; + return apCor; +} + +// return the last entry below or first entry above key value +int psVectorBracket (psVector *index, psF32 key, bool above) +{ + + int N; + int Nlo = 0; + int Nhi = index->n; + + if (above) { + while (Nhi - Nlo > 10) { + N = 0.5*(Nlo + Nhi); + if (index->data.F32[N] > key) { + Nhi = N; + } else { + Nlo = N - 1; + } + } + // at this point, index[Nhi] > key >= index[Nlo] + N = Nlo; + while ((index->data.F32[N] <= key) && (N < Nhi)) { + N++; + } + return (N); + } + while (Nhi - Nlo > 10) { + N = 0.5*(Nlo + Nhi); + if (index->data.F32[N] < key) { + Nlo = N; + } else { + Nhi = N + 1; + } + } + // at this point, index[Nhi] >= key > index[Nlo] + N = Nhi; + while ((index->data.F32[N] >= key) && (N > Nlo)) { + N--; + } + return (N); +} + +// search for the bins bounding key in index, interpolate the corresponding values +psF32 psVectorInterpolate (psVector *index, psVector *value, psF32 key) +{ + + int n0 = 0; + int n1 = 0; + + // extrapolate at ends + if (key < index->data.F32[0]) { + n0 = 0; + n1 = 1; + } + + // extrapolate at ends + if (key > index->data.F32[index->n-1]) { + n0 = index->n-2; + n1 = index->n-1; + } + + if (n1 == 0) { + int n0 = psVectorBracket (index, key, FALSE); + n1 = n0 + 1; + } + + if (n0 == index->n-1) { + n1 = n0; + n0 = n1 - 1; + } + + float dy = value->data.F32[n1] - value->data.F32[n0]; + float dx = index->data.F32[n1] - index->data.F32[n0]; + float dX = key - index->data.F32[n0]; + float dY = dX * (dy/dx); + float result = value->data.F32[n0] + dY; + return result; +} + Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/objects/pmGrowthCurve.h =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/objects/pmGrowthCurve.h (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/objects/pmGrowthCurve.h (revision 21664) @@ -0,0 +1,21 @@ +# ifndef PM_GROWTH_CURVE_H +# define PM_GROWTH_CURVE_H + +typedef struct +{ + psVector *radius; + psVector *apMag; + psF32 refRadius; + psF32 maxRadius; + psF32 fitMag; + psF32 apRef; // apMag[refRadius] + psF32 apLoss; // fitMag - apRef +} +pmGrowthCurve; + +pmGrowthCurve *pmGrowthCurveAlloc (psF32 minRadius, psF32 maxRadius, psF32 dRadius); +int psVectorBracket (psVector *index, psF32 key, bool above); +psF32 psVectorInterpolate (psVector *index, psVector *value, psF32 key); +psF32 pmGrowthCurveCorrect (pmGrowthCurve *growth, psF32 radius); + +# endif /* PM_GROWTH_CURVE_H */ Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/objects/pmModelGroup.c =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/objects/pmModelGroup.c (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/objects/pmModelGroup.c (revision 21664) @@ -0,0 +1,160 @@ +# include "pmModelGroup.h" + +double hypot(double x, double y); +double sqrt (double x); + +#include "psEllipse.h" +#include "models/pmModel_GAUSS.c" +#include "models/pmModel_PGAUSS.c" +#include "models/pmModel_QGAUSS.c" +#include "models/pmModel_SGAUSS.c" + +static pmModelGroup defaultModels[] = { + {"PS_MODEL_GAUSS", 7, pmModelFunc_GAUSS, pmModelFlux_GAUSS, pmModelRadius_GAUSS, pmModelLimits_GAUSS, pmModelGuess_GAUSS, pmModelFromPSF_GAUSS, pmModelFitStatus_GAUSS}, + {"PS_MODEL_PGAUSS", 7, pmModelFunc_PGAUSS, pmModelFlux_PGAUSS, pmModelRadius_PGAUSS, pmModelLimits_PGAUSS, pmModelGuess_PGAUSS, pmModelFromPSF_PGAUSS, pmModelFitStatus_PGAUSS}, + {"PS_MODEL_QGAUSS", 8, pmModelFunc_QGAUSS, pmModelFlux_QGAUSS, pmModelRadius_QGAUSS, pmModelLimits_QGAUSS, pmModelGuess_QGAUSS, pmModelFromPSF_QGAUSS, pmModelFitStatus_QGAUSS}, + {"PS_MODEL_SGAUSS", 9, pmModelFunc_SGAUSS, pmModelFlux_SGAUSS, pmModelRadius_SGAUSS, pmModelLimits_SGAUSS, pmModelGuess_SGAUSS, pmModelFromPSF_SGAUSS, pmModelFitStatus_SGAUSS}, + }; + +static pmModelGroup *models = NULL; +static int Nmodels = 0; + +static void ModelGroupFree (pmModelGroup *modelGroup) +{ + + if (modelGroup == NULL) + return; + return; +} + +pmModelGroup *pmModelGroupAlloc (int nModels) +{ + + pmModelGroup *modelGroup = (pmModelGroup *) psAlloc (nModels * sizeof(pmModelGroup)); + psMemSetDeallocator(modelGroup, (psFreeFunc) ModelGroupFree); + return (modelGroup); +} + +void pmModelGroupAdd (pmModelGroup *model) +{ + + if (models == NULL) { + pmModelGroupInit (); + } + + Nmodels ++; + models = (pmModelGroup *) psRealloc (models, Nmodels*sizeof(pmModelGroup)); + models[Nmodels-1] = model[0]; + return; +} + +void pmModelGroupInit (void) +{ + + int Nnew = sizeof (defaultModels) / sizeof (pmModelGroup); + + models = pmModelGroupAlloc (Nnew); + for (int i = 0; i < Nnew; i++) { + models[i] = defaultModels[i]; + } + Nmodels = Nnew; + return; +} + +void pmModelGroupCleanup (void) +{ + + psFree (models); + return; +} + +pmModelFunc pmModelFunc_GetFunction (pmModelType type) +{ + if ((type < 0) || (type >= Nmodels)) { + psError(PS_ERR_UNKNOWN, true, "Undefined pmModelType"); + return (NULL); + } + return (models[type].modelFunc); +} + +pmModelFlux pmModelFlux_GetFunction (pmModelType type) +{ + if ((type < 0) || (type >= Nmodels)) { + psError(PS_ERR_UNKNOWN, true, "Undefined pmModelType"); + return (NULL); + } + return (models[type].modelFlux); +} + +pmModelRadius pmModelRadius_GetFunction (pmModelType type) +{ + if ((type < 0) || (type >= Nmodels)) { + psError(PS_ERR_UNKNOWN, true, "Undefined pmModelType"); + return (NULL); + } + return (models[type].modelRadius); +} + +pmModelLimits pmModelLimits_GetFunction (pmModelType type) +{ + if ((type < 0) || (type >= Nmodels)) { + psError(PS_ERR_UNKNOWN, true, "Undefined pmModelType"); + return (NULL); + } + return (models[type].modelLimits); +} + +pmModelGuessFunc pmModelGuessFunc_GetFunction (pmModelType type) +{ + if ((type < 0) || (type >= Nmodels)) { + psError(PS_ERR_UNKNOWN, true, "Undefined pmModelType"); + return (NULL); + } + return (models[type].modelGuessFunc); +} + +pmModelFitStatusFunc pmModelFitStatusFunc_GetFunction (pmModelType type) +{ + if ((type < 0) || (type >= Nmodels)) { + psError(PS_ERR_UNKNOWN, true, "Undefined pmModelType"); + return (NULL); + } + return (models[type].modelFitStatusFunc); +} + +pmModelFromPSFFunc pmModelFromPSFFunc_GetFunction (pmModelType type) +{ + if ((type < 0) || (type >= Nmodels)) { + psError(PS_ERR_UNKNOWN, true, "Undefined pmModelType"); + return (NULL); + } + return (models[type].modelFromPSFFunc); +} + +psS32 pmModelParameterCount (pmModelType type) +{ + if ((type < 0) || (type >= Nmodels)) { + psError(PS_ERR_UNKNOWN, true, "Undefined pmModelType"); + return (0); + } + return (models[type].nParams); +} + +psS32 pmModelSetType (char *name) +{ + for (int i = 0; i < Nmodels; i++) { + if (!strcmp(models[i].name, name)) { + return (i); + } + } + return (-1); +} + +char *pmModelGetType (pmModelType type) +{ + if ((type < 0) || (type >= Nmodels)) { + psError(PS_ERR_UNKNOWN, true, "Undefined pmModelType"); + return (NULL); + } + return (models[type].name); +} Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/objects/pmModelGroup.h =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/objects/pmModelGroup.h (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/objects/pmModelGroup.h (revision 21664) @@ -0,0 +1,223 @@ +/** @file pmModelGroup.h + * + * The object model function types are defined to allow for the flexible addition + * of new object models. Every object model, with parameters represented by + * pmModel, has an associated set of functions which provide necessary support + * operations. A set of abstract functions allow the programmer to select the + * approriate function or property for a specific named object model. + * + * @author EAM, IfA + * + * @version $Revision: 1.1.16.3 $ $Name: not supported by cvs2svn $ + * @date $Date: 2006-02-08 06:05:26 $ + * + * Copyright 2004 Maui High Performance Computing Center, University of Hawaii + * + */ +#include "pmObjects.h" +#include "pmPSF.h" +/** + * + * This function returns the number of parameters used by the listed function. + * + */ +int pmModelParameterCount( + pmModelType type ///< Add comment. +); + + +/** + * + * This function returns the user-space model names for the specified model type. + * + */ +char *pmModelGetType( + pmModelType type ///< Add comment. +); + + +/** + * + * This function returns the internal model type code for the user-space model names. + * + */ +pmModelType pmModelSetType( + char *name ///< Add comment. +); + + +#ifndef PM_MODEL_GROUP_H +#define PM_MODEL_GROUP_H + +/** + * + * This function is the model chi-square minimization function for this model. + * + */ +typedef psMinimizeLMChi2Func pmModelFunc; + + +/** + * + * This function returns the integrated flux for the given model parameters. + */ +typedef psF64 (*pmModelFlux)(const psVector *params); + + +/** + * + * This function returns the radius at which the given model and parameters + * achieves the given flux. + * + */ +typedef psF64 (*pmModelRadius)(const psVector *params, double flux); + +/** + * + * This function sets the model parameter limits vectors for the given model + * + */ +typedef bool (*pmModelLimits)(psVector **beta_lim, psVector **params_min, psVector **params_max); + +/** + * + * This function provides the model guess parameters based on the details of + * the given source. + * + */ +typedef bool (*pmModelGuessFunc)(pmModel *model, pmSource *source); + + +/** + * + * This function constructs the PSF model for the given source based on the + * supplied psf and the EXT model for the object. + * + */ +typedef bool (*pmModelFromPSFFunc)(pmModel *modelPSF, pmModel *modelEXT, pmPSF *psf); + +/** + * + * This function returns the success / failure status of the given model fit + * + */ +typedef bool (*pmModelFitStatusFunc)(pmModel *model); + +/** + * + * Each of the function types above has a corresponding function which returns + * the function given the model type: + * + */ + + +/** + * + * pmModelFunc is the function used to determine the value of the model at a + * specific coordinate, and is the one used by psMinimizeLMChi2. + * + */ +pmModelFunc pmModelFunc_GetFunction (pmModelType type); + + +/** + * + * pmModelFlux returns the total integrated flux for the given input parameters. + * + */ +pmModelFlux pmModelFlux_GetFunction (pmModelType type); + + +/** + * + * pmModelRadius returns the scaling radius at which the flux of the model + * matches the specified flux. This presumes that the model is a function of an + * elliptical contour. + * + */ +pmModelRadius pmModelRadius_GetFunction (pmModelType type); + + +/** + * + * pmModelLimits sets the parameter limit vectors for the function. + * + */ +pmModelLimits pmModelLimits_GetFunction (pmModelType type); + + +/** + * + * pmModelGuessFunc generates an initial guess for the model based on the + * provided source statistics (moments and pixel values as needed). + * + */ +pmModelGuessFunc pmModelGuessFunc_GetFunction (pmModelType type); + + +/** + * + * pmModelFromPSFFunc takes as input a representation of the psf and a value + * for the model and fills in the PSF parameters of the model. The input + * primarily relies upon the centroid coordinates of the input model, though the + * normalization may potentially be used. + * + */ +pmModelFromPSFFunc pmModelFromPSFFunc_GetFunction (pmModelType type); + + +/** + * + * pmModelFitStatusFunc returns a true or false values based on the success or + * failure of a model fit. The success is determined by quantities such as the + * chisq or the signal-to-noise. + * + */ +pmModelFitStatusFunc pmModelFitStatusFunc_GetFunction (pmModelType type); + + + + +/** + * + * Every model instance belongs to a class of models, defined by the value of + * the pmModelType type entry. Various functions need access to information about + * each of the models. Some of this information varies from model to model, and + * may depend on the current parameter values or other data quantities. In order + * to keep the code from requiring the information about each model to be coded + * into the low-level fitting routines, we define a collection of functions which + * allow us to abstract this type of model-dependent information. These generic + * functions take the model type and return the corresponding function pointer + * for the specified model. Each model is defined by creating this collection of + * specific functions, and placing them in a single file for each model. We + * define the following structure to carry the collection of information about + * the models. + * + */ +typedef struct +{ + char *name; + int nParams; + pmModelFunc modelFunc; + pmModelFlux modelFlux; + pmModelRadius modelRadius; + pmModelLimits modelLimits; + pmModelGuessFunc modelGuessFunc; + pmModelFromPSFFunc modelFromPSFFunc; + pmModelFitStatusFunc modelFitStatusFunc; +} +pmModelGroup; + +// allocate a pmModelGroup to hold nModels entries +pmModelGroup *pmModelGroupAlloc (int nModels); + +// initialize the internal (static) model group with the default models +void pmModelGroupInit (void); + +// free the internal (static) model group +void pmModelGroupCleanup (void); + +// add a new model to the internal (static) model group +void pmModelGroupAdd (pmModelGroup *model); + +# endif Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/objects/pmObjects.c =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/objects/pmObjects.c (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/objects/pmObjects.c (revision 21664) @@ -0,0 +1,1925 @@ +/** @file pmObjects.c + * + * This file will ... + * + * @author GLG, MHPCC + * @author EAM, IfA: significant modifications. + * + * @version $Revision: 1.5.4.8 $ $Name: not supported by cvs2svn $ + * @date $Date: 2006-02-17 02:48:25 $ + * + * Copyright 2004 Maui High Performance Computing Center, University of Hawaii + * + */ + +#include +#include +#include +#include "pslib.h" +#include "pmObjects.h" +#include "pmModelGroup.h" +/****************************************************************************** +pmPeakAlloc(): Allocate the pmPeak data structure and set appropriate members. +*****************************************************************************/ +pmPeak *pmPeakAlloc(psS32 x, + psS32 y, + psF32 counts, + pmPeakType type) +{ + psTrace(__func__, 3, "---- %s() begin ----\n", __func__); + pmPeak *tmp = (pmPeak *) psAlloc(sizeof(pmPeak)); + tmp->x = x; + tmp->y = y; + tmp->counts = counts; + tmp->type = type; + + psTrace(__func__, 3, "---- %s() end ----\n", __func__); + return(tmp); +} + +/****************************************************************************** +pmMomentsAlloc(): Allocate the pmMoments structure and initialize the members +to zero. +*****************************************************************************/ +pmMoments *pmMomentsAlloc() +{ + psTrace(__func__, 3, "---- %s() begin ----\n", __func__); + pmMoments *tmp = (pmMoments *) psAlloc(sizeof(pmMoments)); + tmp->x = 0.0; + tmp->y = 0.0; + tmp->Sx = 0.0; + tmp->Sy = 0.0; + tmp->Sxy = 0.0; + tmp->Sum = 0.0; + tmp->Peak = 0.0; + tmp->Sky = 0.0; + tmp->nPixels = 0; + + psTrace(__func__, 3, "---- %s() end ----\n", __func__); + return(tmp); +} + +static void modelFree(pmModel *tmp) +{ + psTrace(__func__, 4, "---- %s() begin ----\n", __func__); + psFree(tmp->params); + psFree(tmp->dparams); + psTrace(__func__, 4, "---- %s() end ----\n", __func__); +} + +static void sourceFree(pmSource *tmp) +{ + psTrace(__func__, 4, "---- %s() begin ----\n", __func__); + psFree(tmp->peak); + psFree(tmp->pixels); + psFree(tmp->weight); + psFree(tmp->mask); + psFree(tmp->moments); + psFree(tmp->modelPSF); + psFree(tmp->modelEXT); + psFree(tmp->blends); + psTrace(__func__, 4, "---- %s() end ----\n", __func__); +} + +/****************************************************************************** +getRowVectorFromImage(): a private function which simply returns a +psVector containing the specified row of data from the psImage. + +XXX: Is there a better way to do this? +XXX EAM: does this really need to alloc a new vector??? +*****************************************************************************/ +static psVector *getRowVectorFromImage(psImage *image, + psU32 row) +{ + psTrace(__func__, 4, "---- %s() begin ----\n", __func__); + PS_ASSERT_IMAGE_NON_NULL(image, NULL); + PS_ASSERT_IMAGE_TYPE(image, PS_TYPE_F32, NULL); + + psVector *tmpVector = psVectorAlloc(image->numCols, PS_TYPE_F32); + for (psU32 col = 0; col < image->numCols ; col++) { + tmpVector->data.F32[col] = image->data.F32[row][col]; + } + psTrace(__func__, 4, "---- %s() end ----\n", __func__); + return(tmpVector); +} + +/****************************************************************************** +myListAddPeak(): A private function which allocates a psArray, if the list +argument is NULL, otherwise it adds the peak to that list. +XXX EAM : changed the output to psArray +XXX EAM : Switched row, col args +XXX EAM : NOTE: this was changed in the call, so the new code is consistent +*****************************************************************************/ +static psArray *myListAddPeak(psArray *list, + psS32 row, + psS32 col, + psF32 counts, + pmPeakType type) +{ + psTrace(__func__, 4, "---- %s() begin ----\n", __func__); + pmPeak *tmpPeak = pmPeakAlloc(col, row, counts, type); + + if (list == NULL) { + list = psArrayAlloc(100); + list->n = 0; + } + psArrayAdd(list, 100, tmpPeak); + psFree (tmpPeak); + // XXX EAM : is this free appropriate? (does psArrayAdd increment memory counter?) + + psTrace(__func__, 4, "---- %s() end ----\n", __func__); + return(list); +} + + +/****************************************************************************** +bool checkRadius2(): private function which simply determines if the (x, y) +point is within the radius of the specified peak. + +XXX: macro this for performance. +XXX: this is rather inefficient - at least compute and compare against radius^2 +*****************************************************************************/ +static bool checkRadius2(psF32 xCenter, + psF32 yCenter, + psF32 radius, + psF32 x, + psF32 y) +{ + psTrace(__func__, 4, "---- %s() begin ----\n", __func__); + /// XXX EAM should compare with hypot (x,y) for speed + if ((PS_SQR(x - xCenter) + PS_SQR(y - yCenter)) < PS_SQR(radius)) { + return(true); + } + + psTrace(__func__, 4, "---- %s(false) end ----\n", __func__); + return(false); +} + +// XXX: Macro this. +static bool isItInThisRegion(const psRegion valid, + psS32 x, + psS32 y) +{ + psTrace(__func__, 4, "---- %s() begin ----\n", __func__); + if ((x >= valid.x0) && + (x <= valid.x1) && + (y >= valid.y0) && + (y <= valid.y1)) { + psTrace(__func__, 4, "---- %s(true) end ----\n", __func__); + return(true); + } + psTrace(__func__, 4, "---- %s(false) end ----\n", __func__); + return(false); +} + +/****************************************************************************** +findValue(source, level, row, col, dir): a private function which determines +the column coordinate of the model function which has the value "level". If +dir equals 0, then you loop leftwards from the peak pixel, otherwise, +rightwards. + +XXX: reverse order of row,col args? + +XXX: Input row/col are in image coords. + +XXX: The result is returned in image coords. +*****************************************************************************/ +static psF32 findValue(pmSource *source, + psF32 level, + psU32 row, + psU32 col, + psU32 dir) +{ + psTrace(__func__, 4, "---- %s() begin ----\n", __func__); + // + // Convert coords to subImage space. + // + psU32 subRow = row - source->pixels->row0; + psU32 subCol = col - source->pixels->col0; + + // Ensure that the starting column is allowable. + if (!((0 <= subCol) && (subCol < source->pixels->numCols))) { + psError(PS_ERR_UNKNOWN, true, "Starting column outside subImage range"); + psTrace(__func__, 4, "---- %s(NAN) end ----\n", __func__); + return(NAN); + } + if (!((0 <= subRow) && (subRow < source->pixels->numRows))) { + psTrace(__func__, 4, "---- %s(NAN) end ----\n", __func__); + psError(PS_ERR_UNKNOWN, true, "Starting row outside subImage range"); + return(NAN); + } + + // XXX EAM : i changed this to match pmModelEval above, but see + // XXX EAM the note below in pmSourceContour + psF32 oldValue = pmModelEval(source->modelEXT, source->pixels, subCol, subRow); + if (oldValue == level) { + psTrace(__func__, 4, "---- %s() end ----\n", __func__); + return(((psF32) (subCol + source->pixels->col0))); + } + + // + // We define variables incr and lastColumn so that we can use the same loop + // whether we are stepping leftwards, or rightwards. + // + psS32 incr; + psS32 lastColumn; + if (dir == 0) { + incr = -1; + lastColumn = -1; + } else { + incr = 1; + lastColumn = source->pixels->numCols; + } + subCol+=incr; + + while (subCol != lastColumn) { + psF32 newValue = pmModelEval(source->modelEXT, source->pixels, subCol, subRow); + if (oldValue == level) { + psTrace(__func__, 4, "---- %s() end ----\n", __func__); + return((psF32) (subCol + source->pixels->col0)); + } + + if ((newValue <= level) && (level <= oldValue)) { + // This is simple linear interpolation. + psTrace(__func__, 4, "---- %s() end ----\n", __func__); + return( ((psF32) (subCol + source->pixels->col0)) + ((psF32) incr) * ((level - newValue) / (oldValue - newValue)) ); + } + + if ((oldValue <= level) && (level <= newValue)) { + // This is simple linear interpolation. + psTrace(__func__, 4, "---- %s() end ----\n", __func__); + return( ((psF32) (subCol + source->pixels->col0)) + ((psF32) incr) * ((level - oldValue) / (newValue - oldValue)) ); + } + + subCol+=incr; + } + + psTrace(__func__, 4, "---- %s(NAN) end ----\n", __func__); + return(NAN); +} + +/****************************************************************************** +pmModelAlloc(): Allocate the pmModel structure, along with its parameters, +and initialize the type member. Initialize the params to 0.0. +XXX EAM: simplifying code with pmModelParameterCount +*****************************************************************************/ +pmModel *pmModelAlloc(pmModelType type) +{ + psTrace(__func__, 3, "---- %s() begin ----\n", __func__); + pmModel *tmp = (pmModel *) psAlloc(sizeof(pmModel)); + + tmp->type = type; + tmp->chisq = 0.0; + tmp->nIter = 0; + tmp->radius = 0; + tmp->status = PM_MODEL_UNTRIED; + + psS32 Nparams = pmModelParameterCount(type); + if (Nparams == 0) { + psError(PS_ERR_UNKNOWN, true, "Undefined pmModelType"); + return(NULL); + } + + tmp->params = psVectorAlloc(Nparams, PS_TYPE_F32); + tmp->dparams = psVectorAlloc(Nparams, PS_TYPE_F32); + + for (psS32 i = 0; i < tmp->params->n; i++) { + tmp->params->data.F32[i] = 0.0; + tmp->dparams->data.F32[i] = 0.0; + } + + psMemSetDeallocator(tmp, (psFreeFunc) modelFree); + psTrace(__func__, 3, "---- %s() end ----\n", __func__); + return(tmp); +} + +/****************************************************************************** +XXX EAM : we can now free these pixels - memory ref is incremented now +*****************************************************************************/ + +/****************************************************************************** +pmSourceAlloc(): Allocate the pmSource structure and initialize its members +to NULL. +*****************************************************************************/ +pmSource *pmSourceAlloc() +{ + psTrace(__func__, 3, "---- %s() begin ----\n", __func__); + pmSource *tmp = (pmSource *) psAlloc(sizeof(pmSource)); + tmp->peak = NULL; + tmp->pixels = NULL; + tmp->weight = NULL; + tmp->mask = NULL; + tmp->moments = NULL; + tmp->blends = NULL; + tmp->modelPSF = NULL; + tmp->modelEXT = NULL; + tmp->type = PM_SOURCE_UNKNOWN; + tmp->mode = PM_SOURCE_DEFAULT; + psMemSetDeallocator(tmp, (psFreeFunc) sourceFree); + + psTrace(__func__, 3, "---- %s() end ----\n", __func__); + return(tmp); +} + +/****************************************************************************** +pmFindVectorPeaks(vector, threshold): Find all local peaks in the given vector +above the given threshold. Returns a vector of type PS_TYPE_U32 containing +the location (x value) of all peaks. + +XXX: What types should be supported? Only F32 is implemented. + +XXX: We currently step through the input vector twice; once to determine the +size of the output vector, then to set the values of the output vector. +Depending upon actual use, this may need to be optimized. +*****************************************************************************/ +psVector *pmFindVectorPeaks(const psVector *vector, + psF32 threshold) +{ + psTrace(__func__, 3, "---- %s() begin ----\n", __func__); + PS_ASSERT_VECTOR_NON_NULL(vector, NULL); + PS_ASSERT_VECTOR_NON_EMPTY(vector, NULL); + PS_ASSERT_VECTOR_TYPE(vector, PS_TYPE_F32, NULL); + int count = 0; + int n = vector->n; + + // + // Special case: the input vector has a single element. + // + if (n == 1) { + psVector *tmpVector = NULL; + ; + if (vector->data.F32[0] > threshold) { + tmpVector = psVectorAlloc(1, PS_TYPE_U32); + tmpVector->data.U32[0] = 0; + } else { + tmpVector = psVectorAlloc(0, PS_TYPE_U32); + } + psTrace(__func__, 3, "---- %s() end ----\n", __func__); + return(tmpVector); + } + + // + // Determine if first pixel is a peak + // + if ((vector->data.F32[0] > vector->data.F32[1]) && + (vector->data.F32[0] > threshold)) { + count++; + } + + // + // Determine if interior pixels are peaks + // + for (psU32 i = 1; i < n-1 ; i++) { + if ((vector->data.F32[i] > vector->data.F32[i-1]) && + (vector->data.F32[i] > vector->data.F32[i+1]) && + (vector->data.F32[i] > threshold)) { + count++; + } + } + + // + // Determine if last pixel is a peak + // + if ((vector->data.F32[n-1] > vector->data.F32[n-2]) && + (vector->data.F32[n-1] > threshold)) { + count++; + } + + // + // We know how many peaks exist, so we now allocate a psVector to store + // those peaks. + // + psVector *tmpVector = psVectorAlloc(count, PS_TYPE_U32); + count = 0; + + // + // Determine if first pixel is a peak + // + if ((vector->data.F32[0] > vector->data.F32[1]) && + (vector->data.F32[0] > threshold)) { + tmpVector->data.U32[count++] = 0; + } + + // + // Determine if interior pixels are peaks + // + for (psU32 i = 1; i < (n-1) ; i++) { + if ((vector->data.F32[i] > vector->data.F32[i-1]) && + (vector->data.F32[i] > vector->data.F32[i+1]) && + (vector->data.F32[i] > threshold)) { + tmpVector->data.U32[count++] = i; + } + } + + // + // Determine if last pixel is a peak + // + if ((vector->data.F32[n-1] > vector->data.F32[n-2]) && + (vector->data.F32[n-1] > threshold)) { + tmpVector->data.U32[count++] = n-1; + } + + psTrace(__func__, 3, "---- %s() end ----\n", __func__); + return(tmpVector); +} + + +/****************************************************************************** +pmFindImagePeaks(image, threshold): Find all local peaks in the given psImage +above the given threshold. Returns a psArray containing location (x/y value) +of all peaks. + +XXX: I'm not convinced the peak type definition in the SDRS is mutually +exclusive. Some peaks can have multiple types. Edges for sure. Also, a +digonal line with the same value at each point will have a peak for every +point on that line. + +XXX: This does not work if image has either a single row, or a single column. + +XXX: In the output psArray elements, should we use the image row/column offsets? + Currently, we do not. +XXX EAM : this function needs to return peaks in *parent* coords + +XXX: Merge with CVS 1.20. This had the proper code for images with a single +row or column. + +*****************************************************************************/ +psArray *pmFindImagePeaks(const psImage *image, + psF32 threshold) +{ + psTrace(__func__, 3, "---- %s() begin ----\n", __func__); + PS_ASSERT_IMAGE_NON_NULL(image, NULL); + PS_ASSERT_IMAGE_TYPE(image, PS_TYPE_F32, NULL); + if ((image->numRows == 1) || (image->numCols == 1)) { + psError(PS_ERR_UNKNOWN, true, "Currently, input image must have at least 2 rows and 2 columns."); + psTrace(__func__, 3, "---- %s(NULL) end ----\n", __func__); + return(NULL); + } + psVector *tmpRow = NULL; + psU32 col = 0; + psU32 row = 0; + psArray *list = NULL; + + psU32 col0 = image->col0; + psU32 row0 = image->row0; + + // + // Find peaks in row 0 only. + // + row = 0; + tmpRow = getRowVectorFromImage((psImage *) image, row); + psVector *row1 = pmFindVectorPeaks(tmpRow, threshold); + // pmFindVectorPeaks returns coords in the vector, not corrected for col0 + + for (psU32 i = 0 ; i < row1->n ; i++ ) { + col = row1->data.U32[i]; + // + // Determine if pixel (0,0) is a peak. + // + if (col == 0) { + if ( (image->data.F32[row][col] > image->data.F32[row][col+1]) && + (image->data.F32[row][col] > image->data.F32[row+1][col]) && + (image->data.F32[row][col] >= image->data.F32[row+1][col+1])) { + + if (image->data.F32[row][col] > threshold) { + list = myListAddPeak(list, row + row0, col + col0, image->data.F32[row][col], PM_PEAK_EDGE); + } + } + } else if (col < (image->numCols - 1)) { + if ( (image->data.F32[row][col] >= image->data.F32[row][col-1]) && + (image->data.F32[row][col] > image->data.F32[row][col+1]) && + (image->data.F32[row][col] >= image->data.F32[row+1][col-1]) && + (image->data.F32[row][col] > image->data.F32[row+1][col]) && + (image->data.F32[row][col] >= image->data.F32[row+1][col+1])) { + if (image->data.F32[row][col] > threshold) { + list = myListAddPeak(list, row + row0, col + col0, image->data.F32[row][col], PM_PEAK_EDGE); + } + } + + } else if (col == (image->numCols - 1)) { + if ( (image->data.F32[row][col] >= image->data.F32[row][col-1]) && + (image->data.F32[row][col] > image->data.F32[row+1][col]) && + (image->data.F32[row][col] >= image->data.F32[row+1][col-1])) { + if (image->data.F32[row][col] > threshold) { + list = myListAddPeak(list, row + row0, col + col0, image->data.F32[row][col], PM_PEAK_EDGE); + } + } + + } else { + psError(PS_ERR_UNKNOWN, true, "peak specified valid column range."); + } + } + psFree (tmpRow); + psFree (row1); + + // + // Exit if this image has a single row. + // + if (image->numRows == 1) { + psTrace(__func__, 3, "---- %s() end ----\n", __func__); + return(list); + } + + // + // Find peaks in interior rows only. + // + for (row = 1 ; row < (image->numRows - 1) ; row++) { + tmpRow = getRowVectorFromImage((psImage *) image, row); + row1 = pmFindVectorPeaks(tmpRow, threshold); + + // Step through all local peaks in this row. + for (psU32 i = 0 ; i < row1->n ; i++ ) { + pmPeakType myType = PM_PEAK_UNDEF; + col = row1->data.U32[i]; + + if (col == 0) { + // If col==0, then we can not read col-1 pixels + if ((image->data.F32[row][col] > image->data.F32[row-1][col]) && + (image->data.F32[row][col] >= image->data.F32[row-1][col+1]) && + (image->data.F32[row][col] >= image->data.F32[row][col+1]) && + (image->data.F32[row][col] >= image->data.F32[row+1][col]) && + (image->data.F32[row][col] >= image->data.F32[row+1][col+1])) { + myType = PM_PEAK_EDGE; + list = myListAddPeak(list, row + row0, col + col0, image->data.F32[row][col], myType); + } + } else if (col < (image->numCols - 1)) { + // This is an interior pixel + if ((image->data.F32[row][col] >= image->data.F32[row-1][col-1]) && + (image->data.F32[row][col] > image->data.F32[row-1][col]) && + (image->data.F32[row][col] >= image->data.F32[row-1][col+1]) && + (image->data.F32[row][col] > image->data.F32[row][col-1]) && + (image->data.F32[row][col] >= image->data.F32[row][col+1]) && + (image->data.F32[row][col] >= image->data.F32[row+1][col-1]) && + (image->data.F32[row][col] >= image->data.F32[row+1][col]) && + (image->data.F32[row][col] >= image->data.F32[row+1][col+1])) { + if (image->data.F32[row][col] > threshold) { + if ((image->data.F32[row][col] > image->data.F32[row-1][col-1]) && + (image->data.F32[row][col] > image->data.F32[row-1][col]) && + (image->data.F32[row][col] > image->data.F32[row-1][col+1]) && + (image->data.F32[row][col] > image->data.F32[row][col-1]) && + (image->data.F32[row][col] > image->data.F32[row][col+1]) && + (image->data.F32[row][col] > image->data.F32[row+1][col-1]) && + (image->data.F32[row][col] > image->data.F32[row+1][col]) && + (image->data.F32[row][col] > image->data.F32[row+1][col+1])) { + myType = PM_PEAK_LONE; + } + + if ((image->data.F32[row][col] == image->data.F32[row-1][col-1]) || + (image->data.F32[row][col] == image->data.F32[row-1][col]) || + (image->data.F32[row][col] == image->data.F32[row-1][col+1]) || + (image->data.F32[row][col] == image->data.F32[row][col-1]) || + (image->data.F32[row][col] == image->data.F32[row][col+1]) || + (image->data.F32[row][col] == image->data.F32[row+1][col-1]) || + (image->data.F32[row][col] == image->data.F32[row+1][col]) || + (image->data.F32[row][col] == image->data.F32[row+1][col+1])) { + myType = PM_PEAK_FLAT; + } + + list = myListAddPeak(list, row + row0, col + col0, image->data.F32[row][col], myType); + } + } + } else if (col == (image->numCols - 1)) { + // If col==numCols - 1, then we can not read col+1 pixels + if ((image->data.F32[row][col] >= image->data.F32[row-1][col-1]) && + (image->data.F32[row][col] > image->data.F32[row-1][col]) && + (image->data.F32[row][col] > image->data.F32[row][col-1]) && + (image->data.F32[row][col] >= image->data.F32[row][col+1]) && + (image->data.F32[row][col] >= image->data.F32[row+1][col-1]) && + (image->data.F32[row][col] >= image->data.F32[row+1][col])) { + myType = PM_PEAK_EDGE; + list = myListAddPeak(list, row + row0, col + col0, image->data.F32[row][col], myType); + } + } else { + psError(PS_ERR_UNKNOWN, true, "peak specified outside valid column range."); + } + + } + psFree (tmpRow); + psFree (row1); + } + + // + // Find peaks in the last row only. + // + row = image->numRows - 1; + tmpRow = getRowVectorFromImage((psImage *) image, row); + row1 = pmFindVectorPeaks(tmpRow, threshold); + for (psU32 i = 0 ; i < row1->n ; i++ ) { + col = row1->data.U32[i]; + if (col == 0) { + if ( (image->data.F32[row][col] > image->data.F32[row-1][col]) && + (image->data.F32[row][col] >= image->data.F32[row-1][col+1]) && + (image->data.F32[row][col] > image->data.F32[row][col+1])) { + if (image->data.F32[row][col] > threshold) { + list = myListAddPeak(list, row + row0, col + col0, image->data.F32[row][col], PM_PEAK_EDGE); + } + } + } else if (col < (image->numCols - 1)) { + if ( (image->data.F32[row][col] >= image->data.F32[row-1][col-1]) && + (image->data.F32[row][col] > image->data.F32[row-1][col]) && + (image->data.F32[row][col] >= image->data.F32[row-1][col+1]) && + (image->data.F32[row][col] > image->data.F32[row][col-1]) && + (image->data.F32[row][col] >= image->data.F32[row][col+1])) { + if (image->data.F32[row][col] > threshold) { + list = myListAddPeak(list, row + row0, col + col0, image->data.F32[row][col], PM_PEAK_EDGE); + } + } + + } else if (col == (image->numCols - 1)) { + if ( (image->data.F32[row][col] >= image->data.F32[row-1][col-1]) && + (image->data.F32[row][col] > image->data.F32[row-1][col]) && + (image->data.F32[row][col] > image->data.F32[row][col-1])) { + if (image->data.F32[row][col] > threshold) { + list = myListAddPeak(list, row + row0, col + col0, image->data.F32[row][col], PM_PEAK_EDGE); + } + } + } else { + psError(PS_ERR_UNKNOWN, true, "peak specified outside valid column range."); + } + } + psFree (tmpRow); + psFree (row1); + psTrace(__func__, 3, "---- %s() end ----\n", __func__); + return(list); +} + + +/****************************************************************************** +psCullPeaks(peaks, maxValue, valid): eliminate peaks from the psArray that have +a peak value above the given maximum, or fall outside the valid region. + +XXX: Should the sky value be used when comparing the maximum? + +XXX: warning message if valid is NULL? + +XXX: changed API to create a NEW output psArray (should change name as well) + +XXX: Do we free the psList elements of those culled peaks? + +XXX EAM : do we still need pmCullPeaks, or only pmPeaksSubset? +*****************************************************************************/ +psList *pmCullPeaks(psList *peaks, + psF32 maxValue, + const psRegion valid) +{ + psTrace(__func__, 3, "---- %s() begin ----\n", __func__); + PS_ASSERT_PTR_NON_NULL(peaks, NULL); + + psListElem *tmpListElem = (psListElem *) peaks->head; + psS32 indexNum = 0; + + // printf("pmCullPeaks(): list size is %d\n", peaks->size); + while (tmpListElem != NULL) { + pmPeak *tmpPeak = (pmPeak *) tmpListElem->data; + if ((tmpPeak->counts > maxValue) || + (true == isItInThisRegion(valid, tmpPeak->x, tmpPeak->y))) { + psListRemoveData(peaks, (psPtr) tmpPeak); + } + + indexNum++; + tmpListElem = tmpListElem->next; + } + + psTrace(__func__, 3, "---- %s() end ----\n", __func__); + return(peaks); +} + +// XXX EAM: I changed this to return a new, subset array +// rather than alter the existing one +// XXX: Fix the *valid pointer. +psArray *pmPeaksSubset( + psArray *peaks, + psF32 maxValue, + const psRegion valid) +{ + psTrace(__func__, 3, "---- %s() begin ----\n", __func__); + PS_ASSERT_PTR_NON_NULL(peaks, NULL); + + psArray *output = psArrayAlloc (200); + output->n = 0; + + psTrace (".pmObjects.pmCullPeaks", 3, "list size is %d\n", peaks->n); + + for (int i = 0; i < peaks->n; i++) { + pmPeak *tmpPeak = (pmPeak *) peaks->data[i]; + if (tmpPeak->counts > maxValue) + continue; + if (isItInThisRegion(valid, tmpPeak->x, tmpPeak->y)) + continue; + psArrayAdd (output, 200, tmpPeak); + } + psTrace(__func__, 3, "---- %s() end ----\n", __func__); + return(output); +} + +/****************************************************************************** +pmSource *pmSourceLocalSky(image, peak, innerRadius, outerRadius): this +routine creates a new pmSource data structure and sets the following members: + ->pmPeak + ->pmMoments->sky + +The sky value is set from the pixels in the square annulus surrounding the +peak pixel. + +We simply create a subSet image and mask the inner pixels, then call +psImageStats on that subImage+mask. + +XXX: The subImage has width of 1+2*outerRadius. Verify with IfA. + +XXX: Use static data structures for: + subImage + subImageMask + myStats + +XXX: ensure that the inner and out radius fit in the actual image. Should + we generate an error, or warning? Currently an error. + +XXX: Sync with IfA on whether the peak x/y coords are data structure coords, + or they use the image row/column offsets. +XXX EAM : peak->x,y uses parent coordinates + +XXX: Should we simply set pmSource->peak = peak? If so, should we increase +the reference counter? Or, should we copy the data structure? + +XXX: Currently the subimage always has an even number of rows/columns. Is + this correct? Since there is a center pixel, maybe it should have an + odd number of rows/columns. + +XXX: Use psTrace() for the print statements. + +XXX: Don't use separate structs for the subimage and mask. Use the source-> + members. +*****************************************************************************/ + +bool pmSourceLocalSky( + pmSource *source, + psStatsOptions statsOptions, + psF32 Radius) +{ + psTrace(__func__, 3, "---- %s() begin ----\n", __func__); + PS_ASSERT_PTR_NON_NULL(source, false); + PS_ASSERT_IMAGE_NON_NULL(source->pixels, false); + PS_ASSERT_IMAGE_NON_NULL(source->mask, false); + PS_ASSERT_PTR_NON_NULL(source->peak, false); + PS_ASSERT_INT_POSITIVE(Radius, false); + PS_ASSERT_INT_NONNEGATIVE(Radius, false); + + psImage *image = source->pixels; + psImage *mask = source->mask; + pmPeak *peak = source->peak; + psRegion srcRegion; + + srcRegion = psRegionForSquare(peak->x, peak->y, Radius); + srcRegion = psRegionForImage(mask, srcRegion); + + psImageMaskRegion(mask, srcRegion, "OR", PSPHOT_MASK_MARKED); + psStats *myStats = psStatsAlloc(statsOptions); + myStats = psImageStats(myStats, image, mask, 0xff); + psImageMaskRegion(mask, srcRegion, "AND", ~PSPHOT_MASK_MARKED); + + psF64 tmpF64; + p_psGetStatValue(myStats, &tmpF64); + psFree(myStats); + + if (isnan(tmpF64)) { + psTrace(__func__, 3, "---- %s(false) end ----\n", __func__); + return(false); + } + if (source->moments == NULL) { + source->moments = pmMomentsAlloc(); + } + source->moments->Sky = (psF32) tmpF64; + psTrace(__func__, 3, "---- %s(true) end ----\n", __func__); + return (true); +} + +// A complementary function to pmSourceLocalSky: calculate the local median variance +bool pmSourceLocalSkyVariance( + pmSource *source, + psStatsOptions statsOptions, + psF32 Radius) +{ + psTrace(__func__, 3, "---- %s() begin ----\n", __func__); + PS_ASSERT_PTR_NON_NULL(source, false); + PS_ASSERT_IMAGE_NON_NULL(source->weight, false); + PS_ASSERT_IMAGE_NON_NULL(source->mask, false); + PS_ASSERT_PTR_NON_NULL(source->peak, false); + PS_ASSERT_INT_POSITIVE(Radius, false); + PS_ASSERT_INT_NONNEGATIVE(Radius, false); + + psImage *image = source->weight; + psImage *mask = source->mask; + pmPeak *peak = source->peak; + psRegion srcRegion; + + srcRegion = psRegionForSquare(peak->x, peak->y, Radius); + srcRegion = psRegionForImage(mask, srcRegion); + + psImageMaskRegion(mask, srcRegion, "OR", PSPHOT_MASK_MARKED); + psStats *myStats = psStatsAlloc(statsOptions); + myStats = psImageStats(myStats, image, mask, 0xff); + psImageMaskRegion(mask, srcRegion, "AND", ~PSPHOT_MASK_MARKED); + + psF64 tmpF64; + p_psGetStatValue(myStats, &tmpF64); + psFree(myStats); + + if (isnan(tmpF64)) { + psTrace(__func__, 3, "---- %s(false) end ----\n", __func__); + return(false); + } + if (source->moments == NULL) { + source->moments = pmMomentsAlloc(); + } + source->moments->dSky = (psF32) tmpF64; + psTrace(__func__, 3, "---- %s(true) end ----\n", __func__); + return (true); +} + +/****************************************************************************** +pmSourceMoments(source, radius): this function takes a subImage defined in the +pmSource data structure, along with the peak location, and determines the +various moments associated with that peak. + +Requires the following to have been created: + pmSource + pmSource->peak + pmSource->pixels + pmSource->weight + pmSource->mask + +XXX: The peak calculations are done in image coords, not subImage coords. + +XXX EAM : this version clips input pixels on S/N +XXX EAM : this version returns false for several reasons +*****************************************************************************/ +# define VALID_RADIUS(X,Y,RAD2) (((RAD2) >= (PS_SQR(X) + PS_SQR(Y))) ? 1 : 0) + +bool pmSourceMoments(pmSource *source, + psF32 radius) +{ + psTrace(__func__, 3, "---- %s() begin ----\n", __func__); + PS_ASSERT_PTR_NON_NULL(source, false); + PS_ASSERT_PTR_NON_NULL(source->peak, false); + PS_ASSERT_PTR_NON_NULL(source->pixels, false); + PS_ASSERT_PTR_NON_NULL(source->mask, false); + PS_ASSERT_FLOAT_LARGER_THAN(radius, 0.0, false); + + // + // XXX: Verify the setting for sky if source->moments == NULL. + // + psF32 sky = 0.0; + if (source->moments == NULL) { + source->moments = pmMomentsAlloc(); + } else { + sky = source->moments->Sky; + } + + // + // Sum = SUM (z - sky) + // X1 = SUM (x - xc)*(z - sky) + // X2 = SUM (x - xc)^2 * (z - sky) + // XY = SUM (x - xc)*(y - yc)*(z - sky) + // + psF32 peakPixel = -PS_MAX_F32; + psS32 numPixels = 0; + psF32 Sum = 0.0; + psF32 Var = 0.0; + psF32 X1 = 0.0; + psF32 Y1 = 0.0; + psF32 X2 = 0.0; + psF32 Y2 = 0.0; + psF32 XY = 0.0; + psF32 x = 0; + psF32 y = 0; + psF32 R2 = PS_SQR(radius); + + psF32 xPeak = source->peak->x; + psF32 yPeak = source->peak->y; + psF32 xOff = source->pixels->col0 - source->peak->x; + psF32 yOff = source->pixels->row0 - source->peak->y; + + // XXX why do I get different results for these two methods of finding Sx? + // XXX Sx, Sy would be better measured if we clip pixels close to sky + // XXX Sx, Sy can still be imaginary, so we probably need to keep Sx^2? + // We loop through all pixels in this subimage (source->pixels), and for each + // pixel that is not masked, AND within the radius of the peak pixel, we + // proceed with the moments calculation. need to do two loops for a + // numerically stable result. first loop: get the sums. + // XXX EAM : mask == 0 is valid + + psF32 **vPix = source->pixels->data.F32; + psF32 **vWgt = source->weight->data.F32; + psU8 **vMsk = source->mask->data.U8; + + for (psS32 row = 0; row < source->pixels->numRows ; row++) { + for (psS32 col = 0; col < source->pixels->numCols ; col++) { + if ((source->mask != NULL) && (vMsk[row][col])) { + continue; + } + + // psF32 xDiff = col + source->pixels->col0 - xPeak; + // psF32 yDiff = row + source->pixels->row0 - yPeak; + + psF32 xDiff = col + xOff; + psF32 yDiff = row + yOff; + + // XXX EAM : calculate xDiff, yDiff up front; + // radius is just a function of (xDiff, yDiff) + if (!VALID_RADIUS(xDiff, yDiff, R2)) { + continue; + } + + psF32 pDiff = vPix[row][col] - sky; + psF32 wDiff = vWgt[row][col]; + + // XXX EAM : check for valid S/N in pixel + // XXX EAM : should this limit be user-defined? + if (PS_SQR(pDiff) < wDiff) { + continue; + } + + Var += wDiff; + Sum += pDiff; + + psF32 xWght = xDiff * pDiff; + psF32 yWght = yDiff * pDiff; + + X1 += xWght; + Y1 += yWght; + XY += xDiff * yWght; + + X2 += xDiff * xWght; + Y2 += yDiff * yWght; + + peakPixel = PS_MAX (vPix[row][col], peakPixel); + numPixels++; + } + } + + // if we have less than (1/4) of the possible pixels, force a retry + // XXX EAM - the limit is a bit arbitrary. make it user defined? + if ((numPixels < 0.75*R2) || (Sum <= 0)) { + psTrace (".psModules.pmSourceMoments", 3, "no valid pixels for source\n"); + psTrace(__func__, 3, "---- %s(false) end ----\n", __func__); + return (false); + } + + psTrace (".psModules.pmSourceMoments", 5, + "sky: %f Sum: %f X1: %f Y1: %f X2: %f Y2: %f XY: %f Npix: %d\n", + sky, Sum, X1, Y1, X2, Y2, XY, numPixels); + + // + // first moment X = X1/Sum + xc + // second moment X = sqrt (X2/Sum - (X1/Sum)^2) + // Sxy = XY / Sum + // + x = X1/Sum; + y = Y1/Sum; + if ((fabs(x) > radius) || (fabs(y) > radius)) { + psTrace (".psModules.pmSourceMoments", 3, + "large centroid swing; invalid peak %d, %d\n", + source->peak->x, source->peak->y); + psTrace(__func__, 3, "---- %s(false) end ----\n", __func__); + return (false); + } + + source->moments->x = x + xPeak; + source->moments->y = y + yPeak; + + // XXX EAM : Sxy needs to have x*y subtracted + source->moments->Sxy = XY/Sum - x*y; + source->moments->Sum = Sum; + source->moments->SN = Sum / sqrt(Var); + source->moments->Peak = peakPixel; + source->moments->nPixels = numPixels; + + // XXX EAM : these values can be negative, so we need to limit the range + source->moments->Sx = sqrt(PS_MAX(X2/Sum - PS_SQR(x), 0)); + source->moments->Sy = sqrt(PS_MAX(Y2/Sum - PS_SQR(y), 0)); + + psTrace (".psModules.pmSourceMoments", 4, + "sky: %f Sum: %f x: %f y: %f Sx: %f Sy: %f Sxy: %f\n", + sky, Sum, source->moments->x, source->moments->y, + source->moments->Sx, source->moments->Sy, source->moments->Sxy); + + psTrace(__func__, 3, "---- %s(true) end ----\n", __func__); + return(true); +} + +// XXX EAM : I used +int pmComparePeakAscend (const void **a, const void **b) +{ + psTrace(__func__, 3, "---- %s() begin ----\n", __func__); + pmPeak *A = *(pmPeak **)a; + pmPeak *B = *(pmPeak **)b; + + psF32 diff; + + diff = A->counts - B->counts; + if (diff < FLT_EPSILON) { + psTrace(__func__, 3, "---- %s(-1) end ----\n", __func__); + return (-1); + } else if (diff > FLT_EPSILON) { + psTrace(__func__, 3, "---- %s(+1) end ----\n", __func__); + return (+1); + } + psTrace(__func__, 3, "---- %s(0) end ----\n", __func__); + return (0); +} + +int pmComparePeakDescend (const void **a, const void **b) +{ + psTrace(__func__, 3, "---- %s() begin ----\n", __func__); + pmPeak *A = *(pmPeak **)a; + pmPeak *B = *(pmPeak **)b; + + psF32 diff; + + diff = A->counts - B->counts; + if (diff < FLT_EPSILON) { + psTrace(__func__, 3, "---- %s(+1) end ----\n", __func__); + return (+1); + } else if (diff > FLT_EPSILON) { + psTrace(__func__, 3, "---- %s(-1) end ----\n", __func__); + return (-1); + } + psTrace(__func__, 3, "---- %s(0) end ----\n", __func__); + return (0); +} + +/****************************************************************************** + pmSourcePSFClump(source, metadata): Find the likely PSF clump in the + sigma-x, sigma-y plane. return 0,0 clump in case of error. +*****************************************************************************/ + +// XXX EAM include a S/N cutoff in selecting the sources? +pmPSFClump pmSourcePSFClump(psArray *sources, psMetadata *metadata) +{ + psTrace(__func__, 3, "---- %s() begin ----\n", __func__); + + # define NPIX 10 + # define SCALE 0.1 + + psArray *peaks = NULL; + pmPSFClump emptyClump = {0.0, 0.0, 0.0, 0.0}; + pmPSFClump psfClump = emptyClump; + + PS_ASSERT_PTR_NON_NULL(sources, emptyClump); + PS_ASSERT_PTR_NON_NULL(metadata, emptyClump); + + // find the sigmaX, sigmaY clump + { + psStats *stats = NULL; + psImage *splane = NULL; + int binX, binY; + bool status; + + psF32 SX_MAX = psMetadataLookupF32 (&status, metadata, "MOMENTS_SX_MAX"); + if (!status) + SX_MAX = 10.0; + psF32 SY_MAX = psMetadataLookupF32 (&status, metadata, "MOMENTS_SY_MAX"); + if (!status) + SY_MAX = 10.0; + + // construct a sigma-plane image + // psImageAlloc does zero the data + splane = psImageAlloc (SX_MAX/SCALE, SY_MAX/SCALE, PS_TYPE_F32); + for (int i = 0; i < splane->numRows; i++) + { + memset (splane->data.F32[i], 0, splane->numCols*sizeof(PS_TYPE_F32)); + } + + // place the sources in the sigma-plane image (ignore 0,0 values?) + for (psS32 i = 0 ; i < sources->n ; i++) + { + pmSource *tmpSrc = (pmSource *) sources->data[i]; + if (tmpSrc == NULL) { + continue; + } + if (tmpSrc->moments == NULL) { + continue; + } + + // Sx,Sy are limited at 0. a peak at 0,0 is artificial + if ((fabs(tmpSrc->moments->Sx) < FLT_EPSILON) && (fabs(tmpSrc->moments->Sy) < FLT_EPSILON)) { + continue; + } + + // for the moment, force splane dimensions to be 10x10 image pix + binX = tmpSrc->moments->Sx/SCALE; + if (binX < 0) + continue; + if (binX >= splane->numCols) + continue; + + binY = tmpSrc->moments->Sy/SCALE; + if (binY < 0) + continue; + if (binY >= splane->numRows) + continue; + + splane->data.F32[binY][binX] += 1.0; + } + + // find the peak in this image + stats = psStatsAlloc (PS_STAT_MAX); + stats = psImageStats (stats, splane, NULL, 0); + peaks = pmFindImagePeaks (splane, stats[0].max / 2); + psTrace (".pmObjects.pmSourceRoughClass", 2, "clump threshold is %f\n", stats[0].max/2); + + psFree (splane); + psFree (stats); + + } + // XXX EAM : possible errors: + // 1) no peak in splane + // 2) no significant peak in splane + + // measure statistics on Sx, Sy if Sx, Sy within range of clump + { + pmPeak *clump; + psF32 minSx, maxSx; + psF32 minSy, maxSy; + psVector *tmpSx = NULL; + psVector *tmpSy = NULL; + psStats *stats = NULL; + + // XXX EAM : this lets us takes the single highest peak + psArraySort (peaks, pmComparePeakDescend); + clump = peaks->data[0]; + psTrace (".pmObjects.pmSourceRoughClass", 2, "clump is at %d, %d (%f)\n", clump->x, clump->y, clump->counts); + + // define section window for clump + minSx = clump->x * SCALE - 0.2; + maxSx = clump->x * SCALE + 0.2; + minSy = clump->y * SCALE - 0.2; + maxSy = clump->y * SCALE + 0.2; + + tmpSx = psVectorAlloc (sources->n, PS_TYPE_F32); + tmpSy = psVectorAlloc (sources->n, PS_TYPE_F32); + tmpSx->n = 0; + tmpSy->n = 0; + + // XXX clip sources based on flux? + // create vectors with Sx, Sy values in window + for (psS32 i = 0 ; i < sources->n ; i++) + { + pmSource *tmpSrc = (pmSource *) sources->data[i]; + + if (tmpSrc->moments->Sx < minSx) + continue; + if (tmpSrc->moments->Sx > maxSx) + continue; + if (tmpSrc->moments->Sy < minSy) + continue; + if (tmpSrc->moments->Sy > maxSy) + continue; + tmpSx->data.F32[tmpSx->n] = tmpSrc->moments->Sx; + tmpSy->data.F32[tmpSy->n] = tmpSrc->moments->Sy; + tmpSx->n++; + tmpSy->n++; + if (tmpSx->n == tmpSx->nalloc) { + psVectorRealloc (tmpSx, tmpSx->nalloc + 100); + psVectorRealloc (tmpSy, tmpSy->nalloc + 100); + } + } + + // measures stats of Sx, Sy + stats = psStatsAlloc (PS_STAT_CLIPPED_MEAN | PS_STAT_CLIPPED_STDEV); + + stats = psVectorStats (stats, tmpSx, NULL, NULL, 0); + psfClump.X = stats->clippedMean; + psfClump.dX = stats->clippedStdev; + + stats = psVectorStats (stats, tmpSy, NULL, NULL, 0); + psfClump.Y = stats->clippedMean; + psfClump.dY = stats->clippedStdev; + + psTrace (".pmObjects.pmSourceRoughClass", 2, "clump X, Y: %f, %f\n", psfClump.X, psfClump.Y); + psTrace (".pmObjects.pmSourceRoughClass", 2, "clump DX, DY: %f, %f\n", psfClump.dX, psfClump.dY); + // these values should be pushed on the metadata somewhere + + psFree (stats); + psFree (peaks); + psFree (tmpSx); + psFree (tmpSy); + } + + psTrace(__func__, 3, "---- %s() end ----\n", __func__); + return (psfClump); +} + +/****************************************************************************** + pmSourceRoughClass(source, metadata): make a guess at the source + classification. + + XXX: push the clump info into the metadata? + + XXX: How can this function ever return FALSE? + + EAM: I moved S/N calculation to pmSourceMoments, using weight image +*****************************************************************************/ + +bool pmSourceRoughClass(psArray *sources, psMetadata *metadata, pmPSFClump clump) +{ + psTrace(__func__, 3, "---- %s() begin ----\n", __func__); + + psBool rc = true; + + int Nsat = 0; + int Next = 0; + int Nstar = 0; + int Npsf = 0; + int Ncr = 0; + int Nsatstar = 0; + // psRegion allArray = psRegionSet (0, 0, 0, 0); + psRegion inner; + + // report stats on S/N values for star-like objects + psVector *starsn = psVectorAlloc (sources->n, PS_TYPE_F32); + starsn->n = 0; + + // check return status value (do these exist?) + bool status; + psF32 PSF_SN_LIM = psMetadataLookupF32 (&status, metadata, "PSF_SN_LIM"); + + // XXX allow clump size to be scaled relative to sigmas? + // make rough IDs based on clumpX,Y,DX,DY + for (psS32 i = 0 ; i < sources->n ; i++) { + + pmSource *tmpSrc = (pmSource *) sources->data[i]; + + tmpSrc->peak->type = 0; + + psF32 sigX = tmpSrc->moments->Sx; + psF32 sigY = tmpSrc->moments->Sy; + + // XXX EAM : can we use the value of SATURATE if mask is NULL? + // inner = psRegionForSquare (tmpSrc->peak->x - tmpSrc->mask->col0, tmpSrc->peak->y - tmpSrc->mask->row0, 2); + inner = psRegionForSquare (tmpSrc->peak->x, tmpSrc->peak->y, 2); + int Nsatpix = psImageCountPixelMask (tmpSrc->mask, inner, PSPHOT_MASK_SATURATED); + + // saturated star (size consistent with PSF or larger) + // Nsigma should be user-configured parameter + bool big = (sigX > (clump.X - clump.dX)) && (sigY > (clump.Y - clump.dY)); + big = true; + if ((Nsatpix > 1) && big) { + tmpSrc->type = PM_SOURCE_STAR; + tmpSrc->mode = PM_SOURCE_SATSTAR; + Nsatstar ++; + continue; + } + + // saturated object (not a star, eg bleed trails, hot pixels) + if (Nsatpix > 1) { + tmpSrc->type = PM_SOURCE_SATURATED; + tmpSrc->mode = PM_SOURCE_DEFAULT; + Nsat ++; + continue; + } + + // likely defect (too small to be stellar) (push out to 3 sigma) + // low S/N objects which are small are probably stellar + // only set candidate defects if + if ((sigX < 0.05) || (sigY < 0.05)) { + tmpSrc->type = PM_SOURCE_DEFECT; + tmpSrc->mode = PM_SOURCE_DEFAULT; + Ncr ++; + continue; + } + + // likely unsaturated extended source (too large to be stellar) + if ((sigX > (clump.X + 3*clump.dX)) || (sigY > (clump.Y + 3*clump.dY))) { + tmpSrc->type = PM_SOURCE_EXTENDED; + tmpSrc->mode = PM_SOURCE_DEFAULT; + Next ++; + continue; + } + + // the rest are probable stellar objects + starsn->data.F32[starsn->n] = tmpSrc->moments->SN; + starsn->n ++; + Nstar ++; + + // PSF star (within 1.5 sigma of clump center, S/N > limit) + psF32 radius = hypot ((sigX-clump.X)/clump.dX, (sigY-clump.Y)/clump.dY); + if ((tmpSrc->moments->SN > PSF_SN_LIM) && (radius < 1.5)) { + tmpSrc->type = PM_SOURCE_STAR; + tmpSrc->mode = PM_SOURCE_PSFSTAR; + Npsf ++; + continue; + } + + // random type of star + tmpSrc->type = PM_SOURCE_STAR; + tmpSrc->mode = PM_SOURCE_DEFAULT; + } + + { + psStats *stats = NULL; + stats = psStatsAlloc (PS_STAT_MIN | PS_STAT_MAX); + stats = psVectorStats (stats, starsn, NULL, NULL, 0); + psLogMsg ("pmObjects", 3, "SN range: %f - %f\n", stats[0].min, stats[0].max); + psFree (stats); + psFree (starsn); + } + + psTrace (".pmObjects.pmSourceRoughClass", 2, "Nstar: %3d\n", Nstar); + psTrace (".pmObjects.pmSourceRoughClass", 2, "Npsf: %3d\n", Npsf); + psTrace (".pmObjects.pmSourceRoughClass", 2, "Next: %3d\n", Next); + psTrace (".pmObjects.pmSourceRoughClass", 2, "Nsatstar: %3d\n", Nsatstar); + psTrace (".pmObjects.pmSourceRoughClass", 2, "Nsat: %3d\n", Nsat); + psTrace (".pmObjects.pmSourceRoughClass", 2, "Ncr: %3d\n", Ncr); + + psTrace(__func__, 3, "---- %s(%d) end ----\n", __func__, rc); + return(rc); +} + +/** pmSourceDefinePixels() + * + * Define psImage subarrays for the source located at coordinates x,y on the + * image set defined by readout. The pixels defined by this operation consist of + * a square window (of full width 2Radius+1) centered on the pixel which contains + * the given coordinate, in the frame of the readout. The window is defined to + * have limits which are valid within the boundary of the readout image, thus if + * the radius would fall outside the image pixels, the subimage is truncated to + * only consist of valid pixels. If readout->mask or readout->weight are not + * NULL, matching subimages are defined for those images as well. This function + * fails if no valid pixels can be defined (x or y less than Radius, for + * example). This function should be used to define a region of interest around a + * source, including both source and sky pixels. + * + * XXX: must code this. + * + */ +bool pmSourceDefinePixels( + pmSource *mySource, ///< Add comment. + pmReadout *readout, ///< Add comment. + psF32 x, ///< Add comment. + psF32 y, ///< Add comment. + psF32 Radius) ///< Add comment. +{ + psTrace(__func__, 3, "---- %s() begin ----\n", __func__); + psLogMsg(__func__, PS_LOG_WARN, "WARNING: pmSourceDefinePixels() has not been implemented. Returning FALSE.\n"); + psTrace(__func__, 3, "---- %s() end ----\n", __func__); + return(false); +} + +/****************************************************************************** + pmSourceSetPixelsCircle(source, image, radius) + + XXX: This was replaced by DefinePixels in SDRS. Remove it. +*****************************************************************************/ +bool pmSourceSetPixelsCircle(pmSource *source, + const psImage *image, + psF32 radius) +{ + psTrace(__func__, 3, "---- %s() begin ----\n", __func__); + PS_ASSERT_IMAGE_NON_NULL(image, false); + PS_ASSERT_IMAGE_TYPE(image, PS_TYPE_F32, false); + PS_ASSERT_PTR_NON_NULL(source, false); + PS_ASSERT_PTR_NON_NULL(source->moments, false); + PS_ASSERT_PTR_NON_NULL(source->peak, false); + PS_ASSERT_FLOAT_LARGER_THAN_OR_EQUAL(radius, 0.0, false); + + // + // We define variables for code readability. + // + // XXX: Since the peak->xy coords are in image, not subImage coords, + // these variables should be renamed for clarity (imageCenterRow, etc). + // + psS32 radiusS32 = (psS32) radius; + psS32 SubImageCenterRow = source->peak->y; + psS32 SubImageCenterCol = source->peak->x; + // XXX EAM : for the circle to stay on the image + // XXX EAM : EndRow is *exclusive* of pixel region (ie, last pixel + 1) + psS32 SubImageStartRow = PS_MAX (0, SubImageCenterRow - radiusS32); + psS32 SubImageEndRow = PS_MIN (image->numRows, SubImageCenterRow + radiusS32 + 1); + psS32 SubImageStartCol = PS_MAX (0, SubImageCenterCol - radiusS32); + psS32 SubImageEndCol = PS_MIN (image->numCols, SubImageCenterCol + radiusS32 + 1); + + // XXX: Must recycle image. + // XXX EAM: this message reflects a programming error we know about. + // i am setting it to a trace message which we can take out + if (source->pixels != NULL) { + psTrace (".psModule.pmObjects.pmSourceSetPixelsCircle", 4, + "WARNING: pmSourceSetPixelsCircle(): image->pixels not NULL. Freeing and reallocating.\n"); + psFree(source->pixels); + } + source->pixels = psImageSubset((psImage *) image, psRegionSet(SubImageStartCol, + SubImageStartRow, + SubImageEndCol, + SubImageEndRow)); + + // XXX: Must recycle image. + if (source->mask != NULL) { + psFree(source->mask); + } + source->mask = psImageAlloc(source->pixels->numCols, + source->pixels->numRows, + PS_TYPE_U8); // XXX EAM : type was F32 + + // + // Loop through the subimage mask, initialize mask to 0 or 1. + // XXX EAM: valid pixels should have 0, not 1 + for (psS32 row = 0 ; row < source->mask->numRows; row++) { + for (psS32 col = 0 ; col < source->mask->numCols; col++) { + + if (checkRadius2((psF32) radiusS32, + (psF32) radiusS32, + radius, + (psF32) col, + (psF32) row)) { + source->mask->data.U8[row][col] = 0; + } else { + source->mask->data.U8[row][col] = 1; + } + } + } + psTrace(__func__, 3, "---- %s(true) end ----\n", __func__); + return(true); +} + +/****************************************************************************** + pmSourceModelGuess(source, model): This function allocates a new + pmModel structure based on the given modelType specified in the argument list. + The corresponding pmModelGuess function is returned, and used to + supply the values of the params array in the pmModel structure. + + XXX: Many parameters are based on the src->moments structure, which is in + image, not subImage coords. Therefore, the calls to the model evaluation + functions will be in image, not subImage coords. Remember this. +*****************************************************************************/ +pmModel *pmSourceModelGuess(pmSource *source, + pmModelType modelType) +{ + psTrace(__func__, 3, "---- %s() begin ----\n", __func__); + PS_ASSERT_PTR_NON_NULL(source->moments, false); + PS_ASSERT_PTR_NON_NULL(source->peak, false); + + pmModel *model = pmModelAlloc(modelType); + + pmModelGuessFunc modelGuessFunc = pmModelGuessFunc_GetFunction(modelType); + modelGuessFunc(model, source); + psTrace(__func__, 3, "---- %s() end ----\n", __func__); + return(model); +} + +/****************************************************************************** + evalModel(source, level, row): a private function which evaluates the + source->modelPSF function at the specified coords. The coords are subImage, not + image coords. + + NOTE: The coords are in subImage source->pixel coords, not image coords. + + XXX: reverse order of row,col args? + + XXX: rename all coords in this file such that their name defines whether + the coords is in subImage or image space. + + XXX: This should probably be a public pmModules function. + + XXX: Use static vectors for x. + + XXX: Figure out if it's (row, col) or (col, row) for the model functions. + + XXX: For a while, the first psVectorAlloc() was generating a seg fault during + testing. Try to reproduce that and debug. +*****************************************************************************/ + +// XXX EAM : I have made this a public function +// XXX EAM : this now uses a pmModel as the input +// XXX EAM : it was using src->type to find the model, not model->type +psF32 pmModelEval(pmModel *model, psImage *image, psS32 col, psS32 row) +{ + psTrace(__func__, 3, "---- %s() begin ----\n", __func__); + PS_ASSERT_PTR_NON_NULL(image, false); + PS_ASSERT_PTR_NON_NULL(model, false); + PS_ASSERT_PTR_NON_NULL(model->params, false); + + // Allocate the x coordinate structure and convert row/col to image space. + // + psVector *x = psVectorAlloc(2, PS_TYPE_F32); + x->data.F32[0] = (psF32) (col + image->col0); + x->data.F32[1] = (psF32) (row + image->row0); + psF32 tmpF; + pmModelFunc modelFunc; + + modelFunc = pmModelFunc_GetFunction (model->type); + tmpF = modelFunc (NULL, model->params, x); + psFree(x); + psTrace(__func__, 3, "---- %s() end ----\n", __func__); + return(tmpF); +} + +/****************************************************************************** + pmSourceContour(src, img, level, mode): For an input subImage, and model, this + routine returns a psArray of coordinates that evaluate to the specified level. + + XXX: Probably should remove the "image" argument. + XXX: What type should the output coordinate vectors consist of? col,row? + XXX: Why a pmArray output? + XXX: doex x,y correspond with col,row or row/col? + XXX: What is mode? + XXX: The top, bottom of the contour is not correctly determined. + XXX EAM : this function is using the model for the contour, but it should + be using only the image counts +*****************************************************************************/ +psArray *pmSourceContour(pmSource *source, + const psImage *image, + psF32 level, + pmContourType mode) +{ + psTrace(__func__, 3, "---- %s() begin ----\n", __func__); + PS_ASSERT_PTR_NON_NULL(source, false); + PS_ASSERT_PTR_NON_NULL(image, false); + PS_ASSERT_PTR_NON_NULL(source->moments, false); + PS_ASSERT_PTR_NON_NULL(source->peak, false); + PS_ASSERT_PTR_NON_NULL(source->pixels, false); + PS_ASSERT_PTR_NON_NULL(source->modelEXT, false); + // XXX EAM : what is the purpose of modelPSF/modelEXT? + + // + // Allocate data for x/y pairs. + // + psVector *xVec = psVectorAlloc(2 * source->pixels->numRows, PS_TYPE_F32); + psVector *yVec = psVectorAlloc(2 * source->pixels->numRows, PS_TYPE_F32); + + // + // Start at the row with peak pixel, then decrement. + // + psS32 col = source->peak->x; + for (psS32 row = source->peak->y; row>= 0 ; row--) { + // XXX: yVec contain no real information. Do we really need it? + yVec->data.F32[row] = (psF32) (source->pixels->row0 + row); + yVec->data.F32[row+yVec->n] = (psF32) (source->pixels->row0 + row); + + // Starting at peak pixel, search leftwards for the column intercept. + psF32 leftIntercept = findValue(source, level, row, col, 0); + if (isnan(leftIntercept)) { + psError(PS_ERR_UNKNOWN, true, "Could not find contour edge (NAN)"); + psFree(xVec); + psFree(yVec); + psTrace(__func__, 3, "---- %s(NULL) end ----\n", __func__); + return(NULL); + //psLogMsg(__func__, PS_LOG_WARN, "WARNING: Could not find contour edge (NAN)\n"); + } + xVec->data.F32[row] = ((psF32) source->pixels->col0) + leftIntercept; + + // Starting at peak pixel, search rightwards for the column intercept. + + psF32 rightIntercept = findValue(source, level, row, col, 1); + if (isnan(rightIntercept)) { + psError(PS_ERR_UNKNOWN, true, "Could not find contour edge (NAN)"); + psFree(xVec); + psFree(yVec); + psTrace(__func__, 3, "---- %s(NULL) end ----\n", __func__); + return(NULL); + //psLogMsg(__func__, PS_LOG_WARN, "WARNING: Could not find contour edge (NAN)\n"); + } + psTrace(__func__, 4, "The intercepts are (%.2f, %.2f)\n", leftIntercept, rightIntercept); + xVec->data.F32[row+xVec->n] = ((psF32) source->pixels->col0) + rightIntercept; + + // Set starting column for next row + col = (psS32) ((leftIntercept + rightIntercept) / 2.0); + } + // + // Start at the row (+1) with peak pixel, then increment. + // + col = source->peak->x; + for (psS32 row = 1 + source->peak->y; row < source->pixels->numRows ; row++) { + // XXX: yVec contain no real information. Do we really need it? + yVec->data.F32[row] = (psF32) (source->pixels->row0 + row); + yVec->data.F32[row+yVec->n] = (psF32) (source->pixels->row0 + row); + + // Starting at peak pixel, search leftwards for the column intercept. + psF32 leftIntercept = findValue(source, level, row, col, 0); + if (isnan(leftIntercept)) { + psError(PS_ERR_UNKNOWN, true, "Could not find contour edge (NAN)"); + psFree(xVec); + psFree(yVec); + psTrace(__func__, 3, "---- %s(NULL) end ----\n", __func__); + return(NULL); + //psLogMsg(__func__, PS_LOG_WARN, "WARNING: Could not find contour edge (NAN)\n"); + } + xVec->data.F32[row] = ((psF32) source->pixels->col0) + leftIntercept; + + // Starting at peak pixel, search rightwards for the column intercept. + psF32 rightIntercept = findValue(source, level, row, col, 1); + if (isnan(rightIntercept)) { + psError(PS_ERR_UNKNOWN, true, "Could not find contour edge (NAN)"); + psFree(xVec); + psFree(yVec); + psTrace(__func__, 3, "---- %s(NULL) end ----\n", __func__); + return(NULL); + //psLogMsg(__func__, PS_LOG_WARN, "WARNING: Could not find contour edge (NAN)\n"); + } + xVec->data.F32[row+xVec->n] = ((psF32) source->pixels->col0) + rightIntercept; + + // Set starting column for next row + col = (psS32) ((leftIntercept + rightIntercept) / 2.0); + } + + // + // Allocate an array for result, store coord vectors there. + // + psArray *tmpArray = psArrayAlloc(2); + tmpArray->data[0] = (psPtr *) yVec; + tmpArray->data[1] = (psPtr *) xVec; + psTrace(__func__, 3, "---- %s() end ----\n", __func__); + return(tmpArray); +} + +// save a static values so they may be set externally +static psF32 PM_SOURCE_FIT_MODEL_NUM_ITERATIONS = 15; +static psF32 PM_SOURCE_FIT_MODEL_TOLERANCE = 0.1; + +bool pmSourceFitModelInit (float nIter, float tol) +{ + + PM_SOURCE_FIT_MODEL_NUM_ITERATIONS = nIter; + PM_SOURCE_FIT_MODEL_TOLERANCE = tol; + return true; +} + +bool pmSourceFitModel (pmSource *source, + pmModel *model, + const bool PSF) +{ + psTrace(__func__, 3, "---- %s() begin ----\n", __func__); + PS_ASSERT_PTR_NON_NULL(source, false); + PS_ASSERT_PTR_NON_NULL(source->moments, false); + PS_ASSERT_PTR_NON_NULL(source->peak, false); + PS_ASSERT_PTR_NON_NULL(source->pixels, false); + PS_ASSERT_PTR_NON_NULL(source->mask, false); + PS_ASSERT_PTR_NON_NULL(source->weight, false); + + // XXX EAM : is it necessary for the mask & weight to exist? the + // tests below could be conditions (!NULL) + + psBool fitStatus = true; + psBool onPic = true; + psBool rc = true; + + psVector *params = model->params; + psVector *dparams = model->dparams; + psVector *paramMask = NULL; + + pmModelFunc modelFunc = pmModelFunc_GetFunction (model->type); + + int nParams = PSF ? 4 : params->n; + + // maximum number of valid pixels + psS32 nPix = source->pixels->numRows * source->pixels->numCols; + + // construct the coordinate and value entries + psArray *x = psArrayAlloc(nPix); + psVector *y = psVectorAlloc(nPix, PS_TYPE_F32); + psVector *yErr = psVectorAlloc(nPix, PS_TYPE_F32); + + nPix = 0; + for (psS32 i = 0; i < source->pixels->numRows; i++) { + for (psS32 j = 0; j < source->pixels->numCols; j++) { + // skip masked points + if (source->mask->data.U8[i][j]) { + continue; + } + // skip zero-weight points + if (source->weight->data.F32[i][j] == 0) { + continue; + } + + psVector *coord = psVectorAlloc(2, PS_TYPE_F32); + + // Convert i/j to image space: + coord->data.F32[0] = (psF32) (j + source->pixels->col0); + coord->data.F32[1] = (psF32) (i + source->pixels->row0); + x->data[nPix] = (psPtr *) coord; + y->data.F32[nPix] = source->pixels->data.F32[i][j]; + // psMinimizeLMChi2 takes wt = 1/dY^2 + yErr->data.F32[nPix] = 1.0 / source->weight->data.F32[i][j]; + nPix++; + } + } + if (nPix < nParams + 1) { + psTrace (".pmObjects.pmSourceFitModel", 4, "insufficient valid pixels\n"); + psTrace(__func__, 3, "---- %s(false) end ----\n", __func__); + model->status = PM_MODEL_BADARGS; + psFree (x); + psFree (y); + psFree (yErr); + return(false); + } + x->n = nPix; + y->n = nPix; + yErr->n = nPix; + + // XXX EAM : the new minimization API supplies the constraints as a struct + psMinimization *myMin = psMinimizationAlloc(PM_SOURCE_FIT_MODEL_NUM_ITERATIONS, + PM_SOURCE_FIT_MODEL_TOLERANCE); + psMinConstrain *constrain = psMinConstrainAlloc(); + + // PSF model only fits first 4 parameters, EXT model fits all + if (PSF) { + paramMask = psVectorAlloc (params->n, PS_TYPE_U8); + for (int i = 0; i < 4; i++) { + paramMask->data.U8[i] = 0; + } + for (int i = 4; i < paramMask->n; i++) { + paramMask->data.U8[i] = 1; + } + } + constrain->paramMask = paramMask; + + // Set the parameter range checks + pmModelLimits modelLimits = pmModelLimits_GetFunction (model->type); + modelLimits (&constrain->paramDelta, &constrain->paramMin, &constrain->paramMax); + + psImage *covar = psImageAlloc (params->n, params->n, PS_TYPE_F64); + + psTrace (".pmObjects.pmSourceFitModel", 5, "fitting function\n"); + + fitStatus = psMinimizeLMChi2(myMin, covar, params, constrain, x, y, yErr, modelFunc); + for (int i = 0; i < dparams->n; i++) { + if ((paramMask != NULL) && paramMask->data.U8[i]) + continue; + dparams->data.F32[i] = sqrt(covar->data.F64[i][i]); + } + + // save the resulting chisq, nDOF, nIter + model->chisq = myMin->value; + model->nIter = myMin->iter; + model->nDOF = y->n - nParams; + + // get the Gauss-Newton distance for fixed model parameters + if (paramMask != NULL) { + psVector *delta = psVectorAlloc (params->n, PS_TYPE_F64); + psMinimizeGaussNewtonDelta(delta, params, NULL, x, y, yErr, modelFunc); + for (int i = 0; i < dparams->n; i++) { + if (!paramMask->data.U8[i]) + continue; + dparams->data.F32[i] = delta->data.F64[i]; + } + psFree (delta); + } + + // set the model success or failure status + if (!fitStatus) { + model->status = PM_MODEL_NONCONVERGE; + } else { + model->status = PM_MODEL_SUCCESS; + } + + // models can go insane: reject these + onPic &= (params->data.F32[2] >= source->pixels->col0); + onPic &= (params->data.F32[2] < source->pixels->col0 + source->pixels->numCols); + onPic &= (params->data.F32[3] >= source->pixels->row0); + onPic &= (params->data.F32[3] < source->pixels->row0 + source->pixels->numRows); + if (!onPic) { + model->status = PM_MODEL_OFFIMAGE; + } + + source->mode |= PM_SOURCE_FITTED; + + psFree(x); + psFree(y); + psFree(yErr); + psFree(myMin); + psFree(covar); + psFree(constrain->paramMask); + psFree(constrain->paramMin); + psFree(constrain->paramMax); + psFree(constrain->paramDelta); + psFree(constrain); + + rc = (onPic && fitStatus); + psTrace(__func__, 3, "---- %s(%d) end ----\n", __func__, rc); + return(rc); +} + +bool p_pmSourceAddOrSubModel(psImage *image, + psImage *mask, + pmModel *model, + bool center, + bool sky, + bool add + ) +{ + psTrace(__func__, 3, "---- %s() begin ----\n", __func__); + + PS_ASSERT_PTR_NON_NULL(model, false); + PS_ASSERT_IMAGE_NON_NULL(image, false); + PS_ASSERT_IMAGE_TYPE(image, PS_TYPE_F32, false); + + psVector *x = psVectorAlloc(2, PS_TYPE_F32); + psVector *params = model->params; + pmModelFunc modelFunc = pmModelFunc_GetFunction (model->type); + psS32 imageCol; + psS32 imageRow; + psF32 skyValue = params->data.F32[0]; + psF32 pixelValue; + + for (psS32 i = 0; i < image->numRows; i++) { + for (psS32 j = 0; j < image->numCols; j++) { + if ((mask != NULL) && mask->data.U8[i][j]) + continue; + + // XXX: Should you be adding the pixels for the entire subImage, + // or a radius of pixels around it? + + // Convert i/j to imace coord space: + // XXX: Make sure you have col/row order correct. + // XXX EAM : 'center' option changes this + // XXX EAM : i == numCols/2 -> x = model->params->data.F32[2] + if (center) { + imageCol = j - 0.5*image->numCols + model->params->data.F32[2]; + imageRow = i - 0.5*image->numRows + model->params->data.F32[3]; + } else { + imageCol = j + image->col0; + imageRow = i + image->row0; + } + + x->data.F32[0] = (float) imageCol; + x->data.F32[1] = (float) imageRow; + + // set the appropriate pixel value for this coordinate + if (sky) { + pixelValue = modelFunc (NULL, params, x); + } else { + pixelValue = modelFunc (NULL, params, x) - skyValue; + } + + + // add or subtract the value + if (add + ) { + image->data.F32[i][j] += pixelValue; + } + else { + image->data.F32[i][j] -= pixelValue; + } + } + } + psFree(x); + psTrace(__func__, 3, "---- %s(true) end ----\n", __func__); + return(true); +} + + + +/****************************************************************************** + *****************************************************************************/ +bool pmSourceAddModel(psImage *image, + psImage *mask, + pmModel *model, + bool center, + bool sky) +{ + psTrace(__func__, 3, "---- %s() begin ----\n", __func__); + psBool rc = p_pmSourceAddOrSubModel(image, mask, model, center, sky, true); + psTrace(__func__, 3, "---- %s(%d) end ----\n", __func__, rc); + return(rc); +} + +/****************************************************************************** + *****************************************************************************/ +bool pmSourceSubModel(psImage *image, + psImage *mask, + pmModel *model, + bool center, + bool sky) +{ + psTrace(__func__, 3, "---- %s() begin ----\n", __func__); + psBool rc = p_pmSourceAddOrSubModel(image, mask, model, center, sky, false); + psTrace(__func__, 3, "---- %s(%d) end ----\n", __func__, rc); + return(rc); +} + +bool pmSourcePhotometry (float *fitMag, float *obsMag, pmModel *model, psImage *image, psImage *mask) +{ + + float obsSum = 0; + float fitSum = 0; + float sky = model->params->data.F32[0]; + + pmModelFlux modelFluxFunc = pmModelFlux_GetFunction (model->type); + fitSum = modelFluxFunc (model->params); + + for (int ix = 0; ix < image->numCols; ix++) { + for (int iy = 0; iy < image->numRows; iy++) { + if (mask->data.U8[iy][ix]) + continue; + obsSum += image->data.F32[iy][ix] - sky; + } + } + if (obsSum <= 0) + return false; + if (fitSum <= 0) + return false; + + *fitMag = -2.5*log10(fitSum); + *obsMag = -2.5*log10(obsSum); + return (true); +} + Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/objects/pmObjects.h =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/objects/pmObjects.h (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/objects/pmObjects.h (revision 21664) @@ -0,0 +1,677 @@ +/** @file pmObjects.h + * + * The process of finding, measuring, and classifying astronomical sources on + * images is one of the critical tasks of the IPP or any astronomical software + * system. This file will define structures and functions related to the task + * of source detection and measurement. The elements defined in this section + * are generally low-level components which can be connected together to + * construct a complete object measurement suite. + * + * @author GLG, MHPCC + * + * @version $Revision: 1.4.4.8 $ $Name: not supported by cvs2svn $ + * @date $Date: 2006-02-17 02:48:23 $ + * + * Copyright 2004 Maui High Performance Computing Center, University of Hawaii + * + */ + +#if !defined(PM_OBJECTS_H) +#define PM_OBJECTS_H + +#if HAVE_CONFIG_H +#include +#endif + +#include +#include +#include "pslib.h" +#include "pmFPA.h" +/** + * In the object analysis process, we will use specific mask values to mark the + * image pixels. The following structure defines the relevant mask values. + * + * XXX: This is probably a bad solution: we will want to set mask values + * outside of the PSPHOT code. Perhaps we can set up a registered set of mask + * values with specific meanings that other functions can add to or define? + */ +typedef enum { + PSPHOT_MASK_CLEAR = 0x00, + PSPHOT_MASK_INVALID = 0x01, + PSPHOT_MASK_SATURATED = 0x02, + PSPHOT_MASK_MARKED = 0x08, +} psphotMaskValues; + + +/** pmPeakType + * + * A peak pixel may have several features which may be determined when the + * peak is found or measured. These are specified by the pmPeakType enum. + * PM_PEAK_LONE represents a single pixel which is higher than its 8 immediate + * neighbors. The PM_PEAK_EDGE represents a peak pixel which touching the image + * edge. The PM_PEAK_FLAT represents a peak pixel which has more than a specific + * number of neighbors at the same value, within some tolarence: + * + */ +typedef enum { + PM_PEAK_LONE, ///< Isolated peak. + PM_PEAK_EDGE, ///< Peak on edge. + PM_PEAK_FLAT, ///< Peak has equal-value neighbors. + PM_PEAK_UNDEF ///< Undefined. +} pmPeakType; + + +/** pmPeak data structure + * + * A source has the capacity for several types of measurements. The + * simplest measurement of a source is the location and flux of the peak pixel + * associated with the source: + * + */ +typedef struct +{ + int x; ///< X-coordinate of peak pixel. + int y; ///< Y-coordinate of peak pixel. + float counts; ///< Value of peak pixel (above sky?). + pmPeakType type; ///< Description of peak. +} +pmPeak; + + +/** pmMoments data structure + * + * One of the simplest measurements which can be made quickly for an object + * are the object moments. We specify a structure to carry the moment information + * for a specific source: + * + */ +typedef struct +{ + float x; ///< X-coord of centroid. + float y; ///< Y-coord of centroid. + float Sx; ///< x-second moment. + float Sy; ///< y-second moment. + float Sxy; ///< xy cross moment. + float Sum; ///< Pixel sum above sky (background). + float Peak; ///< Peak counts above sky. + float Sky; ///< Sky level (background). + float dSky; ///< local Sky variance + float SN; ///< approx signal-to-noise + int nPixels; ///< Number of pixels used. +} +pmMoments; + + +/** pmPSFClump data structure + * + * A collection of object moment measurements can be used to determine + * approximate object classes. The key to this analysis is the location and + * statistics (in the second-moment plane, + * + */ +typedef struct +{ + float X; + float dX; + float Y; + float dY; +} +pmPSFClump; + +// type of model carried by the pmModel structure +typedef int pmModelType; + +typedef enum { + PM_MODEL_UNTRIED, ///< model fit not yet attempted + PM_MODEL_SUCCESS, ///< model fit succeeded + PM_MODEL_NONCONVERGE, ///< model fit did not converge + PM_MODEL_OFFIMAGE, ///< model fit drove out of range + PM_MODEL_BADARGS ///< model fit called with invalid args +} pmModelStatus; + +/** pmModel data structure + * + * Every source may have two types of models: a PSF model and a EXT (extended-source) + * model. The PSF model represents the best fit of the image PSF to the specific + * object. In this case, the PSF-dependent parameters are specified for the + * object by the PSF, not by the fit. The EXT model represents the best fit of + * the given model to the object, with all shape parameters floating in the fit. + * + */ +typedef struct +{ + pmModelType type; ///< Model to be used. + psVector *params; ///< Paramater values. + psVector *dparams; ///< Parameter errors. + float chisq; ///< Fit chi-squared. + int nDOF; ///< number of degrees of freedom + int nIter; ///< number of iterations to reach min + pmModelStatus status; ///< fit status + float radius; ///< fit radius actually used +} +pmModel; + +/** pmSourceType enumeration + * + * A given source may be identified as most-likely to be one of several source + * types. The pmSource entry pmSourceType defines the current best-guess for this + * source. + * + * XXX: The values given below are currently illustrative and will require + * some modification as the source classification code is developed. (TBD) + * + */ +typedef enum { + PM_SOURCE_UNKNOWN, ///< a cosmic-ray + PM_SOURCE_DEFECT, ///< a cosmic-ray + PM_SOURCE_SATURATED, ///< random saturated pixels + PM_SOURCE_STAR, ///< a good-quality star + PM_SOURCE_EXTENDED, ///< an extended object (eg, galaxy) +} pmSourceType; + +typedef enum { + PM_SOURCE_DEFAULT = 0x0000, ///< + PM_SOURCE_PSFMODEL = 0x0001, ///< + PM_SOURCE_EXTMODEL = 0x0002, ///< + PM_SOURCE_SUBTRACTED = 0x0004, ///< + PM_SOURCE_FITTED = 0x0008, ///< + PM_SOURCE_FAIL = 0x0010, ///< + PM_SOURCE_POOR = 0x0020, ///< + PM_SOURCE_PAIR = 0x0040, ///< + PM_SOURCE_PSFSTAR = 0x0080, ///< + PM_SOURCE_SATSTAR = 0x0100, ///< + PM_SOURCE_BLEND = 0x0200, ///< + PM_SOURCE_LINEAR = 0x0400, ///< + PM_SOURCE_TEMPSUB = 0x0800, ///< XXX get me a better name! +} pmSourceMode; + +/** pmSource data structure + * + * This source has the capacity for several types of measurements. The + * simplest measurement of a source is the location and flux of the peak pixel + * associated with the source: + * + */ +typedef struct +{ + pmPeak *peak; ///< Description of peak pixel. + psImage *pixels; ///< Rectangular region including object pixels. + psImage *weight; ///< Image variance. + psImage *mask; ///< Mask which marks pixels associated with objects. + pmMoments *moments; ///< Basic moments measure for the object. + pmModel *modelPSF; ///< PSF Model fit (parameters and type) + pmModel *modelEXT; ///< EXT (floating) Model fit (parameters and type). + pmSourceType type; ///< Best identification of object. + pmSourceMode mode; ///< Best identification of object. + psArray *blends; + float apMag; + float fitMag; + psRegion region; // area on image covered by selected pixels +} +pmSource; + + +/** pmPeakAlloc() + * + * @return pmPeak* newly allocated pmPeak with all internal pointers set to NULL + */ +pmPeak *pmPeakAlloc( + int x, ///< Row-coordinate in image space + int y, ///< Col-coordinate in image space + float counts, ///< The value of the peak pixel + pmPeakType type ///< The type of peak pixel +); + + +/** pmMomentsAlloc() + * + */ +pmMoments *pmMomentsAlloc(); + + +/** pmModelAlloc() + * + */ +pmModel *pmModelAlloc(pmModelType type); + + +/** pmSourceAlloc() + * + */ +pmSource *pmSourceAlloc(); + + +/** pmFindVectorPeaks() + * + * Find all local peaks in the given vector above the given threshold. A peak + * is defined as any element with a value greater than its two neighbors and with + * a value above the threshold. Two types of special cases must be addressed. + * Equal value elements: If an element has the same value as the following + * element, it is not considered a peak. If an element has the same value as the + * preceding element (but not the following), then it is considered a peak. Note + * that this rule (arbitrarily) identifies flat regions by their trailing edge. + * Edge cases: At start of the vector, the element must be higher than its + * neighbor. At the end of the vector, the element must be higher or equal to its + * neighbor. These two rules again places the peak associated with a flat region + * which touches the image edge at the image edge. The result of this function is + * a vector containing the coordinates (element number) of the detected peaks + * (type psU32). + * + */ +psVector *pmFindVectorPeaks( + const psVector *vector, ///< The input vector (float) + float threshold ///< Threshold above which to find a peak +); + + +/** pmFindImagePeaks() + * + * Find all local peaks in the given image above the given threshold. This + * function should find all row peaks using pmFindVectorPeaks, then test each row + * peak and exclude peaks which are not local peaks. A peak is a local peak if it + * has a higher value than all 8 neighbors. If the peak has the same value as its + * +y neighbor or +x neighbor, it is NOT a local peak. If any other neighbors + * have an equal value, the peak is considered a valid peak. Note two points: + * first, the +x neighbor condition is already enforced by pmFindVectorPeaks. + * Second, these rules have the effect of making flat-topped regions have single + * peaks at the (+x,+y) corner. When selecting the peaks, their type must also be + * set. The result of this function is an array of pmPeak entries. + * + */ +psArray *pmFindImagePeaks( + const psImage *image, ///< The input image where peaks will be found (float) + float threshold ///< Threshold above which to find a peak +); + + +/** pmCullPeaks() + * + * Eliminate peaks from the psList that have a peak value above the given + * maximum, or fall outside the valid region. + * + */ +psList *pmCullPeaks( + psList *peaks, ///< The psList of peaks to be culled + float maxValue, ///< Cull peaks above this value + const psRegion valid ///< Cull peaks otside this psRegion +); + + +/** pmPeaksSubset() + * + * Create a new peaks array, removing certain types of peaks from the input + * array of peaks based on the given criteria. Peaks should be eliminated if they + * have a peak value above the given maximum value limit or if the fall outside + * the valid region. The result of the function is a new array with a reduced + * number of peaks. + * + */ +psArray *pmPeaksSubset( + psArray *peaks, ///< Add comment. + float maxvalue, ///< Add comment. + const psRegion valid ///< Add comment. +); + + +/** pmSourceDefinePixels() + * + * Define psImage subarrays for the source located at coordinates x,y on the + * image set defined by readout. The pixels defined by this operation consist of + * a square window (of full width 2Radius+1) centered on the pixel which contains + * the given coordinate, in the frame of the readout. The window is defined to + * have limits which are valid within the boundary of the readout image, thus if + * the radius would fall outside the image pixels, the subimage is truncated to + * only consist of valid pixels. If readout->mask or readout->weight are not + * NULL, matching subimages are defined for those images as well. This function + * fails if no valid pixels can be defined (x or y less than Radius, for + * example). This function should be used to define a region of interest around a + * source, including both source and sky pixels. + * + * XXX: must code this. + * + */ +// XXX: Uncommenting the pmReadout causes compile errors. +bool pmSourceDefinePixels( + pmSource *mySource, ///< Add comment. + pmReadout *readout, ///< Add comment. + psF32 x, ///< Add comment. + psF32 y, ///< Add comment. + psF32 Radius ///< Add comment. +); + + +/** pmSourceLocalSky() + * + * Measure the local sky in the vicinity of the given source. The Radius + * defines the square aperture in which the moments will be measured. This + * function assumes the source pixels have been defined, and that the value of + * Radius here is smaller than the value of Radius used to define the pixels. The + * annular region not contained within the radius defined here is used to measure + * the local background in the vicinity of the source. The local background + * measurement uses the specified statistic passed in via the statsOptions entry. + * This function allocates the pmMoments structure. The resulting sky is used to + * set the value of the pmMoments.sky element of the provided pmSource structure. + * + */ +bool pmSourceLocalSky( + pmSource *source, ///< The input image (float) + psStatsOptions statsOptions, ///< The statistic used in calculating the background sky + float Radius ///< The inner radius of the square annulus to exclude +); + + +// A complementary function to pmSourceLocalSky: calculate the local sky variance +bool pmSourceLocalSkyVariance( + pmSource *source, ///< The input image (float) + psStatsOptions statsOptions, ///< The statistic used in calculating the background sky + float Radius ///< The inner radius of the square annulus to exclude +); + +/** pmSourceMoments() + * + * Measure source moments for the given source, using the value of + * source.moments.sky provided as the local background value and the peak + * coordinates as the initial source location. The resulting moment values are + * applied to the source.moments entry, and the source is returned. The moments + * are measured within the given circular radius of the source.peak coordinates. + * The return value indicates the success (TRUE) of the operation. + * + */ +bool pmSourceMoments( + pmSource *source, ///< The input pmSource for which moments will be computed + float radius ///< Use a circle of pixels around the peak +); + + +/** pmSourcePSFClump() + * + * We use the source moments to make an initial, approximate source + * classification, and as part of the information needed to build a PSF model for + * the image. As long as the PSF shape does not vary excessively across the + * image, the sources which are represented by a PSF (the start) will have very + * similar second moments. The function pmSourcePSFClump searches a collection of + * sources with measured moments for a group with moments which are all very + * similar. The function returns a pmPSFClump structure, representing the + * centroid and size of the clump in the sigma_x, sigma_y second-moment plane. + * + * The goal is to identify and characterize the stellar clump within the + * sigma_x, sigma_y second-moment plane. To do this, an image is constructed to + * represent this plane. The units of sigma_x and sigma_y are in image pixels. A + * pixel in this analysis image represents 0.1 pixels in the input image. The + * dimensions of the image need only be 10 pixels. The peak pixel in this image + * (above a threshold of half of the image maximum) is found. The coordinates of + * this peak pixel represent the 2D mode of the sigma_x, sigma_y distribution. + * The sources with sigma_x, sigma_y within 0.2 pixels of this value are then + * * used to calculate the median and standard deviation of the sigma_x, sigma_y + * values. These resulting values are returned via the pmPSFClump structure. + * + * The return value indicates the success (TRUE) of the operation. + * + * XXX: Limit the S/N of the candidate sources (part of Metadata)? (TBD). + * XXX: Save the clump parameters on the Metadata (TBD) + * + */ +pmPSFClump pmSourcePSFClump( + psArray *source, ///< The input pmSource + psMetadata *metadata ///< Contains classification parameters +); + + +/** pmSourceRoughClass() + * + * Based on the specified data values, make a guess at the source + * classification. The sources are provides as a psArray of pmSource entries. + * Definable parameters needed to make the classification are provided to the + * routine with the psMetadata structure. The rules (in SDRS) refer to values which + * can be extracted from the metadata using the given keywords. Except as noted, + * the data type for these parameters are psF32. + * + */ +bool pmSourceRoughClass( + psArray *source, ///< The input pmSource + psMetadata *metadata, ///< Contains classification parameters + pmPSFClump clump ///< Statistics about the PSF clump +); + + +/** pmSourceModelGuess() + * + * Convert available data to an initial guess for the given model. This + * function allocates a pmModel entry for the pmSource structure based on the + * provided model selection. The method of defining the model parameter guesses + * are specified for each model below. The guess values are placed in the model + * parameters. The function returns TRUE on success or FALSE on failure. + * + */ +pmModel *pmSourceModelGuess( + pmSource *source, ///< The input pmSource + pmModelType model ///< The type of model to be created. +); + + +/** pmContourType + * + * Only one type is defined at present. + * + */ +typedef enum { + PS_CONTOUR_CRUDE, + PS_CONTOUR_UNKNOWN01, + PS_CONTOUR_UNKNOWN02 +} pmContourType; + + +/** pmSourceContour() + * + * Find points in a contour for the given source at the given level. If type + * is PM_CONTOUR_CRUDE, the contour is found by starting at the source peak, + * running along each pixel row until the level is crossed, then interpolating to + * the level coordinate for that row. This is done for each row, with the + * starting point determined by the midpoint of the previous row, until the + * starting point has a value below the contour level. The returned contour + * consists of two vectors giving the x and y coordinates of the contour levels. + * This function may be used as part of the model guess inputs. Other contour + * types may be specified in the future for more refined contours (TBD) + * + */ +psArray *pmSourceContour( + pmSource *source, ///< The input pmSource + const psImage *image, ///< The input image (float) (this arg should be removed) + float level, ///< The level of the contour + pmContourType mode ///< Currently this must be PS_CONTOUR_CRUDE +); + + +bool pmSourceFitModelInit( + float nIter, ///< max number of allowed iterations + float tol ///< convergence criterion +); + +/** pmSourceFitModel() + * + * Fit the requested model to the specified source. The starting guess for the + * model is given by the input source.model parameter values. The pixels of + * interest are specified by the source.pixelsand source.maskentries. This + * function calls psMinimizeLMChi2() on the image data. The function returns TRUE + * on success or FALSE on failure. + * + */ +bool pmSourceFitModel( + pmSource *source, ///< The input pmSource + pmModel *model, ///< model to be fitted + const bool PSF ///< Treat model as PSF or EXT? +); + + +/** pmModelFitStatus() + * + * This function wraps the call to the model-specific function returned by + * pmModelFitStatusFunc_GetFunction. The model-specific function examines the + * model parameters, parameter errors, Chisq, S/N, and other parameters available + * from model to decide if the particular fit was successful or not. + * + * XXX: Must code this. + * + */ +bool pmModelFitStatus( + pmModel *model ///< Add comment. +); + + +/** pmSourceAddModel() + * + * Add the given source model flux to/from the provided image. The boolean + * option center selects if the source is re-centered to the image center or if + * it is placed at its centroid location. The boolean option sky selects if the + * background sky is applied (TRUE) or not. The pixel range in the target image + * is at most the pixel range specified by the source.pixels image. The success + * status is returned. + * + */ +bool pmSourceAddModel( + psImage *image, ///< The output image (float) + psImage *mask, ///< The image pixel mask (valid == 0) + pmModel *model, ///< The input pmModel + bool center, ///< A boolean flag that determines whether pixels are centered + bool sky ///< A boolean flag that determines if the sky is subtracted +); + + +/** pmSourceSubModel() + * + * Subtract the given source model flux to/from the provided image. The + * boolean option center selects if the source is re-centered to the image center + * or if it is placed at its centroid location. The boolean option sky selects if + * the background sky is applied (TRUE) or not. The pixel range in the target + * image is at most the pixel range specified by the source.pixels image. The + * success status is returned. + * + */ +bool pmSourceSubModel( + psImage *image, ///< The output image (float) + psImage *mask, ///< The image pixel mask (valid == 0) + pmModel *model, ///< The input pmModel + bool center, ///< A boolean flag that determines whether pixels are centered + bool sky ///< A boolean flag that determines if the sky is subtracted +); + + +/** + * + * The function returns both the magnitude of the fit, defined as -2.5log(flux), + * where the flux is integrated under the model, theoretically from a radius of 0 + * to infinity. In practice, we integrate the model beyond 50sigma. The aperture magnitude is + * defined as -2.5log(flux) , where the flux is summed for all pixels which are + * not excluded by the aperture mask. The model flux is calculated by calling the + * model-specific function provided by pmModelFlux_GetFunction. + * + * XXX: must code this. + * + */ +bool pmSourcePhotometry( + float *fitMag, ///< integrated fit magnitude + float *obsMag, ///< aperture flux magnitude + pmModel *model, ///< model used for photometry + psImage *image, ///< image pixels to be used + psImage *mask ///< mask of pixels to ignore +); + + +/** + * + * This function converts the source classification into the closest available + * approximation to the Dophot classification scheme: + * XXX EAM : fix this to use current source classification scheme + * + * PM_SOURCE_DEFECT: 8 + * PM_SOURCE_SATURATED: 8 + * PM_SOURCE_SATSTAR: 10 + * PM_SOURCE_PSFSTAR: 1 + * PM_SOURCE_GOODSTAR: 1 + * PM_SOURCE_POOR_FIT_PSF: 7 + * PM_SOURCE_FAIL_FIT_PSF: 4 + * PM_SOURCE_FAINTSTAR: 4 + * PM_SOURCE_GALAXY: 2 + * PM_SOURCE_FAINT_GALAXY: 2 + * PM_SOURCE_DROP_GALAXY: 2 + * PM_SOURCE_FAIL_FIT_GAL: 2 + * PM_SOURCE_POOR_FIT_GAL: 2 + * PM_SOURCE_OTHER: ? + * + */ +int pmSourceDophotType( + pmSource *source ///< Add comment. +); + + +/** pmSourceSextractType() + * + * This function converts the source classification into the closest available + * approximation to the Sextractor classification scheme. the correspondence is + * not yet defined (TBD) . + * + * XXX: Must code this. + * + */ +int pmSourceSextractType( + pmSource *source ///< Add comment. +); + +/** pmSourceFitModel_v5() + * + * Fit the requested model to the specified source. The starting guess for the + * model is given by the input source.model parameter values. The pixels of + * interest are specified by the source.pixelsand source.maskentries. This + * function calls psMinimizeLMChi2() on the image data. The function returns TRUE + * on success or FALSE on failure. + * + */ +bool pmSourceFitModel_v5( + pmSource *source, ///< The input pmSource + pmModel *model, ///< model to be fitted + const bool PSF ///< Treat model as PSF or EXT? +); + + +/** pmSourceFitModel_v7() + * + * Fit the requested model to the specified source. The starting guess for the + * model is given by the input source.model parameter values. The pixels of + * interest are specified by the source.pixelsand source.maskentries. This + * function calls psMinimizeLMChi2() on the image data. The function returns TRUE + * on success or FALSE on failure. + * + */ +bool pmSourceFitModel_v7( + pmSource *source, ///< The input pmSource + pmModel *model, ///< model to be fitted + const bool PSF ///< Treat model as PSF or EXT? +); + + +/** pmSourcePhotometry() + * + * XXX: Need descriptions + * + */ +bool pmSourcePhotometry( + float *fitMag, + float *obsMag, + pmModel *model, + psImage *image, + psImage *mask +); + +/** pmModelEval() + * + * XXX: Need descriptions + * + */ +psF32 pmModelEval( + pmModel *model, + psImage *image, + psS32 col, + psS32 row +); + +#endif Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/objects/pmPSF.c =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/objects/pmPSF.c (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/objects/pmPSF.c (revision 21664) @@ -0,0 +1,365 @@ +/** @file pmPSF.c + * + * This file contains typedefs for the Point-Spread Function and prototypes + * for functions that calculate the PSF. + * + * @author EAM, IfA + * + * @version $Revision: 1.3.4.5 $ $Name: not supported by cvs2svn $ + * @date $Date: 2006-02-17 02:48:57 $ + * + * Copyright 2004 Maui High Performance Computing Center, University of Hawaii + * + */ + +/*****************************************************************************/ +/* INCLUDE FILES */ +/*****************************************************************************/ + +#include +#include "pmObjects.h" +#include "pmPSF.h" +#include "pmModelGroup.h" + +/*****************************************************************************/ +/* DEFINE STATEMENTS */ +/*****************************************************************************/ + +/*****************************************************************************/ +/* TYPE DEFINITIONS */ +/*****************************************************************************/ + +/*****************************************************************************/ +/* GLOBAL VARIABLES */ +/*****************************************************************************/ + +/*****************************************************************************/ +/* FILE STATIC VARIABLES */ +/*****************************************************************************/ + +/*****************************************************************************/ +/* FUNCTION IMPLEMENTATION - LOCAL */ +/*****************************************************************************/ + +/*****************************************************************************/ +/* FUNCTION IMPLEMENTATION - PUBLIC */ +/*****************************************************************************/ + + + +/***************************************************************************** +pmPSFFree(psf): function to free a pmPSF structure + *****************************************************************************/ +static void pmPSFFree (pmPSF *psf) +{ + + if (psf == NULL) + return; + + psFree (psf->ApTrend); + psFree (psf->growth); + psFree (psf->params); + return; +} + + + +/***************************************************************************** +pmPSFAlloc (type): allocate a pmPSF. + NOTE: a PSF always has 4 parameters fewer than the equivalent model. + This is because those 4 parameters are + X-center + Y-center + Sky background value + Object Normalization + *****************************************************************************/ +pmPSF *pmPSFAlloc (pmModelType type) +{ + int Nparams; + + pmPSF *psf = (pmPSF *) psAlloc(sizeof(pmPSF)); + + psf->type = type; + psf->chisq = 0.0; + psf->ApResid = 0.0; + psf->dApResid = 0.0; + psf->skyBias = 0.0; + psf->skySat = 0.0; + + // the ApTrend components are (x, y, r2rflux, flux) + psf->ApTrend = psPolynomial4DAlloc (PS_POLYNOMIAL_ORD, 2, 2, 1, 1); + pmPSF_MaskApTrend (psf, PM_PSF_SKYBIAS); + + // don't define a growth curve : user needs to choose radius bins + psf->growth = NULL; + + Nparams = pmModelParameterCount (type); + if (!Nparams) { + psError(PS_ERR_UNKNOWN, true, "Undefined pmModelType"); + return(NULL); + } + + psf->params = psArrayAlloc(Nparams - 4); + for (int i = 0; i < psf->params->n; i++) { + // XXX EAM : make this a user-defined value? + psf->params->data[i] = psPolynomial2DAlloc(PS_POLYNOMIAL_ORD, 1, 1); + } + + psMemSetDeallocator(psf, (psFreeFunc) pmPSFFree); + return(psf); +} + + + +/***************************************************************************** +pmPSFFromModels (*psf, *models, *mask): build a PSF from a collection of +free-fitted models. The PSF ignores the first 4 (independent) model +parameters and constructs a polynomial fit to the remaining as a function of +image coordinate. + input: an array of pmModels, pre-allocated psf +Note: some of the array entries may be NULL (failed fits); ignore them. + *****************************************************************************/ +bool pmPSFFromModels (pmPSF *psf, psArray *models, psVector *mask) +{ + + // construct the fit vectors from the collection of objects + // use the mask to ignore missing fits + psVector *x = psVectorAlloc (models->n, PS_TYPE_F64); + psVector *y = psVectorAlloc (models->n, PS_TYPE_F64); + psVector *z = psVectorAlloc (models->n, PS_TYPE_F64); + psVector *dz = psVectorAlloc (models->n, PS_TYPE_F64); + + for (int i = 0; i < models->n; i++) { + pmModel *model = models->data[i]; + if (model == NULL) + continue; + + // XXX EAM : this is fragile: x and y must be stored consistently at 2,3 + // note that the data is provided in the F64 array + x->data.F64[i] = model->params->data.F32[2]; + y->data.F64[i] = model->params->data.F32[3]; + } + + // we are doing a robust fit. after each pass, we drop points which are + // more deviant than three sigma. + // mask is currently updated for each pass. this is inconsistent? + + psStats *stats = psStatsAlloc (PS_STAT_SAMPLE_MEAN | PS_STAT_SAMPLE_STDEV); + + for (int i = 0; i < psf->params->n; i++) { + for (int j = 0; j < models->n; j++) { + pmModel *model = models->data[j]; + if (model == NULL) + continue; + z->data.F64[j] = model->params->data.F32[i + 4]; + dz->data.F64[j] = 1; + // XXX EAM : need to use actual errors? + // XXX EAM : this is fragile: psf(Nparams) = model(Nparams) - 4 + } + + // XXX EAM : this is the expected API (cycle 7? cycle 8?) + psf->params->data[i] = psVectorClipFitPolynomial2D(psf->params->data[i], stats, mask, 0xff, z, dz, x, y); + + // XXX EAM : drop this when above is implemented... + // psf->params->data[i] = RobustFit2D (psf->params->data[i], mask, x, y, z, dz); + + // psTrace ("psphot.psftest", 3, "keeping %d of %d PSF candidates (PSF param %d)\n", Nkeep, mask->n, i); + // psPolynomial2DDump (psf->params->data[i]); + } + + psFree (stats); + psFree (x); + psFree (y); + psFree (z); + psFree (dz); + return (true); +} + + + +/***************************************************************************** +pmModelFromPSF (*modelEXT, *psf): use the model position parameters to +construct a realization of the PSF model at the object coordinates + *****************************************************************************/ +pmModel *pmModelFromPSF (pmModel *modelEXT, pmPSF *psf) +{ + + // need to define the relationship between the modelEXT and modelPSF ? + + // find function used to set the model parameters + pmModelFromPSFFunc modelFromPSFFunc = pmModelFromPSFFunc_GetFunction (psf->type); + + // allocate a new pmModel to hold the PSF version + pmModel *modelPSF = pmModelAlloc (psf->type); + + // set model parameters for this source based on PSF information + modelFromPSFFunc (modelPSF, modelEXT, psf); + + return (modelPSF); +} + +// zero and mask out all terms: +static bool maskAllTerms (psPolynomial4D *trend) +{ + + for (int i = 0; i < trend->nX + 1; i++) { + for (int j = 0; j < trend->nY + 1; j++) { + for (int k = 0; k < trend->nZ + 1; k++) { + for (int m = 0; m < trend->nT + 1; m++) { + trend->mask[i][j][k][m] = 1; // mask coeff + trend->coeff[i][j][k][m] = 0; // zero coeff + } + } + } + } + return true; +} + +/*********************************************** + * this function masks the psf.ApTrend polynomial + * to enable the specific subset of the coefficients + **********************************************/ +bool pmPSF_MaskApTrend (pmPSF *psf, pmPSF_ApTrendOptions option) +{ + + switch (option) { + case PM_PSF_NONE: + maskAllTerms (psf->ApTrend); + return true; + + case PM_PSF_CONSTANT: + maskAllTerms (psf->ApTrend); + psf->ApTrend->mask[0][0][0][0] = 0; // unmask constant + return true; + + case PM_PSF_SKYBIAS: + maskAllTerms (psf->ApTrend); + psf->ApTrend->mask[0][0][0][0] = 0; // unmask constant + psf->ApTrend->mask[0][0][1][0] = 0; // unmask skybias + return true; + + case PM_PSF_SKYSAT: + maskAllTerms (psf->ApTrend); + psf->ApTrend->mask[0][0][0][0] = 0; // unmask constant + psf->ApTrend->mask[0][0][1][0] = 0; // unmask skybias + psf->ApTrend->mask[0][0][0][1] = 0; // unmask skybias + return true; + + case PM_PSF_XY_LIN: + maskAllTerms (psf->ApTrend); + psf->ApTrend->mask[0][0][0][0] = 0; // unmask constant + psf->ApTrend->mask[1][0][0][0] = 0; // unmask x + psf->ApTrend->mask[0][1][0][0] = 0; // unmask y + return true; + + case PM_PSF_XY_QUAD: + maskAllTerms (psf->ApTrend); + psf->ApTrend->mask[0][0][0][0] = 0; // unmask constant + psf->ApTrend->mask[1][0][0][0] = 0; // unmask x + psf->ApTrend->mask[2][0][0][0] = 0; // unmask x^2 + psf->ApTrend->mask[1][1][0][0] = 0; // unmask x y + psf->ApTrend->mask[0][1][0][0] = 0; // unmask y + psf->ApTrend->mask[0][2][0][0] = 0; // unmask y^2 + return true; + + case PM_PSF_SKY_XY_LIN: + maskAllTerms (psf->ApTrend); + psf->ApTrend->mask[0][0][0][0] = 0; // unmask constant + psf->ApTrend->mask[1][0][0][0] = 0; // unmask x + psf->ApTrend->mask[0][1][0][0] = 0; // unmask y + psf->ApTrend->mask[0][0][1][0] = 0; // unmask skybias + return true; + + case PM_PSF_SKYSAT_XY_LIN: + maskAllTerms (psf->ApTrend); + psf->ApTrend->mask[0][0][0][0] = 0; // unmask constant + psf->ApTrend->mask[1][0][0][0] = 0; // unmask x + psf->ApTrend->mask[0][1][0][0] = 0; // unmask y + psf->ApTrend->mask[0][0][1][0] = 0; // unmask skybias + psf->ApTrend->mask[0][0][0][1] = 0; // unmask skysat + return true; + + case PM_PSF_ALL: + default: + maskAllTerms (psf->ApTrend); + psf->ApTrend->mask[0][0][0][0] = 0; // unmask constant + psf->ApTrend->mask[0][0][1][0] = 0; // unmask skybias + psf->ApTrend->mask[0][0][0][1] = 0; // unmask skysat + + psf->ApTrend->mask[1][0][0][0] = 0; // unmask x + psf->ApTrend->mask[2][0][0][0] = 0; // unmask x^2 + psf->ApTrend->mask[1][1][0][0] = 0; // unmask x y + psf->ApTrend->mask[0][1][0][0] = 0; // unmask y + psf->ApTrend->mask[0][2][0][0] = 0; // unmask y^2 + return true; + } + return false; +} + +psMetadata *pmPSFtoMD (psMetadata *metadata, pmPSF *psf) +{ + + if (metadata == NULL) { + metadata = psMetadataAlloc (); + } + + char *modelName = pmModelGetType (psf->type); + psMetadataAdd (metadata, PS_LIST_TAIL, "PSF_MODEL_NAME", PS_DATA_STRING, "PSF model name", modelName); + + int nPar = pmModelParameterCount (psf->type) ; + psMetadataAdd (metadata, PS_LIST_TAIL, "PSF_MODEL_NPAR", PS_DATA_S32, "PSF model parameter count", nPar); + + for (int i = 0; i < nPar - 4; i++) { + psPolynomial2D *poly = psf->params->data[i]; + psPolynomial2DtoMD (metadata, poly, "PSF_PAR%02d", i); + } + psPolynomial4DtoMD (metadata, psf->ApTrend, "APTREND"); + + psMetadataAdd (metadata, PS_LIST_TAIL, "PSF_AP_RESID", PS_DATA_F32, "aperture residual", psf->ApResid); + psMetadataAdd (metadata, PS_LIST_TAIL, "PSF_dAP_RESID", PS_DATA_F32, "aperture residual scatter", psf->dApResid); + psMetadataAdd (metadata, PS_LIST_TAIL, "PSF_SKY_BIAS", PS_DATA_F32, "sky bias level", psf->skyBias); + + psMetadataAdd (metadata, PS_LIST_TAIL, "PSF_CHISQ", PS_DATA_F32, "chi-square for fit", psf->chisq); + psMetadataAdd (metadata, PS_LIST_TAIL, "PSF_NSTARS", PS_DATA_S32, "number of stars used to measure PSF", psf->nPSFstars); + + return metadata; +} + +pmPSF *pmPSFfromMD (psMetadata *metadata) +{ + + bool status; + char keyword[80]; + + char *modelName = psMetadataLookupPtr (&status, metadata, "PSF_MODEL_NAME"); + pmModelType type = pmModelSetType (modelName); + + pmPSF *psf = pmPSFAlloc (type); + + int nPar = psMetadataLookupS32 (&status, metadata, "PSF_MODEL_NPAR"); + if (nPar != pmModelParameterCount (psf->type)) + psAbort ("read PSF" , "mismatch model par count"); + + for (int i = 0; i < nPar - 4; i++) { + sprintf (keyword, "PSF_PAR%02d", i); + psMetadata *folder = psMetadataLookupPtr (&status, metadata, keyword); + psPolynomial2D *poly = psPolynomial2DfromMD (folder); + psFree (psf->params->data[i]); + psf->params->data[i] = poly; + } + sprintf (keyword, "APTREND"); + psMetadata *folder = psMetadataLookupPtr (&status, metadata, keyword); + psPolynomial4D *poly = psPolynomial4DfromMD (folder); + psFree (psf->ApTrend); + psf->ApTrend = poly; + + psf->ApResid = psMetadataLookupF32 (&status, metadata, "PSF_AP_RESID"); + psf->dApResid = psMetadataLookupF32 (&status, metadata, "PSF_dAP_RESID"); + psf->skyBias = psMetadataLookupF32 (&status, metadata, "PSF_SKY_BIAS"); + + psf->chisq = psMetadataLookupF32 (&status, metadata, "PSF_CHISQ"); + psf->nPSFstars = psMetadataLookupS32 (&status, metadata, "PSF_NSTARS"); + + psFree (metadata); + return (psf); +} Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/objects/pmPSF.h =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/objects/pmPSF.h (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/objects/pmPSF.h (revision 21664) @@ -0,0 +1,107 @@ +/** @file pmPSF.h + * + * This file contains typedefs for the Point-Spread Function and prototypes + * for functions that calculate the PSF. + * + * @author EAM, IfA + * + * @version $Revision: 1.1.18.3 $ $Name: not supported by cvs2svn $ + * @date $Date: 2006-01-15 18:22:34 $ + * + * Copyright 2004 Maui High Performance Computing Center, University of Hawaii + * + */ + +# ifndef PM_PSF_H +# define PM_PSF_H + +#include "pmGrowthCurve.h" + +/** pmPSF data structure + * + * It is useful to generate a model to define the point-spread-function which + * describes the flux distribution for unresolved sources in an image. In + * general, the PSF varies with position in the image. We allow any of the source + * models defined for the pmModel to represent the PSF. For a given source model, + * the 2D spatial variation of all of the source parameters, except the first + * four PSF-independent parameters, are represented as polynomial, stored in a + * psArray. The other elements of the structure define the quality of the PSF + * determination. + * + */ +typedef struct +{ + pmModelType type; ///< PSF Model in use + psArray *params; ///< Model parameters (psPolynomial2D) + psPolynomial4D *ApTrend; ///< ApResid vs (x,y,rflux) (rflux = ten(0.4*mInst) + pmGrowthCurve *growth; ///< apMag vs Radius + float ApResid; ///< ??? + float dApResid; ///< ??? + float skyBias; ///< ??? + float skySat; ///< ??? + float chisq; ///< PSF goodness statistic + int nPSFstars; ///< number of stars used to measure PSF + int nApResid; ///< number of stars used to measure ApResid +} +pmPSF; + +typedef enum { + PM_PSF_NONE, + PM_PSF_CONSTANT, + PM_PSF_SKYBIAS, + PM_PSF_SKYSAT, + PM_PSF_XY_LIN, + PM_PSF_XY_QUAD, + PM_PSF_SKY_XY_LIN, + PM_PSF_SKYSAT_XY_LIN, + PM_PSF_ALL +} pmPSF_ApTrendOptions; + +/** + * + * Allocator for the pmPSF structure. + * + */ +pmPSF *pmPSFAlloc( + pmModelType type ///< Add comment +); + + +/** + * + * This function takes a collection of pmModel fitted models from across a + * single image and builds a pmPSF representation of the PSF. The input array of + * model fits may consist of entries to be ignored (noted by a non-zero mask + * entry). The analysis of the models fits a 2D polynomial for each parameter to + * the collection of model parameters as a function of position (and + * normalization?). In this process, some of the input models may be marked as + * outliers and excluded from the fit. These elements will be marked with a + * specific mask value (1 == PSFTRY_MASK_OUTLIER). + * + */ +bool pmPSFFromModels( + pmPSF *psf, ///< Add comment + psArray *models, ///< Add comment + psVector *mask ///< Add comment +); + + +/** + * + * This function constructs a pmModel instance based on the pmPSF description + * of the PSF. The input is a pmModel with at least the values of the centroid + * coordinates (possibly normalization if this is needed) defined. The values of + * the PSF-dependent parameters are specified for the specific realization based + * on the coordinates of the object. + * + */ +pmModel *pmModelFromPSF( + pmModel *model, ///< Add comment + pmPSF *psf ///< Add comment +); + +bool pmPSF_MaskApTrend (pmPSF *psf, pmPSF_ApTrendOptions option); +psMetadata *pmPSFtoMD (psMetadata *metadata, pmPSF *psf); +pmPSF *pmPSFfromMD (psMetadata *metadata); + +# endif Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/objects/pmPSFtry.c =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/objects/pmPSFtry.c (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/objects/pmPSFtry.c (revision 21664) @@ -0,0 +1,236 @@ +/** @file pmPSFtry.c + * + * XXX: need description of file purpose + * + * @author EAM, IfA + * + * @version $Revision: 1.3.4.5 $ $Name: not supported by cvs2svn $ + * @date $Date: 2006-02-17 02:49:07 $ + * + * Copyright 2004 Maui High Performance Computing Center, University of Hawaii + * + */ + +# include +# include "pmObjects.h" +# include "pmPSF.h" +# include "pmPSFtry.h" +# include "pmModelGroup.h" + +// ******** pmPSFtry functions ************************************************** +// * pmPSFtry holds a single pmPSF model test, with the input sources, the freely +// * fitted version of the model, the pmPSF fit to the fitted model parameters, +// * and the PSF fits to the source. It also includes the statistics from the +// * fits, both the individual sources, and the collection + +// free a pmPSFtry structure +static void pmPSFtryFree (pmPSFtry *test) +{ + + if (test == NULL) + return; + + psFree (test->psf); + psFree (test->sources); + psFree (test->modelEXT); + psFree (test->modelPSF); + psFree (test->metric); + psFree (test->fitMag); + psFree (test->mask); + return; +} + +// allocate a pmPSFtry based on the desired sources and the model (identified by name) +pmPSFtry *pmPSFtryAlloc (psArray *sources, char *modelName) +{ + + pmModelType type; + + pmPSFtry *test = (pmPSFtry *) psAlloc(sizeof(pmPSFtry)); + + // XXX probably need to increment ref counter + type = pmModelSetType (modelName); + test->psf = pmPSFAlloc (type); + test->sources = psMemIncrRefCounter(sources); + test->modelEXT = psArrayAlloc (sources->n); + test->modelPSF = psArrayAlloc (sources->n); + test->metric = psVectorAlloc (sources->n, PS_TYPE_F64); + test->fitMag = psVectorAlloc (sources->n, PS_TYPE_F64); + test->mask = psVectorAlloc (sources->n, PS_TYPE_U8); + + for (int i = 0; i < test->modelEXT->n; i++) { + test->mask->data.U8[i] = 0; + test->modelEXT->data[i] = NULL; + test->modelPSF->data[i] = NULL; + test->metric->data.F64[i] = 0; + test->fitMag->data.F64[i] = 0; + } + + psMemSetDeallocator(test, (psFreeFunc) pmPSFtryFree); + return (test); +} + +// build a pmPSFtry for the given model: +// - fit each source with the free-floating model +// - construct the pmPSF from the collection of models +// - fit each source with the PSF-parameter models +// - measure the pmPSF quality metric (dApResid) + +// sources used in for pmPSFtry may be masked by the analysis +// mask values indicate the reason the source was rejected: + +pmPSFtry *pmPSFtryModel (psArray *sources, char *modelName, float RADIUS) +{ + bool status; + float obsMag; + float fitMag; + float x; + float y; + int Next = 0; + int Npsf = 0; + + pmPSFtry *psfTry = pmPSFtryAlloc (sources, modelName); + + // stage 1: fit an independent model (freeModel) to all sources + psTimerStart ("fit"); + for (int i = 0; i < psfTry->sources->n; i++) { + + pmSource *source = psfTry->sources->data[i]; + pmModel *model = pmSourceModelGuess (source, psfTry->psf->type); + x = source->peak->x; + y = source->peak->y; + + // set temporary object mask and fit object + // fit model as EXT, not PSF + + psImageKeepCircle (source->mask, x, y, RADIUS, "OR", PSPHOT_MASK_MARKED); + status = pmSourceFitModel (source, model, false); + psImageKeepCircle (source->mask, x, y, RADIUS, "AND", ~PSPHOT_MASK_MARKED); + + // exclude the poor fits + if (!status) { + psfTry->mask->data.U8[i] = PSFTRY_MASK_EXT_FAIL; + psFree (model); + continue; + } + psfTry->modelEXT->data[i] = model; + Next ++; + } + psLogMsg ("psphot.psftry", 4, "fit ext: %f sec for %d sources\n", psTimerMark ("fit"), sources->n); + psTrace ("psphot.psftry", 3, "keeping %d of %d PSF candidates (EXT)\n", Next, sources->n); + + // stage 2: construct a psf (pmPSF) from this collection of model fits + pmPSFFromModels (psfTry->psf, psfTry->modelEXT, psfTry->mask); + + // stage 3: refit with fixed shape parameters + psTimerStart ("fit"); + for (int i = 0; i < psfTry->sources->n; i++) { + // masked for: bad model fit, outlier in parameters + if (psfTry->mask->data.U8[i] & PSFTRY_MASK_ALL) + continue; + + pmSource *source = psfTry->sources->data[i]; + pmModel *modelEXT = psfTry->modelEXT->data[i]; + + // set shape for this model based on PSF + pmModel *modelPSF = pmModelFromPSF (modelEXT, psfTry->psf); + x = source->peak->x; + y = source->peak->y; + + psImageKeepCircle (source->mask, x, y, RADIUS, "OR", PSPHOT_MASK_MARKED); + status = pmSourceFitModel (source, modelPSF, true); + + // skip poor fits + if (!status) { + psfTry->mask->data.U8[i] = PSFTRY_MASK_PSF_FAIL; + psFree (modelPSF); + goto next_source; + } + + // otherwise, save the resulting model + psfTry->modelPSF->data[i] = modelPSF; + + // XXX : use a different aperture radius from the fit radius? + // XXX : use a different estimator for the local sky? + // XXX : pass 'source' as input? + if (!pmSourcePhotometry (&fitMag, &obsMag, modelPSF, source->pixels, source->mask)) { + psfTry->mask->data.U8[i] = PSFTRY_MASK_BAD_PHOT; + goto next_source; + } + + psfTry->metric->data.F64[i] = obsMag - fitMag; + psfTry->fitMag->data.F64[i] = fitMag; + Npsf ++; + +next_source: + psImageKeepCircle (source->mask, x, y, RADIUS, "AND", ~PSPHOT_MASK_MARKED); + + } + psfTry->psf->nPSFstars = Npsf; + + psLogMsg ("psphot.psftry", 4, "fit psf: %f sec for %d sources\n", psTimerMark ("fit"), sources->n); + psTrace ("psphot.psftry", 3, "keeping %d of %d PSF candidates (PSF)\n", Npsf, sources->n); + + // make this optional + // DumpModelFits (psfTry->modelPSF, "modelsPSF.dat"); + + // XXX this function wants aperture radius for pmSourcePhotometry + pmPSFtryMetric (psfTry, RADIUS); + psLogMsg ("psphot.pspsf", 3, "try model %s, ap-fit: %f +/- %f : sky bias: %f\n", + modelName, psfTry->psf->ApResid, psfTry->psf->dApResid, psfTry->psf->skyBias); + + return (psfTry); +} + +bool pmPSFtryMetric (pmPSFtry *psfTry, float RADIUS) +{ + // the measured (aperture - fit) magnitudes (dA == psfTry->metric) + // depend on both the true ap-fit (dAo) and the bias in the sky measurement: + // dA = dAo + dsky/flux + // where flux is the flux of the star + // we fit this trend to find the infinite flux aperture correction (dAo), + // the nominal sky bias (dsky), and the error on dAo + // the values of dA are contaminated by stars with close neighbors in the aperture + // we use an outlier rejection to avoid this bias + + // r2rflux = radius^2 * ten(0.4*fitMag); + psVector *r2rflux = psVectorAlloc (psfTry->sources->n, PS_TYPE_F64); + for (int i = 0; i < psfTry->sources->n; i++) { + if (psfTry->mask->data.U8[i] & PSFTRY_MASK_ALL) + continue; + r2rflux->data.F64[i] = PS_SQR(RADIUS) * pow(10.0, 0.4*psfTry->fitMag->data.F64[i]); + } + + // use 3hi/1lo sigma clipping on the r2rflux vs metric fit + psStats *stats = psStatsAlloc (PS_STAT_SAMPLE_MEDIAN | PS_STAT_SAMPLE_STDEV); + stats->min = 1.0; + stats->max = 3.0; + stats->clipIter = 3; + + // fit ApTrend only to r2rflux, ignore x,y,flux variations for now + // linear clipped fit of ApResid to r2rflux + psPolynomial1D *poly = psPolynomial1DAlloc (PS_POLYNOMIAL_ORD, 1); + poly = psVectorClipFitPolynomial1D (poly, stats, psfTry->mask, PSFTRY_MASK_ALL, psfTry->metric, NULL, r2rflux); + psLogMsg ("pmPSFtryMetric", 4, "fit stats: %f +/- %f\n", stats->sampleMedian, stats->sampleStdev); + + pmPSF_MaskApTrend (psfTry->psf, PM_PSF_SKYBIAS); + psfTry->psf->ApTrend->coeff[0][0][0][0] = poly->coeff[0]; + psfTry->psf->ApTrend->coeff[0][0][1][0] = 0; + + psfTry->psf->skyBias = poly->coeff[1]; + psfTry->psf->ApResid = poly->coeff[0]; + psfTry->psf->dApResid = stats->sampleStdev; + + psFree (r2rflux); + psFree (poly); + psFree (stats); + + return true; +} + +/* + (aprMag' - fitMag) = rflux*skyBias + ApTrend(x,y) + (aprMag - rflux*skyBias) - fitMag = ApTrend(x,y) + (aprMag - rflux*skyBias) = fitMag + ApTrend(x,y) +*/ + Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/objects/pmPSFtry.h =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/objects/pmPSFtry.h (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/objects/pmPSFtry.h (revision 21664) @@ -0,0 +1,123 @@ +/** @file pmPSFtry.h + * + * This file contains code that allows the user to try to fit several + * PSF models to an image. + * + * @author EAM, IfA + * + * @version $Revision: 1.2.4.3 $ $Name: not supported by cvs2svn $ + * @date $Date: 2006-02-08 07:16:49 $ + * + * Copyright 2004 Maui High Performance Computing Center, University of Hawaii + * + */ + +# ifndef PM_PSF_TRY_H +# define PM_PSF_TRY_H + + +/** + * + * This structure contains a pointer to the collection of sources which will + * be used to test the PSF model form. It lists the pmModelType type of model + * being tests, and contains an element to store the resulting psf + * representation. In addition, this structure carries the complete collection of + * EXT (floating parameter) and PSF (fixed parameter) model fits to each of the + * sources modelEXT and modelPSF. It also contains a mask which is set by the + * model fitting and psf fitting steps. For each model, the value of the quality + * metric is stored in the vector metric and the fitted instrumental magnitude is + * stored in fitMag. The quality metric for the PSF model is the aperture + * magnitude minus the fitted magnitude for each source. This collection of + * aperture residuals is examined in the analysis process, and a linear trend of + * the residual with the inverse object flux (ie, 100:4his structure contains a + * pointer to the collection of sources which will be used to test the PSF model + * form. It lists the pmModelType type of modmag) is fitted. The result of this + * fit is a measured sky bias (systematic error in the sky measured by the fits), + * an effective infinite-magnitude aperture correction (ApResid), and the scatter + * of the aperture correction for the ensemble of PSF stars (dApResid). The + * ultimate metric to intercompare multiple types of PSF models is the value of + * the aperture correction scatter. + * + * XXX: There are many more members in the SDRS then in the prototype code. + * I stuck with the prototype code. + * + * + */ +typedef struct +{ + pmPSF *psf; ///< Add comment. + psArray *sources; ///< pointers to the original sources + psArray *modelEXT; ///< model fits, floating parameters + psArray *modelPSF; ///< model fits, PSF parameters + psVector *mask; ///< Add comment. + psVector *metric; ///< Add comment. + psVector *fitMag; ///< Add comment. +} +pmPSFtry; + + +/** pmPSFtryMaskValues + * + * The following datatype defines the masks used by the pmPSFtry analysis to + * identify sources which should or should not be included in the analysis. + * + */ +typedef enum { + PSFTRY_MASK_CLEAR = 0x00, ///< Add comment. + PSFTRY_MASK_OUTLIER = 0x01, ///< 1: outlier in psf polynomial fit (provided by psPolynomials) + PSFTRY_MASK_EXT_FAIL = 0x02, ///< 2: ext model failed to converge + PSFTRY_MASK_PSF_FAIL = 0x04, ///< 3: psf model failed to converge + PSFTRY_MASK_BAD_PHOT = 0x08, ///< 4: invalid source photometry + PSFTRY_MASK_ALL = 0x0f, ///< Add comment. +} pmPSFtryMaskValues; + + +/** pmPSFtryAlloc() + * + * Allocate a pmPSFtry data structure. + * + */ +pmPSFtry *pmPSFtryAlloc( + psArray *stars, ///< Add comment. + char *modelName ///< Add comment. +); + + +/** pmPSFtryModel() + * + * This function takes the input collection of sources and performs a complete + * analysis to determine a PSF model of the given type (specified by model name). + * The result is a pmPSFtry with the results of the analysis. + * + */ +pmPSFtry *pmPSFtryModel( + psArray *sources, ///< Add comment. + char *modelName, ///< Add comment. + float radius ///< Add comment. +); + + +/** pmPSFtryMetric() + * + * This function is used to measure the PSF model metric for the set of + * results contained in the pmPSFtry structure. + * + */ +bool pmPSFtryMetric( + pmPSFtry *psfTry, ///< Add comment. + float RADIUS ///< Add comment. +); + +/** pmPSFtryMetric_Alt() + * + * This function is used to measure the PSF model metric for the set of + * results contained in the pmPSFtry structure (alternative implementation). + * + */ +bool pmPSFtryMetric_Alt( + pmPSFtry *try + , ///< Add comment. + float RADIUS ///< Add comment. +); + +# endif Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/objects/psEllipse.c =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/objects/psEllipse.c (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/objects/psEllipse.c (revision 21664) @@ -0,0 +1,62 @@ +# include "pslib.h" +# include "psEllipse.h" + +EllipseAxes EllipseMomentsToAxes (EllipseMoments moments) +{ + + EllipseAxes axes; + + double f = sqrt (0.25*PS_SQR(moments.x2 - moments.y2) + PS_SQR(moments.xy)); + if (f > (moments.x2 + moments.y2) / 2.0) { + f = 0.98*(moments.x2 + moments.y2) / 2.0; + } + + axes.major = sqrt (0.5*(moments.x2 + moments.y2) + f); + axes.minor = sqrt (0.5*(moments.x2 + moments.y2) - f); + axes.theta = atan2 (2*moments.xy, moments.x2 - moments.y2) / 2; + // theta in radians + + return (axes); +} + +EllipseShape EllipseAxesToShape (EllipseAxes axes) +{ + + EllipseShape shape; + + double r1 = 1.0 / PS_SQR(axes.major) + 1.0 / PS_SQR(axes.minor); + double r2 = 1.0 / PS_SQR(axes.major) - 1.0 / PS_SQR(axes.minor); + + double sxr = r1 + r2*cos(2*axes.theta); + double syr = r1 - r2*cos(2*axes.theta); + + shape.sx = 1.0 / sqrt(sxr); + shape.sy = 1.0 / sqrt(syr); + shape.sxy = r2*sin(2*axes.theta); + + return (shape); +} + +EllipseAxes EllipseShapeToAxes (EllipseShape shape) +{ + + EllipseAxes axes; + + double f1 = 1.0 / PS_SQR(shape.sx) + 1.0 / PS_SQR(shape.sy); + double f2 = 1.0 / PS_SQR(shape.sx) - 1.0 / PS_SQR(shape.sy); + + // force the axis ratio to be less than 10 + double r1 = 0.5*0.95*sqrt (PS_SQR(f1) - PS_SQR(f2)); + + shape.sxy = PS_MIN(PS_MAX(shape.sxy, -r1), r1); + + axes.theta = atan2 (-2.0*shape.sxy, f2) / 2.0; + + double Ar = 0.25*f1 + 0.25*sqrt(PS_SQR(f2) + 4*PS_SQR(shape.sxy)); + double Br = 0.25*f1 - 0.25*sqrt(PS_SQR(f2) + 4*PS_SQR(shape.sxy)); + + axes.minor = 1.0 / sqrt (Ar); + axes.major = 1.0 / sqrt (Br); + + return (axes); +} Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/objects/psEllipse.h =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/objects/psEllipse.h (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/objects/psEllipse.h (revision 21664) @@ -0,0 +1,30 @@ +// strucures to define elliptical shape parameters +typedef struct +{ + double major; + double minor; + double theta; +} +EllipseAxes; + +typedef struct +{ + double x2; + double y2; + double xy; +} +EllipseMoments; + +typedef struct +{ + double sx; + double sy; + double sxy; +} +EllipseShape; + +// conversions between elliptical shape representations +EllipseAxes EllipseMomentsToAxes (EllipseMoments moments); +EllipseShape EllipseAxesToShape (EllipseAxes axes); +EllipseAxes EllipseShapeToAxes (EllipseShape shape); + Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/parseErrorCodes.pl =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/parseErrorCodes.pl (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/parseErrorCodes.pl (revision 21664) @@ -0,0 +1,97 @@ +#!/usr/bin/perl + +# Provides functions for handling long command line options +use Getopt::Long; + +my @ErrorCodes = (); +my @ErrorDescriptions = (); + +my $data = "psErrorCodes.dat"; + +# Assign variables based on the presence of command line options to the script +GetOptions( + "data=s" => \$data, + "verbose" => \$verbose, + "help" => \$help +); + +if ($help) { + print "Usage: parseErrorCodes ", "[--data=$data] ", "[--help] ", + "[--verbose] filename [filename ...]\n\n"; + exit(0); +} + +print "Using data file '$data'\n" if $verbose; +unless ( open( DATAFILE, "<", $data ) ) { + die "Can not open data file $data."; +} + +print "Datafile:\n" if $verbose; +while () { + chop; + if (/^\s*\#/) { + print "C $_\n" if $verbose; + } + else { + if (/^\s*(\w+)\s+([\%\w].*)/) { + my $ErrorCode = $1; + my $ErrorDescription = $2; + print " $ErrorCode: '$ErrorDescription'\n" if $verbose; + push( @ErrorCodes, $ErrorCode ); + push( @ErrorDescriptions, $ErrorDescription ); + } else { + print "I $_\n" if $verbose; + } + } +} +close(DATAFILE); + +my $found = $#ErrorCodes + 1; +print "\nFound $found error codes.\n" if $verbose; + +foreach (@ARGV) { + my $filename = $_; + my @result = (); + + die "Failed to open input file" + if !open( INFILE, "<", $filename ); + + print "\nOutput File:\n" if $verbose; + while () { + chop; + push( @result, $_ ); + if (/^\s*\/\/~Start(.*)$/) { + $line = $1; + for ( $n = 0 ; $n < $found ; $n++ ) { + $_ = $line; + s/\$1/$ErrorCodes[$n]/g; + s/\$2/$ErrorDescriptions[$n]/g; + s/\$n/$n/g; + push( @result, $_ ); + print "$_\n" if $verbose; + } + + $break = 0; + while ( ( $break == 0 ) && ( $_ = ) ) { + if (/^\s*\/\/~End/) { + $break = 1; + } + } + chop; + push( @result, $_ ); + } + } + + close(INFILE); + + die "Failed to overwrite input file" + if !open( OUTFILE, ">", $filename ); + + foreach (@result) { + print OUTFILE "$_\n"; + print "$_\n" if $verbose; + } + + close(OUTFILE); + +} Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/photom/.cvsignore =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/photom/.cvsignore (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/photom/.cvsignore (revision 21664) @@ -0,0 +1,6 @@ +.deps +.libs +Makefile +Makefile.in +*.la +*.lo Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/photom/Makefile.am =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/photom/Makefile.am (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/photom/Makefile.am (revision 21664) @@ -0,0 +1,9 @@ +noinst_LTLIBRARIES = libpsmodulephotom.la + +libpsmodulephotom_la_CPPFLAGS = $(SRCINC) $(PSMODULE_CFLAGS) +libpsmodulephotom_la_LDFLAGS = -release $(PACKAGE_VERSION) +libpsmodulephotom_la_SOURCES = + +psmoduleincludedir = $(includedir) +psmoduleinclude_HEADERS = + Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/psErrorCodes.dat =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/psErrorCodes.dat (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/src/psErrorCodes.dat (revision 21664) @@ -0,0 +1,18 @@ +# +# This file is used to generate psErrorCode.h content +# +# Format: +# ERROR_CLASS_NAME ERROR_CLASS_DESCRIPTION +# +# Note: the ERROR_CLASS_NAME will appear in the code with a "PS_ERR_" prefix +# +UNKNOWN unknown error +IO I/O error +LOCATION_INVALID specified location is unknown +MEMORY_CORRUPTION memory corruption detected +MEMORY_DEREF_USAGE dereferenced memory still used +BAD_PARAMETER_VALUE parameter is out-of-range +BAD_PARAMETER_TYPE parameter is of unsupported type +BAD_PARAMETER_NULL parameter is null +BAD_PARAMETER_SIZE size of parameter's data is outside of acceptable range. +UNEXPECTED_NULL unexpected NULL found Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/templates/c =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/templates/c (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/templates/c (revision 21664) @@ -0,0 +1,11 @@ +/** @file filename.c + * + * @brief Contains the definitions for ... + * + * @author Robert DeSonia, MHPCC + * + * @version $Revision: 1.1.1.1 $ $Name: not supported by cvs2svn $ + * @date $Date: 2004-09-10 19:01:33 $ + * + * Copyright 2004 Maui High Performance Computing Center, University of Hawaii + */ Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/templates/h =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/templates/h (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/templates/h (revision 21664) @@ -0,0 +1,13 @@ +/** @file filename.h + * + * @brief Contains the definitions for ... + * + * Detailed Description goes here. + * + * @author Robert DeSonia, MHPCC + * + * @version $Revision: 1.1.1.1 $ $Name: not supported by cvs2svn $ + * @date $Date: 2004-09-10 19:01:33 $ + * + * Copyright 2004 Maui High Performance Computing Center, University of Hawaii + */ Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/.cvsignore =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/.cvsignore (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/.cvsignore (revision 21664) @@ -0,0 +1,15 @@ +.deps +.libs +Makefile +tst_pmFlatField +tst_pmMaskBadPixels +tst_pmNonLinear +tst_pmSubtractBias +temp +Makefile.in +tst_pmObjects01 +tst_pmReadoutCombine +tst_pmSubtractSky +tst_pmImageSubtract +tst_pmImageCombine +tst_pmAstrometry Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/FullUnitTest =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/FullUnitTest (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/FullUnitTest (revision 21664) @@ -0,0 +1,360 @@ +#!/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.3 $ $Name: not supported by cvs2svn $ +# $Date: 2005-04-12 21:51:00 $ +# +# Copyright 2004 Maui High Performance Computing Center, University of Hawaii +# +############################################################################## + +use FindBin qw($Bin); + +$runTest = "$Bin/runTest"; + +# Provide functions for determining the pathname of current working directory +use Cwd; + +# Provides functions for handling psS64 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'}/src/.libs:$ENV{'LD_LIBRARY_PATH'}"; +$ENV{'DYLD_LIBRARY_PATH'} = "$ENV{'PSLIB_ROOT'}/src/.libs:$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 and save results + $_ = join( "\n|| ", split( "\n", "\n" . `make tests` ) ); + + # Check the output of make for return value != 0 or any of the + # following words: FAILED, FAULT, ERROR, Not found, SIGNAL + if ( $? != 0 ) { + + # 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 ); + } + } +} + +################################################################################ +# +# 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++; + + # Display message to user of which test driver is being executed + print("--- Executing test driver $files[$j]\n") if ( !$silent ); + + # Execute the test driver + if ($silent) { + system("$runTest --quiet ./$files[$j]"); + } elsif ($verbose) { + system("$runTest --printpassfail ./$files[$j]"); + } else { + system("$runTest ./$files[$j]"); + } + $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 ) + { + + # 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] ); + } + } + $j++; + } +} + Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/Makefile.am =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/Makefile.am (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/Makefile.am (revision 21664) @@ -0,0 +1,17 @@ +# Makefile for psModule tests + +SUBDIRS = $(SRCDIRS) + +EXTRA_DIST = \ + runTest \ + FullUnitTest + +all: + chmod a+x $(srcdir)/FullUnitTest + +test: check + +tests: $(TESTS) + +CLEANFILES = $(TESTS) + Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/astrom/.cvsignore =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/astrom/.cvsignore (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/astrom/.cvsignore (revision 21664) @@ -0,0 +1,7 @@ +.deps +.libs +Makefile +Makefile.in +temp +tst_pmAstrometry +tst_pmAstrometry01 Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/astrom/Makefile.am =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/astrom/Makefile.am (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/astrom/Makefile.am (revision 21664) @@ -0,0 +1,24 @@ +# Makefile for psModule tests + +AM_LDFLAGS = -L$(top_builddir)/src -lpsmodule $(PSMODULE_LIBS) +AM_CFLAGS = @AM_CFLAGS@ $(PSMODULE_CFLAGS) $(SRCINC) +AM_CPPFLAGS = $(SRCINC) $(PSLIB_CFLAGS) + +TESTS = \ + tst_pmAstrometry \ + tst_pmAstrometry01 + +tst_pmAstrometry_SOURCES = tst_pmAstrometry.c +tst_pmAstrometry01_SOURCES = tst_pmAstrometry01.c + +check_PROGRAMS = $(TESTS) + +TESTS_ENVIRONMENT = perl $(top_srcdir)/test/runTest --verified=$(srcdir)/verified + +tests: $(TESTS) + +EXTRA_DIST = verified + +CLEANFILES = $(TESTS) temp/* + +test: check Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/astrom/tst_pmAstrometry.c =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/astrom/tst_pmAstrometry.c (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/astrom/tst_pmAstrometry.c (revision 21664) @@ -0,0 +1,615 @@ +/** @file tst_pmAstrometry.c + * + * @brief Contains the tests: pmAstrometry.[ch]. The pmxxxAlloc() + * and psFree() functionality are used here. + * + * @author GLG, MHPCC + * + * XXX: Untested: pmFPACheckParents() + * XXX: Create the pmHDU alloc/free function, test them here + * + * @version $Revision: 1.5 $ $Name: not supported by cvs2svn $ + * @date $Date: 2005-12-05 21:28:55 $ + * + * Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii + */ + +#include "config.h" +#include +#include +#include "psTest.h" +#include "pslib_strict.h" +#include "pmAstrometry.h" + +static psS32 testFPAAlloc(void); +static psS32 testChipAlloc(void); +static psS32 testCellAlloc(void); +static psS32 testReadoutAlloc(void); + +testDescription tests[] = { + {testFPAAlloc,739,"pmFPAAlloc",0,false}, + {testChipAlloc,740,"pmChipAlloc",0,false}, + {testCellAlloc,741,"pmCellAlloc",0,false}, + {testReadoutAlloc,742,"pmReadoutAlloc",0,false}, + {NULL} + }; + +#define CHIP_ALLOC_NAME "ChipName" +#define CELL_ALLOC_NAME "CellName" +#define MISC_NUM 32 +#define MISC_NAME "META00" +#define MISC_NAME2 "META01" +#define NUM_BIAS_DATA 10 +#define TEST_NUM_ROWS 32 +#define TEST_NUM_COLS 32 + +psPlaneTransform *PS_CREATE_2D_IDENTITY_PLANE_TRANSFORM() +{ + psPlaneTransform *pt = psPlaneTransformAlloc(1, 1); + pt->x->coeff[1][0] = 1.0; + pt->y->coeff[0][1] = 1.0; + return(pt); +} + +psPlaneDistort *PS_CREATE_4D_IDENTITY_PLANE_DISTORT() +{ + psPlaneDistort *pd = psPlaneDistortAlloc(1, 1, 1, 1); + pd->x->coeff[1][0][0][0] = 1.0; + pd->y->coeff[0][1][0][0] = 1.0; + return(pd); +} + +/****************************************************************************** +generateSimpleFPA(): This function generates a pmFPA data structure and then +populates its members with real data. We do this to ensure that the data is +later being psFree()'ed correctly. + *****************************************************************************/ +pmFPA *generateSimpleFPA() +{ + psBool rc; + pmFPA* fpa = pmFPAAlloc(psMetadataAlloc()); + + if (fpa == NULL) { + psLogMsg(__func__,PS_LOG_ERROR, "TEST ERROR: pmFPAAlloc() returned a NULL."); + return(NULL); + } + + // + // Test and create camera metadata. + // + if (fpa->camera == NULL) { + psLogMsg(__func__, PS_LOG_ERROR, "TEST ERROR: fpa->camera is NULL."); + psFree(fpa); + return(NULL); + } else { + rc = psMetadataAddS32((psMetadata *) fpa->camera, PS_LIST_HEAD, MISC_NAME, 0, NULL, MISC_NUM); + if (rc == false) { + psLogMsg(__func__,PS_LOG_ERROR, "TEST ERROR: could not add metadata to fpa->camera."); + psFree(fpa); + return(NULL); + } + psS32 tmpS32 = psMetadataLookupS32(&rc, fpa->camera, MISC_NAME); + if ((rc == false) || (tmpS32 != MISC_NUM)) { + psLogMsg(__func__,PS_LOG_ERROR, "TEST ERROR: could not read metadata from fpa->camera."); + psFree(fpa); + return(NULL); + } + } + + // + // Create various transforms and projections. + // + fpa->fromTangentPlane = PS_CREATE_4D_IDENTITY_PLANE_DISTORT(); + fpa->toTangentPlane = PS_CREATE_4D_IDENTITY_PLANE_DISTORT(); + fpa->projection = psProjectionAlloc(0.0,0.0,10.0,10.0,PS_PROJ_TAN); + + // + // Ensure fpa concepts metadata was allocated properly. + // + if (fpa->concepts == NULL) { + psLogMsg(__func__,PS_LOG_ERROR, "TEST ERROR: pmFPAAlloc did not set fpa->concepts."); + psFree(fpa); + return(NULL); + } else { + rc = psMetadataAddS32(fpa->concepts, PS_LIST_HEAD, MISC_NAME, 0, NULL, MISC_NUM); + if (rc == false) { + psLogMsg(__func__,PS_LOG_ERROR, "TEST ERROR: could not add data to fpa->concepts."); + psFree(fpa); + return(NULL); + } + psS32 tmpS32 = psMetadataLookupS32(&rc, fpa->concepts, MISC_NAME); + if ((rc == false) || (tmpS32 != MISC_NUM)) { + psLogMsg(__func__,PS_LOG_ERROR, "TEST ERROR: could not read metadata from fpa->concepts."); + psFree(fpa); + return(NULL); + } + } + + // + // Create ->analysis metadata. + // + fpa->analysis = psMetadataAlloc(); + rc = psMetadataAddS32(fpa->analysis, PS_LIST_HEAD, MISC_NAME, 0, NULL, MISC_NUM); + + // + // We test the fpa->chips array later. + // + + // + // How to test the p_pmHDU *private member? + // + + // + // Create ->phu metadata. + // + fpa->phu = psMetadataAlloc(); + rc = psMetadataAddS32(fpa->phu, PS_LIST_HEAD, MISC_NAME, 0, NULL, MISC_NUM); + + return(fpa); +} + + +psS32 main(psS32 argc, char* argv[]) +{ + psLogSetLevel(PS_LOG_INFO); + psLogSetFormat("HLNM"); + + return ! runTestSuite(stderr,"pmAstrometry",tests,argc,argv); +} + +/****************************************************************************** +testFPAAlloc() + 1: We ensure that pmFPAAlloc() properly allocates a pmFPA struct. + 2: We populate the members with real data to ensure they are being + free'ed correctly. + *****************************************************************************/ +static psS32 testFPAAlloc(void) +{ + psMetadata *camera = psMetadataAlloc(); + pmFPA* fpa = pmFPAAlloc(camera); + + if (fpa == NULL) { + psLogMsg(__func__,PS_LOG_ERROR, "TEST ERROR: pmFPAAlloc() returned a NULL."); + return 1; + } + + if (fpa->fromTangentPlane != NULL) { + psLogMsg(__func__,PS_LOG_ERROR, "TEST ERROR: pmFPAAlloc did not set ->fromTangentPlane to NULL."); + return 2; + } + + if (fpa->toTangentPlane != NULL) { + psLogMsg(__func__,PS_LOG_ERROR, "TEST ERROR: pmFPAAlloc did not set ->toTangentPlane to NULL."); + return 3; + } + if (fpa->projection != NULL) { + psLogMsg(__func__,PS_LOG_ERROR, "TEST ERROR: pmFPAAlloc did not set ->projection to NULL."); + return 4; + } + + if (fpa->concepts == NULL) { + psLogMsg(__func__,PS_LOG_ERROR, "TEST ERROR: pmFPAAlloc did not set ->concepts."); + return 5; + } + + if (fpa->analysis != NULL) { + psLogMsg(__func__,PS_LOG_ERROR, "TEST ERROR: pmFPAAlloc did not set ->analysis to NULL."); + return 6; + } + + if (fpa->camera != camera) { + psLogMsg(__func__,PS_LOG_ERROR, "TEST ERROR: pmFPAAlloc did not set ->camera."); + return 7; + } + + if (fpa->chips == NULL) { + psLogMsg(__func__,PS_LOG_ERROR, "TEST ERROR: pmFPAAlloc did not set ->chips."); + return 8; + } + + if (fpa->private != NULL) { + psLogMsg(__func__,PS_LOG_ERROR, "TEST ERROR: pmFPAAlloc did not set ->private to NULL."); + return 9; + } + psFree(fpa); + + // + // Populate the pmFPA struct with real data to ensure they were + // psFree()'ed correctly. + // + fpa = generateSimpleFPA(); + if (fpa == NULL) { + psLogMsg(__func__,PS_LOG_ERROR, "TEST ERROR: generateSimpleFPA() returned NULL."); + return(15); + } + psFree(fpa); + + return(0); +} + +/****************************************************************************** +generateSimpleChip(): This function generates a pmChip data structure and then +populates its members with real data. We do this to ensure that the data is +later being psFree()'ed correctly. + *****************************************************************************/ +pmChip *generateSimpleChip(pmFPA *fpa) +{ + psBool rc; + pmChip *chip = pmChipAlloc(fpa, CHIP_ALLOC_NAME); + if (chip == NULL) { + psLogMsg(__func__,PS_LOG_ERROR, "TEST ERROR: pmChipAlloc returned a NULL."); + return(NULL); + } + chip->toFPA = PS_CREATE_2D_IDENTITY_PLANE_TRANSFORM(); + chip->fromFPA = PS_CREATE_2D_IDENTITY_PLANE_TRANSFORM(); + // + // We already ensured that chip->concepts was working properly. + // + + // + // Create ->analysis metadata. + // + chip->analysis = psMetadataAlloc(); + rc = psMetadataAddS32(chip->analysis, PS_LIST_HEAD, MISC_NAME, 0, NULL, MISC_NUM); + + // + // We test the chip->cells array later. + // + + // + // How to test the p_pmHDU *private member? + // + + return(chip); +} + +static psS32 testChipAlloc(void) +{ + pmFPA* fpa = generateSimpleFPA(); + pmChip *chip = pmChipAlloc(fpa, CHIP_ALLOC_NAME); + if (chip == NULL) { + psLogMsg(__func__,PS_LOG_ERROR, "TEST ERROR: pmChipAlloc returned a NULL."); + return 1; + } + + if (chip->col0 != -1) { + psLogMsg(__func__, PS_LOG_ERROR, "TEST ERROR: chip->col0 set improperly.\n"); + return 5; + } + + if (chip->row0 != -1) { + psLogMsg(__func__, PS_LOG_ERROR, "TEST ERROR: chip->row0 set improperly.\n"); + return 6; + } + + if (chip->toFPA != NULL) { + psLogMsg(__func__, PS_LOG_ERROR, "TEST ERROR: chip->toChip set improperly.\n"); + return 7; + } + + if (chip->fromFPA != NULL) { + psLogMsg(__func__, PS_LOG_ERROR, "TEST ERROR: chip->toFPA set improperly.\n"); + return 8; + } + + if (chip->concepts == NULL) { + psLogMsg(__func__, PS_LOG_ERROR, "TEST ERROR: chip->concepts set improperly.\n"); + return 21; + } else { + psMetadataItem *tmpMeta = psMetadataLookup(chip->concepts, "CHIP.NAME"); + if (0 != strcmp((char *) tmpMeta->data.V, CHIP_ALLOC_NAME)) { + psLogMsg(__func__, PS_LOG_ERROR, "TEST ERROR: The metadata was set improperly.\n"); + return (32); + } + // XXX: Code a test to ensure the metadata has the correct type + } + + if (chip->analysis != NULL) { + psLogMsg(__func__, PS_LOG_ERROR, "TEST ERROR: chip->analysis set improperly.\n"); + return 10; + } + + if (chip->cells == NULL) { + psLogMsg(__func__, PS_LOG_ERROR, "TEST ERROR: chip->cells set improperly.\n"); + return 22; + } + + if (chip->parent != fpa) { + psLogMsg(__func__, PS_LOG_ERROR, "TEST ERROR: chip->parent set improperly.\n"); + return 23; + } + + if (chip->valid != false) { + psLogMsg(__func__, PS_LOG_ERROR, "TEST ERROR: chip->valid set improperly.\n"); + return 24; + } + + if (chip->private != NULL) { + psLogMsg(__func__, PS_LOG_ERROR, "TEST ERROR: chip->private set improperly.\n"); + return 25; + } + psFree(fpa); + + // + // Populate the pmChip struct with real data to ensure they were + // psFree()'ed correctly. + // + fpa = generateSimpleFPA(); + chip = generateSimpleChip(fpa); + psFree(fpa); + + return(0); +} + +/****************************************************************************** +generateSimpleCell(): This function generates a pmCell data structure and then +populates its members with real data. We do this to ensure that the data is +later being psFree()'ed correctly. + *****************************************************************************/ +pmCell *generateSimpleCell(pmFPA *fpa, pmChip *chip) +{ + psBool rc; + pmCell *cell = pmCellAlloc(chip, (psMetadata *) fpa->camera, CELL_ALLOC_NAME); + if (cell == NULL) { + psLogMsg(__func__,PS_LOG_ERROR, "TEST ERROR: pmCellAlloc returned a NULL."); + return(NULL); + } + cell->toChip = PS_CREATE_2D_IDENTITY_PLANE_TRANSFORM(); + cell->toFPA = PS_CREATE_2D_IDENTITY_PLANE_TRANSFORM(); + cell->toSky = PS_CREATE_2D_IDENTITY_PLANE_TRANSFORM(); + // + // We already ensured that cell->concepts was working properly. + // + + // + // Test camera metadata. + // + if (cell->camera == NULL) { + psLogMsg(__func__, PS_LOG_ERROR, "TEST ERROR: cell->camera is NULL."); + psFree(fpa); + return(NULL); + } else { + rc = psMetadataAddS32((psMetadata *) cell->camera, PS_LIST_HEAD, MISC_NAME2, 0, NULL, MISC_NUM); + if (rc == false) { + psLogMsg(__func__,PS_LOG_ERROR, "TEST ERROR: could not add metadata to cell->camera."); + psFree(fpa); + return(NULL); + } + psS32 tmpS32 = psMetadataLookupS32(&rc, cell->camera, MISC_NAME2); + if ((rc == false) || (tmpS32 != MISC_NUM)) { + psLogMsg(__func__,PS_LOG_ERROR, "TEST ERROR: could not read metadata from cell->camera."); + psFree(fpa); + return(NULL); + } + } + + // + // Create ->analysis metadata. + // + cell->analysis = psMetadataAlloc(); + rc = psMetadataAddS32(cell->analysis, PS_LIST_HEAD, MISC_NAME, 0, NULL, MISC_NUM); + + // + // We test the cell->readouts array later. + // + + // + // How to test the p_pmHDU *private member? + // + + return(cell); +} + +static psS32 testCellAlloc(void) +{ + pmFPA* fpa = generateSimpleFPA(); + pmChip *chip = pmChipAlloc(fpa, CHIP_ALLOC_NAME); + pmCell *cell = pmCellAlloc(chip, (psMetadata *) fpa->camera, CELL_ALLOC_NAME); + if (cell == NULL) { + psLogMsg(__func__,PS_LOG_ERROR, "TEST ERROR: pmCellAlloc returned a NULL.n"); + return 3; + } + + if (cell->col0 != -1) { + psLogMsg(__func__, PS_LOG_ERROR, "TEST ERROR: cell->col0 set improperly.\n"); + return 5; + } + + if (cell->row0 != -1) { + psLogMsg(__func__, PS_LOG_ERROR, "TEST ERROR: cell->row0 set improperly.\n"); + return 6; + } + + if (cell->toChip != NULL) { + psLogMsg(__func__, PS_LOG_ERROR, "TEST ERROR: cell->toChip set improperly.\n"); + return 7; + } + + if (cell->toFPA != NULL) { + psLogMsg(__func__, PS_LOG_ERROR, "TEST ERROR: cell->toFPA set improperly.\n"); + return 8; + } + + if (cell->toSky != NULL) { + psLogMsg(__func__, PS_LOG_ERROR, "TEST ERROR: cell->toSky set improperly.\n"); + return 9; + } + + if (cell->concepts == NULL) { + psLogMsg(__func__, PS_LOG_ERROR, "TEST ERROR: cell->concepts set improperly.\n"); + return 21; + } else { + psMetadataItem *tmpMeta = psMetadataLookup(cell->concepts, "CELL.NAME"); + if (0 != strcmp((char *) tmpMeta->data.V, CELL_ALLOC_NAME)) { + psLogMsg(__func__, PS_LOG_ERROR, "TEST ERROR: The metadata was set improperly.\n"); + return (32); + } + // XXX: Code a test to ensure the metadata has the correct type + } + + if (cell->camera != fpa->camera) { + psLogMsg(__func__, PS_LOG_ERROR, "TEST ERROR: cell->camera set improperly.\n"); + return 20; + } + + if (cell->analysis != NULL) { + psLogMsg(__func__, PS_LOG_ERROR, "TEST ERROR: cell->analysis set improperly.\n"); + return 10; + } + + if (cell->readouts == NULL) { + psLogMsg(__func__, PS_LOG_ERROR, "TEST ERROR: cell->readouts set improperly.\n"); + return 22; + } + + if (cell->parent != chip) { + psLogMsg(__func__, PS_LOG_ERROR, "TEST ERROR: cell->parent set improperly.\n"); + return 23; + } + + if (cell->valid != false) { + psLogMsg(__func__, PS_LOG_ERROR, "TEST ERROR: cell->valid set improperly.\n"); + return 24; + } + + if (cell->private != NULL) { + psLogMsg(__func__, PS_LOG_ERROR, "TEST ERROR: cell->private set improperly.\n"); + return 27; + } + psFree(fpa); + + // + // Populate the pmCell struct with real data to ensure they were + // psFree()'ed correctly. + // + fpa = generateSimpleFPA(); + chip = generateSimpleChip(fpa); + cell = generateSimpleCell(fpa, chip); + psFree(fpa); + + return(0); +} + +/****************************************************************************** +generateSimpleReadout(): This function generates a pmReadout data structure and then +populates its members with real data. We do this to ensure that the data is +later being psFree()'ed correctly. + *****************************************************************************/ +pmReadout *generateSimpleReadout(pmFPA *fpa, pmChip *chip, pmCell *cell) +{ + psBool rc; + pmReadout *readout = pmReadoutAlloc(cell); + if (readout == NULL) { + psLogMsg(__func__,PS_LOG_ERROR, "TEST ERROR: pmReadoutAlloc returned a NULL."); + return(NULL); + } + readout->image = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32); + readout->mask = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_U8); + readout->weight = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32); + + // + // Create a psList of bias data. + // + for (psS32 i = 0 ; i < NUM_BIAS_DATA ; i++) { + psImage *tmpImage = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32); + if (readout->bias == NULL) { + readout->bias = psListAlloc(tmpImage); + } else { + psListAdd(readout->bias, PS_LIST_HEAD, tmpImage); + } + } + + // + // Test readout->analysis metadata. + // + if (readout->analysis == NULL) { + psLogMsg(__func__, PS_LOG_ERROR, "TEST ERROR: readout->analysis is NULL."); + psFree(fpa); + return(NULL); + } else { + rc = psMetadataAddS32((psMetadata *) readout->analysis, PS_LIST_HEAD, MISC_NAME, 0, NULL, MISC_NUM); + if (rc == false) { + psLogMsg(__func__,PS_LOG_ERROR, "TEST ERROR: could not add metadata to readout->analysis."); + psFree(fpa); + return(NULL); + } + } + + return(readout); +} + + +static psS32 testReadoutAlloc(void) +{ + pmFPA* fpa = generateSimpleFPA(); + pmChip *chip = pmChipAlloc(fpa, CHIP_ALLOC_NAME); + pmCell *cell = pmCellAlloc(chip, (psMetadata *) fpa->camera, CELL_ALLOC_NAME); + pmReadout *readout = pmReadoutAlloc(cell); + if (readout == NULL) { + psLogMsg(__func__,PS_LOG_ERROR, "TEST ERROR: pmReadoutAlloc returned a NULL.\n"); + return 4; + } + + if (readout->col0 != -1) { + psLogMsg(__func__, PS_LOG_ERROR, "TEST ERROR: pmReadout->col0 set improperly.\n"); + return 5; + } + + if (readout->row0 != -1) { + psLogMsg(__func__, PS_LOG_ERROR, "TEST ERROR: pmReadout->row0 set improperly.\n"); + return 6; + } + + if (readout->colBins != -1) { + psLogMsg(__func__, PS_LOG_ERROR, "TEST ERROR: pmReadout->colBins set improperly.\n"); + return 7; + } + + if (readout->rowBins != -1) { + psLogMsg(__func__, PS_LOG_ERROR, "TEST ERROR: pmReadout->colBins set improperly.\n"); + return 8; + } + + if (readout->image != NULL) { + psLogMsg(__func__, PS_LOG_ERROR, "TEST ERROR: pmReadout->image set improperly.\n"); + return 10; + } + + if (readout->mask != NULL) { + psLogMsg(__func__, PS_LOG_ERROR, "TEST ERROR: pmReadout->mask set improperly.\n"); + return 12; + } + + if (readout->weight != NULL) { + psLogMsg(__func__, PS_LOG_ERROR, "TEST ERROR: pmReadout->weight set improperly.\n"); + return 14; + } + + if (readout->bias != NULL) { + psLogMsg(__func__, PS_LOG_ERROR, "TEST ERROR: pmReadout->bias set improperly.\n"); + return 16; + } + + if (readout->analysis == NULL) { + psLogMsg(__func__, PS_LOG_ERROR, "TEST ERROR: pmReadout->analysis set improperly.\n"); + return 18; + } + + if (readout->parent != cell) { + psLogMsg(__func__, PS_LOG_ERROR, "TEST ERROR: pmReadout->parent set improperly.\n"); + return 20; + } + psFree(fpa); + + // + // Populate the pmReadout struct with real data to ensure they were + // psFree()'ed correctly. + // + fpa = generateSimpleFPA(); + chip = generateSimpleChip(fpa); + cell = generateSimpleCell(fpa, chip); + readout = generateSimpleReadout(fpa, chip, cell); + psFree(fpa); + + return(0); +} Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/astrom/tst_pmAstrometry01.c =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/astrom/tst_pmAstrometry01.c (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/astrom/tst_pmAstrometry01.c (revision 21664) @@ -0,0 +1,670 @@ +/** @file tst_psAstrometry01.c +* +* @brief This code will test the pmFPA hierarchy transform code in psAstrometry.[ch] +* +* @author GLG, MHPCC +* +* @version $Revision: 1.3 $ $Name: not supported by cvs2svn $ +* @date $Date: 2005-12-08 00:00:57 $ +* +* XXX: Add tests were the coordinate does not transform to any legitimate cell +* or chip, or FPA, or whatever. +* +* XXX: For each function, add tests for bad input parameters, as well as failed transforms. +* +* XXX: Must test pmFPASelectChip() and pmFPAExcludeChip(). +* +* Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii +*/ +#include "config.h" +#include +#include +#include "psTest.h" +#include "pslib_strict.h" +#include "pmAstrometry.h" +static psS32 test3( void ); +static psS32 test4( void ); +static psS32 test5( void ); + +testDescription tests[] = { + {test3, -3, "pmAstrometry focal plane transformations", 0, false}, + {test4, -3, "pmCheckParents()", 0, false}, + {test5, -3, "pmFPASelectChip() and pmFPAExcludeChip()", 0, false}, + {NULL} + }; + +psS32 currentId = 0; +psS32 memLeaks = 0; +psS32 main( psS32 argc, char* argv[] ) +{ + psLogSetLevel( PS_LOG_INFO ); + psLogSetFormat("HLNM"); + + return ( ! runTestSuite( stderr, "psAstrometry", tests, argc, argv ) ); +} + +#define PS_PERCENT_COMPARE(X, Y, PERCENT_FRACTION) (fabs((Y)-(X))/fabs(X) < (PERCENT_FRACTION)) +#define VERBOSE 0 +#define NUM_READOUTS 1 +#define READOUT_NUM_ROWS 10 +#define READOUT_NUM_COLS 10 + +#define NUM_CELLS 4 +#define CELL_GAP 2 +#define CELL_WIDTH READOUT_NUM_COLS +#define CELL_HEIGHT READOUT_NUM_ROWS +#define CELL_MIN_X 0 +#define CELL_MAX_X CELL_HEIGHT +#define CELL_MIN_Y 0 +#define CELL_MAX_Y CELL_WIDTH + +#define NUM_CHIPS 2 +#define CHIP_GAP 2 +#define CHIP_MIN_X 0 +#define CHIP_MAX_X CELL_HEIGHT +#define CHIP_MIN_Y 0 +#define CHIP_MAX_Y ((NUM_CELLS * CELL_WIDTH) + ((NUM_CELLS) * CELL_GAP)) +#define CHIP_WIDTH CHIP_MAX_Y +#define CHIP_HEIGHT CHIP_MAX_X + +#define NUM_FPAS 1 +#define FPA_MIN_X 0 +#define FPA_MAX_X CHIP_HEIGHT +#define FPA_MIN_Y 0 +#define FPA_MAX_Y (((NUM_CHIPS) * CHIP_WIDTH) + (((NUM_CHIPS)-1) * CHIP_GAP)) + +#define PROJECTION_SCALE_X 1.0 +#define PROJECTION_SCALE_Y 1.0 + +psPlaneTransform *PS_CREATE_2D_IDENTITY_PLANE_TRANSFORM() +{ + psPlaneTransform *pt = psPlaneTransformAlloc(1, 1); + pt->x->coeff[1][0] = 1.0; + pt->y->coeff[0][1] = 1.0; + return(pt); +} + +psPlaneDistort *PS_CREATE_4D_IDENTITY_PLANE_DISTORT() +{ + psPlaneDistort *pd = psPlaneDistortAlloc(1, 1, 1, 1); + pd->x->coeff[1][0][0][0] = 1.0; + pd->y->coeff[0][1][0][0] = 1.0; + return(pd); +} + +/****************************************************************************** +genSystem(): This routine will create a system of FPAs/Chips/Cells/Readouts. For +simplicity, an FPA is defined as a linear array of chips, and a chip is +defined as a linear array of cells, both in the y (cols) direction. The +transforms between the various layers take into account the cell/chip and +the boundaries between each. + *****************************************************************************/ +pmFPA *genSystem() +{ + // + // Create top pmFPA structure. + // + const psMetadata *camera = psMetadataAlloc(); + pmFPA* myFPA = pmFPAAlloc(camera); + if (myFPA == NULL) { + psLogMsg(__func__,PS_LOG_ERROR, "TEST ERROR: pmFPAAlloc() returned a NULL.\n"); + return NULL; + } + myFPA->fromTangentPlane = PS_CREATE_4D_IDENTITY_PLANE_DISTORT(); + myFPA->toTangentPlane = PS_CREATE_4D_IDENTITY_PLANE_DISTORT(); + myFPA->projection = psProjectionAlloc(0.0,0.0,PROJECTION_SCALE_X,PROJECTION_SCALE_X,PS_PROJ_TAN); + + myFPA->chips = psArrayRealloc(myFPA->chips, NUM_CHIPS); + for (psS32 chipID=0 ; chipIDchips->data[chipID] = (psPtr *) myChip; + myChip->row0 = 0; + myChip->col0 = chipID * (CHIP_WIDTH + CHIP_GAP); + + // We create the transforms between the chip and FPA. The + // transform is a simple identity transform. + myChip->toFPA = PS_CREATE_2D_IDENTITY_PLANE_TRANSFORM(); + myChip->toFPA->y->coeff[0][0] = (psF64) myChip->col0; + myChip->toFPA->y->coeff[1][1] = 0.0; + myChip->toFPA->x->coeff[0][0] = (psF64) myChip->row0; + myChip->toFPA->x->coeff[1][1] = 0.0; + + myChip->fromFPA = PS_CREATE_2D_IDENTITY_PLANE_TRANSFORM(); + myChip->fromFPA->y->coeff[0][0] = (psF64) (- myChip->col0); + myChip->fromFPA->y->coeff[1][1] = 0.0; + myChip->fromFPA->x->coeff[0][0] = (psF64) (- myChip->row0); + myChip->fromFPA->x->coeff[1][1] = 0.0; + + myChip->cells = psArrayRealloc(myChip->cells, NUM_CELLS); + for (psS32 cellID=0 ; cellIDcells->data[cellID] = (psPtr *) myCell; + myCell->row0 = 0; + myCell->col0 = cellID * (CELL_WIDTH + CELL_GAP); + myCell->toChip = PS_CREATE_2D_IDENTITY_PLANE_TRANSFORM(); + myCell->toChip->y->coeff[0][0] = (psF64) myCell->col0; + myCell->toChip->y->coeff[1][1] = 0.0; + myCell->toChip->x->coeff[0][0] = (psF64) myCell->row0; + myCell->toChip->x->coeff[1][1] = 0.0; + + myCell->toFPA = PS_CREATE_2D_IDENTITY_PLANE_TRANSFORM(); + myCell->toFPA->y->coeff[0][0] = (psF64) (myCell->col0 + myChip->col0); + myCell->toFPA->y->coeff[1][1] = 0.0; + myCell->toFPA->x->coeff[0][0] = (psF64) (myCell->row0 + myChip->row0); + myCell->toFPA->x->coeff[1][1] = 0.0; + + myCell->toSky = PS_CREATE_2D_IDENTITY_PLANE_TRANSFORM(); + myCell->toSky->y->coeff[0][0] = myCell->toFPA->y->coeff[0][0]; + myCell->toSky->y->coeff[1][1] = 0.0; + myCell->toSky->x->coeff[0][0] = myCell->toFPA->x->coeff[0][0]; + myCell->toSky->x->coeff[1][1] = 0.0; + + myCell->readouts = psArrayRealloc(myCell->readouts, NUM_READOUTS); + for (psS32 readoutID=0 ; readoutIDreadouts->data[readoutID] = (psPtr *) myReadout; + myReadout->image = psImageAlloc(READOUT_NUM_COLS, READOUT_NUM_ROWS, PS_TYPE_F32); + for (psS32 row=0;rowimage->data.F32[row][col] = (psF32) ((chipID * (CHIP_WIDTH + CHIP_GAP)) + + (cellID * (CELL_WIDTH + CELL_GAP))); + } + } + myReadout->row0 = myCell->row0; + myReadout->col0 = myCell->col0; + myReadout->rowBins = 0; + myReadout->colBins = 0; + } + if (VERBOSE) { + printf("\n\n\n\nFor chip %d cell %d the cell->toFPA transform is:\n", chipID, cellID); + PS_PRINT_PLANE_TRANSFORM(myCell->toFPA); + printf("\n\n\n\nFor chip %d cell %d the cell->toChip transform is:\n", chipID, cellID); + PS_PRINT_PLANE_TRANSFORM(myCell->toChip); + printf("\n\n\n\nFor chip %d cell %d the cell->toSky transform is:\n", chipID, cellID); + PS_PRINT_PLANE_TRANSFORM(myCell->toSky); + } + } + if (VERBOSE) { + printf("\n\n\n\nFor chip %d the chip->toFPA transform is:\n", chipID); + PS_PRINT_PLANE_TRANSFORM(myChip->toFPA); + printf("\n\n\n\nFor chip %d the chip->fromFPA transform is:\n", chipID); + PS_PRINT_PLANE_TRANSFORM(myChip->fromFPA); + } + } + + return(myFPA); +} + + +/****************************************************************************** +This routine tests many Astrometry functions. It loops through all valid +pixels of all cells of all chips and computes the corresponding (x,y) +coordinates in the FPA plane. It then calls the pmChipInFPA() then +pmCellInFPA() with the FPA coordinate and determines the chip/cell that that +coordinate corresponds to. Following that it does a variety of tests on the +various functions that tharnsform coordinates within the pmFPA hierarchy. + +List of tested functions: + pmCellInFPA() yes + pmChipInFPA() yes + pmCellInChip() yes + + pmCoordCellToFPA() yes + pmCoordChipToFPA() yes + pmCoordFPAToChip() yes + pmCoordCellToChip() yes + pmCoordChipToCell() yes + + pmCoordFPAToTP() yes + pmCoordTPToFPA() yes + + pmCoordTPToSky() yes + pmCoordSkyToTP() yes + pmCoordSkyToCell() yes + pmCoordCellToSky() yes + pmCoordCellToSkyQuick() yes + pmCoordSkyToCellQuick() yes + *****************************************************************************/ +psS32 test3( void ) +{ + psS32 x; + psS32 y; + psPlane fpaCoord; + pmFPA *myFPA = genSystem(); + pmCell *myCell = NULL; + psPlane chipCoord; + psPlane cellCoord; + psPlane testCoord; + psSphere skyCoord; + psPlane tpCoord; + psS32 testStatus = 0; + + // + // I'm not convinced that the p_psProject() and p_psDeproject() functions work + // correctly. If we project a set of coordinates over a wide range of (R, D) + // values, then deproject them, the original (R, D) values are only produced + // when D is larger than 0. This code demonstrates that. I also created tests + // that currently fail in tst_psCoord01.c. I have a workaround in the function + // XXXDeproject() in pmAstrometry.c. + // + if (0) { + // This loop goes from (R, D) -> (X, Y) -> (R, D) + psPlane planeCoord01; + psSphere skyCoord01; + psSphere skyCoord02; + #define DEG_INC 15.0 + + for (psF32 R = -90.0 ; R <= 90.0 ; R+= DEG_INC) { + for (psF32 D = -90.0 ; D <= 90.0 ; D+= DEG_INC) { + if ((fabs(R) != 90.0) && (fabs(D) != 90.0)) { + skyCoord01.r = DEG_TO_RAD(R); + skyCoord01.d = DEG_TO_RAD(D); + p_psProject(&planeCoord01, &skyCoord01, myFPA->projection); + p_psDeproject(&skyCoord02, &planeCoord01, myFPA->projection); + printf("(%.2fr %.2fd) (%.2fr %.2fd) -> (%.2f %.2f) -> (%.2fr %.2fd)", R, D, + skyCoord01.r, skyCoord01.d, + planeCoord01.x, planeCoord01.y, + skyCoord02.r, skyCoord02.d); + if ((fabs(skyCoord01.r - skyCoord02.r) < FLT_EPSILON) && + (fabs(skyCoord01.d - skyCoord02.d) < FLT_EPSILON)) { + printf(": CORRECT\n"); + } else { + printf(": WRONG\n"); + } + } + } + } + psFree(myFPA); + return(0); + } + if (0) { + // This loop goes from (X, Y) -> (R, D) -> (X, Y) + #define SPACE_INC 4.0 + for(testCoord.x=-CELL_HEIGHT;testCoord.x<=CELL_HEIGHT;testCoord.x+=SPACE_INC) + { + for (testCoord.y=-CELL_WIDTH;testCoord.y<=CELL_WIDTH;testCoord.y+=SPACE_INC) { + psPlane planeCoord01; + psPlane planeCoord02; + psSphere skyCoord01; + psSphere skyCoord02; + p_psDeproject(&skyCoord01, &testCoord, myFPA->projection); + p_psProject(&planeCoord01, &skyCoord01, myFPA->projection); + p_psDeproject(&skyCoord02, &planeCoord01, myFPA->projection); + p_psProject(&planeCoord02, &skyCoord02, myFPA->projection); + printf("Plane: (%.2f %.2f) -> (%.2fr %.2fd) -> (%.2f %.2f)\n", + testCoord.x, testCoord.y, + skyCoord01.r, skyCoord01.d, + planeCoord01.x, planeCoord01.y); + /* + printf("Plane: (%.2f %.2f) -> (%.2f %.2f) -> (%.2f %.2f)\n", + testCoord.x, testCoord.y, planeCoord01.x, planeCoord01.y, + planeCoord02.x, planeCoord02.y); + printf("Sphere: (%.2f %.2f) -> (%.2f %.2f)\n", + skyCoord01.r, skyCoord01.d, skyCoord02.r, skyCoord02.d); + printf("Plane: (%.2f %.2f) -> (%.2fd %.2fr) -> (%.2f %.2f) -> (%.2fd %.2fr) -> (%.2f %.2f)\n", + testCoord.x, testCoord.y, + skyCoord01.r, skyCoord01.d, + planeCoord01.x, planeCoord01.y, + skyCoord02.r, skyCoord02.d, + planeCoord02.x, planeCoord02.y); + */ + } + } + psFree(myFPA); + return(0); + } + // + // We iterate through all cells on all chips on the fpa. We determine + // the expected fpaCcoord. + // + + for (psS32 chip=0;chippmCoordChipToCell(): x coord was %d (%f), should be %d\n", (psS32) cellCoord.x, cellCoord.x, x); + testStatus = 1; + } + if (y != (psS32) cellCoord.y) { + printf("TEST ERROR: pmCoordFPAToChip()->pmCoordChipToCell(): y coord was %d (%f), should be %d\n", (psS32) cellCoord.y, cellCoord.y, y); + testStatus = 1; + } + + pmCoordCellToChip(&testCoord, &cellCoord, myCell); + if (fabs(testCoord.x - chipCoord.x) > FLT_EPSILON) { + printf("TEST ERROR: pmCoordCellToChip() x coord was %.2f, should be %d\n", cellCoord.x, x); + testStatus = 1; + } + if (fabs(testCoord.y - chipCoord.y) > FLT_EPSILON) { + printf("TEST ERROR: pmCoordCellToChip() y coord was %.2f, should be %d\n", cellCoord.y, y); + testStatus = 1; + } + + pmCell *myCell2 = pmCellInChip(&chipCoord, tmpChip); + if (myCell2 != myCell) { + printf("TEST ERROR: pmCellInChip() != pmCellInChip(pmChipInFPA()) (%p %p)\n", myCell2, myCell); + testStatus = 1; + } + + pmCoordChipToFPA(&testCoord, &chipCoord, tmpChip); + if (fabs(testCoord.x - x) > FLT_EPSILON) { + printf("TEST ERROR: pmCoordChipToFPA() x coord was %.2f, should be %d\n", cellCoord.x, x); + testStatus = 1; + } + if (fabs(testCoord.y - fpaCoord.y) > FLT_EPSILON) { + printf("TEST ERROR: pmCoordChipToFPA() y coord was %.2f, should be %.2f\n", cellCoord.y, fpaCoord.y); + testStatus = 1; + } + + pmCoordFPAToTP(&testCoord, &fpaCoord, 0.0, 0.0, myFPA); + if (fabs(testCoord.x - fpaCoord.x) > FLT_EPSILON) { + printf("TEST ERROR: pmCoordFPAToTP() x coord was %.2f, should be %d\n", cellCoord.x, x); + testStatus = 1; + } + if (fabs(testCoord.y - fpaCoord.y) > FLT_EPSILON) { + printf("TEST ERROR: pmCoordFPAToTP() y coord was %.2f, should be %d\n", cellCoord.y, y); + testStatus = 1; + } + + // + // Test pmCoordTPToSky() -> pmCoordSkyToTP() + // + if (1) { + psSphere *rc = pmCoordTPToSky(&skyCoord, &testCoord, myFPA->projection); + if (rc == NULL) { + printf("pmCoordTPToSky() failed.\n"); + } else { + psPlane *rc = pmCoordSkyToTP(&tpCoord, &skyCoord, myFPA->projection); + if (rc == NULL) { + printf("pmCoordSkyToTP() failed.\n"); + } else { + if (fabs(testCoord.x - tpCoord.x) > FLT_EPSILON) { + printf("TEST ERROR: pmCoordTPToSky()/pmCoordSkyToTP() x coord was %.2f, should be %.2f\n", tpCoord.x, testCoord.x); + testStatus = 1; + } + if (fabs(testCoord.y - tpCoord.y) > FLT_EPSILON) { + printf("TEST ERROR: pmCoordTPToSky()/pmCoordSkyToTP() y coord was %.2f, should be %.2f\n", tpCoord.y, testCoord.y); + testStatus = 1; + } + if (VERBOSE) { + printf("(%.2f %.2f) -> (%.2f %.2f) -> (%.2f %.2f)\n", testCoord.x, testCoord.y, skyCoord.r, skyCoord.d, tpCoord.x, tpCoord.y); + } + } + } + } + + // + // Test pmCoordCellToSky() -> pmCoordSkyToCell() + // + if (1) { + psPlane tmpCellCoord; + psSphere *rc = pmCoordCellToSky(&skyCoord, &cellCoord, 0.0, 0.0, myCell); + if (rc == NULL) { + printf("pmCoordCellToSky() failed.\n"); + } else { + psPlane *rc = pmCoordSkyToCell(&tmpCellCoord, &skyCoord, 0.0, 0.0, myCell); + if (rc == NULL) { + printf("pmCoordSkyToCell() failed.\n"); + } else { + if (fabs(cellCoord.x - tmpCellCoord.x) > FLT_EPSILON) { + printf("TEST ERROR: pmCoordCellToSky()/pmCoordSkyToCell() x coord was %.2f, should be %.2f\n", tmpCellCoord.x, cellCoord.x); + testStatus = 1; + } + if (fabs(cellCoord.y - tmpCellCoord.y) > FLT_EPSILON) { + printf("TEST ERROR: pmCoordCellToSky()/pmCoordSkyToCell() y coord was %.2f, should be %.2f\n", tmpCellCoord.y, cellCoord.y); + testStatus = 1; + } + if (VERBOSE) { + printf("(%.2f %.2f) -> (%.2f %.2f) -> (%.2f %.2f)\n", testCoord.x, testCoord.y, skyCoord.r, skyCoord.d, tmpCellCoord.x, tmpCellCoord.y); + } + } + } + } + + // + // Test pmCoordCellToSkyQuick() -> pmCoordSkyToCellQuick() + // I'm not sure how to test this in a system with chip and cell gaps. + // There's no way to create an accurate polynomial transform from + // a cell to the sky where there are cell, or chip gaps. + // + if ((NUM_CHIPS == 1) && (NUM_CELLS == 1)) { + psPlane tmpCellCoord; + psSphere *rc = pmCoordCellToSkyQuick(&skyCoord, &cellCoord, myCell); + if (rc == NULL) { + printf("pmCoordCellToSkyQuick() failed.\n"); + } else { + psPlane *rc = pmCoordSkyToCellQuick(&tmpCellCoord, &skyCoord, myCell); + if (rc == NULL) { + printf("pmCoordSkyToCellQuick() failed.\n"); + } else { + if (fabs(cellCoord.x - tmpCellCoord.x) > FLT_EPSILON) { + printf("TEST ERROR: pmCoordCellToSky()/pmCoordSkyToCell() x coord was %.2f, should be %.2f\n", tmpCellCoord.x, cellCoord.x); + testStatus = 1; + } + if (fabs(cellCoord.y - tmpCellCoord.y) > FLT_EPSILON) { + printf("TEST ERROR: pmCoordCellToSky()/pmCoordSkyToCell() y coord was %.2f, should be %.2f\n", tmpCellCoord.y, cellCoord.y); + testStatus = 1; + } + if (VERBOSE) { + printf("(%.2f %.2f) -> (%.2f %.2f) -> (%.2f %.2f)\n", testCoord.x, testCoord.y, skyCoord.r, skyCoord.d, tmpCellCoord.x, tmpCellCoord.y); + } + } + } + } + + pmCoordCellToFPA(&testCoord, &cellCoord, myCell); + if (fabs(testCoord.x - fpaCoord.x) > FLT_EPSILON) { + printf("TEST ERROR: pmCoordCellToFPA() x coord was %.2f, should be %d\n", cellCoord.x, x); + testStatus = 1; + } + if (fabs(testCoord.y - fpaCoord.y) > FLT_EPSILON) { + printf("TEST ERROR: pmCoordCellToFPA() y coord was %.2f, should be %d\n", cellCoord.y, y); + testStatus = 1; + } + + pmCoordTPToFPA(&testCoord, &fpaCoord, 0.0, 0.0, myFPA); + if (fabs(testCoord.x - fpaCoord.x) > FLT_EPSILON) { + printf("TEST ERROR: pmCoordTPToFPA() x coord was %.2f, should be %d\n", cellCoord.x, x); + testStatus = 1; + } + if (fabs(testCoord.y - fpaCoord.y) > FLT_EPSILON) { + printf("TEST ERROR: pmCoordTPToFPA() y coord was %.2f, should be %d\n", cellCoord.y, y); + testStatus = 1; + } + } + } + } + } + } + psFree(myFPA); + + return(testStatus); +} + +/****************************************************************************** +test4(): This routine wil test the pmFPACheckParents() function. We generate +an pmFPA hierarchy, then set the parents of each readout/cell/chip to NULL, +then call pmFPACheckParents() to restore them, then we ensure they were +restored. + *****************************************************************************/ +psS32 test4( void ) +{ + psS32 testStatus = 0; + + // + // Generate a pmFPA hierarchy. + // + pmFPA *tmpFPA = genSystem(); + + // + // We set the parents of each readout/cell/chip to NULL. + // + for (psS32 chipID = 0; chipID < tmpFPA->chips->n ; chipID++) { + pmChip *tmpChip = (pmChip *) tmpFPA->chips->data[chipID]; + tmpChip->parent = NULL; + + for (psS32 cellID = 0; cellID < tmpChip->cells->n ; cellID++) { + pmCell *tmpCell = (pmCell *) tmpChip->cells->data[cellID]; + tmpCell->parent = NULL; + + for (psS32 readoutID = 0; readoutID < tmpCell->readouts->n ; readoutID++) { + pmReadout *tmpReadout = (pmReadout *) tmpCell->readouts->data[readoutID]; + tmpReadout->parent = NULL; + } + } + } + + // + // Ensure that pmFPACheckParents() returned FALSE. + // + psBool rc = pmFPACheckParents(tmpFPA); + if (rc != false) { + printf("TEST ERROR: pmCheckParents() returned TRUE.\n"); + testStatus = 1; + } + + // + // Ensure that the parent members are right. + // + for (psS32 chipID = 0; chipID < tmpFPA->chips->n ; chipID++) { + pmChip *tmpChip = (pmChip *) tmpFPA->chips->data[chipID]; + if (tmpChip->parent != tmpFPA) { + printf("TEST ERROR: pmCheckParents() did not restore Chip->parent.\n"); + testStatus = 2; + } + + for (psS32 cellID = 0; cellID < tmpChip->cells->n ; cellID++) { + pmCell *tmpCell = (pmCell *) tmpChip->cells->data[cellID]; + if (tmpCell->parent != tmpChip) { + printf("TEST ERROR: pmCheckParents() did not restore Cell->parent.\n"); + testStatus = 3; + } + + for (psS32 readoutID = 0; readoutID < tmpCell->readouts->n ; readoutID++) { + pmReadout *tmpReadout = (pmReadout *) tmpCell->readouts->data[readoutID]; + if (tmpReadout->parent != tmpCell) { + printf("TEST ERROR: pmCheckParents() did not restore Readout->parent.\n"); + testStatus = 4; + } + } + } + } + + psFree(tmpFPA); + return(testStatus); +} + +/****************************************************************************** +test5(): This routine wil test the pmFPASelectChip() and pmFPAExcludeChip() +functions. We generate an pmFPA hierarchy, then set the ->valid members with +those routines, then verify. + *****************************************************************************/ +psS32 test5( void ) +{ + psS32 testStatus = 0; + pmChip *tmpChip = NULL; + + // + // Generate a pmFPA hierarchy. + // + pmFPA *tmpFPA = genSystem(); + + // + // We test the ->valid member for each chip. + // + for (psS32 i = 0 ; i < tmpFPA->chips->n ; i++) { + tmpChip = (pmChip *) tmpFPA->chips->data[i]; + if ((tmpChip == NULL) || (tmpChip->valid != false)) { + printf("TEST ERROR: Could not properly generate an FPA hierarchy.\n"); + testStatus = 1; + } + } + + // + // Exclude chip number 0, include all others, then test return value + // + psS32 numChips = pmFPAExcludeChip(tmpFPA, 0); + if (numChips != (NUM_CHIPS-1)) { + printf("TEST ERROR: pmFPAExcludeChip() did not return the correct number of chips.\n"); + testStatus = 2; + } + + // + // We test the ->valid member for each chip. + // + tmpChip = (pmChip *) tmpFPA->chips->data[0]; + if (tmpChip->valid != false) { + printf("TEST ERROR: pmFPAExcludeChip() did not set the proper chip->valid to FALSE.\n"); + testStatus = 3; + } + for (psS32 i = 1 ; i < tmpFPA->chips->n ; i++) { + pmChip *tmpChip = (pmChip *) tmpFPA->chips->data[i]; + if (tmpChip->valid != true) { + printf("TEST ERROR: pmFPAExcludeChip() did not set the proper chip->valids to FALSE.\n"); + testStatus = 4; + } + } + + + // + // Include chip number 0, exclude all others, then test return value + // + psBool tmpBool = pmFPASelectChip(tmpFPA, 0); + if (tmpBool != true) { + printf("TEST ERROR: pmFPASelectChip() returned FALSE.\n"); + testStatus = 5; + } + + // + // We test the ->valid member for each chip. + // + tmpChip = (pmChip *) tmpFPA->chips->data[0]; + if (tmpChip->valid != true) { + printf("TEST ERROR: pmFPASelectChip() did not set the proper chip->valid to FALSE.\n"); + testStatus = 6; + } + for (psS32 i = 1 ; i < tmpFPA->chips->n ; i++) { + pmChip *tmpChip = (pmChip *) tmpFPA->chips->data[i]; + if (tmpChip->valid != false) { + printf("TEST ERROR: pmFPASelectChip() did not set the proper chip->valids to FALSE.\n"); + testStatus = 7; + } + } + + psFree(tmpFPA); + return(testStatus); +} Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/astrom/verified/tst_pmAstrometry.stderr =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/astrom/verified/tst_pmAstrometry.stderr (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/astrom/verified/tst_pmAstrometry.stderr (revision 21664) @@ -0,0 +1,36 @@ +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmAstrometry.c * +* TestPoint: pmAstrometry{pmFPAAlloc} * +* TestType: Positive * +\**********************************************************************************/ + + +---> TESTPOINT PASSED (pmAstrometry{pmFPAAlloc} | tst_pmAstrometry.c) + +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmAstrometry.c * +* TestPoint: pmAstrometry{pmChipAlloc} * +* TestType: Positive * +\**********************************************************************************/ + + +---> TESTPOINT PASSED (pmAstrometry{pmChipAlloc} | tst_pmAstrometry.c) + +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmAstrometry.c * +* TestPoint: pmAstrometry{pmCellAlloc} * +* TestType: Positive * +\**********************************************************************************/ + + +---> TESTPOINT PASSED (pmAstrometry{pmCellAlloc} | tst_pmAstrometry.c) + +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmAstrometry.c * +* TestPoint: pmAstrometry{pmReadoutAlloc} * +* TestType: Positive * +\**********************************************************************************/ + + +---> TESTPOINT PASSED (pmAstrometry{pmReadoutAlloc} | tst_pmAstrometry.c) + Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/camera/.cvsignore =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/camera/.cvsignore (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/camera/.cvsignore (revision 21664) @@ -0,0 +1,6 @@ +.deps +.libs +Makefile +Makefile.in +temp +tst_pmAstrometry Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/camera/Makefile.am =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/camera/Makefile.am (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/camera/Makefile.am (revision 21664) @@ -0,0 +1,16 @@ +# Makefile for psModule tests + +AM_LDFLAGS = -L$(top_builddir)/src -lpsmodule $(PSMODULE_LIBS) +AM_CFLAGS = @AM_CFLAGS@ $(PSMODULE_CFLAGS) $(SRCINC) + +TESTS = + +check_PROGRAMS = $(TESTS) + +TESTS_ENVIRONMENT = perl $(top_srcdir)/test/runTest --verified=$(srcdir)/verified + +tests: $(TESTS) + +CLEANFILES = $(TESTS) temp/* + +test: check Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/config/.cvsignore =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/config/.cvsignore (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/config/.cvsignore (revision 21664) @@ -0,0 +1,6 @@ +.deps +.libs +Makefile +Makefile.in +temp +tst_pmConfig Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/config/Makefile.am =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/config/Makefile.am (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/config/Makefile.am (revision 21664) @@ -0,0 +1,27 @@ +# Makefile for psModule tests + +AM_LDFLAGS = -L$(top_builddir)/src -lpsmodule $(PSMODULE_LIBS) +AM_CFLAGS = @AM_CFLAGS@ $(PSMODULE_CFLAGS) $(SRCINC) + +TESTS = \ + tst_pmConfig + +tst_pmConfig_SOURCES = tst_pmConfig.c + +check_PROGRAMS = $(TESTS) + +check_DATA = \ + SampleIPPConfig + +TESTS_ENVIRONMENT = perl $(top_srcdir)/test/runTest --verified=$(srcdir)/verified + +SampleIPPConfig: data/SampleIPPConfig + cp $? $@ + +tests: $(TESTS) + +EXTRA_DIST = verified data + +CLEANFILES = $(TESTS) temp/* $(check_DATA) + +test: check Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/config/data/SampleIPPConfig =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/config/data/SampleIPPConfig (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/config/data/SampleIPPConfig (revision 21664) @@ -0,0 +1,32 @@ +### Example .ipprc file + +### Database configuration +DBSERVER STR ippdb.ifa.hawaii.edu # Database host name (for psDBInit) +DBUSER STR ipp # Database user name (for psDBInit) +DBPASSWORD STR password # Database password (for psDBInit) + +### Setups for each camera system +CAMERAS METADATA + MEGACAM_RAW STR megacam_raw.config + MEGACAM_SPLICE STR megacam_splice.config + GPC1_RAW STR gpc1_raw.config + LRIS_BLUE STR lris_blue.config + LRIS_RED STR lris_red.config +END + +### psLib setup +#TIME STR /home/mithrandir/price/pan-starrs/jhroot/i686-pc-linux-gnu/etc/pslib/psTime.config # Time configuration file +LOGLEVEL S32 3 # Logging level; 3=INFO +LOGFORMAT STR HLNM # Log format +LOGDEST STR STDOUT # Log destination +TRACE METADATA # Trace levels + dummyTraceFunc01 S32 1 + dummyTraceFunc02 S32 2 +END +ARBITRARY_STRING_S32 S32 20 +ARBITRARY_STRING_F32 F32 21.0 +ARBITRARY_STRING_F64 F64 22.0 +ARBITRARY_STRING_STR STR 19.0 +ARBITRARY_STRING_BOOL_T BOOL true +ARBITRARY_STRING_BOOL_F BOOL false + Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/config/tst_pmConfig.c =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/config/tst_pmConfig.c (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/config/tst_pmConfig.c (revision 21664) @@ -0,0 +1,265 @@ +/** @file tst_pmConfig.c + * + * @brief Contains the tests for pmConfig.c: + * + * test00: This code will ... + * + * @author GLG, MHPCC + * + * @version $Revision: 1.1 $ $Name: not supported by cvs2svn $ + * @date $Date: 2005-12-05 21:41:31 $ + * + * Copyright 2004 Maui High Performance Computing Center, University of Hawaii + */ +#include "psTest.h" +#include "pslib.h" +#include "pmConfig.h" + +static int test00(void); +testDescription tests[] = { + {test00, 000, "pmConfig:", true, false}, + {NULL} + }; + +int main(int argc, char* argv[]) +{ + psLogSetFormat("HLNM"); + // + // We include the function names here in psTraceSetLevel() commands for + // debugging convenience. There is no guarantee that this list of functions + // is complete. + // + psTraceSetLevel(".", 0); + psTraceSetLevel("readConfig", 0); + psTraceSetLevel("pmConfigRead", 0); + psTraceSetLevel("pmConfigValidateCamera", 0); + psTraceSetLevel("pmConfigCameraFromHeader", 0); + psTraceSetLevel("pmConfigRecipeFromCamera", 0); + psTraceSetLevel("pmConfigDB", 0); + return !runTestSuite(stderr, "Test Point Driver", tests, argc, argv); +} + +/****************************************************************************** +test00(): Test the various allocators and deallocators. +XXX: untested: + TIME: + LOGFORMAT: tested implicitly via the stdout files. + Command line arguments for logging shall override config file defaults. + *****************************************************************************/ +int test00( void ) +{ + psTraceSetLevel(".", 0); + bool testStatus = true; + psBool rc = 0; + psString str[3]; + str[0] = "ARGS:"; + str[1] = "-site"; + str[2] = "SampleIPPConfig"; + + psMetadata *site = psMetadataAlloc(); + psMetadata *camera = psMetadataAlloc(); + psMetadata *recipe = psMetadataAlloc(); + psS32 argc = 3; + + psMetadata *nullMD = NULL; + printf("----------------------------------------------------------------\n"); + printf("Calling pmConfigRead() with NULL site pointer. Should generate ERROR, return false.\n"); + rc = pmConfigRead(NULL, &camera, &recipe, &argc, str, "RecipeName"); + if (rc == true) { + printf("TEST ERROR: pmConfigRead() returned true\n"); + testStatus = false; + } + + printf("----------------------------------------------------------------\n"); + printf("Calling pmConfigRead() with NULL *site pointer. Should generate ERROR, return false.\n"); + rc = pmConfigRead(&nullMD, &camera, &recipe, &argc, str, "RecipeName"); + if (rc == true) { + printf("TEST ERROR: pmConfigRead() returned true\n"); + testStatus = false; + } + + printf("----------------------------------------------------------------\n"); + printf("Calling pmConfigRead() with NULL camera pointer. Should generate ERROR, return false.\n"); + rc = pmConfigRead(&site, NULL, &recipe, &argc, str, "RecipeName"); + if (rc == true) { + printf("TEST ERROR: pmConfigRead() returned true\n"); + testStatus = false; + } + + printf("----------------------------------------------------------------\n"); + printf("Calling pmConfigRead() with NULL *camera pointer. Should generate ERROR, return false.\n"); + rc = pmConfigRead(&site, &nullMD, &recipe, &argc, str, "RecipeName"); + if (rc == true) { + printf("TEST ERROR: pmConfigRead() returned true\n"); + testStatus = false; + } + + printf("----------------------------------------------------------------\n"); + printf("Calling pmConfigRead() with NULL recipe pointer. Should generate ERROR, return false.\n"); + rc = pmConfigRead(&site, &camera, NULL, &argc, str, "RecipeName"); + if (rc == true) { + printf("TEST ERROR: pmConfigRead() returned true\n"); + testStatus = false; + } + + printf("----------------------------------------------------------------\n"); + printf("Calling pmConfigRead() with NULL *recipe pointer. Should generate ERROR, return false.\n"); + rc = pmConfigRead(&site, &camera, &nullMD, &argc, str, "RecipeName"); + if (rc == true) { + printf("TEST ERROR: pmConfigRead() returned true\n"); + testStatus = false; + } + + printf("----------------------------------------------------------------\n"); + printf("Calling pmConfigRead() with NULL argv pointer. Should generate ERROR, return false.\n"); + rc = pmConfigRead(&site, &camera, &recipe, &argc, NULL, "RecipeName"); + if (rc == true) { + printf("TEST ERROR: pmConfigRead() returned true\n"); + testStatus = false; + } + + printf("----------------------------------------------------------------\n"); + printf("Calling pmConfigRead() with negative argc. Should generate ERROR, return false.\n"); + psS32 tmpArgc = -1; + rc = pmConfigRead(&site, &camera, &recipe, &tmpArgc, str, "RecipeName"); + if (rc == true) { + printf("TEST ERROR: pmConfigRead() returned true\n"); + testStatus = false; + } + + printf("----------------------------------------------------------------\n"); + + rc = pmConfigRead(&site, &camera, &recipe, &argc, str, "RecipeName"); + if (rc == false) { + printf("TEST ERROR: pmPeakAlloc() returned False\n"); + testStatus = false; + } else { + // + // Ensure that the various trace and logging values are set properly + // + if (1 != psTraceGetLevel("dummyTraceFunc01")) { + printf("TEST ERROR: failed to properly set tracelevel for dummyTraceFunc01\n"); + printf(" tracelevel was %d, should be 1.\n", psTraceGetLevel("dummyTraceFunc01")); + testStatus = false; + } + + if (2 != psTraceGetLevel("dummyTraceFunc02")) { + printf("TEST ERROR: failed to properly set tracelevel for dummyTraceFunc02\n"); + printf(" tracelevel was %d, should be 2.\n", psTraceGetLevel("dummyTraceFunc02")); + testStatus = false; + } + + if (1 != psLogGetDestination()) { + printf("TEST ERROR: failed to properly set log destination.\n"); + printf(" it was %d, should be 1\n", psLogGetDestination()); + testStatus = false; + } + + if (3 != psLogGetLevel()) { + printf("TEST ERROR: failed to properly set log level.\n"); + printf(" it was %d, should be 3\n", psLogGetLevel()); + testStatus = false; + } + + // + // Test the several arbitrary config file strings. + // + psS32 tmpInt = psMetadataLookupS32(&rc, site, "ARBITRARY_STRING_S32"); + if ((rc == false) || (tmpInt != 20)) { + printf("TEST ERROR: failed to properly set metadata integer ARBITRARY_STRING_S32.\n"); + testStatus = false; + } + + psF32 tmpFloat = psMetadataLookupS32(&rc, site, "ARBITRARY_STRING_F32"); + if ((rc == false) || (tmpFloat != 21.0)) { + printf("TEST ERROR: failed to properly set metadata float ARBITRARY_STRING_F32.\n"); + testStatus = false; + } + + psF64 tmpDub = psMetadataLookupS32(&rc, site, "ARBITRARY_STRING_F64"); + if ((rc == false) || (tmpDub != 22.0)) { + printf("TEST ERROR: failed to properly set metadata double ARBITRARY_STRING_F64.\n"); + testStatus = false; + } + + psBool tmpBool; + tmpBool = psMetadataLookupS32(&rc, site, "ARBITRARY_STRING_BOOL_T"); + if ((rc == false) || (tmpBool != true)) { + printf("TEST ERROR: failed to properly set metadata double ARBITRARY_STRING_BOOL_T.\n"); + testStatus = false; + } + tmpBool = psMetadataLookupS32(&rc, site, "ARBITRARY_STRING_BOOL_F"); + if ((rc == false) || (tmpBool != false)) { + printf("TEST ERROR: failed to properly set metadata double ARBITRARY_STRING_BOOL_F.\n"); + testStatus = false; + } + + // + // Test the database camera metadata keywords. + // + psMetadata *tmpMeta = psMetadataLookupMD(&rc, site, "CAMERAS"); + if (rc == false) { + printf("TEST ERROR: failed to properly set metadata metadata CAMERAS.\n"); + testStatus = false; + } else { + psString tmpStr; + tmpStr = psMetadataLookupStr(&rc, tmpMeta, "MEGACAM_RAW"); + if ((rc == false) || (0 != strcmp(tmpStr, "megacam_raw.config"))) { + printf("TEST ERROR: failed to properly set metadata metadata CAMERAS->MEGACAM_RAW.\n"); + testStatus = false; + } + + tmpStr = psMetadataLookupStr(&rc, tmpMeta, "MEGACAM_SPLICE"); + if ((rc == false) || (0 != strcmp(tmpStr, "megacam_splice.config"))) { + printf("TEST ERROR: failed to properly set metadata metadata CAMERAS->MEGACAM_SPLICE.\n"); + testStatus = false; + } + + tmpStr = psMetadataLookupStr(&rc, tmpMeta, "GPC1_RAW"); + if ((rc == false) || (0 != strcmp(tmpStr, "gpc1_raw.config"))) { + printf("TEST ERROR: failed to properly set metadata metadata CAMERAS->GPC1_RAW.\n"); + testStatus = false; + } + + tmpStr = psMetadataLookupStr(&rc, tmpMeta, "LRIS_BLUE"); + if ((rc == false) || (0 != strcmp(tmpStr, "lris_blue.config"))) { + printf("TEST ERROR: failed to properly set metadata metadata CAMERAS->LRIS_BLUE.\n"); + testStatus = false; + } + + tmpStr = psMetadataLookupStr(&rc, tmpMeta, "LRIS_RED"); + if ((rc == false) || (0 != strcmp(tmpStr, "lris_red.config"))) { + printf("TEST ERROR: failed to properly set metadata metadata CAMERAS->LRIS_RED.\n"); + testStatus = false; + } + } + + // + // Test the database metadata keywords. This is somewhat redundant since + // we already test metadat strings. + // + psString tmpStr; + tmpStr = psMetadataLookupStr(&rc, site, "DBSERVER"); + if ((rc == false) || (0 != strcmp(tmpStr, "ippdb.ifa.hawaii.edu"))) { + printf("TEST ERROR: failed to properly set metadata string DBSERVER.\n"); + testStatus = false; + } + + tmpStr = psMetadataLookupStr(&rc, site, "DBUSER"); + if ((rc == false) || (0 != strcmp(tmpStr, "ipp"))) { + printf("TEST ERROR: failed to properly set metadata string DBUSER.\n"); + testStatus = false; + } + + tmpStr = psMetadataLookupStr(&rc, site, "DBPASSWORD"); + if ((rc == false) || (0 != strcmp(tmpStr, "password"))) { + printf("TEST ERROR: failed to properly set metadata string DBPASSWORD.\n"); + testStatus = false; + } + } + + psFree(site); + psFree(camera); + psFree(recipe); + return(testStatus); +} Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/config/verified/tst_pmConfig.stderr =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/config/verified/tst_pmConfig.stderr (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/config/verified/tst_pmConfig.stderr (revision 21664) @@ -0,0 +1,27 @@ +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmConfig.c * +* TestPoint: Test Point Driver{pmConfig:} * +* TestType: Positive * +\**********************************************************************************/ + +|E|pmConfigRead (FILE:LINENO) + Unallowable operation: site is NULL. +|E|pmConfigRead (FILE:LINENO) + Unallowable operation: *site is NULL. +|E|pmConfigRead (FILE:LINENO) + Unallowable operation: camera is NULL. +|E|pmConfigRead (FILE:LINENO) + Unallowable operation: *camera is NULL. +|E|pmConfigRead (FILE:LINENO) + Unallowable operation: recipe is NULL. +|E|pmConfigRead (FILE:LINENO) + Unallowable operation: *recipe is NULL. +|E|pmConfigRead (FILE:LINENO) + Unallowable operation: argv is NULL. +|E|pmConfigRead (FILE:LINENO) + Error: *argc is 0 or less. +|I|readConfig + Loading site configuration from file SampleIPPConfig + +---> TESTPOINT PASSED (Test Point Driver{pmConfig:} | tst_pmConfig.c) + Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/config/verified/tst_pmConfig.stdout =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/config/verified/tst_pmConfig.stdout (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/config/verified/tst_pmConfig.stdout (revision 21664) @@ -0,0 +1,17 @@ +---------------------------------------------------------------- +Calling pmConfigRead() with NULL site pointer. Should generate ERROR, return false. +---------------------------------------------------------------- +Calling pmConfigRead() with NULL *site pointer. Should generate ERROR, return false. +---------------------------------------------------------------- +Calling pmConfigRead() with NULL camera pointer. Should generate ERROR, return false. +---------------------------------------------------------------- +Calling pmConfigRead() with NULL *camera pointer. Should generate ERROR, return false. +---------------------------------------------------------------- +Calling pmConfigRead() with NULL recipe pointer. Should generate ERROR, return false. +---------------------------------------------------------------- +Calling pmConfigRead() with NULL *recipe pointer. Should generate ERROR, return false. +---------------------------------------------------------------- +Calling pmConfigRead() with NULL argv pointer. Should generate ERROR, return false. +---------------------------------------------------------------- +Calling pmConfigRead() with negative argc. Should generate ERROR, return false. +---------------------------------------------------------------- Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/detrend/.cvsignore =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/detrend/.cvsignore (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/detrend/.cvsignore (revision 21664) @@ -0,0 +1,9 @@ +.deps +.libs +Makefile +Makefile.in +temp +tst_pmFlatField +tst_pmMaskBadPixels +tst_pmNonLinear +.tmp_tst_pmNonLinearLookupFile Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/detrend/Makefile.am =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/detrend/Makefile.am (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/detrend/Makefile.am (revision 21664) @@ -0,0 +1,27 @@ +# Makefile for psModule tests + +AM_LDFLAGS = -L$(top_builddir)/src -lpsmodule $(PSMODULE_LIBS) +AM_CFLAGS = @AM_CFLAGS@ $(PSMODULE_CFLAGS) $(SRCINC) +AM_CPPFLAGS = $(SRCINC) $(PSLIB_CFLAGS) + +TESTS = \ + tst_pmFlatField \ + tst_pmMaskBadPixels \ + tst_pmNonLinear + +tst_pmFlatField_SOURCES = tst_pmFlatField.c +tst_pmMaskBadPixels_SOURCES = tst_pmMaskBadPixels.c +tst_pmNonLinear_SOURCES = tst_pmNonLinear.c + +check_PROGRAMS = $(TESTS) + +TESTS_ENVIRONMENT = perl $(top_srcdir)/test/runTest --verified=$(srcdir)/verified + +tests: $(TESTS) + +EXTRA_DIST = verified + +CLEANFILES = $(TESTS) temp/* .tmp_tst_pmNonLinearLookupFile + + +test: check Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/detrend/tst_pmFlatField.c =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/detrend/tst_pmFlatField.c (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/detrend/tst_pmFlatField.c (revision 21664) @@ -0,0 +1,290 @@ +/** @file tst_pmFlatField.c + * + * @brief Contains the tests for pmFlatField.c: + * + * Test A - Divide input image by flat image + * Test B - Mask flat image data + * Test C - Mask flat image data starting with non-null mask + * Test E - Attempt to use null input image + * Test F - Attempt tp use null flat image + * Test G - Attempt to use input image bigger than flat image + * Test H - Attempt to use input image mask bigger than flat image + * Test I - Attempt to use offset greater than input image + * Test J - Attempt to use complex input image + * Test K - Attempt to use complex flat image + * Test L - Attempt to use non-equal input and flat image types + * Test M - Attempt to use non-mask type mask image + * + * XXX: Added a mask argument to pmFlatField(). Must add tests. For now, all + * masks are NULL. + * + * @author Ross Harman, MHPCC + * + * XXX: I added the CELL.TRIMSEC region code but there are not tests for it. + * + * @version $Revision: 1.3 $ $Name: not supported by cvs2svn $ + * @date $Date: 2005-11-15 20:09:03 $ + * + * Copyright 2004 Maui High Performance Computing Center, University of Hawaii + */ + + +#include "psTest.h" +#include "pslib.h" +#include "pmFlatField.h" + + +#define PRINT_MATRIX(IMAGE,TYPE,STRING) \ +printf(STRING); \ +printf("\n"); \ +for(int i=IMAGE->numRows-1; i>-1; i--) { \ + for(int j=0; jnumCols; j++) { \ + if(PS_IS_PSELEMTYPE_COMPLEX(IMAGE->type.type)) { \ + printf("%f+%fi ", creal(IMAGE->data.TYPE[i][j]), cimag(IMAGE->data.TYPE[i][j])); \ + } else if(PS_IS_PSELEMTYPE_INT(IMAGE->type.type)) { \ + printf("%d ", (int)IMAGE->data.TYPE[i][j]); \ + } else { \ + printf("%f ", (double)IMAGE->data.TYPE[i][j]); \ + } \ + } \ + printf("\n"); \ +} \ +printf("\n"); + + +#define CREATE_AND_SET_IMAGE(NAME,TYPE,VALUE,NROWS,NCOLS) \ +psImage *NAME = (psImage*)psImageAlloc(NCOLS,NROWS,PS_TYPE_##TYPE); \ +for(int i=0; inumRows; i++) { \ + for(int j=0; jnumCols; j++) { \ + NAME->data.TYPE[i][j] = VALUE; \ + } \ +} + + +static int testFlatField(void); + + +testDescription tests[] = { + {testFlatField, 753, "pmFlatField", 0, false}, + {NULL} + }; + + +int main(int argc, char* argv[]) +{ + psLogSetFormat("HLNM"); + return !runTestSuite(stderr, "Test Point Driver", tests, argc, argv); +} + + +int testFlatField( void ) +{ + // Test A - Divide input image by flat image + printPositiveTestHeader(stdout, "pmFlatField", "Test A - Divide input image by flat image"); + CREATE_AND_SET_IMAGE(inImage,F64,6.0,3,3) + pmReadout *inReadout = pmReadoutAlloc(NULL); + inReadout->image = inImage; + inReadout->row0 = 0; + inReadout->col0 = 0; + CREATE_AND_SET_IMAGE(inMask, U8, 0, 3,3); + inReadout->mask = inMask; + PRINT_MATRIX((inReadout->mask),U8,"Input mask:"); + PRINT_MATRIX(inImage,F64,"Input image:"); + + CREATE_AND_SET_IMAGE(flatImage1,F64,2.0,3,3) + pmReadout *flatReadout = pmReadoutAlloc(NULL); + flatReadout->row0 = 0; + flatReadout->col0 = 0; + flatReadout->image = flatImage1; + PRINT_MATRIX(flatImage1,F64,"Flat image:"); + + if ( !pmFlatField(inReadout, flatReadout) ) { + psError(PS_ERR_UNKNOWN,true,"Test A - Returned false should be true"); + return 1; + } + PRINT_MATRIX(inImage,F64, "Resulting image:"); + printFooter(stdout, "pmFlatField", "Test A - Divide input image by flat image", true); + printf("\n\n\n"); + + + // Test B - Mask flat image data + printPositiveTestHeader(stdout, "pmFlatField", "Test B - Mask flat image data"); + PRINT_MATRIX(inImage, F64, "Input image:"); + CREATE_AND_SET_IMAGE(flatImage2,F64,0.0,3,3) + PRINT_MATRIX(flatImage2, F64, "Flat image:"); + flatReadout->image = flatImage2; + if ( !pmFlatField(inReadout, flatReadout) ) { + psError(PS_ERR_UNKNOWN,true,"Test B - Returned false should be true"); + return 2; + } + PRINT_MATRIX(inReadout->mask, PS_TYPE_MASK_DATA, "Resulting mask:"); + PRINT_MATRIX(inImage,F64,"Resulting image:"); + printFooter(stdout, "pmFlatField", "Test B - Mask flat image data", true); + printf("\n\n\n"); + + + // Test C - Mask flat image data starting with non-null mask + printPositiveTestHeader(stdout, "pmFlatField", "Test C - Mask flat image data starting with non-null mask"); + PRINT_MATRIX(inImage, F64, "Input image:"); + flatImage2->data.F64[0][0] = 3.0; + flatImage2->data.F64[0][1] = -3.0; + PRINT_MATRIX(flatImage2, F64, "Flat image:"); + CREATE_AND_SET_IMAGE(mask1,U8,0,3,3); + psFree(inReadout->mask); + inReadout->mask = mask1; + if ( !pmFlatField(inReadout, flatReadout) ) { + psError(PS_ERR_UNKNOWN,true,"Test C - Returned false should be true"); + return 3; + } + PRINT_MATRIX(flatImage2, F64, "Flat image out:"); + PRINT_MATRIX(inReadout->mask, PS_TYPE_MASK_DATA,"Resulting mask:"); + PRINT_MATRIX(inImage,F64,"Resulting image:"); + printFooter(stdout, "pmFlatField", "Test C - Mask flat image data starting with non-null mask", true); + printf("\n\n\n"); + + + // Test D - Attempt to use null flat readout + printNegativeTestHeader(stdout,"pmFlatField", "Test D - Attempt to use null flat readout", + "Null not allowed for flat readout", 0); + if( pmFlatField(inReadout, NULL) ) { + psError(PS_ERR_UNKNOWN,true,"Test D - Returned true should be false"); + return 4; + } + printFooter(stdout, "pmFlatField", "Test D - Attempt to use null flat readout", true); + printf("\n\n\n"); + + + // Test E - Attempt to use null input image + printNegativeTestHeader(stdout,"pmFlatField", "Test E - Attempt to use null input image", + "Null not allowed for input image", 0); + psImage *temp = inReadout->image; + inReadout->image = NULL; + if ( pmFlatField(inReadout, flatReadout) ) { + psError(PS_ERR_UNKNOWN,true,"Test E - Returned true should be false" ); + return 5; + } + inReadout->image = temp ; + printFooter(stdout, "pmFlatField", "Test E - Attempt to use null input image", true); + printf("\n\n\n"); + + + // Test F - Attempt tp use null flat image + printNegativeTestHeader(stdout,"pmFlatField", "Test F - Attempt tp use null flat image", + "Null not allowed for flat image", 0); + temp = flatReadout->image; + flatReadout->image = NULL; + if ( pmFlatField(inReadout, flatReadout) ) { + psError(PS_ERR_UNKNOWN,true,"Test F - Returned true should be false" ); + return 6; + } + flatReadout->image = temp; + printFooter(stdout, "pmFlatField", "Test F - Attempt tp use null flat image", true); + printf("\n\n\n"); + + + // Test G - Attempt to use input image bigger than flat image + printNegativeTestHeader(stdout,"pmFlatField", "Test G - Attempt to use input image bigger than flat image", + "Input image size exceeds that of flat image", 0); + CREATE_AND_SET_IMAGE(smallFlat,F64,0.0,2,2); + temp = flatReadout->image; + flatReadout->image = smallFlat; + if ( pmFlatField(inReadout, flatReadout) ) { + psError(PS_ERR_UNKNOWN,true,"Test G - Returned true should be false"); + return 7; + } + flatReadout->image = temp; + printFooter(stdout, "pmFlatField", "Test G - Attempt to use input image bigger than flat image", true); + printf("\n\n\n"); + + // Test H - Attempt to use input image mask bigger than flat image + printNegativeTestHeader(stdout,"pmFlatField", "Test H - Attempt to use input image mask bigger than flat image", + "Input image mask size exceeds that of flat image", 0); + CREATE_AND_SET_IMAGE(largeMask,F64,0.0,5,5); + inReadout->mask = largeMask; + if ( pmFlatField(inReadout, flatReadout) ) { + psError(PS_ERR_UNKNOWN,true,"Test H - Returned true should be false"); + return 8; + } + printFooter(stdout, "pmFlatField", "Test H - Attempt to use input image mask bigger than flat image", true); + printf("\n\n\n"); + inReadout->mask = mask1; + + // Test I - Attempt to use offset greater than input image + printNegativeTestHeader(stdout,"pmFlatField", "Test I - Attempt to use offset greater than input image", + "Total offset >= input image size", 0); + *(int*)&inReadout->col0 = 50; + *(int*)&inReadout->row0 = 50; + if ( pmFlatField(inReadout, flatReadout) ) { + psError(PS_ERR_UNKNOWN,true,"Test I - Returned true should be false"); + return 9; + } + *(int*)&inReadout->col0 = 0; + *(int*)&inReadout->row0 = 0; + printFooter(stdout, "pmFlatField", "Test I - Attempt to use offset greater than input image", true); + printf("\n\n\n"); + + + // Test J - Attempt to use complex input image + printNegativeTestHeader(stdout,"pmFlatField", "Test J - Attempt to use complex input image", + "Complex types not allowed for input image", 0); + *(psElemType* ) & inReadout->image->type.type = PS_TYPE_C64; + if ( pmFlatField(inReadout, flatReadout) ) { + psError(PS_ERR_UNKNOWN,true,"Test J - Returned true should be false"); + return 10; + } + *(psElemType* ) & inReadout->image->type.type = PS_TYPE_F64; + printFooter(stdout, "pmFlatField", "Test J - Attempt to use complex input image", true); + printf("\n\n\n"); + + + // Test K - Attempt to use complex flat image + printNegativeTestHeader(stdout,"pmFlatField", "Test K - Attempt to use complex flat image", + "Complex types not allowed for flat image", 0); + *(psElemType* ) & flatReadout->image->type.type = PS_TYPE_C64; + if ( pmFlatField(inReadout, flatReadout) ) { + psError(PS_ERR_UNKNOWN,true,"Test K - Returned ture should be false"); + return 11; + } + *(psElemType* ) & flatReadout->image->type.type = PS_TYPE_F64; + printFooter(stdout, "pmFlatField", "Test K - Attempt to use complex flat image", true); + printf("\n\n\n"); + + + // Test L - Attempt to use non-equal input and flat image types + printNegativeTestHeader(stdout,"pmFlatField", "Test L - Attempt to use non-equal input and flat image types", + "Input and flat image types differ", 0); + *(psElemType* ) & flatReadout->image->type.type = PS_TYPE_F32; + if ( pmFlatField(inReadout, flatReadout) ) { + psError(PS_ERR_UNKNOWN,true,"Test L - Returned true should be false"); + return 12; + } + *(psElemType* ) & flatReadout->image->type.type = PS_TYPE_F64; + printFooter(stdout, "pmFlatField", "Test L - Attempt to use non-equal input and flat image types", true); + printf("\n\n\n"); + + + // Test M - Attempt to use non-mask type mask image + printNegativeTestHeader(stdout,"pmFlatField", "Test M - Attempt to use non-mask type mask image", + "Mask must be PS_TYPE_MASK type", 0); + *(psElemType* ) & inReadout->mask->type.type = PS_TYPE_F32; + if ( pmFlatField(inReadout, flatReadout) ) { + psError(PS_ERR_UNKNOWN,true,"Test M - Returned true should be false"); + return 13; + } + *(psElemType* ) & inReadout->mask->type.type = PS_TYPE_MASK; + printFooter(stdout, "pmFlatField", "Test M - Attempt to use non-mask type mask image", true); + printf("\n\n\n"); + + + // Free memory + psFree(inReadout); + psFree(flatReadout); + //psFree(inImage); + psFree(flatImage1); + //psFree(flatImage1); + psFree(smallFlat); + psFree(largeMask); + + return 0; +} + Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/detrend/tst_pmMaskBadPixels.c =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/detrend/tst_pmMaskBadPixels.c (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/detrend/tst_pmMaskBadPixels.c (revision 21664) @@ -0,0 +1,381 @@ +/** @file tst_pmMaskBadPixels.c + * + * @brief Contains the tests for pmMaskBadPixels: + * + * Test A - Create mask based on maskVal argument + * Test B - Create mask based on saturation argument + * Test C - Create mask based on growVal and grow arguments + * Test D - Auto Create mask based on maskVal argument + * Test E - Attempt to use null mask + * Test F - Attempt tp use null input image + * Test G - Attempt to use input image bigger than mask + * Test H - Attempt to use input image mask bigger than mask + * Test I - Attempt to use offset greater than input image + * Test J - Attempt to use complex input image + * Test K - Attempt to use non-mask type mask image + * + * @author Ross Harman, MHPCC + * + * @version $Revision: 1.2 $ $Name: not supported by cvs2svn $ + * @date $Date: 2005-11-15 20:09:03 $ + * + * Copyright 2004 Maui High Performance Computing Center, University of Hawaii + */ + + +#include "psTest.h" +#include "pslib.h" +#include "pmMaskBadPixels.h" + + +#define PRINT_MATRIX(IMAGE,TYPE,STRING) \ +printf(STRING); \ +printf("\n"); \ +for(int i=(IMAGE)->numRows-1; i>-1; i--) { \ + for(int j=0; j<(IMAGE)->numCols; j++) { \ + if(PS_IS_PSELEMTYPE_COMPLEX((IMAGE)->type.type)) { \ + printf("%f+%fi ", creal((IMAGE)->data.TYPE[i][j]), cimag((IMAGE)->data.TYPE[i][j])); \ + } else if(PS_IS_PSELEMTYPE_INT((IMAGE)->type.type)) { \ + printf("%d", (int)(IMAGE)->data.TYPE[i][j]); \ + } else { \ + printf("%f", (double)(IMAGE)->data.TYPE[i][j]); \ + } \ + } \ + printf("\n"); \ +} \ +printf("\n"); + + +#define CREATE_AND_SET_IMAGE(NAME,TYPE,VALUE,NROWS,NCOLS) \ +(NAME) = (psImage*)psImageAlloc(NCOLS,NROWS,PS_TYPE_##TYPE); \ +for(int i=0; i<(NAME)->numRows; i++) { \ + for(int j=0; j<(NAME)->numCols; j++) { \ + (NAME)->data.TYPE[i][j] = VALUE; \ + } \ +} + +static int testMaskBadPixels1(void); +static int testMaskBadPixels2(void); +static int testMaskBadPixels3(void); +static int testMaskBadPixels4(void); +static int testMaskBadPixels5(void); +static int testMaskBadPixels6(void); +static int testMaskBadPixels7(void); +static int testMaskBadPixels8(void); +static int testMaskBadPixels9(void); +static int testMaskBadPixels10(void); +static int testMaskBadPixels11(void); + + +testDescription tests[] = { + {testMaskBadPixels1, 885, "pmMaskBadPixels - Create mask based on maskVal argument", 0, false}, + {testMaskBadPixels2, 885, "pmMaskBadPixels - Create mask based on saturation argument", 0, false}, + {testMaskBadPixels3, 885, "pmMaskBadPixels - Create mask based on growVal and grow arguments", 0, false}, + {testMaskBadPixels4, 885, "pmMaskBadPixels - Auto create mask based on maskVal argument", 0, false}, + {testMaskBadPixels5, 885, "pmMaskBadPixels - Attempt to use null mask", 0, false}, + {testMaskBadPixels6, 885, "pmMaskBadPixels - Attempt tp use null input image", 0, false}, + {testMaskBadPixels7, 885, "pmMaskBadPixels - Attempt to use input image bigger than mask", 0, false}, + {testMaskBadPixels8, 885, "pmMaskBadPixels - Attempt to use input image mask bigger than mask", 0, false}, + {testMaskBadPixels9, 885, "pmMaskBadPixels - Attempt to use offset greater than input image", 0, false}, + {testMaskBadPixels10, 885, "pmMaskBadPixels - Attempt to use complex input image", 0, false}, + {testMaskBadPixels11, 885, "pmMaskBadPixels - Attempt to use non-mask type mask image", 0, false }, + {NULL} + }; + +/* + #define PS_TYPE_MASK PS_TYPE_U8 + #define PS_TYPE_MASK_DATA U8 + #define PS_TYPE_MASK_NAME "psU8" +*/ + +int main(int argc, char* argv[]) +{ + psLogSetFormat("HLNM"); + return !runTestSuite(stderr, "Test Point Driver", tests, argc, argv); +} + + +#define NUM_ROWS 50 +#define NUM_COLS 50 +#define DEFAULT_IMAGE_VAL 0.0 +#define DEFAULT_MASK_VAL 0 +#define MASK_VAL 1 +#define SAT_VAL 100.0 +#define GROW_VAL 1 +#define GROW_RAD 10 +int testMaskBadPixels1( void ) +{ + // + // Test A - Create mask based on maskVal argument + // + + pmReadout *inReadout = pmReadoutAlloc(NULL); + CREATE_AND_SET_IMAGE(inReadout->image, F32, DEFAULT_IMAGE_VAL, NUM_ROWS, NUM_COLS); + inReadout->image->row0 = 0; + inReadout->image->col0 = 0; + inReadout->row0 = 0; + inReadout->col0 = 0; + + pmReadout *maskReadout = pmReadoutAlloc(NULL); + CREATE_AND_SET_IMAGE(maskReadout->image, U8, DEFAULT_MASK_VAL, NUM_ROWS, NUM_COLS) + maskReadout->image->data.PS_TYPE_MASK_DATA[NUM_ROWS/2][NUM_COLS/2]=1; + maskReadout->image->row0 = 0; + maskReadout->image->col0 = 0; + + PRINT_MATRIX(maskReadout->image, U8, "Data mask:"); + + pmMaskBadPixels(inReadout, maskReadout, MASK_VAL, SAT_VAL, GROW_VAL, GROW_RAD); + PRINT_MATRIX(inReadout->mask, PS_TYPE_MASK_DATA, "Resulting mask:"); + + psFree(inReadout); + psFree(maskReadout); + + return 0; +} + +int testMaskBadPixels2( void ) +{ + // + // Test B - Create mask based on saturation argument + // + + pmReadout *inReadout = pmReadoutAlloc(NULL); + CREATE_AND_SET_IMAGE(inReadout->image, F32, DEFAULT_IMAGE_VAL, NUM_ROWS, NUM_COLS); + inReadout->image->row0 = 0; + inReadout->image->col0 = 0; + inReadout->row0 = 0; + inReadout->col0 = 0; + inReadout->image->data.F32[NUM_ROWS/2][NUM_COLS/2] = 150.0; + + pmReadout *maskReadout = pmReadoutAlloc(NULL); + CREATE_AND_SET_IMAGE(maskReadout->image, U8, DEFAULT_MASK_VAL, NUM_ROWS, NUM_COLS) + + //PS_IMAGE_PRINT_F32(inReadout->image); + PRINT_MATRIX(maskReadout->image, U8, "Data mask:"); + pmMaskBadPixels(inReadout, maskReadout, MASK_VAL, SAT_VAL, GROW_VAL, GROW_RAD); + PRINT_MATRIX(inReadout->mask, U8, "Resulting mask:"); + + psFree(inReadout); + psFree(maskReadout); + + return 0; +} + +int testMaskBadPixels3( void ) +{ + // + // Test C - Create mask based on growVal and grow arguments + // + + pmReadout *inReadout = pmReadoutAlloc(NULL); + CREATE_AND_SET_IMAGE(inReadout->image, F32, DEFAULT_IMAGE_VAL, NUM_ROWS, NUM_COLS); + inReadout->image->row0 = 0; + inReadout->image->col0 = 0; + inReadout->row0 = 0; + inReadout->col0 = 0; + inReadout->image->data.F32[NUM_ROWS/2][NUM_COLS/2]=GROW_VAL; + inReadout->image->data.F32[NUM_ROWS/4][NUM_COLS/4]=GROW_VAL; + inReadout->image->data.F32[NUM_ROWS/4][NUM_COLS-(NUM_COLS/4)]=GROW_VAL; + + pmReadout *maskReadout = pmReadoutAlloc(NULL); + CREATE_AND_SET_IMAGE(maskReadout->image, U8, DEFAULT_MASK_VAL, NUM_ROWS, NUM_COLS); + + PRINT_MATRIX(maskReadout->image, U8, "Data mask:"); + //PS_IMAGE_PRINT_F32(inReadout->image); + pmMaskBadPixels(inReadout, maskReadout, MASK_VAL, SAT_VAL, GROW_VAL, GROW_RAD); + PRINT_MATRIX(inReadout->mask, U8, "Resulting mask:"); + + psFree(inReadout); + psFree(maskReadout); + + return 0; +} + +int testMaskBadPixels4( void ) +{ + // + // Test D - Auto Create mask based on maskVal argument + // + + pmReadout *inReadout = pmReadoutAlloc(NULL); + CREATE_AND_SET_IMAGE(inReadout->image, F32, DEFAULT_IMAGE_VAL, NUM_ROWS, NUM_COLS); + inReadout->image->row0 = 0; + inReadout->image->col0 = 0; + inReadout->row0 = 0; + inReadout->col0 = 0; + + pmReadout *maskReadout = pmReadoutAlloc(NULL); + CREATE_AND_SET_IMAGE(maskReadout->image, U8, DEFAULT_MASK_VAL, NUM_ROWS, NUM_COLS) + maskReadout->image->data.PS_TYPE_MASK_DATA[NUM_ROWS/2][NUM_COLS/2]=1; + + PRINT_MATRIX(maskReadout->image, U8, "Data mask:"); + pmMaskBadPixels(inReadout, maskReadout, MASK_VAL, SAT_VAL, GROW_VAL, GROW_RAD); + PRINT_MATRIX(inReadout->mask, U8, "Resulting mask:"); + + psFree(inReadout); + psFree(maskReadout); + + return 0; +} + +int testMaskBadPixels5( void ) +{ + // + // Test E - Attempt to use null mask + // + + pmReadout *inReadout = pmReadoutAlloc(NULL); + CREATE_AND_SET_IMAGE(inReadout->image, F32, DEFAULT_IMAGE_VAL, NUM_ROWS, NUM_COLS); + inReadout->image->row0 = 0; + inReadout->image->col0 = 0; + inReadout->row0 = 0; + inReadout->col0 = 0; + + pmMaskBadPixels(inReadout, NULL, MASK_VAL, SAT_VAL, GROW_VAL, GROW_RAD); + psFree(inReadout); + + return 0; +} + +int testMaskBadPixels6( void ) +{ + // + // Test F - Attempt tp use null input image + // + + pmReadout *inReadout = pmReadoutAlloc(NULL); + inReadout->row0 = 0; + inReadout->col0 = 0; + + pmReadout *maskReadout = pmReadoutAlloc(NULL); + CREATE_AND_SET_IMAGE(maskReadout->image, U8, DEFAULT_MASK_VAL, NUM_ROWS, NUM_COLS) + + pmMaskBadPixels(inReadout, maskReadout, MASK_VAL, SAT_VAL, GROW_VAL, GROW_RAD); + + psFree(inReadout); + psFree(maskReadout); + + return 0; +} + +int testMaskBadPixels7( void ) +{ + // + // Test G - Attempt to use input image bigger than mask + // + + pmReadout *inReadout = pmReadoutAlloc(NULL); + CREATE_AND_SET_IMAGE(inReadout->image, F32, DEFAULT_IMAGE_VAL, NUM_ROWS+10, NUM_COLS+10); + inReadout->image->row0 = 0; + inReadout->image->col0 = 0; + inReadout->row0 = 0; + inReadout->col0 = 0; + + pmReadout *maskReadout = pmReadoutAlloc(NULL); + CREATE_AND_SET_IMAGE(maskReadout->image, U8, DEFAULT_MASK_VAL, NUM_ROWS, NUM_COLS) + + pmMaskBadPixels(inReadout, maskReadout, MASK_VAL, SAT_VAL, GROW_VAL, GROW_RAD); + + psFree(inReadout); + psFree(maskReadout); + + return 0; +} + +int testMaskBadPixels8( void ) +{ + // + // Test H - Attempt to use mask bigger than image + // + + pmReadout *inReadout = pmReadoutAlloc(NULL); + CREATE_AND_SET_IMAGE(inReadout->image, F32, DEFAULT_IMAGE_VAL, NUM_ROWS, NUM_COLS); + inReadout->image->row0 = 0; + inReadout->image->col0 = 0; + inReadout->row0 = 0; + inReadout->col0 = 0; + + pmReadout *maskReadout = pmReadoutAlloc(NULL); + CREATE_AND_SET_IMAGE(maskReadout->image, U8, DEFAULT_MASK_VAL, NUM_ROWS+10, NUM_COLS+10) + + pmMaskBadPixels(inReadout, maskReadout, MASK_VAL, SAT_VAL, GROW_VAL, GROW_RAD); + + psFree(inReadout); + psFree(maskReadout); + + return 0; +} + +int testMaskBadPixels9( void ) +{ + // + // Test I - Attempt to use offset greater than input image + // + + pmReadout *inReadout = pmReadoutAlloc(NULL); + CREATE_AND_SET_IMAGE(inReadout->image, F32, DEFAULT_IMAGE_VAL, NUM_ROWS, NUM_COLS); + inReadout->image->row0 = 0; + inReadout->image->col0 = 0; + inReadout->row0 = 0; + inReadout->col0 = 0; + *(int*)&inReadout->image->col0 = 150; + *(int*)&inReadout->image->row0 = 150; + + pmReadout *maskReadout = pmReadoutAlloc(NULL); + CREATE_AND_SET_IMAGE(maskReadout->image, U8, DEFAULT_MASK_VAL, NUM_ROWS, NUM_COLS) + pmMaskBadPixels(inReadout, maskReadout, MASK_VAL, SAT_VAL, GROW_VAL, GROW_RAD); + + psFree(inReadout); + psFree(maskReadout); + + return 0; +} + +int testMaskBadPixels10( void ) +{ + // + // Test J - Attempt to use complex input image + // + + pmReadout *inReadout = pmReadoutAlloc(NULL); + CREATE_AND_SET_IMAGE(inReadout->image, C64, DEFAULT_IMAGE_VAL, NUM_ROWS, NUM_COLS); + inReadout->image->row0 = 0; + inReadout->image->col0 = 0; + inReadout->row0 = 0; + inReadout->col0 = 0; + + pmReadout *maskReadout = pmReadoutAlloc(NULL); + CREATE_AND_SET_IMAGE(maskReadout->image, U8, DEFAULT_MASK_VAL, NUM_ROWS, NUM_COLS) + + pmMaskBadPixels(inReadout, maskReadout, MASK_VAL, SAT_VAL, GROW_VAL, GROW_RAD); + + psFree(inReadout); + psFree(maskReadout); + + return 0; +} + +int testMaskBadPixels11( void ) +{ + // + // Test K - Attempt to use mask image with wrong data type. + // + + pmReadout *inReadout = pmReadoutAlloc(NULL); + CREATE_AND_SET_IMAGE(inReadout->image, F32, DEFAULT_IMAGE_VAL, NUM_ROWS, NUM_COLS); + inReadout->image->row0 = 0; + inReadout->image->col0 = 0; + inReadout->row0 = 0; + inReadout->col0 = 0; + + pmReadout *maskReadout = pmReadoutAlloc(NULL); + CREATE_AND_SET_IMAGE(maskReadout->image, F64, DEFAULT_MASK_VAL, NUM_ROWS, NUM_COLS) + + pmMaskBadPixels(inReadout, maskReadout, MASK_VAL, SAT_VAL, GROW_VAL, GROW_RAD); + + psFree(inReadout); + psFree(maskReadout); + + return 0; +} + Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/detrend/tst_pmNonLinear.c =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/detrend/tst_pmNonLinear.c (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/detrend/tst_pmNonLinear.c (revision 21664) @@ -0,0 +1,268 @@ +/* @file tst_pmNonLinear.c + * + * @brief Contains the tests for pmNonLinear.c: + * + * test00: This code will create a simple polynomial, and call + * pmNonLinearityPolynomial() for a variety of image sizes [(1, 1), (1, + * N), (N, 1), (N, N)]. + * + * test01: This code will create simple table lookup vectors, and call + * pmNonLinearityPolynomial() for a variety of image sizes [(1, 1), (1, + * N), (N, 1), (N, N)]. + * + * test02, test03: This code tests the functions with various unallowable + * input parameters (NULLS) and incorrect vector sizes. + * + * @author GLG, MHPCC + * + * XXX: Add tests in which the lookup file has incorrect number of entries, + * and where the data is outside the pmReadout range. + * + * @version $Revision: 1.2 $ $Name: not supported by cvs2svn $ + * @date $Date: 2005-10-20 23:06:24 $ + * + * Copyright 2004 Maui High Performance Computing Center, University of Hawaii + */ + +#include "psTest.h" +#include "pslib.h" +#include "pmNonLinear.h" +static int test00(void); +static int test01(void); +static int test02(void); +static int test03(void); +testDescription tests[] = { + {test00, 000, "pmNonLinearityPolynomial", true, false}, + {test01, 000, "pmNonLinearityLookup", true, false}, + {test02, 000, "pmNonLinearityPolynomial(): error/warning conditions", true, false}, + {test03, 000, "pmNonLinearityLookup(): error/warning conditions", true, false}, + {NULL} + }; + +#define NUM_ROWS 8 +#define NUM_COLS 8 +#define LOOKUP_FILENAME ".tmp_tst_pmNonLinearLookupFile" +int main(int argc, char* argv[]) +{ + psLogSetFormat("HLNM"); + // + // We generate a lookup file for future tests. We should probably remove + // it when we're done. + // + FILE *fp = fopen(LOOKUP_FILENAME, "w"); + ; + for (psS32 i=0;iimage = myImage; + psPolynomial1D *myPoly = psPolynomial1DAlloc(2, PS_POLYNOMIAL_ORD); + myPoly->coeff[1] = 1.0; + + printPositiveTestHeader(stdout, "pmNonLinear", "doNonLinearityPolynomialTest"); + + for (i=0;iimage->data.F32[i][j] = (float) (i + j); + } + } + + myReadout = pmNonLinearityPolynomial(myReadout, myPoly); + for (i=0;iimage->data.F32[i][j]; + if (FLT_EPSILON < fabs(expect - actual)) { + printf("TEST ERROR: image[%d][%d] is %f, should be %f\n", i, j, actual, expect); + testStatus = false; + } + } + } + + + psFree(myReadout); + psFree(myPoly); + printFooter(stdout, "pmNonLinear", "doNonLinearityPolynomialTest", true); + return(testStatus); +} + +int test00( void ) +{ + int testStatus = 0; + + testStatus |= doNonLinearityPolynomialTest(1, 1); + testStatus |= doNonLinearityPolynomialTest(NUM_COLS, 1); + testStatus |= doNonLinearityPolynomialTest(1, NUM_ROWS); + testStatus |= doNonLinearityPolynomialTest(NUM_COLS, NUM_ROWS); + + return(testStatus); +} + +int doNonLinearityLookupTest(int numCols, int numRows) +{ + int i; + int j; + float actual; + float expect; + int testStatus = true; + psImage *myImage = psImageAlloc(numCols, numRows, PS_TYPE_F32); + pmReadout *myReadout = pmReadoutAlloc(NULL); + myReadout->image = myImage; + + printPositiveTestHeader(stdout, "pmNonLinear", "doNonLinearityLookupTest"); + for (i=0;iimage->data.F32[i][j] = (float) (i + j); + } + } + + myReadout = pmNonLinearityLookup(myReadout, LOOKUP_FILENAME); + for (i=0;iimage->data.F32[i][j]; + if (FLT_EPSILON < fabs(expect - actual)) { + printf("TEST ERROR: image[%d][%d] is %f, should be %f\n", i, j, actual, expect); + testStatus = false; + } + } + } + + psFree(myReadout); + printFooter(stdout, "pmNonLinear", "doNonLinearityLookupTest", true); + return(testStatus); +} + +int test01( void ) +{ + int testStatus = 0; + + testStatus |= doNonLinearityLookupTest(1, 1); + testStatus |= doNonLinearityLookupTest(NUM_COLS, 1); + testStatus |= doNonLinearityLookupTest(1, NUM_ROWS); + testStatus |= doNonLinearityLookupTest (NUM_COLS, NUM_ROWS); + + return(testStatus); +} + +int test02( void ) +{ + int i; + int j; + int testStatus = true; + psImage *myImage = psImageAlloc(NUM_COLS, NUM_ROWS, PS_TYPE_F32); + pmReadout *myReadout = pmReadoutAlloc(NULL); + pmReadout *rc = NULL; + myReadout->image = myImage; + psPolynomial1D *myPoly = psPolynomial1DAlloc(2, PS_POLYNOMIAL_ORD); + myPoly->coeff[1] = 1.0; + + printPositiveTestHeader(stdout, "pmNonLinear", "Testing bad input parameter conditions."); + for (i=0;iimage->data.F32[i][j] = (float) (i + j); + } + } + + printf("------------------------------------------------------------\n"); + printf("Calling pmNonLinearityPolynomial() with NULL input readout. Should generate error, return NULL.\n"); + rc = pmNonLinearityPolynomial(NULL, myPoly); + if (rc != NULL) { + printf("TEST ERROR: pmNonLinearityPolynomial() returned a non-NULL pmReadout\n"); + testStatus = false; + } + + printf("------------------------------------------------------------\n"); + printf("Calling pmNonLinearityPolynomial() with NULL input readout->image. Should generate error, return NULL.\n"); + psImage *tmpImage = myReadout->image; + myReadout->image = NULL; + rc = pmNonLinearityPolynomial(myReadout, myPoly); + if (rc != NULL) { + printf("TEST ERROR: pmNonLinearityPolynomial() returned a non-NULL pmReadout\n"); + testStatus = false; + } + myReadout->image = tmpImage; + + printf("------------------------------------------------------------\n"); + printf("Calling pmNonLinearityPolynomial() with NULL polynomial. Should generate error, return NULL.\n"); + rc = pmNonLinearityPolynomial(myReadout, NULL); + if (rc != NULL) { + printf("TEST ERROR: pmNonLinearityPolynomial() returned a non-NULL pmReadout\n"); + testStatus = false; + } + + psFree(myReadout); + psFree(myPoly); + return(testStatus); +} + + +int test03Init(pmReadout *myReadout) +{ + for (psS32 i=0;iimage->data.F32[i][j] = (float) (i + j); + } + } + return(0); +} + +int test03() +{ + int testStatus = true; + psImage *myImage = psImageAlloc(NUM_COLS, NUM_ROWS, PS_TYPE_F32); + pmReadout *myReadout = pmReadoutAlloc(NULL); + pmReadout *rc = NULL; + myReadout->image = myImage; + + test03Init(myReadout); + printf("------------------------------------------------------------\n"); + printf("Calling pmNonLinearityLookup() with NULL input pmReadout. Should generate error, return NULL.\n"); + rc = pmNonLinearityLookup(NULL, LOOKUP_FILENAME); + if (rc != NULL) { + printf("TEST ERROR: pmNonLinearityPolynomial() returned a non-NULL pmReadout\n"); + testStatus = false; + } + + printf("------------------------------------------------------------\n"); + printf("Calling pmNonLinearityLookup() with NULL input pmReadout->image. Should generate error, return NULL.\n"); + psImage *tmpImage = myReadout->image; + myReadout->image = NULL; + rc = pmNonLinearityLookup(myReadout, LOOKUP_FILENAME); + if (rc != NULL) { + printf("TEST ERROR: pmNonLinearityPolynomial() returned a non-NULL pmReadout\n"); + testStatus = false; + } + myReadout->image = tmpImage; + + printf("------------------------------------------------------------\n"); + printf("Calling pmNonLinearityLookup() with non-existent lookup file.\n"); + rc = pmNonLinearityLookup(myReadout, "I_DONT_EXIST"); + if (rc == NULL) { + printf("TEST ERROR: pmNonLinearityPolynomial() returned a NULL pmReadout\n"); + testStatus = false; + } + + + printf("------------------------------------------------------------\n"); + printf("Calling pmNonLinearityLookup() with one pixels outside inFlux range. Should generate warnings.\n"); + + psFree(myReadout); + + printFooter(stdout, "pmNonLinear", "Testing bad input parameter conditions.", true); + return(testStatus); +} Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/detrend/verified/tst_pmFlatField.stderr =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/detrend/verified/tst_pmFlatField.stderr (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/detrend/verified/tst_pmFlatField.stderr (revision 21664) @@ -0,0 +1,69 @@ +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmFlatField.c * +* TestPoint: Test Point Driver{pmFlatField} * +* TestType: Positive * +\**********************************************************************************/ + +|W|pmFlatField + WARNING: in->parent is NULL. +|W|p_psDetermineTrimmedImage + WARNING: could not determine CELL.TRIMSEC from parent cell Metadata (NULL). +|W|pmFlatField + WARNING: in->parent is NULL. +|W|p_psDetermineTrimmedImage + WARNING: could not determine CELL.TRIMSEC from parent cell Metadata (NULL). +|W|pmFlatField + WARNING: in->parent is NULL. +|W|p_psDetermineTrimmedImage + WARNING: could not determine CELL.TRIMSEC from parent cell Metadata (NULL). +|E|pmFlatField (FILE:LINENO) + Unallowable operation: flat is NULL. +|E|pmFlatField (FILE:LINENO) + Unallowable operation: in->image is NULL. +|E|pmFlatField (FILE:LINENO) + Unallowable operation: flat->image is NULL. +|W|pmFlatField + WARNING: in->parent is NULL. +|W|p_psDetermineTrimmedImage + WARNING: could not determine CELL.TRIMSEC from parent cell Metadata (NULL). +|E|pmFlatField (FILE:LINENO) + Input image size exceeds that of flat image: (3, 3) vs (2, 2) +|W|pmFlatField + WARNING: in->parent is NULL. +|W|p_psDetermineTrimmedImage + WARNING: could not determine CELL.TRIMSEC from parent cell Metadata (NULL). +|E|pmFlatField (FILE:LINENO) + Input image mask size exceeds that of flat image: (5, 5) vs (3, 3) +|W|pmFlatField + WARNING: in->parent is NULL. +|W|p_psDetermineTrimmedImage + WARNING: could not determine CELL.TRIMSEC from parent cell Metadata (NULL). +|E|pmFlatField (FILE:LINENO) + Total offset >= flat image size: (50, 50) vs (3, 3) +|W|pmFlatField + WARNING: in->parent is NULL. +|W|p_psDetermineTrimmedImage + WARNING: could not determine CELL.TRIMSEC from parent cell Metadata (NULL). +|E|pmFlatField (FILE:LINENO) + Complex types not allowed for input image. Type: 2064 +|W|pmFlatField + WARNING: in->parent is NULL. +|W|p_psDetermineTrimmedImage + WARNING: could not determine CELL.TRIMSEC from parent cell Metadata (NULL). +|E|pmFlatField (FILE:LINENO) + Complex types not allowed for flat image. Type: 2064 +|W|pmFlatField + WARNING: in->parent is NULL. +|W|p_psDetermineTrimmedImage + WARNING: could not determine CELL.TRIMSEC from parent cell Metadata (NULL). +|E|pmFlatField (FILE:LINENO) + Input and flat image types differ: (1032 vs 1028) +|W|pmFlatField + WARNING: in->parent is NULL. +|W|p_psDetermineTrimmedImage + WARNING: could not determine CELL.TRIMSEC from parent cell Metadata (NULL). +|E|pmFlatField (FILE:LINENO) + Mask must be PS_TYPE_MASK type. Type: 1028 + +---> TESTPOINT PASSED (Test Point Driver{pmFlatField} | tst_pmFlatField.c) + Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/detrend/verified/tst_pmFlatField.stdout =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/detrend/verified/tst_pmFlatField.stdout (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/detrend/verified/tst_pmFlatField.stdout (revision 21664) @@ -0,0 +1,241 @@ +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmFlatField.c * +* TestPoint: pmFlatField{Test A - Divide input image by flat image} * +* TestType: Positive * +\**********************************************************************************/ + +Input mask: +0 0 0 +0 0 0 +0 0 0 + +Input image: +6.000000 6.000000 6.000000 +6.000000 6.000000 6.000000 +6.000000 6.000000 6.000000 + +Flat image: +2.000000 2.000000 2.000000 +2.000000 2.000000 2.000000 +2.000000 2.000000 2.000000 + +Resulting image: +3.000000 3.000000 3.000000 +3.000000 3.000000 3.000000 +3.000000 3.000000 3.000000 + + +---> TESTPOINT PASSED (pmFlatField{Test A - Divide input image by flat image} | tst_pmFlatField.c) + + + + +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmFlatField.c * +* TestPoint: pmFlatField{Test B - Mask flat image data} * +* TestType: Positive * +\**********************************************************************************/ + +Input image: +3.000000 3.000000 3.000000 +3.000000 3.000000 3.000000 +3.000000 3.000000 3.000000 + +Flat image: +0.000000 0.000000 0.000000 +0.000000 0.000000 0.000000 +0.000000 0.000000 0.000000 + +Resulting mask: +8 8 8 +8 8 8 +8 8 8 + +Resulting image: +3.000000 3.000000 3.000000 +3.000000 3.000000 3.000000 +3.000000 3.000000 3.000000 + + +---> TESTPOINT PASSED (pmFlatField{Test B - Mask flat image data} | tst_pmFlatField.c) + + + + +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmFlatField.c * +* TestPoint: pmFlatField{Test C - Mask flat image data starting with non-null mask} * +* TestType: Positive * +\**********************************************************************************/ + +Input image: +3.000000 3.000000 3.000000 +3.000000 3.000000 3.000000 +3.000000 3.000000 3.000000 + +Flat image: +0.000000 0.000000 0.000000 +0.000000 0.000000 0.000000 +3.000000 -3.000000 0.000000 + +Flat image out: +0.000000 0.000000 0.000000 +0.000000 0.000000 0.000000 +3.000000 0.000000 0.000000 + +Resulting mask: +8 8 8 +8 8 8 +0 8 8 + +Resulting image: +3.000000 3.000000 3.000000 +3.000000 3.000000 3.000000 +1.000000 3.000000 3.000000 + + +---> TESTPOINT PASSED (pmFlatField{Test C - Mask flat image data starting with non-null mask} | tst_pmFlatField.c) + + + + +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmFlatField.c * +* TestPoint: pmFlatField{Test D - Attempt to use null flat readout} * +* TestType: Negative * +* ExpectedErrorText: Null not allowed for flat readout * +* ExpectedStatusValue: 0 * +\**********************************************************************************/ + + +---> TESTPOINT PASSED (pmFlatField{Test D - Attempt to use null flat readout} | tst_pmFlatField.c) + + + + +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmFlatField.c * +* TestPoint: pmFlatField{Test E - Attempt to use null input image} * +* TestType: Negative * +* ExpectedErrorText: Null not allowed for input image * +* ExpectedStatusValue: 0 * +\**********************************************************************************/ + + +---> TESTPOINT PASSED (pmFlatField{Test E - Attempt to use null input image} | tst_pmFlatField.c) + + + + +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmFlatField.c * +* TestPoint: pmFlatField{Test F - Attempt tp use null flat image} * +* TestType: Negative * +* ExpectedErrorText: Null not allowed for flat image * +* ExpectedStatusValue: 0 * +\**********************************************************************************/ + + +---> TESTPOINT PASSED (pmFlatField{Test F - Attempt tp use null flat image} | tst_pmFlatField.c) + + + + +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmFlatField.c * +* TestPoint: pmFlatField{Test G - Attempt to use input image bigger than flat image} * +* TestType: Negative * +* ExpectedErrorText: Input image size exceeds that of flat image * +* ExpectedStatusValue: 0 * +\**********************************************************************************/ + + +---> TESTPOINT PASSED (pmFlatField{Test G - Attempt to use input image bigger than flat image} | tst_pmFlatField.c) + + + + +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmFlatField.c * +* TestPoint: pmFlatField{Test H - Attempt to use input image mask bigger than flat image} * +* TestType: Negative * +* ExpectedErrorText: Input image mask size exceeds that of flat image * +* ExpectedStatusValue: 0 * +\**********************************************************************************/ + + +---> TESTPOINT PASSED (pmFlatField{Test H - Attempt to use input image mask bigger than flat image} | tst_pmFlatField.c) + + + + +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmFlatField.c * +* TestPoint: pmFlatField{Test I - Attempt to use offset greater than input image} * +* TestType: Negative * +* ExpectedErrorText: Total offset >= input image size * +* ExpectedStatusValue: 0 * +\**********************************************************************************/ + + +---> TESTPOINT PASSED (pmFlatField{Test I - Attempt to use offset greater than input image} | tst_pmFlatField.c) + + + + +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmFlatField.c * +* TestPoint: pmFlatField{Test J - Attempt to use complex input image} * +* TestType: Negative * +* ExpectedErrorText: Complex types not allowed for input image * +* ExpectedStatusValue: 0 * +\**********************************************************************************/ + + +---> TESTPOINT PASSED (pmFlatField{Test J - Attempt to use complex input image} | tst_pmFlatField.c) + + + + +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmFlatField.c * +* TestPoint: pmFlatField{Test K - Attempt to use complex flat image} * +* TestType: Negative * +* ExpectedErrorText: Complex types not allowed for flat image * +* ExpectedStatusValue: 0 * +\**********************************************************************************/ + + +---> TESTPOINT PASSED (pmFlatField{Test K - Attempt to use complex flat image} | tst_pmFlatField.c) + + + + +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmFlatField.c * +* TestPoint: pmFlatField{Test L - Attempt to use non-equal input and flat image types} * +* TestType: Negative * +* ExpectedErrorText: Input and flat image types differ * +* ExpectedStatusValue: 0 * +\**********************************************************************************/ + + +---> TESTPOINT PASSED (pmFlatField{Test L - Attempt to use non-equal input and flat image types} | tst_pmFlatField.c) + + + + +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmFlatField.c * +* TestPoint: pmFlatField{Test M - Attempt to use non-mask type mask image} * +* TestType: Negative * +* ExpectedErrorText: Mask must be PS_TYPE_MASK type * +* ExpectedStatusValue: 0 * +\**********************************************************************************/ + + +---> TESTPOINT PASSED (pmFlatField{Test M - Attempt to use non-mask type mask image} | tst_pmFlatField.c) + + + + Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/detrend/verified/tst_pmMaskBadPixels.stderr =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/detrend/verified/tst_pmMaskBadPixels.stderr (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/detrend/verified/tst_pmMaskBadPixels.stderr (revision 21664) @@ -0,0 +1,149 @@ +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmMaskBadPixels.c * +* TestPoint: Test Point Driver{pmMaskBadPixels - Create mask based on maskVal argument} * +* TestType: Positive * +\**********************************************************************************/ + +|W|pmMaskBadPixels + WARNING: in->parent is NULL. +|W|p_psDetermineTrimmedImage + WARNING: could not determine CELL.TRIMSEC from parent cell Metadata (NULL). + +---> TESTPOINT PASSED (Test Point Driver{pmMaskBadPixels - Create mask based on maskVal argument} | tst_pmMaskBadPixels.c) + +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmMaskBadPixels.c * +* TestPoint: Test Point Driver{pmMaskBadPixels - Create mask based on saturation argument} * +* TestType: Positive * +\**********************************************************************************/ + +|W|pmMaskBadPixels + WARNING: in->parent is NULL. +|W|p_psDetermineTrimmedImage + WARNING: could not determine CELL.TRIMSEC from parent cell Metadata (NULL). + +---> TESTPOINT PASSED (Test Point Driver{pmMaskBadPixels - Create mask based on saturation argument} | tst_pmMaskBadPixels.c) + +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmMaskBadPixels.c * +* TestPoint: Test Point Driver{pmMaskBadPixels - Create mask based on growVal and grow argum * +* TestType: Positive * +\**********************************************************************************/ + +|W|pmMaskBadPixels + WARNING: in->parent is NULL. +|W|p_psDetermineTrimmedImage + WARNING: could not determine CELL.TRIMSEC from parent cell Metadata (NULL). + +---> TESTPOINT PASSED (Test Point Driver{pmMaskBadPixels - Create mask based on growVal and grow arguments} | tst_pmMaskBadPixels.c) + +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmMaskBadPixels.c * +* TestPoint: Test Point Driver{pmMaskBadPixels - Auto create mask based on maskVal argument} * +* TestType: Positive * +\**********************************************************************************/ + +|W|pmMaskBadPixels + WARNING: in->parent is NULL. +|W|p_psDetermineTrimmedImage + WARNING: could not determine CELL.TRIMSEC from parent cell Metadata (NULL). + +---> TESTPOINT PASSED (Test Point Driver{pmMaskBadPixels - Auto create mask based on maskVal argument} | tst_pmMaskBadPixels.c) + +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmMaskBadPixels.c * +* TestPoint: Test Point Driver{pmMaskBadPixels - Attempt to use null mask} * +* TestType: Positive * +\**********************************************************************************/ + +|W|pmMaskBadPixels + WARNING: in->parent is NULL. +|E|pmMaskBadPixels (FILE:LINENO) + Unallowable operation: mask is NULL. + +---> TESTPOINT PASSED (Test Point Driver{pmMaskBadPixels - Attempt to use null mask} | tst_pmMaskBadPixels.c) + +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmMaskBadPixels.c * +* TestPoint: Test Point Driver{pmMaskBadPixels - Attempt tp use null input image} * +* TestType: Positive * +\**********************************************************************************/ + +|E|pmMaskBadPixels (FILE:LINENO) + Unallowable operation: in->image is NULL. + +---> TESTPOINT PASSED (Test Point Driver{pmMaskBadPixels - Attempt tp use null input image} | tst_pmMaskBadPixels.c) + +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmMaskBadPixels.c * +* TestPoint: Test Point Driver{pmMaskBadPixels - Attempt to use input image bigger than mask * +* TestType: Positive * +\**********************************************************************************/ + +|W|pmMaskBadPixels + WARNING: in->parent is NULL. +|W|p_psDetermineTrimmedImage + WARNING: could not determine CELL.TRIMSEC from parent cell Metadata (NULL). +|E|pmMaskBadPixels (FILE:LINENO) + Input image size exceeds that of mask image: (60, 60) vs (50, 50) + +---> TESTPOINT PASSED (Test Point Driver{pmMaskBadPixels - Attempt to use input image bigger than mask} | tst_pmMaskBadPixels.c) + +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmMaskBadPixels.c * +* TestPoint: Test Point Driver{pmMaskBadPixels - Attempt to use input image mask bigger than * +* TestType: Positive * +\**********************************************************************************/ + +|W|pmMaskBadPixels + WARNING: in->parent is NULL. +|W|p_psDetermineTrimmedImage + WARNING: could not determine CELL.TRIMSEC from parent cell Metadata (NULL). + +---> TESTPOINT PASSED (Test Point Driver{pmMaskBadPixels - Attempt to use input image mask bigger than mask} | tst_pmMaskBadPixels.c) + +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmMaskBadPixels.c * +* TestPoint: Test Point Driver{pmMaskBadPixels - Attempt to use offset greater than input im * +* TestType: Positive * +\**********************************************************************************/ + +|W|pmMaskBadPixels + WARNING: in->parent is NULL. +|W|p_psDetermineTrimmedImage + WARNING: could not determine CELL.TRIMSEC from parent cell Metadata (NULL). +|E|pmMaskBadPixels (FILE:LINENO) + Total offset >= mask image: (150, 150) vs (50, 50) + +---> TESTPOINT PASSED (Test Point Driver{pmMaskBadPixels - Attempt to use offset greater than input image} | tst_pmMaskBadPixels.c) + +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmMaskBadPixels.c * +* TestPoint: Test Point Driver{pmMaskBadPixels - Attempt to use complex input image} * +* TestType: Positive * +\**********************************************************************************/ + +|W|pmMaskBadPixels + WARNING: in->parent is NULL. +|W|p_psDetermineTrimmedImage + WARNING: could not determine CELL.TRIMSEC from parent cell Metadata (NULL). +|E|pmMaskBadPixels (FILE:LINENO) + Complex types not allowed for input image. Type: 2064 + +---> TESTPOINT PASSED (Test Point Driver{pmMaskBadPixels - Attempt to use complex input image} | tst_pmMaskBadPixels.c) + +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmMaskBadPixels.c * +* TestPoint: Test Point Driver{pmMaskBadPixels - Attempt to use non-mask type mask image} * +* TestType: Positive * +\**********************************************************************************/ + +|W|pmMaskBadPixels + WARNING: in->parent is NULL. +|W|p_psDetermineTrimmedImage + WARNING: could not determine CELL.TRIMSEC from parent cell Metadata (NULL). +|E|pmMaskBadPixels (FILE:LINENO) + Mask must be PS_TYPE_MASK type. Type: 1032 + +---> TESTPOINT PASSED (Test Point Driver{pmMaskBadPixels - Attempt to use non-mask type mask image} | tst_pmMaskBadPixels.c) + Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/detrend/verified/tst_pmMaskBadPixels.stdout =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/detrend/verified/tst_pmMaskBadPixels.stdout (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/detrend/verified/tst_pmMaskBadPixels.stdout (revision 21664) @@ -0,0 +1,416 @@ +Data mask: +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000001000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 + +Resulting mask: +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000001000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 + +Data mask: +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 + +Resulting mask: +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000001000000000000000000000000 +00000000000000000000000011100000000000000000000000 +00000000000000000000000111110000000000000000000000 +00000000000000000000000011100000000000000000000000 +00000000000000000000000001000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 + +Data mask: +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 + +Resulting mask: +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000001000000000000000000000000 +00000000000000000000011111111100000000000000000000 +00000000000000000001111111111111000000000000000000 +00000000000000000011111111111111100000000000000000 +00000000000000000111111111111111110000000000000000 +00000000000000000111111111111111110000000000000000 +00000000000000001111111111111111111000000000000000 +00000000000000001111111111111111111000000000000000 +00000000000000001111111111111111111000000000000000 +00000000000000001111111111111111111000000000000000 +00000000000000011111111111111111111100000000000000 +00000000000000001111111111111111111000000000000000 +00000000000000001111111111111111111000000000000000 +00000000000010001111111111111111111000100000000000 +00000000111111111111111111111111111111111110000000 +00000011111111111111111111111111111111111111100000 +00000111111111111111111111111111111111111111110000 +00001111111111111111111111111111111111111111111000 +00001111111111111111111111111111111111111111111000 +00011111111111111111111111111111111111111111111100 +00011111111111111111110001000111111111111111111100 +00011111111111111111110000000111111111111111111100 +00011111111111111111110000000111111111111111111100 +00111111111111111111111000001111111111111111111110 +00011111111111111111110000000111111111111111111100 +00011111111111111111110000000111111111111111111100 +00011111111111111111110000000111111111111111111100 +00011111111111111111110000000111111111111111111100 +00001111111111111111100000000011111111111111111000 +00001111111111111111100000000011111111111111111000 +00000111111111111111000000000001111111111111110000 +00000011111111111110000000000000111111111111100000 +00000000111111111000000000000000001111111110000000 +00000000000010000000000000000000000000100000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 + +Data mask: +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000001000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 + +Resulting mask: +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000001000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000 + Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/detrend/verified/tst_pmNonLinear.stderr =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/detrend/verified/tst_pmNonLinear.stderr (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/detrend/verified/tst_pmNonLinear.stderr (revision 21664) @@ -0,0 +1,86 @@ +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmNonLinear.c * +* TestPoint: Test Point Driver{pmNonLinearityPolynomial} * +* TestType: Positive * +\**********************************************************************************/ + +|W|pmNonLinearityPolynomial + WARNING: inputReadout->parent is NULL. +|W|p_psDetermineTrimmedImage + WARNING: could not determine CELL.TRIMSEC from parent cell Metadata (NULL). +|W|pmNonLinearityPolynomial + WARNING: inputReadout->parent is NULL. +|W|p_psDetermineTrimmedImage + WARNING: could not determine CELL.TRIMSEC from parent cell Metadata (NULL). +|W|pmNonLinearityPolynomial + WARNING: inputReadout->parent is NULL. +|W|p_psDetermineTrimmedImage + WARNING: could not determine CELL.TRIMSEC from parent cell Metadata (NULL). +|W|pmNonLinearityPolynomial + WARNING: inputReadout->parent is NULL. +|W|p_psDetermineTrimmedImage + WARNING: could not determine CELL.TRIMSEC from parent cell Metadata (NULL). + +---> TESTPOINT PASSED (Test Point Driver{pmNonLinearityPolynomial} | tst_pmNonLinear.c) + +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmNonLinear.c * +* TestPoint: Test Point Driver{pmNonLinearityLookup} * +* TestType: Positive * +\**********************************************************************************/ + +|W|pmNonLinearityLookup + WARNING: inputReadout->parent is NULL. +|W|p_psDetermineTrimmedImage + WARNING: could not determine CELL.TRIMSEC from parent cell Metadata (NULL). +|W|pmNonLinearityLookup + WARNING: inputReadout->parent is NULL. +|W|p_psDetermineTrimmedImage + WARNING: could not determine CELL.TRIMSEC from parent cell Metadata (NULL). +|W|pmNonLinearityLookup + WARNING: inputReadout->parent is NULL. +|W|p_psDetermineTrimmedImage + WARNING: could not determine CELL.TRIMSEC from parent cell Metadata (NULL). +|W|pmNonLinearityLookup + WARNING: inputReadout->parent is NULL. +|W|p_psDetermineTrimmedImage + WARNING: could not determine CELL.TRIMSEC from parent cell Metadata (NULL). + +---> TESTPOINT PASSED (Test Point Driver{pmNonLinearityLookup} | tst_pmNonLinear.c) + +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmNonLinear.c * +* TestPoint: Test Point Driver{pmNonLinearityPolynomial(): error/warning conditions} * +* TestType: Positive * +\**********************************************************************************/ + +|E|pmNonLinearityPolynomial (FILE:LINENO) + Unallowable operation: inputReadout is NULL. +|E|pmNonLinearityPolynomial (FILE:LINENO) + Unallowable operation: inputReadout->image is NULL. +|E|pmNonLinearityPolynomial (FILE:LINENO) + Unallowable operation: input1DPoly is NULL. + +---> TESTPOINT PASSED (Test Point Driver{pmNonLinearityPolynomial(): error/warning conditions} | tst_pmNonLinear.c) + +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmNonLinear.c * +* TestPoint: Test Point Driver{pmNonLinearityLookup(): error/warning conditions} * +* TestType: Positive * +\**********************************************************************************/ + +|E|pmNonLinearityLookup (FILE:LINENO) + Unallowable operation: inputReadout is NULL. +|E|pmNonLinearityLookup (FILE:LINENO) + Unallowable operation: inputReadout->image is NULL. +|W|pmNonLinearityLookup + WARNING: inputReadout->parent is NULL. +|W|p_psDetermineTrimmedImage + WARNING: could not determine CELL.TRIMSEC from parent cell Metadata (NULL). +|E|psVectorsReadFromFile (FILE:LINENO) + Failed to open file I_DONT_EXIST. +|W|pmNonLinearityLookup + WARNING: Lookup Table is too small. Returning original pmReadout. + +---> TESTPOINT PASSED (Test Point Driver{pmNonLinearityLookup(): error/warning conditions} | tst_pmNonLinear.c) + Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/detrend/verified/tst_pmNonLinear.stdout =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/detrend/verified/tst_pmNonLinear.stdout (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/detrend/verified/tst_pmNonLinear.stdout (revision 21664) @@ -0,0 +1,95 @@ +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmNonLinear.c * +* TestPoint: pmNonLinear{doNonLinearityPolynomialTest} * +* TestType: Positive * +\**********************************************************************************/ + + +---> TESTPOINT PASSED (pmNonLinear{doNonLinearityPolynomialTest} | tst_pmNonLinear.c) + +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmNonLinear.c * +* TestPoint: pmNonLinear{doNonLinearityPolynomialTest} * +* TestType: Positive * +\**********************************************************************************/ + + +---> TESTPOINT PASSED (pmNonLinear{doNonLinearityPolynomialTest} | tst_pmNonLinear.c) + +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmNonLinear.c * +* TestPoint: pmNonLinear{doNonLinearityPolynomialTest} * +* TestType: Positive * +\**********************************************************************************/ + + +---> TESTPOINT PASSED (pmNonLinear{doNonLinearityPolynomialTest} | tst_pmNonLinear.c) + +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmNonLinear.c * +* TestPoint: pmNonLinear{doNonLinearityPolynomialTest} * +* TestType: Positive * +\**********************************************************************************/ + + +---> TESTPOINT PASSED (pmNonLinear{doNonLinearityPolynomialTest} | tst_pmNonLinear.c) + +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmNonLinear.c * +* TestPoint: pmNonLinear{doNonLinearityLookupTest} * +* TestType: Positive * +\**********************************************************************************/ + + +---> TESTPOINT PASSED (pmNonLinear{doNonLinearityLookupTest} | tst_pmNonLinear.c) + +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmNonLinear.c * +* TestPoint: pmNonLinear{doNonLinearityLookupTest} * +* TestType: Positive * +\**********************************************************************************/ + + +---> TESTPOINT PASSED (pmNonLinear{doNonLinearityLookupTest} | tst_pmNonLinear.c) + +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmNonLinear.c * +* TestPoint: pmNonLinear{doNonLinearityLookupTest} * +* TestType: Positive * +\**********************************************************************************/ + + +---> TESTPOINT PASSED (pmNonLinear{doNonLinearityLookupTest} | tst_pmNonLinear.c) + +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmNonLinear.c * +* TestPoint: pmNonLinear{doNonLinearityLookupTest} * +* TestType: Positive * +\**********************************************************************************/ + + +---> TESTPOINT PASSED (pmNonLinear{doNonLinearityLookupTest} | tst_pmNonLinear.c) + +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmNonLinear.c * +* TestPoint: pmNonLinear{Testing bad input parameter conditions.} * +* TestType: Positive * +\**********************************************************************************/ + +------------------------------------------------------------ +Calling pmNonLinearityPolynomial() with NULL input readout. Should generate error, return NULL. +------------------------------------------------------------ +Calling pmNonLinearityPolynomial() with NULL input readout->image. Should generate error, return NULL. +------------------------------------------------------------ +Calling pmNonLinearityPolynomial() with NULL polynomial. Should generate error, return NULL. +------------------------------------------------------------ +Calling pmNonLinearityLookup() with NULL input pmReadout. Should generate error, return NULL. +------------------------------------------------------------ +Calling pmNonLinearityLookup() with NULL input pmReadout->image. Should generate error, return NULL. +------------------------------------------------------------ +Calling pmNonLinearityLookup() with non-existent lookup file. +------------------------------------------------------------ +Calling pmNonLinearityLookup() with one pixels outside inFlux range. Should generate warnings. + +---> TESTPOINT PASSED (pmNonLinear{Testing bad input parameter conditions.} | tst_pmNonLinear.c) + Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/imcombine/.cvsignore =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/imcombine/.cvsignore (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/imcombine/.cvsignore (revision 21664) @@ -0,0 +1,7 @@ +.deps +.libs +Makefile +Makefile.in +temp +tst_pmImageCombine +tst_pmReadoutCombine Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/imcombine/Makefile.am =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/imcombine/Makefile.am (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/imcombine/Makefile.am (revision 21664) @@ -0,0 +1,23 @@ +# Makefile for psModule tests + +AM_LDFLAGS = -L$(top_builddir)/src -lpsmodule $(PSMODULE_LIBS) +AM_CFLAGS = @AM_CFLAGS@ $(PSMODULE_CFLAGS) $(SRCINC) + +TESTS = \ + tst_pmImageCombine \ + tst_pmReadoutCombine + +tst_pmImageCombine_SOURCES = tst_pmImageCombine.c +tst_pmReadoutCombine_SOURCES = tst_pmReadoutCombine.c + +check_PROGRAMS = $(TESTS) + +TESTS_ENVIRONMENT = perl $(top_srcdir)/test/runTest --verified=$(srcdir)/verified + +tests: $(TESTS) + +EXTRA_DIST = verified + +CLEANFILES = $(TESTS) temp/* + +test: check Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/imcombine/tst_pmImageCombine.c =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/imcombine/tst_pmImageCombine.c (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/imcombine/tst_pmImageCombine.c (revision 21664) @@ -0,0 +1,353 @@ +/** @file tst_pmImageCombine.c + * + * @brief Contains the tests for pmImageCombine.c: + * + * test00: This code will test the various functions in the pmImageCombine.c file. + * + * @author GLG, MHPCC + * + * XXX: Must verify the results internally. Don't use stdout file. + * XXX: Must test masks with pmRejectPixels() + * + * @version $Revision: 1.2 $ $Name: not supported by cvs2svn $ + * @date $Date: 2005-10-10 21:58:34 $ + * + * Copyright 2004 Maui High Performance Computing Center, University of Hawaii + */ +#include "psTest.h" +#include "pslib.h" +#include "pmImageCombine.h" +static int test00(void); +testDescription tests[] = { + {test00, 000, "pmCombineImages()", true, false}, + {NULL} + }; + +int main(int argc, char* argv[]) +{ + psLogSetFormat("HLNM"); + return !runTestSuite(stderr, "Test Point Driver", tests, argc, argv); +} + +psF32 genRanFloat(psF32 low, + psF32 high) +{ + psF32 ran1 = (((psF32) (random() % 10000)) / 10000.0); + return(low + (ran1 * (high - low))); +} + +psF32 genRanInt(psS32 low, + psS32 high) +{ + psF32 ran1 = (((psF32) (random() % 10000)) / 10000.0); + return((psS32) (low + (ran1 * (high - low)))); +} + +#define TST00_EXPANSION_FACTOR_X 1.0 +#define TST00_EXPANSION_FACTOR_Y 1.0 +#define TST00_OFFSET_X 0.0 +#define TST00_OFFSET_Y 0.0 +#define TST00_NUM_PIXELS 10 +#define TST00_MASK_VALUE 1 +#define TST00_NUM_ITERATIONS 4 +#define TST00_SIGMA_CLIP 1.0 +#define TST00_REJECTION_THRESHOLD 0.01 +#define TST00_GRADIENT_LIMIT 10.0 +/******************************************************************************* +NOTE: This function returns FALSE if there were no errors. + ******************************************************************************/ +psBool testCombineImages(psS32 numRows, + psS32 numCols, + psS32 numImages) +{ + printf("Testing pmCombineImages(%d, %d, %d)\n", numRows, numCols, numImages); + bool testStatus = false; + + psArray *images = psArrayAlloc(numImages); + psArray *errors = psArrayAlloc(numImages); + psArray *masks = psArrayAlloc(numImages); + for (psS32 i = 0 ; i < numImages ; i++) { + images->data[i] = (psPtr *) psImageAlloc(numCols, numRows, PS_TYPE_F32); + errors->data[i] = (psPtr *) psImageAlloc(numCols, numRows, PS_TYPE_F32); + masks->data[i] = (psPtr *) psImageAlloc(numCols, numRows, PS_TYPE_U8); + psImage *image = (psImage *) images->data[i]; + psImage *error = (psImage *) errors->data[i]; + psImage *mask = (psImage *) masks->data[i]; + PS_IMAGE_SET_F32(image, 0.0); + PS_IMAGE_SET_F32(error, 1.0); + PS_IMAGE_SET_U8(mask, 0); + + for (psS32 row = 0 ; row < numRows ; row++) { + for (psS32 col = 0 ; col < numCols ; col++) { + // Scale row/col to [-1.0:1.0] + psF32 rowScaled = ((psF32) (row - (numRows/2))) / ((psF32) (numRows/2)); + psF32 colScaled = ((psF32) (col - (numCols/2))) / ((psF32) (numCols/2)); + image->data.F32[row][col] = PS_SQR((2.0 - rowScaled) + (2.0 - colScaled)) + genRanFloat(0.0, 0.5); + } + } + } + + // + // Same as above except the numImages is wrong + // + psArray *imagesLong = psArrayAlloc(numImages+1); + psArray *errorsLong = psArrayAlloc(numImages+1); + psArray *masksLong = psArrayAlloc(numImages+1); + for (psS32 i = 0 ; i < numImages+1 ; i++) { + imagesLong->data[i] = (psPtr *) psImageAlloc(numCols, numRows, PS_TYPE_F32); + errorsLong->data[i] = (psPtr *) psImageAlloc(numCols, numRows, PS_TYPE_F32); + masksLong->data[i] = (psPtr *) psImageAlloc(numCols, numRows, PS_TYPE_U8); + psImage *image = (psImage *) imagesLong->data[i]; + psImage *error = (psImage *) errorsLong->data[i]; + psImage *mask = (psImage *) masksLong->data[i]; + PS_IMAGE_SET_F32(image, 0.0); + PS_IMAGE_SET_F32(error, 1.0); + PS_IMAGE_SET_U8(mask, 0); + + for (psS32 row = 0 ; row < numRows ; row++) { + for (psS32 col = 0 ; col < numCols ; col++) { + // Scale row/col to [-1.0:1.0] + psF32 rowScaled = ((psF32) (row - (numRows/2))) / ((psF32) (numRows/2)); + psF32 colScaled = ((psF32) (col - (numCols/2))) / ((psF32) (numCols/2)); + image->data.F32[row][col] = PS_SQR((2.0 - rowScaled) + (2.0 - colScaled)) + genRanFloat(0.0, 0.5); + } + } + } + + // + // Same as above except the type is wrong + // + psArray *imagesBadType = psArrayAlloc(numImages); + psArray *errorsBadType = psArrayAlloc(numImages); + psArray *masksBadType = psArrayAlloc(numImages); + for (psS32 i = 0 ; i < numImages ; i++) { + imagesBadType->data[i] = (psPtr *) psImageAlloc(numCols, numRows, PS_TYPE_F64); + errorsBadType->data[i] = (psPtr *) psImageAlloc(numCols, numRows, PS_TYPE_F64); + masksBadType->data[i] = (psPtr *) psImageAlloc(numCols, numRows, PS_TYPE_S8); + psImage *image = (psImage *) imagesBadType->data[i]; + psImage *error = (psImage *) errorsBadType->data[i]; + psImage *mask = (psImage *) masksBadType ->data[i]; + PS_IMAGE_SET_F32(image, 0.0); + PS_IMAGE_SET_F32(error, 1.0); + PS_IMAGE_SET_U8(mask, 0); + + for (psS32 row = 0 ; row < numRows ; row++) { + for (psS32 col = 0 ; col < numCols ; col++) { + // Scale row/col to [-1.0:1.0] + psF32 rowScaled = ((psF32) (row - (numRows/2))) / ((psF32) (numRows/2)); + psF32 colScaled = ((psF32) (col - (numCols/2))) / ((psF32) (numCols/2)); + image->data.F32[row][col] = PS_SQR((2.0 - rowScaled) + (2.0 - colScaled)) + genRanFloat(0.0, 0.5); + } + } + } + + psPixels *pixels = psPixelsAlloc(TST00_NUM_PIXELS); + for (psS32 p = 0 ; p < TST00_NUM_PIXELS ; p++) { + psS32 col = genRanInt(0, numCols); + psS32 row = genRanInt(0, numRows); + pixels->data[p].x = (psF32) col; + pixels->data[p].y = (psF32) row; + psS32 im = genRanInt(0, numImages-1); + psImage *image = (psImage *) images->data[im]; + image->data.F32[row][col] += 100.0; + printf("Generating a bad pixel in image (%d) at (%d, %d)\n", im, row, col); + } + + psArray *questionablePixels = NULL; + psStats *stats = psStatsAlloc(PS_STAT_SAMPLE_MEAN); + + //------------------------------------------------------------------------- + printf("Calling with a NULL images. Should generate error, return NULL.\n"); + psImage *outImg = pmCombineImages(NULL, &questionablePixels, NULL, errors, + masks, TST00_MASK_VALUE, pixels, TST00_NUM_ITERATIONS, + TST00_SIGMA_CLIP, stats); + if (outImg != NULL) { + printf("TEST ERROR: pmCombineImages() returned a non-NULL psImage.\n"); + psFree(outImg); + testStatus = true; + } + + //------------------------------------------------------------------------- + printf("Calling with a long images. Should generate error, return NULL.\n"); + outImg = pmCombineImages(NULL, &questionablePixels, imagesLong, errors, + masks, TST00_MASK_VALUE, pixels, TST00_NUM_ITERATIONS, + TST00_SIGMA_CLIP, stats); + if (outImg != NULL) { + printf("TEST ERROR: pmCombineImages() returned a non-NULL psImage.\n"); + psFree(outImg); + testStatus = true; + } + + //------------------------------------------------------------------------- + printf("Calling with a bad type images. Should generate error, return NULL.\n"); + outImg = pmCombineImages(NULL, &questionablePixels, imagesBadType, errors, + masks, TST00_MASK_VALUE, pixels, TST00_NUM_ITERATIONS, + TST00_SIGMA_CLIP, stats); + if (outImg != NULL) { + printf("TEST ERROR: pmCombineImages() returned a non-NULL psImage.\n"); + psFree(outImg); + testStatus = true; + } + + //------------------------------------------------------------------------- + printf("Calling with a long errors. Should generate error, return NULL.\n"); + outImg = pmCombineImages(NULL, &questionablePixels, images, errorsLong, + masks, TST00_MASK_VALUE, pixels, TST00_NUM_ITERATIONS, + TST00_SIGMA_CLIP, stats); + if (outImg != NULL) { + printf("TEST ERROR: pmCombineImages() returned a non-NULL psImage.\n"); + psFree(outImg); + testStatus = true; + } + + //------------------------------------------------------------------------- + printf("Calling with a bad type errors. Should generate error, return NULL.\n"); + outImg = pmCombineImages(NULL, &questionablePixels, images, errorsBadType, + masks, TST00_MASK_VALUE, pixels, TST00_NUM_ITERATIONS, + TST00_SIGMA_CLIP, stats); + if (outImg != NULL) { + printf("TEST ERROR: pmCombineImages() returned a non-NULL psImage.\n"); + psFree(outImg); + testStatus = true; + } + + //------------------------------------------------------------------------- + printf("Calling with a long masks. Should generate error, return NULL.\n"); + outImg = pmCombineImages(NULL, &questionablePixels, images, errors, + masksLong, TST00_MASK_VALUE, pixels, TST00_NUM_ITERATIONS, + TST00_SIGMA_CLIP, stats); + if (outImg != NULL) { + printf("TEST ERROR: pmCombineImages() returned a non-NULL psImage.\n"); + psFree(outImg); + testStatus = true; + } + + //------------------------------------------------------------------------- + printf("Calling with a bad type masks. Should generate error, return NULL.\n"); + outImg = pmCombineImages(NULL, &questionablePixels, images, errors, + masksBadType, TST00_MASK_VALUE, pixels, TST00_NUM_ITERATIONS, + TST00_SIGMA_CLIP, stats); + if (outImg != NULL) { + printf("TEST ERROR: pmCombineImages() returned a non-NULL psImage.\n"); + psFree(outImg); + testStatus = true; + } + + //------------------------------------------------------------------------- + printf("Calling with a NULL stats. Should generate error, return NULL.\n"); + outImg = pmCombineImages(NULL, &questionablePixels, images, errors, + masks, TST00_MASK_VALUE, pixels, TST00_NUM_ITERATIONS, + TST00_SIGMA_CLIP, NULL); + if (outImg != NULL) { + printf("TEST ERROR: pmCombineImages() returned a non-NULL psImage.\n"); + psFree(outImg); + testStatus = true; + } + + //------------------------------------------------------------------------- + printf("Calling with acceptable data. Should generate a psImage.\n"); + outImg = pmCombineImages(NULL, &questionablePixels, images, errors, + masks, TST00_MASK_VALUE, pixels, TST00_NUM_ITERATIONS, + TST00_SIGMA_CLIP, stats); + if (outImg == NULL) { + printf("TEST ERROR: pmCombineImages() returned a NULL psImage.\n"); + testStatus = true; + } + if (0) { + for (psS32 p = 0 ; p < TST00_NUM_PIXELS ; p++) { + psS32 col = (psS32) (pixels->data[p]).x; + psS32 row = (psS32) (pixels->data[p]).y; + printf("------------------------------------------\n"); + printf("Pixel (%d, %d) in combined image is %f\n", row, col, outImg->data.F32[row][col]); + for (psS32 i = 0 ; i < numImages ; i++) { + psImage *image = (psImage *) images->data[i]; + printf("Pixel (after combine) (%d, %d) in image (%d) is %f\n", row, col, i, image->data.F32[row][col]); + } + } + } + + if (questionablePixels->n != numImages) { + printf("TEST ERROR: pmCombineImages(): questionablePixels->n was %ld, should have been %d\n", + questionablePixels->n, numImages); + testStatus = true; + } else { + // XXX: We should internally verify this with the pixels list, not merely use the stdout. + for (psS32 i = 0 ; i < questionablePixels->n ; i++) { + psPixels *myPixels = (psPixels *) questionablePixels->data[i]; + for (psS32 p = 0 ; p < myPixels->n ; p++) { + printf("Image %d, questionable pixel %d is (%f %f)\n", + i, p, myPixels->data[p].y, myPixels->data[p].x); + } + } + } + + psArray *expandTransforms = psArrayAlloc(numImages); + psArray *contractTransforms = psArrayAlloc(numImages); + for (psS32 im = 0 ; im < numImages ; im++) { + psPlaneTransform *ptExpand = psPlaneTransformAlloc(2, 2); + ptExpand->x->coeff[0][0] = TST00_OFFSET_X; + ptExpand->x->coeff[1][0] = TST00_EXPANSION_FACTOR_X; + ptExpand->y->coeff[0][0] = TST00_OFFSET_Y; + ptExpand->y->coeff[0][1] = TST00_EXPANSION_FACTOR_Y; + expandTransforms->data[im] = (psPtr *) ptExpand; + + psPlaneTransform *ptContract = psPlaneTransformAlloc(2, 2); + ptContract->x->coeff[0][0] = -TST00_OFFSET_X; + ptContract->x->coeff[1][0] = 1.0 / TST00_EXPANSION_FACTOR_X; + ptContract->y->coeff[0][0] = -TST00_OFFSET_Y; + ptContract->y->coeff[0][1] = 1.0 / TST00_EXPANSION_FACTOR_Y; + contractTransforms->data[im] = (psPtr *) ptContract; + } + + //------------------------------------------------------------------------- + // + // XXX: psRejectPixels() has known bugs. Specifically, in the psImageTransform() call. + // We exclude this from our tests. + // + printf("\n\n\nCalling pmRejectPixels() with acceptable data. Should generate a psArray.\n"); + psArray *pixelRejects = pmRejectPixels(images, NULL, questionablePixels, expandTransforms, + contractTransforms, TST00_REJECTION_THRESHOLD, + TST00_GRADIENT_LIMIT); + if (pixelRejects == NULL) { + printf("TEST ERROR: pmRejectPixels() returned a NULL psArray.\n"); + testStatus = true; + } else { + // XXX: We should internally verify this with the pixels list, not merely use the stdout. + for (psS32 i = 0 ; i < pixelRejects->n ; i++) { + psPixels *myPixels = (psPixels *) pixelRejects->data[i]; + printf("tst_pmImageCombine.c: Image %d had %ld rejects.\n", i, myPixels->n); + + for (psS32 p = 0 ; p < myPixels->n ; p++) { + printf("Image %d, rejected pixel %d is (%f %f)\n", i, p, + myPixels->data[p].y, myPixels->data[p].x); + } + } + psFree(pixelRejects); + } + + psFree(images); + psFree(errors); + psFree(masks); + psFree(imagesLong); + psFree(errorsLong); + psFree(masksLong); + psFree(imagesBadType); + psFree(errorsBadType); + psFree(masksBadType); + psFree(pixels); + psFree(stats); + + return(testStatus); +} + +/******************************************************************************* +NOTE: This function returns TRUE if there were no errors. + ******************************************************************************/ +int test00( void ) +{ + bool testStatus = false; + + testStatus|= testCombineImages(10, 10, 5); + + return(!testStatus); +} Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/imcombine/tst_pmReadoutCombine.c =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/imcombine/tst_pmReadoutCombine.c (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/imcombine/tst_pmReadoutCombine.c (revision 21664) @@ -0,0 +1,452 @@ +/** @file tst_pmReadoutCombine.c + * + * test00() This routine will test the basic functionality. + * + * @author GLG, MHPCC + * + * @version $Revision: 1.1 $ $Name: not supported by cvs2svn $ + * @date $Date: 2005-09-28 20:42:52 $ + * + * Copyright 2004 Maui High Performance Computing Center, University of Hawaii + * + * XXX: Untested: + * S16, S32 types + * Multiple input readouts with varying sizes and offsets. + * params->fracLow and params->fracHigh + * params->nKeep + * (gain > 0.0) && (readnoise >= 0.0) (applyZeroScale == true) + * (gain > 0.0) && (readnoise >= 0.0) (applyZeroScale == false) + * + */ + +#include "psTest.h" +#include "pslib.h" +#include "pmReadoutCombine.h" +static int test00(void); +static int test01(void); +testDescription tests[] = { + {test00, 000, "pmSubtractBias(): Basic readout combines with no image overlap", true, false}, + {test01, 000, "pmSubtractBias(): input parameter error conditions", true, false}, + {NULL} + }; + +#define NUM_READOUTS 10 +#define INPUT_NUM_ROWS 20 +#define INPUT_NUM_COLS 20 +#define VEC_ZERO 1.0 +#define VEC_SCALE 2.0 + +psS32 VerifyTheOutput(psImage *output, psF32 expect) +{ + bool testStatus = true; + + for (psS32 i = 0 ; i < output->numRows ; i++) { + for (psS32 j = 0 ; j < output->numCols ; j++) { + if (output->data.F32[i][j] != expect) { + printf("TEST ERROR: output[%d][%d] is %.2f, should be %f\n", i, j, output->data.F32[i][j], expect); + testStatus = false; + } + } + } + return(testStatus); +} + + + +int main(int argc, char* argv[]) +{ + psLogSetFormat("HLNM"); + return !runTestSuite(stderr, "Test Point Driver", tests, argc, argv); +} + +/****************************************************************************** +simpleCombineNoOverlap(): this routine creates a list of NUM_READOUTS input +readouts and calls pmReadoutCombine(). + *****************************************************************************/ +int simpleCombineNoOverlap(psS32 numInputCols, psS32 numInputRows) +{ + int i; + int r; + psList *list = NULL; + int baseRowsReadout[NUM_READOUTS]; + int baseColsReadout[NUM_READOUTS]; + int baseRows[NUM_READOUTS]; + int baseCols[NUM_READOUTS]; + int numRows[NUM_READOUTS]; + int numCols[NUM_READOUTS]; + int minOutRow = 10000; + int minOutCol = 10000; + int maxOutRow = -1; + int maxOutCol = -1; + psImage *output = NULL; + psCombineParams *params = (psCombineParams *) psAlloc(sizeof(psCombineParams)); + psVector *zero = psVectorAlloc(NUM_READOUTS, PS_TYPE_F32); + psVector *scale = psVectorAlloc(NUM_READOUTS, PS_TYPE_F32); + printPositiveTestHeader(stdout, "pmReadoutCombine", "simpleCombineNoOverlap"); + + for (i=0;idata.F32[i] = VEC_ZERO; + } + for (i=0;idata.F32[i] = VEC_SCALE; + } + + params->stats = psStatsAlloc(PS_STAT_SAMPLE_MEAN); + params->maskVal = 1; + params->fracLow = 0.0; + params->fracHigh = 10000.0; + params->nKeep = 0; + + // + // Create a psList of psReadouts. The pixels in readout r will all have the + // value r. + // + for (r=0;rrow0)) = baseRows[r]; + *(int *) (& (tmpImage->col0)) = baseCols[r]; + pmReadout *tmpReadout = pmReadoutAlloc(NULL); + tmpReadout->row0 = 0; + tmpReadout->col0 = 0; + tmpReadout->image = tmpImage; + + minOutRow = PS_MIN(minOutRow, (baseRowsReadout[r] + baseRows[r])); + minOutCol = PS_MIN(minOutCol, (baseColsReadout[r] + baseCols[r])); + maxOutRow = PS_MAX(maxOutRow, (baseRowsReadout[r] + baseRows[r] + numRows[r])); + maxOutCol = PS_MAX(maxOutCol, (baseColsReadout[r] + baseCols[r] + numCols[r])); + + if (r == 0) { + list = psListAlloc(tmpReadout); + } else { + psListAdd(list, PS_LIST_HEAD, tmpReadout); + } + } + printf("tst_pmReadoutCombine(): (minOutRow, minOutCol) to (maxOutRow, maxOutCol) is (%d, %d) (%d, %d)\n", + minOutRow, minOutCol, maxOutRow, maxOutCol); + + output = pmReadoutCombine(output, list, params, zero, scale, true, 0.0, 0.0); + psF32 NR = (psF32) NUM_READOUTS; + psF32 expectedPixel = ((NR/2.0) * (VEC_ZERO + (VEC_ZERO + VEC_SCALE * (NR - 1)))) / NR; + + int testStatus = VerifyTheOutput(output, expectedPixel); + + psFree(params->stats); + psFree(params); + psFree(output); + psFree(zero); + psFree(scale); + + psListElem *tmpInput = (psListElem *) list->head; + while (NULL != tmpInput) { + pmReadout *tmpReadout = (pmReadout *) tmpInput->data; + psFree(tmpReadout); + tmpInput = tmpInput->next; + } + psFree(list); + + printFooter(stdout, "pmReadoutCombine", "simpleCombineNoOverlap", true); + return(testStatus); +} + +int test00( void ) +{ + int testStatus = 0; + + testStatus |= simpleCombineNoOverlap(1, 1); + testStatus |= simpleCombineNoOverlap(INPUT_NUM_COLS, 1); + testStatus |= simpleCombineNoOverlap(1, INPUT_NUM_ROWS); + testStatus |= simpleCombineNoOverlap(INPUT_NUM_COLS, INPUT_NUM_ROWS); + + return(testStatus); +} + +/****************************************************************************** +test01(): we simply call pmReadoutCombine() with a variety of erroneous input +parameter combinations and verify that it behaves properly. + *****************************************************************************/ +int test01() +{ + int testStatus = true; + int i; + int r; + psList *list = NULL; + int baseRowsReadout[NUM_READOUTS]; + int baseColsReadout[NUM_READOUTS]; + int baseRows[NUM_READOUTS]; + int baseCols[NUM_READOUTS]; + int numRows[NUM_READOUTS]; + int numCols[NUM_READOUTS]; + int minOutRow = 10000; + int minOutCol = 10000; + int maxOutRow = -1; + int maxOutCol = -1; + psImage *output = NULL; + psImage *rc = NULL; + psCombineParams *params = (psCombineParams *) psAlloc(sizeof(psCombineParams)); + psVector *zero = psVectorAlloc(NUM_READOUTS, PS_TYPE_F32); + psVector *zeroHalf = psVectorAlloc(NUM_READOUTS/2, PS_TYPE_F32); + psVector *zeroBig = psVectorAlloc(NUM_READOUTS+1, PS_TYPE_F32); + psVector *zeroF64 = psVectorAlloc(NUM_READOUTS, PS_TYPE_F64); + psVector *scale = psVectorAlloc(NUM_READOUTS, PS_TYPE_F32); + psVector *scaleHalf = psVectorAlloc(NUM_READOUTS/2, PS_TYPE_F32); + psVector *scaleBig = psVectorAlloc(NUM_READOUTS*2, PS_TYPE_F32); + psVector *scaleF64 = psVectorAlloc(NUM_READOUTS, PS_TYPE_F64); + for (i=0;idata.F32[i] = 3.0; + zeroBig->data.F32[i] = 3.0; + zero->data.F32[i] = VEC_ZERO; + zeroBig->data.F32[i] = VEC_ZERO; + } + for (i=0;idata.F32[i] = 6.0; + scaleBig->data.F32[i] = 6.0; + scale->data.F32[i] = VEC_SCALE; + scaleBig->data.F32[i] = VEC_SCALE; + } + printPositiveTestHeader(stdout, "pmReadoutCombine", "Testing bad input parameter conditions"); + + params->stats = psStatsAlloc(PS_STAT_SAMPLE_MEAN); + params->maskVal = 1; + params->fracLow = 0.0; + params->fracHigh = 10000.0; + params->nKeep = 0; + + for (r=0;rrow0)) = baseRows[r]; + *(int *) (& (tmpImage->col0)) = baseCols[r]; + pmReadout *tmpReadout = pmReadoutAlloc(NULL); + tmpReadout->row0 = 0; + tmpReadout->col0 = 0; + tmpReadout->image = tmpImage; + minOutRow = PS_MIN(minOutRow, (baseRowsReadout[r] + baseRows[r])); + minOutCol = PS_MIN(minOutCol, (baseColsReadout[r] + baseCols[r])); + maxOutRow = PS_MAX(maxOutRow, (baseRowsReadout[r] + baseRows[r] + numRows[r])); + maxOutCol = PS_MAX(maxOutCol, (baseColsReadout[r] + baseCols[r] + numCols[r])); + + if (r == 0) { + list = psListAlloc(tmpReadout); + } else { + psListAdd(list, PS_LIST_HEAD, tmpReadout); + } + } + + printf("----------------------------------------------------------------------------\n"); + printf("Calling pmReadoutCombine() with NULL zero vector.\n"); + rc = pmReadoutCombine(NULL, list, params, NULL, scale, true, 0.0, 0.0); + if (rc != NULL) { + psF32 NR = (psF32) NUM_READOUTS; + psF32 expectedPixel = ((NR/2.0) * (0.0 + (0.0 + VEC_SCALE * (NR - 1)))) / NR; + if (false == VerifyTheOutput(rc, expectedPixel)) { + testStatus = false; + } + + if (rc->type.type != scale->type.type) { + printf("TEST ERROR: output readout->image has incorrect type.\n"); + testStatus = false; + } + psFree(rc); + } else { + printf("TEST ERROR: pmReadoutCombine() returned NULL\n"); + testStatus = false; + + } + + printf("----------------------------------------------------------------------------\n"); + printf("Calling pmReadoutCombine() with incorrect length zero vector (too small). Should generate error.\n"); + rc = pmReadoutCombine(NULL, list, params, zeroHalf, scale, true, 0.0, 0.0); + if (rc != NULL) { + printf("TEST ERROR: pmReadoutCombine() did not return NULL\n"); + testStatus = false; + } + + printf("----------------------------------------------------------------------------\n"); + printf("Calling pmReadoutCombine() with incorrect type zero vector. Should generate error.\n"); + rc = pmReadoutCombine(NULL, list, params, zeroF64, scale, true, 0.0, 0.0); + if (rc != NULL) { + printf("TEST ERROR: pmReadoutCombine() did not return NULL\n"); + testStatus = false; + } + + printf("----------------------------------------------------------------------------\n"); + printf("Calling pmReadoutCombine() with incorrect length zero vector (too big). Should generate warning.\n"); + rc = pmReadoutCombine(output, list, params, zeroBig, scale, true, 0.0, 0.0); + if (rc != NULL) { + psF32 NR = (psF32) NUM_READOUTS; + psF32 expectedPixel = ((NR/2.0) * (VEC_ZERO + (VEC_ZERO + VEC_SCALE * (NR - 1)))) / NR; + + if (false == VerifyTheOutput(rc, expectedPixel)) { + testStatus = false; + } + psFree(rc); + rc = NULL; + } else { + printf("TEST ERROR: pmReadoutCombine() returned NULL\n"); + testStatus = false; + } + + printf("----------------------------------------------------------------------------\n"); + printf("Calling pmReadoutCombine() with NULL scale vector.\n"); + rc = pmReadoutCombine(output, list, params, zero, NULL, true, 0.0, 0.0); + + if (rc != NULL) { + psF32 NR = (psF32) NUM_READOUTS; + psF32 expectedPixel = ((NR/2.0) * (VEC_ZERO + (VEC_ZERO + 1.0 * (NR - 1)))) / NR; + if (false == VerifyTheOutput(rc, expectedPixel)) { + testStatus = false; + } + + if (rc->type.type != scale->type.type) { + printf("TEST ERROR: output readout->image has incorrect type.\n"); + testStatus = false; + } + psFree(rc); + } else { + printf("TEST ERROR: pmReadoutCombine() returned NULL\n"); + testStatus = false; + + } + + printf("----------------------------------------------------------------------------\n"); + printf("Calling pmReadoutCombine() with incorrect length scale vector (too small). Should generate error.\n"); + rc = pmReadoutCombine(output, list, params, zero, scaleHalf, true, 0.0, 0.0); + if (rc != NULL) { + printf("TEST ERROR: pmReadoutCombine() did not return NULL\n"); + testStatus = false; + } + + printf("----------------------------------------------------------------------------\n"); + printf("Calling pmReadoutCombine() with incorrect type scale vector. Should generate error.\n"); + rc = pmReadoutCombine(output, list, params, zero, scaleF64, true, 0.0, 0.0); + if (rc != NULL) { + printf("TEST ERROR: pmReadoutCombine() did not return NULL\n"); + testStatus = false; + } + + printf("----------------------------------------------------------------------------\n"); + printf("Calling pmReadoutCombine() with incorrect length scale vector (too big). Should generate warning.\n"); + rc = pmReadoutCombine(output, list, params, zero, scaleBig, true, 0.0, 0.0); + if (rc != NULL) { + psF32 NR = (psF32) NUM_READOUTS; + psF32 expectedPixel = ((NR/2.0) * (VEC_ZERO + (VEC_ZERO + VEC_SCALE * (NR - 1)))) / NR; + + if (false == VerifyTheOutput(rc, expectedPixel)) { + testStatus = false; + } + psFree(rc); + rc = NULL; + } else { + printf("TEST ERROR: pmReadoutCombine() returned NULL\n"); + testStatus = false; + } + + printf("----------------------------------------------------------------------------\n"); + printf("Calling pmReadoutCombine() insufficient size output image. Should generate error, return NULL.\n"); + output = psImageAlloc(1, 1, PS_TYPE_F32); + rc = pmReadoutCombine(output, list, params, zero, scale, true, 0.0, 0.0); + if (rc != NULL) { + printf("TEST ERROR: pmReadoutCombine() did not return NULL\n"); + testStatus = false; + } + psFree(output); + output = NULL; + + printf("----------------------------------------------------------------------------\n"); + printf("Calling pmReadoutCombine() row0/col0 too large. Should generate error, return NULL.\n"); + output = psImageAlloc(1, 1, PS_TYPE_F32); + *(psS32*)&output->row0 = 10000; + *(psS32*)&output->col0 = 10000; + rc = pmReadoutCombine(output, list, params, zero, scale, true, 0.0, 0.0); + if (rc != NULL) { + printf("TEST ERROR: pmReadoutCombine() did not return NULL\n"); + testStatus = false; + } + psFree(output); + output = NULL; + + printf("----------------------------------------------------------------------------\n"); + printf("Calling pmReadoutCombine() with NULL input list. Should generate error, return NULL.\n"); + rc = pmReadoutCombine(output, NULL, params, zero, scale, true, 0.0, 0.0); + if (rc != NULL) { + printf("TEST ERROR: pmReadoutCombine() did not return NULL\n"); + testStatus = false; + } + + printf("----------------------------------------------------------------------------\n"); + printf("Calling pmReadoutCombine() with NULL params. Should generate error, return NULL.\n"); + rc = pmReadoutCombine(output, list, NULL, zero, scale, true, 0.0, 0.0); + if (rc != NULL) { + printf("TEST ERROR: pmReadoutCombine() did not return NULL\n"); + testStatus = false; + } + + printf("----------------------------------------------------------------------------\n"); + psStatsOptions oldStatsOpts = params->stats->options |= PS_STAT_MIN; + printf("Calling pmReadoutCombine() with multiple stats->options. Should generate error, return NULL.\n"); + rc = pmReadoutCombine(output, list, params, zero, scale, true, 0.0, 0.0); + if (rc != NULL) { + printf("TEST ERROR: pmReadoutCombine() did not return NULL\n"); + testStatus = false; + } + params->stats->options = oldStatsOpts; + + printf("----------------------------------------------------------------------------\n"); + psStats *oldStats = params->stats; + printf("Calling pmReadoutCombine() with NULL param->stats. Should generate error, return NULL.\n"); + params->stats = NULL; + rc = pmReadoutCombine(output, list, params, zero, scale, true, 0.0, 0.0); + if (rc != NULL) { + printf("TEST ERROR: pmReadoutCombine() did not return NULL\n"); + testStatus = false; + } + params->stats = oldStats; + + printf("----------------------------------------------------------------------------\n"); + printf("============================================================================\n"); + + psFree(params->stats); + psFree(params); + // psFree(output); + // psFree(rc); + psFree(zero); + psFree(zeroHalf); + psFree(zeroBig); + psFree(zeroF64); + psFree(scale); + psFree(scaleHalf); + psFree(scaleBig); + psFree(scaleF64); + psListElem *tmpInput = (psListElem *) list->head; + while (NULL != tmpInput) { + pmReadout *tmpReadout = (pmReadout *) tmpInput->data; + psFree(tmpReadout); + tmpInput = tmpInput->next; + } + psFree(list); + + printFooter(stdout, "pmReadoutCombine", "Testing bad input parameter conditions", true); + return(testStatus); +} Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/imcombine/verified/tst_pmImageCombine.stderr =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/imcombine/verified/tst_pmImageCombine.stderr (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/imcombine/verified/tst_pmImageCombine.stderr (revision 21664) @@ -0,0 +1,25 @@ +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmImageCombine.c * +* TestPoint: Test Point Driver{pmCombineImages()} * +* TestType: Positive * +\**********************************************************************************/ + +|E|pmCombineImages (FILE:LINENO) + Unallowable operation: images is NULL. +|E|pmCombineImages (FILE:LINENO) + images and errors args must have same length (6 != 5) +|E|pmCombineImages (FILE:LINENO) + Unallowable operation: psImage tmpDataImg has incorrect type. +|E|pmCombineImages (FILE:LINENO) + images and errors args must have same length (5 != 6) +|E|pmCombineImages (FILE:LINENO) + Unallowable operation: psImage tmpErrorImg has incorrect type. +|E|pmCombineImages (FILE:LINENO) + images and masks args must have same length (5 != 6) +|E|pmCombineImages (FILE:LINENO) + Unallowable operation: psImage tmpMaskImg has incorrect type. +|E|pmCombineImages (FILE:LINENO) + Unallowable operation: stats is NULL. + +---> TESTPOINT PASSED (Test Point Driver{pmCombineImages()} | tst_pmImageCombine.c) + Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/imcombine/verified/tst_pmImageCombine.stdout =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/imcombine/verified/tst_pmImageCombine.stdout (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/imcombine/verified/tst_pmImageCombine.stdout (revision 21664) @@ -0,0 +1,47 @@ +Testing pmCombineImages(10, 10, 5) +Generating a bad pixel in image (1) at (0, 8) +Generating a bad pixel in image (3) at (7, 5) +Generating a bad pixel in image (1) at (1, 2) +Generating a bad pixel in image (2) at (9, 9) +Generating a bad pixel in image (1) at (3, 9) +Generating a bad pixel in image (2) at (0, 5) +Generating a bad pixel in image (1) at (4, 5) +Generating a bad pixel in image (1) at (3, 8) +Generating a bad pixel in image (2) at (6, 2) +Generating a bad pixel in image (2) at (3, 7) +Calling with a NULL images. Should generate error, return NULL. +Calling with a long images. Should generate error, return NULL. +Calling with a bad type images. Should generate error, return NULL. +Calling with a long errors. Should generate error, return NULL. +Calling with a bad type errors. Should generate error, return NULL. +Calling with a long masks. Should generate error, return NULL. +Calling with a bad type masks. Should generate error, return NULL. +Calling with a NULL stats. Should generate error, return NULL. +Calling with acceptable data. Should generate a psImage. +Image 1, questionable pixel 0 is (0.000000 8.000000) +Image 1, questionable pixel 1 is (1.000000 2.000000) +Image 1, questionable pixel 2 is (3.000000 9.000000) +Image 1, questionable pixel 3 is (4.000000 5.000000) +Image 1, questionable pixel 4 is (3.000000 8.000000) +Image 2, questionable pixel 0 is (9.000000 9.000000) +Image 2, questionable pixel 1 is (0.000000 5.000000) +Image 2, questionable pixel 2 is (6.000000 2.000000) +Image 2, questionable pixel 3 is (3.000000 7.000000) +Image 3, questionable pixel 0 is (7.000000 5.000000) + + + +Calling pmRejectPixels() with acceptable data. Should generate a psArray. +tst_pmImageCombine.c: Image 0 had 0 rejects. +tst_pmImageCombine.c: Image 1 had 4 rejects. +Image 1, rejected pixel 0 is (0.000000 8.000000) +Image 1, rejected pixel 1 is (1.000000 2.000000) +Image 1, rejected pixel 2 is (4.000000 5.000000) +Image 1, rejected pixel 3 is (3.000000 8.000000) +tst_pmImageCombine.c: Image 2 had 3 rejects. +Image 2, rejected pixel 0 is (0.000000 5.000000) +Image 2, rejected pixel 1 is (6.000000 2.000000) +Image 2, rejected pixel 2 is (3.000000 7.000000) +tst_pmImageCombine.c: Image 3 had 1 rejects. +Image 3, rejected pixel 0 is (7.000000 5.000000) +tst_pmImageCombine.c: Image 4 had 0 rejects. Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/imcombine/verified/tst_pmReadoutCombine.stderr =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/imcombine/verified/tst_pmReadoutCombine.stderr (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/imcombine/verified/tst_pmReadoutCombine.stderr (revision 21664) @@ -0,0 +1,42 @@ +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmReadoutCombine.c * +* TestPoint: Test Point Driver{pmSubtractBias(): Basic readout combines with no image overla * +* TestType: Positive * +\**********************************************************************************/ + + +---> TESTPOINT PASSED (Test Point Driver{pmSubtractBias(): Basic readout combines with no image overlap} | tst_pmReadoutCombine.c) + +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmReadoutCombine.c * +* TestPoint: Test Point Driver{pmSubtractBias(): input parameter error conditions} * +* TestType: Positive * +\**********************************************************************************/ + +|E|pmReadoutCombine (FILE:LINENO) + zero vector has incorrect size (5). Returning NULL. +|E|pmReadoutCombine (FILE:LINENO) + Unallowable operation: psVector zero has incorrect type. +|W|pmReadoutCombine + WARNING: the zero vector too many elements (11) +|E|pmReadoutCombine (FILE:LINENO) + scale vector has incorrect size (5). Returning NULL. +|E|pmReadoutCombine (FILE:LINENO) + Unallowable operation: psVector scale has incorrect type. +|W|pmReadoutCombine + WARNING: the scale vector has too many elements (20) +|E|pmReadoutCombine (FILE:LINENO) + Output image (1, 1) is too small to hold combined images. Returning NULL. +|E|pmReadoutCombine (FILE:LINENO) + Output image offset is larger then input image offset. Returning NULL. +|E|pmReadoutCombine (FILE:LINENO) + Unallowable operation: inputs is NULL. +|E|pmReadoutCombine (FILE:LINENO) + Unallowable operation: params is NULL. +|E|pmReadoutCombine (FILE:LINENO) + Multiple statistical options have been requested. Returning NULL. +|E|pmReadoutCombine (FILE:LINENO) + Unallowable operation: params->stats is NULL. + +---> TESTPOINT PASSED (Test Point Driver{pmSubtractBias(): input parameter error conditions} | tst_pmReadoutCombine.c) + Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/imcombine/verified/tst_pmReadoutCombine.stdout =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/imcombine/verified/tst_pmReadoutCombine.stdout (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/imcombine/verified/tst_pmReadoutCombine.stdout (revision 21664) @@ -0,0 +1,79 @@ +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmReadoutCombine.c * +* TestPoint: pmReadoutCombine{simpleCombineNoOverlap} * +* TestType: Positive * +\**********************************************************************************/ + +tst_pmReadoutCombine(): (minOutRow, minOutCol) to (maxOutRow, maxOutCol) is (0, 0) (1, 1) + +---> TESTPOINT PASSED (pmReadoutCombine{simpleCombineNoOverlap} | tst_pmReadoutCombine.c) + +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmReadoutCombine.c * +* TestPoint: pmReadoutCombine{simpleCombineNoOverlap} * +* TestType: Positive * +\**********************************************************************************/ + +tst_pmReadoutCombine(): (minOutRow, minOutCol) to (maxOutRow, maxOutCol) is (0, 0) (1, 20) + +---> TESTPOINT PASSED (pmReadoutCombine{simpleCombineNoOverlap} | tst_pmReadoutCombine.c) + +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmReadoutCombine.c * +* TestPoint: pmReadoutCombine{simpleCombineNoOverlap} * +* TestType: Positive * +\**********************************************************************************/ + +tst_pmReadoutCombine(): (minOutRow, minOutCol) to (maxOutRow, maxOutCol) is (0, 0) (20, 1) + +---> TESTPOINT PASSED (pmReadoutCombine{simpleCombineNoOverlap} | tst_pmReadoutCombine.c) + +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmReadoutCombine.c * +* TestPoint: pmReadoutCombine{simpleCombineNoOverlap} * +* TestType: Positive * +\**********************************************************************************/ + +tst_pmReadoutCombine(): (minOutRow, minOutCol) to (maxOutRow, maxOutCol) is (0, 0) (20, 20) + +---> TESTPOINT PASSED (pmReadoutCombine{simpleCombineNoOverlap} | tst_pmReadoutCombine.c) + +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmReadoutCombine.c * +* TestPoint: pmReadoutCombine{Testing bad input parameter conditions} * +* TestType: Positive * +\**********************************************************************************/ + +---------------------------------------------------------------------------- +Calling pmReadoutCombine() with NULL zero vector. +---------------------------------------------------------------------------- +Calling pmReadoutCombine() with incorrect length zero vector (too small). Should generate error. +---------------------------------------------------------------------------- +Calling pmReadoutCombine() with incorrect type zero vector. Should generate error. +---------------------------------------------------------------------------- +Calling pmReadoutCombine() with incorrect length zero vector (too big). Should generate warning. +---------------------------------------------------------------------------- +Calling pmReadoutCombine() with NULL scale vector. +---------------------------------------------------------------------------- +Calling pmReadoutCombine() with incorrect length scale vector (too small). Should generate error. +---------------------------------------------------------------------------- +Calling pmReadoutCombine() with incorrect type scale vector. Should generate error. +---------------------------------------------------------------------------- +Calling pmReadoutCombine() with incorrect length scale vector (too big). Should generate warning. +---------------------------------------------------------------------------- +Calling pmReadoutCombine() insufficient size output image. Should generate error, return NULL. +---------------------------------------------------------------------------- +Calling pmReadoutCombine() row0/col0 too large. Should generate error, return NULL. +---------------------------------------------------------------------------- +Calling pmReadoutCombine() with NULL input list. Should generate error, return NULL. +---------------------------------------------------------------------------- +Calling pmReadoutCombine() with NULL params. Should generate error, return NULL. +---------------------------------------------------------------------------- +Calling pmReadoutCombine() with multiple stats->options. Should generate error, return NULL. +---------------------------------------------------------------------------- +Calling pmReadoutCombine() with NULL param->stats. Should generate error, return NULL. +---------------------------------------------------------------------------- +============================================================================ + +---> TESTPOINT PASSED (pmReadoutCombine{Testing bad input parameter conditions} | tst_pmReadoutCombine.c) + Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/imsubtract/.cvsignore =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/imsubtract/.cvsignore (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/imsubtract/.cvsignore (revision 21664) @@ -0,0 +1,8 @@ +.deps +.libs +Makefile +Makefile.in +temp +tst_pmImageSubtract +tst_pmSubtractBias +tst_pmSubtractSky Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/imsubtract/Makefile.am =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/imsubtract/Makefile.am (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/imsubtract/Makefile.am (revision 21664) @@ -0,0 +1,26 @@ +# Makefile for psModule tests + +AM_LDFLAGS = -L$(top_builddir)/src -lpsmodule $(PSMODULE_LIBS) +AM_CFLAGS = @AM_CFLAGS@ $(PSMODULE_CFLAGS) $(SRCINC) +AM_CPPFLAGS = $(SRCINC) $(PSLIB_CFLAGS) + +TESTS = \ + tst_pmImageSubtract \ + tst_pmSubtractBias \ + tst_pmSubtractSky + +tst_pmImageSubtract_SOURCES = tst_pmImageSubtract.c +tst_pmSubtractBias_SOURCES = tst_pmSubtractBias.c +tst_pmSubtractSky_SOURCES = tst_pmSubtractSky.c + +check_PROGRAMS = $(TESTS) + +TESTS_ENVIRONMENT = perl $(top_srcdir)/test/runTest --verified=$(srcdir)/verified + +tests: $(TESTS) + +EXTRA_DIST = verified + +CLEANFILES = $(TESTS) temp/* + +test: check Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/imsubtract/tst_pmImageSubtract.c =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/imsubtract/tst_pmImageSubtract.c (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/imsubtract/tst_pmImageSubtract.c (revision 21664) @@ -0,0 +1,843 @@ +/** @file tst_pmImageSubtract.c + * + * @brief Contains the tests for pmImageSubtract.c: + * + * test00: This code will test the various functions in pmObjects.c + * + * @author GLG, MHPCC + * + * XXX: Most test simply ensure that the functions can be called with allowable + * data. More work need to be done to verify the results. + * + * @version $Revision: 1.1 $ $Name: not supported by cvs2svn $ + * @date $Date: 2005-09-28 20:42:52 $ + * + * Copyright 2004 Maui High Performance Computing Center, University of Hawaii + */ +#include "psTest.h" +#include "pslib.h" +#include "pmImageSubtract.h" +#define ERROR_TOLERANCE 1.0 +static int test00(void); +static int test01(void); +static int test02(void); +static int test03(void); +testDescription tests[] = { + {test00, 000, "pmSubtractionKernelsAllocPOIS()", true, false}, + {test01, 000, "pmSubtractionKernelsAllocISIS()", true, false}, + {test02, 000, "pmSubtractionFindStamps()", true, false}, + {test03, 000, "pmSubtractionCalculateEquation()", true, false}, + {NULL} + }; + +int main(int argc, char* argv[]) +{ + psLogSetFormat("HLNM"); + return !runTestSuite(stderr, "Test Point Driver", tests, argc, argv); +} + + +/******************************************************************************* +NOTE: This function returns FALSE if there were no errors. + +XXX: Call with various unallowable input parameters. + +XXX: Untested: we don't loop through the (u, v, xOrder, yOrder) psVectors and +ensure that each value is set correctly. + ******************************************************************************/ +psBool testPOISAlloc(psS32 size, + psS32 SpatialOrder) +{ + printf("Testing pmSubtractionKernelsAllocPOIS(%d, %d)\n", size, SpatialOrder); + + bool testStatus = false; + psS32 nBasisFunctions = (2 * size + 1) * (2 * size + 1) * (SpatialOrder + 1) * (SpatialOrder + 2) / 2; + + psSubtractionKernels *kernels = pmSubtractionKernelsAllocPOIS(size, SpatialOrder); + if (kernels == NULL) { + printf("TEST ERROR: pmSubtractionKernelsAllocPOIS() returned a NULL psSubtractionKernels.\n"); + testStatus = true; + } else { + if (kernels->type != PM_SUBTRACTION_KERNEL_POIS) { + printf("TEST ERROR: pmSubtractionKernelsAllocPOIS() generated the wrong kernels->type.\n"); + testStatus = true; + } + + if ((kernels->u == NULL) || + (kernels->u->n != nBasisFunctions)) { + printf("TEST ERROR: pmSubtractionKernelsAllocPOIS() generated a NULL ->u member or\n"); + printf("TEST ERROR: pmSubtractionKernelsAllocPOIS() generated a incorrect length ->u member.\n"); + testStatus = true; + } + + if ((kernels->v == NULL) || + (kernels->v->n != nBasisFunctions)) { + printf("TEST ERROR: pmSubtractionKernelsAllocPOIS() generated a NULL ->v member or\n"); + printf("TEST ERROR: pmSubtractionKernelsAllocPOIS() generated a incorrect length ->v member.\n"); + testStatus = true; + } + + if (kernels->sigma != NULL) { + printf("TEST ERROR: pmSubtractionKernelsAllocPOIS() generated a non-NULL ->sigma member.\n"); + testStatus = true; + } + + if ((kernels->xOrder == NULL) || + (kernels->xOrder->n != nBasisFunctions)) { + printf("TEST ERROR: pmSubtractionKernelsAllocPOIS() generated a NULL ->xOrder member or\n"); + printf("TEST ERROR: pmSubtractionKernelsAllocPOIS() generated a incorrect length ->xOrder member.\n"); + testStatus = true; + } + + if ((kernels->yOrder == NULL) || + (kernels->yOrder->n != nBasisFunctions)) { + printf("TEST ERROR: pmSubtractionKernelsAllocPOIS() generated a NULL ->yOrder member or\n"); + printf("TEST ERROR: pmSubtractionKernelsAllocPOIS() generated a incorrect length ->yOrder member.\n"); + testStatus = true; + } + + if (kernels->subIndex != 0) { + printf("TEST ERROR: pmSubtractionKernelsAllocPOIS() generated a non-zero ->subIndex member (%d).\n", kernels->subIndex); + testStatus = true; + } + + psS32 i = kernels->subIndex; + if ((kernels->u->data.F32[i] != 0) || + (kernels->v->data.F32[i] != 0)) { + printf("TEST ERROR: pmSubtractionKernelsAllocPOIS(): the ->subIndex member points to a kernel with (%f, %f) (u, v) basis function.\n", + kernels->u->data.F32[i], kernels->v->data.F32[i]); + testStatus = true; + } + + if (kernels->preCalc != NULL) { + printf("TEST ERROR: pmSubtractionKernelsAllocPOIS() generated a non-NULL ->preCalc member.\n"); + testStatus = true; + } + + if (kernels->size != size) { + printf("TEST ERROR: pmSubtractionKernelsAllocPOIS() generated an incorrect ->size member (%d).\n", kernels->size); + testStatus = true; + } + + if (kernels->spatialOrder != SpatialOrder) { + printf("TEST ERROR: pmSubtractionKernelsAllocPOIS() generated an incorrect ->spatialOrder member (%d).\n", kernels->spatialOrder); + testStatus = true; + } + } + psFree(kernels); + return(testStatus); +} + +/******************************************************************************* +NOTE: This function returns TRUE if there were no errors. + ******************************************************************************/ +int test00( void ) +{ + bool testStatus = false; + + testStatus|= testPOISAlloc(1, 1); + testStatus|= testPOISAlloc(2, 3); + testStatus|= testPOISAlloc(3, 4); + + return(!testStatus); +} + +/******************************************************************************* +NOTE: This function returns FALSE if there were no errors. + +XXX: Call with various unallowable input parameters. + +XXX: Untested: we don't loop through the (u, v, xOrder, yOrder) psVectors and +ensure that each value is set correctly. We don't ensure that he preCalc +psImages are set correctly. + ******************************************************************************/ +psBool testISISAlloc(psS32 sigmaLength, + psS32 orderLength, + psS32 size, + psS32 SpatialOrder) +{ + printf("Testing pmSubtractionKernelsAllocISIS(%d, %d, %d, %d)\n", + sigmaLength, orderLength, size, SpatialOrder); + + psVector *sigmas = psVectorAlloc(sigmaLength, PS_TYPE_F32); + for (psS32 i = 0 ; i < sigmas->n ; i++) { + sigmas->data.F32[i] = 1.0 + (psF32) i; + } + psVector *orders = psVectorAlloc(orderLength, PS_TYPE_S32); + for (psS32 i = 0 ; i < orders->n ; i++) { + orders->data.S32[i] = i + 2; + } + + bool testStatus = false; + psS32 numSigmas = sigmas->n; + psS32 nBasisFunctions = 0; + for (psS32 s = 0 ; s < numSigmas ; s++) { + for (psS32 o = 0 ; o < orders->n ; o++) { + nBasisFunctions+= ((orders->data.S32[o] + 1) * (orders->data.S32[o] + 2) / 2); + } + } + nBasisFunctions*= ((SpatialOrder + 1) * (SpatialOrder + 2) / 2); + + psSubtractionKernels *kernels = pmSubtractionKernelsAllocISIS(sigmas, orders, size, SpatialOrder); + if (kernels == NULL) { + printf("TEST ERROR: pmSubtractionKernelsAllocISIS() returned a NULL psSubtractionKernels.\n"); + testStatus = true; + } else { + if (kernels->type != PM_SUBTRACTION_KERNEL_ISIS) { + printf("TEST ERROR: pmSubtractionKernelsAllocISIS() generated the wrong kernels->type.\n"); + testStatus = true; + } + + if ((kernels->u == NULL) || + (kernels->u->n != nBasisFunctions)) { + printf("TEST ERROR: pmSubtractionKernelsAllocISIS() generated a NULL ->u member or\n"); + printf("TEST ERROR: pmSubtractionKernelsAllocISIS() generated a incorrect length ->u member.\n"); + testStatus = true; + } + + if ((kernels->v == NULL) || + (kernels->v->n != nBasisFunctions)) { + printf("TEST ERROR: pmSubtractionKernelsAllocISIS() generated a NULL ->v member or\n"); + printf("TEST ERROR: pmSubtractionKernelsAllocISIS() generated a incorrect length ->v member.\n"); + testStatus = true; + } + + if ((kernels->sigma == NULL) || + (kernels->sigma->n != nBasisFunctions)) { + printf("TEST ERROR: pmSubtractionKernelsAllocISIS() generated a NULL ->sigma member or\n"); + printf("TEST ERROR: pmSubtractionKernelsAllocISIS() generated a incorrect length ->sigma member.\n"); + testStatus = true; + } + + if ((kernels->xOrder == NULL) || + (kernels->xOrder->n != nBasisFunctions)) { + printf("TEST ERROR: pmSubtractionKernelsAllocISIS() generated a NULL ->xOrder member or\n"); + printf("TEST ERROR: pmSubtractionKernelsAllocISIS() generated a incorrect length ->xOrder member.\n"); + testStatus = true; + } + + if ((kernels->yOrder == NULL) || + (kernels->yOrder->n != nBasisFunctions)) { + printf("TEST ERROR: pmSubtractionKernelsAllocISIS() generated a NULL ->yOrder member or\n"); + printf("TEST ERROR: pmSubtractionKernelsAllocISIS() generated a incorrect length ->yOrder member.\n"); + testStatus = true; + } + + if (kernels->subIndex != 0) { + printf("TEST ERROR: pmSubtractionKernelsAllocISIS() generated a non-zero ->subIndex member (%d).\n", kernels->subIndex); + testStatus = true; + } + + // + // Ensure that kernels->subIndex points to the correct kernel. + // + psS32 i = kernels->subIndex; + if ((kernels->u->data.F32[i] != 0.0) || + (kernels->v->data.F32[i] != 0.0) || + (kernels->xOrder->data.F32[i] != 0.0) || + (kernels->yOrder->data.F32[i] != 0.0) || + (kernels->sigma->data.F32[i] != sigmas->data.F32[0])) { + printf("TEST ERROR: pmSubtractionKernelsAllocISIS(): the ->subIndex member points to the wrong kernel.\n"); + printf("TEST ERROR: (u, v, xOrder, yOrder, sigma) is (%f, %f, %f, %f, %f).\n", + kernels->u->data.F32[i], kernels->v->data.F32[i], + kernels->xOrder->data.F32[i], kernels->yOrder->data.F32[i], + kernels->sigma->data.F32[i]); + testStatus = true; + } + + // + // Ensure that the preCalc images are allocated correctly. + // + if ((kernels->preCalc == NULL) || + (kernels->preCalc->n != nBasisFunctions)) { + printf("TEST ERROR: pmSubtractionKernelsAllocISIS() generated a NULL ->preCalc member or\n"); + printf("TEST ERROR: pmSubtractionKernelsAllocISIS() generated a incorrect length ->preCalc member.\n"); + testStatus = true; + } else { + for (psS32 k = 0 ; k < kernels->u->n ; k++) { + psImage *kerImg = (psImage *) kernels->preCalc->data[k]; + if (kerImg == NULL) { + printf("TEST ERROR: the %d-th kernel preCalc image is NULL.\n", k); + testStatus = true; + } else { + if (kerImg->type.type != PS_TYPE_F32) { + printf("TEST ERROR: preCalc image %d had ioncorrect type.\n", k); + testStatus = true; + } + if ((kerImg->numRows != (1 + (2 * size))) || + (kerImg->numCols != (1 + (2 * size)))) { + printf("TEST ERROR: preCalc image %d had incorrect size (%d, %d).\n", k, + kerImg->numRows, kerImg->numCols); + testStatus = true; + } + } + } + } + + if (kernels->size != size) { + printf("TEST ERROR: pmSubtractionKernelsAllocISIS() generated an incorrect ->size member (%d).\n", kernels->size); + testStatus = true; + } + + if (kernels->spatialOrder != SpatialOrder) { + printf("TEST ERROR: pmSubtractionKernelsAllocISIS() generated an incorrect ->spatialOrder member (%d).\n", kernels->spatialOrder); + testStatus = true; + } + } + psFree(sigmas); + + psFree(kernels->u); + psFree(kernels->v); + psFree(kernels->sigma); + psFree(kernels->xOrder); + psFree(kernels->yOrder); + psFree(kernels->preCalc); + psFree(kernels); + psFree(orders); + return(testStatus); +} + +/******************************************************************************* +NOTE: This function returns TRUE if there were no errors. + ******************************************************************************/ +int test01( void ) +{ + bool testStatus = false; + + /* + testStatus|= testISISAlloc(1, 1, 1, 1); + testStatus|= testISISAlloc(2, 2, 2, 2); + testStatus|= testISISAlloc(2, 3, 4, 5); + testStatus|= testISISAlloc(3, 4, 5, 6); + */ + + return(!testStatus); +} + + +/******************************************************************************* +NOTE: This function returns FALSE if there were no errors. + +XXX: Can we test to ensure that no stamps overlap? + +XXX: Test stamp alloc/dealloc functions. + ******************************************************************************/ +#define TST02_THRESHOLD 3.0 +#define TST02_MASK_VAL 1 +psBool testFindStamps(psS32 numCols, + psS32 numRows, + psS32 xNum, + psS32 yNum, + psS32 border) +{ + printf("Testing pmSubtractionFindStamps(%d, %d, %d, %d, %d)\n", + numCols, numRows, xNum, yNum, border); + bool testStatus = false; + + // Create a test image and set a single pixel in the center of each stamp. + psImage *tstImg = psImageAlloc(numCols, numRows, PS_TYPE_F32); + int numStamps = 0; + PS_IMAGE_SET_F32(tstImg, 0.0); + for (psS32 j = 0; j < yNum; j++) { + for (psS32 i = 0; i < xNum; i++) { + psS32 yMin = border + j * (numRows - 2.0 * border) / yNum; + psS32 yMax = PS_MIN(numRows-1, (border + (j + 1) * (numRows - 2.0 * border) / yNum) - 1); + psS32 xMin = border + i * (numCols - 2.0 * border) / xNum; + psS32 xMax = PS_MIN(numCols-1, (border + (i + 1) * (numCols - 2.0 * border) / xNum) - 1); + + tstImg->data.F32[(yMax+yMin)/2][(xMax+xMin)/2] = TST02_THRESHOLD + (psF32) (i + j); + numStamps++; + } + } + psImage *tmpMask= psImageAlloc(numCols, numRows, PS_TYPE_U8); + PS_IMAGE_SET_U8(tstImg, 0); + + //------------------------------------------------------------------------- + printf("Calling with a NULL psImage. Should generate error, return NULL.\n"); + psArray *stamps = pmSubtractionFindStamps(NULL, NULL, tmpMask, TST02_MASK_VAL, + TST02_THRESHOLD, xNum, yNum, + border); + if (stamps != NULL) { + printf("TEST ERROR: pmSubtractionFindStamps returned a non-NULL psArray.\n"); + psFree(stamps); + testStatus = true; + } + + //------------------------------------------------------------------------- + printf("Calling with a non-positive xNum. Should generate error, return NULL.\n"); + stamps = pmSubtractionFindStamps(NULL, tstImg, tmpMask, TST02_MASK_VAL, + TST02_THRESHOLD, 0, yNum, + border); + if (stamps != NULL) { + printf("TEST ERROR: pmSubtractionFindStamps returned a non-NULL psArray.\n"); + psFree(stamps); + testStatus = true; + } + + //------------------------------------------------------------------------- + printf("Calling with a non-positive yNum. Should generate error, return NULL.\n"); + stamps = pmSubtractionFindStamps(NULL, tstImg, tmpMask, TST02_MASK_VAL, + TST02_THRESHOLD, xNum, 0, + border); + if (stamps != NULL) { + printf("TEST ERROR: pmSubtractionFindStamps returned a non-NULL psArray.\n"); + psFree(stamps); + testStatus = true; + } + + //------------------------------------------------------------------------- + printf("Calling with a non-positive border. Should generate error, return NULL.\n"); + stamps = pmSubtractionFindStamps(NULL, tstImg, tmpMask, TST02_MASK_VAL, + TST02_THRESHOLD, xNum, yNum, + 0); + if (stamps != NULL) { + printf("TEST ERROR: pmSubtractionFindStamps returned a non-NULL psArray.\n"); + psFree(stamps); + testStatus = true; + } + + //------------------------------------------------------------------------- + printf("Calling with acceptable input parameters, non-NULL mask.\n"); + stamps = pmSubtractionFindStamps(NULL, tstImg, tmpMask, TST02_MASK_VAL, + TST02_THRESHOLD, xNum, yNum, + border); + if (stamps == NULL) { + printf("TEST ERROR: pmSubtractionFindStamps returned a non-NULL psArray.\n"); + testStatus = true; + } else { + if (stamps->n != numStamps) { + printf("TEST ERROR: %ld stamps were found, %d were expected.\n", + stamps->n, numStamps); + testStatus = true; + } + for (psS32 s = 0 ; s < stamps->n ; s++) { + pmStamp *stamp = (pmStamp *) stamps->data[s]; + psS32 row = stamp->y; + psS32 col = stamp->x; + // printf("Stamp %d at (%d, %d) has a value of %f\n", s, row, col, tstImg->data.F32[row][col]); + if (tstImg->data.F32[row][col] < TST02_THRESHOLD) { + if (stamp->status != PM_STAMP_NONE) { + printf("TEST ERROR: stamp %d had peak value %f (below theshold) and the status was not set to PM_STAMP_NONE.\n", + s, tstImg->data.F32[row][col]); + testStatus = true; + } + } else { + if (stamp->status != PM_STAMP_RECALC) { + printf("TEST ERROR: stamp %d had peak value %f (above theshold) and the status was not set to PM_STAMP_RECALC.\n", + s, tstImg->data.F32[row][col]); + testStatus = true; + } + } + } + } + psFree(stamps); + + //------------------------------------------------------------------------- + printf("Calling with acceptable input parameters, NULL mask.\n"); + stamps = pmSubtractionFindStamps(NULL, tstImg, NULL, TST02_MASK_VAL, + TST02_THRESHOLD, xNum, yNum, + border); + if (stamps == NULL) { + printf("TEST ERROR: pmSubtractionFindStamps returned a non-NULL psArray.\n"); + testStatus = true; + } else { + if (stamps->n != numStamps) { + printf("TEST ERROR: %ld stamps were found, %d were expected.\n", + stamps->n, numStamps); + testStatus = true; + } + for (psS32 s = 0 ; s < stamps->n ; s++) { + pmStamp *stamp = (pmStamp *) stamps->data[s]; + psS32 row = stamp->y; + psS32 col = stamp->x; + //printf("Stamp %d at (%d, %d) has a value of %f\n", s, row, col, tstImg->data.F32[row][col]); + if (tstImg->data.F32[row][col] < TST02_THRESHOLD) { + if (stamp->status != PM_STAMP_NONE) { + printf("TEST ERROR: stamp %d had peak value %f (below theshold) and the status was not set to PM_STAMP_NONE.\n", + s, tstImg->data.F32[row][col]); + testStatus = true; + } + } else { + if (stamp->status != PM_STAMP_RECALC) { + printf("TEST ERROR: stamp %d had peak value %f (above theshold) and the status was not set to PM_STAMP_RECALC.\n", + s, tstImg->data.F32[row][col]); + testStatus = true; + } + } + } + } + + psFree(tstImg); + psFree(tmpMask); + psFree(stamps); + + return(testStatus); +} + + + +/******************************************************************************* +NOTE: This function returns TRUE if there were no errors. + ******************************************************************************/ +int test02( void ) +{ + bool testStatus = false; + + testStatus|= testFindStamps(100, 100, 2, 2, 2); + testStatus|= testFindStamps(100, 100, 10, 10, 2); + + return(!testStatus); +} + + +psF32 genRanFloat(psF32 low, + psF32 high) +{ + psF32 ran1 = (((psF32) (random() % 10000)) / 10000.0); + return(low + (ran1 * (high - low))); +} + +// +// XXX: POIS kernels are producing NANs if the image size is 20 or less. +// +// XXX: ISIS kernels are producing NANS if the TST03_ORDER_LENGTH is 2 or larger. +// +#define TST03_THRESHOLD 3.0 +#define TST03_MASK_VAL 1 +#define TST03_KERNEL_SIZE 2 +#define TST03_SPATIAL_ORDER 2 +#define TST03_ORDER_LENGTH 1 +#define TST03_SIGMA_LENGTH 1 +#define TST03_PSF_MAX 10.0 +#define TST03_BG 0.0 +#define TST03_IMAGE_SIZE 25 +#define TST03_NUM_COLS TST03_IMAGE_SIZE +#define TST03_NUM_ROWS TST03_IMAGE_SIZE +#define TST03_NUM_STAMPS 2 +#define TST03_NUM_STAMPS_COLS TST03_NUM_STAMPS +#define TST03_NUM_STAMPS_ROWS TST03_NUM_STAMPS +#define TST03_BORDER TST03_KERNEL_SIZE +//#define TST03_FOOTPRINT (((TST03_IMAGE_SIZE - (2 * TST03_BORDER)) / TST03_NUM_STAMPS) - TST03_KERNEL_SIZE) +#define TST03_FOOTPRINT 4 +#define TST03_PSF_WIDTH (TST03_FOOTPRINT/2 - 1) + +/******************************************************************************* +This routine generates an object in the center of the stamp defined by the +(xMin, xMax) and (yMin, yMax) boundary. + ******************************************************************************/ +psBool genObject(psImage *tstImg, + psImage *refImg, + psS32 xMin, + psS32 xMax, + psS32 yMin, + psS32 yMax) +{ + if (((1 + 2 * TST03_PSF_WIDTH) > (xMax - xMin)) || + ((1 + 2 * TST03_PSF_WIDTH) > (yMax - yMin))) { + printf("INCORRECT TEST CONFIGURATION: TST03_PSF_WIDTH is too big.\n"); + printf("TST03_PSF_WIDTH is %d: (xMin - xMax) is %d\n", TST03_PSF_WIDTH, (xMax - xMin)); + return(FALSE); + } + // + // This code basically creates a peak at the center of the stamp with + // a height of TST03_PSF_MAX + // + psS32 xCenter = (xMax + xMin) / 2; + psS32 yCenter = (yMax + yMin) / 2; + psF32 subImageWidth = 1.0 + sqrtf(PS_SQR(((psF32) ((yMax-yMin)/2))) + PS_SQR(((psF32) ((xMax-xMin)/2)))); + for (psS32 y = yMin ; y <= yMax ; y++) { + for (psS32 x = xMin ; x <= xMax ; x++) { + psF32 dist = sqrtf(PS_SQR((psF32) (y - yCenter)) + PS_SQR((psF32) (x - xCenter))); + psF32 pixel = TST03_PSF_MAX * PS_SQR(((psF32) (subImageWidth - dist)) / ((psF32) subImageWidth)); + if (pixel < 0.0) { + pixel = 0.0; + } + refImg->data.F32[y][x] = pixel + TST03_BG; + tstImg->data.F32[y][x] = pixel + TST03_BG; + // Add some noise for the test image. + tstImg->data.F32[y][x]+= genRanFloat(0.0, 1.0); + } + } + + return(TRUE); +} + +/******************************************************************************* +NOTE: This function returns FALSE if there were no errors. + +XXX: We should use a larger variety of input parameter configurations. + +I test the following functions here (since they linearly rely on a set of data +structures that the previoues ones generate): + pmSubtractionCalculateEquation() + pmSubtractionSolveEquation() + pmSubtractionRejectStamps() + pmSubtractionKernelImage() + ******************************************************************************/ +psBool testSubCalcEqu(psS32 numCols, + psS32 numRows, + psS32 xNum, + psS32 yNum, + psS32 border, + pmSubtractionKernelsType KernelType) +{ + printf("Testing pmSubtractionCalculateEquation(): \n"); + printf(" image size is (%d, %d)\n", numRows, numCols); + printf(" num stamps is (%d, %d). Border is %d\n", yNum, xNum, border); + if (KernelType == PM_SUBTRACTION_KERNEL_POIS) { + printf(" kernel type is PM_SUBTRACTION_KERNEL_POIS.\n"); + } else if (KernelType == PM_SUBTRACTION_KERNEL_ISIS) { + printf(" kernel type is PM_SUBTRACTION_KERNEL_ISIS.\n"); + } + bool testStatus = false; + + // Create a test image and set a single pixel in the center of each stamp. + psImage *tstImg = psImageAlloc(numCols, numRows, PS_TYPE_F32); + psImage *refImg = psImageAlloc(numCols, numRows, PS_TYPE_F32); + psImage *maskImg = psImageAlloc(numCols, numRows, PS_TYPE_U8); + PS_IMAGE_SET_F32(tstImg, 0.0); + PS_IMAGE_SET_F32(maskImg, 0); + for (psS32 j = 0; j < yNum; j++) { + for (psS32 i = 0; i < xNum; i++) { + psS32 yMin = border + j * (numRows - 2.0 * border) / yNum; + psS32 yMax = PS_MIN(numRows-1, (border + (j + 1) * (numRows - 2.0 * border) / yNum) - 1); + psS32 xMin = border + i * (numCols - 2.0 * border) / xNum; + psS32 xMax = PS_MIN(numCols-1, (border + (i + 1) * (numCols - 2.0 * border) / xNum) - 1); + + genObject(tstImg, refImg, xMin, xMax, yMin, yMax); + } + } + printf("Generating stamps...\n"); + psArray *stamps = pmSubtractionFindStamps(NULL, tstImg, NULL, TST03_MASK_VAL, + TST03_THRESHOLD, xNum, yNum, + border); + + // + // PsVectors sigmas and orders are for ISIS kernels only. + // + psVector *sigmas = psVectorAlloc(TST03_SIGMA_LENGTH, PS_TYPE_F32); + for (psS32 i = 0 ; i < sigmas->n ; i++) { + sigmas->data.F32[i] = 1.0 + (psF32) i; + } + psVector *orders = psVectorAlloc(TST03_ORDER_LENGTH, PS_TYPE_S32); + for (psS32 i = 0 ; i < orders->n ; i++) { + orders->data.S32[i] = i + 2; + } + + // + // Create the subtraction kernels + // + printf("Generating kernel basis functions...\n"); + psSubtractionKernels *myKernels = NULL; + if (KernelType == PM_SUBTRACTION_KERNEL_POIS) { + myKernels = pmSubtractionKernelsAllocPOIS(TST03_KERNEL_SIZE, TST03_SPATIAL_ORDER); + } else if (KernelType == PM_SUBTRACTION_KERNEL_ISIS) { + myKernels = pmSubtractionKernelsAllocISIS(sigmas, orders, TST03_KERNEL_SIZE, TST03_SPATIAL_ORDER); + } + + if ((stamps == NULL) || + (myKernels == NULL)) { + printf("TEST ERROR: stamps or myKernels is NULL.\n"); + testStatus = true; + } else { + //------------------------------------------------------------------------- + printf("Calling with a NULL psArray stamps. Should generate error, return FALSE.\n"); + psBool rc = pmSubtractionCalculateEquation(NULL, refImg, tstImg, myKernels, TST03_FOOTPRINT); + if (rc == TRUE) { + printf("TEST ERROR: pmSubtractionCalculateEquation() returned TRUE.\n"); + testStatus = true; + } + + //------------------------------------------------------------------------- + printf("Calling with a NULL reference images. Should generate error, return FALSE.\n"); + rc = pmSubtractionCalculateEquation(stamps, NULL, tstImg, myKernels, TST03_FOOTPRINT); + if (rc == TRUE) { + printf("TEST ERROR: pmSubtractionCalculateEquation() returned TRUE.\n"); + testStatus = true; + } + + //------------------------------------------------------------------------- + printf("Calling with a NULL input images. Should generate error, return FALSE.\n"); + rc = pmSubtractionCalculateEquation(stamps, refImg, NULL, myKernels, TST03_FOOTPRINT); + if (rc == TRUE) { + printf("TEST ERROR: pmSubtractionCalculateEquation() returned TRUE.\n"); + testStatus = true; + } + + //------------------------------------------------------------------------- + printf("Calling with a NULL kernel basis functions. Should generate error, return FALSE.\n"); + rc = pmSubtractionCalculateEquation(stamps, refImg, tstImg, NULL, TST03_FOOTPRINT); + if (rc == TRUE) { + printf("TEST ERROR: pmSubtractionCalculateEquation() returned TRUE.\n"); + testStatus = true; + } + + //------------------------------------------------------------------------- + printf("Calling with acceptable input parameters. Should return TRUE.\n"); + + rc = pmSubtractionCalculateEquation(stamps, refImg, tstImg, myKernels, TST03_FOOTPRINT); + if (rc != TRUE) { + printf("TEST ERROR: pmSubtractionCalculateEquation() returned FALSE.\n"); + testStatus = true; + } else { + + if (0) { + for (psS32 s = 0 ; s < stamps->n ; s++) { + printf("********************************* Stamp %d *********************************\n", s); + pmStamp *stamp = (pmStamp *) stamps->data[s]; + if (stamp->vector != NULL) { + PS_VECTOR_PRINT_F64(stamp->vector); + } + if (stamp->matrix != NULL) { + printf("Stamp matrix size is (%d, %d)\n", stamp->matrix->numRows, stamp->matrix->numCols); + PS_IMAGE_PRINT_F64(stamp->matrix); + } + } + } + + + //------------------------------------------------------------------------- + printf("Calling pmSubtractionSolveEquation() with a NULL stamp argument. Should generate error, return FALSE.\n"); + psVector *solution = pmSubtractionSolveEquation(NULL, NULL); + if (solution != NULL) { + printf("TEST ERROR: pmSubtractionSolveEquation() returned non-NULL.\n"); + testStatus = true; + } + + //------------------------------------------------------------------------- + printf("Calling pmSubtractionSolveEquation() with acceptable input parameters. Should return non-NULL.\n"); + solution = pmSubtractionSolveEquation(NULL, stamps); + if (solution == NULL) { + printf("TEST ERROR: pmSubtractionSolveEquation() returned NULL.\n"); + testStatus = true; + } else { + printf("The solution vector is:\n"); + for (psS32 i = 0 ; i < solution->n ; i++) { + printf("(%.2f) ", solution->data.F64[i]); + } + printf("\n"); + + //------------------------------------------------------------------------- + printf("Calling pmSubtractionRejectStamps() with acceptable input parameters. Should return TRUE.\n"); + rc = pmSubtractionRejectStamps(stamps, maskImg, 0xff, TST03_FOOTPRINT, 1.0, refImg, + tstImg, solution, myKernels); + if (rc != TRUE) { + printf("TEST ERROR: pmSubtractionRejectStamps() returned FALSE.\n"); + testStatus = true; + } else {} + + //------------------------------------------------------------------------- + printf("Calling pmSubtractionKernelImage() with NULL solution. Should generate error, return NULL.\n"); + psImage *kernelImg = pmSubtractionKernelImage(NULL, NULL, myKernels, 0.0, 0.0); + if (kernelImg != NULL) { + printf("TEST ERROR: pmSubtractionKernelImage() returned non-NULL.\n"); + testStatus = true; + } + free(kernelImg); + + //------------------------------------------------------------------------- + printf("Calling pmSubtractionKernelImage() with NULL kernels. Should generate error, return NULL.\n"); + kernelImg = pmSubtractionKernelImage(NULL, solution, NULL, 0.0, 0.0); + if (kernelImg != NULL) { + printf("TEST ERROR: pmSubtractionKernelImage() returned non-NULL.\n"); + testStatus = true; + } + free(kernelImg); + + //------------------------------------------------------------------------- + printf("Calling pmSubtractionKernelImage() unallowable x value. Should generate error, return NULL.\n"); + kernelImg = pmSubtractionKernelImage(NULL, solution, myKernels, -2.0, 0.0); + if (kernelImg != NULL) { + printf("TEST ERROR: pmSubtractionKernelImage() returned non-NULL.\n"); + testStatus = true; + } + free(kernelImg); + + //------------------------------------------------------------------------- + printf("Calling pmSubtractionKernelImage() unallowable x value. Should generate error, return NULL.\n"); + kernelImg = pmSubtractionKernelImage(NULL, solution, myKernels, 2.0, 0.0); + if (kernelImg != NULL) { + printf("TEST ERROR: pmSubtractionKernelImage() returned non-NULL.\n"); + testStatus = true; + } + free(kernelImg); + + //------------------------------------------------------------------------- + printf("Calling pmSubtractionKernelImage() unallowable y value. Should generate error, return NULL.\n"); + kernelImg = pmSubtractionKernelImage(NULL, solution, myKernels, 0.0, -2.0); + if (kernelImg != NULL) { + printf("TEST ERROR: pmSubtractionKernelImage() returned non-NULL.\n"); + testStatus = true; + } + free(kernelImg); + + //------------------------------------------------------------------------- + printf("Calling pmSubtractionKernelImage() unallowable y value. Should generate error, return NULL.\n"); + kernelImg = pmSubtractionKernelImage(NULL, solution, myKernels, 0.0, 2.0); + if (kernelImg != NULL) { + printf("TEST ERROR: pmSubtractionKernelImage() returned non-NULL.\n"); + testStatus = true; + } + free(kernelImg); + + //------------------------------------------------------------------------- + printf("Calling pmSubtractionKernelImage() with acceptable input parameters. Should return a psImage.\n"); + kernelImg = pmSubtractionKernelImage(NULL, solution, myKernels, 0.5, 0.5); + if (kernelImg == NULL) { + printf("TEST ERROR: pmSubtractionKernelImage() returned NULL.\n"); + testStatus = true; + } else { + for (psS32 row = 0 ; row < kernelImg->numRows; row++) { + for (psS32 col = 0 ; col < kernelImg->numCols; col++) { + printf("%f ", kernelImg->data.F32[row][col]); + } + printf("\n"); + } + } + free(kernelImg); + + psFree(solution); + } + } + } + psFree(tstImg); + psFree(refImg); + psFree(stamps); + psFree(myKernels); + psFree(orders); + psFree(sigmas); + + return(testStatus); +} + +/******************************************************************************* +NOTE: This function returns TRUE if there were no errors. + ******************************************************************************/ +int test03( void ) +{ + bool testStatus = false; + + + srand(1995); + if (1) + testStatus|= testSubCalcEqu(TST03_NUM_COLS, + TST03_NUM_ROWS, + TST03_NUM_STAMPS_COLS, + TST03_NUM_STAMPS_ROWS, + TST03_BORDER, + PM_SUBTRACTION_KERNEL_POIS); + + + srand(1995); + if (1) + testStatus|= testSubCalcEqu(TST03_NUM_COLS, + TST03_NUM_ROWS, + TST03_NUM_STAMPS_COLS, + TST03_NUM_STAMPS_ROWS, + TST03_BORDER, + PM_SUBTRACTION_KERNEL_ISIS); + + + + return(!testStatus); +} Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/imsubtract/tst_pmSubtractBias.c =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/imsubtract/tst_pmSubtractBias.c (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/imsubtract/tst_pmSubtractBias.c (revision 21664) @@ -0,0 +1,1129 @@ +/** @file tst_pmSubtractBias.c + * + * @brief Contains the tests for pmSubtractBias.c: + * + * test00a: This code will subtract full bias frames from the input image. + * XXX: Must test: + * Various image offsets. + * Various image size combinations. + * Various data types for the bias and input images. + * Ensure code works when CELL.TRIMSEC is not set. + * test00b: This code will subtract full dark frames from the input image. + * XXX: Must test: + * Various image offsets. + * Various image size combinations. + * Various data types for the bias and input images. + * Code properly determines CELL.DARKTIME from cell metadata. + * Ensure code works when CELL.DARKTIME is not set. + * Ensure code works when CELL.TRIMSEC is not set. + * test03: Calculate a row overscan vector and subtract it from each + * row in the input image. + * test05: + * + * @author GLG, MHPCC + * + * XXX: Memory leaks are not being detected. + * + * @version $Revision: 1.5 $ $Name: not supported by cvs2svn $ + * @date $Date: 2005-11-23 23:54:30 $ + * + * Copyright 2004 Maui High Performance Computing Center, University of Hawaii + */ + +#include "psTest.h" +#include "pslib.h" +#include "pmSubtractBias.h" +static int test00a(void); +static int test00b(void); +//static int test01(void); +//static int test02(void); +//static int test03(void); +//static int test04(void); +static int test05(void); +testDescription tests[] = { + {test00a, 000, "doSubtractBiasFullFrame", 0, true}, + {test00b, 000, "doSubtractDarkFullFrame", 0, true}, + // {test01, 000, "pmSubtractBias", 0, true}, + // {test02, 000, "pmSubtractBias", 0, true}, + // {test03, 000, "pmSubtractBias", 0, true}, + // {test04, 000, "pmSubtractBias", 0, true}, + {test05, 000, "pmSubtractBias", 0, false}, + {NULL} + }; + +psS32 currentId = 0; +psS32 memLeaks = 0; // XXX: remove + +int main(int argc, char* argv[]) +{ + psLogSetFormat("HLNM"); + + psTraceSetLevel(".", 0); + psTraceSetLevel("spline1DFree", 0); + psTraceSetLevel("calculateSecondDerivs", 0); + psTraceSetLevel("vectorBinDisectF32", 0); + psTraceSetLevel("vectorBinDisectF64", 0); + psTraceSetLevel("p_psVectorBinDisect", 0); + psTraceSetLevel("psSpline1DAlloc", 0); + psTraceSetLevel("psVectorFitSpline1D", 0); + psTraceSetLevel("psSpline1DEval", 0); + psTraceSetLevel("psSpline1DEvalVector", 0); + + psS32 currentId = psMemGetId(); // XXX: remove + psS32 memLeaks = 0; // XXX: remove + if (0) { + PRINT_MEMLEAKS(0); + } + + return !runTestSuite(stderr, "Test Point Driver", tests, argc, argv); +} + +#define NUM_ROWS 8 +#define NUM_COLS 8 +#define MAX_HEADER_MSG_LENGTH 1000 +#define POLYNOMIAL_FIT_ORDER 2 +#define NUM_OVERSCANS 2 +/****************************************************************************** +doSubtractBiasFullFrame(): a sample pmReadout as well as a bias image are +created and the bias image is subtracted from the pmReadout. + *****************************************************************************/ +int doSubtractBiasFullFrame(int numCols, int numRows) +{ + int i; + int j; + float actual; + float expect; + int testStatus = 0; + psImage *tmpImage1 = psImageAlloc(numCols, numRows, PS_TYPE_F32); + psImage *tmpImage2 = psImageAlloc(numCols, numRows, PS_TYPE_F32); + pmReadout *myReadout = pmReadoutAlloc(NULL); + pmReadout *myBias = pmReadoutAlloc(NULL); + myReadout->image = tmpImage1; + myBias->image = tmpImage2; + + char *HeaderMessageStr = (char *) psAlloc(MAX_HEADER_MSG_LENGTH); + sprintf(HeaderMessageStr, "doSubtractBiasFullFrame(%d, %d)", numRows, numCols); + printPositiveTestHeader(stdout, "pmSubtractBias", HeaderMessageStr); + for (i=0;iimage->data.F32[i][j] = (float) (i + j); + myBias->image->data.F32[i][j] = 1.0; + } + } + + myReadout = pmSubtractBias(myReadout, NULL, PM_FIT_NONE, false, + NULL, 0, myBias, NULL); + + for (i=0;iimage->data.F32[i][j]; + if (FLT_EPSILON < fabs(expect - actual)) { + printf("TEST ERROR: image[%d][%d] is %f, should be %f\n", i, j, actual, expect); + testStatus = 1; + } + } + } + + + psFree(myReadout); + psFree(myBias); + printFooter(stdout, "pmSubtractBias", HeaderMessageStr, true); + psFree(HeaderMessageStr); + return(testStatus); +} + + +int test00a( void ) +{ + int testStatus = 0; + + testStatus |= doSubtractBiasFullFrame(1, 1); + testStatus |= doSubtractBiasFullFrame(NUM_COLS, 1); + testStatus |= doSubtractBiasFullFrame(1, NUM_ROWS); + testStatus |= doSubtractBiasFullFrame(NUM_COLS, NUM_ROWS); + return(testStatus); +} + + +/****************************************************************************** +doSubtractDarkFullFrame(): a sample pmReadout as well as a dark image are +created and the dark image is subtracted from the pmReadout. + *****************************************************************************/ +int doSubtractDarkFullFrame(int numCols, int numRows) +{ + int i; + int j; + float actual; + float expect; + int testStatus = 0; + psImage *tmpImage1 = psImageAlloc(numCols, numRows, PS_TYPE_F32); + psImage *tmpImage2 = psImageAlloc(numCols, numRows, PS_TYPE_F32); + pmReadout *myReadout = pmReadoutAlloc(NULL); + pmReadout *myDark = pmReadoutAlloc(NULL); + myReadout->image = tmpImage1; + myDark->image = tmpImage2; + + char *HeaderMessageStr = (char *) psAlloc(MAX_HEADER_MSG_LENGTH); + sprintf(HeaderMessageStr, "doSubtractDarkFullFrame(%d, %d)", numRows, numCols); + printPositiveTestHeader(stdout, "pmSubtractBias", HeaderMessageStr); + for (i=0;iimage->data.F32[i][j] = (float) (i + j); + myDark->image->data.F32[i][j] = 1.0; + } + } + + myReadout = pmSubtractBias(myReadout, NULL, PM_FIT_NONE, false, + NULL, 0, NULL, myDark); + + for (i=0;iimage->data.F32[i][j]; + if (FLT_EPSILON < fabs(expect - actual)) { + printf("TEST ERROR: image[%d][%d] is %f, should be %f\n", i, j, actual, expect); + testStatus = 1; + } + } + } + + + psFree(myReadout); + psFree(myDark); + printFooter(stdout, "pmSubtractBias", HeaderMessageStr, true); + psFree(HeaderMessageStr); + return(testStatus); +} + + +int test00b( void ) +{ + int testStatus = 0; + + testStatus |= doSubtractDarkFullFrame(1, 1); + testStatus |= doSubtractDarkFullFrame(NUM_COLS, 1); + testStatus |= doSubtractDarkFullFrame(1, NUM_ROWS); + testStatus |= doSubtractDarkFullFrame(NUM_COLS, NUM_ROWS); + return(testStatus); +} + + +/* +int doSubtractOverscansTestInputCases(int numCols, int numRows) +{ + int i; + int j; + int testStatus = 0; + psImage *tmpImage1 = psImageAlloc(numCols, numRows, PS_TYPE_F32); + psImage *tmpImage2 = psImageAlloc(numCols, numRows, PS_TYPE_F32); + psImage *tmpImage3 = psImageAlloc(numCols, numRows, PS_TYPE_F32); + psImage *tmpImage4 = psImageAlloc(numCols, numRows, PS_TYPE_F32); + psImage *tmpImage2Short = psImageAlloc(numCols-1, numRows-1, PS_TYPE_F32); + psImage *tmpImage3Short = psImageAlloc(numCols-1, numRows-1, PS_TYPE_F32); + psImage *tmpImage4Short = psImageAlloc(numCols-1, numRows-1, PS_TYPE_F32); + pmReadout *myReadout = pmReadoutAlloc(NULL); + myReadout->image = tmpImage1; + pmReadout *rc = NULL; + psList *list; + psList *listShort; + psStats *stat = psStatsAlloc(PS_STAT_SAMPLE_MEAN); + psImage *tmpImage5 = psImageAlloc(numCols, numRows, PS_TYPE_F32); + pmReadout *myBias = pmReadoutAlloc(NULL); + myBias->image = tmpImage5; + printPositiveTestHeader(stdout, "pmSubtractBias", "Testing input parameter error conditions"); + + psImage *tmpImage5ShortRows = psImageAlloc(numCols, numRows-1, PS_TYPE_F32); + pmReadout *myBiasShortRows = pmReadoutAlloc(NULL); + myBiasShortRows->image = tmpImage5ShortRows; + psImage *tmpImage5ShortCols = psImageAlloc(numCols-1, numRows, PS_TYPE_F32); + pmReadout *myBiasShortCols = pmReadoutAlloc(NULL); + myBiasShortCols->image = tmpImage5ShortCols; + + for (i=0;iimage->data.F32[i][j] = (float) (i + j); + tmpImage2->data.F32[i][j] = 3.0; + tmpImage3->data.F32[i][j] = 4.0; + tmpImage4->data.F32[i][j] = 5.0; + myBias->image->data.F32[i][j] = 1.0; + } + } + list = psListAlloc(tmpImage2); + psListAdd(list, PS_LIST_HEAD, tmpImage3); + psListAdd(list, PS_LIST_HEAD, tmpImage4); + + for (i=0;idata.F32[i][j] = 3.0; + tmpImage3Short->data.F32[i][j] = 4.0; + tmpImage4Short->data.F32[i][j] = 5.0; + } + } + listShort = psListAlloc(tmpImage2Short); + psListAdd(listShort, PS_LIST_HEAD, tmpImage3Short); + psListAdd(listShort, PS_LIST_HEAD, tmpImage4Short); + for (i=0;iimage->data.F32[i][j] = 1.0; + } + } + for (i=0;iimage->data.F32[i][j] = 1.0; + } + } + + + printf("------------------------------------------------------------------\n"); + printf("Calling pmSubtractBias() with NULL overscan list and PM_OVERSCAN_ALL. Should generate error.\n"); + rc = pmSubtractBias(myReadout, NULL, NULL, PM_OVERSCAN_ALL, stat, 0, PM_FIT_NONE, NULL); + if (rc != myReadout) { + printf("TEST ERROR: pmSubtractBias() did not return input pmReadout.\n"); + testStatus = false; + } + + printf("------------------------------------------------------------------\n"); + printf("Calling pmSubtractBias() with NULL overscan list and PM_OVERSCAN_ROWS. Should generate error.\n"); + rc = pmSubtractBias(myReadout, NULL, NULL, PM_OVERSCAN_ROWS, stat, 0, PM_FIT_NONE, NULL); + if (rc != myReadout) { + printf("TEST ERROR: pmSubtractBias() did not return input pmReadout.\n"); + testStatus = false; + psFree(rc); + } + + printf("------------------------------------------------------------------\n"); + printf("Calling pmSubtractBias() with NULL overscan list and PM_OVERSCAN_COLUMNS. Should generate error.\n"); + rc = pmSubtractBias(myReadout, NULL, NULL, PM_OVERSCAN_COLUMNS, stat, 0, PM_FIT_NONE, NULL); + if (rc != myReadout) { + printf("TEST ERROR: pmSubtractBias() did not return input pmReadout.\n"); + testStatus = false; + psFree(rc); + } + + printf("------------------------------------------------------------------\n"); + printf("Calling pmSubtractBias() with non-NULL overscan list and PM_OVERSCAN_NONE. Should generate warning.\n"); + rc = pmSubtractBias(myReadout, NULL, list, PM_OVERSCAN_NONE, stat, 0, PM_FIT_NONE, myBias); + + for (i=0;iimage->data.F32[i][j]; + if (FLT_EPSILON < fabs(expect - actual)) { + printf("TEST ERROR: image[%d][%d] is %f, should be %f\n", i, j, actual, expect); + testStatus = 1; + } + + // Restore myReadout for next test. + myReadout->image->data.F32[i][j] = (float) (i + j); + } + } + + // XXX: This does not seem to be a requirement. + if (0) { + printf("------------------------------------------------------------------\n"); + printf("Calling pmSubtractBias() with NULL overscan list and PM_OVERSCAN_NONE. Should generate warning.\n"); + rc = pmSubtractBias(myReadout, NULL, NULL, PM_OVERSCAN_NONE, stat, + 0, PM_FIT_NONE, myBias); + + for (i=0;iimage->data.F32[i][j]; + if (FLT_EPSILON < fabs(expect - actual)) { + printf("TEST ERROR: image[%d][%d] is %f, should be %f\n", i, j, actual, expect); + testStatus = 1; + } + + // Restore myReadout for next test. + myReadout->image->data.F32[i][j] = (float) (i + j); + } + } + } + + printf("------------------------------------------------------------------\n"); + printf("Calling pmSubtractBias() with PM_OVERSCAN_NONE and PM_FIT_POLYNOMIAL. Should generate Warning.\n"); + rc = pmSubtractBias(myReadout, NULL, NULL, PM_OVERSCAN_NONE, stat, 0, PM_FIT_POLYNOMIAL, myBias); + for (i=0;iimage->data.F32[i][j]; + if (FLT_EPSILON < fabs(expect - actual)) { + printf("TEST ERROR: image[%d][%d] is %f, should be %f\n", i, j, actual, expect); + testStatus = 1; + } + + // Restore myReadout for next test. + myReadout->image->data.F32[i][j] = (float) (i + j); + } + } + + + printf("------------------------------------------------------------------\n"); + printf("Calling pmSubtractBias() with PM_OVERSCAN_ALL and PM_FIT_SPLINE. Should generate Warning.\n"); + rc = pmSubtractBias(myReadout, NULL, NULL, PM_OVERSCAN_NONE, stat, 0, PM_FIT_SPLINE, myBias); + if (rc != myReadout) { + printf("TEST ERROR: pmSubtractBias() did not return input pmReadout.\n"); + testStatus = false; + psFree(rc); + } + + for (i=0;iimage->data.F32[i][j]; + if (FLT_EPSILON < fabs(expect - actual)) { + printf("TEST ERROR: image[%d][%d] is %f, should be %f\n", i, j, actual, expect); + testStatus = 1; + } + + // Restore myReadout for next test. + myReadout->image->data.F32[i][j] = (float) (i + j); + } + } + + + printf("------------------------------------------------------------------\n"); + printf("Calling pmSubtractBias() with multiple stats->options. Should generate Warning.\n"); + stat->options|= PS_STAT_SAMPLE_MEDIAN; + myReadout = pmSubtractBias(myReadout, NULL, list, PM_OVERSCAN_ALL, stat, + 0, PM_FIT_NONE, NULL); + for (i=0;iimage->data.F32[i][j]; + if (FLT_EPSILON < fabs(expect - actual)) { + printf("TEST ERROR: image[%d][%d] is %f, should be %f\n", i, j, actual, expect); + testStatus = 1; + } + } + } + stat->options = PS_STAT_SAMPLE_MEAN; + + printf("------------------------------------------------------------------\n"); + printf("Calling pmSubtractBias() undersize overscans (PM_OVERSCAN_ROWS). Should generate Warning.\n"); + rc = pmSubtractBias(myReadout, NULL, listShort, PM_OVERSCAN_ROWS, stat, + 0, PM_FIT_NONE, NULL); + if (0) { + for (i=0;iimage->data.F32[i][j]; + if (FLT_EPSILON < fabs(expect - actual)) { + printf("TEST ERROR: image[%d][%d] is %f, should be %f\n", i, j, actual, expect); + testStatus = 1; + } + } + } + } + + printf("------------------------------------------------------------------\n"); + printf("Calling pmSubtractBias() undersize overscans (PM_OVERSCAN_COLUMNS). Should generate Warning.\n"); + rc = pmSubtractBias(myReadout, NULL, listShort, PM_OVERSCAN_COLUMNS, stat, + 0, PM_FIT_NONE, NULL); + if (0) { + for (i=0;iimage->data.F32[i][j]; + if (FLT_EPSILON < fabs(expect - actual)) { + printf("TEST ERROR: image[%d][%d] is %f, should be %f\n", i, j, actual, expect); + testStatus = 1; + } + } + } + } + + printf("------------------------------------------------------------------\n"); + printf("Calling pmSubtractBias() undersize bias image (short rows). Should generate Error.\n"); + myReadout = pmSubtractBias(myReadout, NULL, NULL, PM_OVERSCAN_NONE, NULL, + 0, PM_FIT_NONE, myBiasShortRows); + if (rc != myReadout) { + printf("TEST ERROR: pmSubtractBias() did not return input pmReadout.\n"); + testStatus = false; + psFree(rc); + } + + + printf("------------------------------------------------------------------\n"); + printf("Calling pmSubtractBias() undersize bias image (short columns). Should generate Error.\n"); + myReadout = pmSubtractBias(myReadout, NULL, NULL, PM_OVERSCAN_NONE, NULL, + 0, PM_FIT_NONE, myBiasShortCols); + if (rc != myReadout) { + printf("TEST ERROR: pmSubtractBias() did not return input pmReadout.\n"); + testStatus = false; + psFree(rc); + } + + printf("------------------------------------------------------------------\n"); + printf("Calling pmSubtractBias() with bogus PM_FIT. Should generate Error.\n"); + myReadout = pmSubtractBias(myReadout, NULL, list, PM_OVERSCAN_ROWS, stat, + 0, 54321, NULL); + if (rc != myReadout) { + printf("TEST ERROR: pmSubtractBias() did not return input pmReadout.\n"); + testStatus = false; + psFree(rc); + } + + printf("------------------------------------------------------------------\n"); + printf("Calling pmSubtractBias() with bogus overScanAxis. Should generate Error.\n"); + myReadout = pmSubtractBias(myReadout, NULL, list, 54321, stat, + 0, PM_FIT_NONE, NULL); + if (rc != myReadout) { + printf("TEST ERROR: pmSubtractBias() did not return input pmReadout.\n"); + testStatus = false; + psFree(rc); + } + + if (0) { + for (i=0;iimage->data.F32[i][j]; + if (FLT_EPSILON < fabs(expect - actual)) { + printf("TEST ERROR: image[%d][%d] is %f, should be %f\n", i, j, actual, expect); + testStatus = 1; + } + } + } + } + + printf("------------------------------------------------------------------\n"); + psFree(myReadout); + psFree(tmpImage2); + psFree(tmpImage3); + psFree(tmpImage4); + psFree(tmpImage2Short); + psFree(tmpImage3Short); + psFree(tmpImage4Short); + psFree(myBias); + psFree(myBiasShortRows); + psFree(myBiasShortCols); + psFree(stat); + psFree(list); + psFree(listShort); + + printFooter(stdout, "pmSubtractBias", "Testing input parameter error conditions", true); + return(testStatus); +} + +int test04( void ) +{ + int testStatus = 0; + + testStatus |= doSubtractOverscansTestInputCases(NUM_COLS, NUM_ROWS); + return(testStatus); +} +*/ + +void PS_POLY1D_PRINT( + psPolynomial1D *poly) +{ + printf("-------------- PS_POLY1D_PRINT() --------------\n"); + printf("poly->nX is %d\n", poly->nX); + for (psS32 i = 0 ; i < (1 + poly->nX) ; i++) { + printf("poly->coeff[%d] is %f\n", i, poly->coeff[i]); + } +} + +void PS_PRINT_SPLINE2(psSpline1D *mySpline) +{ + printf("-------------- PS_PRINT_SPLINE2() --------------\n"); + if (mySpline != NULL) { + printf("mySpline->n is %d\n", mySpline->n); + for (psS32 i = 0 ; i < mySpline->n ; i++) { + if (mySpline->spline[i] != NULL) { + PS_POLY1D_PRINT(mySpline->spline[i]); + } + } + if (mySpline->knots != NULL) { + PS_VECTOR_PRINT_F32(mySpline->knots); + } + } else { + printf("NULL\n"); + } + printf("-------------- PS_PRINT_SPLINE2() DONE --------------\n"); +} + + + + + + +/****************************************************************************** +doSubtractOverscansGeneric(): This is a general version of the +bias subtraction tests which allows the various parameters to be specified +as arguments. + *****************************************************************************/ +int doSubtractOverscansGeneric( + int imageNumCols, + int imageNumRows, + int overscanNumCols, + int overscanNumRows, + int numOverscans, + pmOverscanAxis overscanaxis, + pmFit fit, + psS32 nBin) +{ + int i; + int j; + float actual; + float expect; + int testStatus = 0; + + printPositiveTestHeader(stdout, "pmSubtractBias", "PUT COMMENT HERE"); + printf("---- doSubtractOverscansGeneric() ----\n"); + printf(" Image size: %d by %d\n", imageNumRows, imageNumCols); + printf(" Overscan size: %d by %d\n", overscanNumRows, overscanNumCols); + printf(" Total Overscans: %d\n", numOverscans); + printf(" Binning factor: %d\n", nBin); + if (overscanaxis == PM_OVERSCAN_ROWS) + printf(" Overscan axis: PM_OVERSCAN_ROWS\n"); + if (overscanaxis == PM_OVERSCAN_COLUMNS) + printf(" Overscan axis: PM_OVERSCAN_COLUMNS\n"); + if (overscanaxis == PM_OVERSCAN_ALL) + printf(" Overscan axis: PM_OVERSCAN_ALL\n"); + if (overscanaxis == PM_OVERSCAN_NONE) + printf(" Overscan axis: PM_OVERSCAN_NONE\n"); + if (fit == PM_FIT_NONE) + printf(" Fit type: PM_FIT_NONE\n"); + if (fit == PM_FIT_POLYNOMIAL) + printf(" Fit type: PM_FIT_POLYNOMIAL\n"); + if (fit == PM_FIT_SPLINE) + printf(" Fit type: PM_FIT_SPLINE\n"); + + // + // Create and initialize input image, FPA hierarchy. + // + const psMetadata *camera = psMetadataAlloc(); + pmFPA* fpa = pmFPAAlloc(camera); + + if (fpa == NULL) { + psLogMsg(__func__,PS_LOG_ERROR, "TEST ERROR: pmFPAAlloc returned a NULL.\n"); + return 1; + } + + pmChip *chip = pmChipAlloc(fpa, "ChipName"); + if (chip == NULL) { + psLogMsg(__func__,PS_LOG_ERROR, "TEST ERROR: pmChipAlloc returned a NULL.\n"); + return 2; + } + + pmCell *cell = pmCellAlloc(chip, (psMetadata *) camera, "CellName"); + if (cell == NULL) { + psLogMsg(__func__,PS_LOG_ERROR, "TEST ERROR: pmCellAlloc returned a NULL.\n"); + return 3; + } + + pmReadout *myReadout = pmReadoutAlloc(cell); + myReadout->image = psImageAlloc(imageNumCols, imageNumRows, PS_TYPE_F32); + for (i=0;iimage->numRows;i++) { + for (j=0;jimage->numCols;j++) { + myReadout->image->data.F32[i][j] = (float) (i + j); + } + } + + // + // Set overscan axis in the metadata. + // + psBool rc; + if (overscanaxis == PM_OVERSCAN_ROWS) { + rc = psMetadataAddS32(myReadout->parent->concepts, PS_LIST_HEAD, "CELL.READDIR", 0, NULL, 1); + } else if (overscanaxis == PM_OVERSCAN_COLUMNS) { + rc = psMetadataAddS32(myReadout->parent->concepts, PS_LIST_HEAD, "CELL.READDIR", 0, NULL, 2); + } else if (overscanaxis == PM_OVERSCAN_ALL) { + rc = psMetadataAddS32(myReadout->parent->concepts, PS_LIST_HEAD, "CELL.READDIR", 0, NULL, 3); + } else if (overscanaxis == PM_OVERSCAN_NONE) { + rc = psMetadataAddS32(myReadout->parent->concepts, PS_LIST_HEAD, "CELL.READDIR", 0, NULL, 0); + } + if (rc == false) { + printf("TEST ERROR: Could not set CELL.READDIR metadata.\n"); + testStatus = 1; + } + + psStats *stat = psStatsAlloc(PS_STAT_SAMPLE_MEAN); + psPolynomial1D *myPoly = psPolynomial1DAlloc(POLYNOMIAL_FIT_ORDER, PS_POLYNOMIAL_ORD); + psSpline1D *mySpline = NULL; + + + if (0) { + if (overscanNumRows <= 0) { + overscanNumRows = 1; + } + if (overscanNumCols <= 0) { + overscanNumCols = 1; + } + } + psF32 oAverage = 0.0; + myReadout->bias = NULL; + for (psS32 i = 0 ; i < numOverscans ; i++) { + psImage *tmpImage = psImageAlloc(overscanNumCols, overscanNumRows, PS_TYPE_F32); + psF32 oValue = (float) (i + 3); + PS_IMAGE_SET_F32(tmpImage, oValue); + oAverage += oValue; + if (myReadout->bias == NULL) { + myReadout->bias = psListAlloc(tmpImage); + } else { + psListAdd(myReadout->bias, PS_LIST_HEAD, tmpImage); + } + } + oAverage/= (psF32) numOverscans; + if (0) { + if (fit == PM_FIT_NONE) { + myReadout = pmSubtractBias(myReadout, NULL, PM_FIT_NONE, overscanaxis, + stat, nBin, NULL, NULL); + } else if (fit == PM_FIT_POLYNOMIAL) { + myReadout = pmSubtractBias(myReadout, myPoly, PM_FIT_POLYNOMIAL, overscanaxis, + stat, nBin, NULL, NULL); + } else if (fit == PM_FIT_SPLINE) { + // mySpline = psSpline1DAlloc(); + myReadout = pmSubtractBias(myReadout, mySpline, PM_FIT_SPLINE, overscanaxis, + stat, nBin, NULL, NULL); + } + if (myReadout == NULL ) { + printf("TEST ERROR: pmSubtractBias() returned NULL.\n"); + testStatus = 1; + } else { + for (i=0;iimage->data.F32[i][j]; + if (FLT_EPSILON < fabs(expect - actual)) { + printf("TEST ERROR: image[%d][%d] is %f, should be %f\n", i, j, actual, expect); + testStatus = 1; + } else { + //printf("GOOD: image[%d][%d] is %f, should be %f\n", i, j, actual, expect); + } + } + } + } + } + + // HEY + psFree(fpa); + psFree(stat); + psFree(myPoly); + psFree(mySpline); + + printFooter(stdout, "pmSubtractBias", "Column Overscans", true); + return(testStatus); +} + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +/****************************************************************************** +test05a() The following combinations are tested here: + Overscan images are same size, no fit, bin factor is 1. + Overscan images are same size, no fit, bin factor is 2. + *****************************************************************************/ +int test05a( + psS32 imageNumCols, + psS32 imageNumRows, + psS32 overscanNumCols, + psS32 overscanNumRows) +{ + int testStatus = 0; + + // imageNumCols, imageNumRows, overscanNumCols, overscanNumRows, + // overscanaxis, fit, nBin + + // + // Overscan images are same size, no fit, bin factor is 1. + // + testStatus |= doSubtractOverscansGeneric(imageNumCols, imageNumRows, + overscanNumCols, overscanNumRows, NUM_OVERSCANS, + PM_OVERSCAN_ALL, + PM_FIT_NONE, 1); + + testStatus |= doSubtractOverscansGeneric(imageNumCols, imageNumRows, + overscanNumCols, overscanNumRows, NUM_OVERSCANS, + PM_OVERSCAN_COLUMNS, + PM_FIT_NONE, 1); + + testStatus |= doSubtractOverscansGeneric(imageNumCols, imageNumRows, + overscanNumCols, overscanNumRows, NUM_OVERSCANS, + PM_OVERSCAN_ROWS, + PM_FIT_NONE, 1); + + // + // Overscan images are same size, no fit, bin factor is 2. + // + testStatus |= doSubtractOverscansGeneric(imageNumCols, imageNumRows, + overscanNumCols, overscanNumRows, NUM_OVERSCANS, + PM_OVERSCAN_ALL, + PM_FIT_NONE, 2); + + testStatus |= doSubtractOverscansGeneric(imageNumCols, imageNumRows, + overscanNumCols, overscanNumRows, NUM_OVERSCANS, + PM_OVERSCAN_COLUMNS, + PM_FIT_NONE, 2); + + testStatus |= doSubtractOverscansGeneric(imageNumCols, imageNumRows, + overscanNumCols, overscanNumRows, NUM_OVERSCANS, + PM_OVERSCAN_ROWS, + PM_FIT_NONE, 2); + + return(testStatus); +} + + +/****************************************************************************** +test05b() The following combinations are tested here: + Overscan images are too small, spline fit, bin factor is 1. + Overscan images are too small, spline fit, bin factor is 2. + Overscan images are same size, spline fit, bin factor is 1. + Overscan images are same size, spline fit, bin factor is 2. + Overscan images are too big, spline fit, bin factor is 1. + Overscan images are too big, spline fit, bin factor is 2. + A single overscan image of the same size, spline fit, bin factor is 1. + + Overscan images are too small, polynomial fit, bin factor is 1. + Overscan images are too small, polynomial fit, bin factor is 2. + Overscan images are same size, polynomial fit, bin factor is 1. + Overscan images are same size, polynomial fit, bin factor is 2. + Overscan images are too big, polynomial fit, bin factor is 1. + Overscan images are too big, polynomial fit, bin factor is 2. + A single overscan image of the same size, polynomial fit, bin factor is 1. + +XXX: Must add M-by-N image size tests. + *****************************************************************************/ +int test05b( + psS32 imageNumCols, + psS32 imageNumRows, + psS32 overscanNumCols, + psS32 overscanNumRows) +{ + int testStatus = 0; + + // + // Overscan images are too small, spline fit, bin factor is 1. + // + testStatus |= doSubtractOverscansGeneric(imageNumCols, imageNumRows, + overscanNumCols-2, overscanNumRows-2, NUM_OVERSCANS, + PM_OVERSCAN_ALL, + PM_FIT_SPLINE, 1); + + testStatus |= doSubtractOverscansGeneric(imageNumCols, imageNumRows, + overscanNumCols-2, overscanNumRows-2, NUM_OVERSCANS, + PM_OVERSCAN_COLUMNS, + PM_FIT_SPLINE, 1); + + testStatus |= doSubtractOverscansGeneric(imageNumCols, imageNumRows, + overscanNumCols-2, overscanNumRows-2, NUM_OVERSCANS, + PM_OVERSCAN_ROWS, + PM_FIT_SPLINE, 1); + + // + // Overscan images are too small, spline fit, bin factor is 2. + // + testStatus |= doSubtractOverscansGeneric(imageNumCols, imageNumRows, + overscanNumCols-2, overscanNumRows-2, NUM_OVERSCANS, + PM_OVERSCAN_ALL, + PM_FIT_SPLINE, 2); + + testStatus |= doSubtractOverscansGeneric(imageNumCols, imageNumRows, + overscanNumCols-2, overscanNumRows-2, NUM_OVERSCANS, + PM_OVERSCAN_COLUMNS, + PM_FIT_SPLINE, 2); + + testStatus |= doSubtractOverscansGeneric(imageNumCols, imageNumRows, + overscanNumCols-2, overscanNumRows-2, NUM_OVERSCANS, + PM_OVERSCAN_ROWS, + PM_FIT_SPLINE, 2); + + + // + // Overscan images are same size, spline fit, bin factor is 1. + // + testStatus |= doSubtractOverscansGeneric(imageNumCols, imageNumRows, + overscanNumCols, overscanNumRows, NUM_OVERSCANS, + PM_OVERSCAN_ALL, + PM_FIT_SPLINE, 1); + + testStatus |= doSubtractOverscansGeneric(imageNumCols, imageNumRows, + overscanNumCols, overscanNumRows, NUM_OVERSCANS, + PM_OVERSCAN_COLUMNS, + PM_FIT_SPLINE, 1); + + testStatus |= doSubtractOverscansGeneric(imageNumCols, imageNumRows, + overscanNumCols, overscanNumRows, NUM_OVERSCANS, + PM_OVERSCAN_ROWS, + PM_FIT_SPLINE, 1); + + // + // Overscan images are same size, spline fit, bin factor is 2. + // + testStatus |= doSubtractOverscansGeneric(imageNumCols, imageNumRows, + overscanNumCols, overscanNumRows, NUM_OVERSCANS, + PM_OVERSCAN_ALL, + PM_FIT_SPLINE, 2); + + testStatus |= doSubtractOverscansGeneric(imageNumCols, imageNumRows, + overscanNumCols, overscanNumRows, NUM_OVERSCANS, + PM_OVERSCAN_COLUMNS, + PM_FIT_SPLINE, 2); + + testStatus |= doSubtractOverscansGeneric(imageNumCols, imageNumRows, + overscanNumCols, overscanNumRows, NUM_OVERSCANS, + PM_OVERSCAN_ROWS, + PM_FIT_SPLINE, 2); + + // + // Overscan images are too big, spline fit, bin factor is 1. + // + testStatus |= doSubtractOverscansGeneric(imageNumCols, imageNumRows, + overscanNumCols+2, overscanNumRows+2, NUM_OVERSCANS, + PM_OVERSCAN_ALL, + PM_FIT_SPLINE, 1); + + testStatus |= doSubtractOverscansGeneric(imageNumCols, imageNumRows, + overscanNumCols+2, overscanNumRows+2, NUM_OVERSCANS, + PM_OVERSCAN_COLUMNS, + PM_FIT_SPLINE, 1); + + testStatus |= doSubtractOverscansGeneric(imageNumCols, imageNumRows, + overscanNumCols+2, overscanNumRows+2, NUM_OVERSCANS, + PM_OVERSCAN_ROWS, + PM_FIT_SPLINE, 1); + + // + // Overscan images are too big, spline fit, bin factor is 2. + // + testStatus |= doSubtractOverscansGeneric(imageNumCols, imageNumRows, + overscanNumCols+2, overscanNumRows+2, NUM_OVERSCANS, + PM_OVERSCAN_ALL, + PM_FIT_SPLINE, 2); + + testStatus |= doSubtractOverscansGeneric(imageNumCols, imageNumRows, + overscanNumCols+2, overscanNumRows+2, NUM_OVERSCANS, + PM_OVERSCAN_COLUMNS, + PM_FIT_SPLINE, 2); + + testStatus |= doSubtractOverscansGeneric(imageNumCols, imageNumRows, + overscanNumCols+2, overscanNumRows+2 , NUM_OVERSCANS, + PM_OVERSCAN_ROWS, + PM_FIT_SPLINE, 2); + + + // + // A single overscan image of the same size, spline fit, bin factor is 1. + // + testStatus |= doSubtractOverscansGeneric(imageNumCols, imageNumRows, + overscanNumCols, overscanNumRows, 1, + PM_OVERSCAN_ALL, + PM_FIT_SPLINE, 1); + + testStatus |= doSubtractOverscansGeneric(imageNumCols, imageNumRows, + overscanNumCols, overscanNumRows, 1, + PM_OVERSCAN_COLUMNS, + PM_FIT_SPLINE, 1); + + testStatus |= doSubtractOverscansGeneric(imageNumCols, imageNumRows, + overscanNumCols, overscanNumRows, 1, + PM_OVERSCAN_ROWS, + PM_FIT_SPLINE, 1); + + + // + // Overscan images are too small, polynomial fit, bin factor is 1. + // + testStatus |= doSubtractOverscansGeneric(imageNumCols, imageNumRows, + overscanNumCols-2, overscanNumRows-2, NUM_OVERSCANS, + PM_OVERSCAN_ALL, + PM_FIT_POLYNOMIAL, 1); + + testStatus |= doSubtractOverscansGeneric(imageNumCols, imageNumRows, + overscanNumCols-2, overscanNumRows-2, NUM_OVERSCANS, + PM_OVERSCAN_COLUMNS, + PM_FIT_POLYNOMIAL, 1); + + testStatus |= doSubtractOverscansGeneric(imageNumCols, imageNumRows, + overscanNumCols-2, overscanNumRows-2, NUM_OVERSCANS, + PM_OVERSCAN_ROWS, + PM_FIT_POLYNOMIAL, 1); + + // + // Overscan images are too small, polynomial fit, bin factor is 2. + // + testStatus |= doSubtractOverscansGeneric(imageNumCols, imageNumRows, + overscanNumCols-2, overscanNumRows-2, NUM_OVERSCANS, + PM_OVERSCAN_ALL, + PM_FIT_POLYNOMIAL, 2); + + testStatus |= doSubtractOverscansGeneric(imageNumCols, imageNumRows, + overscanNumCols-2, overscanNumRows-2, NUM_OVERSCANS, + PM_OVERSCAN_COLUMNS, + PM_FIT_POLYNOMIAL, 2); + + testStatus |= doSubtractOverscansGeneric(imageNumCols, imageNumRows, + overscanNumCols-2, overscanNumRows-2, NUM_OVERSCANS, + PM_OVERSCAN_ROWS, + PM_FIT_POLYNOMIAL, 2); + + + // + // Overscan images are same size, polynomial fit, bin factor is 1. + // + testStatus |= doSubtractOverscansGeneric(imageNumCols, imageNumRows, + overscanNumCols, overscanNumRows, NUM_OVERSCANS, + PM_OVERSCAN_ALL, + PM_FIT_POLYNOMIAL, 1); + + testStatus |= doSubtractOverscansGeneric(imageNumCols, imageNumRows, + overscanNumCols, overscanNumRows, NUM_OVERSCANS, + PM_OVERSCAN_COLUMNS, + PM_FIT_POLYNOMIAL, 1); + + testStatus |= doSubtractOverscansGeneric(imageNumCols, imageNumRows, + overscanNumCols, overscanNumRows, NUM_OVERSCANS, + PM_OVERSCAN_ROWS, + PM_FIT_POLYNOMIAL, 1); + + // + // Overscan images are same size, polynomial fit, bin factor is 2. + // + testStatus |= doSubtractOverscansGeneric(imageNumCols, imageNumRows, + overscanNumCols, overscanNumRows, NUM_OVERSCANS, + PM_OVERSCAN_ALL, + PM_FIT_POLYNOMIAL, 2); + + testStatus |= doSubtractOverscansGeneric(imageNumCols, imageNumRows, + overscanNumCols, overscanNumRows, NUM_OVERSCANS, + PM_OVERSCAN_COLUMNS, + PM_FIT_POLYNOMIAL, 2); + + testStatus |= doSubtractOverscansGeneric(imageNumCols, imageNumRows, + overscanNumCols, overscanNumRows, NUM_OVERSCANS, + PM_OVERSCAN_ROWS, + PM_FIT_POLYNOMIAL, 2); + + // + // Overscan images are too big, polynomial fit, bin factor is 1. + // + testStatus |= doSubtractOverscansGeneric(imageNumCols, imageNumRows, + overscanNumCols+2, overscanNumRows+2, NUM_OVERSCANS, + PM_OVERSCAN_ALL, + PM_FIT_POLYNOMIAL, 1); + + testStatus |= doSubtractOverscansGeneric(imageNumCols, imageNumRows, + overscanNumCols+2, overscanNumRows+2, NUM_OVERSCANS, + PM_OVERSCAN_COLUMNS, + PM_FIT_POLYNOMIAL, 1); + + testStatus |= doSubtractOverscansGeneric(imageNumCols, imageNumRows, + overscanNumCols+2, overscanNumRows+2, NUM_OVERSCANS, + PM_OVERSCAN_ROWS, + PM_FIT_POLYNOMIAL, 1); + + // + // Overscan images are too big, polynomial fit, bin factor is 2. + // + testStatus |= doSubtractOverscansGeneric(imageNumCols, imageNumRows, + overscanNumCols+2, overscanNumRows+2, NUM_OVERSCANS, + PM_OVERSCAN_ALL, + PM_FIT_POLYNOMIAL, 2); + + testStatus |= doSubtractOverscansGeneric(imageNumCols, imageNumRows, + overscanNumCols+2, overscanNumRows+2, NUM_OVERSCANS, + PM_OVERSCAN_COLUMNS, + PM_FIT_POLYNOMIAL, 2); + + testStatus |= doSubtractOverscansGeneric(imageNumCols, imageNumRows, + overscanNumCols+2, overscanNumRows+2, NUM_OVERSCANS, + PM_OVERSCAN_ROWS, + PM_FIT_POLYNOMIAL, 2); + + // + // A single overscan image of the same size, polynomial fit, bin factor is 1. + // + testStatus |= doSubtractOverscansGeneric(imageNumCols, imageNumRows, + overscanNumCols, overscanNumRows, 1, + PM_OVERSCAN_ALL, + PM_FIT_POLYNOMIAL, 1); + + testStatus |= doSubtractOverscansGeneric(imageNumCols, imageNumRows, + overscanNumCols, overscanNumRows, 1, + PM_OVERSCAN_COLUMNS, + PM_FIT_POLYNOMIAL, 1); + + testStatus |= doSubtractOverscansGeneric(imageNumCols, imageNumRows, + overscanNumCols, overscanNumRows, 1, + PM_OVERSCAN_ROWS, + PM_FIT_POLYNOMIAL, 1); + + return(testStatus); +} + + + +#define LOW_COLS 3 +#define LOW_ROWS 3 + +/****************************************************************************** +test05(): See test05a() and test05b(). + +We run the tests in test05b() starting with all possible combinations of +sizes. + +XXX: Must add M-by-N image size tests. + *****************************************************************************/ +int test05() +{ + int testStatus = 0; + // testStatus = test05a(NUM_COLS, NUM_ROWS, NUM_COLS, NUM_ROWS); + + // testStatus|= test05b(LOW_COLS, LOW_ROWS, LOW_COLS, LOW_ROWS); + // testStatus|= test05b(LOW_COLS, LOW_ROWS, LOW_COLS, NUM_ROWS); + // testStatus|= test05b(LOW_COLS, LOW_ROWS, NUM_COLS, LOW_ROWS); + // testStatus|= test05b(LOW_COLS, LOW_ROWS, NUM_COLS, NUM_ROWS); + + // testStatus|= test05b(LOW_COLS, NUM_ROWS, LOW_COLS, LOW_ROWS); + // testStatus|= test05b(LOW_COLS, NUM_ROWS, LOW_COLS, NUM_ROWS); + // testStatus|= test05b(LOW_COLS, NUM_ROWS, NUM_COLS, LOW_ROWS); + // testStatus|= test05b(LOW_COLS, NUM_ROWS, NUM_COLS, NUM_ROWS); + + // testStatus|= test05b(NUM_COLS, LOW_ROWS, LOW_COLS, LOW_ROWS); + // testStatus|= test05b(NUM_COLS, LOW_ROWS, LOW_COLS, NUM_ROWS); + // testStatus|= test05b(NUM_COLS, LOW_ROWS, NUM_COLS, LOW_ROWS); + // testStatus|= test05b(NUM_COLS, LOW_ROWS, NUM_COLS, NUM_ROWS); + + // testStatus|= test05b(NUM_COLS, NUM_ROWS, LOW_COLS, LOW_ROWS); + // testStatus|= test05b(NUM_COLS, NUM_ROWS, LOW_COLS, NUM_ROWS); + // testStatus|= test05b(NUM_COLS, NUM_ROWS, NUM_COLS, LOW_ROWS); + testStatus|= test05b(NUM_COLS, NUM_ROWS, NUM_COLS, NUM_ROWS); + + + return(testStatus); +} + Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/imsubtract/tst_pmSubtractSky.c =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/imsubtract/tst_pmSubtractSky.c (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/imsubtract/tst_pmSubtractSky.c (revision 21664) @@ -0,0 +1,375 @@ +/** @file tst_pmSubtractSky.c + * + * @brief Contains the tests for pmSubtractSky.c: + * + * test00: This code will ... + * + * @author GLG, MHPCC + * + * @version $Revision: 1.2 $ $Name: not supported by cvs2svn $ + * @date $Date: 2005-11-15 20:09:03 $ + * + * XXX: I added the CELL.TRIMSEC region code but there are not tests for it. + * + * Copyright 2004 Maui High Performance Computing Center, University of Hawaii + */ +#include "psTest.h" +#include "pslib.h" +#include "pmSubtractSky.h" +#define NUM_ROWS 512 +#define NUM_COLS 512 +#define POLY_X_ORDER 3 +#define POLY_Y_ORDER 3 +#define ERROR_TOLERANCE 1.0 +#define OBJECT_INTENSITY 2000.0 +static int test00(void); +static int test01(void); +testDescription tests[] = { + {test00, 000, "pmSubtractSky", 0, false}, + {test01, 000, "pmSubtractSky: warning, error messages", 0, false}, + {NULL} + }; + +float func(int i, int j) +{ + return((float) (i + j)); +} + +int main(int argc, char* argv[]) +{ + psLogSetFormat("HLNM"); + return !runTestSuite(stderr, "Test Point Driver", tests, argc, argv); + // test00(); +} + +/****************************************************************************** + *****************************************************************************/ +int doSubtractSkySimple(int numCols, int numRows, int binFactor) +{ + int i; + int j; + int testStatus = 0; + psImage *tmpImageF32 = psImageAlloc(numCols, numRows, PS_TYPE_F32); + // pmReadout *myReadout = pmReadoutAlloc(numCols, numRows, tmpImageF32); + pmReadout *myReadout = pmReadoutAlloc(NULL); + myReadout->image = tmpImageF32; + psStats *myStats = psStatsAlloc(PS_STAT_SAMPLE_MEAN); + psPolynomial2D *myPoly = psPolynomial2DAlloc(POLY_X_ORDER, POLY_Y_ORDER, PS_POLYNOMIAL_ORD); + + printPositiveTestHeader(stdout, "pmSubtractSky", "doSubtractSkySimple"); + for (i=0;iimage->data.F32[i][j] = func(i, j); + } + } + + myReadout = pmSubtractSky(myReadout, (void *) myPoly, PM_FIT_POLYNOMIAL, + binFactor, myStats, 10.0); + if (myReadout == NULL) { + printf("TEST ERROR: pmSubtractSky() returned NULL.\n"); + testStatus = 1; + } else { + for (i=0;iimage->data.F32[i][j])) { + printf("TEST ERROR: image[%d][%d] is %f, should be 0.0\n", i, j, myReadout->image->data.F32[i][j]); + testStatus = 1; + } + } + } + } + psFree(myReadout); + psFree(myStats); + psFree(myPoly); + printFooter(stdout, "pmSubtractSky", "doSubtractSkySimple", true); + return(testStatus); +} + +/****************************************************************************** + *****************************************************************************/ +int doSubtractSkyWithObjects(int numCols, int numRows, int binFactor) +{ + int i; + int j; + int testStatus = 0; + psImage *tmpImageF32 = psImageAlloc(numCols, numRows, PS_TYPE_F32); + // pmReadout *myReadout = pmReadoutAlloc(numCols, numRows, tmpImageF32); + pmReadout *myReadout = pmReadoutAlloc(NULL); + myReadout->image = tmpImageF32; + psStats *myStats = psStatsAlloc(PS_STAT_SAMPLE_MEAN); + psPolynomial2D *myPoly = psPolynomial2DAlloc(POLY_X_ORDER, POLY_Y_ORDER, PS_POLYNOMIAL_ORD); + psImage *trueImage = psImageAlloc(numCols, numRows, PS_TYPE_F32); + psF32 errorTolerance = ERROR_TOLERANCE * ((psF32) binFactor); + + printPositiveTestHeader(stdout, "pmSubtractSky", "doSubtractSkyWithObjects"); + for (i=0;iimage->data.F32[i][j] = func(i, j); + } + } + // We insert a few bright spots in the image. + myReadout->image->data.F32[NUM_ROWS/4][NUM_COLS/4]+= OBJECT_INTENSITY; + myReadout->image->data.F32[NUM_ROWS/4][3*NUM_COLS/4]+= OBJECT_INTENSITY; + myReadout->image->data.F32[3*NUM_ROWS/4][NUM_COLS/4]+= OBJECT_INTENSITY; + myReadout->image->data.F32[3*NUM_ROWS/4][3*NUM_COLS/4]+= OBJECT_INTENSITY; + PS_IMAGE_SET_F32(trueImage, 0.0); + trueImage->data.F32[NUM_ROWS/4][NUM_COLS/4]+= OBJECT_INTENSITY; + trueImage->data.F32[NUM_ROWS/4][3*NUM_COLS/4]+= OBJECT_INTENSITY; + trueImage->data.F32[3*NUM_ROWS/4][NUM_COLS/4]+= OBJECT_INTENSITY; + trueImage->data.F32[3*NUM_ROWS/4][3*NUM_COLS/4]+= OBJECT_INTENSITY; + + myReadout = pmSubtractSky(myReadout, (void *) myPoly, PM_FIT_POLYNOMIAL, + binFactor, myStats, 2.0); + if (myReadout == NULL) { + printf("TEST ERROR: pmSubtractSky() returned NULL.\n"); + testStatus = 1; + } else { + for (i=0;iimage->data.F32[i][j] - trueImage->data.F32[i][j])) { + printf("TEST ERROR: image[%d][%d] is %f, should be %f\n", i, j, + myReadout->image->data.F32[i][j], trueImage->data.F32[i][j]); + testStatus = 1; + } + } + } + } + psFree(myReadout); + psFree(myStats); + psFree(myPoly); + psFree(trueImage); + printFooter(stdout, "pmSubtractSky", "doSubtractSkyWithObjects", true); + return(testStatus); +} + + +int test00( void ) +{ + int testStatus = 0; + + psTraceSetLevel(".", 0); + + // Bin Factor == 1 + printf("doSubtractSkySimple(1, 1, 1)\n"); + testStatus |= doSubtractSkySimple(1, 1, 1); + printf("doSubtractSkySimple(NUM_COLS, 1, 1)\n"); + testStatus |= doSubtractSkySimple(NUM_COLS, 1, 1); + + printf("doSubtractSkySimple(1, NUM_ROWS, 1)\n"); + testStatus |= doSubtractSkySimple(1, NUM_ROWS, 1); + printf("doSubtractSkySimple(NUM_COLS, NUM_ROWS, 1)\n"); + testStatus |= doSubtractSkySimple(NUM_COLS, NUM_ROWS, 1); + + // Bin Factor == 2 + printf("doSubtractSkySimple(1, 1, 2)\n"); + testStatus |= doSubtractSkySimple(1, 1, 2); + printf("doSubtractSkySimple(NUM_COLS, 1, 2)\n"); + testStatus |= doSubtractSkySimple(NUM_COLS, 1, 2); + printf("doSubtractSkySimple(1, NUM_ROWS, 2)\n"); + testStatus |= doSubtractSkySimple(1, NUM_ROWS, 2); + printf("doSubtractSkySimple(NUM_COLS, NUM_ROWS, 2)\n"); + testStatus |= doSubtractSkySimple(NUM_COLS, NUM_ROWS, 2); + + printf("doSubtractSkyWithObjects(NUM_COLS, NUM_ROWS, 1)\n"); + testStatus |= doSubtractSkyWithObjects(NUM_COLS, NUM_ROWS, 1); + printf("doSubtractSkyWithObjects(NUM_COLS, NUM_ROWS, 2)\n"); + testStatus |= doSubtractSkyWithObjects(NUM_COLS, NUM_ROWS, 2); + printf("doSubtractSkyWithObjects(NUM_COLS, NUM_ROWS, 4)\n"); + testStatus |= doSubtractSkyWithObjects(NUM_COLS, NUM_ROWS, 8); + + printf("doSubtractSkyWithObjects(NUM_COLS, NUM_ROWS, 8)\n"); + testStatus |= doSubtractSkyWithObjects(NUM_COLS, NUM_ROWS, 8); + printf("doSubtractSkyWithObjects(NUM_COLS, NUM_ROWS, 16)\n"); + testStatus |= doSubtractSkyWithObjects(NUM_COLS, NUM_ROWS, 16); + printf("doSubtractSkyWithObjects(NUM_COLS, NUM_ROWS, 32)\n"); + testStatus |= doSubtractSkyWithObjects(NUM_COLS, NUM_ROWS, 32); + printf("doSubtractSkyWithObjects(NUM_COLS, NUM_ROWS, 64)\n"); + testStatus |= doSubtractSkyWithObjects(NUM_COLS, NUM_ROWS, 64); + printf("doSubtractSkyWithObjects(NUM_COLS, NUM_ROWS, 128)\n"); + testStatus |= doSubtractSkyWithObjects(NUM_COLS, NUM_ROWS, 128); + printf("doSubtractSkyWithObjects(NUM_COLS, NUM_ROWS, 256)\n"); + testStatus |= doSubtractSkyWithObjects(NUM_COLS, NUM_ROWS, 256); + + return(testStatus); +} + +#define NUM_ROWS_SMALL 16 +#define NUM_COLS_SMALL 16 +int test01( void ) +{ + int testStatus = 0; + psS32 i; + psS32 j; + psImage *tmpImageF32 = psImageAlloc(NUM_COLS_SMALL, NUM_ROWS_SMALL, PS_TYPE_F32); + psImage *tmpImageF64 = psImageAlloc(NUM_COLS_SMALL, NUM_ROWS_SMALL, PS_TYPE_F64); + // pmReadout *myReadout = pmReadoutAlloc(NUM_COLS_SMALL, NUM_ROWS_SMALL, tmpImageF32); + pmReadout *myReadout = pmReadoutAlloc(NULL); + myReadout->image = tmpImageF32; + pmReadout *rc = NULL; + psStats *myStats = psStatsAlloc(PS_STAT_SAMPLE_MEAN); + psPolynomial2D *myPoly = psPolynomial2DAlloc(POLY_X_ORDER, POLY_Y_ORDER, PS_POLYNOMIAL_ORD); + + printPositiveTestHeader(stdout, "pmSubtractSky", "Testing bad input parameter conditions."); + for (i=0;iimage->data.F32[i][j] = func(i, j); + } + } + + printf("----------------------------------------------------------------\n"); + printf("Calling pmSubtractSky() with NULL pmReadout. Should error.\n\n"); + rc = pmSubtractSky(NULL, (void *) myPoly, PM_FIT_POLYNOMIAL, 1, myStats, 2.0); + if (rc != NULL) { + printf("TEST ERROR: pmSubtractSky() returned a non-NULL pmReadout\n"); + testStatus = false; + } + + printf("----------------------------------------------------------------\n"); + printf("Calling pmSubtractSky() with NULL pmReadout->image. Should error.\n\n"); + myReadout->image = NULL; + rc = pmSubtractSky(myReadout, (void *) myPoly, PM_FIT_POLYNOMIAL, 1, myStats, 2.0); + if (rc != NULL) { + printf("TEST ERROR: pmSubtractSky() returned a non-NULL pmReadout\n"); + testStatus = false; + } + myReadout->image = tmpImageF32; + + printf("----------------------------------------------------------------\n"); + printf("Calling pmSubtractSky() with PS_TYPE_F64 pmReadout->image. Should error.\n\n"); + myReadout->image = tmpImageF64; + rc = pmSubtractSky(myReadout, (void *) myPoly, PM_FIT_POLYNOMIAL, 1, myStats, 2.0); + if (rc != NULL) { + printf("TEST ERROR: pmSubtractSky() returned a non-NULL pmReadout\n"); + testStatus = false; + } + myReadout->image = tmpImageF32; + + printf("----------------------------------------------------------------\n"); + printf("Calling pmSubtractSky() with NULL fitSpec. Should return image, no ERROR, no WARNING.\n\n"); + rc = pmSubtractSky(myReadout, NULL, PM_FIT_POLYNOMIAL, 1, myStats, 2.0); + if (rc != myReadout) { + printf("TEST ERROR: pmSubtractSky() returned something other than pmReadout\n"); + testStatus = false; + } + + printf("----------------------------------------------------------------\n"); + printf("Calling pmSubtractSky() with PM_FIT_NONE fit. Should return image, no ERROR, no WARNING.\n\n"); + rc = pmSubtractSky(myReadout, (void *) myPoly, PM_FIT_NONE, 1, myStats, 2.0); + if (rc != myReadout) { + printf("TEST ERROR: pmSubtractSky() returned something other than pmReadout\n"); + testStatus = false; + } + + printf("----------------------------------------------------------------\n"); + printf("Calling pmSubtractSky() with PM_FIT_SPLINE fit. Should return image, no ERROR, no WARNING.\n\n"); + rc = pmSubtractSky(myReadout, (void *) myPoly, PM_FIT_SPLINE, 1, myStats, 2.0); + if (rc != myReadout) { + printf("TEST ERROR: pmSubtractSky() returned something other than pmReadout\n"); + testStatus = false; + } + + printf("----------------------------------------------------------------\n"); + printf("Calling pmSubtractSky() with NULL myStats. Should fit entire image, generate WARNING.\n\n"); + rc = pmSubtractSky(myReadout, (void *) myPoly, PM_FIT_POLYNOMIAL, 1, NULL, 2.0); + for (i=0;iimage->data.F32[i][j])) { + printf("TEST ERROR: image[%d][%d] is %f, should be 0.0\n", i, j, + rc->image->data.F32[i][j]); + testStatus = false; + } + } + } + + printf("----------------------------------------------------------------\n"); + psU64 oldOptions = myStats->options; + myStats->options = 0; + printf("Calling pmSubtractSky() with no myStats->options specified. Should fit entire image, generate WARNING.\n\n"); + rc = pmSubtractSky(myReadout, (void *) myPoly, PM_FIT_POLYNOMIAL, 1, myStats, 2.0); + for (i=0;iimage->data.F32[i][j])) { + printf("TEST ERROR: image[%d][%d] is %f, should be 0.0\n", i, j, + rc->image->data.F32[i][j]); + testStatus = false; + } + } + } + myStats->options = oldOptions; + + printf("----------------------------------------------------------------\n"); + oldOptions = myStats->options; + myStats->options = PS_STAT_SAMPLE_MEAN | PS_STAT_SAMPLE_MEDIAN; + printf("Calling pmSubtractSky() with multiple myStats->options specified. Should fit entire image, generate WARNING.\n\n"); + rc = pmSubtractSky(myReadout, (void *) myPoly, PM_FIT_POLYNOMIAL, 1, myStats, 2.0); + for (i=0;iimage->data.F32[i][j])) { + printf("TEST ERROR: image[%d][%d] is %f, should be 0.0\n", i, j, + rc->image->data.F32[i][j]); + testStatus = false; + } + } + } + myStats->options = oldOptions; + + printf("----------------------------------------------------------------\n"); + printf("Calling pmSubtractSky() with 0 binFactor. Should fit entire image, generate WARNING.\n\n"); + rc = pmSubtractSky(myReadout, (void *) myPoly, PM_FIT_POLYNOMIAL, 0, myStats, 2.0); + for (i=0;iimage->data.F32[i][j])) { + printf("TEST ERROR: image[%d][%d] is %f, should be 0.0\n", i, j, + rc->image->data.F32[i][j]); + testStatus = false; + } + } + } + + printf("----------------------------------------------------------------\n"); + printf("Calling pmSubtractSky() with -1 binFactor. Should fit entire image, generate WARNING.\n\n"); + rc = pmSubtractSky(myReadout, (void *) myPoly, PM_FIT_POLYNOMIAL, -1, myStats, 2.0); + for (i=0;iimage->data.F32[i][j])) { + printf("TEST ERROR: image[%d][%d] is %f, should be 0.0\n", i, j, + rc->image->data.F32[i][j]); + testStatus = false; + } + } + } + + printf("----------------------------------------------------------------\n"); + printf("Calling pmSubtractSky() with -1.0 clipSD. Should fit entire image, generate WARNING.\n\n"); + rc = pmSubtractSky(myReadout, (void *) myPoly, PM_FIT_POLYNOMIAL, 1, myStats, -1.0); + for (i=0;iimage->data.F32[i][j])) { + printf("TEST ERROR: image[%d][%d] is %f, should be 0.0\n", i, j, + rc->image->data.F32[i][j]); + testStatus = false; + } + } + } + + printf("----------------------------------------------------------------\n"); + printf("Calling pmSubtractSky() with bogus psFit. Should generate Error.\n\n"); + rc = pmSubtractSky(myReadout, (void *) myPoly, 54321, 1, myStats, -1.0); + if (rc != myReadout) { + printf("TEST ERROR: pmSubtractSky() returned something other than pmReadout\n"); + testStatus = false; + } + + + // myReadout = pmSubtractSky(myReadout, (void *) myPoly, PM_FIT_POLYNOMIAL, + // 1, myStats, 2.0); + + + printf("----------------------------------------------------------------\n"); + psFree(myReadout); + psFree(myStats); + psFree(myPoly); + psFree(tmpImageF64); + printFooter(stdout, "pmSubtractSky", "Testing bad input parameter conditions.", true); + return(testStatus); +} Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/imsubtract/verified/tst_pmImageSubtract.stderr =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/imsubtract/verified/tst_pmImageSubtract.stderr (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/imsubtract/verified/tst_pmImageSubtract.stderr (revision 21664) @@ -0,0 +1,96 @@ +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmImageSubtract.c * +* TestPoint: Test Point Driver{pmSubtractionKernelsAllocPOIS()} * +* TestType: Positive * +\**********************************************************************************/ + + +---> TESTPOINT PASSED (Test Point Driver{pmSubtractionKernelsAllocPOIS()} | tst_pmImageSubtract.c) + +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmImageSubtract.c * +* TestPoint: Test Point Driver{pmSubtractionKernelsAllocISIS()} * +* TestType: Positive * +\**********************************************************************************/ + + +---> TESTPOINT PASSED (Test Point Driver{pmSubtractionKernelsAllocISIS()} | tst_pmImageSubtract.c) + +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmImageSubtract.c * +* TestPoint: Test Point Driver{pmSubtractionFindStamps()} * +* TestType: Positive * +\**********************************************************************************/ + +|E|pmSubtractionFindStamps (FILE:LINENO) + Unallowable operation: psImage image or its data is NULL. +|E|pmSubtractionFindStamps (FILE:LINENO) + Error: xNum is 0 or less. +|E|pmSubtractionFindStamps (FILE:LINENO) + Error: yNum is 0 or less. +|E|pmSubtractionFindStamps (FILE:LINENO) + Error: border is 0 or less. +|E|pmSubtractionFindStamps (FILE:LINENO) + Unallowable operation: psImage image or its data is NULL. +|E|pmSubtractionFindStamps (FILE:LINENO) + Error: xNum is 0 or less. +|E|pmSubtractionFindStamps (FILE:LINENO) + Error: yNum is 0 or less. +|E|pmSubtractionFindStamps (FILE:LINENO) + Error: border is 0 or less. + +---> TESTPOINT PASSED (Test Point Driver{pmSubtractionFindStamps()} | tst_pmImageSubtract.c) + +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmImageSubtract.c * +* TestPoint: Test Point Driver{pmSubtractionCalculateEquation()} * +* TestType: Positive * +\**********************************************************************************/ + +|E|pmSubtractionCalculateEquation (FILE:LINENO) + Unallowable operation: stamps is NULL. +|E|pmSubtractionCalculateEquation (FILE:LINENO) + Unallowable operation: psImage reference or its data is NULL. +|E|pmSubtractionCalculateEquation (FILE:LINENO) + Unallowable operation: psImage input or its data is NULL. +|E|pmSubtractionCalculateEquation (FILE:LINENO) + Unallowable operation: kernels is NULL. +|E|pmSubtractionSolveEquation (FILE:LINENO) + Unallowable operation: stamps is NULL. +|E|pmSubtractionKernelImage (FILE:LINENO) + Unallowable operation: psVector solution or its data is NULL. +|E|pmSubtractionKernelImage (FILE:LINENO) + Unallowable operation: kernels is NULL. +|E|pmSubtractionKernelImage (FILE:LINENO) + Error: x, -2.000000, is out of range. Must be between -1.000000 and 1.000000. +|E|pmSubtractionKernelImage (FILE:LINENO) + Error: x, 2.000000, is out of range. Must be between -1.000000 and 1.000000. +|E|pmSubtractionKernelImage (FILE:LINENO) + Error: y, -2.000000, is out of range. Must be between -1.000000 and 1.000000. +|E|pmSubtractionKernelImage (FILE:LINENO) + Error: y, 2.000000, is out of range. Must be between -1.000000 and 1.000000. +|E|pmSubtractionCalculateEquation (FILE:LINENO) + Unallowable operation: stamps is NULL. +|E|pmSubtractionCalculateEquation (FILE:LINENO) + Unallowable operation: psImage reference or its data is NULL. +|E|pmSubtractionCalculateEquation (FILE:LINENO) + Unallowable operation: psImage input or its data is NULL. +|E|pmSubtractionCalculateEquation (FILE:LINENO) + Unallowable operation: kernels is NULL. +|E|pmSubtractionSolveEquation (FILE:LINENO) + Unallowable operation: stamps is NULL. +|E|pmSubtractionKernelImage (FILE:LINENO) + Unallowable operation: psVector solution or its data is NULL. +|E|pmSubtractionKernelImage (FILE:LINENO) + Unallowable operation: kernels is NULL. +|E|pmSubtractionKernelImage (FILE:LINENO) + Error: x, -2.000000, is out of range. Must be between -1.000000 and 1.000000. +|E|pmSubtractionKernelImage (FILE:LINENO) + Error: x, 2.000000, is out of range. Must be between -1.000000 and 1.000000. +|E|pmSubtractionKernelImage (FILE:LINENO) + Error: y, -2.000000, is out of range. Must be between -1.000000 and 1.000000. +|E|pmSubtractionKernelImage (FILE:LINENO) + Error: y, 2.000000, is out of range. Must be between -1.000000 and 1.000000. + +---> TESTPOINT PASSED (Test Point Driver{pmSubtractionCalculateEquation()} | tst_pmImageSubtract.c) + Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/imsubtract/verified/tst_pmImageSubtract.stdout =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/imsubtract/verified/tst_pmImageSubtract.stdout (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/imsubtract/verified/tst_pmImageSubtract.stdout (revision 21664) @@ -0,0 +1,73 @@ +Testing pmSubtractionKernelsAllocPOIS(1, 1) +Testing pmSubtractionKernelsAllocPOIS(2, 3) +Testing pmSubtractionKernelsAllocPOIS(3, 4) +Testing pmSubtractionFindStamps(100, 100, 2, 2, 2) +Calling with a NULL psImage. Should generate error, return NULL. +Calling with a non-positive xNum. Should generate error, return NULL. +Calling with a non-positive yNum. Should generate error, return NULL. +Calling with a non-positive border. Should generate error, return NULL. +Calling with acceptable input parameters, non-NULL mask. +Calling with acceptable input parameters, NULL mask. +Testing pmSubtractionFindStamps(100, 100, 10, 10, 2) +Calling with a NULL psImage. Should generate error, return NULL. +Calling with a non-positive xNum. Should generate error, return NULL. +Calling with a non-positive yNum. Should generate error, return NULL. +Calling with a non-positive border. Should generate error, return NULL. +Calling with acceptable input parameters, non-NULL mask. +Calling with acceptable input parameters, NULL mask. +Testing pmSubtractionCalculateEquation(): + image size is (25, 25) + num stamps is (2, 2). Border is 2 + kernel type is PM_SUBTRACTION_KERNEL_POIS. +Generating stamps... +Generating kernel basis functions... +Calling with a NULL psArray stamps. Should generate error, return FALSE. +Calling with a NULL reference images. Should generate error, return FALSE. +Calling with a NULL input images. Should generate error, return FALSE. +Calling with a NULL kernel basis functions. Should generate error, return FALSE. +Calling with acceptable input parameters. Should return TRUE. +Calling pmSubtractionSolveEquation() with a NULL stamp argument. Should generate error, return FALSE. +Calling pmSubtractionSolveEquation() with acceptable input parameters. Should return non-NULL. +The solution vector is: +(-3866492.76) (-520094.85) (-1277345.36) (-481569.41) (0.21) (-1182727.56) (0.01) (0.01) (-0.00) (-0.02) (-0.00) (0.00) (-0.01) (0.01) (-0.00) (-0.01) (0.00) (0.00) (0.02) (-0.01) (-0.01) (0.00) (0.01) (0.01) (-0.03) (0.01) (0.00) (-0.01) (0.00) (0.00) (0.01) (-0.01) (-0.02) (0.00) (0.01) (0.01) (-0.01) (0.01) (-0.00) (-0.01) (0.00) (0.01) (-0.02) (0.01) (0.02) (-0.01) (-0.00) (-0.01) (0.04) (-0.02) (-0.02) (0.01) (0.02) (0.01) (-0.03) (0.03) (0.02) (-0.02) (-0.01) (-0.01) (-0.01) (0.01) (0.00) (-0.01) (0.00) (0.00) (-0.02) (0.01) (0.01) (-0.01) (0.00) (-0.00) (-0.01) (-0.02) (0.01) (0.02) (0.02) (-0.01) (0.04) (0.00) (-0.01) (-0.01) (-0.02) (-0.00) (0.00) (-0.00) (-0.01) (0.00) (0.01) (0.01) (0.00) (-0.01) (-0.02) (0.02) (0.02) (0.02) (0.01) (-0.01) (-0.02) (0.01) (0.01) (0.02) (0.03) (-0.00) (-0.05) (-0.00) (0.01) (0.05) (-0.04) (0.03) (0.03) (-0.03) (-0.04) (-0.02) (-0.02) (-0.00) (0.00) (0.01) (0.00) (0.00) (-0.02) (0.01) (0.01) (-0.00) (-0.00) (-0.01) (-0.03) (0.02) (0.01) (-0.02) (-0.01) (-0.00) (0.01) (-0.01) (-0.02) (0.01) (0.00) (0.02) (-0.03) (0.01) (0.00) (-0.00) (-0.00) (0.00) (0.00) (-0.02) (-0.02) (0.02) (0.01) (0.02) (0.49) +Calling pmSubtractionRejectStamps() with acceptable input parameters. Should return TRUE. +Calling pmSubtractionKernelImage() with NULL solution. Should generate error, return NULL. +Calling pmSubtractionKernelImage() with NULL kernels. Should generate error, return NULL. +Calling pmSubtractionKernelImage() unallowable x value. Should generate error, return NULL. +Calling pmSubtractionKernelImage() unallowable x value. Should generate error, return NULL. +Calling pmSubtractionKernelImage() unallowable y value. Should generate error, return NULL. +Calling pmSubtractionKernelImage() unallowable y value. Should generate error, return NULL. +Calling pmSubtractionKernelImage() with acceptable input parameters. Should return a psImage. +-0.001170 -0.025330 0.003882 -0.024851 -0.014656 +-0.019844 -0.032570 0.014897 0.002807 0.000729 +0.002328 0.031599 -5181287.500000 -0.004433 -0.013596 +-0.008172 -0.016571 0.033990 -0.012052 -0.002317 +0.010558 -0.020875 0.011541 -0.006648 0.006954 +Testing pmSubtractionCalculateEquation(): + image size is (25, 25) + num stamps is (2, 2). Border is 2 + kernel type is PM_SUBTRACTION_KERNEL_ISIS. +Generating stamps... +Generating kernel basis functions... +Calling with a NULL psArray stamps. Should generate error, return FALSE. +Calling with a NULL reference images. Should generate error, return FALSE. +Calling with a NULL input images. Should generate error, return FALSE. +Calling with a NULL kernel basis functions. Should generate error, return FALSE. +Calling with acceptable input parameters. Should return TRUE. +Calling pmSubtractionSolveEquation() with a NULL stamp argument. Should generate error, return FALSE. +Calling pmSubtractionSolveEquation() with acceptable input parameters. Should return non-NULL. +The solution vector is: +(0.09) (-0.01) (-0.01) (0.00) (-0.00) (-0.00) (0.00) (-0.00) (0.00) (0.00) (-0.00) (0.00) (0.00) (-0.00) (0.00) (0.00) (-0.00) (0.00) (0.00) (-0.00) (0.00) (0.00) (-0.00) (0.00) (0.00) (-0.00) (0.00) (0.00) (-0.00) (0.00) (0.00) (-0.00) (0.00) (0.00) (-0.00) (0.00) (0.55) +Calling pmSubtractionRejectStamps() with acceptable input parameters. Should return TRUE. +Calling pmSubtractionKernelImage() with NULL solution. Should generate error, return NULL. +Calling pmSubtractionKernelImage() with NULL kernels. Should generate error, return NULL. +Calling pmSubtractionKernelImage() unallowable x value. Should generate error, return NULL. +Calling pmSubtractionKernelImage() unallowable x value. Should generate error, return NULL. +Calling pmSubtractionKernelImage() unallowable y value. Should generate error, return NULL. +Calling pmSubtractionKernelImage() unallowable y value. Should generate error, return NULL. +Calling pmSubtractionKernelImage() with acceptable input parameters. Should return a psImage. +0.031614 0.045997 0.052122 0.045997 0.031614 +0.045997 0.066926 0.075837 0.066926 0.045997 +0.052122 0.075837 0.085934 0.075837 0.052122 +0.045997 0.066926 0.075837 0.066926 0.045997 +0.031614 0.045997 0.052122 0.045997 0.031614 Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/imsubtract/verified/tst_pmSubtractBias.stderr =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/imsubtract/verified/tst_pmSubtractBias.stderr (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/imsubtract/verified/tst_pmSubtractBias.stderr (revision 21664) @@ -0,0 +1,9 @@ +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmSubtractBias.c * +* TestPoint: Test Point Driver{pmSubtractBias} * +* TestType: Positive * +\**********************************************************************************/ + + +---> TESTPOINT PASSED (Test Point Driver{pmSubtractBias} | tst_pmSubtractBias.c) + Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/imsubtract/verified/tst_pmSubtractBias.stdout =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/imsubtract/verified/tst_pmSubtractBias.stdout (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/imsubtract/verified/tst_pmSubtractBias.stdout (revision 21664) @@ -0,0 +1,672 @@ +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmSubtractBias.c * +* TestPoint: pmSubtractBias{PUT COMMENT HERE} * +* TestType: Positive * +\**********************************************************************************/ + +---- doSubtractOverscansGeneric() ---- + Image size: 8 by 8 + Overscan size: 6 by 6 + Total Overscans: 2 + Binning factor: 1 + Overscan axis: PM_OVERSCAN_ALL + Fit type: PM_FIT_SPLINE + +---> TESTPOINT PASSED (pmSubtractBias{Column Overscans} | tst_pmSubtractBias.c) + +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmSubtractBias.c * +* TestPoint: pmSubtractBias{PUT COMMENT HERE} * +* TestType: Positive * +\**********************************************************************************/ + +---- doSubtractOverscansGeneric() ---- + Image size: 8 by 8 + Overscan size: 6 by 6 + Total Overscans: 2 + Binning factor: 1 + Overscan axis: PM_OVERSCAN_COLUMNS + Fit type: PM_FIT_SPLINE + +---> TESTPOINT PASSED (pmSubtractBias{Column Overscans} | tst_pmSubtractBias.c) + +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmSubtractBias.c * +* TestPoint: pmSubtractBias{PUT COMMENT HERE} * +* TestType: Positive * +\**********************************************************************************/ + +---- doSubtractOverscansGeneric() ---- + Image size: 8 by 8 + Overscan size: 6 by 6 + Total Overscans: 2 + Binning factor: 1 + Overscan axis: PM_OVERSCAN_ROWS + Fit type: PM_FIT_SPLINE + +---> TESTPOINT PASSED (pmSubtractBias{Column Overscans} | tst_pmSubtractBias.c) + +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmSubtractBias.c * +* TestPoint: pmSubtractBias{PUT COMMENT HERE} * +* TestType: Positive * +\**********************************************************************************/ + +---- doSubtractOverscansGeneric() ---- + Image size: 8 by 8 + Overscan size: 6 by 6 + Total Overscans: 2 + Binning factor: 2 + Overscan axis: PM_OVERSCAN_ALL + Fit type: PM_FIT_SPLINE + +---> TESTPOINT PASSED (pmSubtractBias{Column Overscans} | tst_pmSubtractBias.c) + +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmSubtractBias.c * +* TestPoint: pmSubtractBias{PUT COMMENT HERE} * +* TestType: Positive * +\**********************************************************************************/ + +---- doSubtractOverscansGeneric() ---- + Image size: 8 by 8 + Overscan size: 6 by 6 + Total Overscans: 2 + Binning factor: 2 + Overscan axis: PM_OVERSCAN_COLUMNS + Fit type: PM_FIT_SPLINE + +---> TESTPOINT PASSED (pmSubtractBias{Column Overscans} | tst_pmSubtractBias.c) + +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmSubtractBias.c * +* TestPoint: pmSubtractBias{PUT COMMENT HERE} * +* TestType: Positive * +\**********************************************************************************/ + +---- doSubtractOverscansGeneric() ---- + Image size: 8 by 8 + Overscan size: 6 by 6 + Total Overscans: 2 + Binning factor: 2 + Overscan axis: PM_OVERSCAN_ROWS + Fit type: PM_FIT_SPLINE + +---> TESTPOINT PASSED (pmSubtractBias{Column Overscans} | tst_pmSubtractBias.c) + +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmSubtractBias.c * +* TestPoint: pmSubtractBias{PUT COMMENT HERE} * +* TestType: Positive * +\**********************************************************************************/ + +---- doSubtractOverscansGeneric() ---- + Image size: 8 by 8 + Overscan size: 8 by 8 + Total Overscans: 2 + Binning factor: 1 + Overscan axis: PM_OVERSCAN_ALL + Fit type: PM_FIT_SPLINE + +---> TESTPOINT PASSED (pmSubtractBias{Column Overscans} | tst_pmSubtractBias.c) + +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmSubtractBias.c * +* TestPoint: pmSubtractBias{PUT COMMENT HERE} * +* TestType: Positive * +\**********************************************************************************/ + +---- doSubtractOverscansGeneric() ---- + Image size: 8 by 8 + Overscan size: 8 by 8 + Total Overscans: 2 + Binning factor: 1 + Overscan axis: PM_OVERSCAN_COLUMNS + Fit type: PM_FIT_SPLINE + +---> TESTPOINT PASSED (pmSubtractBias{Column Overscans} | tst_pmSubtractBias.c) + +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmSubtractBias.c * +* TestPoint: pmSubtractBias{PUT COMMENT HERE} * +* TestType: Positive * +\**********************************************************************************/ + +---- doSubtractOverscansGeneric() ---- + Image size: 8 by 8 + Overscan size: 8 by 8 + Total Overscans: 2 + Binning factor: 1 + Overscan axis: PM_OVERSCAN_ROWS + Fit type: PM_FIT_SPLINE + +---> TESTPOINT PASSED (pmSubtractBias{Column Overscans} | tst_pmSubtractBias.c) + +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmSubtractBias.c * +* TestPoint: pmSubtractBias{PUT COMMENT HERE} * +* TestType: Positive * +\**********************************************************************************/ + +---- doSubtractOverscansGeneric() ---- + Image size: 8 by 8 + Overscan size: 8 by 8 + Total Overscans: 2 + Binning factor: 2 + Overscan axis: PM_OVERSCAN_ALL + Fit type: PM_FIT_SPLINE + +---> TESTPOINT PASSED (pmSubtractBias{Column Overscans} | tst_pmSubtractBias.c) + +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmSubtractBias.c * +* TestPoint: pmSubtractBias{PUT COMMENT HERE} * +* TestType: Positive * +\**********************************************************************************/ + +---- doSubtractOverscansGeneric() ---- + Image size: 8 by 8 + Overscan size: 8 by 8 + Total Overscans: 2 + Binning factor: 2 + Overscan axis: PM_OVERSCAN_COLUMNS + Fit type: PM_FIT_SPLINE + +---> TESTPOINT PASSED (pmSubtractBias{Column Overscans} | tst_pmSubtractBias.c) + +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmSubtractBias.c * +* TestPoint: pmSubtractBias{PUT COMMENT HERE} * +* TestType: Positive * +\**********************************************************************************/ + +---- doSubtractOverscansGeneric() ---- + Image size: 8 by 8 + Overscan size: 8 by 8 + Total Overscans: 2 + Binning factor: 2 + Overscan axis: PM_OVERSCAN_ROWS + Fit type: PM_FIT_SPLINE + +---> TESTPOINT PASSED (pmSubtractBias{Column Overscans} | tst_pmSubtractBias.c) + +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmSubtractBias.c * +* TestPoint: pmSubtractBias{PUT COMMENT HERE} * +* TestType: Positive * +\**********************************************************************************/ + +---- doSubtractOverscansGeneric() ---- + Image size: 8 by 8 + Overscan size: 10 by 10 + Total Overscans: 2 + Binning factor: 1 + Overscan axis: PM_OVERSCAN_ALL + Fit type: PM_FIT_SPLINE + +---> TESTPOINT PASSED (pmSubtractBias{Column Overscans} | tst_pmSubtractBias.c) + +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmSubtractBias.c * +* TestPoint: pmSubtractBias{PUT COMMENT HERE} * +* TestType: Positive * +\**********************************************************************************/ + +---- doSubtractOverscansGeneric() ---- + Image size: 8 by 8 + Overscan size: 10 by 10 + Total Overscans: 2 + Binning factor: 1 + Overscan axis: PM_OVERSCAN_COLUMNS + Fit type: PM_FIT_SPLINE + +---> TESTPOINT PASSED (pmSubtractBias{Column Overscans} | tst_pmSubtractBias.c) + +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmSubtractBias.c * +* TestPoint: pmSubtractBias{PUT COMMENT HERE} * +* TestType: Positive * +\**********************************************************************************/ + +---- doSubtractOverscansGeneric() ---- + Image size: 8 by 8 + Overscan size: 10 by 10 + Total Overscans: 2 + Binning factor: 1 + Overscan axis: PM_OVERSCAN_ROWS + Fit type: PM_FIT_SPLINE + +---> TESTPOINT PASSED (pmSubtractBias{Column Overscans} | tst_pmSubtractBias.c) + +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmSubtractBias.c * +* TestPoint: pmSubtractBias{PUT COMMENT HERE} * +* TestType: Positive * +\**********************************************************************************/ + +---- doSubtractOverscansGeneric() ---- + Image size: 8 by 8 + Overscan size: 10 by 10 + Total Overscans: 2 + Binning factor: 2 + Overscan axis: PM_OVERSCAN_ALL + Fit type: PM_FIT_SPLINE + +---> TESTPOINT PASSED (pmSubtractBias{Column Overscans} | tst_pmSubtractBias.c) + +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmSubtractBias.c * +* TestPoint: pmSubtractBias{PUT COMMENT HERE} * +* TestType: Positive * +\**********************************************************************************/ + +---- doSubtractOverscansGeneric() ---- + Image size: 8 by 8 + Overscan size: 10 by 10 + Total Overscans: 2 + Binning factor: 2 + Overscan axis: PM_OVERSCAN_COLUMNS + Fit type: PM_FIT_SPLINE + +---> TESTPOINT PASSED (pmSubtractBias{Column Overscans} | tst_pmSubtractBias.c) + +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmSubtractBias.c * +* TestPoint: pmSubtractBias{PUT COMMENT HERE} * +* TestType: Positive * +\**********************************************************************************/ + +---- doSubtractOverscansGeneric() ---- + Image size: 8 by 8 + Overscan size: 10 by 10 + Total Overscans: 2 + Binning factor: 2 + Overscan axis: PM_OVERSCAN_ROWS + Fit type: PM_FIT_SPLINE + +---> TESTPOINT PASSED (pmSubtractBias{Column Overscans} | tst_pmSubtractBias.c) + +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmSubtractBias.c * +* TestPoint: pmSubtractBias{PUT COMMENT HERE} * +* TestType: Positive * +\**********************************************************************************/ + +---- doSubtractOverscansGeneric() ---- + Image size: 8 by 8 + Overscan size: 8 by 8 + Total Overscans: 1 + Binning factor: 1 + Overscan axis: PM_OVERSCAN_ALL + Fit type: PM_FIT_SPLINE + +---> TESTPOINT PASSED (pmSubtractBias{Column Overscans} | tst_pmSubtractBias.c) + +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmSubtractBias.c * +* TestPoint: pmSubtractBias{PUT COMMENT HERE} * +* TestType: Positive * +\**********************************************************************************/ + +---- doSubtractOverscansGeneric() ---- + Image size: 8 by 8 + Overscan size: 8 by 8 + Total Overscans: 1 + Binning factor: 1 + Overscan axis: PM_OVERSCAN_COLUMNS + Fit type: PM_FIT_SPLINE + +---> TESTPOINT PASSED (pmSubtractBias{Column Overscans} | tst_pmSubtractBias.c) + +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmSubtractBias.c * +* TestPoint: pmSubtractBias{PUT COMMENT HERE} * +* TestType: Positive * +\**********************************************************************************/ + +---- doSubtractOverscansGeneric() ---- + Image size: 8 by 8 + Overscan size: 8 by 8 + Total Overscans: 1 + Binning factor: 1 + Overscan axis: PM_OVERSCAN_ROWS + Fit type: PM_FIT_SPLINE + +---> TESTPOINT PASSED (pmSubtractBias{Column Overscans} | tst_pmSubtractBias.c) + +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmSubtractBias.c * +* TestPoint: pmSubtractBias{PUT COMMENT HERE} * +* TestType: Positive * +\**********************************************************************************/ + +---- doSubtractOverscansGeneric() ---- + Image size: 8 by 8 + Overscan size: 6 by 6 + Total Overscans: 2 + Binning factor: 1 + Overscan axis: PM_OVERSCAN_ALL + Fit type: PM_FIT_POLYNOMIAL + +---> TESTPOINT PASSED (pmSubtractBias{Column Overscans} | tst_pmSubtractBias.c) + +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmSubtractBias.c * +* TestPoint: pmSubtractBias{PUT COMMENT HERE} * +* TestType: Positive * +\**********************************************************************************/ + +---- doSubtractOverscansGeneric() ---- + Image size: 8 by 8 + Overscan size: 6 by 6 + Total Overscans: 2 + Binning factor: 1 + Overscan axis: PM_OVERSCAN_COLUMNS + Fit type: PM_FIT_POLYNOMIAL + +---> TESTPOINT PASSED (pmSubtractBias{Column Overscans} | tst_pmSubtractBias.c) + +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmSubtractBias.c * +* TestPoint: pmSubtractBias{PUT COMMENT HERE} * +* TestType: Positive * +\**********************************************************************************/ + +---- doSubtractOverscansGeneric() ---- + Image size: 8 by 8 + Overscan size: 6 by 6 + Total Overscans: 2 + Binning factor: 1 + Overscan axis: PM_OVERSCAN_ROWS + Fit type: PM_FIT_POLYNOMIAL + +---> TESTPOINT PASSED (pmSubtractBias{Column Overscans} | tst_pmSubtractBias.c) + +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmSubtractBias.c * +* TestPoint: pmSubtractBias{PUT COMMENT HERE} * +* TestType: Positive * +\**********************************************************************************/ + +---- doSubtractOverscansGeneric() ---- + Image size: 8 by 8 + Overscan size: 6 by 6 + Total Overscans: 2 + Binning factor: 2 + Overscan axis: PM_OVERSCAN_ALL + Fit type: PM_FIT_POLYNOMIAL + +---> TESTPOINT PASSED (pmSubtractBias{Column Overscans} | tst_pmSubtractBias.c) + +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmSubtractBias.c * +* TestPoint: pmSubtractBias{PUT COMMENT HERE} * +* TestType: Positive * +\**********************************************************************************/ + +---- doSubtractOverscansGeneric() ---- + Image size: 8 by 8 + Overscan size: 6 by 6 + Total Overscans: 2 + Binning factor: 2 + Overscan axis: PM_OVERSCAN_COLUMNS + Fit type: PM_FIT_POLYNOMIAL + +---> TESTPOINT PASSED (pmSubtractBias{Column Overscans} | tst_pmSubtractBias.c) + +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmSubtractBias.c * +* TestPoint: pmSubtractBias{PUT COMMENT HERE} * +* TestType: Positive * +\**********************************************************************************/ + +---- doSubtractOverscansGeneric() ---- + Image size: 8 by 8 + Overscan size: 6 by 6 + Total Overscans: 2 + Binning factor: 2 + Overscan axis: PM_OVERSCAN_ROWS + Fit type: PM_FIT_POLYNOMIAL + +---> TESTPOINT PASSED (pmSubtractBias{Column Overscans} | tst_pmSubtractBias.c) + +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmSubtractBias.c * +* TestPoint: pmSubtractBias{PUT COMMENT HERE} * +* TestType: Positive * +\**********************************************************************************/ + +---- doSubtractOverscansGeneric() ---- + Image size: 8 by 8 + Overscan size: 8 by 8 + Total Overscans: 2 + Binning factor: 1 + Overscan axis: PM_OVERSCAN_ALL + Fit type: PM_FIT_POLYNOMIAL + +---> TESTPOINT PASSED (pmSubtractBias{Column Overscans} | tst_pmSubtractBias.c) + +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmSubtractBias.c * +* TestPoint: pmSubtractBias{PUT COMMENT HERE} * +* TestType: Positive * +\**********************************************************************************/ + +---- doSubtractOverscansGeneric() ---- + Image size: 8 by 8 + Overscan size: 8 by 8 + Total Overscans: 2 + Binning factor: 1 + Overscan axis: PM_OVERSCAN_COLUMNS + Fit type: PM_FIT_POLYNOMIAL + +---> TESTPOINT PASSED (pmSubtractBias{Column Overscans} | tst_pmSubtractBias.c) + +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmSubtractBias.c * +* TestPoint: pmSubtractBias{PUT COMMENT HERE} * +* TestType: Positive * +\**********************************************************************************/ + +---- doSubtractOverscansGeneric() ---- + Image size: 8 by 8 + Overscan size: 8 by 8 + Total Overscans: 2 + Binning factor: 1 + Overscan axis: PM_OVERSCAN_ROWS + Fit type: PM_FIT_POLYNOMIAL + +---> TESTPOINT PASSED (pmSubtractBias{Column Overscans} | tst_pmSubtractBias.c) + +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmSubtractBias.c * +* TestPoint: pmSubtractBias{PUT COMMENT HERE} * +* TestType: Positive * +\**********************************************************************************/ + +---- doSubtractOverscansGeneric() ---- + Image size: 8 by 8 + Overscan size: 8 by 8 + Total Overscans: 2 + Binning factor: 2 + Overscan axis: PM_OVERSCAN_ALL + Fit type: PM_FIT_POLYNOMIAL + +---> TESTPOINT PASSED (pmSubtractBias{Column Overscans} | tst_pmSubtractBias.c) + +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmSubtractBias.c * +* TestPoint: pmSubtractBias{PUT COMMENT HERE} * +* TestType: Positive * +\**********************************************************************************/ + +---- doSubtractOverscansGeneric() ---- + Image size: 8 by 8 + Overscan size: 8 by 8 + Total Overscans: 2 + Binning factor: 2 + Overscan axis: PM_OVERSCAN_COLUMNS + Fit type: PM_FIT_POLYNOMIAL + +---> TESTPOINT PASSED (pmSubtractBias{Column Overscans} | tst_pmSubtractBias.c) + +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmSubtractBias.c * +* TestPoint: pmSubtractBias{PUT COMMENT HERE} * +* TestType: Positive * +\**********************************************************************************/ + +---- doSubtractOverscansGeneric() ---- + Image size: 8 by 8 + Overscan size: 8 by 8 + Total Overscans: 2 + Binning factor: 2 + Overscan axis: PM_OVERSCAN_ROWS + Fit type: PM_FIT_POLYNOMIAL + +---> TESTPOINT PASSED (pmSubtractBias{Column Overscans} | tst_pmSubtractBias.c) + +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmSubtractBias.c * +* TestPoint: pmSubtractBias{PUT COMMENT HERE} * +* TestType: Positive * +\**********************************************************************************/ + +---- doSubtractOverscansGeneric() ---- + Image size: 8 by 8 + Overscan size: 10 by 10 + Total Overscans: 2 + Binning factor: 1 + Overscan axis: PM_OVERSCAN_ALL + Fit type: PM_FIT_POLYNOMIAL + +---> TESTPOINT PASSED (pmSubtractBias{Column Overscans} | tst_pmSubtractBias.c) + +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmSubtractBias.c * +* TestPoint: pmSubtractBias{PUT COMMENT HERE} * +* TestType: Positive * +\**********************************************************************************/ + +---- doSubtractOverscansGeneric() ---- + Image size: 8 by 8 + Overscan size: 10 by 10 + Total Overscans: 2 + Binning factor: 1 + Overscan axis: PM_OVERSCAN_COLUMNS + Fit type: PM_FIT_POLYNOMIAL + +---> TESTPOINT PASSED (pmSubtractBias{Column Overscans} | tst_pmSubtractBias.c) + +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmSubtractBias.c * +* TestPoint: pmSubtractBias{PUT COMMENT HERE} * +* TestType: Positive * +\**********************************************************************************/ + +---- doSubtractOverscansGeneric() ---- + Image size: 8 by 8 + Overscan size: 10 by 10 + Total Overscans: 2 + Binning factor: 1 + Overscan axis: PM_OVERSCAN_ROWS + Fit type: PM_FIT_POLYNOMIAL + +---> TESTPOINT PASSED (pmSubtractBias{Column Overscans} | tst_pmSubtractBias.c) + +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmSubtractBias.c * +* TestPoint: pmSubtractBias{PUT COMMENT HERE} * +* TestType: Positive * +\**********************************************************************************/ + +---- doSubtractOverscansGeneric() ---- + Image size: 8 by 8 + Overscan size: 10 by 10 + Total Overscans: 2 + Binning factor: 2 + Overscan axis: PM_OVERSCAN_ALL + Fit type: PM_FIT_POLYNOMIAL + +---> TESTPOINT PASSED (pmSubtractBias{Column Overscans} | tst_pmSubtractBias.c) + +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmSubtractBias.c * +* TestPoint: pmSubtractBias{PUT COMMENT HERE} * +* TestType: Positive * +\**********************************************************************************/ + +---- doSubtractOverscansGeneric() ---- + Image size: 8 by 8 + Overscan size: 10 by 10 + Total Overscans: 2 + Binning factor: 2 + Overscan axis: PM_OVERSCAN_COLUMNS + Fit type: PM_FIT_POLYNOMIAL + +---> TESTPOINT PASSED (pmSubtractBias{Column Overscans} | tst_pmSubtractBias.c) + +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmSubtractBias.c * +* TestPoint: pmSubtractBias{PUT COMMENT HERE} * +* TestType: Positive * +\**********************************************************************************/ + +---- doSubtractOverscansGeneric() ---- + Image size: 8 by 8 + Overscan size: 10 by 10 + Total Overscans: 2 + Binning factor: 2 + Overscan axis: PM_OVERSCAN_ROWS + Fit type: PM_FIT_POLYNOMIAL + +---> TESTPOINT PASSED (pmSubtractBias{Column Overscans} | tst_pmSubtractBias.c) + +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmSubtractBias.c * +* TestPoint: pmSubtractBias{PUT COMMENT HERE} * +* TestType: Positive * +\**********************************************************************************/ + +---- doSubtractOverscansGeneric() ---- + Image size: 8 by 8 + Overscan size: 8 by 8 + Total Overscans: 1 + Binning factor: 1 + Overscan axis: PM_OVERSCAN_ALL + Fit type: PM_FIT_POLYNOMIAL + +---> TESTPOINT PASSED (pmSubtractBias{Column Overscans} | tst_pmSubtractBias.c) + +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmSubtractBias.c * +* TestPoint: pmSubtractBias{PUT COMMENT HERE} * +* TestType: Positive * +\**********************************************************************************/ + +---- doSubtractOverscansGeneric() ---- + Image size: 8 by 8 + Overscan size: 8 by 8 + Total Overscans: 1 + Binning factor: 1 + Overscan axis: PM_OVERSCAN_COLUMNS + Fit type: PM_FIT_POLYNOMIAL + +---> TESTPOINT PASSED (pmSubtractBias{Column Overscans} | tst_pmSubtractBias.c) + +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmSubtractBias.c * +* TestPoint: pmSubtractBias{PUT COMMENT HERE} * +* TestType: Positive * +\**********************************************************************************/ + +---- doSubtractOverscansGeneric() ---- + Image size: 8 by 8 + Overscan size: 8 by 8 + Total Overscans: 1 + Binning factor: 1 + Overscan axis: PM_OVERSCAN_ROWS + Fit type: PM_FIT_POLYNOMIAL + +---> TESTPOINT PASSED (pmSubtractBias{Column Overscans} | tst_pmSubtractBias.c) + Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/imsubtract/verified/tst_pmSubtractSky.stderr =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/imsubtract/verified/tst_pmSubtractSky.stderr (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/imsubtract/verified/tst_pmSubtractSky.stderr (revision 21664) @@ -0,0 +1,162 @@ +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmSubtractSky.c * +* TestPoint: Test Point Driver{pmSubtractSky} * +* TestType: Positive * +\**********************************************************************************/ + +|W|pmSubtractSky + WARNING: in->parent is NULL. +|W|p_psDetermineTrimmedImage + WARNING: could not determine CELL.TRIMSEC from parent cell Metadata (NULL). +|W|p_psVectorSampleStdev + WARNING: p_psVectorSampleStdev(): only one valid psVector elements (1). Setting stats->sampleStdev = 0.0. +|W|ImageFitPolynomial + WARNING: ImageFitPolynomial(): Reducing polynomial complexity in x-dimension. +|W|ImageFitPolynomial + WARNING: ImageFitPolynomial(): Reducing polynomial complexity in y-dimension. +|W|pmSubtractSky + WARNING: in->parent is NULL. +|W|p_psDetermineTrimmedImage + WARNING: could not determine CELL.TRIMSEC from parent cell Metadata (NULL). +|W|ImageFitPolynomial + WARNING: ImageFitPolynomial(): Reducing polynomial complexity in x-dimension. +|W|pmSubtractSky + WARNING: in->parent is NULL. +|W|p_psDetermineTrimmedImage + WARNING: could not determine CELL.TRIMSEC from parent cell Metadata (NULL). +|W|ImageFitPolynomial + WARNING: ImageFitPolynomial(): Reducing polynomial complexity in y-dimension. +|W|pmSubtractSky + WARNING: in->parent is NULL. +|W|p_psDetermineTrimmedImage + WARNING: could not determine CELL.TRIMSEC from parent cell Metadata (NULL). +|W|pmSubtractSky + WARNING: in->parent is NULL. +|W|p_psDetermineTrimmedImage + WARNING: could not determine CELL.TRIMSEC from parent cell Metadata (NULL). +|W|p_psVectorSampleStdev + WARNING: p_psVectorSampleStdev(): only one valid psVector elements (1). Setting stats->sampleStdev = 0.0. +|W|ImageFitPolynomial + WARNING: ImageFitPolynomial(): Reducing polynomial complexity in x-dimension. +|W|ImageFitPolynomial + WARNING: ImageFitPolynomial(): Reducing polynomial complexity in y-dimension. +|W|pmSubtractSky + WARNING: in->parent is NULL. +|W|p_psDetermineTrimmedImage + WARNING: could not determine CELL.TRIMSEC from parent cell Metadata (NULL). +|W|ImageFitPolynomial + WARNING: ImageFitPolynomial(): Reducing polynomial complexity in x-dimension. +|W|pmSubtractSky + WARNING: in->parent is NULL. +|W|p_psDetermineTrimmedImage + WARNING: could not determine CELL.TRIMSEC from parent cell Metadata (NULL). +|W|ImageFitPolynomial + WARNING: ImageFitPolynomial(): Reducing polynomial complexity in y-dimension. +|W|pmSubtractSky + WARNING: in->parent is NULL. +|W|p_psDetermineTrimmedImage + WARNING: could not determine CELL.TRIMSEC from parent cell Metadata (NULL). +|W|pmSubtractSky + WARNING: in->parent is NULL. +|W|p_psDetermineTrimmedImage + WARNING: could not determine CELL.TRIMSEC from parent cell Metadata (NULL). +|W|pmSubtractSky + WARNING: in->parent is NULL. +|W|p_psDetermineTrimmedImage + WARNING: could not determine CELL.TRIMSEC from parent cell Metadata (NULL). +|W|pmSubtractSky + WARNING: in->parent is NULL. +|W|p_psDetermineTrimmedImage + WARNING: could not determine CELL.TRIMSEC from parent cell Metadata (NULL). +|W|pmSubtractSky + WARNING: in->parent is NULL. +|W|p_psDetermineTrimmedImage + WARNING: could not determine CELL.TRIMSEC from parent cell Metadata (NULL). +|W|pmSubtractSky + WARNING: in->parent is NULL. +|W|p_psDetermineTrimmedImage + WARNING: could not determine CELL.TRIMSEC from parent cell Metadata (NULL). +|W|pmSubtractSky + WARNING: in->parent is NULL. +|W|p_psDetermineTrimmedImage + WARNING: could not determine CELL.TRIMSEC from parent cell Metadata (NULL). +|W|pmSubtractSky + WARNING: in->parent is NULL. +|W|p_psDetermineTrimmedImage + WARNING: could not determine CELL.TRIMSEC from parent cell Metadata (NULL). +|W|pmSubtractSky + WARNING: in->parent is NULL. +|W|p_psDetermineTrimmedImage + WARNING: could not determine CELL.TRIMSEC from parent cell Metadata (NULL). +|W|pmSubtractSky + WARNING: in->parent is NULL. +|W|p_psDetermineTrimmedImage + WARNING: could not determine CELL.TRIMSEC from parent cell Metadata (NULL). +|W|ImageFitPolynomial + WARNING: ImageFitPolynomial(): Reducing polynomial complexity in x-dimension. +|W|ImageFitPolynomial + WARNING: ImageFitPolynomial(): Reducing polynomial complexity in y-dimension. + +---> TESTPOINT PASSED (Test Point Driver{pmSubtractSky} | tst_pmSubtractSky.c) + +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmSubtractSky.c * +* TestPoint: Test Point Driver{pmSubtractSky: warning, error messages} * +* TestType: Positive * +\**********************************************************************************/ + +|E|pmSubtractSky (FILE:LINENO) + Unallowable operation: psReadout in or its data is NULL. +|E|pmSubtractSky (FILE:LINENO) + Unallowable operation: psReadout in or its data is NULL. +|E|pmSubtractSky (FILE:LINENO) + Unallowable operation: psImage in has incorrect type. +|W|pmSubtractSky + WARNING: in->parent is NULL. +|W|pmSubtractSky + WARNING: in->parent is NULL. +|W|pmSubtractSky + WARNING: in->parent is NULL. +|W|pmSubtractSky + WARNING: in->parent is NULL. +|W|p_psDetermineTrimmedImage + WARNING: could not determine CELL.TRIMSEC from parent cell Metadata (NULL). +|W|pmSubtractSky + WARNING: pmSubtractSky(): input parameter stats is NULL +|W|pmSubtractSky + WARNING: in->parent is NULL. +|W|p_psDetermineTrimmedImage + WARNING: could not determine CELL.TRIMSEC from parent cell Metadata (NULL). +|W|pmSubtractSky + WARNING: pmSubtractSky(): no stats->options was requested +|W|pmSubtractSky + WARNING: in->parent is NULL. +|W|p_psDetermineTrimmedImage + WARNING: could not determine CELL.TRIMSEC from parent cell Metadata (NULL). +|W|pmSubtractSky + WARNING: Multiple statistical options have been requested. +|W|pmSubtractSky + WARNING: in->parent is NULL. +|W|p_psDetermineTrimmedImage + WARNING: could not determine CELL.TRIMSEC from parent cell Metadata (NULL). +|W|pmSubtractSky + WARNING: pmSubtractSky(): binFactor is 0 +|W|pmSubtractSky + WARNING: in->parent is NULL. +|W|p_psDetermineTrimmedImage + WARNING: could not determine CELL.TRIMSEC from parent cell Metadata (NULL). +|W|pmSubtractSky + WARNING: pmSubtractSky(): binFactor is -1 +|W|pmSubtractSky + WARNING: in->parent is NULL. +|W|p_psDetermineTrimmedImage + WARNING: could not determine CELL.TRIMSEC from parent cell Metadata (NULL). +|W|pmSubtractSky + WARNING: pmSubtractSky(): clipSD is -1.000000 +|W|pmSubtractSky + WARNING: in->parent is NULL. +|E|pmSubtractSky (FILE:LINENO) + psFit is unallowable (54321). Returning in image. + +---> TESTPOINT PASSED (Test Point Driver{pmSubtractSky: warning, error messages} | tst_pmSubtractSky.c) + Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/imsubtract/verified/tst_pmSubtractSky.stdout =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/imsubtract/verified/tst_pmSubtractSky.stdout (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/imsubtract/verified/tst_pmSubtractSky.stdout (revision 21664) @@ -0,0 +1,219 @@ +doSubtractSkySimple(1, 1, 1) +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmSubtractSky.c * +* TestPoint: pmSubtractSky{doSubtractSkySimple} * +* TestType: Positive * +\**********************************************************************************/ + + +---> TESTPOINT PASSED (pmSubtractSky{doSubtractSkySimple} | tst_pmSubtractSky.c) + +doSubtractSkySimple(NUM_COLS, 1, 1) +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmSubtractSky.c * +* TestPoint: pmSubtractSky{doSubtractSkySimple} * +* TestType: Positive * +\**********************************************************************************/ + + +---> TESTPOINT PASSED (pmSubtractSky{doSubtractSkySimple} | tst_pmSubtractSky.c) + +doSubtractSkySimple(1, NUM_ROWS, 1) +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmSubtractSky.c * +* TestPoint: pmSubtractSky{doSubtractSkySimple} * +* TestType: Positive * +\**********************************************************************************/ + + +---> TESTPOINT PASSED (pmSubtractSky{doSubtractSkySimple} | tst_pmSubtractSky.c) + +doSubtractSkySimple(NUM_COLS, NUM_ROWS, 1) +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmSubtractSky.c * +* TestPoint: pmSubtractSky{doSubtractSkySimple} * +* TestType: Positive * +\**********************************************************************************/ + + +---> TESTPOINT PASSED (pmSubtractSky{doSubtractSkySimple} | tst_pmSubtractSky.c) + +doSubtractSkySimple(1, 1, 2) +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmSubtractSky.c * +* TestPoint: pmSubtractSky{doSubtractSkySimple} * +* TestType: Positive * +\**********************************************************************************/ + + +---> TESTPOINT PASSED (pmSubtractSky{doSubtractSkySimple} | tst_pmSubtractSky.c) + +doSubtractSkySimple(NUM_COLS, 1, 2) +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmSubtractSky.c * +* TestPoint: pmSubtractSky{doSubtractSkySimple} * +* TestType: Positive * +\**********************************************************************************/ + + +---> TESTPOINT PASSED (pmSubtractSky{doSubtractSkySimple} | tst_pmSubtractSky.c) + +doSubtractSkySimple(1, NUM_ROWS, 2) +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmSubtractSky.c * +* TestPoint: pmSubtractSky{doSubtractSkySimple} * +* TestType: Positive * +\**********************************************************************************/ + + +---> TESTPOINT PASSED (pmSubtractSky{doSubtractSkySimple} | tst_pmSubtractSky.c) + +doSubtractSkySimple(NUM_COLS, NUM_ROWS, 2) +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmSubtractSky.c * +* TestPoint: pmSubtractSky{doSubtractSkySimple} * +* TestType: Positive * +\**********************************************************************************/ + + +---> TESTPOINT PASSED (pmSubtractSky{doSubtractSkySimple} | tst_pmSubtractSky.c) + +doSubtractSkyWithObjects(NUM_COLS, NUM_ROWS, 1) +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmSubtractSky.c * +* TestPoint: pmSubtractSky{doSubtractSkyWithObjects} * +* TestType: Positive * +\**********************************************************************************/ + + +---> TESTPOINT PASSED (pmSubtractSky{doSubtractSkyWithObjects} | tst_pmSubtractSky.c) + +doSubtractSkyWithObjects(NUM_COLS, NUM_ROWS, 2) +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmSubtractSky.c * +* TestPoint: pmSubtractSky{doSubtractSkyWithObjects} * +* TestType: Positive * +\**********************************************************************************/ + + +---> TESTPOINT PASSED (pmSubtractSky{doSubtractSkyWithObjects} | tst_pmSubtractSky.c) + +doSubtractSkyWithObjects(NUM_COLS, NUM_ROWS, 4) +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmSubtractSky.c * +* TestPoint: pmSubtractSky{doSubtractSkyWithObjects} * +* TestType: Positive * +\**********************************************************************************/ + + +---> TESTPOINT PASSED (pmSubtractSky{doSubtractSkyWithObjects} | tst_pmSubtractSky.c) + +doSubtractSkyWithObjects(NUM_COLS, NUM_ROWS, 8) +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmSubtractSky.c * +* TestPoint: pmSubtractSky{doSubtractSkyWithObjects} * +* TestType: Positive * +\**********************************************************************************/ + + +---> TESTPOINT PASSED (pmSubtractSky{doSubtractSkyWithObjects} | tst_pmSubtractSky.c) + +doSubtractSkyWithObjects(NUM_COLS, NUM_ROWS, 16) +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmSubtractSky.c * +* TestPoint: pmSubtractSky{doSubtractSkyWithObjects} * +* TestType: Positive * +\**********************************************************************************/ + + +---> TESTPOINT PASSED (pmSubtractSky{doSubtractSkyWithObjects} | tst_pmSubtractSky.c) + +doSubtractSkyWithObjects(NUM_COLS, NUM_ROWS, 32) +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmSubtractSky.c * +* TestPoint: pmSubtractSky{doSubtractSkyWithObjects} * +* TestType: Positive * +\**********************************************************************************/ + + +---> TESTPOINT PASSED (pmSubtractSky{doSubtractSkyWithObjects} | tst_pmSubtractSky.c) + +doSubtractSkyWithObjects(NUM_COLS, NUM_ROWS, 64) +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmSubtractSky.c * +* TestPoint: pmSubtractSky{doSubtractSkyWithObjects} * +* TestType: Positive * +\**********************************************************************************/ + + +---> TESTPOINT PASSED (pmSubtractSky{doSubtractSkyWithObjects} | tst_pmSubtractSky.c) + +doSubtractSkyWithObjects(NUM_COLS, NUM_ROWS, 128) +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmSubtractSky.c * +* TestPoint: pmSubtractSky{doSubtractSkyWithObjects} * +* TestType: Positive * +\**********************************************************************************/ + + +---> TESTPOINT PASSED (pmSubtractSky{doSubtractSkyWithObjects} | tst_pmSubtractSky.c) + +doSubtractSkyWithObjects(NUM_COLS, NUM_ROWS, 256) +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmSubtractSky.c * +* TestPoint: pmSubtractSky{doSubtractSkyWithObjects} * +* TestType: Positive * +\**********************************************************************************/ + + +---> TESTPOINT PASSED (pmSubtractSky{doSubtractSkyWithObjects} | tst_pmSubtractSky.c) + +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmSubtractSky.c * +* TestPoint: pmSubtractSky{Testing bad input parameter conditions.} * +* TestType: Positive * +\**********************************************************************************/ + +---------------------------------------------------------------- +Calling pmSubtractSky() with NULL pmReadout. Should error. + +---------------------------------------------------------------- +Calling pmSubtractSky() with NULL pmReadout->image. Should error. + +---------------------------------------------------------------- +Calling pmSubtractSky() with PS_TYPE_F64 pmReadout->image. Should error. + +---------------------------------------------------------------- +Calling pmSubtractSky() with NULL fitSpec. Should return image, no ERROR, no WARNING. + +---------------------------------------------------------------- +Calling pmSubtractSky() with PM_FIT_NONE fit. Should return image, no ERROR, no WARNING. + +---------------------------------------------------------------- +Calling pmSubtractSky() with PM_FIT_SPLINE fit. Should return image, no ERROR, no WARNING. + +---------------------------------------------------------------- +Calling pmSubtractSky() with NULL myStats. Should fit entire image, generate WARNING. + +---------------------------------------------------------------- +Calling pmSubtractSky() with no myStats->options specified. Should fit entire image, generate WARNING. + +---------------------------------------------------------------- +Calling pmSubtractSky() with multiple myStats->options specified. Should fit entire image, generate WARNING. + +---------------------------------------------------------------- +Calling pmSubtractSky() with 0 binFactor. Should fit entire image, generate WARNING. + +---------------------------------------------------------------- +Calling pmSubtractSky() with -1 binFactor. Should fit entire image, generate WARNING. + +---------------------------------------------------------------- +Calling pmSubtractSky() with -1.0 clipSD. Should fit entire image, generate WARNING. + +---------------------------------------------------------------- +Calling pmSubtractSky() with bogus psFit. Should generate Error. + +---------------------------------------------------------------- + +---> TESTPOINT PASSED (pmSubtractSky{Testing bad input parameter conditions.} | tst_pmSubtractSky.c) + Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/objects/.cvsignore =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/objects/.cvsignore (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/objects/.cvsignore (revision 21664) @@ -0,0 +1,6 @@ +.deps +.libs +Makefile +Makefile.in +temp +tst_pmObjects01 Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/objects/Makefile.am =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/objects/Makefile.am (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/objects/Makefile.am (revision 21664) @@ -0,0 +1,21 @@ +# Makefile for psModule tests + +AM_LDFLAGS = -L$(top_builddir)/src -lpsmodule $(PSMODULE_LIBS) +AM_CFLAGS = @AM_CFLAGS@ $(PSMODULE_CFLAGS) $(SRCINC) + +TESTS = \ + tst_pmObjects01 + +tst_pmObjects01_SOURCES = tst_pmObjects01.c + +check_PROGRAMS = $(TESTS) + +TESTS_ENVIRONMENT = perl $(top_srcdir)/test/runTest --verified=$(srcdir)/verified + +tests: $(TESTS) + +EXTRA_DIST = verified + +CLEANFILES = $(TESTS) temp/* + +test: check Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/objects/tst_pmObjects01.c =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/objects/tst_pmObjects01.c (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/objects/tst_pmObjects01.c (revision 21664) @@ -0,0 +1,1297 @@ +/** @file tst_pmObjects.c + * + * @brief Contains the tests for pmObjects.c: + * + * test00: This code will ... + * + * @author GLG, MHPCC + * + * XXX: Must test + * pmSourceRoughClass + * many others... + * + * + * XXX: Must test output results for many other functions. + * + * XXX: There are many cases where row/col can be switched in the code. + * We must test that here by using non-square images. All tests + * in this file should be run with non-square images. + * + * XXX: Memory leaks are not being caught. If I allocated a psVector in these functions + * and never deallocate, no error is generated. + * + * XXX: Much of this file is commented out due to the API changes in rel 7. + * + * +Fully Tested: + pmPeakAlloc() + pmMomentsAlloc() +Weakly Tested: + pmSourceMoments() + most of psObjects.c is not tested + * + * @version $Revision: 1.6 $ $Name: not supported by cvs2svn $ + * @date $Date: 2005-12-05 21:28:55 $ + * + * Copyright 2004 Maui High Performance Computing Center, University of Hawaii + */ +#include "psTest.h" +#include "pslib.h" +#include "pmObjects.h" +#include "pmModelGroup.h" + +#define NUM_ROWS 10 +#define NUM_COLS 10 +#define ERROR_TOLERANCE 1.0 +#define ERROR_TOL 0.001 +static int test00(void); +static int test01(void); +static int test02(void); +static int test03(void); +static int test04(void); +static int test05(void); +//static int test06(void); +//static int test07(void); +//static int test08(void); +//static int test09(void); +//static int test15(void); +//static int test16(void); +//static int test20(void); +testDescription tests[] = { + {test00, 000, "pmObjects: structure allocators and deallocators", true, false}, + {test01, 001, "pmObjects: psFindVectorPeaks()", true, false}, + {test02, 001, "pmObjects: psFindImagePeaks()", true, false}, + {test03, 001, "pmObjects: pmCullPeaks()", true, false}, + {test04, 001, "pmObjects: pmSourceLocalSky()", true, false}, + {test05, 001, "pmObjects: pmSourceMoments()", true, false}, + // {test06, 001, "pmObjects: pmSourceSetPixelsCircle()", true, false}, + // {test07, 001, "pmObjects: pmMin()", true, false}, + // {test08, 001, "pmObjects: pmSourceModelGuess()", true, false}, + //{test09, 001, "pmObjects: pmSourceContour()", true, false}, + //{test15, 001, "pmObjects: pmSourceAddModel()", true, false}, + //{test16, 001, "pmObjects: pmSourceSubModel()", true, false}, + //{test20, 001, "pmObjects: pmSourceSubModel()", true, false}, + {NULL} + }; + +int main(int argc, char* argv[]) +{ + psLogSetFormat("HLNM"); + // + // We include the function names here in psTraceSetLevel() commands for + // debugging convenience. There is no guarantee that this list of functions + // is complete. + // + psTraceSetLevel(".", 0); + psTraceSetLevel("pmPeakAlloc", 0); + psTraceSetLevel("pmMomentsAlloc", 0); + psTraceSetLevel("modelFree", 0); + psTraceSetLevel("pmModelAlloc", 0); + psTraceSetLevel("sourceFree", 0); + psTraceSetLevel("pmSourceAlloc", 0); + psTraceSetLevel("pmFindVectorPeaks", 0); + psTraceSetLevel("getRowVectorFromImage", 0); + psTraceSetLevel("myListAddPeak", 0); + psTraceSetLevel("pmFindImagePeaks", 0); + psTraceSetLevel("isItInThisRegion", 0); + psTraceSetLevel("pmCullPeaks", 0); + psTraceSetLevel("pmPeaksSubset", 0); + psTraceSetLevel("pmSourceLocalSky", 0); + psTraceSetLevel("checkRadius2", 0); + psTraceSetLevel("pmSourceMoments", 0); + psTraceSetLevel("pmComparePeakAscend", 0); + psTraceSetLevel("pmComparePeakDescend", 0); + psTraceSetLevel("pmSourcePSFClump", 0); + psTraceSetLevel("pmSourceRoughClass", 0); + psTraceSetLevel("pmSourceDefinePixels", 0); + psTraceSetLevel("pmSourceModelGuess", 0); + psTraceSetLevel("pmModelEval", 0); + psTraceSetLevel("findValue", 0); + psTraceSetLevel("pmSourceContour", 0); + psTraceSetLevel("pmSourceFitModel_v5", 0); + psTraceSetLevel("pmSourceFitModel", 0); + psTraceSetLevel("p_pmSourceAddOrSubModel", 0); + psTraceSetLevel("pmSourceAddModel", 0); + psTraceSetLevel("pmSourceSubModel", 0); + + return !runTestSuite(stderr, "Test Point Driver", tests, argc, argv); +} + +/****************************************************************************** +test00(): Test the various allocators and deallocators. + *****************************************************************************/ +int test00( void ) +{ + bool testStatus = true; + psTraceSetLevel(".", 0); + + printf("Testing pmPeakAlloc()...\n"); + pmPeak *tmpPeak = pmPeakAlloc(1, 2, 3.0, PM_PEAK_LONE); + if (tmpPeak == NULL) { + printf("TEST ERROR: pmPeakAlloc() returned a NULL pmPeak\n"); + testStatus = false; + } else { + if (tmpPeak->x != 1) { + printf("TEST ERROR: pmPeakAlloc() improperly set pmPeak->x\n"); + testStatus = false; + } + if (tmpPeak->y != 2) { + printf("TEST ERROR: pmPeakAlloc() improperly set pmPeak->y\n"); + testStatus = false; + } + if (tmpPeak->counts != 3.0) { + printf("TEST ERROR: pmPeakAlloc() improperly set pmPeak->counts\n"); + testStatus = false; + } + if (tmpPeak->class != PM_PEAK_LONE) { + printf("TEST ERROR: pmPeakAlloc() improperly set pmPeak->class\n"); + testStatus = false; + } + } + psFree(tmpPeak); + + printf("Testing pmMomentsAlloc()...\n"); + pmMoments *tmpMoments = pmMomentsAlloc(); + if (tmpMoments == NULL) { + printf("TEST ERROR: pmMomentsAlloc() returned a NULL pmMoments\n"); + testStatus = false; + } else { + if ((fabs(tmpMoments->x-0.0) > ERROR_TOL) || + (fabs(tmpMoments->y-0.0) > ERROR_TOL) || + (fabs(tmpMoments->Sx-0.0) > ERROR_TOL) || + (fabs(tmpMoments->Sy-0.0) > ERROR_TOL) || + (fabs(tmpMoments->Sxy-0.0) > ERROR_TOL) || + (fabs(tmpMoments->Sum-0.0) > ERROR_TOL) || + (fabs(tmpMoments->Peak-0.0) > ERROR_TOL) || + (fabs(tmpMoments->Sky-0.0) > ERROR_TOL) || + (tmpMoments->nPixels != 0)) { + printf("TEST ERROR: pmMomentsAlloc() did not properly initialize the pmMoments structure.\n"); + printf(" tmpMoments->x is %f\n", tmpMoments->x); + printf(" tmpMoments->y is %f\n", tmpMoments->y); + printf(" tmpMoments->Sx is %f\n", tmpMoments->Sx); + printf(" tmpMoments->Sy is %f\n", tmpMoments->Sy); + printf(" tmpMoments->Sxy is %f\n", tmpMoments->Sxy); + printf(" tmpMoments->Sum is %f\n", tmpMoments->Sum); + printf(" tmpMoments->Peak is %f\n", tmpMoments->Peak); + printf(" tmpMoments->Sky is %f\n", tmpMoments->Sky); + printf(" tmp Moments->nPixels is %d\n", tmpMoments->nPixels); + testStatus = false; + } + } + psFree(tmpMoments); + + + // + // Loop through each type of model + // + psS32 i = 0; + while (0 != pmModelParameterCount(i)) { + printf("Testing pmModelAlloc(%s)...\n", pmModelGetType(0)); + pmModel *tmpModel = pmModelAlloc(i); + if (tmpModel == NULL) { + printf("TEST ERROR: pmModelAlloc(%s) returned a NULL pmModel\n", pmModelGetType(0)); + testStatus = false; + } else { + + /* XXX: Should we test that the members were set correctly? + if ((tmpModel->params->n != 7) || (tmpModel->dparams->n != 7)) { + printf("TEST ERROR: pmModelAlloc(PS_MODEL_GAUSS) allocated an incorrect number of params (%ld, %ld)\n", + tmpModel->params->n, tmpModel->dparams->n); + testStatus = false; + } else { + for (psS32 i = 0 ; i < 7 ; i++) { + if ((tmpModel->params->data.F32[i] != 0.0) || + (tmpModel->dparams->data.F32[i] != 0.0)) { + printf("TEST ERROR: pmModelAlloc(PS_MODEL_GAUSS) did not ininitialize the params/dparams array to 0.0.\n"); + testStatus = false; + } + } + } + */ + } + psFree(tmpModel); + i++; + } + + + pmSource *tmpSource = pmSourceAlloc(); + if (tmpSource == NULL) { + printf("TEST ERROR: pmSourceAlloc() returned a NULL pmSource\n"); + testStatus = false; + } + psFree(tmpSource); + + return(testStatus); +} + +/****************************************************************************** +test01(): we first test pmFindVectorPeaks() with a variety of bad input +parameters. Then we test it with a simple vector both 1- and multi-elements. + *****************************************************************************/ +#define TST01_VECTOR_LENGTH 10 +bool test_pmFindVectorPeaks(int n) +{ + bool testStatus = true; + psVector *inData = psVectorAlloc(n, PS_TYPE_F32); + psVector *outData = NULL; + + printf("-------------- Calling test_pmFindVectorPeaks on an %d size vector. --------------\n", n); + // + // Test first pixel peak. + // + printf("Test pmFindVectorPeaks() with a first-element peak.\n"); + for (psS32 i = 0 ; i < n ; i++) { + inData->data.F32[i] = (float) (n-i); + } + inData->data.F32[0] = (float) n; + + outData= pmFindVectorPeaks(inData, 0.0); + if (outData == NULL) { + printf("TEST ERROR: pmFindVectorPeaks returned a NULL psVector.\n"); + testStatus = false; + } else { + if (outData->n != 1) { + printf("TEST ERROR: outData->n is %ld\n", outData->n); + testStatus = false; + } + if (outData->data.U32[0] != 0) { + printf("TEST ERROR: Did not find peak at element 0.\n"); + testStatus = false; + } + psFree(outData); + } + + // + // Test first pixel peak, large threshold + // + printf("Test pmFindVectorPeaks() with a first-element peak, large threshold.\n"); + for (psS32 i = 0 ; i < n ; i++) { + inData->data.F32[i] = (float) (n-i); + } + inData->data.F32[0] = (float) n; + + outData= pmFindVectorPeaks(inData, (float) (n*n)); + if (outData == NULL) { + printf("TEST ERROR: pmFindVectorPeaks returned a NULL psVector.\n"); + testStatus = false; + } else { + + if (outData->n != 0) { + printf("TEST ERROR: outData->n is %ld\n", outData->n); + testStatus = false; + } + psFree(outData); + + // Skip remaining tests if the input vector has length 1. + if (n == 1) { + psFree(inData); + return(testStatus); + } + } + + // + // Test last pixel peak. + // + printf("Test pmFindVectorPeaks() with a last-element peak.\n"); + for (psS32 i = 0 ; i < n ; i++) { + inData->data.F32[i] = (float) (i); + } + inData->data.F32[n-1] = (float) n; + + outData= pmFindVectorPeaks(inData, 0.0); + if (outData == NULL) { + printf("TEST ERROR: pmFindVectorPeaks returned a NULL psVector.\n"); + testStatus = false; + } else { + + if (outData->n != 1) { + printf("TEST ERROR: outData->n is %ld\n", outData->n); + testStatus = false; + } + if (outData->data.U32[0] != n-1) { + printf("TEST ERROR: Did not find peak at element %d.\n", n-1); + testStatus = false; + } + psFree(outData); + } + + // + // Test last pixel peak, large threshold. + // + printf("Test pmFindVectorPeaks() with a last-element peak, large threshold.\n"); + for (psS32 i = 0 ; i < n ; i++) { + inData->data.F32[i] = (float) (i); + } + inData->data.F32[n-1] = (float) n; + + outData= pmFindVectorPeaks(inData, (float) (n*n)); + if (outData == NULL) { + printf("TEST ERROR: pmFindVectorPeaks returned a NULL psVector.\n"); + testStatus = false; + } else { + + if (outData->n != 0) { + printf("TEST ERROR: outData->n is %ld\n", outData->n); + testStatus = false; + } + psFree(outData); + } + + // + // Test interior peaks. + // Set all even number elements to be peaks. + // + printf("Test pmFindVectorPeaks() with all even-numbered elements peak.\n"); + for (psS32 i = 0 ; i < n ; i++) { + if (0 == i%2) { + inData->data.F32[i] = (float) (2 * i); + } else { + inData->data.F32[i] = (float) (i); + } + } + inData->data.F32[0] = (float) n; + + + outData= pmFindVectorPeaks(inData, 0.0); + if (outData == NULL) { + printf("TEST ERROR: pmFindVectorPeaks returned a NULL psVector.\n"); + testStatus = false; + } else { + + if (outData->n != n/2) { + printf("TEST ERROR: outData->n is %ld\n", outData->n); + testStatus = false; + } + + for (psS32 i = 0 ; i < outData->n ; i++) { + if (outData->data.U32[i] != (2 * i)) { + printf("TEST ERROR: the %d-th peak is element number %d\n", i, outData->data.U32[i]); + testStatus = false; + } + } + psFree(outData); + } + + // + // Test interior peaks, with threshold = n*n. + // Should generate an empty output psVector. + // + printf("Test pmFindVectorPeaks() with all even-numbered elements peak, large threshold.\n"); + outData= pmFindVectorPeaks(inData, (float) (n*n)); + if (outData == NULL) { + printf("TEST ERROR: pmFindVectorPeaks returned a NULL psVector.\n"); + testStatus = false; + } else { + + if (outData->n != 0) { + printf("TEST ERROR: outData->n is %ld\n", outData->n); + testStatus = false; + } + psFree(outData); + } + + psFree(inData); + return(testStatus); +} + +int test01( void ) +{ + bool testStatus = true; + psVector *tmpVec = NULL; + psVector *tmpVecF64 = psVectorAlloc(TST01_VECTOR_LENGTH, PS_TYPE_F64); + psVector *tmpVecEmpty = psVectorAlloc(0, PS_TYPE_F32); + + psTraceSetLevel(".", 0); + + printf("----------------------------------------------------------------------------------\n"); + printf("Calling pmFindVectorPeaks with NULL psVector. Should generate error and return NULL.\n"); + tmpVec = pmFindVectorPeaks(NULL, 0.0); + if (tmpVec != NULL) { + printf("TEST ERROR: pmFindVectorPeaks() returned a non-NULL psVector.\n"); + testStatus = false; + psFree(tmpVec); + } + + printf("----------------------------------------------------------------------------------\n"); + printf("Calling pmFindVectorPeaks with empty psVector. Should generate error and return NULL.\n"); + tmpVec = pmFindVectorPeaks(tmpVecEmpty, 0.0); + if (tmpVec != NULL) { + printf("TEST ERROR: pmFindVectorPeaks() returned a non-NULL psVector.\n"); + testStatus = false; + psFree(tmpVec); + } + + printf("----------------------------------------------------------------------------------\n"); + printf("Calling pmFindVectorPeaks with PS_TYPE_F64 psVector. Should generate error and return NULL.\n"); + tmpVec = pmFindVectorPeaks(tmpVecF64, 0.0); + if (tmpVec != NULL) { + printf("TEST ERROR: pmFindVectorPeaks() returned a non-NULL psVector.\n"); + testStatus = false; + psFree(tmpVec); + } + testStatus&= test_pmFindVectorPeaks(1); + testStatus&= test_pmFindVectorPeaks(TST01_VECTOR_LENGTH); + + psFree(tmpVecF64); + psFree(tmpVecEmpty); + return(testStatus); +} + +/****************************************************************************** +test02(): +// XXX: Must test flat peaks. +// XXX: test 1-by-n and n-by-1 images. + *****************************************************************************/ +#define TST02_NUM_ROWS 5 +#define TST02_NUM_COLS 5 +bool test_pmFindImagePeaks(int numRows, int numCols) +{ + printf("-------------- Calling test_pmFindImagePeaks on an %d-by-%d image. --------------\n", numRows, numCols); + // if ((numRows < 4) || (numCols < 4)) { + // printf("WARNING: Don't call this test with a smaller than 4-by-4 image.\n"); + // return(true); + // } + bool testStatus = true; + psImage *inData = psImageAlloc(numCols, numRows, PS_TYPE_F32); + psArray *outData = NULL; + + // + // Initialize test image. + // + for (psS32 i = 0 ; i < numRows ; i++) { + for (psS32 j = 0 ; j < numCols ; j++) { + inData->data.F32[i][j] = PS_SQR(i - numRows/2) + PS_SQR(j-numCols/2); + } + } + // + // Set corner and center pixels as peaks. + // + inData->data.F32[0][0] = PS_SQR(numRows) + PS_SQR(numCols); + inData->data.F32[0][numCols-1] = PS_SQR(numRows) + PS_SQR(numCols); + inData->data.F32[numRows-1][0] = PS_SQR(numRows) + PS_SQR(numCols); + inData->data.F32[numRows-1][numCols-1] = PS_SQR(numRows) + PS_SQR(numCols); + inData->data.F32[numRows/2][numCols/2] = PS_SQR(numRows) + PS_SQR(numCols); + + // + // Print image. + // + for (psS32 i = 0 ; i < numRows ; i++) { + for (psS32 j = 0 ; j < numCols ; j++) { + printf("(%.1f) ", inData->data.F32[i][j]); + } + printf("\n"); + } + + // + // Call pmFindImagePeaks() with a threshold of 0.0. + // + outData = pmFindImagePeaks(inData, 0.0); + + if (outData == NULL) { + printf("TEST ERROR: pmFindImagePeaks returned a NULL psList.\n"); + testStatus = false; + } else { + psS32 expectedNumPeaks; + if ((numRows == 1) && (numCols == 1)) { + expectedNumPeaks = 1; + } else if ((numRows == 1) || (numCols == 1)) { + expectedNumPeaks = 3; + } else { + expectedNumPeaks = 5; + } + if (outData->n != expectedNumPeaks) { + printf("TEST ERROR: pmFindImagePeaks found %ld peaks (should be %d)\n", outData->n, expectedNumPeaks); + testStatus = false; + } + + // HEY: verify + for (psS32 i = 0 ; i < outData->n ; i++) { + pmPeak *tmpPeak = (pmPeak *) outData->data[i]; + if (((tmpPeak->x == 0) && (tmpPeak->y == 0)) || + ((tmpPeak->x == 0) && (tmpPeak->y == numRows-1)) || + ((tmpPeak->x == numCols-1) && (tmpPeak->y == 0)) || + ((tmpPeak->x == numCols-1) && (tmpPeak->y == numRows-1))) { + if (!((tmpPeak->class & PM_PEAK_LONE) || (tmpPeak->class & PM_PEAK_EDGE))) { + printf("TEST ERROR: (0) peak at (%d, %d) (%f) ->class set improperly (0x%x).", + tmpPeak->y, tmpPeak->x, tmpPeak->counts, tmpPeak->class); + printf(" should be (0x%x or 0x%x).\n", PM_PEAK_LONE, PM_PEAK_EDGE); + testStatus = false; + } + } else if ((tmpPeak->x == numCols/2) && (tmpPeak->y == numRows/2)) { + if (tmpPeak->class != PM_PEAK_LONE) { + printf("TEST ERROR: (1) peak at (%d, %d) (%f) ->class set improperly (0x%x).\n", + tmpPeak->y, tmpPeak->x, tmpPeak->counts, tmpPeak->class); + printf(" should be (0x%x).\n", PM_PEAK_LONE); + testStatus = false; + } + } else { + printf("TEST ERROR: Peak at (%d, %d) (%f)\n", tmpPeak->y, tmpPeak->x, tmpPeak->counts); + testStatus = false; + } + } + } + + psFree(inData); + psFree(outData); + return(testStatus); +} + +int test02( void ) +{ + bool testStatus = true; + psArray *tmpArray = NULL; + psImage *tmpImageF64 = psImageAlloc(TST02_NUM_ROWS, TST02_NUM_COLS, PS_TYPE_F64); + psImage *tmpImageEmpty = psImageAlloc(0, 0, PS_TYPE_F32); + + psTraceSetLevel(".", 0); + + printf("----------------------------------------------------------------------------------\n"); + printf("Calling pmFindImagePeaks with NULL psImage. Should generate error and return NULL.\n"); + tmpArray = pmFindImagePeaks(NULL, 0.0); + if (tmpArray != NULL) { + printf("TEST ERROR: pmFindImagePeaks() returned a non-NULL psImage.\n"); + testStatus = false; + psFree(tmpArray); + } + + printf("----------------------------------------------------------------------------------\n"); + printf("Calling pmFindImagePeaks with empty psImage. Should generate error and return NULL.\n"); + tmpArray = pmFindImagePeaks(tmpImageEmpty, 0.0); + if (tmpArray != NULL) { + printf("TEST ERROR: pmFindImagePeaks() returned a non-NULL psImage.\n"); + testStatus = false; + psFree(tmpArray); + } + + printf("----------------------------------------------------------------------------------\n"); + printf("Calling pmFindImagePeaks with PS_TYPE_F64 psImage. Should generate error and return NULL.\n"); + tmpArray = pmFindImagePeaks(tmpImageF64, 0.0); + if (tmpArray != NULL) { + printf("TEST ERROR: pmFindImagePeaks() returned a non-NULL psImage.\n"); + testStatus = false; + psFree(tmpArray); + } + printf("----------------------------------------------------------------------------------\n"); + // testStatus&= test_pmFindImagePeaks(1, 1); + // testStatus&= test_pmFindImagePeaks(2, 5); + // testStatus&= test_pmFindImagePeaks(5, 2); + // HEY: add code for small images + // testStatus&= test_pmFindImagePeaks(1, 1); + // testStatus&= test_pmFindImagePeaks(1, 8); + // testStatus&= test_pmFindImagePeaks(8, 1); + testStatus&= test_pmFindImagePeaks(TST02_NUM_ROWS, TST02_NUM_COLS); + testStatus&= test_pmFindImagePeaks(2*TST02_NUM_ROWS, TST02_NUM_COLS); + testStatus&= test_pmFindImagePeaks(TST02_NUM_ROWS, 2*TST02_NUM_COLS); + + + psFree(tmpImageF64); + psFree(tmpImageEmpty); + return(testStatus); +} + +/****************************************************************************** +test03(): We first test pmCullPeaks() with various NULL and unallowable input +parameters. Then we generate a list of peaks and test that pmCullPeaks() +removes them correctly. + *****************************************************************************/ +int test03( void ) +{ + bool testStatus = true; + psImage *imgData = psImageAlloc(NUM_COLS, NUM_ROWS, PS_TYPE_F32); + psArray *outData = NULL; + + /* XXX: Modify for new pmCullPeaks() + printf("----------------------------------------------------------------------------------\n"); + printf("Calling pmCullPeaks with NULL psList. Should generate error and return NULL.\n"); + outData = pmCullPeaks(NULL, 0.0, NULL); + if (outData != NULL) { + printf("TEST ERROR: pmCulPeaks() returned a non-NULL psList.\n"); + testStatus = false; + } + */ + + // + // Set peaks in input image. All even-column and even-row pixels are + // set non-zero, all other pixels are set to zero. + // + psS32 numPeaksOrig = 0; + for (psS32 i = 0 ; i < NUM_ROWS ; i++) { + for (psS32 j = 0 ; j < NUM_COLS ; j++) { + if ((0 == i%2) && (0 == j%2)) { + imgData->data.F32[i][j] = (float) (i + 10); + numPeaksOrig++; + } else { + imgData->data.F32[i][j] = 0.0; + } + } + } + for (psS32 i = 0 ; i < NUM_ROWS ; i++) { + for (psS32 j = 0 ; j < NUM_COLS ; j++) { + printf("(%.1f) ", imgData->data.F32[i][j]); + } + printf("\n"); + } + printf("Set %d peaks\n", numPeaksOrig); + + // + // Call pmCullPeaks() with HUGE maxValue and NULL psRegion. Should not + // remove any peaks. + // + printf("----------------------------------------------------------------------------------\n"); + printf("Calling pmCullPeaks with large maxValue and NULL psRegion.\n"); + outData = pmFindImagePeaks(imgData, 0.0); + /* XXX: Modify for new pmCullPeaks + outData = pmCullPeaks(outData, PS_MAX_F32, NULL); + + if (outData == NULL) { + printf("TEST ERROR: pmCullPeaks() returned a non-NULL psList.\n"); + testStatus = false; + return(testStatus); + } + if (outData->n != numPeaksOrig) { + printf("TEST ERROR (0): pmCullPeaks incorrectly removed peaks\n"); + printf("The pmCullPeaks() output had %d peaks, should have had %d peaks.\n", outData->n, numPeaksOrig); + testStatus = false; + } + */ + psFree(outData); + + // + // Call pmCullPeaks() with TINY maxValue and NULL psRegion. Should + // remove all peaks. + // + printf("----------------------------------------------------------------------------------\n"); + printf("Calling pmCullPeaks with tiny maxValue and NULL psRegion.\n"); + outData = pmFindImagePeaks(imgData, 0.0); + printf("pmFindImagePeaks found %ld peaks\n", outData->n); + /* XXX: Modify for new pmCullPeaks + outData = pmCullPeaks(outData, 0.0, NULL); + + if (outData == NULL) { + printf("TEST ERROR: pmCullPeaks() returned a non-NULL psList.\n"); + testStatus = false; + return(testStatus); + } + if (outData->n != 0) { + printf("TEST ERROR (1): pmCullPeaks incorrectly removed peaks\n"); + printf("The pmCullPeaks() output had %d peaks, should have had %d peaks.\n", outData->n, 0); + testStatus = false; + } + psFree(outData); + */ + + // + // Call pmCullPeaks() with HUGE maxValue and disjoint psRegion. Should + // not remove any peaks. + // + printf("----------------------------------------------------------------------------------\n"); + printf("Calling pmCullPeaks with large maxValue and disjoint psRegion.\n"); + outData = pmFindImagePeaks(imgData, 0.0); + printf("pmFindImagePeaks found %ld peaks\n", outData->n); + psRegion tmpRegion = psRegionSet(10000.0, 20000.0, 10000.0, 20000.0); + + /* XXX: Modify for new pmCullPeaks + outData = pmCullPeaks(outData, PS_MAX_F32, tmpRegion); + + if (outData == NULL) { + printf("TEST ERROR: pmCullPeaks() returned a non-NULL psList.\n"); + testStatus = false; + return(testStatus); + } + if (outData->n != numPeaksOrig) { + printf("TEST ERROR (2): pmCullPeaks incorrectly removed peaks\n"); + printf("The pmCullPeaks() output had %d peaks, should have had %d peaks.\n", outData->n, numPeaksOrig); + testStatus = false; + } + */ + psFree(outData); + + // + // Call pmCullPeaks() with HUGE maxValue and non-disjoint psRegion. Should + // remove all peaks. + // + printf("----------------------------------------------------------------------------------\n"); + printf("Calling pmCullPeaks with large maxValue and non-disjoint psRegion.\n"); + outData = pmFindImagePeaks(imgData, 0.0); + printf("pmFindImagePeaks found %ld peaks\n", outData->n); + tmpRegion = psRegionSet(-PS_MAX_F32, PS_MAX_F32, -PS_MAX_F32, PS_MAX_F32); + /* XXX: Modify for new pmCullPeaks + outData = pmCullPeaks(outData, PS_MAX_F32, tmpRegion); + + if (outData == NULL) { + printf("TEST ERROR: pmCullPeaks() returned a non-NULL psList.\n"); + testStatus = false; + return(testStatus); + } + if (outData->n != 0) { + printf("TEST ERROR (3): pmCullPeaks incorrectly removed peaks\n"); + printf("The pmCullPeaks() output had %d peaks, should have had %d peaks.\n", outData->n, 0); + testStatus = false; + } + */ + psFree(outData); + + printf("----------------------------------------------------------------------------------\n"); + psFree(imgData); + return(testStatus); +} + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +#define TST04_NUM_ROWS 100 +#define TST04_NUM_COLS 100 +#define TST04_SKY 20.0 +#define TST04_INNER_RADIUS 3 +#define TST04_OUTER_RADIUS 5 +/****************************************************************************** +test04(): We first test pmSourceLocalSky() with various NULL and unallowable +input parameters. + +XXX: Should we produce tests with boundary numbers for the inner/outer radius? + +XXX: Call this with varying sizes for the image. + *****************************************************************************/ +int test04( void ) +{ + bool testStatus = true; + psImage *imgData = psImageAlloc(TST04_NUM_COLS, TST04_NUM_ROWS, PS_TYPE_F32); + psImageInit(imgData, TST04_SKY); + psImage *imgMask = psImageAlloc(TST04_NUM_COLS, TST04_NUM_ROWS, PS_TYPE_U8); + psImageInit(imgMask, 0); + // psImage *imgMaskS8 = psImageAlloc(TST04_NUM_COLS, TST04_NUM_ROWS, PS_TYPE_S8); + // psImageInit(imgMaskS8, 0); + psImage *imgDataF64 = psImageAlloc(TST04_NUM_COLS, TST04_NUM_ROWS, PS_TYPE_F64); + psImageInit(imgDataF64, 0.0); + pmPeak *tmpPeak = pmPeakAlloc((psF32) (TST04_NUM_ROWS / 2), + (psF32) (TST04_NUM_COLS / 2), + 200.0, + PM_PEAK_LONE); + pmSource *tmpSource = pmSourceAlloc(); + tmpSource->pixels = imgData; + tmpSource->mask = imgMask; + tmpSource->peak = tmpPeak; + + printf("----------------------------------------------------------------------------------\n"); + printf("Calling pmSourceLocalSky with NULL tmpSource. Should generate error and return FALSE.\n"); + bool rc = pmSourceLocalSky(NULL, PS_STAT_SAMPLE_MEAN, 10.0); + if (rc != false) { + printf("TEST ERROR: pmSourceLocalSky() returned a non-FALSE pmSource.\n"); + testStatus = false; + } + + printf("----------------------------------------------------------------------------------\n"); + printf("Calling pmSourceLocalSky with Radius<0.0. Should generate error and return FALSE.\n"); + rc = pmSourceLocalSky(tmpSource, PS_STAT_SAMPLE_MEAN, -10.0); + if (rc != false) { + printf("TEST ERROR: pmSourceLocalSky() returned a non-FALSE pmSource.\n"); + testStatus = false; + } + + // + // XXX: The following code should be a separate function, and we should call it + // with a variety of image sizes, peaks. + // + printf("----------------------------------------------------------------------------------\n"); + printf("Calling pmSourceLocalSky with valid data.\n"); + tmpPeak->x = (psF32) (TST04_NUM_ROWS / 2); + tmpPeak->y = (psF32) (TST04_NUM_COLS / 2); + rc = pmSourceLocalSky(tmpSource, PS_STAT_SAMPLE_MEAN, 10.0); + + if (rc == false) { + printf("TEST ERROR: pmSourceLocalSky() returned a FALSE pmSource.\n"); + testStatus = false; + } else { + if (tmpSource->peak == NULL) { + printf("TEST ERROR: pmSourceLocalSky() returned a NULL pmSource->peak.\n"); + testStatus = false; + } else { + if (tmpSource->peak->x != tmpPeak->x) { + printf("TEST ERROR: pmSourceLocalSky() pmSource->peak->x was %d, should have been %d.\n", + tmpSource->peak->x, tmpPeak->x); + testStatus = false; + } + + if (tmpSource->peak->y != tmpPeak->y) { + printf("TEST ERROR: pmSourceLocalSky() pmSource->peak->y was %d, should have been %d.\n", + tmpSource->peak->y, tmpPeak->y); + testStatus = false; + } + + if (tmpSource->peak->counts != tmpPeak->counts) { + printf("TEST ERROR: pmSourceLocalSky() pmSource->peak->counts was %f, should have been %f.\n", + tmpSource->peak->counts, tmpPeak->counts); + testStatus = false; + } + + if (tmpSource->peak->class != tmpPeak->class) { + printf("TEST ERROR: pmSourceLocalSky() pmSource->peak->class was %d, should have been %d.\n", + tmpSource->peak->class, tmpPeak->class); + testStatus = false; + } + } + + if (tmpSource->moments == NULL) { + printf("TEST ERROR: pmSourceLocalSky() returned a NULL pmSource->moments.\n"); + testStatus = false; + } else { + if (tmpSource->moments->Sky != TST04_SKY) { + printf("TEST ERROR: pmSourceLocalSky() pmSource->moments->Sky was %f, should have been %f.\n", tmpSource->moments->Sky, TST04_SKY); + testStatus = false; + } + } + } + + printf("----------------------------------------------------------------------------------\n"); + psFree(tmpSource); + // psFree(imgData); + // psFree(imgDataF64); + // psFree(imgMask); + // psFree(imgMaskS8); + return(testStatus); +} + +#define TST05_NUM_ROWS 100 +#define TST05_NUM_COLS 100 +#define TST05_SKY 20.0 +#define TST05_INNER_RADIUS 3 +#define TST05_OUTER_RADIUS 5 +/****************************************************************************** +test05(): We first test pmSourceMoments() with various NULL and unallowable +input parameters. + +XXX: Should we produce tests with boundary numbers for the inner/outer radius? + +XXX: Call this with varying sizes for the image. + +XXX: The actual values of the moments are not tested. + *****************************************************************************/ +int test05( void ) +{ + bool testStatus = true; + psImage *imgData = psImageAlloc(TST04_NUM_COLS, TST04_NUM_ROWS, PS_TYPE_F32); + psImageInit(imgData, TST04_SKY); + psImage *imgMask = psImageAlloc(TST04_NUM_COLS, TST04_NUM_ROWS, PS_TYPE_U8); + psImageInit(imgMask, 0); + pmPeak *tmpPeak = pmPeakAlloc((psF32) (TST04_NUM_ROWS / 2), + (psF32) (TST04_NUM_COLS / 2), + 200.0, + PM_PEAK_LONE); + pmSource *tmpSource = pmSourceAlloc(); + tmpSource->pixels = imgData; + tmpSource->mask = imgMask; + tmpSource->peak = tmpPeak; + psBool rc = pmSourceLocalSky(tmpSource, PS_STAT_SAMPLE_MEAN, 10.0); + + if (rc == false) { + printf("TEST ERROR: pmSourceLocalSky() returned a FALSE pmSource.\n"); + testStatus = false; + } + + printf("----------------------------------------------------------------------------------\n"); + printf("Calling pmSourceMoments with NULL pmSource. Should generate error and return FALSE.\n"); + rc = pmSourceMoments(NULL, 10.0); + if (rc != false) { + printf("TEST ERROR: pmSourceMoments() returned TRUE.\n"); + testStatus = false; + } + // XXX: test with pmSource->peaks NULL + // XXX: test with pmSource->pixels NULL + // XXX: test with pmSource->mask NULL + + printf("----------------------------------------------------------------------------------\n"); + printf("Calling pmSourceMoments with radius < 0.0. Should generate error and return FALSE.\n"); + rc = pmSourceMoments(tmpSource, -10.0); + if (rc != false) { + printf("TEST ERROR: pmSourceMoments() returned TRUE.\n"); + testStatus = false; + } + + printf("----------------------------------------------------------------------------------\n"); + psFree(tmpSource); + return(testStatus); + +} + +#define TST09_NUM_ROWS 70 +#define TST09_NUM_COLS 70 +#define TST09_SKY 5.0 +#define TST09_INNER_RADIUS 3 +#define TST09_OUTER_RADIUS 10 +#define LEVEL (TST09_SKY + 10.0) +/****************************************************************************** +test09(): We first test pmSourceContour() with various NULL and unallowable +input parameters. + +XXX: We don't verify the numbers. + *****************************************************************************/ +int test09( void ) +{ + bool testStatus = true; + psImage *imgData = psImageAlloc(TST09_NUM_COLS, TST09_NUM_ROWS, PS_TYPE_F32); + psImageInit(imgData, TST09_SKY); + psImage *imgMask = psImageAlloc(TST09_NUM_COLS, TST09_NUM_ROWS, PS_TYPE_U8); + psImageInit(imgMask, 0); + pmPeak *tmpPeak = pmPeakAlloc((psF32) (TST09_NUM_ROWS / 2), + (psF32) (TST09_NUM_COLS / 2), + 200.0, + PM_PEAK_LONE); + pmSource *tmpSource = pmSourceAlloc(); + tmpSource->pixels = imgData; + tmpSource->mask = imgMask; + tmpSource->peak = tmpPeak; + psBool rc = pmSourceLocalSky(tmpSource, PS_STAT_SAMPLE_MEAN, 10.0); + if (rc == false) { + printf("TEST ERROR: pmSourceLocalSky() returned a FALSE pmSource.\n"); + testStatus = false; + } + + printf("----------------------------------------------------------------------------------\n"); + printf("Calling pmSourceContour with NULL pmSource . Should generate error, return FALSE.\n"); + rc = pmSourceContour(NULL, imgData, LEVEL, PS_CONTOUR_CRUDE); + if (rc != false) { + printf("TEST ERROR: pmSourceContour() returned TRUE.\n"); + testStatus = false; + psFree(rc); + } + + printf("----------------------------------------------------------------------------------\n"); + printf("Calling pmSourceContour with NULL psImage . Should generate error, return FALSE.\n"); + rc = pmSourceContour(tmpSource, NULL, LEVEL, PS_CONTOUR_CRUDE); + if (rc != FALSE) { + printf("TEST ERROR: pmSourceContour() returned TRUE.\n"); + testStatus = false; + psFree(rc); + } + + // + // XXX: pmSourceContour() has a problem with contour tops/bottoms. + // Must correct this. + // + if (1) { + printf("----------------------------------------------------------------------------------\n"); + printf("Calling pmSourceContour with acceptable data.\n"); + printf("NOTE: must figure out the parameters for this test to be meaningful.\n"); + tmpSource->modelPSF->params->data.F32[0] = TST09_SKY; + tmpSource->modelPSF->params->data.F32[1] = 15.0; + tmpSource->modelPSF->params->data.F32[2] = (psF32) (TST09_NUM_ROWS / 2); + tmpSource->modelPSF->params->data.F32[3] = (psF32) (TST09_NUM_COLS / 2); + tmpSource->modelPSF->params->data.F32[4] = 2.0; + tmpSource->modelPSF->params->data.F32[5] = 2.0; + tmpSource->modelPSF->params->data.F32[6] = 2.0; + rc = pmSourceContour(tmpSource, imgData, LEVEL, PS_CONTOUR_CRUDE); + if (rc == false) { + printf("TEST ERROR: pmSourceContour() returned FALSE.\n"); + testStatus = false; + } else { + psFree(rc); + } + } + + psFree(tmpSource); + return(testStatus); +} + +#define TST15_NUM_ROWS 100 +#define TST15_NUM_COLS 100 +#define TST15_SKY 10.0 +#define TST15_INNER_RADIUS 3 +#define TST15_OUTER_RADIUS 5 +/****************************************************************************** +test15(): We first test pmSourceAddModel() with various NULL and unallowable +input parameters. + +XXX: We don't verify the numbers. + *****************************************************************************/ +/* +int test15( void ) +{ + bool testStatus = true; + psImage *imgData = psImageAlloc(TST15_NUM_COLS, TST15_NUM_ROWS, PS_TYPE_F32); + psImageInit(imgData, TST15_SKY); + psImage *imgMask = psImageAlloc(TST15_NUM_COLS, TST15_NUM_ROWS, PS_TYPE_U8); + psImageInit(imgMask, 0); + pmPeak *tmpPeak = pmPeakAlloc((psF32) (TST15_NUM_ROWS / 2), + (psF32) (TST15_NUM_COLS / 2), + 200.0, + PM_PEAK_LONE); + pmSource *tmpSource = pmSourceAlloc(); + tmpSource->pixels = imgData; + tmpSource->mask = imgMask; + tmpSource->peak = tmpPeak; + psBool rc = pmSourceLocalSky(tmpSource, PS_STAT_SAMPLE_MEAN, 10.0); + if (rc == false) { + printf("TEST ERROR: pmSourceLocalSky() returned a FALSE pmSource.\n"); + testStatus = false; + } + + + tmpSource->modelPSF = pmModelAlloc(PS_MODEL_GAUSS); + tmpSource->modelPSF->params->data.F32[0] = 5.0; + tmpSource->modelPSF->params->data.F32[1] = 70.0; + tmpSource->modelPSF->params->data.F32[2] = (psF32) (TST15_NUM_ROWS / 2); + tmpSource->modelPSF->params->data.F32[3] = (psF32) (TST15_NUM_COLS / 2); + tmpSource->modelPSF->params->data.F32[4] = 1.0; + tmpSource->modelPSF->params->data.F32[5] = 1.0; + tmpSource->modelPSF->params->data.F32[6] = 2.0; + + printf("----------------------------------------------------------------------------------\n"); + printf("Calling pmSourceAddModel with NULL psImage. Should generate error, return FALSE.\n"); + rc = pmSourceAddModel(NULL, tmpSource, true); + if (rc == true) { + printf("TEST ERROR: pmSourceAddModel() returned TRUE.\n"); + testStatus = false; + } + + printf("----------------------------------------------------------------------------------\n"); + printf("Calling pmSourceAddModel with NULL psSrc. Should generate error, return FALSE.\n"); + rc = pmSourceAddModel(imgData, NULL, true); + if (rc == true) { + printf("TEST ERROR: pmSourceAddModel() returned TRUE.\n"); + testStatus = false; + } + + printf("----------------------------------------------------------------------------------\n"); + printf("Calling pmSourceAddModel with acceptable data.\n"); + rc = pmSourceAddModel(imgData, tmpSource, true); + if (rc != true) { + printf("TEST ERROR: pmSourceAddModel() returned FALSE.\n"); + testStatus = false; + } + + psFree(tmpSource); + psFree(imgData); + return(testStatus); +} +*/ + +#define TST16_NUM_ROWS 100 +#define TST16_NUM_COLS 100 +#define TST16_SKY 10.0 +#define TST16_INNER_RADIUS 3 +#define TST16_OUTER_RADIUS 5 +/****************************************************************************** +test16(): We first test pmSourceSubModel() with various NULL and unallowable +input parameters. + +XXX: We don't verify the numbers. + *****************************************************************************/ +/* +int test16( void ) +{ + bool testStatus = true; + psImage *imgData = psImageAlloc(TST16_NUM_COLS, TST16_NUM_ROWS, PS_TYPE_F32); + for (psS32 i = 0 ; i < imgData->numRows; i++) { + for (psS32 j = 0 ; j < imgData->numCols; j++) { + imgData->data.F32[i][j] = TST16_SKY; + } + } + pmSource *tmpSource = NULL; + psBool rc = false; + + pmPeak *tmpPeak = pmPeakAlloc((psF32) (TST16_NUM_ROWS / 2), + (psF32) (TST16_NUM_COLS / 2), + 200.0, + PM_PEAK_LONE); + + printf("Calling pmSourceLocalSky with valid data.\n"); + tmpPeak->x = (psF32) (TST16_NUM_ROWS / 2); + tmpPeak->y = (psF32) (TST16_NUM_COLS / 2); + tmpSource = pmSourceLocalSky(imgData, + tmpPeak, + PS_STAT_SAMPLE_MEAN, + (psF32) TST16_INNER_RADIUS, + (psF32) TST16_OUTER_RADIUS); + + if (tmpSource == NULL) { + printf("TEST ERROR: pmSourceLocalSky() returned a NULL pmSource.\n"); + testStatus = false; + } + + tmpSource->modelPSF = pmModelAlloc(PS_MODEL_GAUSS); + tmpSource->modelPSF->params->data.F32[0] = 5.0; + tmpSource->modelPSF->params->data.F32[1] = 70.0; + tmpSource->modelPSF->params->data.F32[2] = (psF32) (TST16_NUM_ROWS / 2); + tmpSource->modelPSF->params->data.F32[3] = (psF32) (TST16_NUM_COLS / 2); + tmpSource->modelPSF->params->data.F32[4] = 1.0; + tmpSource->modelPSF->params->data.F32[5] = 1.0; + tmpSource->modelPSF->params->data.F32[6] = 2.0; + + printf("----------------------------------------------------------------------------------\n"); + printf("Calling pmSourceSubModel with NULL psImage. Should generate error, return FALSE.\n"); + rc = pmSourceSubModel(NULL, tmpSource, true); + if (rc == true) { + printf("TEST ERROR: pmSourceSubModel() returned TRUE.\n"); + testStatus = false; + } + + printf("----------------------------------------------------------------------------------\n"); + printf("Calling pmSourceSubModel with NULL psSrc. Should generate error, return FALSE.\n"); + rc = pmSourceSubModel(imgData, NULL, true); + if (rc == true) { + printf("TEST ERROR: pmSourceSubModel() returned TRUE.\n"); + testStatus = false; + } + + printf("----------------------------------------------------------------------------------\n"); + printf("Calling pmSourceSubModel with acceptable data.\n"); + rc = pmSourceSubModel(imgData, tmpSource, true); + if (rc != true) { + printf("TEST ERROR: pmSourceSubModel() returned FALSE.\n"); + testStatus = false; + } + + psFree(tmpSource); + psFree(imgData); + return(testStatus); +} +*/ + +#define TST20_NUM_ROWS 100 +#define TST20_NUM_COLS 100 +#define TST20_SKY 10.0 +#define TST20_INNER_RADIUS 3 +#define TST20_OUTER_RADIUS 5 +/****************************************************************************** +test20(): We first test pmSourceSubModel() with various NULL and unallowable +input parameters. + +XXX: We don't verify the numbers. + *****************************************************************************/ +/* +int test20( void ) +{ + bool testStatus = true; + psImage *imgData = psImageAlloc(TST20_NUM_COLS, TST20_NUM_ROWS, PS_TYPE_F32); + for (psS32 i = 0 ; i < imgData->numRows; i++) { + for (psS32 j = 0 ; j < imgData->numCols; j++) { + imgData->data.F32[i][j] = TST20_SKY; + } + } + pmSource *tmpSource = NULL; + psBool rc = false; + + pmPeak *tmpPeak = pmPeakAlloc((psF32) (TST20_NUM_ROWS / 2), + (psF32) (TST20_NUM_COLS / 2), + 200.0, + PM_PEAK_LONE); + + printf("Calling pmSourceLocalSky with valid data.\n"); + tmpPeak->x = (psF32) (TST20_NUM_ROWS / 2); + tmpPeak->y = (psF32) (TST20_NUM_COLS / 2); + tmpSource = pmSourceLocalSky(imgData, + tmpPeak, + PS_STAT_SAMPLE_MEAN, + (psF32) TST20_INNER_RADIUS, + (psF32) TST20_OUTER_RADIUS); + + if (tmpSource == NULL) { + printf("TEST ERROR: pmSourceLocalSky() returned a NULL pmSource.\n"); + testStatus = false; + } + + tmpSource->modelPSF = pmModelAlloc(PS_MODEL_GAUSS); + + + tmpSource->modelPSF->params->data.F32[0] = 5.0; + tmpSource->modelPSF->params->data.F32[1] = 70.0; + tmpSource->modelPSF->params->data.F32[2] = (psF32) (TST20_NUM_ROWS / 2); + tmpSource->modelPSF->params->data.F32[3] = (psF32) (TST20_NUM_COLS / 2); + tmpSource->modelPSF->params->data.F32[4] = 1.0; + tmpSource->modelPSF->params->data.F32[5] = 1.0; + tmpSource->modelPSF->params->data.F32[6] = 2.0; + + printf("----------------------------------------------------------------------------------\n"); + printf("Calling pmSourceFitModel with NULL psImage. Should generate error, return FALSE.\n"); + rc = pmSourceFitModel(tmpSource, NULL); + if (rc == true) { + printf("TEST ERROR: pmSourceFitModel() returned TRUE.\n"); + testStatus = false; + } + + printf("----------------------------------------------------------------------------------\n"); + printf("Calling pmSourceFitModel with NULL pmSource. Should generate error, return FALSE.\n"); + rc = pmSourceFitModel(NULL, imgData); + if (rc == true) { + printf("TEST ERROR: pmSourceFitModel() returned TRUE.\n"); + testStatus = false; + } + + printf("----------------------------------------------------------------------------------\n"); + printf("Calling pmSourceFitModel with acceptable data.\n"); + rc = pmSourceFitModel(tmpSource, imgData); + printf("pmSourceFitModel returned %d\n", rc); + + // XXX: Memory leaks are not being tested + psVector *junk = psVectorAlloc(10, PS_TYPE_F32); + junk->data.F32[0] = 0.0; + + psFree(tmpSource); + psFree(imgData); + return(testStatus); +} +*/ + Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/objects/verified/tst_pmObjects01.stderr =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/objects/verified/tst_pmObjects01.stderr (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/objects/verified/tst_pmObjects01.stderr (revision 21664) @@ -0,0 +1,78 @@ +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmObjects01.c * +* TestPoint: Test Point Driver{pmObjects: structure allocators and deallocators} * +* TestType: Positive * +\**********************************************************************************/ + +|E|pmModelParameterCount (FILE:LINENO) + Undefined pmModelType + +---> TESTPOINT PASSED (Test Point Driver{pmObjects: structure allocators and deallocators} | tst_pmObjects01.c) + +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmObjects01.c * +* TestPoint: Test Point Driver{pmObjects: psFindVectorPeaks()} * +* TestType: Positive * +\**********************************************************************************/ + +|E|pmFindVectorPeaks (FILE:LINENO) + Unallowable operation: psVector vector or its data is NULL. +|E|pmFindVectorPeaks (FILE:LINENO) + Unallowable operation: psVector vector has no elements. +|E|pmFindVectorPeaks (FILE:LINENO) + Unallowable operation: psVector vector has incorrect type. + +---> TESTPOINT PASSED (Test Point Driver{pmObjects: psFindVectorPeaks()} | tst_pmObjects01.c) + +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmObjects01.c * +* TestPoint: Test Point Driver{pmObjects: psFindImagePeaks()} * +* TestType: Positive * +\**********************************************************************************/ + +|E|psImageAlloc (FILE:LINENO) + Specified number of rows (0) or columns (0) is invalid. +|E|pmFindImagePeaks (FILE:LINENO) + Unallowable operation: psImage image or its data is NULL. +|E|pmFindImagePeaks (FILE:LINENO) + Unallowable operation: psImage image or its data is NULL. +|E|pmFindImagePeaks (FILE:LINENO) + Unallowable operation: psImage image has incorrect type. + +---> TESTPOINT PASSED (Test Point Driver{pmObjects: psFindImagePeaks()} | tst_pmObjects01.c) + +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmObjects01.c * +* TestPoint: Test Point Driver{pmObjects: pmCullPeaks()} * +* TestType: Positive * +\**********************************************************************************/ + + +---> TESTPOINT PASSED (Test Point Driver{pmObjects: pmCullPeaks()} | tst_pmObjects01.c) + +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmObjects01.c * +* TestPoint: Test Point Driver{pmObjects: pmSourceLocalSky()} * +* TestType: Positive * +\**********************************************************************************/ + +|E|pmSourceLocalSky (FILE:LINENO) + Unallowable operation: source is NULL. +|E|pmSourceLocalSky (FILE:LINENO) + Error: Radius is 0 or less. + +---> TESTPOINT PASSED (Test Point Driver{pmObjects: pmSourceLocalSky()} | tst_pmObjects01.c) + +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_pmObjects01.c * +* TestPoint: Test Point Driver{pmObjects: pmSourceMoments()} * +* TestType: Positive * +\**********************************************************************************/ + +|E|pmSourceMoments (FILE:LINENO) + Unallowable operation: source is NULL. +|E|pmSourceMoments (FILE:LINENO) + Error: !(radius > 0.0) (-10.000000 0.000000). + +---> TESTPOINT PASSED (Test Point Driver{pmObjects: pmSourceMoments()} | tst_pmObjects01.c) + Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/objects/verified/tst_pmObjects01.stdout =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/objects/verified/tst_pmObjects01.stdout (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/objects/verified/tst_pmObjects01.stdout (revision 21664) @@ -0,0 +1,87 @@ +Testing pmPeakAlloc()... +Testing pmMomentsAlloc()... +Testing pmModelAlloc(PS_MODEL_GAUSS)... +Testing pmModelAlloc(PS_MODEL_GAUSS)... +Testing pmModelAlloc(PS_MODEL_GAUSS)... +Testing pmModelAlloc(PS_MODEL_GAUSS)... +---------------------------------------------------------------------------------- +Calling pmFindVectorPeaks with NULL psVector. Should generate error and return NULL. +---------------------------------------------------------------------------------- +Calling pmFindVectorPeaks with empty psVector. Should generate error and return NULL. +---------------------------------------------------------------------------------- +Calling pmFindVectorPeaks with PS_TYPE_F64 psVector. Should generate error and return NULL. +-------------- Calling test_pmFindVectorPeaks on an 1 size vector. -------------- +Test pmFindVectorPeaks() with a first-element peak. +Test pmFindVectorPeaks() with a first-element peak, large threshold. +-------------- Calling test_pmFindVectorPeaks on an 10 size vector. -------------- +Test pmFindVectorPeaks() with a first-element peak. +Test pmFindVectorPeaks() with a first-element peak, large threshold. +Test pmFindVectorPeaks() with a last-element peak. +Test pmFindVectorPeaks() with a last-element peak, large threshold. +Test pmFindVectorPeaks() with all even-numbered elements peak. +Test pmFindVectorPeaks() with all even-numbered elements peak, large threshold. +---------------------------------------------------------------------------------- +Calling pmFindImagePeaks with NULL psImage. Should generate error and return NULL. +---------------------------------------------------------------------------------- +Calling pmFindImagePeaks with empty psImage. Should generate error and return NULL. +---------------------------------------------------------------------------------- +Calling pmFindImagePeaks with PS_TYPE_F64 psImage. Should generate error and return NULL. +---------------------------------------------------------------------------------- +-------------- Calling test_pmFindImagePeaks on an 5-by-5 image. -------------- +(50.0) (5.0) (4.0) (5.0) (50.0) +(5.0) (2.0) (1.0) (2.0) (5.0) +(4.0) (1.0) (50.0) (1.0) (4.0) +(5.0) (2.0) (1.0) (2.0) (5.0) +(50.0) (5.0) (4.0) (5.0) (50.0) +-------------- Calling test_pmFindImagePeaks on an 10-by-5 image. -------------- +(125.0) (26.0) (25.0) (26.0) (125.0) +(20.0) (17.0) (16.0) (17.0) (20.0) +(13.0) (10.0) (9.0) (10.0) (13.0) +(8.0) (5.0) (4.0) (5.0) (8.0) +(5.0) (2.0) (1.0) (2.0) (5.0) +(4.0) (1.0) (125.0) (1.0) (4.0) +(5.0) (2.0) (1.0) (2.0) (5.0) +(8.0) (5.0) (4.0) (5.0) (8.0) +(13.0) (10.0) (9.0) (10.0) (13.0) +(125.0) (17.0) (16.0) (17.0) (125.0) +-------------- Calling test_pmFindImagePeaks on an 5-by-10 image. -------------- +(125.0) (20.0) (13.0) (8.0) (5.0) (4.0) (5.0) (8.0) (13.0) (125.0) +(26.0) (17.0) (10.0) (5.0) (2.0) (1.0) (2.0) (5.0) (10.0) (17.0) +(25.0) (16.0) (9.0) (4.0) (1.0) (125.0) (1.0) (4.0) (9.0) (16.0) +(26.0) (17.0) (10.0) (5.0) (2.0) (1.0) (2.0) (5.0) (10.0) (17.0) +(125.0) (20.0) (13.0) (8.0) (5.0) (4.0) (5.0) (8.0) (13.0) (125.0) +(10.0) (0.0) (10.0) (0.0) (10.0) (0.0) (10.0) (0.0) (10.0) (0.0) +(0.0) (0.0) (0.0) (0.0) (0.0) (0.0) (0.0) (0.0) (0.0) (0.0) +(12.0) (0.0) (12.0) (0.0) (12.0) (0.0) (12.0) (0.0) (12.0) (0.0) +(0.0) (0.0) (0.0) (0.0) (0.0) (0.0) (0.0) (0.0) (0.0) (0.0) +(14.0) (0.0) (14.0) (0.0) (14.0) (0.0) (14.0) (0.0) (14.0) (0.0) +(0.0) (0.0) (0.0) (0.0) (0.0) (0.0) (0.0) (0.0) (0.0) (0.0) +(16.0) (0.0) (16.0) (0.0) (16.0) (0.0) (16.0) (0.0) (16.0) (0.0) +(0.0) (0.0) (0.0) (0.0) (0.0) (0.0) (0.0) (0.0) (0.0) (0.0) +(18.0) (0.0) (18.0) (0.0) (18.0) (0.0) (18.0) (0.0) (18.0) (0.0) +(0.0) (0.0) (0.0) (0.0) (0.0) (0.0) (0.0) (0.0) (0.0) (0.0) +Set 25 peaks +---------------------------------------------------------------------------------- +Calling pmCullPeaks with large maxValue and NULL psRegion. +---------------------------------------------------------------------------------- +Calling pmCullPeaks with tiny maxValue and NULL psRegion. +pmFindImagePeaks found 25 peaks +---------------------------------------------------------------------------------- +Calling pmCullPeaks with large maxValue and disjoint psRegion. +pmFindImagePeaks found 25 peaks +---------------------------------------------------------------------------------- +Calling pmCullPeaks with large maxValue and non-disjoint psRegion. +pmFindImagePeaks found 25 peaks +---------------------------------------------------------------------------------- +---------------------------------------------------------------------------------- +Calling pmSourceLocalSky with NULL tmpSource. Should generate error and return FALSE. +---------------------------------------------------------------------------------- +Calling pmSourceLocalSky with Radius<0.0. Should generate error and return FALSE. +---------------------------------------------------------------------------------- +Calling pmSourceLocalSky with valid data. +---------------------------------------------------------------------------------- +---------------------------------------------------------------------------------- +Calling pmSourceMoments with NULL pmSource. Should generate error and return FALSE. +---------------------------------------------------------------------------------- +Calling pmSourceMoments with radius < 0.0. Should generate error and return FALSE. +---------------------------------------------------------------------------------- Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/photom/.cvsignore =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/photom/.cvsignore (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/photom/.cvsignore (revision 21664) @@ -0,0 +1,6 @@ +.deps +.libs +Makefile +Makefile.in +temp + Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/photom/Makefile.am =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/photom/Makefile.am (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/photom/Makefile.am (revision 21664) @@ -0,0 +1,16 @@ +# Makefile for psModule tests + +AM_LDFLAGS = -L$(top_builddir)/src -lpsmodule $(PSMODULE_LIBS) +AM_CFLAGS = @AM_CFLAGS@ $(PSMODULE_CFLAGS) $(SRCINC) + +TESTS = + +check_PROGRAMS = $(TESTS) + +TESTS_ENVIRONMENT = perl $(top_srcdir)/test/runTest --verified=$(srcdir)/verified + +tests: $(TESTS) + +CLEANFILES = $(TESTS) temp/* + +test: check Index: /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/runTest =================================================================== --- /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/runTest (revision 21664) +++ /branches/ipp-1-X-branches/eam_rel9_p0/psModules/test/runTest (revision 21664) @@ -0,0 +1,400 @@ +#!/usr/bin/perl +# +# This is a perl script to execute a single test driver program. The script +# will examine the return value of the test driver and capture STDOUT, STDERR +# to files. If the return value of the test driver is not zero, the test is +# deemed a failure. STDOUT and STDERR files will be place in a subdirectory +# named temp and the files will be compared with verified STDOUT, STDERR files +# in a subdirectory named verified. If there are no STDOUT, STDERR files in +# the verified directory, the captured STDOUT, STDERR files will be scanned +# for words which indicate a failure. +# +# Assumptions: A verified subdirectory with STDOUT, STDERR files exists for +# the test driver specified in the arguements if an exact +# match of the streams STDOUT, STDERR is necessary. +# +# Return values: +# Bit mapped values +# 0 Test run successfull and all tests passed +# 1 Verified directory did not exist +# 8 STDOUT files did not compare +# 16 STDERR files did not compare +# 32 Test driver doesn't exist or is not executable +# 64 Test driver did not return zero +# +# SYNOSIS: runTest testDriverName +# +# $Revison: $ $Name: not supported by cvs2svn $ +# $Date: 2005-09-13 20:26:33 $ +# +# Copyright 2004 Maui High Performance Computering Center, University of Hawaii +# +################################################################################ + +# Provides functions for handling psS64 command line options +use Getopt::Long; + +$verifiedDir = "verified"; + +# Assign variables based on the presence of command line options to the script +GetOptions( + "reset!" => \$reset, + "resetStderr!" => \$resetStderr, + "resetStdout!" => \$resetStdout, + "verified=s" => \$verifiedDir, + "help!" => \$help, + "quiet!" => \$quiet, + "printpassfail!" => \$verbose, + "printdiff!" => \$printdiff +); + +if ($help || $#ARGV < 0) { + print "\nUsage: runTest [--help] [--quiet] [--resetStderr] [--resetStdout] [--reset] \\\n", + " [--verified=DIR] [--printpassfail] [--printdiff] testfile(s)\n\n", + "Options include:\n", + " --help Prints this help message\n", + " --quiet Suppresses all messages\n", + " --resetStderr Resets the STDERR expected output file in the verified\n", + " directory\n", + " --resetStdout Resets the STDOUT expected output file in the verified\n", + " directory\n", + " --reset Equivalent to --resetStderr plus --resetStdout\n", + " --verified=DIR Specifies the location of the verified directory\n", + " --printpassfail Prints a PASS or FAIL message for each test in each file\n", + " --printdiff Prints any differences found in the test output and\n", + " verified expected output.\n\n"; + exit(0); +} + +if ($reset) { + $resetStderr = 1; + $resetStdout = 1; +} + +# Initialize exit value +$exitValue = 0; + +# Set up the PSLIB_ROOT environment variable if the user doesn't have it set +if ( $ENV{'PSLIB_ROOT'} ) { + + # Add PSLIB_ROOT/lib to LD_LIBRARY_PATH and DYLD_LIBRARY_PATH environment vars + $ENV{'LD_LIBRARY_PATH'} = "$ENV{'PSLIB_ROOT'}/src/.libs:$ENV{'LD_LIBRARY_PATH'}"; + $ENV{'DYLD_LIBRARY_PATH'} = "$ENV{'PSLIB_ROOT'}/src/.libs:$ENV{'DYLD_LIBRARY_PATH'}"; +} + +# Loop through the arguements passed to the script +foreach (@ARGV) { + chomp; + $testFile = $_; + + # 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 run + `mkdir temp`; + } + + # Check if a verified directory exists in the current work directory + if ( !( -e $verifiedDir ) ) { + + # Display message that verified subdirectory doesn't exist + print STDERR " Verified directory doesn't exist.\n"; + + # Exit script since the test cannot be run with verified files + $exitValue = 1; + } + + # Check if the test driver file exists and is executable + if ( ( -e $testFile ) && ( -x $testFile ) ) { + + # Invoke the test driver + system("./$testFile 1> temp/$testFile.stdout 2> temp/$testFile.stderr"); + + # Check the return value of the test driver. A value other than 0 + # indicates failure of the test driver unless the test driver is name + # with a leading 'a' which indicates the test driver is expecting an + # abort condition to terminate the driver. + if ( ( $? != 0 && ( $testFile !~ /^A/i ) ) + || ( $? == 0 && ( $testFile =~ /^A/i ) ) ) + { + + # Display failure message with return value to user + if ( $? != 0 && ( $testFile !~ /^A/i ) ) { + print STDERR "Failed - Test Driver returned $?, expected 0.\n"; + } + elsif ( $? == 0 && ( $testFile =~ /^A/i ) ) { + print STDERR "Failed - Test Driver returned $?, expected abort.\n"; + } + $exitValue |= 64; + } + + # Test driver succeeded. + + # Create filtered version of stdout and stderr + + # Open the STDOUT file for reading + open( OUTFILE, "< temp/$testFile.stdout" ); + + # Open mod file to place filtered STDOUT + open( MODFILE, "> temp/$testFile.stdout.mod" ); + open( MODFILE2, "> $verifiedDir/$testFile.stdout" ) if $resetStdout; + + # Replace the variable date, time and host information with constants + $hostname = `hostname`; + chop $hostname; + while () { + s/\s+\d+:\d+:\d+\w/