diff --git a/CMake/mitkSetupVariables.cmake b/CMake/mitkSetupVariables.cmake index d337fb6fec..bde4916fa4 100644 --- a/CMake/mitkSetupVariables.cmake +++ b/CMake/mitkSetupVariables.cmake @@ -1,166 +1,165 @@ if(MITK_BUILD_ALL_PLUGINS) set(MITK_BUILD_ALL_PLUGINS_OPTION "FORCE_BUILD_ALL") endif() set(LIBPOSTFIX "") # MITK_VERSION set(MITK_VERSION_MAJOR "2013") set(MITK_VERSION_MINOR "06") set(MITK_VERSION_PATCH "99") set(MITK_VERSION_STRING "${MITK_VERSION_MAJOR}.${MITK_VERSION_MINOR}.${MITK_VERSION_PATCH}") if(MITK_VERSION_PATCH STREQUAL "99") set(MITK_VERSION_STRING "${MITK_VERSION_STRING}-${MITK_REVISION_SHORTID}") endif() # Needed early on for redirecting the BlueBerry documentation output dir set(MITK_DOXYGEN_OUTPUT_DIR ${PROJECT_BINARY_DIR}/Documentation/Doxygen CACHE PATH "Output directory for doxygen generated documentation." ) #----------------------------------- # Configuration of module system #----------------------------------- set(MODULES_CONF_DIRNAME modulesConf) set(MODULES_CONF_DIRS ${MITK_BINARY_DIR}/${MODULES_CONF_DIRNAME}) if(NOT UNIX AND NOT MINGW) set(MITK_WIN32_FORCE_STATIC "STATIC" CACHE INTERNAL "Use this variable to always build static libraries on non-unix platforms") endif() # build the MITK_INCLUDE_DIRS variable set(MITK_INCLUDE_DIRS ${ITK_INCLUDE_DIRS} ${VTK_INCLUDE_DIRS} ${PROJECT_BINARY_DIR} # contains mitkConfig.h and similar files ${MODULES_CONF_DIRS} # contains module *Exports.h files ) set(CORE_DIRECTORIES Common DataManagement Algorithms IO Rendering Interactions Controllers Service) foreach(d ${CORE_DIRECTORIES}) list(APPEND MITK_INCLUDE_DIRS ${CMAKE_CURRENT_SOURCE_DIR}/Core/Code/${d}) endforeach() #list(APPEND MITK_INCLUDE_DIRS #${ITK_INCLUDE_DIRS} #${VTK_INCLUDE_DIRS} # ) -foreach(d Utilities Utilities/ipPic Utilities/pic2vtk Utilities/tinyxml Utilities/mbilog) +foreach(d Utilities Utilities/ipPic Utilities/tinyxml Utilities/mbilog) list(APPEND MITK_INCLUDE_DIRS ${CMAKE_CURRENT_SOURCE_DIR}/${d}) endforeach() list(APPEND MITK_INCLUDE_DIRS ${CMAKE_CURRENT_BINARY_DIR}/Utilities/mbilog) if(WIN32) list(APPEND MITK_INCLUDE_DIRS ${CMAKE_CURRENT_SOURCE_DIR}/Utilities/ipPic/win32) endif() # additional include dirs variables set(IPSEGMENTATION_INCLUDE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/Utilities/ipSegmentation) # variables containing librariy names set(MITK_CORE_LIBRARIES Mitk) set(VTK_FOR_MITK_LIBRARIES vtkGraphics vtkCommon vtkFiltering vtkGraphics vtkHybrid vtkImaging vtkIO vtkParallel vtkRendering vtkVolumeRendering vtkWidgets ${VTK_JPEG_LIBRARIES} ${VTK_PNG_LIBRARIES} ${VTK_ZLIB_LIBRARIES} ${VTK_EXPAT_LIBRARIES} ${VTK_FREETYPE_LIBRARIES} ) # TODO: maybe solve this with lib depends mechanism of CMake set(UTIL_FOR_MITK_LIBRARIES mbilog) set(LIBRARIES_FOR_MITK_CORE ${UTIL_FOR_MITK_LIBRARIES} ${VTK_FOR_MITK_LIBRARIES} ${ITK_LIBRARIES} ) set(MITK_LIBRARIES ${MITK_CORE_LIBRARIES} ${LIBRARIES_FOR_MITK_CORE} - pic2vtk ) # variables used in CMake macros which are called from external projects set(MITK_VTK_LIBRARY_DIRS ${VTK_LIBRARY_DIRS}) set(MITK_ITK_LIBRARY_DIRS ${ITK_LIBRARY_DIRS}) # variables containing link directories set(MITK_LIBRARY_DIRS ${CMAKE_LIBRARY_OUTPUT_DIRECTORY}) set(MITK_LINK_DIRECTORIES ${CMAKE_LIBRARY_OUTPUT_DIRECTORY} ${ITK_LIBRARY_DIRS} ${VTK_LIBRARY_DIRS} ${GDCM_LIBRARY_DIRS}) # Qt support if(MITK_USE_QT) find_package(Qt4 REQUIRED) set(QMITK_INCLUDE_DIRS ${MITK_INCLUDE_DIRS} ${CMAKE_CURRENT_SOURCE_DIR}/Modules/Qmitk ${PROJECT_BINARY_DIR}/Modules/Qmitk ) set(QMITK_LIBRARIES Qmitk ${MITK_LIBRARIES}) set(QMITK_LINK_DIRECTORIES ${MITK_LINK_DIRECTORIES}) endif() if(MITK_BUILD_ALL_PLUGINS) set(MITK_BUILD_ALL_PLUGINS_OPTION "FORCE_BUILD_ALL") endif() # create a list of types for template instantiations of itk image access functions function(_create_type_seq TYPES seq_var seqdim_var) set(_seq ) set(_seq_dim ) string(REPLACE "," ";" _pixeltypes "${TYPES}") foreach(_pixeltype ${_pixeltypes}) set(_seq "${_seq}(${_pixeltype})") set(_seq_dim "${_seq_dim}((${_pixeltype},dim))") endforeach() set(${seq_var} "${_seq}" PARENT_SCOPE) set(${seqdim_var} "${_seq_dim}" PARENT_SCOPE) endfunction() set(MITK_ACCESSBYITK_PIXEL_TYPES ) set(MITK_ACCESSBYITK_PIXEL_TYPES_SEQ ) set(MITK_ACCESSBYITK_TYPES_DIMN_SEQ ) # concatenate only the simple pixel types to the MITK_ACCESSBYITK_PIXEL_TYPE_SEQ list # see Bug 12682 for detailed information foreach(_type INTEGRAL FLOATING) set(_typelist "${MITK_ACCESSBYITK_${_type}_PIXEL_TYPES}") if(_typelist) if(MITK_ACCESSBYITK_PIXEL_TYPES) set(MITK_ACCESSBYITK_PIXEL_TYPES "${MITK_ACCESSBYITK_PIXEL_TYPES},${_typelist}") else() set(MITK_ACCESSBYITK_PIXEL_TYPES "${_typelist}") endif() endif() _create_type_seq("${_typelist}" MITK_ACCESSBYITK_${_type}_PIXEL_TYPES_SEQ MITK_ACCESSBYITK_${_type}_TYPES_DIMN_SEQ) set(MITK_ACCESSBYITK_PIXEL_TYPES_SEQ "${MITK_ACCESSBYITK_PIXEL_TYPES_SEQ}${MITK_ACCESSBYITK_${_type}_PIXEL_TYPES_SEQ}") set(MITK_ACCESSBYITK_TYPES_DIMN_SEQ "${MITK_ACCESSBYITK_TYPES_DIMN_SEQ}${MITK_ACCESSBYITK_${_type}_TYPES_DIMN_SEQ}") endforeach() # separate processing of the COMPOSITE list to avoid its concatenation to to global list _create_type_seq(${MITK_ACCESSBYITK_COMPOSITE_PIXEL_TYPES} MITK_ACCESSBYITK_COMPOSITE_PIXEL_TYPES_SEQ MITK_ACCESSBYITK_COMPOSITE_TYPES_DIMN_SEQ) set(MITK_ACCESSBYITK_DIMENSIONS_SEQ ) string(REPLACE "," ";" _dimensions "${MITK_ACCESSBYITK_DIMENSIONS}") foreach(_dimension ${_dimensions}) set(MITK_ACCESSBYITK_DIMENSIONS_SEQ "${MITK_ACCESSBYITK_DIMENSIONS_SEQ}(${_dimension})") endforeach() diff --git a/Core/Code/CMakeLists.txt b/Core/Code/CMakeLists.txt index 70aa911579..9291534934 100644 --- a/Core/Code/CMakeLists.txt +++ b/Core/Code/CMakeLists.txt @@ -1,52 +1,51 @@ #FIND_PACKAGE(OpenGL) #IF(NOT OPENGL_FOUND) # MESSAGE("GL is required for MITK rendering") #ENDIF(NOT OPENGL_FOUND ) set(TOOL_CPPS "") # temporary suppress warnings in the following files until image accessors are fully integrated. set_source_files_properties( DataManagement/mitkImage.cpp COMPILE_FLAGS -DMITK_NO_DEPRECATED_WARNINGS ) set_source_files_properties( Controllers/mitkSliceNavigationController.cpp COMPILE_FLAGS -DMITK_NO_DEPRECATED_WARNINGS ) # In MITK_ITK_Config.cmake, we set ITK_NO_IO_FACTORY_REGISTER_MANAGER to 1 unless # the variable is already defined. Setting it to 1 prevents multiple registrations/ # unregistrations of ITK IO factories during library loading/unloading (of MITK # libraries). However, we need "one" place where the IO factories are registered at # least once. This could be the application executable, but every executable would # need to take care of that itself. Instead, we allow the auto registration in the # Mitk Core library. set(ITK_NO_IO_FACTORY_REGISTER_MANAGER 0) MITK_CREATE_MODULE( Mitk INCLUDE_DIRS ${CppMicroServices_INCLUDE_DIRS} Algorithms Common DataManagement Controllers Interactions Interfaces IO Rendering ${MITK_BINARY_DIR} INTERNAL_INCLUDE_DIRS ${OPENGL_INCLUDE_DIR} ${CppMicroServices_INTERNAL_INCLUDE_DIRS} DEPENDS mbilog tinyxml CppMicroServices - DEPENDS_INTERNAL pic2vtk PACKAGE_DEPENDS ITK GDCM VTK OpenGL EXPORT_DEFINE MITK_CORE_EXPORT WARNINGS_AS_ERRORS ) # this is needed for libraries which link to Mitk and need # symbols from explicitly instantiated templates if(MINGW) get_target_property(_mitkCore_MINGW_linkflags Mitk LINK_FLAGS) if(NOT _mitkCore_MINGW_linkflags) set(_mitkCore_MINGW_linkflags "") endif(NOT _mitkCore_MINGW_linkflags) set_target_properties(Mitk PROPERTIES LINK_FLAGS "${_mitkCore_MINGW_linkflags} -Wl,--export-all-symbols") endif(MINGW) if(MSVC_IDE OR MSVC_VERSION OR MINGW) target_link_libraries(Mitk psapi.lib) endif(MSVC_IDE OR MSVC_VERSION OR MINGW) # build tests? if(BUILD_TESTING) add_subdirectory(Testing) ENDIF() diff --git a/Documentation/doxygen.conf.in b/Documentation/doxygen.conf.in index 682a77f6d0..aafe0c22d4 100644 --- a/Documentation/doxygen.conf.in +++ b/Documentation/doxygen.conf.in @@ -1,1928 +1,1920 @@ # Doxyfile 1.8.0 # 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 #--------------------------------------------------------------------------- # This tag specifies the encoding used for all characters in the config file # that follow. The default is UTF-8 which is also the encoding used for all # text before the first occurrence of this tag. Doxygen uses libiconv (or the # iconv built into libc) for the transcoding. See # http://www.gnu.org/software/libiconv for the list of possible encodings. DOXYFILE_ENCODING = UTF-8 # The PROJECT_NAME tag is a single word (or sequence of words) that should # identify the project. Note that if you do not use Doxywizard you need # to put quotes around the project name if it contains spaces. PROJECT_NAME = MITK # 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 = @MITK_VERSION_STRING@ # Using the PROJECT_BRIEF tag one can provide an optional one line description # for a project that appears at the top of each page and should give viewer # a quick idea about the purpose of the project. Keep the description short. PROJECT_BRIEF = "Medical Imaging Interaction Toolkit" # With the PROJECT_LOGO tag one can specify an logo or icon that is # included in the documentation. The maximum height of the logo should not # exceed 55 pixels and the maximum width should not exceed 200 pixels. # Doxygen will copy the logo to the output directory. PROJECT_LOGO = # 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 = @MITK_DOXYGEN_OUTPUT_DIR@ # If the CREATE_SUBDIRS tag is set to YES, then doxygen will create # 4096 sub-directories (in 2 levels) under the output directory of each output # format and will distribute the generated files over these directories. # Enabling this option can be useful when feeding doxygen a huge amount of # source files, where putting all generated files in the same directory would # otherwise cause performance problems for the file system. CREATE_SUBDIRS = NO # The OUTPUT_LANGUAGE tag is used to specify the language in which all # documentation generated by doxygen is written. Doxygen will use this # information to generate all constant output in the proper language. # The default language is English, other supported languages are: # Afrikaans, Arabic, Brazilian, Catalan, Chinese, Chinese-Traditional, # Croatian, Czech, Danish, Dutch, Esperanto, Farsi, Finnish, French, German, # Greek, Hungarian, Italian, Japanese, Japanese-en (Japanese with English # messages), Korean, Korean-en, Lithuanian, Norwegian, Macedonian, Persian, # Polish, Portuguese, Romanian, Russian, Serbian, Serbian-Cyrillic, Slovak, # Slovene, Spanish, Swedish, Ukrainian, and Vietnamese. OUTPUT_LANGUAGE = English # If the BRIEF_MEMBER_DESC tag is set to YES (the default) Doxygen will # include brief member descriptions after the members that are listed in # the file and class documentation (similar to JavaDoc). # Set to NO to disable this. BRIEF_MEMBER_DESC = YES # If the REPEAT_BRIEF tag is set to YES (the default) Doxygen will prepend # the brief description of a member or function before the detailed description. # Note: if both HIDE_UNDOC_MEMBERS and BRIEF_MEMBER_DESC are set to NO, the # brief descriptions will be completely suppressed. REPEAT_BRIEF = YES # This tag implements a quasi-intelligent brief description abbreviator # that is used to form the text in various listings. Each string # in this list, if found as the leading text of the brief description, will be # stripped from the text and the result after processing the whole list, is # used as the annotated text. Otherwise, the brief description is used as-is. # If left blank, the following values are used ("$name" is automatically # replaced with the name of the entity): "The $name class" "The $name widget" # "The $name file" "is" "provides" "specifies" "contains" # "represents" "a" "an" "the" ABBREVIATE_BRIEF = # If the ALWAYS_DETAILED_SEC and REPEAT_BRIEF tags are both set to YES then # Doxygen will generate a detailed section even if there is only a brief # description. ALWAYS_DETAILED_SEC = NO # If the INLINE_INHERITED_MEMB tag is set to YES, doxygen will show all # inherited members of a class in the documentation of that class as if those # members were ordinary class members. Constructors, destructors and assignment # operators of the base classes will not be shown. INLINE_INHERITED_MEMB = NO # If the FULL_PATH_NAMES tag is set to YES then Doxygen will prepend the full # path before files name in the file list and in the header files. If set # to NO the shortest path that makes the file name unique will be used. FULL_PATH_NAMES = 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. The tag can be used to show relative paths in the file list. # If left blank the directory from which doxygen is run is used as the # path to strip. STRIP_FROM_PATH = # The STRIP_FROM_INC_PATH tag can be used to strip a user-defined part of # the path mentioned in the documentation of a class, which tells # the reader which header file to include in order to use a class. # If left blank only the name of the header file containing the class # definition is used. Otherwise one should specify the include paths that # are normally passed to the compiler using the -I flag. STRIP_FROM_INC_PATH = # If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter # (but less readable) file names. This can be useful if your file system # 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 regular Qt-style comments # (thus requiring an explicit @brief command for a brief description.) JAVADOC_AUTOBRIEF = NO # If the QT_AUTOBRIEF tag is set to YES then Doxygen will # interpret the first line (until the first dot) of a Qt-style # comment as the brief description. If set to NO, the comments # will behave just like regular Qt-style comments (thus requiring # an explicit \brief command for a brief description.) QT_AUTOBRIEF = NO # The MULTILINE_CPP_IS_BRIEF tag can be set to YES to make Doxygen # treat a multi-line C++ special comment block (i.e. a block of //! or /// # comments) as a brief description. This used to be the default behaviour. # The new default is to treat a multi-line C++ comment block as a detailed # description. Set this tag to YES if you prefer the old behaviour instead. MULTILINE_CPP_IS_BRIEF = NO # If the INHERIT_DOCS tag is set to YES (the default) then an undocumented # member inherits the documentation from any documented member that it # re-implements. INHERIT_DOCS = YES # If the SEPARATE_MEMBER_PAGES tag is set to YES, then doxygen will produce # a new page for each member. If set to NO, the documentation of a member will # be part of the file/class/namespace that contains it. SEPARATE_MEMBER_PAGES = NO # The TAB_SIZE tag can be used to set the number of spaces in a tab. # Doxygen uses this value to replace tabs by spaces in code fragments. TAB_SIZE = 8 # This tag can be used to specify a number of aliases that acts # as commands in the documentation. An alias has the form "name=value". # For example adding "sideeffect=\par Side Effects:\n" will allow you to # put the command \sideeffect (or @sideeffect) in the documentation, which # will result in a user-defined paragraph with heading "Side Effects:". # You can put \n's in the value part of an alias to insert newlines. ALIASES = "FIXME=\par Fix Me's:\n" \ "BlueBerry=\if BLUEBERRY" \ "endBlueBerry=\endif" \ "bundlemainpage{1}=\page \1" \ "embmainpage{1}=\page \1" \ "github{2}=\2" \ "deprecatedSince{1}=\xrefitem deprecatedSince\1 \" Deprecated as of \1\" \"Functions deprecated as of \1\" " # This tag can be used to specify a number of word-keyword mappings (TCL only). # A mapping has the form "name=value". For example adding # "class=itcl::class" will allow you to use the command class in the # itcl::class meaning. TCL_SUBST = # Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C # sources only. Doxygen will then generate output that is more tailored for C. # For instance, some of the names that are used will be different. The list # of all members will be omitted, etc. OPTIMIZE_OUTPUT_FOR_C = NO # Set the OPTIMIZE_OUTPUT_JAVA tag to YES if your project consists of Java # sources only. Doxygen will then generate output that is more tailored for # Java. For instance, namespaces will be presented as packages, qualified # scopes will look different, etc. OPTIMIZE_OUTPUT_JAVA = NO # Set the OPTIMIZE_FOR_FORTRAN tag to YES if your project consists of Fortran # sources only. Doxygen will then generate output that is more tailored for # Fortran. OPTIMIZE_FOR_FORTRAN = NO # Set the OPTIMIZE_OUTPUT_VHDL tag to YES if your project consists of VHDL # sources. Doxygen will then generate output that is tailored for # VHDL. OPTIMIZE_OUTPUT_VHDL = NO # Doxygen selects the parser to use depending on the extension of the files it # parses. With this tag you can assign which parser to use for a given extension. # Doxygen has a built-in mapping, but you can override or extend it using this # tag. The format is ext=language, where ext is a file extension, and language # is one of the parsers supported by doxygen: IDL, Java, Javascript, CSharp, C, # C++, D, PHP, Objective-C, Python, Fortran, VHDL, C, C++. For instance to make # doxygen treat .inc files as Fortran files (default is PHP), and .f files as C # (default is Fortran), use: inc=Fortran f=C. Note that for custom extensions # you also need to set FILE_PATTERNS otherwise the files are not read by doxygen. EXTENSION_MAPPING = # If MARKDOWN_SUPPORT is enabled (the default) then doxygen pre-processes all # comments according to the Markdown format, which allows for more readable # documentation. See http://daringfireball.net/projects/markdown/ for details. # The output of markdown processing is further processed by doxygen, so you # can mix doxygen, HTML, and XML commands with Markdown formatting. # Disable only in case of backward compatibilities issues. MARKDOWN_SUPPORT = YES # If you use STL classes (i.e. std::string, std::vector, etc.) but do not want # to include (a tag file for) the STL sources as input, then you should # set this tag to YES in order to let doxygen match functions declarations and # definitions whose arguments contain STL classes (e.g. func(std::string); v.s. # func(std::string) {}). This also makes the inheritance and collaboration # diagrams that involve STL classes more complete and accurate. BUILTIN_STL_SUPPORT = YES # If you use Microsoft's C++/CLI language, you should set this option to YES to # enable parsing support. CPP_CLI_SUPPORT = NO # Set the SIP_SUPPORT tag to YES if your project consists of sip sources only. # Doxygen will parse them like normal C++ but will assume all classes use public # instead of private inheritance when no explicit protection keyword is present. SIP_SUPPORT = NO # For Microsoft's IDL there are propget and propput attributes to indicate getter # and setter methods for a property. Setting this option to YES (the default) # will make doxygen replace the get and set methods by a property in the # documentation. This will only work if the methods are indeed getting or # setting a simple type. If this is not the case, or you want to show the # methods anyway, you should set this option to NO. IDL_PROPERTY_SUPPORT = 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 = YES # Set the SUBGROUPING tag to YES (the default) to allow class member groups of # the same type (for instance a group of public functions) to be put as a # subgroup of that type (e.g. under the Public Functions section). Set it to # NO to prevent subgrouping. Alternatively, this can be done per class using # the \nosubgrouping command. SUBGROUPING = YES # When the INLINE_GROUPED_CLASSES tag is set to YES, classes, structs and # unions are shown inside the group in which they are included (e.g. using # @ingroup) instead of on a separate page (for HTML and Man pages) or # section (for LaTeX and RTF). INLINE_GROUPED_CLASSES = NO # When the INLINE_SIMPLE_STRUCTS tag is set to YES, structs, classes, and # unions with only public data fields will be shown inline in the documentation # of the scope in which they are defined (i.e. file, namespace, or group # documentation), provided this scope is documented. If set to NO (the default), # structs, classes, and unions are shown on a separate page (for HTML and Man # pages) or section (for LaTeX and RTF). INLINE_SIMPLE_STRUCTS = NO # When TYPEDEF_HIDES_STRUCT is enabled, a typedef of a struct, union, or enum # is documented as struct, union, or enum with the name of the typedef. So # typedef struct TypeS {} TypeT, will appear in the documentation as a struct # with name TypeT. When disabled the typedef will appear as a member of a file, # namespace, or class. And the struct will be named TypeS. This can typically # be useful for C code in case the coding convention dictates that all compound # types are typedef'ed and only the typedef is referenced, never the tag name. TYPEDEF_HIDES_STRUCT = NO # The SYMBOL_CACHE_SIZE determines the size of the internal cache use to # determine which symbols to keep in memory and which to flush to disk. # When the cache is full, less often used symbols will be written to disk. # For small to medium size projects (<1000 input files) the default value is # probably good enough. For larger projects a too small cache size can cause # doxygen to be busy swapping symbols to and from disk most of the time # causing a significant performance penalty. # If the system has enough physical memory increasing the cache will improve the # performance by keeping more symbols in memory. Note that the value works on # a logarithmic scale so increasing the size by one will roughly double the # memory usage. The cache size is given by this formula: # 2^(16+SYMBOL_CACHE_SIZE). The valid range is 0..9, the default is 0, # corresponding to a cache size of 2^16 = 65536 symbols. SYMBOL_CACHE_SIZE = 0 # Similar to the SYMBOL_CACHE_SIZE the size of the symbol lookup cache can be # set using LOOKUP_CACHE_SIZE. This cache is used to resolve symbols given # their name and scope. Since this can be an expensive process and often the # same symbol appear multiple times in the code, doxygen keeps a cache of # pre-resolved symbols. If the cache is too small doxygen will become slower. # If the cache is too large, memory is wasted. The cache size is given by this # formula: 2^(16+LOOKUP_CACHE_SIZE). The valid range is 0..9, the default is 0, # corresponding to a cache size of 2^16 = 65536 symbols. LOOKUP_CACHE_SIZE = 0 #--------------------------------------------------------------------------- # 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_PACKAGE tag is set to YES all members with package or internal scope will be included in the documentation. EXTRACT_PACKAGE = NO # If the EXTRACT_STATIC tag is set to YES all static members of a file # will be included in the documentation. EXTRACT_STATIC = YES # If the EXTRACT_LOCAL_CLASSES tag is set to YES classes (and structs) # defined locally in source files will be included in the documentation. # If set to NO only classes defined in header files are included. EXTRACT_LOCAL_CLASSES = @MITK_DOXYGEN_INTERNAL_DOCS@ # This flag is only useful for Objective-C code. When set to YES local # methods, which are defined in the implementation section but not in # the interface are included in the documentation. # If set to NO (the default) only methods in the interface are included. EXTRACT_LOCAL_METHODS = NO # If this flag is set to YES, the members of anonymous namespaces will be # extracted and appear in the documentation as a namespace called # 'anonymous_namespace{file}', where file will be replaced with the base # name of the file that contains the anonymous namespace. By default # anonymous namespaces are hidden. EXTRACT_ANON_NSPACES = 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 = @MITK_DOXYGEN_HIDE_FRIEND_COMPOUNDS@ # 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 = @MITK_DOXYGEN_INTERNAL_DOCS@ # If the CASE_SENSE_NAMES tag is set to NO then Doxygen will only generate # file names in lower-case letters. If set to YES upper-case letters are also # allowed. This is useful if you have classes or files whose names only differ # in case and if your file system supports case sensitive file names. Windows # and Mac users are advised to set this option to NO. CASE_SENSE_NAMES = YES # If the HIDE_SCOPE_NAMES tag is set to NO (the default) then Doxygen # will show members with their full class and namespace scopes in the # documentation. If set to YES the scope will be hidden. HIDE_SCOPE_NAMES = NO # If the SHOW_INCLUDE_FILES tag is set to YES (the default) then Doxygen # will put a list of the files that are included by a file in the documentation # of that file. SHOW_INCLUDE_FILES = YES # If the FORCE_LOCAL_INCLUDES tag is set to YES then Doxygen # will list include files with double quotes in the documentation # rather than with sharp brackets. FORCE_LOCAL_INCLUDES = NO # If the INLINE_INFO tag is set to YES (the default) then a tag [inline] # is inserted in the documentation for inline members. INLINE_INFO = YES # If the SORT_MEMBER_DOCS tag is set to YES (the default) then doxygen # will sort the (detailed) documentation of file and class members # alphabetically by member name. If set to NO the members will appear in # declaration order. SORT_MEMBER_DOCS = YES # If the SORT_BRIEF_DOCS tag is set to YES then doxygen will sort the # brief documentation of file, namespace and class members alphabetically # by member name. If set to NO (the default) the members will appear in # declaration order. SORT_BRIEF_DOCS = NO # If the SORT_MEMBERS_CTORS_1ST tag is set to YES then doxygen # will sort the (brief and detailed) documentation of class members so that # constructors and destructors are listed first. If set to NO (the default) # the constructors will appear in the respective orders defined by # SORT_MEMBER_DOCS and SORT_BRIEF_DOCS. # This tag will be ignored for brief docs if SORT_BRIEF_DOCS is set to NO # and ignored for detailed docs if SORT_MEMBER_DOCS is set to NO. SORT_MEMBERS_CTORS_1ST = NO # If the SORT_GROUP_NAMES tag is set to YES then doxygen will sort the # hierarchy of group names into alphabetical order. If set to NO (the default) # the group names will appear in their defined order. SORT_GROUP_NAMES = NO # If the SORT_BY_SCOPE_NAME tag is set to YES, the class list will be # sorted by fully-qualified names, including namespaces. If set to # NO (the default), the class list will be sorted only by class name, # not including the namespace part. # Note: This option is not very useful if HIDE_SCOPE_NAMES is set to YES. # Note: This option applies only to the class list, not to the # alphabetical list. SORT_BY_SCOPE_NAME = YES # If the STRICT_PROTO_MATCHING option is enabled and doxygen fails to # do proper type resolution of all parameters of a function it will reject a # match between the prototype and the implementation of a member function even # if there is only one candidate or it is obvious which candidate to choose # by doing a simple string match. By disabling STRICT_PROTO_MATCHING doxygen # will still accept a match between prototype and implementation in such cases. STRICT_PROTO_MATCHING = NO # The GENERATE_TODOLIST tag can be used to enable (YES) or # disable (NO) the todo list. This list is created by putting \todo # commands in the documentation. GENERATE_TODOLIST = @MITK_DOXYGEN_GENERATE_TODOLIST@ # 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 = @MITK_DOXYGEN_GENERATE_BUGLIST@ # 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= @MITK_DOXYGEN_GENERATE_DEPRECATEDLIST@ # The ENABLED_SECTIONS tag can be used to enable conditional # documentation sections, marked by \if sectionname ... \endif. ENABLED_SECTIONS = @MITK_DOXYGEN_ENABLED_SECTIONS@ # The MAX_INITIALIZER_LINES tag determines the maximum number of lines # the initial value of a variable or macro 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 macros in the # documentation can be controlled using \showinitializer or \hideinitializer # command in the documentation regardless of this setting. MAX_INITIALIZER_LINES = 0 # Set the SHOW_USED_FILES tag to NO to disable the list of files generated # at the bottom of the documentation of classes and structs. If set to YES the # list will mention the files that were used to generate the documentation. SHOW_USED_FILES = YES # If the sources in your project are distributed over multiple directories # then setting the SHOW_DIRECTORIES tag to YES will show the directory hierarchy # in the documentation. The default is NO. SHOW_DIRECTORIES = NO # Set the SHOW_FILES tag to NO to disable the generation of the Files page. # This will remove the Files entry from the Quick Index and from the # Folder Tree View (if specified). The default is YES. SHOW_FILES = YES # Set the SHOW_NAMESPACES tag to NO to disable the generation of the # Namespaces page. # This will remove the Namespaces entry from the Quick Index # and from the Folder Tree View (if specified). The default is YES. SHOW_NAMESPACES = YES # The FILE_VERSION_FILTER tag can be used to specify a program or script that # doxygen should invoke to get the current version for each file (typically from # the version control system). Doxygen will invoke the program by executing (via # popen()) the command , where is the value of # the FILE_VERSION_FILTER tag, and is the name of an input file # provided by doxygen. Whatever the program writes to standard output # is used as the file version. See the manual for examples. FILE_VERSION_FILTER = # The LAYOUT_FILE tag can be used to specify a layout file which will be parsed # by doxygen. The layout file controls the global structure of the generated # output files in an output format independent way. The create the layout file # that represents doxygen's defaults, run doxygen with the -l option. # You can optionally specify a file name after the option, if omitted # DoxygenLayout.xml will be used as the name of the layout file. LAYOUT_FILE = @MITK_SOURCE_DIR@/Documentation/MITKDoxygenLayout.xml # The CITE_BIB_FILES tag can be used to specify one or more bib files # containing the references data. This must be a list of .bib files. The # .bib extension is automatically appended if omitted. Using this command # requires the bibtex tool to be installed. See also # http://en.wikipedia.org/wiki/BibTeX for more info. For LaTeX the style # of the bibliography can be controlled using LATEX_BIB_STYLE. To use this # feature you need bibtex and perl available in the search path. CITE_BIB_FILES = #--------------------------------------------------------------------------- # 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_NO_PARAMDOC option can be enabled to get warnings for # functions that are documented, but have no documentation for their parameters # or return value. If set to NO (the default) doxygen will only warn about # wrong or incomplete parameter documentation, but not about the absence of # documentation. WARN_NO_PARAMDOC = NO # The WARN_FORMAT tag determines the format of the warning messages that # doxygen can produce. The string should contain the $file, $line, and $text # tags, which will be replaced by the file and line number from which the # warning originated and the warning text. Optionally the format may contain # $version, which will be replaced by the version of the file (if it could # be obtained via FILE_VERSION_FILTER) WARN_FORMAT = "$file:$line: $text" # The WARN_LOGFILE tag can be used to specify a file to which warning # and error messages should be written. If left blank the output is written # to stderr. WARN_LOGFILE = #--------------------------------------------------------------------------- # configuration options related to the input files #--------------------------------------------------------------------------- # The INPUT tag can be used to specify the files and/or directories that contain # documented source files. You may enter file names like "myfile.cpp" or # directories like "/usr/src/myproject". Separate the files or directories # with spaces. INPUT = @MITK_SOURCE_DIR@ \ @MITK_BINARY_DIR@ \ @MITK_DOXYGEN_ADDITIONAL_INPUT_DIRS@ # This tag can be used to specify the character encoding of the source files # that doxygen parses. Internally doxygen uses the UTF-8 encoding, which is # also the default input encoding. Doxygen uses libiconv (or the iconv built # into libc) for the transcoding. See http://www.gnu.org/software/libiconv for # the list of possible encodings. INPUT_ENCODING = UTF-8 # 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++ *.d *.java *.ii *.ixx *.ipp *.i++ *.inl *.h *.hh # *.hxx *.hpp *.h++ *.idl *.odl *.cs *.php *.php3 *.inc *.m *.mm *.dox *.py # *.f90 *.f *.for *.vhd *.vhdl FILE_PATTERNS = *.h \ *.cpp \ *.dox \ *.md \ *.txx \ *.tpp \ *.cxx \ *.cmake # 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 be # 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. # Note that relative paths are relative to the directory from which doxygen is # run. EXCLUDE = @MITK_SOURCE_DIR@/BlueBerry/Documentation/reference/api/MainPage.dox \ - @MITK_SOURCE_DIR@/Utilities/ann/ \ - @MITK_SOURCE_DIR@/Utilities/glew/ \ @MITK_SOURCE_DIR@/Utilities/ipFunc/ \ @MITK_SOURCE_DIR@/Utilities/ipSegmentation/ \ @MITK_SOURCE_DIR@/Utilities/KWStyle/ \ - @MITK_SOURCE_DIR@/Utilities/pic2vtk/ \ @MITK_SOURCE_DIR@/Utilities/Poco/ \ @MITK_SOURCE_DIR@/Utilities/qtsingleapplication/ \ @MITK_SOURCE_DIR@/Utilities/qwt/ \ @MITK_SOURCE_DIR@/Utilities/qxt/ \ @MITK_SOURCE_DIR@/Utilities/tinyxml/ \ - @MITK_SOURCE_DIR@/Utilities/vecmath/ \ @MITK_SOURCE_DIR@/Applications/PluginGenerator/ \ @MITK_SOURCE_DIR@/Core/CppMicroServices/README.md \ @MITK_SOURCE_DIR@/Core/CppMicroServices/documentation/snippets/ \ @MITK_SOURCE_DIR@/Core/CppMicroServices/documentation/doxygen/standalone/ \ @MITK_SOURCE_DIR@/Core/CppMicroServices/examples/ \ @MITK_SOURCE_DIR@/Core/CppMicroServices/test/ \ @MITK_SOURCE_DIR@/Core/CppMicroServices/src/util/jsoncpp.cpp \ @MITK_SOURCE_DIR@/Deprecated/ \ @MITK_SOURCE_DIR@/Build/ \ @MITK_SOURCE_DIR@/CMake/PackageDepends \ @MITK_SOURCE_DIR@/CMake/QBundleTemplate \ @MITK_SOURCE_DIR@/CMakeExternals \ @MITK_SOURCE_DIR@/Modules/QmitkExt/vtkQtChartHeaders/ \ @MITK_BINARY_DIR@/bin/ \ @MITK_BINARY_DIR@/PT/ \ @MITK_BINARY_DIR@/GP/ \ @MITK_BINARY_DIR@/Core/CppMicroServices/ \ @MITK_BINARY_DIR@/_CPack_Packages/ \ @MITK_DOXYGEN_ADDITIONAL_EXCLUDE_DIRS@ # The EXCLUDE_SYMLINKS tag can be used to select whether or not files or # directories that are symbolic links (a Unix file system feature) are excluded # from the input. EXCLUDE_SYMLINKS = NO # If the value of the INPUT tag contains directories, you can use the # EXCLUDE_PATTERNS tag to specify one or more wildcard patterns to exclude # certain files from those directories. Note that the wildcards are matched # against the file with absolute path, so to exclude all test directories # for example use the pattern */test/* EXCLUDE_PATTERNS = moc_* \ ui_* \ qrc_* \ wrap_* \ Register* \ */files.cmake \ */.git/* \ *_p.h \ *Private.* \ */Snippets/* \ */snippets/* \ */testing/* \ */Testing/* \ @MITK_BINARY_DIR@/*.cmake \ @MITK_DOXYGEN_EXCLUDE_PATTERNS@ # The EXCLUDE_SYMBOLS tag can be used to specify one or more symbol names # (namespaces, classes, functions, etc.) that should be excluded from the # output. The symbol name can be a fully qualified name, a word, or if the # wildcard * is used, a substring. Examples: ANamespace, AClass, # AClass::ANamespace, ANamespace::*Test -EXCLUDE_SYMBOLS = *Private* \ - ModuleInfo \ - ServiceObjectsBase* \ - TrackedService* +EXCLUDE_SYMBOLS = # 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 = @MITK_SOURCE_DIR@/Examples/ \ @MITK_SOURCE_DIR@/Examples/Tutorial/ \ - @MITK_SOURCE_DIR@/Examples/Plugins/ \ + @MITK_SOURCE_DIR@/Examples/Plugins/ \ @MITK_SOURCE_DIR@/Examples/QtFreeRender/ \ @MITK_SOURCE_DIR@/Core/Code/ \ - @MITK_SOURCE_DIR@/Core/CppMicroServices/documentation/snippets/ \ - @MITK_SOURCE_DIR@/Core/CppMicroServices/examples/ \ + @MITK_SOURCE_DIR@/Core/Code/CppMicroServices/Documentation/Snippets/ \ @MITK_DOXYGEN_OUTPUT_DIR@/html/extension-points/html/ \ @MITK_SOURCE_DIR@/Documentation/Snippets/ \ @MITK_SOURCE_DIR@/Documentation/Doxygen/ExampleCode/ \ - @MITK_SOURCE_DIR@/Modules/OpenCL/Documentation/doxygen/snippets/ \ - @MITK_SOURCE_DIR@/BlueBerry/Documentation/snippets/ + @MITK_SOURCE_DIR@/Modules/OpenCL/Documentation/doxygen/snippets/ # 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 = YES # 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 = @MITK_SOURCE_DIR@/Documentation/Doxygen/ \ @MITK_SOURCE_DIR@/Documentation/Doxygen/Modules/ \ @MITK_SOURCE_DIR@/Documentation/Doxygen/Tutorial/ \ @MITK_SOURCE_DIR@ # The INPUT_FILTER tag can be used to specify a program that doxygen should # invoke to filter for each input file. Doxygen will invoke the filter program # by executing (via popen()) the command , where # is the value of the INPUT_FILTER tag, and is the name of an # input file. Doxygen will then use the output that the filter program writes # to standard output. # If FILTER_PATTERNS is specified, this tag will be # ignored. INPUT_FILTER = # The FILTER_PATTERNS tag can be used to specify filters on a per file pattern # basis. # Doxygen will compare the file name with each pattern and apply the # filter if there is a match. # The filters are a list of the form: # pattern=filter (like *.cpp=my_cpp_filter). See INPUT_FILTER for further # info on how filters are used. If FILTER_PATTERNS is empty or if # non of the patterns match the file name, INPUT_FILTER is applied. FILTER_PATTERNS = *.cmake=@CMakeDoxygenFilter_EXECUTABLE@ # 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 # The FILTER_SOURCE_PATTERNS tag can be used to specify source filters per file # pattern. A pattern will override the setting for FILTER_PATTERN (if any) # and it is also possible to disable source filtering for a specific pattern # using *.ext= (so without naming a filter). This option only has effect when # FILTER_SOURCE_FILES is enabled. FILTER_SOURCE_PATTERNS = #--------------------------------------------------------------------------- # configuration options related to source browsing #--------------------------------------------------------------------------- # If the SOURCE_BROWSER tag is set to YES then a list of source files will # be generated. Documented entities will be cross-referenced with these sources. # Note: To get rid of all source code in the generated output, make sure also # VERBATIM_HEADERS is set to NO. SOURCE_BROWSER = 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 = YES # If the REFERENCED_BY_RELATION tag is set to YES # 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 # then for each documented function all documented entities # called/used by that function will be listed. REFERENCES_RELATION = YES # If the REFERENCES_LINK_SOURCE tag is set to YES (the default) # and SOURCE_BROWSER tag is set to YES, then the hyperlinks from # functions in REFERENCES_RELATION and REFERENCED_BY_RELATION lists will # link to the source code. # Otherwise they will link to the documentation. REFERENCES_LINK_SOURCE = YES # If the USE_HTAGS tag is set to YES then the references to source code # will point to the HTML generated by the htags(1) tool instead of doxygen # built-in source browser. The htags tool is part of GNU's global source # tagging system (see http://www.gnu.org/software/global/global.html). You # will need version 4.8.6 or higher. USE_HTAGS = NO # If the VERBATIM_HEADERS tag is set to YES (the default) then Doxygen # will generate a verbatim copy of the header file for each class for # which an include is specified. Set to NO to disable this. VERBATIM_HEADERS = YES #--------------------------------------------------------------------------- # configuration options related to the alphabetical class index #--------------------------------------------------------------------------- # If the ALPHABETICAL_INDEX tag is set to YES, an alphabetical index # of all compounds will be generated. Enable this if the project # contains a lot of classes, structs, unions or interfaces. ALPHABETICAL_INDEX = 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 = 3 # 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. Note that when using a custom header you are responsible # for the proper inclusion of any scripts and style sheets that doxygen # needs, which is dependent on the configuration options used. # It is advised to generate a default header using "doxygen -w html # header.html footer.html stylesheet.css YourConfigFile" and then modify # that header. Note that the header is subject to change so you typically # have to redo this when upgrading to a newer version of doxygen or when # changing the value of configuration settings such as GENERATE_TREEVIEW! HTML_HEADER = # The HTML_FOOTER tag can be used to specify a personal HTML footer for # each generated HTML page. If it is left blank doxygen will generate a # standard footer. HTML_FOOTER = # The HTML_STYLESHEET tag can be used to specify a user-defined cascading # style sheet that is used by each HTML page. It can be used to # fine-tune the look of the HTML output. If the tag is left blank doxygen # will generate a default style sheet. Note that doxygen will try to copy # the style sheet file to the HTML output directory, so don't put your own # style sheet in the HTML output directory as well, or it will be erased! HTML_STYLESHEET = @MITK_DOXYGEN_STYLESHEET@ # The HTML_EXTRA_FILES tag can be used to specify one or more extra images or # other source files which should be copied to the HTML output directory. Note # that these files will be copied to the base HTML output directory. Use the # $relpath$ marker in the HTML_HEADER and/or HTML_FOOTER files to load these # files. In the HTML_STYLESHEET file, use the file name only. Also note that # the files will be copied as-is; there are no commands or markers available. HTML_EXTRA_FILES = # The HTML_COLORSTYLE_HUE tag controls the color of the HTML output. # Doxygen will adjust the colors in the style sheet and background images # according to this color. Hue is specified as an angle on a colorwheel, # see http://en.wikipedia.org/wiki/Hue for more information. # For instance the value 0 represents red, 60 is yellow, 120 is green, # 180 is cyan, 240 is blue, 300 purple, and 360 is red again. # The allowed range is 0 to 359. HTML_COLORSTYLE_HUE = 220 # The HTML_COLORSTYLE_SAT tag controls the purity (or saturation) of # the colors in the HTML output. For a value of 0 the output will use # grayscales only. A value of 255 will produce the most vivid colors. HTML_COLORSTYLE_SAT = 100 # The HTML_COLORSTYLE_GAMMA tag controls the gamma correction applied to # the luminance component of the colors in the HTML output. Values below # 100 gradually make the output lighter, whereas values above 100 make # the output darker. The value divided by 100 is the actual gamma applied, # so 80 represents a gamma of 0.8, The value 220 represents a gamma of 2.2, # and 100 does not change the gamma. HTML_COLORSTYLE_GAMMA = 80 # If the HTML_TIMESTAMP tag is set to YES then the footer of each generated HTML # page will contain the date and time when the page was generated. Setting # this to NO can help when comparing the output of multiple runs. HTML_TIMESTAMP = YES # 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 HTML_DYNAMIC_SECTIONS tag is set to YES then the generated HTML # documentation will contain sections that can be hidden and shown after the # page has loaded. For this to work a browser that supports # JavaScript and DHTML is required (for instance Mozilla 1.0+, Firefox # Netscape 6.0+, Internet explorer 5.0+, Konqueror, or Safari). HTML_DYNAMIC_SECTIONS = @MITK_DOXYGEN_HTML_DYNAMIC_SECTIONS@ # If the GENERATE_DOCSET tag is set to YES, additional index files # will be generated that can be used as input for Apple's Xcode 3 # integrated development environment, introduced with OSX 10.5 (Leopard). # To create a documentation set, doxygen will generate a Makefile in the # HTML output directory. Running make will produce the docset in that # directory and running "make install" will install the docset in # ~/Library/Developer/Shared/Documentation/DocSets so that Xcode will find # it at startup. # See http://developer.apple.com/tools/creatingdocsetswithdoxygen.html # for more information. GENERATE_DOCSET = NO # When GENERATE_DOCSET tag is set to YES, this tag determines the name of the # feed. A documentation feed provides an umbrella under which multiple # documentation sets from a single provider (such as a company or product suite) # can be grouped. DOCSET_FEEDNAME = "Doxygen generated docs" # When GENERATE_DOCSET tag is set to YES, this tag specifies a string that # should uniquely identify the documentation set bundle. This should be a # reverse domain-name style string, e.g. com.mycompany.MyDocSet. Doxygen # will append .docset to the name. DOCSET_BUNDLE_ID = org.doxygen.Project # When GENERATE_PUBLISHER_ID tag specifies a string that should uniquely identify # the documentation publisher. This should be a reverse domain-name style # string, e.g. com.mycompany.MyDocSet.documentation. DOCSET_PUBLISHER_ID = org.doxygen.Publisher # The GENERATE_PUBLISHER_NAME tag identifies the documentation publisher. DOCSET_PUBLISHER_NAME = Publisher # 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 compiled HTML help file (.chm) # of the generated HTML documentation. GENERATE_HTMLHELP = NO # If the GENERATE_HTMLHELP tag is set to YES, the CHM_FILE tag can # be used to specify the file name of the resulting .chm file. You # can add a path in front of the file if the result should not be # written to the html output directory. CHM_FILE = # If the GENERATE_HTMLHELP tag is set to YES, the HHC_LOCATION tag can # be used to specify the location (absolute path including file name) of # the HTML help compiler (hhc.exe). If non-empty doxygen will try to run # the HTML help compiler on the generated index.hhp. HHC_LOCATION = # If the GENERATE_HTMLHELP tag is set to YES, the GENERATE_CHI flag # controls if a separate .chi index file is generated (YES) or that # it should be included in the master .chm file (NO). GENERATE_CHI = NO # If the GENERATE_HTMLHELP tag is set to YES, the CHM_INDEX_ENCODING # is used to encode HtmlHelp index (hhk), content (hhc) and project file # content. CHM_INDEX_ENCODING = # If the GENERATE_HTMLHELP tag is set to YES, the BINARY_TOC flag # controls whether a binary table of contents is generated (YES) or a # normal table of contents (NO) in the .chm file. BINARY_TOC = NO # The TOC_EXPAND flag can be set to YES to add extra items for group members # to the contents of the HTML help documentation and to the tree view. TOC_EXPAND = NO # If the GENERATE_QHP tag is set to YES and both QHP_NAMESPACE and # QHP_VIRTUAL_FOLDER are set, an additional index file will be generated # that can be used as input for Qt's qhelpgenerator to generate a # Qt Compressed Help (.qch) of the generated HTML documentation. GENERATE_QHP = @MITK_DOXYGEN_GENERATE_QHP@ # If the QHG_LOCATION tag is specified, the QCH_FILE tag can # be used to specify the file name of the resulting .qch file. # The path specified is relative to the HTML output folder. QCH_FILE = @MITK_DOXYGEN_QCH_FILE@ # The QHP_NAMESPACE tag specifies the namespace to use when generating # Qt Help Project output. For more information please see # http://doc.trolltech.com/qthelpproject.html#namespace QHP_NAMESPACE = "org.mitk" # The QHP_VIRTUAL_FOLDER tag specifies the namespace to use when generating # Qt Help Project output. For more information please see # http://doc.trolltech.com/qthelpproject.html#virtual-folders QHP_VIRTUAL_FOLDER = MITK # If QHP_CUST_FILTER_NAME is set, it specifies the name of a custom filter to # add. For more information please see # http://doc.trolltech.com/qthelpproject.html#custom-filters QHP_CUST_FILTER_NAME = # The QHP_CUST_FILT_ATTRS tag specifies the list of the attributes of the # custom filter to add. For more information please see # # Qt Help Project / Custom Filters. QHP_CUST_FILTER_ATTRS = # The QHP_SECT_FILTER_ATTRS tag specifies the list of the attributes this # project's # filter section matches. # # Qt Help Project / Filter Attributes. QHP_SECT_FILTER_ATTRS = # If the GENERATE_QHP tag is set to YES, the QHG_LOCATION tag can # be used to specify the location of Qt's qhelpgenerator. # If non-empty doxygen will try to run qhelpgenerator on the generated # .qhp file. QHG_LOCATION = @QT_HELPGENERATOR_EXECUTABLE@ # If the GENERATE_ECLIPSEHELP tag is set to YES, additional index files # will be generated, which together with the HTML files, form an Eclipse help # plugin. To install this plugin and make it available under the help contents # menu in Eclipse, the contents of the directory containing the HTML and XML # files needs to be copied into the plugins directory of eclipse. The name of # the directory within the plugins directory should be the same as # the ECLIPSE_DOC_ID value. After copying Eclipse needs to be restarted before # the help appears. GENERATE_ECLIPSEHELP = NO # A unique identifier for the eclipse help plugin. When installing the plugin # the directory name containing the HTML and XML files should also have # this name. ECLIPSE_DOC_ID = org.doxygen.Project # The DISABLE_INDEX tag can be used to turn on/off the condensed index (tabs) # at top of each HTML page. The value NO (the default) enables the index and # the value YES disables it. Since the tabs have the same information as the # navigation tree you can set this option to NO if you already set # GENERATE_TREEVIEW to YES. DISABLE_INDEX = NO # The GENERATE_TREEVIEW tag is used to specify whether a tree-like index # structure should be generated to display hierarchical information. # If the tag value 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 (i.e. any modern browser). # Windows users are probably better off using the HTML help feature. # Since the tree basically has the same information as the tab index you # could consider to set DISABLE_INDEX to NO when enabling this option. GENERATE_TREEVIEW = YES # The ENUM_VALUES_PER_LINE tag can be used to set the number of enum values # (range [0,1..20]) that doxygen will group on one line in the generated HTML # documentation. Note that a value of 0 will completely suppress the enum # values from appearing in the overview section. ENUM_VALUES_PER_LINE = 4 # By enabling USE_INLINE_TREES, doxygen will generate the Groups, Directories, # and Class Hierarchy pages using a tree view instead of an ordered list. USE_INLINE_TREES = 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 = 300 # When the EXT_LINKS_IN_WINDOW option is set to YES doxygen will open # links to external symbols imported via tag files in a separate window. EXT_LINKS_IN_WINDOW = NO # Use this tag to change the font size of Latex formulas included # as images in the HTML documentation. The default is 10. Note that # when you change the font size after a successful doxygen run you need # to manually remove any form_*.png images from the HTML output directory # to force them to be regenerated. FORMULA_FONTSIZE = 10 # Use the FORMULA_TRANPARENT tag to determine whether or not the images # generated for formulas are transparent PNGs. Transparent PNGs are # not supported properly for IE 6.0, but are supported on all modern browsers. # Note that when changing this option you need to delete any form_*.png files # in the HTML output before the changes have effect. FORMULA_TRANSPARENT = YES # Enable the USE_MATHJAX option to render LaTeX formulas using MathJax # (see http://www.mathjax.org) which uses client side Javascript for the # rendering instead of using prerendered bitmaps. Use this if you do not # have LaTeX installed or if you want to formulas look prettier in the HTML # output. When enabled you may also need to install MathJax separately and # configure the path to it using the MATHJAX_RELPATH option. USE_MATHJAX = NO # When MathJax is enabled you need to specify the location relative to the # HTML output directory using the MATHJAX_RELPATH option. The destination # directory should contain the MathJax.js script. For instance, if the mathjax # directory is located at the same level as the HTML output directory, then # MATHJAX_RELPATH should be ../mathjax. The default value points to # the MathJax Content Delivery Network so you can quickly see the result without # installing MathJax. # However, it is strongly recommended to install a local # copy of MathJax from http://www.mathjax.org before deployment. MATHJAX_RELPATH = http://www.mathjax.org/mathjax # The MATHJAX_EXTENSIONS tag can be used to specify one or MathJax extension # names that should be enabled during MathJax rendering. MATHJAX_EXTENSIONS = # When the SEARCHENGINE tag is enabled doxygen will generate a search box # for the HTML output. The underlying search engine uses javascript # and DHTML and should work on any modern browser. Note that when using # HTML help (GENERATE_HTMLHELP), Qt help (GENERATE_QHP), or docsets # (GENERATE_DOCSET) there is already a search function so this one should # typically be disabled. For large projects the javascript based search engine # can be slow, then enabling SERVER_BASED_SEARCH may provide a better solution. SEARCHENGINE = YES # When the SERVER_BASED_SEARCH tag is enabled the search engine will be # implemented using a PHP enabled web server instead of at the web client # using Javascript. Doxygen will generate the search PHP script and index # file to put on the web server. The advantage of the server # based approach is that it scales better to large projects and allows # full text search. The disadvantages are that it is more difficult to setup # and does not have live searching capabilities. SERVER_BASED_SEARCH = NO #--------------------------------------------------------------------------- # 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. # Note that when enabling USE_PDFLATEX this option is only used for # generating bitmaps for formulas in the HTML output, but not in the # Makefile that is written to the output directory. LATEX_CMD_NAME = latex # The MAKEINDEX_CMD_NAME tag can be used to specify the command name to # generate index for LaTeX. If left blank `makeindex' will be used as the # default command name. MAKEINDEX_CMD_NAME = makeindex # If the COMPACT_LATEX tag is set to YES Doxygen generates more compact # LaTeX documents. This may be useful for small projects and may help to # save some trees in general. COMPACT_LATEX = NO # The PAPER_TYPE tag can be used to set the paper type that is used # by the printer. Possible values are: a4, letter, legal and # executive. If left blank a4wide will be used. PAPER_TYPE = a4wide # The EXTRA_PACKAGES tag can be to specify one or more names of LaTeX # packages that should be included in the LaTeX output. EXTRA_PACKAGES = amssymb # 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 = # The LATEX_FOOTER tag can be used to specify a personal LaTeX footer for # the generated latex document. The footer should contain everything after # the last chapter. If it is left blank doxygen will generate a # standard footer. Notice: only use this tag if you know what you are doing! LATEX_FOOTER = # If the PDF_HYPERLINKS tag is set to YES, the LaTeX that is generated # is prepared for conversion to pdf (using ps2pdf). The pdf file will # contain links (just like the HTML output) instead of page references # This makes the output suitable for online browsing using a pdf viewer. PDF_HYPERLINKS = NO # If the USE_PDFLATEX tag is set to YES, pdflatex will be used instead of # plain latex in the generated Makefile. Set this option to YES to get a # higher quality PDF documentation. USE_PDFLATEX = NO # If the LATEX_BATCHMODE tag is set to YES, doxygen will add the \\batchmode. # command to the generated LaTeX files. This will instruct LaTeX to keep # running if errors occur, instead of asking the user for help. # This option is also used when generating formulas in HTML. LATEX_BATCHMODE = NO # If LATEX_HIDE_INDICES is set to YES then doxygen will not # include the index chapters (such as File Index, Compound Index, etc.) # in the output. LATEX_HIDE_INDICES = NO # If LATEX_SOURCE_CODE is set to YES then doxygen will include # source code with syntax highlighting in the LaTeX output. # Note that which sources are shown also depends on other settings # such as SOURCE_BROWSER. LATEX_SOURCE_CODE = NO # The LATEX_BIB_STYLE tag can be used to specify the style to use for the # bibliography, e.g. plainnat, or ieeetr. The default style is "plain". See # http://en.wikipedia.org/wiki/BibTeX for more info. LATEX_BIB_STYLE = plain #--------------------------------------------------------------------------- # configuration options related to the RTF output #--------------------------------------------------------------------------- # If the GENERATE_RTF tag is set to YES Doxygen will generate RTF output # The RTF output is optimized for Word 97 and may not look very pretty with # other RTF readers or editors. GENERATE_RTF = NO # The RTF_OUTPUT tag is used to specify where the RTF docs will be put. # If a relative path is entered the value of OUTPUT_DIRECTORY will be # put in front of it. If left blank `rtf' will be used as the default path. RTF_OUTPUT = rtf # If the COMPACT_RTF tag is set to YES Doxygen generates more compact # RTF documents. This may be useful for small projects and may help to # save some trees in general. COMPACT_RTF = NO # If the RTF_HYPERLINKS tag is set to YES, the RTF that is generated # will contain hyperlink fields. The RTF file will # contain links (just like the HTML output) instead of page references. # This makes the output suitable for online browsing using WORD or other # programs which support those fields. # Note: wordpad (write) and others do not support links. RTF_HYPERLINKS = NO # Load style sheet definitions from file. Syntax is similar to doxygen's # config file, i.e. a series of assignments. You only have to provide # replacements, missing definitions are set to their default value. RTF_STYLESHEET_FILE = # Set optional variables used in the generation of an rtf document. # Syntax is similar to doxygen's config file. RTF_EXTENSIONS_FILE = #--------------------------------------------------------------------------- # configuration options related to the man page output #--------------------------------------------------------------------------- # If the GENERATE_MAN tag is set to YES (the default) Doxygen will # generate man pages GENERATE_MAN = NO # The MAN_OUTPUT tag is used to specify where the man pages will be put. # If a relative path is entered the value of OUTPUT_DIRECTORY will be # put in front of it. If left blank `man' will be used as the default path. MAN_OUTPUT = man # The MAN_EXTENSION tag determines the extension that is added to # the generated man pages (default is the subroutine's section .3) MAN_EXTENSION = .3 # If the MAN_LINKS tag is set to YES and Doxygen generates man output, # then it will generate one additional man file for each entity # documented in the real man page(s). These additional files # only source the real man page, but without them the man command # would be unable to find the correct page. The default is NO. MAN_LINKS = NO #--------------------------------------------------------------------------- # configuration options related to the XML output #--------------------------------------------------------------------------- # If the GENERATE_XML tag is set to YES Doxygen will # generate an XML file that captures the structure of # the code including all documentation. GENERATE_XML = NO # The XML_OUTPUT tag is used to specify where the XML pages will be put. # If a relative path is entered the value of OUTPUT_DIRECTORY will be # put in front of it. If left blank `xml' will be used as the default path. XML_OUTPUT = xml # The XML_SCHEMA tag can be used to specify an XML schema, # which can be used by a validating XML parser to check the # syntax of the XML files. XML_SCHEMA = # The XML_DTD tag can be used to specify an XML DTD, # which can be used by a validating XML parser to check the # syntax of the XML files. XML_DTD = # If the XML_PROGRAMLISTING tag is set to YES Doxygen will # dump the program listings (including syntax highlighting # and cross-referencing information) to the XML output. Note that # enabling this will significantly increase the size of the XML output. XML_PROGRAMLISTING = YES #--------------------------------------------------------------------------- # configuration options for the AutoGen Definitions output #--------------------------------------------------------------------------- # If the GENERATE_AUTOGEN_DEF tag is set to YES Doxygen will # generate an AutoGen Definitions (see autogen.sf.net) file # that captures the structure of the code including all # documentation. Note that this feature is still experimental # and incomplete at the moment. GENERATE_AUTOGEN_DEF = NO #--------------------------------------------------------------------------- # configuration options related to the Perl module output #--------------------------------------------------------------------------- # If the GENERATE_PERLMOD tag is set to YES Doxygen will # generate a Perl module file that captures the structure of # the code including all documentation. Note that this # feature is still experimental and incomplete at the # moment. GENERATE_PERLMOD = NO # If the PERLMOD_LATEX tag is set to YES Doxygen will generate # the necessary Makefile rules, Perl scripts and LaTeX code to be able # to generate PDF and DVI output from the Perl module output. PERLMOD_LATEX = NO # If the PERLMOD_PRETTY tag is set to YES the Perl module output will be # nicely formatted so it can be parsed by a human reader. # This is useful # if you want to understand what is going on. # On the other hand, if this # tag is set to NO the size of the Perl module output will be much smaller # and Perl will parse it just the same. PERLMOD_PRETTY = YES # The names of the make variables in the generated doxyrules.make file # are prefixed with the string contained in PERLMOD_MAKEVAR_PREFIX. # This is useful so different doxyrules.make files included by the same # Makefile don't overwrite each other's variables. PERLMOD_MAKEVAR_PREFIX = #--------------------------------------------------------------------------- # Configuration options related to the preprocessor #--------------------------------------------------------------------------- # If the ENABLE_PREPROCESSING tag is set to YES (the default) Doxygen will # evaluate all C-preprocessor directives found in the sources and include # files. ENABLE_PREPROCESSING = YES # If the MACRO_EXPANSION tag is set to YES Doxygen will expand all macro # names in the source code. If set to NO (the default) only conditional # compilation will be performed. Macro expansion can be done in a controlled # way by setting EXPAND_ONLY_PREDEF to YES. MACRO_EXPANSION = YES # 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_DEFINED tags. EXPAND_ONLY_PREDEF = NO # If the SEARCH_INCLUDES tag is set to YES (the default) the includes files # pointed to by INCLUDE_PATH will be searched when a #include is found. SEARCH_INCLUDES = YES # The INCLUDE_PATH tag can be used to specify one or more directories that # contain include files that are not input files but should be processed by # the preprocessor. INCLUDE_PATH = # You can use the INCLUDE_FILE_PATTERNS tag to specify one or more wildcard # patterns (like *.h and *.hpp) to filter out the header-files in the # directories. If left blank, the patterns specified with FILE_PATTERNS will # be used. INCLUDE_FILE_PATTERNS = # The PREDEFINED tag can be used to specify one or more macro names that # are defined before the preprocessor is started (similar to the -D option of # gcc). The argument of the tag is a list of macros of the form: name # or name=definition (no spaces). If the definition and the = are # omitted =1 is assumed. To prevent a macro definition from being # undefined via #undef or recursively expanded use the := operator # instead of the = operator. PREDEFINED = itkNotUsed(x)= \ "itkSetMacro(name,type)= virtual void Set##name (type _arg);" \ "itkGetMacro(name,type)= virtual type Get##name ();" \ "itkGetConstMacro(name,type)= virtual type Get##name () const;" \ "itkSetStringMacro(name)= virtual void Set##name (const char* _arg);" \ "itkGetStringMacro(name)= virtual const char* Get##name () const;" \ "itkSetClampMacro(name,type,min,max)= virtual void Set##name (type _arg);" \ "itkSetObjectMacro(name,type)= virtual void Set##name (type* _arg);" \ "itkGetObjectMacro(name,type)= virtual type* Get##name ();" \ "itkSetConstObjectMacro(name,type)= virtual void Set##name ( const type* _arg);" \ "itkGetConstObjectMacro(name,type)= virtual const type* Get##name ();" \ "itkGetConstReferenceMacro(name,type)= virtual const type& Get##name ();" \ "itkGetConstReferenceObjectMacro(name,type)= virtual const type::Pointer& Get##name () const;" \ "itkBooleanMacro(name)= virtual void name##On (); virtual void name##Off ();" \ "itkSetVector2Macro(name,type)= virtual void Set##name (type _arg1, type _arg2) virtual void Set##name (type _arg[2]);" \ "itkGetVector2Macro(name,type)= virtual type* Get##name () const; virtual void Get##name (type& _arg1, type& _arg2) const; virtual void Get##name (type _arg[2]) const;" \ "itkSetVector3Macro(name,type)= virtual void Set##name (type _arg1, type _arg2, type _arg3) virtual void Set##name (type _arg[3]);" \ "itkGetVector3Macro(name,type)= virtual type* Get##name () const; virtual void Get##name (type& _arg1, type& _arg2, type& _arg3) const; virtual void Get##name (type _arg[3]) const;" \ "itkSetVector4Macro(name,type)= virtual void Set##name (type _arg1, type _arg2, type _arg3, type _arg4) virtual void Set##name (type _arg[4]);" \ "itkGetVector4Macro(name,type)= virtual type* Get##name () const; virtual void Get##name (type& _arg1, type& _arg2, type& _arg3, type& _arg4) const; virtual void Get##name (type _arg[4]) const;" \ "itkSetVector6Macro(name,type)= virtual void Set##name (type _arg1, type _arg2, type _arg3, type _arg4, type _arg5, type _arg6) virtual void Set##name (type _arg[6]);" \ "itkGetVector6Macro(name,type)= virtual type* Get##name () const; virtual void Get##name (type& _arg1, type& _arg2, type& _arg3, type& _arg4, type& _arg5, type& _arg6) const; virtual void Get##name (type _arg[6]) const;" \ "itkSetVectorMacro(name,type,count)= virtual void Set##name(type data[]);" \ "itkGetVectorMacro(name,type,count)= virtual type* Get##name () const;" \ "itkNewMacro(type)= static Pointer New();" \ "itkTypeMacro(thisClass,superclass)= virtual const char *GetClassName() const;" \ "itkConceptMacro(name,concept)= enum { name = 0 };" \ "ITK_NUMERIC_LIMITS= std::numeric_limits" \ "ITK_TYPENAME= typename" \ "FEM_ABSTRACT_CLASS(thisClass,parentClass)= public: /** Standard Self typedef.*/ typedef thisClass Self; /** Standard Superclass typedef. */ typedef parentClass Superclass; /** Pointer or SmartPointer to an object. */ typedef Self* Pointer; /** Const pointer or SmartPointer to an object. */ typedef const Self* ConstPointer; private:" \ "FEM_CLASS(thisClass,parentClass)= FEM_ABSTRACT_CLASS(thisClass,parentClass) public: /** Create a new object from the existing one */ virtual Baseclass::Pointer Clone() const; /** Class ID for FEM object factory */ static const int CLID; /** Virtual function to access the class ID */ virtual int ClassID() const { return CLID; } /** Object creation in an itk compatible way */ static Self::Pointer New() { return new Self(); } private:" \ FREEVERSION \ ERROR_CHECKING \ HAS_TIFF \ HAS_JPEG \ HAS_NETLIB \ HAS_PNG \ HAS_ZLIB \ HAS_GLUT \ HAS_QT \ VCL_USE_NATIVE_STL=1 \ VCL_USE_NATIVE_COMPLEX=1 \ VCL_HAS_BOOL=1 \ VXL_BIG_ENDIAN=1 \ VXL_LITTLE_ENDIAN=0 \ VNL_DLL_DATA= \ size_t=vcl_size_t \ - "US_PREPEND_NAMESPACE(x)=us::x" \ - "US_BEGIN_NAMESPACE= namespace us {" \ + "US_PREPEND_NAMESPACE(x)=mitk::x" \ + "US_BEGIN_NAMESPACE= namespace mitk {" \ "US_END_NAMESPACE=}" \ + "US_BASECLASS_NAME=itk::LightObject" \ US_EXPORT= \ "DEPRECATED(func)=func" # 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 that # overrules the definition found in the source code. EXPAND_AS_DEFINED = # If the SKIP_FUNCTION_MACROS tag is set to YES (the default) then # doxygen's preprocessor will remove all references to function-like macros # that are alone on a line, have an all uppercase name, and do not end with a # semicolon, because these will confuse the parser if not removed. SKIP_FUNCTION_MACROS = YES #--------------------------------------------------------------------------- # Configuration::additions related to external references #--------------------------------------------------------------------------- # The TAGFILES option can be used to specify one or more tagfiles. For each # tag file the location of the external documentation should be added. 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. 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 = +TAGFILES = @BLUEBERRY_DOXYGEN_TAGFILE@ # 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 = @MITK_DOXYGEN_TAGFILE_NAME@ # 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 = NO # The PERL_PATH should be the absolute path and name of the perl script # interpreter (i.e. the result of `which perl'). PERL_PATH = /usr/bin/perl #--------------------------------------------------------------------------- # Configuration options related to the dot tool #--------------------------------------------------------------------------- # If the CLASS_DIAGRAMS tag is set to YES (the default) Doxygen will # generate a inheritance diagram (in HTML, RTF and LaTeX) for classes with base # or super classes. Setting the tag to NO turns the diagrams off. Note that # this option also works with HAVE_DOT disabled, but it is recommended to # install and use dot, since it yields more powerful graphs. CLASS_DIAGRAMS = YES # You can define message sequence charts within doxygen comments using the \msc # command. Doxygen will then run the mscgen tool (see # http://www.mcternan.me.uk/mscgen/) to produce the chart and insert it in the # documentation. The MSCGEN_PATH tag allows you to specify the directory where # the mscgen tool resides. If left empty the tool is assumed to be found in the # default search path. MSCGEN_PATH = # 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 = @HAVE_DOT@ # The DOT_NUM_THREADS specifies the number of dot invocations doxygen is # allowed to run in parallel. When set to 0 (the default) doxygen will # base this on the number of processors available in the system. You can set it # explicitly to a value larger than 0 to get control over the balance # between CPU load and processing speed. DOT_NUM_THREADS = @MITK_DOXYGEN_DOT_NUM_THREADS@ # By default doxygen will use the Helvetica font for all dot files that # doxygen generates. When you want a differently looking font you can specify # the font name using DOT_FONTNAME. You need to make sure dot is able to find # the font, which can be done by putting it in a standard location or by setting # the DOTFONTPATH environment variable or by setting DOT_FONTPATH to the # directory containing the font. DOT_FONTNAME = FreeSans.ttf # The DOT_FONTSIZE tag can be used to set the size of the font of dot graphs. # The default size is 10pt. DOT_FONTSIZE = 10 # By default doxygen will tell dot to use the Helvetica font. # If you specify a different font using DOT_FONTNAME you can use DOT_FONTPATH to # set the path where dot can find it. DOT_FONTPATH = # 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 # CLASS_DIAGRAMS tag to NO. CLASS_GRAPH = YES # If the COLLABORATION_GRAPH and HAVE_DOT tags are set to YES then doxygen # will generate a graph for each documented class showing the direct and # indirect implementation dependencies (inheritance, containment, and # class references variables) of the class with other documented classes. COLLABORATION_GRAPH = YES # If the GROUP_GRAPHS and HAVE_DOT tags are set to YES then doxygen # will generate a graph for groups, showing the direct groups dependencies GROUP_GRAPHS = YES # If the UML_LOOK tag is set to YES doxygen will generate inheritance and # collaboration diagrams in a style similar to the OMG's Unified Modeling # Language. UML_LOOK = @MITK_DOXYGEN_UML_LOOK@ # If the UML_LOOK tag is enabled, the fields and methods are shown inside # the class node. If there are many fields or methods and many nodes the # graph may become too big to be useful. The UML_LIMIT_NUM_FIELDS # threshold limits the number of items for each type to make the size more # managable. Set this to 0 for no limit. Note that the threshold may be # exceeded by 50% before the limit is enforced. UML_LIMIT_NUM_FIELDS = 10 # 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 = NO # 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 = NO # If the CALL_GRAPH and HAVE_DOT options 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 CALLER_GRAPH and HAVE_DOT tags are set to YES then # doxygen will generate a caller 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 caller # graphs for selected functions only using the \callergraph command. CALLER_GRAPH = NO # If the GRAPHICAL_HIERARCHY and HAVE_DOT tags are set to YES then doxygen # will generate a graphical hierarchy of all classes instead of a textual one. GRAPHICAL_HIERARCHY = NO # If the DIRECTORY_GRAPH, SHOW_DIRECTORIES and HAVE_DOT tags are set to YES # then doxygen will show the dependencies a directory has on other directories # in a graphical way. The dependency relations are determined by the #include # relations between the files in the directories. DIRECTORY_GRAPH = YES # The DOT_IMAGE_FORMAT tag can be used to set the image format of the images # generated by dot. Possible values are svg, png, jpg, or gif. # If left blank png will be used. If you choose svg you need to set # HTML_FILE_EXTENSION to xhtml in order to make the SVG files # visible in IE 9+ (other browsers do not have this requirement). DOT_IMAGE_FORMAT = png # If DOT_IMAGE_FORMAT is set to svg, then this option can be set to YES to # enable generation of interactive SVG images that allow zooming and panning. # Note that this requires a modern browser other than Internet Explorer. # Tested and working are Firefox, Chrome, Safari, and Opera. For IE 9+ you # need to set HTML_FILE_EXTENSION to xhtml in order to make the SVG files # visible. Older versions of IE do not have SVG support. INTERACTIVE_SVG = NO # The tag DOT_PATH can be used to specify the path where the dot tool can be # found. If left blank, it is assumed the dot tool can be found in the path. DOT_PATH = @DOXYGEN_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 MSCFILE_DIRS tag can be used to specify one or more directories that # contain msc files that are included in the documentation (see the # \mscfile command). MSCFILE_DIRS = # The DOT_GRAPH_MAX_NODES tag can be used to set the maximum number of # nodes that will be shown in the graph. If the number of nodes in a graph # becomes larger than this value, doxygen will truncate the graph, which is # visualized by representing a node as a red box. Note that doxygen if the # number of direct children of the root node in a graph is already larger than # DOT_GRAPH_MAX_NODES then the graph will not be shown at all. Also note # that the size of a graph can be further restricted by MAX_DOT_GRAPH_DEPTH. DOT_GRAPH_MAX_NODES = 50 # 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 the size of a graph can be further restricted by # DOT_GRAPH_MAX_NODES. Using a depth of 0 means no depth restriction. MAX_DOT_GRAPH_DEPTH = 0 # Set the DOT_TRANSPARENT tag to YES to generate images with a transparent # background. This is disabled by default, because dot on Windows does not # seem to support this out of the box. Warning: Depending on the platform used, # enabling this option may lead to badly anti-aliased labels on the edges of # a graph (i.e. they become hard to read). DOT_TRANSPARENT = NO # Set the DOT_MULTI_TARGETS tag to YES allow dot to generate multiple output # files in one run (i.e. multiple -o and -T options on the command line). This # makes dot run faster, but since only newer versions of dot (>1.8.10) # support this, this feature is disabled by default. DOT_MULTI_TARGETS = NO # If the GENERATE_LEGEND tag is set to YES (the default) Doxygen will # generate a legend page explaining the meaning of the various boxes and # arrows in the dot generated graphs. GENERATE_LEGEND = YES # If the DOT_CLEANUP tag is set to YES (the default) Doxygen will # remove the intermediate dot files that are used to generate # the various graphs. DOT_CLEANUP = YES diff --git a/Modules/ImageExtraction/CMakeLists.txt b/Modules/ImageExtraction/CMakeLists.txt index 51327efccc..41b3ebf9ad 100644 --- a/Modules/ImageExtraction/CMakeLists.txt +++ b/Modules/ImageExtraction/CMakeLists.txt @@ -1,10 +1,9 @@ MITK_CREATE_MODULE( ImageExtraction DEPENDS Mitk mitkIpPic PlanarFigure - DEPENDS_INTERNAL pic2vtk ) if(BUILD_TESTING) add_subdirectory(Testing) endif(BUILD_TESTING) diff --git a/Modules/ImageExtraction/mitkExtractDirectedPlaneImageFilter.cpp b/Modules/ImageExtraction/mitkExtractDirectedPlaneImageFilter.cpp index 68c2a59a8c..a1883fa717 100644 --- a/Modules/ImageExtraction/mitkExtractDirectedPlaneImageFilter.cpp +++ b/Modules/ImageExtraction/mitkExtractDirectedPlaneImageFilter.cpp @@ -1,511 +1,508 @@ /*=================================================================== The Medical Imaging Interaction Toolkit (MITK) Copyright (c) German Cancer Research Center, Division of Medical and Biological Informatics. All rights reserved. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See LICENSE.txt or http://www.mitk.org for details. ===================================================================*/ #include "mitkExtractDirectedPlaneImageFilter.h" #include "mitkAbstractTransformGeometry.h" //#include "mitkImageMapperGL2D.h" #include #include #include #include #include "vtkMitkThickSlicesFilter.h" #include #include #include #include #include #include #include -#include "pic2vtk.h" - - mitk::ExtractDirectedPlaneImageFilter::ExtractDirectedPlaneImageFilter() : m_WorldGeometry(NULL) { MITK_WARN << "Class ExtractDirectedPlaneImageFilter is deprecated! Use ExtractSliceFilter instead."; m_Reslicer = vtkImageReslice::New(); m_TargetTimestep = 0; m_InPlaneResampleExtentByGeometry = true; m_ResliceInterpolationProperty = NULL;//VtkResliceInterpolationProperty::New(); //TODO initial with value m_ThickSlicesMode = 0; m_ThickSlicesNum = 1; } mitk::ExtractDirectedPlaneImageFilter::~ExtractDirectedPlaneImageFilter() { if(m_ResliceInterpolationProperty!=NULL)m_ResliceInterpolationProperty->Delete(); m_Reslicer->Delete(); } void mitk::ExtractDirectedPlaneImageFilter::GenerateData() { // A world geometry must be set... if ( m_WorldGeometry == NULL ) { itkWarningMacro(<<"No world geometry has been set. Returning."); return; } Image *input = const_cast< ImageToImageFilter::InputImageType* >( this->GetInput() ); input->Update(); if ( input == NULL ) { itkWarningMacro(<<"No input set."); return; } const TimeSlicedGeometry *inputTimeGeometry = input->GetTimeSlicedGeometry(); if ( ( inputTimeGeometry == NULL ) || ( inputTimeGeometry->GetTimeSteps() == 0 ) ) { itkWarningMacro(<<"Error reading input image geometry."); return; } // Get the target timestep; if none is set, use the lowest given. unsigned int timestep = 0; if ( ! m_TargetTimestep ) { ScalarType time = m_WorldGeometry->GetTimeBounds()[0]; if ( time > ScalarTypeNumericTraits::NonpositiveMin() ) { timestep = inputTimeGeometry->MSToTimeStep( time ); } } else timestep = m_TargetTimestep; if ( inputTimeGeometry->IsValidTime( timestep ) == false ) { itkWarningMacro(<<"This is not a valid timestep: "<IsVolumeSet( timestep ) ) { itkWarningMacro(<<"No volume data existent at given timestep "<GetLargestPossibleRegion(); requestedRegion.SetIndex( 3, timestep ); requestedRegion.SetSize( 3, 1 ); requestedRegion.SetSize( 4, 1 ); input->SetRequestedRegion( &requestedRegion ); input->Update(); vtkImageData* inputData = input->GetVtkImageData( timestep ); if ( inputData == NULL ) { itkWarningMacro(<<"Could not extract vtk image data for given timestep"<GetSpacing( spacing ); // how big the area is in physical coordinates: widthInMM x heightInMM pixels mitk::ScalarType widthInMM, heightInMM; // where we want to sample Point3D origin; Vector3D right, bottom, normal; Vector3D rightInIndex, bottomInIndex; assert( input->GetTimeSlicedGeometry() == inputTimeGeometry ); // take transform of input image into account Geometry3D* inputGeometry = inputTimeGeometry->GetGeometry3D( timestep ); if ( inputGeometry == NULL ) { itkWarningMacro(<<"There is no Geometry3D at given timestep "<( m_WorldGeometry ) != NULL ) { const PlaneGeometry *planeGeometry = static_cast< const PlaneGeometry * >( m_WorldGeometry ); origin = planeGeometry->GetOrigin(); right = planeGeometry->GetAxisVector( 0 ); bottom = planeGeometry->GetAxisVector( 1 ); normal = planeGeometry->GetNormal(); if ( m_InPlaneResampleExtentByGeometry ) { // Resampling grid corresponds to the current world geometry. This // means that the spacing of the output 2D image depends on the // currently selected world geometry, and *not* on the image itself. extent[0] = m_WorldGeometry->GetExtent( 0 ); extent[1] = m_WorldGeometry->GetExtent( 1 ); } else { // Resampling grid corresponds to the input geometry. This means that // the spacing of the output 2D image is directly derived from the // associated input image, regardless of the currently selected world // geometry. inputGeometry->WorldToIndex( right, rightInIndex ); inputGeometry->WorldToIndex( bottom, bottomInIndex ); extent[0] = rightInIndex.GetNorm(); extent[1] = bottomInIndex.GetNorm(); } // Get the extent of the current world geometry and calculate resampling // spacing therefrom. widthInMM = m_WorldGeometry->GetExtentInMM( 0 ); heightInMM = m_WorldGeometry->GetExtentInMM( 1 ); mmPerPixel[0] = widthInMM / extent[0]; mmPerPixel[1] = heightInMM / extent[1]; right.Normalize(); bottom.Normalize(); normal.Normalize(); //origin += right * ( mmPerPixel[0] * 0.5 ); //origin += bottom * ( mmPerPixel[1] * 0.5 ); //widthInMM -= mmPerPixel[0]; //heightInMM -= mmPerPixel[1]; // Use inverse transform of the input geometry for reslicing the 3D image m_Reslicer->SetResliceTransform( inputGeometry->GetVtkTransform()->GetLinearInverse() ); // Set background level to TRANSLUCENT (see Geometry2DDataVtkMapper3D) m_Reslicer->SetBackgroundLevel( -32768 ); // Check if a reference geometry does exist (as would usually be the case for // PlaneGeometry). // Note: this is currently not strictly required, but could facilitate // correct plane clipping. if ( m_WorldGeometry->GetReferenceGeometry() ) { // Calculate the actual bounds of the transformed plane clipped by the // dataset bounding box; this is required for drawing the texture at the // correct position during 3D mapping. boundsInitialized = this->CalculateClippedPlaneBounds( m_WorldGeometry->GetReferenceGeometry(), planeGeometry, bounds ); } } // Do we have an AbstractTransformGeometry? else if ( dynamic_cast< const AbstractTransformGeometry * >( m_WorldGeometry ) ) { const mitk::AbstractTransformGeometry* abstractGeometry = dynamic_cast< const AbstractTransformGeometry * >(m_WorldGeometry); extent[0] = abstractGeometry->GetParametricExtent(0); extent[1] = abstractGeometry->GetParametricExtent(1); widthInMM = abstractGeometry->GetParametricExtentInMM(0); heightInMM = abstractGeometry->GetParametricExtentInMM(1); mmPerPixel[0] = widthInMM / extent[0]; mmPerPixel[1] = heightInMM / extent[1]; origin = abstractGeometry->GetPlane()->GetOrigin(); right = abstractGeometry->GetPlane()->GetAxisVector(0); right.Normalize(); bottom = abstractGeometry->GetPlane()->GetAxisVector(1); bottom.Normalize(); normal = abstractGeometry->GetPlane()->GetNormal(); normal.Normalize(); // Use a combination of the InputGeometry *and* the possible non-rigid // AbstractTransformGeometry for reslicing the 3D Image vtkGeneralTransform *composedResliceTransform = vtkGeneralTransform::New(); composedResliceTransform->Identity(); composedResliceTransform->Concatenate( inputGeometry->GetVtkTransform()->GetLinearInverse() ); composedResliceTransform->Concatenate( abstractGeometry->GetVtkAbstractTransform() ); m_Reslicer->SetResliceTransform( composedResliceTransform ); // Set background level to BLACK instead of translucent, to avoid // boundary artifacts (see Geometry2DDataVtkMapper3D) m_Reslicer->SetBackgroundLevel( -1023 ); composedResliceTransform->Delete(); } else { itkWarningMacro(<<"World Geometry has to be a PlaneGeometry or an AbstractTransformGeometry."); return; } // Make sure that the image to be resliced has a certain minimum size. if ( (extent[0] <= 2) && (extent[1] <= 2) ) { itkWarningMacro(<<"Image is too small to be resliced..."); return; } vtkImageChangeInformation * unitSpacingImageFilter = vtkImageChangeInformation::New() ; unitSpacingImageFilter->SetOutputSpacing( 1.0, 1.0, 1.0 ); unitSpacingImageFilter->SetInput( inputData ); m_Reslicer->SetInput( unitSpacingImageFilter->GetOutput() ); unitSpacingImageFilter->Delete(); //m_Reslicer->SetInput( inputData ); m_Reslicer->SetOutputDimensionality( 2 ); m_Reslicer->SetOutputOrigin( 0.0, 0.0, 0.0 ); Vector2D pixelsPerMM; pixelsPerMM[0] = 1.0 / mmPerPixel[0]; pixelsPerMM[1] = 1.0 / mmPerPixel[1]; //calulate the originArray and the orientations for the reslice-filter double originArray[3]; itk2vtk( origin, originArray ); m_Reslicer->SetResliceAxesOrigin( originArray ); double cosines[9]; // direction of the X-axis of the sampled result vnl2vtk( right.GetVnlVector(), cosines ); // direction of the Y-axis of the sampled result vnl2vtk( bottom.GetVnlVector(), cosines + 3 ); // normal of the plane vnl2vtk( normal.GetVnlVector(), cosines + 6 ); m_Reslicer->SetResliceAxesDirectionCosines( cosines ); int xMin, xMax, yMin, yMax; if ( boundsInitialized ) { xMin = static_cast< int >( bounds[0] / mmPerPixel[0] );//+ 0.5 ); xMax = static_cast< int >( bounds[1] / mmPerPixel[0] );//+ 0.5 ); yMin = static_cast< int >( bounds[2] / mmPerPixel[1] );//+ 0.5); yMax = static_cast< int >( bounds[3] / mmPerPixel[1] );//+ 0.5 ); } else { // If no reference geometry is available, we also don't know about the // maximum plane size; so the overlap is just ignored xMin = yMin = 0; xMax = static_cast< int >( extent[0] - pixelsPerMM[0] );//+ 0.5 ); yMax = static_cast< int >( extent[1] - pixelsPerMM[1] );//+ 0.5 ); } m_Reslicer->SetOutputSpacing( mmPerPixel[0], mmPerPixel[1], 1.0 ); // xMax and yMax are meant exclusive until now, whereas // SetOutputExtent wants an inclusive bound. Thus, we need // to subtract 1. m_Reslicer->SetOutputExtent( xMin, xMax-1, yMin, yMax-1, 0, 1 ); // Do the reslicing. Modified() is called to make sure that the reslicer is // executed even though the input geometry information did not change; this // is necessary when the input /em data, but not the /em geometry changes. m_Reslicer->Modified(); m_Reslicer->ReleaseDataFlagOn(); m_Reslicer->Update(); // 1. Check the result vtkImageData* reslicedImage = m_Reslicer->GetOutput(); //mitkIpPicDescriptor *pic = Pic2vtk::convert( reslicedImage ); if((reslicedImage == NULL) || (reslicedImage->GetDataDimension() < 1)) { itkWarningMacro(<<"Reslicer returned empty image"); return; } unsigned int dimensions[2]; dimensions[0] = (unsigned int)extent[0]; dimensions[1] = (unsigned int)extent[1]; Vector3D spacingVector; FillVector3D(spacingVector, mmPerPixel[0], mmPerPixel[1], 1.0); mitk::Image::Pointer resultImage = this->GetOutput(); resultImage->Initialize(input->GetPixelType(), 2, dimensions ); //resultImage->Initialize( pic ); resultImage->SetSpacing( spacingVector ); //resultImage->SetPicVolume( pic ); //mitkIpPicFree(pic); /*unsigned int dimensions[2]; dimensions[0] = (unsigned int)extent[0]; dimensions[1] = (unsigned int)extent[1]; Vector3D spacingVector; FillVector3D(spacingVector, mmPerPixel[0], mmPerPixel[1], 1.0); mitk::Image::Pointer resultImage = this->GetOutput(); resultImage->Initialize(m_Reslicer->GetOutput()); resultImage->Initialize(inputImage->GetPixelType(), 2, dimensions); resultImage->SetSpacing(spacingVector); resultImage->SetSlice(m_Reslicer->GetOutput());*/ } void mitk::ExtractDirectedPlaneImageFilter::GenerateOutputInformation() { Superclass::GenerateOutputInformation(); } bool mitk::ExtractDirectedPlaneImageFilter ::CalculateClippedPlaneBounds( const Geometry3D *boundingGeometry, const PlaneGeometry *planeGeometry, vtkFloatingPointType *bounds ) { // Clip the plane with the bounding geometry. To do so, the corner points // of the bounding box are transformed by the inverse transformation // matrix, and the transformed bounding box edges derived therefrom are // clipped with the plane z=0. The resulting min/max values are taken as // bounds for the image reslicer. const BoundingBox *boundingBox = boundingGeometry->GetBoundingBox(); BoundingBox::PointType bbMin = boundingBox->GetMinimum(); BoundingBox::PointType bbMax = boundingBox->GetMaximum(); vtkPoints *points = vtkPoints::New(); if(boundingGeometry->GetImageGeometry()) { points->InsertPoint( 0, bbMin[0]-0.5, bbMin[1]-0.5, bbMin[2]-0.5 ); points->InsertPoint( 1, bbMin[0]-0.5, bbMin[1]-0.5, bbMax[2]-0.5 ); points->InsertPoint( 2, bbMin[0]-0.5, bbMax[1]-0.5, bbMax[2]-0.5 ); points->InsertPoint( 3, bbMin[0]-0.5, bbMax[1]-0.5, bbMin[2]-0.5 ); points->InsertPoint( 4, bbMax[0]-0.5, bbMin[1]-0.5, bbMin[2]-0.5 ); points->InsertPoint( 5, bbMax[0]-0.5, bbMin[1]-0.5, bbMax[2]-0.5 ); points->InsertPoint( 6, bbMax[0]-0.5, bbMax[1]-0.5, bbMax[2]-0.5 ); points->InsertPoint( 7, bbMax[0]-0.5, bbMax[1]-0.5, bbMin[2]-0.5 ); } else { points->InsertPoint( 0, bbMin[0], bbMin[1], bbMin[2] ); points->InsertPoint( 1, bbMin[0], bbMin[1], bbMax[2] ); points->InsertPoint( 2, bbMin[0], bbMax[1], bbMax[2] ); points->InsertPoint( 3, bbMin[0], bbMax[1], bbMin[2] ); points->InsertPoint( 4, bbMax[0], bbMin[1], bbMin[2] ); points->InsertPoint( 5, bbMax[0], bbMin[1], bbMax[2] ); points->InsertPoint( 6, bbMax[0], bbMax[1], bbMax[2] ); points->InsertPoint( 7, bbMax[0], bbMax[1], bbMin[2] ); } vtkPoints *newPoints = vtkPoints::New(); vtkTransform *transform = vtkTransform::New(); transform->Identity(); transform->Concatenate( planeGeometry->GetVtkTransform()->GetLinearInverse() ); transform->Concatenate( boundingGeometry->GetVtkTransform() ); transform->TransformPoints( points, newPoints ); transform->Delete(); bounds[0] = bounds[2] = 10000000.0; bounds[1] = bounds[3] = -10000000.0; bounds[4] = bounds[5] = 0.0; this->LineIntersectZero( newPoints, 0, 1, bounds ); this->LineIntersectZero( newPoints, 1, 2, bounds ); this->LineIntersectZero( newPoints, 2, 3, bounds ); this->LineIntersectZero( newPoints, 3, 0, bounds ); this->LineIntersectZero( newPoints, 0, 4, bounds ); this->LineIntersectZero( newPoints, 1, 5, bounds ); this->LineIntersectZero( newPoints, 2, 6, bounds ); this->LineIntersectZero( newPoints, 3, 7, bounds ); this->LineIntersectZero( newPoints, 4, 5, bounds ); this->LineIntersectZero( newPoints, 5, 6, bounds ); this->LineIntersectZero( newPoints, 6, 7, bounds ); this->LineIntersectZero( newPoints, 7, 4, bounds ); // clean up vtk data points->Delete(); newPoints->Delete(); if ( (bounds[0] > 9999999.0) || (bounds[2] > 9999999.0) || (bounds[1] < -9999999.0) || (bounds[3] < -9999999.0) ) { return false; } else { // The resulting bounds must be adjusted by the plane spacing, since we // we have so far dealt with index coordinates const float *planeSpacing = planeGeometry->GetFloatSpacing(); bounds[0] *= planeSpacing[0]; bounds[1] *= planeSpacing[0]; bounds[2] *= planeSpacing[1]; bounds[3] *= planeSpacing[1]; bounds[4] *= planeSpacing[2]; bounds[5] *= planeSpacing[2]; return true; } } bool mitk::ExtractDirectedPlaneImageFilter ::LineIntersectZero( vtkPoints *points, int p1, int p2, vtkFloatingPointType *bounds ) { vtkFloatingPointType point1[3]; vtkFloatingPointType point2[3]; points->GetPoint( p1, point1 ); points->GetPoint( p2, point2 ); if ( (point1[2] * point2[2] <= 0.0) && (point1[2] != point2[2]) ) { double x, y; x = ( point1[0] * point2[2] - point1[2] * point2[0] ) / ( point2[2] - point1[2] ); y = ( point1[1] * point2[2] - point1[2] * point2[1] ) / ( point2[2] - point1[2] ); if ( x < bounds[0] ) { bounds[0] = x; } if ( x > bounds[1] ) { bounds[1] = x; } if ( y < bounds[2] ) { bounds[2] = y; } if ( y > bounds[3] ) { bounds[3] = y; } bounds[4] = bounds[5] = 0.0; return true; } return false; } diff --git a/Modules/MitkExt/CMakeLists.txt b/Modules/MitkExt/CMakeLists.txt index 6a6a06c49d..d646f62a0e 100644 --- a/Modules/MitkExt/CMakeLists.txt +++ b/Modules/MitkExt/CMakeLists.txt @@ -1,28 +1,29 @@ #if(WIN32) # option(MITK_USE_TD_MOUSE "Enable support for 3D Connexion SpaceNavigator" OFF) #endif(WIN32) configure_file(${PROJECT_SOURCE_DIR}/CMake/ToolExtensionITKFactory.cpp.in ${PROJECT_BINARY_DIR}/ToolExtensionITKFactory.cpp.in COPYONLY) configure_file(${PROJECT_SOURCE_DIR}/CMake/ToolExtensionITKFactoryLoader.cpp.in ${PROJECT_BINARY_DIR}/ToolExtensionITKFactoryLoader.cpp.in COPYONLY) configure_file(${PROJECT_SOURCE_DIR}/CMake/ToolGUIExtensionITKFactory.cpp.in ${PROJECT_BINARY_DIR}/ToolGUIExtensionITKFactory.cpp.in COPYONLY) MITK_CREATE_MODULE( MitkExt INCLUDE_DIRS Algorithms Controllers DataManagement Interactions IO Rendering DEPENDS Mitk LegacyAdaptors IpPicSupport ipSegmentation mitkIpFunc PlanarFigure ImageStatistics - DEPENDS_INTERNAL pic2vtk ) # this is needed for libraries which link to mitkCoreExt and need # symbols from explicitly instantiated templates like # mitk::UnstructuredGridVtkWriter which is referenced in # mitk::UnstructuredGridVtkWriterTest in the MitkExtTestDriver executable. if(MINGW) get_target_property(_mitkCoreExt_MINGW_linkflags mitkCoreExt LINK_FLAGS) if(NOT _mitkCoreExt_MINGW_linkflags) set(_mitkCoreExt_MINGW_linkflags "") endif(NOT _mitkCoreExt_MINGW_linkflags) set_target_properties(mitkCoreExt PROPERTIES LINK_FLAGS "${_mitkCoreExt_MINGW_linkflags} -Wl,--export-all-symbols") endif(MINGW) -add_subdirectory(Testing) +if(BUILD_TESTING) + add_subdirectory(Testing) +endif() diff --git a/Modules/MitkExt/DataManagement/mitkVecmathHelper.h b/Modules/MitkExt/DataManagement/mitkVecmathHelper.h deleted file mode 100644 index 9ba502e370..0000000000 --- a/Modules/MitkExt/DataManagement/mitkVecmathHelper.h +++ /dev/null @@ -1,100 +0,0 @@ -/*=================================================================== - -The Medical Imaging Interaction Toolkit (MITK) - -Copyright (c) German Cancer Research Center, -Division of Medical and Biological Informatics. -All rights reserved. - -This software is distributed WITHOUT ANY WARRANTY; without -even the implied warranty of MERCHANTABILITY or FITNESS FOR -A PARTICULAR PURPOSE. - -See LICENSE.txt or http://www.mitk.org for details. - -===================================================================*/ - - -#ifndef MITKVECHELPER_H_HEADER_INCLUDED_C1EBD0AD -#define MITKVECHELPER_H_HEADER_INCLUDED_C1EBD0AD - -#include "mitkVector.h" -#include "vecmath.h" - -namespace mitk { - -//itk vs. vecmath conversion -template - inline void vm2itk(const Point3& p, Point3D& a) -{ - a[0]=p.x; - a[1]=p.y; - a[2]=p.z; -} - -template - inline void itk2vm(const Point3D& a, Point3 & p) -{ - p.set(a[0], a[1], a[2]); -} - -template - inline void vm2itk(const Vector3& p, Vector3D& a) -{ - a[0]=p.x; - a[1]=p.y; - a[2]=p.z; -} - -template - inline void itk2vm(const Vector3D& a, Vector3 & p) -{ - p.set(a[0], a[1], a[2]); -} - -template - inline void vm2itk(const Vector3& p, VnlVector& a) -{ - a[0]=p.x; - a[1]=p.y; - a[2]=p.z; -} - -template - inline void itk2vm(const VnlVector& a, Vector3 & p) -{ - p.set(a[0], a[1], a[2]); -} - -template - inline void vtk2vm(const Tin a[3], Vector3 & p) -{ - p.set(a[0], a[1], a[2]); -} - -template - inline void vm2vtk(const Vector3 & p, Tout a[3]) -{ - a[0]=p.x; - a[1]=p.y; - a[2]=p.z; -} - -template - inline void vtk2vm(const Tin a[3], Point3 & p) -{ - p.set(a[0], a[1], a[2]); -} - -template - inline void vm2vtk(const Point3 & p, Tout a[3]) -{ - a[0]=p.x; - a[1]=p.y; - a[2]=p.z; -} - -} // namespace mitk - - -#endif /* MITKVECHELPER */ diff --git a/Modules/MitkExt/Testing/CMakeLists.txt b/Modules/MitkExt/Testing/CMakeLists.txt index 9874b913ef..014497799f 100644 --- a/Modules/MitkExt/Testing/CMakeLists.txt +++ b/Modules/MitkExt/Testing/CMakeLists.txt @@ -1,8 +1,6 @@ MITK_CREATE_MODULE_TESTS(EXTRA_DRIVER_INIT "RegisterCoreExtObjectFactory();;" EXTRA_DRIVER_INCLUDE "mitkCoreExtObjectFactory.h") -if(BUILD_TESTING AND MODULE_IS_ENABLED) mitkAddCustomModuleTest(mitkLabeledImageToSurfaceFilterTest_BinaryBall mitkLabeledImageToSurfaceFilterTest ${MITK_DATA_DIR}/BallBinary30x30x30.pic.gz) mitkAddCustomModuleTest(mitkImageToSurfaceFilterTest_BinaryBall mitkImageToSurfaceFilterTest ${MITK_DATA_DIR}/BallBinary30x30x30.nrrd) -endif() diff --git a/Utilities/CMakeLists.txt b/Utilities/CMakeLists.txt index 8da20aafcb..6959f35dc6 100644 --- a/Utilities/CMakeLists.txt +++ b/Utilities/CMakeLists.txt @@ -1,45 +1,43 @@ SUPPRESS_ALL_WARNINGS() # most stuff of these uses itk_zlib.h (via mitkIpPic.h) find_package(ITK) include(${ITK_USE_FILE}) # some legacy util files include in the old style with prefixed directory, # like #include include_directories(.) subdirs( ipPic ipFunc ipSegmentation - pic2vtk tinyxml Poco qwt qxt mbilog glew - vecmath qtsingleapplication KWStyle ) # mbilog is independent of mitk, and cant use mitk macros # configuring happens through mbilog/mbilogConfig.cmake.in set(mbilog_INCLUDE_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/mbilog" "${CMAKE_CURRENT_BINARY_DIR}/mbilog") set(mbilog_CONFIG_FILE "${PROJECT_BINARY_DIR}/${MODULES_CONF_DIRNAME}/mbilogConfig.cmake" CACHE INTERNAL "Path to module config" FORCE) configure_file("${CMAKE_CURRENT_SOURCE_DIR}/mbilog/mbilogConfig.cmake.in" "${mbilog_CONFIG_FILE}") set(Poco_INCLUDE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/Poco CACHE PATH "top-level directory containing the poco include directories. E.g /usr/local/include/ or c:\\poco\\include\\poco-1.3.2" ) set(Poco_LIBRARY_DIR ${CMAKE_LIBRARY_OUTPUT_DIRECTORY} CACHE PATH "top-level directory containing the poco libraries." ) diff --git a/Utilities/pic2vtk/CMakeLists.txt b/Utilities/pic2vtk/CMakeLists.txt deleted file mode 100644 index a86e67f69c..0000000000 --- a/Utilities/pic2vtk/CMakeLists.txt +++ /dev/null @@ -1,11 +0,0 @@ -find_package(VTK) -include(${VTK_USE_FILE}) - -include_directories(.. ../ipPic) -add_library(pic2vtk ${MITK_WIN32_FORCE_STATIC} pic2vtk.cpp) -target_link_libraries(pic2vtk mitkIpPic vtkIO) - -MITK_CREATE_MODULE_CONF(pic2vtk - DEPENDS mitkIpPic -) - diff --git a/Utilities/pic2vtk/pic2vtk.cpp b/Utilities/pic2vtk/pic2vtk.cpp deleted file mode 100644 index ae87b61efb..0000000000 --- a/Utilities/pic2vtk/pic2vtk.cpp +++ /dev/null @@ -1,1355 +0,0 @@ -#include -#include -#include -#include -#include -#include - -/** - * konvertiert ein vtkImageReader in ein pic-Image - */ -mitkIpPicDescriptor* Pic2vtk::convert( vtkImageData* vtkImage ) { - - if ( vtkImage == NULL ) - return NULL; - - mitkIpPicDescriptor* pic = mitkIpPicNew(); - - if ( pic == NULL ) - return NULL; - - int dim[3]; - vtkImage->GetDimensions(dim); - - if ( dim[2] > 1 ) { - pic->dim = 3; - } else if( dim[1] > 1 ) { - pic->dim = 2; - } else if ( dim[0] > 1 ) { - pic->dim = 1; - } else { - return NULL; - } - - pic->n[0] = dim[0]; - pic->n[1] = dim[1]; - pic->n[2] = dim[2]; - - register unsigned long size = dim[0] * dim[1] * dim[2] * vtkImage->GetNumberOfScalarComponents(); - - switch ( vtkImage->GetScalarType () ) { - - case VTK_BIT: { - - pic->type = mitkIpPicInt; - pic->bpe = 8; - unsigned int vtkSize = size>>3; - - if (vtkSize%8) - vtkSize++; - - register char *s = (char*) vtkImage->GetScalarPointer(); - register char *a = (char*) malloc(sizeof(char)* size); - if(a==NULL) - { - mitkIpPicFree( pic ); - return NULL; - } - pic->data = a; - - for ( register unsigned int i = 0; i < vtkSize; i++ ) { - - for ( int k=0; k < 8; k++ ) - *a++ = 0x80 & (*s<type = mitkIpPicInt; - pic->bpe = 8*vtkImage->GetNumberOfScalarComponents(); - - register char *s = (char*) vtkImage->GetScalarPointer(); - register char *a = (char*) malloc(sizeof(char)* size); - if(a==NULL) - { - mitkIpPicFree( pic ); - return NULL; - } - pic->data = a; - - for ( unsigned long i = 0; i < size; i++ ) - *a++ = *s++; - - break; - } - case VTK_UNSIGNED_CHAR: { - - pic->type = mitkIpPicUInt; - pic->bpe = 8*vtkImage->GetNumberOfScalarComponents(); - - register unsigned char *s = (unsigned char*) vtkImage->GetScalarPointer(); - register unsigned char *a = (unsigned char*) malloc(sizeof(unsigned char)* size); - if(a==NULL) - { - mitkIpPicFree( pic ); - return NULL; - } - pic->data = a; - - for ( unsigned long i = 0; i < size; i++ ) - *a++ = *s++; - - break; - } - case VTK_SHORT: { - - pic->type = mitkIpPicInt; - pic->bpe = 16; - - register short *s = (short*) vtkImage->GetScalarPointer(); - register short *a = (short*) malloc(sizeof(short)* size); - if(a==NULL) - { - mitkIpPicFree( pic ); - return NULL; - } - pic->data = a; - - for ( unsigned long i = 0; i < size; i++ ) - *a++ = *s++; - - break; - } - case VTK_UNSIGNED_SHORT: { - - pic->type = mitkIpPicUInt; - pic->bpe = 16; - - register unsigned short *s = (unsigned short*) vtkImage->GetScalarPointer(); - register unsigned short *a = (unsigned short*) malloc(sizeof(unsigned short)* size); - if(a==NULL) - { - mitkIpPicFree( pic ); - return NULL; - } - pic->data = a; - - - for ( unsigned long i = 0; i < size; i++ ) - *a++ = *s++; - - break; - } - case VTK_INT: { - - pic->type = mitkIpPicInt; - pic->bpe = 32; - - register int *s = (int*) vtkImage->GetScalarPointer(); - register int *a = (int*) malloc(sizeof(int)* size); - if(a==NULL) - { - mitkIpPicFree( pic ); - return NULL; - } - pic->data = a; - - for ( unsigned long i = 0; i < size; i++ ) - *a++ = *s++; - - break; - } - case VTK_UNSIGNED_INT: { - - pic->type = mitkIpPicUInt; - pic->bpe = 32; - - register unsigned int *s = (unsigned int*) vtkImage->GetScalarPointer(); - register unsigned int *a = (unsigned int*) malloc(sizeof(unsigned int)* size); - if(a==NULL) - { - mitkIpPicFree( pic ); - return NULL; - } - pic->data = a; - - for ( unsigned long i = 0; i < size; i++ ) - *a++ = *s++; - - break; - } - case VTK_LONG: { - - pic->type = mitkIpPicInt; - pic->bpe = 64; - - register long *s = (long*) vtkImage->GetScalarPointer(); - register long *a = (long*) malloc(sizeof(long)* size); - if(a==NULL) - { - mitkIpPicFree( pic ); - return NULL; - } - pic->data = a; - - for ( unsigned long i = 0; i < size; i++ ) - *a++ = *s++; - - break; - } - case VTK_UNSIGNED_LONG: { - - pic->type = mitkIpPicUInt; - pic->bpe = 64; - - register unsigned long *s = (unsigned long*) vtkImage->GetScalarPointer(); - register unsigned long *a = (unsigned long*) malloc(sizeof(unsigned long)* size); - if(a==NULL) - { - mitkIpPicFree( pic ); - return NULL; - } - pic->data = a; - - for ( unsigned long i = 0; i < size; i++ ) - *a++ = *s++; - - break; - } - case VTK_FLOAT: { - - pic->type = mitkIpPicFloat; - pic->bpe = 32; - - register float *s = (float*) vtkImage->GetScalarPointer(); - register float *a = (float*) malloc(sizeof(float)* size); - if(a==NULL) - { - mitkIpPicFree( pic ); - return NULL; - } - pic->data = a; - - for ( unsigned long i = 0; i < size; i++ ) - *a++ = *s++; - - break; - } - case VTK_DOUBLE: { - - pic->type = mitkIpPicFloat; - pic->bpe = 64; - - register double *s = (double*) vtkImage->GetScalarPointer(); - register double *a = (double*) malloc(sizeof(double)* size); - if(a==NULL) - { - mitkIpPicFree( pic ); - return NULL; - } - pic->data = a; - - - for ( unsigned long i = 0; i < size; i++ ) - *a++ = *s++; - - break; - } - default: - mitkIpPicFree( pic ); - return NULL; - } - - return pic; -} - - - - -/** - * konvertiert ein vektorwertiges vtkImageData in ein vector pic-Image - */ -mitkIpPicDescriptor* Pic2vtk::convertVectorImage( vtkImageData* vtkImage ) { - - std::cout << "Pic2vtk::convertVectorImage()... converting vector vtkImage to vector pic image" << std::endl; - - if ( vtkImage == NULL ) - return NULL; - - std::cout << " vtk dimension: " << vtkImage->GetDataDimension() << std::endl; - std::cout << " vtk vector dim = " << vtkImage->GetNumberOfScalarComponents() << std::endl; - - mitkIpPicDescriptor* pic = mitkIpPicNew(); - - if ( pic == NULL ) - return NULL; - - - int dim[3]; - vtkImage->GetDimensions(dim); - - unsigned int vectorDim = vtkImage->GetNumberOfScalarComponents(); - - unsigned long size = 0; - unsigned long volumeSize = 0; - - if ( dim[2] > 1 ) { - pic->dim = 3 + 1; - - pic->n[0] = dim[0]; - pic->n[1] = dim[1]; - pic->n[2] = dim[2]; - pic->n[3] = vectorDim; - - volumeSize = dim[0] * dim[1] * dim[2]; - size = volumeSize * vectorDim; - - - } else if( dim[1] > 1 ) { - pic->dim = 2 + 1; - - pic->n[0] = dim[0]; - pic->n[1] = dim[1]; - pic->n[2] = vectorDim; - - volumeSize = dim[0] * dim[1]; - size = volumeSize * vectorDim; - - - } else if ( dim[1] > 1 ) { - pic->dim = 1 + 1; - - pic->n[0] = dim[0]; - pic->n[1] = vectorDim; - - volumeSize = dim[0]; - size = volumeSize * vectorDim; - - } - - - - switch ( vtkImage->GetScalarType () ) { - - case VTK_BIT: { - - - std::cout << "WARNING: VTK_BIT vector images not supported yet ... " << std::endl; - -// pic->type = mitkIpPicInt; -// pic->bpe = 8; -// unsigned int vtkSize = size>>3; -// -// if (vtkSize%8) -// vtkSize++; -// -// register unsigned char *s = (unsigned char*) vtkImage->GetScalarPointer(); -// register unsigned char *a = new unsigned char[size]; -// pic->data = a; -// -// for ( register unsigned int i = 0; i < vtkSize; i++ ) { -// -// for ( int k=0; k < 8; k++ ) -// *a++ = 0x80 & (*s<type = mitkIpPicInt; - pic->bpe = 8; - - register char *s = (char*) vtkImage->GetScalarPointer(); - register char *a = (char*) malloc(sizeof(char)* size);; - pic->data = a; - -#define COPYVECTORDATAVTK2PIC \ - for ( unsigned long i = 0; i < volumeSize; i++ ) \ - { \ - for ( unsigned int j = 0; jtype = mitkIpPicUInt; - pic->bpe = 8; - - register unsigned char *s = (unsigned char*) vtkImage->GetScalarPointer(); - register unsigned char *a = (unsigned char*) malloc(sizeof(unsigned char)* size);; - pic->data = a; - - COPYVECTORDATAVTK2PIC - - break; - } - case VTK_SHORT: { - - pic->type = mitkIpPicInt; - pic->bpe = 16; - - register short *s = (short*) vtkImage->GetScalarPointer(); - register short *a = (short*) malloc(sizeof(short)* size); - pic->data = a; - - COPYVECTORDATAVTK2PIC - - break; - } - case VTK_UNSIGNED_SHORT: { - - pic->type = mitkIpPicUInt; - pic->bpe = 16; - - register unsigned short *s = (unsigned short*) vtkImage->GetScalarPointer(); - register unsigned short *a = (unsigned short*) malloc(sizeof(unsigned short)* size); - pic->data = a; - - - COPYVECTORDATAVTK2PIC - - break; - } - case VTK_INT: { - - pic->type = mitkIpPicInt; - pic->bpe = 32; - - register int *s = (int*) vtkImage->GetScalarPointer(); - register int *a = (int*) malloc(sizeof(int)* size); - pic->data = a; - - COPYVECTORDATAVTK2PIC - - break; - } - case VTK_UNSIGNED_INT: { - - pic->type = mitkIpPicUInt; - pic->bpe = 32; - - register unsigned int *s = (unsigned int*) vtkImage->GetScalarPointer(); - register unsigned int *a = (unsigned int*) malloc(sizeof(unsigned int)* size); - pic->data = a; - - COPYVECTORDATAVTK2PIC - - break; - } - case VTK_LONG: { - - pic->type = mitkIpPicInt; - pic->bpe = 64; - - register long *s = (long*) vtkImage->GetScalarPointer(); - register long *a = (long*) malloc(sizeof(long)* size); - pic->data = a; - - COPYVECTORDATAVTK2PIC - - break; - } - case VTK_UNSIGNED_LONG: { - - pic->type = mitkIpPicUInt; - pic->bpe = 64; - - register unsigned long *s = (unsigned long*) vtkImage->GetScalarPointer(); - register unsigned long *a = (unsigned long*) malloc(sizeof(unsigned long)* size); - pic->data = a; - - COPYVECTORDATAVTK2PIC - - break; - } - case VTK_FLOAT: { - - pic->type = mitkIpPicFloat; - pic->bpe = 32; - - register float *s = (float*) vtkImage->GetScalarPointer(); - register float *a = (float*) malloc(sizeof(float)* size); - pic->data = a; - - COPYVECTORDATAVTK2PIC - - break; - } - case VTK_DOUBLE: { - - pic->type = mitkIpPicFloat; - pic->bpe = 64; - - register double *s = (double*) vtkImage->GetScalarPointer(); - register double *a = (double*) malloc(sizeof(double)* size); - pic->data = a; - - COPYVECTORDATAVTK2PIC - - break; - } - default: - mitkIpPicFree( pic ); - return NULL; - } - - // add tag tp result pic - mitkIpPicTSV_t *tsv; - tsv = (mitkIpPicTSV_t *) malloc( sizeof(mitkIpPicTSV_t) ); - strcpy( tsv->tag, "VectorValued" ); - tsv->type = mitkIpPicASCII; - tsv->bpe = 8; - tsv->dim = 1; - tsv->value = strdup( "." ); - tsv->n[0] = strlen((char *) tsv->value); - mitkIpPicAddTag( pic, tsv ); - - return pic; -} - - - -/** - * konvertiert ein pic-Image in ein vtkImageReader - */ -vtkImageData* Pic2vtk::convert( mitkIpPicDescriptor* pic ) { - - if ( pic == NULL ) - return NULL; - - - vtkImageData *inData = vtkImageData::New(); - - if ( inData == NULL ) - return NULL; - - unsigned long size = 0; - - if ( pic->dim == 1 ) { - inData->SetDimensions( pic->n[0] -1, 1, 1); - size = pic->n[0]; - inData->SetOrigin( ((float) pic->n[0]) / 2.0f, 0, 0 ); - } else if ( pic->dim == 2 ) { - inData->SetDimensions( pic->n[0] , pic->n[1] , 1 ); - size = pic->n[0] * pic->n[1]; - inData->SetOrigin( ((float) pic->n[0]) / 2.0f, ((float) pic->n[1]) / 2.0f, 0 ); - } else if ( pic->dim >= 3 ) { - inData->SetDimensions( pic->n[0], pic->n[1], pic->n[2] ); - size = pic->n[0] * pic->n[1] * pic->n[2]; - // Test - //inData->SetOrigin( (float) pic->n[0] / 2.0f, (float) pic->n[1] / 2.0f, (float) pic->n[2] / 2.0f ); - inData->SetOrigin( 0, 0, 0 ); - } else { - inData->Delete () ; - return NULL; - } - - inData->SetNumberOfScalarComponents(1); - - - if ( ( pic->type == mitkIpPicInt || pic->type == mitkIpPicUInt ) && pic->bpe == 1 ) { - inData->SetScalarType( VTK_BIT ); - inData->AllocateScalars(); - size = size>>3; - register unsigned char* s = (unsigned char*) pic->data; - register unsigned char* a = (unsigned char*) inData->GetScalarPointer(); - - for ( register unsigned long i = 0; i < size ; i++ ) - *a++ = *s++; - - } else if ( pic->type == mitkIpPicInt && pic->bpe == 8 ) { - inData->SetScalarType( VTK_CHAR ); - inData->AllocateScalars(); - - register char* s = (char*) pic->data; - register char* a = (char*) inData->GetScalarPointer(); - - for ( register unsigned long i = 0; i < size ; i++ ) - *a++ = *s++; - - } else if ( pic->type == mitkIpPicUInt && pic->bpe == 8 ) { - inData->SetScalarType( VTK_UNSIGNED_CHAR ); - inData->AllocateScalars(); - - register unsigned char* s = (unsigned char*) pic->data; - register unsigned char* a = (unsigned char*) inData->GetScalarPointer(); - - for ( register unsigned long i = 0; i < size ; i++ ) - *a++ = *s++; - - - } else if ( pic->type == mitkIpPicUInt && pic->bpe == 24 ) { - inData->SetNumberOfScalarComponents(3); - inData->SetScalarType( VTK_UNSIGNED_CHAR ); - inData->AllocateScalars(); - - register unsigned char* s = (unsigned char*) pic->data; - register unsigned char* a = (unsigned char*) inData->GetScalarPointer(); - - for ( register unsigned long i = 0; i < size*3 ; i++ ) - *a++ = *s++; - - - } else if ( pic->type == mitkIpPicInt && pic->bpe == 16 ) { - inData->SetScalarType( VTK_SHORT ); - inData->AllocateScalars(); - - register short* s = (short*) pic->data; - register short* a = (short*) inData->GetScalarPointer(); - - for ( register unsigned long i = 0; i < size ; i++ ) - *a++ = *s++; - - } else if ( pic->type == mitkIpPicUInt && pic->bpe == 16 ) { - inData->SetScalarType( VTK_UNSIGNED_SHORT ); - inData->AllocateScalars(); - - register unsigned short* s = (unsigned short*) pic->data; - register unsigned short* a = (unsigned short*) inData->GetScalarPointer(); - - for ( register unsigned long i = 0; i < size ; i++ ) - *a++ = *s++; - - } else if ( pic->type == mitkIpPicInt && pic->bpe == 32 ) { - inData->SetScalarType( VTK_INT ); - inData->AllocateScalars(); - - register int* s = (int*) pic->data; - register int* a = (int*) inData->GetScalarPointer(); - - for ( register unsigned long i = 0; i < size ; i++ ) - *a++ = *s++; - - } else if ( pic->type == mitkIpPicUInt && pic->bpe == 32 ) { - inData->SetScalarType( VTK_UNSIGNED_INT ); - inData->AllocateScalars(); - - register unsigned int* s = (unsigned int*) pic->data; - register unsigned int* a = (unsigned int*) inData->GetScalarPointer(); - - for ( register unsigned long i = 0; i < size ; i++ ) - *a++ = *s++; - - } else if ( pic->type == mitkIpPicInt && pic->bpe == 64 ) { - inData->SetScalarType( VTK_LONG ); - inData->AllocateScalars(); - - register long* s = (long*) pic->data; - register long* a = (long*) inData->GetScalarPointer(); - - for ( register unsigned long i = 0; i < size ; i++ ) - *a++ = *s++; - - } else if ( pic->type == mitkIpPicUInt && pic->bpe == 64 ) { - inData->SetScalarType( VTK_UNSIGNED_LONG ); - inData->AllocateScalars(); - - register unsigned long* s = (unsigned long*) pic->data; - register unsigned long* a = (unsigned long*) inData->GetScalarPointer(); - - for ( register unsigned long i = 0; i < size ; i++ ) - *a++ = *s++; - - } else if ( pic->type == mitkIpPicFloat && pic->bpe == 32 ) { - inData->SetScalarType( VTK_FLOAT ); - inData->AllocateScalars(); - - register float* s = (float*) pic->data; - register float* a = (float*) inData->GetScalarPointer(); - - for ( register unsigned long i = 0; i < size ; i++ ) - *a++ = *s++; - - } else if ( pic->type == mitkIpPicFloat && pic->bpe == 64 ) { - inData->SetScalarType( VTK_DOUBLE ); - inData->AllocateScalars(); - - register double* s = (double*) pic->data; - register double* a = (double*) inData->GetScalarPointer(); - - for ( register unsigned long i = 0; i < size ; i++ ) - *a++ = *s++; - - } else { - inData->Delete(); - return NULL; - } - - return inData; -} - - -/** - * konvertiert ein vector pic-Image in ein vector vtkImageData - */ -vtkImageData* Pic2vtk::convertVectorImage( mitkIpPicDescriptor* pic ) { - - std::cout << "Pic2vtk::convertVectorImage()... converting vector pic image to vector vtkImage " << std::endl; - - if ( pic == NULL ) - return NULL; - - - vtkImageData *inData = vtkImageData::New(); - - if ( inData == NULL ) - return NULL; - - unsigned long size = 0; - unsigned long volumeSize = 0; - - int dim = pic->dim - 1; - unsigned int vectorDim = pic->n[dim]; - - std::cout << " pic dimension = " << dim << std::endl; - std::cout << " pic vector dim = " << vectorDim << std::endl; - - - if ( dim == 1 ) { - inData->SetDimensions( pic->n[0] -1, 1, 1); - volumeSize = pic->n[0]; - size = volumeSize * vectorDim; - inData->SetOrigin( ((float) pic->n[0]) / 2.0f, 0, 0 ); - } else if ( dim == 2 ) { - inData->SetDimensions( pic->n[0] , pic->n[1] , 1 ); - volumeSize = pic->n[0]* pic->n[1]; - size = volumeSize * vectorDim; - //inData->SetOrigin( ((float) pic->n[0]) / 2.0f, ((float) pic->n[1]) / 2.0f, 0 ); - inData->SetOrigin( 0,0, 0 ); - } else if ( dim >= 3 ) { - inData->SetDimensions( pic->n[0], pic->n[1], pic->n[2] ); - volumeSize = pic->n[0]* pic->n[1]* pic->n[2]; - size = volumeSize * vectorDim; - inData->SetOrigin( 0, 0, 0 ); - } else { - inData->Delete () ; - return NULL; - } - -// std::cout << " size = " << size << std::endl; -// std::cout << " volumeSize = " << volumeSize << std::endl; - - //inData->SetNumberOfScalarComponents(vectorDim); - inData->SetNumberOfScalarComponents(3); - - if ( ( pic->type == mitkIpPicInt || pic->type == mitkIpPicUInt ) && pic->bpe == 1 ) { - inData->SetScalarType( VTK_BIT ); - inData->AllocateScalars(); - size = size>>3; - - std::cout << "WARNING: 1 bit vector not supported yet ..." << std::endl; -// register unsigned char* s = (unsigned char*) pic->data; -// register unsigned char* a = (unsigned char*) inData->GetScalarPointer(); -// -// for ( register unsigned long i = 0; i < size ; i++ ) -// for ( register unsigned int j = 0; jtype == mitkIpPicInt && pic->bpe == 8 ) { - inData->SetScalarType( VTK_CHAR ); - inData->AllocateScalars(); - - register char* s = (char*) pic->data; - register char* a = (char*) inData->GetScalarPointer(); - -#define COPYVECTORDATAPIC2VTK \ - for ( register unsigned long i = 0; i < volumeSize ; i++ ) \ - { \ - for ( register unsigned int j = 0; j<3; j++) \ - { \ - if (jtype == mitkIpPicUInt && pic->bpe == 8 ) { - inData->SetScalarType( VTK_UNSIGNED_CHAR ); - inData->AllocateScalars(); - - register unsigned char* s = (unsigned char*) pic->data; - register unsigned char* a = (unsigned char*) inData->GetScalarPointer(); - - COPYVECTORDATAPIC2VTK - - } else if ( pic->type == mitkIpPicInt && pic->bpe == 16 ) { - inData->SetScalarType( VTK_SHORT ); - inData->AllocateScalars(); - - register short* s = (short*) pic->data; - register short* a = (short*) inData->GetScalarPointer(); - - COPYVECTORDATAPIC2VTK - - } else if ( pic->type == mitkIpPicUInt && pic->bpe == 16 ) { - inData->SetScalarType( VTK_UNSIGNED_SHORT ); - inData->AllocateScalars(); - std::cout << " memory = " << inData->GetActualMemorySize() << std::endl; - fflush(stdout); - - register unsigned short* s = (unsigned short*) pic->data; - register unsigned short* a = (unsigned short*) inData->GetScalarPointer(); - - COPYVECTORDATAPIC2VTK - - - - } else if ( pic->type == mitkIpPicInt && pic->bpe == 32 ) { - inData->SetScalarType( VTK_INT ); - inData->AllocateScalars(); - - register int* s = (int*) pic->data; - register int* a = (int*) inData->GetScalarPointer(); - - COPYVECTORDATAPIC2VTK - - } else if ( pic->type == mitkIpPicUInt && pic->bpe == 32 ) { - inData->SetScalarType( VTK_UNSIGNED_INT ); - inData->AllocateScalars(); - - register unsigned int* s = (unsigned int*) pic->data; - register unsigned int* a = (unsigned int*) inData->GetScalarPointer(); - - COPYVECTORDATAPIC2VTK - - } else if ( pic->type == mitkIpPicInt && pic->bpe == 64 ) { - inData->SetScalarType( VTK_LONG ); - inData->AllocateScalars(); - - register long* s = (long*) pic->data; - register long* a = (long*) inData->GetScalarPointer(); - - COPYVECTORDATAPIC2VTK - - } else if ( pic->type == mitkIpPicUInt && pic->bpe == 64 ) { - inData->SetScalarType( VTK_UNSIGNED_LONG ); - inData->AllocateScalars(); - - register unsigned long* s = (unsigned long*) pic->data; - register unsigned long* a = (unsigned long*) inData->GetScalarPointer(); - - COPYVECTORDATAPIC2VTK - - } else if ( pic->type == mitkIpPicFloat && pic->bpe == 32 ) { - inData->SetScalarType( VTK_FLOAT ); - inData->AllocateScalars(); - - register float* s = (float*) pic->data; - register float* a = (float*) inData->GetScalarPointer(); - - COPYVECTORDATAPIC2VTK - } else if ( pic->type == mitkIpPicFloat && pic->bpe == 64 ) { - inData->SetScalarType( VTK_DOUBLE ); - inData->AllocateScalars(); - - register double* s = (double*) pic->data; - register double* a = (double*) inData->GetScalarPointer(); - - COPYVECTORDATAPIC2VTK - - } else { - inData->Delete(); - return NULL; - } - - - return inData; -} - -/** - * läd ein unkomprimiertes pic file - */ -vtkImageData* Pic2vtk::loadImage( char* fileName, bool littleEndian ) { - - if ( fileName == NULL ) - return NULL; - - mitkIpPicDescriptor* pic = mitkIpPicGetHeader( fileName, NULL ); - - if ( pic == NULL ) - return NULL; - - if ( pic->info->pixel_start_in_file == 0 ) { - // komprimierte Date - - mitkIpPicFree( pic ); - pic = NULL; - - pic = mitkIpPicGet( fileName, NULL ); - - if ( pic == NULL ) - return NULL; - - vtkImageData* vtkImage = convert( pic ); - mitkIpPicFree( pic ); - return vtkImage; - } - - vtkImageReader *reader = vtkImageReader::New(); - - if ( reader == NULL ) - return NULL; - - reader->ReleaseDataFlagOff(); - - if ( littleEndian == true ) - reader->SetDataByteOrderToLittleEndian(); - else - reader->SetDataByteOrderToBigEndian(); - - if ( pic->dim == 1 ) { - reader->SetFileDimensionality(1); - reader->SetDataExtent ( 0, pic->n[0] -1, 0, 0, 0, 0); - reader->SetDataOrigin( ((float) pic->n[0]) / 2.0f, 0, 0 ); - } else if ( pic->dim == 2 ) { - reader->SetFileDimensionality(2); - reader->SetDataExtent ( 0, pic->n[0] -1, 0, pic->n[1] -1, 0, 0); - reader->SetDataOrigin( ((float) pic->n[0]) / 2.0f, ((float) pic->n[1]) / 2.0f, 0 ); - } else if ( pic->dim >= 3 ) { - reader->SetFileDimensionality(3); - reader->SetDataOrigin( (float) pic->n[0] / 2.0f, (float) pic->n[1] / 2.0f, (float) pic->n[2] / 2.0f ); - reader->SetDataExtent( 0, pic->n[0] - 1, 0, pic->n[1] - 1, 0, pic->n[2] - 1 ); - } else { - reader->Delete () ; - mitkIpPicFree( pic ); - return NULL; - } - - // Datatype - if ( ( pic->type == mitkIpPicInt || pic->type == mitkIpPicUInt ) && pic->bpe == 1 ) { - reader->SetDataScalarType( VTK_BIT ); - - } else if ( pic->type == mitkIpPicInt && pic->bpe == 8 ) { - reader->SetDataScalarType( VTK_CHAR ); - - } else if ( pic->type == mitkIpPicUInt && pic->bpe == 8 ) { - reader->SetDataScalarType( VTK_UNSIGNED_CHAR ); - - } else if ( pic->type == mitkIpPicInt && pic->bpe == 16 ) { - reader->SetDataScalarType( VTK_SHORT ); - - } else if ( pic->type == mitkIpPicUInt && pic->bpe == 16 ) { - reader->SetDataScalarType( VTK_UNSIGNED_SHORT ); - - } else if ( pic->type == mitkIpPicInt && pic->bpe == 32 ) { - reader->SetDataScalarType( VTK_INT ); - - } else if ( pic->type == mitkIpPicUInt && pic->bpe == 32 ) { - reader->SetDataScalarType( VTK_UNSIGNED_INT ); - - } else if ( pic->type == mitkIpPicInt && pic->bpe == 64 ) { - reader->SetDataScalarType( VTK_LONG ); - - } else if ( pic->type == mitkIpPicUInt && pic->bpe == 64 ) { - reader->SetDataScalarType( VTK_UNSIGNED_LONG ); - - } else if ( pic->type == mitkIpPicFloat && pic->bpe == 32 ) { - reader->SetDataScalarType( VTK_FLOAT ); - - } else if ( pic->type == mitkIpPicFloat && pic->bpe == 64 ) { - reader->SetDataScalarType( VTK_DOUBLE ); - - } else { - reader->Delete(); - mitkIpPicFree( pic ); - return NULL; - } - - reader->SetDataMask(0xffff); - reader->SetHeaderSize ( pic->info->pixel_start_in_file ); - - reader->SetFileName( fileName ); - reader->UpdateWholeExtent(); - mitkIpPicFree( pic ); - - vtkImageData* vtkImage = reader->GetOutput(); - reader->Delete(); - return vtkImage; -} - - -/** - * konvertiert ein pic-Image in ein vtkImageReader - * mask erwartet ein Bittmuster, das im Zielbild eingeblendet wird. - * move gibt die Verschiebung an, mit der das Bitmuster im Zielbilt plaziert wird. - */ -vtkImageData* Pic2vtk::convert( mitkIpPicDescriptor* pic, unsigned long mask, int move ) { - - if ( pic == NULL ) - return NULL; - - vtkImageData *inData = vtkImageData::New(); - - if ( inData == NULL ) - return NULL; - - unsigned long size = 0; - - if ( pic->dim == 1 ) { - - inData->SetDimensions( pic->n[0] -1, 1, 1); - size = pic->n[0]; - inData->SetOrigin( ((float) pic->n[0]) / 2.0f, 0, 0 ); - } else if ( pic->dim == 2 ) { - - inData->SetDimensions( pic->n[0] , pic->n[1] , 1 ); - size = pic->n[0] * pic->n[1]; - inData->SetOrigin( ((float) pic->n[0]) / 2.0f, ((float) pic->n[1]) / 2.0f, 0 ); - } else if ( pic->dim >= 3 ) { - - inData->SetDimensions( pic->n[0], pic->n[1], pic->n[2] ); - size = pic->n[0] * pic->n[1] * pic->n[2]; - inData->SetOrigin( 0, 0, 0 ); - } else { - - inData->Delete () ; - return NULL; - } - - inData->SetNumberOfScalarComponents(1); - - - if ( ( pic->type == mitkIpPicInt || pic->type == mitkIpPicUInt ) && pic->bpe == 1 ) { - inData->SetScalarType( VTK_BIT ); - inData->AllocateScalars(); - - size = size>>3; - register unsigned char* s = (unsigned char*) pic->data; - register unsigned char* a = (unsigned char*) inData->GetScalarPointer(); - register unsigned char v; - - for ( register unsigned long i = 0; i < size ; i++ ) { - - v = 0; - - for ( int j = 0; j < 8; j++ ) - v |= (((mask & (*s++))>>move)<type == mitkIpPicInt && pic->bpe == 8 ) { - inData->SetScalarType( VTK_BIT ); - inData->AllocateScalars(); - - register char* s = (char*) pic->data; - register unsigned char* a = (unsigned char*) inData->GetScalarPointer(); - register unsigned char v; - - - for ( register unsigned long i = 0; i < size ; i++ ) { - - v = 0; - - for ( int j = 0; j < 8; j++ ) - v |= (((mask & (*s++))>>move)<type == mitkIpPicUInt && pic->bpe == 8 ) { - inData->SetScalarType( VTK_BIT ); - inData->AllocateScalars(); - - register unsigned char* s = (unsigned char*) pic->data; - register unsigned char* a = (unsigned char*) inData->GetScalarPointer(); - register unsigned char v; - - for ( register unsigned long i = 0; i < size ; i++ ) { - - v = 0; - - for ( int j = 0; j < 8; j++ ) - v |= (((mask & (*s++))>>move)<type == mitkIpPicInt && pic->bpe == 16 ) { - inData->SetScalarType( VTK_BIT ); - inData->AllocateScalars(); - - register short* s = (short*) pic->data; - register unsigned char* a = (unsigned char*) inData->GetScalarPointer(); - register unsigned char v; - - for ( register unsigned long i = 0; i < size ; i++ ) { - - v = 0; - - for ( int j = 0; j < 8; j++ ) - v |= (((mask & (*s++))>>move)<type == mitkIpPicUInt && pic->bpe == 16 ) { - inData->SetScalarType( VTK_BIT ); - inData->AllocateScalars(); - - register unsigned short* s = (unsigned short*) pic->data; - register unsigned char* a = (unsigned char*) inData->GetScalarPointer(); - register unsigned char v; - - for ( register unsigned long i = 0; i < size ; i++ ) { - - v = 0; - - for ( int j = 0; j < 8; j++ ) - v |= (((mask & (*s++))>>move)<type == mitkIpPicInt && pic->bpe == 32 ) { - inData->SetScalarType( VTK_BIT ); - inData->AllocateScalars(); - - register int* s = (int*) pic->data; - register unsigned char* a = (unsigned char*) inData->GetScalarPointer(); - register unsigned char v; - - for ( register unsigned long i = 0; i < size ; i++ ) { - - v = 0; - - for ( int j = 0; j < 8; j++ ) - v |= (((mask & (*s++))>>move)<type == mitkIpPicUInt && pic->bpe == 32 ) { - inData->SetScalarType( VTK_BIT ); - inData->AllocateScalars(); - - register unsigned int* s = (unsigned int*) pic->data; - register unsigned char* a = (unsigned char*) inData->GetScalarPointer(); - register unsigned char v; - - for ( register unsigned long i = 0; i < size ; i++ ) { - - v = 0; - - for ( int j = 0; j < 8; j++ ) - v |= (((mask & (*s++))>>move)<type == mitkIpPicInt && pic->bpe == 64 ) { - inData->SetScalarType( VTK_BIT ); - inData->AllocateScalars(); - - register long* s = (long*) pic->data; - register unsigned char* a = (unsigned char*) inData->GetScalarPointer(); - register unsigned char v; - - for ( register unsigned long i = 0; i < size ; i++ ) { - - v = 0; - - for ( int j = 0; j < 8; j++ ) - v |= (((mask & (*s++))>>move)<type == mitkIpPicUInt && pic->bpe == 64 ) { - inData->SetScalarType( VTK_BIT ); - inData->AllocateScalars(); - - register unsigned long* s = (unsigned long*) pic->data; - register unsigned char* a = (unsigned char*) inData->GetScalarPointer(); - register unsigned char v; - - for ( register unsigned long i = 0; i < size ; i++ ) { - - v = 0; - - for ( int j = 0; j < 8; j++ ) - v |= (((mask & (*s++))>>move)<type == mitkIpPicFloat && pic->bpe == 32 ) { - - inData->Delete(); - return NULL; - - } else if ( pic->type == mitkIpPicFloat && pic->bpe == 64 ) { - - inData->Delete(); - return NULL; - - } else { - inData->Delete(); - return NULL; - } - - return inData; -} - -/** - * - */ - mitkIpPicDescriptor* Pic2vtk::convertSigned2Unsigned( mitkIpPicDescriptor* pic, unsigned long* offset ) { - - if ( pic == NULL ) - return NULL; - - if ( pic->type == mitkIpPicUInt ) - return pic; - - mitkIpPicDescriptor* newPic = mitkIpPicCopyHeader( pic, NULL ); - const unsigned int size = _mitkIpPicElements( pic ); - - if ( pic->type == mitkIpPicInt && pic->bpe == 8 ) { - - newPic->type = mitkIpPicUInt; - newPic->data = new unsigned char[ size ]; - - register char* s = (char*) pic->data; - register unsigned char* a = (unsigned char*) newPic->data; - register unsigned short localOffset = 2^7; - - for ( register unsigned long i = 0; i < size ; i++ ) - *a++ = (unsigned char) ((*s++) + localOffset); - - if ( offset ) - *offset = localOffset; - - } else if ( pic->type == mitkIpPicInt && pic->bpe == 16 ) { - - newPic->type = mitkIpPicUInt; - newPic->data = new unsigned short[ size ]; - - register short* s = (short*) pic->data; - register unsigned short* a = (unsigned short*) newPic->data; - register unsigned int localOffset = 1<<15; - - for ( register unsigned long i = 0; i < size ; i++ ) - *a++ = (unsigned short) ((*s++) + localOffset); - - if ( offset ) - *offset = localOffset; - - } else if ( pic->type == mitkIpPicInt && pic->bpe == 32 ) { - - newPic->type = mitkIpPicUInt; - newPic->data = new unsigned int[ size ]; - - register int* s = (int*) pic->data; - register unsigned int* a = (unsigned int*) newPic->data; - register unsigned long localOffset = 1<<31; - - for ( register unsigned long i = 0; i < size ; i++ ) - *a++ = (unsigned int)((*s++) + localOffset); - - if ( offset ) - *offset = localOffset; - - } else if ( pic->type == mitkIpPicInt && pic->bpe == 64 ) { - assert(false); - } - - return newPic; - } - - - /** - * - */ - -vtkImageData* Pic2vtk::loadVtkImage( char* fileName ) { - - vtkStructuredPointsReader* reader = vtkStructuredPointsReader::New(); - // vtkDataReader* reader = vtkDataReader::New(); - - - reader->SetFileName( fileName ); - reader->Update(); - - if ( reader->OpenVTKFile() == 0 ) - { - std::cout << "something happend ..." << std::endl; - return NULL; - } - - // int test = reader->IsFileStructuredPoints(); /* \todo remove line! */ - - - //int a = reader->GetFileType(); /* \todo remove line! */ - //char * kk = reader->GetHeader(); /* \todo remove line! */ - - vtkStructuredPoints* points = reader->GetOutput(); - std::cout << "dim: " << ((vtkImageData *)points)->GetDataDimension() << std::endl; - std::cout << "size: " << ((vtkImageData *)points)->GetScalarSize() << std::endl; - std::cout << "min: " << ((vtkImageData *)points)->GetScalarTypeMin () << std::endl; - std::cout << "min: " << ((vtkImageData *)points)->GetScalarTypeMax () << std::endl; - std::cout << "scalars: " << ((vtkImageData *)points)->GetNumberOfScalarComponents () << std::endl; - ((vtkImageData *)points)->SetNumberOfScalarComponents (3); - std::cout << "scalars: " << ((vtkImageData *)points)->GetNumberOfScalarComponents () << std::endl; - - int dims[3]; - ((vtkImageData *)points)->GetDimensions (dims); - std::cout << "dim1 = " << dims[0] << " dims2 = " << dims[1] << " dims3 = " << dims[2] << std::endl; - dims[2] = 2; - ((vtkImageData *)points)->SetDimensions (dims); - ((vtkImageData *)points)->GetDimensions (dims); - std::cout << "dim1 = " << dims[0] << " dims2 = " << dims[1] << " dims3 = " << dims[2] << std::endl; - std::cout << "dim: " << ((vtkImageData *)points)->GetDataDimension() << std::endl; - - - int extent[6]; - ((vtkImageData *)points)->GetExtent (extent); - std::cout << "e1 = " << extent[0] << " e2 = " << extent[1] << " e3 = " << extent[2] << std::endl; - std::cout << "e4 = " << extent[3] << " e5 = " << extent[4] << " e6 = " << extent[5] << std::endl; - - ((vtkImageData *)points)->GetUpdateExtent (extent); - std::cout << "e1 = " << extent[0] << " e2 = " << extent[1] << " e3 = " << extent[2] << std::endl; - std::cout << "e4 = " << extent[3] << " e5 = " << extent[4] << " e6 = " << extent[5] << std::endl; - - ((vtkImageData *)points)->GetExtent (extent); - ((vtkImageData *)points)->SetUpdateExtent (extent); - std::cout << "e1 = " << extent[0] << " e2 = " << extent[1] << " e3 = " << extent[2] << std::endl; - std::cout << "e4 = " << extent[3] << " e5 = " << extent[4] << " e6 = " << extent[5] << std::endl; - - ((vtkImageData *)points)->GetExtent (extent); - ((vtkImageData *)points)->SetWholeExtent (extent); - std::cout << "e1 = " << extent[0] << " e2 = " << extent[1] << " e3 = " << extent[2] << std::endl; - std::cout << "e4 = " << extent[3] << " e5 = " << extent[4] << " e6 = " << extent[5] << std::endl; - - vtkFloatingPointType s[3]; - - ((vtkImageData *)points)->GetSpacing (s); - std::cout << "s1 = " << s[0] << " s2 = " << s[1] << " s3 = " << s[2] << std::endl; - - ((vtkDataObject*)points)->Update(); - - - return (vtkImageData *)points; - //return NULL; - } - diff --git a/Utilities/pic2vtk/pic2vtk.h b/Utilities/pic2vtk/pic2vtk.h deleted file mode 100644 index e2b9bbde34..0000000000 --- a/Utilities/pic2vtk/pic2vtk.h +++ /dev/null @@ -1,54 +0,0 @@ -#ifndef Pic2vtk_h -#define Pic2vtk_h - -#include -#include - -/** @file - * DKFZ - Heidelberg - * - * Module Name: Pic2vtk - * - * Module Klasse: ADT - * - * Beschreibung: - * - * - * Exportierte Klassen und Funktionen: - * - * - * Importierte Klassen und Funktionen: - * - * - * @warning Dieses Modul wurde noch nicht abgenommen! - * - * @version 1.0 - * - * @date 03.07.2000 - * - * @author Marcus Vetter - * - */ - -class Pic2vtk { - -private: - - // verhindert das erzeugen eines Objects. - Pic2vtk() {}; - -public: - - static vtkImageData* loadVtkImage( char* fileName ); - static vtkImageData* loadImage( char* fileName, bool littleEndian = true ); - static vtkImageData* convert( mitkIpPicDescriptor* pic ); - static vtkImageData* convert( mitkIpPicDescriptor* pic, unsigned long mask, int move ); - static mitkIpPicDescriptor* convert( vtkImageData* vtkImage ); - static mitkIpPicDescriptor* convertSigned2Unsigned( mitkIpPicDescriptor*, unsigned long* offset = NULL ); - - static vtkImageData* convertVectorImage( mitkIpPicDescriptor* pic ); - static mitkIpPicDescriptor* convertVectorImage( vtkImageData* vtkImage ); - -}; - -#endif // Pic2vtk_h diff --git a/Utilities/vecmath/AxisAngle4.h b/Utilities/vecmath/AxisAngle4.h deleted file mode 100644 index ed556a1e3e..0000000000 --- a/Utilities/vecmath/AxisAngle4.h +++ /dev/null @@ -1,104 +0,0 @@ -/* - Copyright (C) 1997,1998,1999 - Kenji Hiranabe, Eiwa System Management, Inc. - - This program is free software. - Implemented by Kenji Hiranabe(hiranabe@esm.co.jp), - conforming to the Java(TM) 3D API specification by Sun Microsystems. - - Permission to use, copy, modify, distribute and sell this software - and its documentation for any purpose is hereby granted without fee, - provided that the above copyright notice appear in all copies and - that both that copyright notice and this permission notice appear - in supporting documentation. Kenji Hiranabe and Eiwa System Management,Inc. - makes no representations about the suitability of this software for any - purpose. It is provided "AS IS" with NO WARRANTY. -*/ -#ifndef AXISANGLE4_H -#define AXISANGLE4_H - -#include "VmUtil.h" -#include "AxisAngle4_.h" -#include "Quat4_.h" - -VM_BEGIN_NS - -template -void AxisAngle4::set(const Quat4& q1) { - setFromQuat(q1.x, q1.y, q1.z, q1.w); -} - -template -void AxisAngle4::setFromMat(T m00, T m01, T m02, - T m10, T m11, T m12, - T m20, T m21, T m22) { - // assuming M is normalized. - T cos = (m00 + m11 + m22 - 1.0)*0.5; - x = m21 - m12; - y = m02 - m20; - z = m10 - m01; - T sin = 0.5*VmUtil::sqrt(x*x + y*y + z*z); - angle = VmUtil::atan2(sin, cos); - - // no need to normalize - // x /= n; - // y /= n; - // z /= n; - -} - - - - -template -void AxisAngle4::setFromQuat(T x, T y, T z, T w) { - // This logic can calculate angle without normalization. - // The direction of (x,y,z) and the sign of rotation cancel - // each other to calculate a right answer. - - T sin_a2 = VmUtil::sqrt(x*x + y*y + z*z); // |sin a/2|, w = cos a/2 - this->angle = 2.0*VmUtil::atan2(sin_a2, w); // 0 <= angle <= PI , because 0 < sin_a2 - this->x = x; - this->y = y; - this->z = z; -} - -#ifdef VM_INCLUDE_TOSTRING -template -VM_STRING_STD::string AxisAngle4::toString() const { - VM_TOSTRING -} -#endif - -VM_END_NS - -#ifdef VM_INCLUDE_IO -template -VM_IOSTREAM_STD::ostream& operator<<(VM_IOSTREAM_STD::ostream& o, const VM_VECMATH_NS::AxisAngle4& a1) { - return o << "(" << a1.x << "," << a1.y << "," - << a1.z << "," << a1.angle << ")"; -} - -// Anfang Änderung Marcus -template -VM_IOSTREAM_STD::istream& operator>>(VM_IOSTREAM_STD::istream& i, const VM_VECMATH_NS::AxisAngle4& a1) { - - char c; - - i >> c; - i >> a1.x; - i >> c; - i >> a1.y; - i >> c; - i >> a1.z; - i >> c; - i >> a1.angle; - i >> c; - - return i; -} -// Ende Änderung Marcus - -#endif - -#endif /* AXISANGLE4_H */ diff --git a/Utilities/vecmath/AxisAngle4_.h b/Utilities/vecmath/AxisAngle4_.h deleted file mode 100644 index 5706c8a524..0000000000 --- a/Utilities/vecmath/AxisAngle4_.h +++ /dev/null @@ -1,323 +0,0 @@ -/* - Copyright (C) 1997,1998,1999 - Kenji Hiranabe, Eiwa System Management, Inc. - - This program is free software. - Implemented by Kenji Hiranabe(hiranabe@esm.co.jp), - conforming to the Java(TM) 3D API specification by Sun Microsystems. - - Permission to use, copy, modify, distribute and sell this software - and its documentation for any purpose is hereby granted without fee, - provided that the above copyright notice appear in all copies and - that both that copyright notice and this permission notice appear - in supporting documentation. Kenji Hiranabe and Eiwa System Management,Inc. - makes no representations about the suitability of this software for any - purpose. It is provided "AS IS" with NO WARRANTY. -*/ -#ifndef AXISANGLE4__H -#define AXISANGLE4__H - -#include "VmUtil.h" -#include "Matrix4_.h" - -VM_BEGIN_NS - -/** - * A 4 element axis angle represented by - * x,y,z,angle components. An axis angle is a rotation of angle (radians) about - * the vector (x,y,z). - * @version specification 1.1, implementation $Revision$, $Date$ - * @author Kenji hiranabe - */ -template -class AxisAngle4 { -/* - * $Log$ - * Revision 1.3 2005/10/13 13:50:04 maleike - * FIX: doxygen warnings - * - * Revision 1.2 2003/04/22 14:42:11 max - * made inclusions of vecmath header files "local" (for gcc 3.3 support) - * - * Revision 1.1 2002/11/16 12:25:36 mark - * vecmath bibliothek - * in cvs, da einige bugs behoben - * - * Revision 1.4 1999/10/06 02:52:46 hiranabe - * Java3D 1.2 and namespace - * - * Revision 1.3 1999/10/05 06:19:19 hiranabe - * Java3D 1.2 - * AxisAngle4(Vector3,T) - * set(Vector3,T) - * - * Revision 1.2 1999/05/26 00:59:37 hiranabe - * support Visual C++ - * - * Revision 1.1 1999/03/04 11:07:09 hiranabe - * Initial revision - * - * Revision 1.1 1999/03/04 11:07:09 hiranabe - * Initial revision - * - */ -/* - * I assumed that the length of axis vectors is not significant. - */ -public: - /** - * the type for values - */ - typedef T value_type; - - /** - * The x coordinate. - */ - T x; - - /** - * The y coordinate. - */ - T y; - - /** - * The z coordinate. - */ - T z; - - /** - * The angle. - */ - T angle; - - /** - * Constructs and initializes an AxisAngle4 from the specified x, y, z, - * and angle. - * @param xvalue the x coordinate - * @param yvalue the y coordinate - * @param zvalue the z coordinate - * @param anglevalue the angle. - */ - AxisAngle4(T xvalue, T yvalue, T zvalue, T anglevalue): - x(xvalue), y(yvalue), z(zvalue), angle(anglevalue) { } - - /** - * Constructs and initializes an AxisAngle4 from the components contained - * in the array. - * @param a the array of length 4 containing x,y,z,angle in order - */ - AxisAngle4(const T a[]): - x(a[0]), y(a[1]), z(a[2]), angle(a[3]) { } - -#if 0 - /** - * Constructs and initializes a AxisAngle4 from the specified AxisAngle4f. - * @param a1 the AxisAngle4f containing the initialization x y z angle data - */ - AxisAngle4(AxisAngle4f a1) { - set(a1); - } -#endif - - /** - * Constructs and initializes a AxisAngle4 to (0,0,1,0). - */ - AxisAngle4(): x(0), y(0), z(1), angle(0) { } - - /** - * Constructs and initializes an AxisAngle4f from the specified axis - * and angle. - * - * @param axis the axis - * @param ang the angle - * @since Java 3D 1.2 - */ - AxisAngle4(const Vector3& axis, T ang): - x(axis.x), y(axis.y), z(axis.z), angle(ang) { } - - /** - * Sets the value of this AxisAngle4f to the specified axis and - * angle. - * @param axis the axis - * @param ang the angle - * @since Java 3D 1.2 - */ - void set(const Vector3& axis, T ang) { - x = axis.x; - y = axis.y; - z = axis.z; - angle = ang; - } - - /** - * Sets the value of this axis angle to the specified x,y,z,angle. - * @param x the x coordinate - * @param y the y coordinate - * @param z the z coordinate - * @param angle the angle - */ - void set(T x, T y, T z, T angle) { - this->x = x; - this->y = y; - this->z = z; - this->angle = angle; - } - - /** - * Sets the value of this axis angle from the 4 values specified in the array. - * @param a the array of length 4 containing x,y,z,angle in order - */ - void set(const T a[]) { - assert(a != 0); - x = a[0]; - y = a[1]; - z = a[2]; - angle = a[3]; - } - - /** - * Sets the value of this axis angle to the value of axis angle t1. - * @param a1 the axis angle to be copied - */ - void set(const AxisAngle4& a1) { - x = a1.x; - y = a1.y; - z = a1.z; - angle = a1.angle; - } - -#if 0 - /** - * Sets the value of this axis angle to the value of axis angle t1. - * @param t1 the axis angle to be copied - */ - void set(AxisAngle4f a1) { - x = (float)(a1.x); - y = (float)(a1.y); - z = (float)(a1.z); - angle = (float)(a1.angle); - } -#endif - - /** - * Gets the value of this axis angle into the array a of - * length four in x,y,z,angle order. - * @param a the array of length four - */ - void get(T a[]) const { - assert(a != 0); - a[0] = x; - a[1] = y; - a[2] = z; - a[3] = angle; - } - - /** - * Sets the value of this axis-angle to the rotational component of the - * passed matrix. - * @param m1 the matrix4 - */ - void set(const Matrix4& m1) { - setFromMat( - m1.m00, m1.m01, m1.m02, - m1.m10, m1.m11, m1.m12, - m1.m20, m1.m21, m1.m22 - ); - } - - /** - * Sets the value of this axis-angle to the rotational component of the - * passed matrix. - * @param m1 the matrix3f - */ - void set(const Matrix3& m1) { - setFromMat( - m1.m00, m1.m01, m1.m02, - m1.m10, m1.m11, m1.m12, - m1.m20, m1.m21, m1.m22 - ); - } - - /** - * Sets the value of this axis-angle to the rotational equivalent of the - * passed quaternion. - * @param q1 the Quat4 - */ - void set(const Quat4& q1); - - // helper method -protected: - void setFromMat(T m00, T m01, T m02, - T m10, T m11, T m12, - T m20, T m21, T m22); - - void setFromQuat(T x, T y, T z, T w); - -public: - /** - * Returns true if all of the data members of AxisAngle4 t1 are equal to the corresponding - * data members in this - * @param a1 the vector with which the comparison is made. - */ - bool equals(const AxisAngle4& a1) const { - return x == a1.x && y == a1.y && z == a1.z && angle == a1.angle; - } - - /** - * Returns true if the L-infinite distance between this axis-angle and axis-angle t1 is - * less than or equal to the epsilon parameter, otherwise returns false. The L-infinite - * distance is equal to MAX[abs(x1-x2), abs(y1-y2), abs(z1-z2), abs(angle1-angle2)]. - * @param a1 the axis-angle to be compared to this axis-angle - * @param epsilon the threshold value - */ - bool epsilonEquals(const AxisAngle4& a1, T epsilon) const { - return (VmUtil::abs(a1.x - x) <= epsilon) && - (VmUtil::abs(a1.y - y) <= epsilon) && - (VmUtil::abs(a1.z - z) <= epsilon) && - (VmUtil::abs(a1.angle - angle) <= epsilon); - } - - /** - * Returns a hash number based on the data values in this object. - * Two different AxisAngle4 objects with identical data values - * (ie, returns true for equals(AxisAngle4) ) will return the same hash number. - * Two vectors with different data members may return the same hash value, - * although this is not likely. - */ - size_t hashCode() const { - return VmUtil::hashCode(sizeof *this, this); - } - - /** - * Returns a string that contains the values of this AxisAngle4. The form is (x,y,z,angle). - * @return the String representation - */ -#ifdef VM_INCLUDE_TOSTRING -VM_STRING_STD::string toString() const; -#endif - - // copy constructor and operator = is made by complier - - bool operator==(const AxisAngle4& m1) const { - return equals(m1); - } - -}; - -VM_END_NS - -#ifdef VM_INCLUDE_IO -template -VM_IOSTREAM_STD::ostream& operator<<(VM_IOSTREAM_STD::ostream& o, const VM_VECMATH_NS::AxisAngle4& t1); -#endif - -VM_BEGIN_NS - -typedef AxisAngle4 AxisAngle4d; -typedef AxisAngle4 AxisAngle4f; - -VM_END_NS - - - -#endif /* AXISANGLE4__H */ diff --git a/Utilities/vecmath/CHANGES b/Utilities/vecmath/CHANGES deleted file mode 100644 index 576da29c06..0000000000 --- a/Utilities/vecmath/CHANGES +++ /dev/null @@ -1,63 +0,0 @@ -HISTOR OF CHANGES: - -* 1.2-1.4 - -** added operator= for Tuples. - (Thanks > Katsuaki KAWACHI ) - -** added '/D "TESTALL" /I "." ' to vecmath.dsp - (Thanks > Takayuki MATSUOKA ) - -* 1.2-1.3 - -** This 1.2-1.3 version newly places 'kh_vecmath' namespace around -the all vecmath classes. Users upgrading from earlier versions, -there are 2 options. - (1) Insert 'using namespace kh_vecmath;' into your code. - (2) undef VM_INCLUDE_NAMESPACE in vm_conf.h to turn off - the namespace feature. You don't have to change your code. - -** For Visual Studio users, vecmath.dsw (Workspace) is provided -for testing. vecmath.dsp (Project) is a project to create a -vecmath testing excutable. You don't have to build this project -unless you need testing. - -** Java3D 1.2 conformance - - Vector4#Vector4(Tuple3) - Vector4#set3(Tuple3) - - Point4#Point4(Tuple3) - Point4#set3(Tuple3) - AxisAngle4#AxisAngle4(Vector3,T) - AxisAngle4#set(Vector3,T) - -** Makefile.unix adjust ($$i -> ./$$i) - thanks > matsuoka@osaka.whoopeecamp.co.jp - -** Point{2,3}.h distance*() method to const - thanks > okamura@esm.co.jp - -** removed static helper method like max,min,abs from Tuple classes - -** test sources .cc -> .cpp - -** added more tests. - -** Visual Studio Workspace and Project support. - -* 1.1-1.2 - -** VM_INCLUDE_STRING -> VM_INCLUDE_TOSTRING in Tuple{3,4}.h - thanks > kawachi@cim.pe.u-tokyo.ac.jp - -** SVD normalization is now done per axis in Matrix{3,4}d.h - -* 1.1-1.1 - -** Adaptation to Microsoft Visual C/C++ 6.0 compiler - (Thanks > "Lucas Ammon" ) - -* 1.1-1.0 - -** first release of vecmath-c++(1999,3/4) diff --git a/Utilities/vecmath/CMakeLists.txt b/Utilities/vecmath/CMakeLists.txt deleted file mode 100644 index 55cf487746..0000000000 --- a/Utilities/vecmath/CMakeLists.txt +++ /dev/null @@ -1,2 +0,0 @@ -MITK_CREATE_MODULE_CONF(vecmath HEADERS_ONLY) - diff --git a/Utilities/vecmath/Color3.h b/Utilities/vecmath/Color3.h deleted file mode 100644 index a9097d9887..0000000000 --- a/Utilities/vecmath/Color3.h +++ /dev/null @@ -1,98 +0,0 @@ -/* - Copyright (C) 1997,1998,1999 - Kenji Hiranabe, Eiwa System Management, Inc. - - This program is free software. - Implemented by Kenji Hiranabe(hiranabe@esm.co.jp), - conforming to the Java(TM) 3D API specification by Sun Microsystems. - - Permission to use, copy, modify, distribute and sell this software - and its documentation for any purpose is hereby granted without fee, - provided that the above copyright notice appear in all copies and - that both that copyright notice and this permission notice appear - in supporting documentation. Kenji Hiranabe and Eiwa System Management,Inc. - makes no representations about the suitability of this software for any - purpose. It is provided "AS IS" with NO WARRANTY. -*/ -#ifndef COLOR3_H -#define COLOR3_H - -#include "VmUtil.h" -#include "Tuple3.h" - -VM_BEGIN_NS - -/** - * A 3 element color represented by x,y,z - * coordinates. - * @version specification 1.1, implementation $Revision$, $Date$ - * @author Kenji hiranabe - */ -template -class Color3 : public Tuple3 { -/* - * $Log$ - * Revision 1.2 2003/04/22 14:42:11 max - * made inclusions of vecmath header files "local" (for gcc 3.3 support) - * - * Revision 1.1 2002/11/16 12:25:36 mark - * vecmath bibliothek - * in cvs, da einige bugs behoben - * - * Revision 1.3 1999/10/06 02:52:46 hiranabe - * Java3D 1.2 and namespace - * - * Revision 1.2 1999/05/26 00:59:37 hiranabe - * support Visual C++ - * - * Revision 1.1 1999/03/04 11:07:09 hiranabe - * Initial revision - * - * Revision 1.1 1999/03/04 11:07:09 hiranabe - * Initial revision - * - */ -public: - /** - * Constructs and initializes a Color3 from the specified xyz - * @param x the x coordinate - * @param y the y coordinate - * @param z the z coordinate - */ - Color3(T x, T y, T z): Tuple3(x, y, z) { } - - /** - * Constructs and initializes a Color3 from input array of length 3. - * @param c the array of length 3 containing xyz in order - */ - Color3(const T c[]): Tuple3(c) { } - - /** - * Constructs and initializes a Color3 from the specified Tuple3d. - * @param t1 the Tuple3d containing the initialization x y z data - */ - Color3(const Tuple3& t1): Tuple3(t1) { } - -#if 0 - /** - * Constructs and initializes a Color3 from the specified Tuple3f. - * @param t1 the Tuple3f containing the initialization x y z data - */ - Color3(Tuple3f t1) { - super(t1); - } -#endif - - /** - * Constructs and initializes a Color3 to (0,0,0). - */ - Color3(): Tuple3() { } -}; - -typedef Color3 Color3f; -typedef Color3 Color3d; -typedef Color3 Color3b; - -VM_END_NS - -#endif /* COLOR3_H */ diff --git a/Utilities/vecmath/Color4.h b/Utilities/vecmath/Color4.h deleted file mode 100644 index 818f020d28..0000000000 --- a/Utilities/vecmath/Color4.h +++ /dev/null @@ -1,99 +0,0 @@ -/* - Copyright (C) 1997,1998,1999 - Kenji Hiranabe, Eiwa System Management, Inc. - - This program is free software. - Implemented by Kenji Hiranabe(hiranabe@esm.co.jp), - conforming to the Java(TM) 3D API specification by Sun Microsystems. - - Permission to use, copy, modify, distribute and sell this software - and its documentation for any purpose is hereby granted without fee, - provided that the above copyright notice appear in all copies and - that both that copyright notice and this permission notice appear - in supporting documentation. Kenji Hiranabe and Eiwa System Management,Inc. - makes no representations about the suitability of this software for any - purpose. It is provided "AS IS" with NO WARRANTY. -*/ -#ifndef COLOR4_H -#define COLOR4_H - -#include "VmUtil.h" -#include "Tuple4.h" - -VM_BEGIN_NS - -/** - * A 4 element color represented by x,y,z,w - * coordinates. Color and alpha components. - * @version specification 1.1, implementation 1.0 $Revision$, $Date$ - * @author Kenji hiranabe - */ -template -class Color4 : public Tuple4 { -/* - * $Log$ - * Revision 1.2 2003/04/22 14:42:11 max - * made inclusions of vecmath header files "local" (for gcc 3.3 support) - * - * Revision 1.1 2002/11/16 12:25:36 mark - * vecmath bibliothek - * in cvs, da einige bugs behoben - * - * Revision 1.3 1999/10/06 02:52:46 hiranabe - * Java3D 1.2 and namespace - * - * Revision 1.2 1999/05/26 00:59:37 hiranabe - * support Visual C++ - * - * Revision 1.1 1999/03/04 11:07:09 hiranabe - * Initial revision - * - * Revision 1.1 1999/03/04 11:07:09 hiranabe - * Initial revision - * - */ -public: - /** - * Constructs and initializes a Color4 from the specified xyzw - * @param x the x coordinate - * @param y the y coordinate - * @param z the z coordinate - * @param w the w coordinate - */ - Color4(T x, T y, T z, T w): Tuple4(x, y, z, w) { } - - /** - * Constructs and initializes a Color4 from input array of length 4. - * @param c the array of length 4 containing xyzw in order - */ - Color4(const T c[]): Tuple4(c) { } - - /** - * Constructs and initializes a Color4 from the specified Tuple4d. - * @param t1 the Tuple4d containing the initialization x y z w data - */ - Color4(const Tuple4& t1): Tuple4(t1) { } - -#if 0 - /** - * Constructs and initializes a Color4 from the specified Tuple4. - * @param t1 the Tuple4 containing the initialization x y z w data - */ - Color4(Tuple4 t1) { - Tuple4(t1); - } -#endif - - /** - * Constructs and initializes a Color4 to (0,0,0,0). - */ - Color4(): Tuple4() { } -}; - -typedef Color4 Color4f; -typedef Color4 Color4d; -typedef Color4 Color4b; - -VM_END_NS - -#endif /* COLOR4_H */ diff --git a/Utilities/vecmath/Matrix3.h b/Utilities/vecmath/Matrix3.h deleted file mode 100644 index d504509d62..0000000000 --- a/Utilities/vecmath/Matrix3.h +++ /dev/null @@ -1,890 +0,0 @@ -/* - Copyright (C) 1997,1998,1999 - Kenji Hiranabe, Eiwa System Management, Inc. - - This program is free software. - Implemented by Kenji Hiranabe(hiranabe@esm.co.jp), - conforming to the Java(TM) 3D API specification by Sun Microsystems. - - Permission to use, copy, modify, distribute and sell this software - and its documentation for any purpose is hereby granted without fee, - provided that the above copyright notice appear in all copies and - that both that copyright notice and this permission notice appear - in supporting documentation. Kenji Hiranabe and Eiwa System Management,Inc. - makes no representations about the suitability of this software for any - purpose. It is provided "AS IS" with NO WARRANTY. -*/ -#ifndef MATRIX3_H -#define MATRIX3_H - -#include "VmUtil.h" -#include "Matrix3_.h" -#include "AxisAngle4_.h" -#include "Quat4_.h" - -VM_BEGIN_NS - -template -Matrix3::Matrix3(T n00, T n01, T n02, - T n10, T n11, T n12, - T n20, T n21, T n22): - m00(n00), m01(n01), m02(n02), - m10(n10), m11(n11), m12(n12), - m20(n20), m21(n21), m22(n22) { } - -template -Matrix3::Matrix3(const T v[]): - m00(v[ 0]), m01(v[ 1]), m02(v[ 2]), - m10(v[ 3]), m11(v[ 4]), m12(v[ 5]), - m20(v[ 6]), m21(v[ 7]), m22(v[ 8]) { } - -#ifdef VM_INCLUDE_CONVERSION_FROM_2DARRAY -template -Matrix3::Matrix3(const T v[][3]): - m00(v[0][0]), m01(v[0][1]), m02(v[0][2]), - m10(v[1][0]), m11(v[1][1]), m12(v[1][2]), - m20(v[2][0]), m21(v[2][1]), m22(v[2][2]) { } -#endif - -template -Matrix3::Matrix3(): - m00(0), m01(0), m02(0), - m10(0), m11(0), m12(0), - m20(0), m21(0), m22(0) { } - -template -void Matrix3::set(T m00, T m01, T m02, - T m10, T m11, T m12, - T m20, T m21, T m22) { - this->m00 = m00; this->m01 = m01; this->m02 = m02; - this->m10 = m10; this->m11 = m11; this->m12 = m12; - this->m20 = m20; this->m21 = m21; this->m22 = m22; -} - -template -void Matrix3::set(const Matrix3& m1) { - m00 = m1.m00; m01 = m1.m01; m02 = m1.m02; - m10 = m1.m10; m11 = m1.m11; m12 = m1.m12; - m20 = m1.m20; m21 = m1.m21; m22 = m1.m22; -} - -template -void Matrix3::set(const T v[]) { - assert(v != 0); - m00 = v[ 0]; m01 = v[ 1]; m02 = v[ 2]; - m10 = v[ 3]; m11 = v[ 4]; m12 = v[ 5]; - m20 = v[ 6]; m21 = v[ 7]; m22 = v[ 8]; -} - -#ifdef VM_INCLUDE_CONVERSION_FROM_2DARRAY -template -void Matrix3::set(const T m[][3]) { - assert(m != 0); - m00 = m[0][0]; m01 = m[0][1]; m02 = m[0][2]; - m10 = m[1][0]; m11 = m[1][1]; m12 = m[1][2]; - m20 = m[2][0]; m21 = m[2][1]; m22 = m[2][2]; -} -#endif - -template -void Matrix3::setIdentity() { - m00 = 1.0; m01 = 0.0; m02 = 0.0; - m10 = 0.0; m11 = 1.0; m12 = 0.0; - m20 = 0.0; m21 = 0.0; m22 = 1.0; -} - -template -void Matrix3::setScale(T scale) { - SVD(this); - m00 *= scale; - m11 *= scale; - m22 *= scale; -} - - -template -void Matrix3::set(const Quat4& q1) { - setFromQuat(q1.x, q1.y, q1.z, q1.w); -} - -template -void Matrix3::set(const AxisAngle4& a1) { - setFromAxisAngle(a1.x, a1.y, a1.z, a1.angle); -} - -template -void Matrix3::setElement(size_t row, size_t column, T value) { - assert(row < 3); - assert(column < 3); - if (row == 0) - if (column == 0) - m00 = value; - else if (column == 1) - m01 = value; - else if (column == 2) - m02 = value; - else - VM_OUT_OF_RANGE; - else if (row == 1) - if (column == 0) - m10 = value; - else if (column == 1) - m11 = value; - else if (column == 2) - m12 = value; - else - VM_OUT_OF_RANGE; - else if (row == 2) - if (column == 0) - m20 = value; - else if (column == 1) - m21 = value; - else if (column == 2) - m22 = value; - else - VM_OUT_OF_RANGE; - else - VM_OUT_OF_RANGE; -} - -template -T Matrix3::getElement(size_t row, size_t column) const { - assert(row < 3); - assert(column < 3); - if (row == 0) - if (column == 0) - return m00; - else if (column == 1) - return m01; - else if (column == 2) - return m02; - else { - VM_OUT_OF_RANGE; - } - else if (row == 1) - if (column == 0) - return m10; - else if (column == 1) - return m11; - else if (column == 2) - return m12; - else { - VM_OUT_OF_RANGE; - } - - else if (row == 2) - if (column == 0) - return m20; - else if (column == 1) - return m21; - else if (column == 2) - return m22; - else { - VM_OUT_OF_RANGE; - } - else { - VM_OUT_OF_RANGE; - } - return 0; -} - -template -T& Matrix3::getElementReference(size_t row, size_t column) { - assert(row < 3); - assert(column < 3); - if (row == 0) - if (column == 0) - return m00; - else if (column == 1) - return m01; - else if (column == 2) - return m02; - else { - VM_OUT_OF_RANGE; - } - else if (row == 1) - if (column == 0) - return m10; - else if (column == 1) - return m11; - else if (column == 2) - return m12; - else { - VM_OUT_OF_RANGE; - } - - else if (row == 2) - if (column == 0) - return m20; - else if (column == 1) - return m21; - else if (column == 2) - return m22; - else { - VM_OUT_OF_RANGE; - } - else { - VM_OUT_OF_RANGE; - } - - // error anyway - static T dummy; - return dummy; -} - -template -void Matrix3::setRow(size_t row, T x, T y, T z) { - assert(row < 3); - if (row == 0) { - m00 = x; - m01 = y; - m02 = z; - } else if (row == 1) { - m10 = x; - m11 = y; - m12 = z; - } else if (row == 2) { - m20 = x; - m21 = y; - m22 = z; - } else { - VM_OUT_OF_RANGE; - } -} - -template -void Matrix3::setRow(size_t row, const Vector3& v) { - assert(row < 3); - if (row == 0) { - m00 = v.x; - m01 = v.y; - m02 = v.z; - } else if (row == 1) { - m10 = v.x; - m11 = v.y; - m12 = v.z; - } else if (row == 2) { - m20 = v.x; - m21 = v.y; - m22 = v.z; - } else { - VM_OUT_OF_RANGE; - } -} - -template -void Matrix3::setRow(size_t row, const T v[]) { - assert(v != 0); - assert(row < 3); - if (row == 0) { - m00 = v[0]; - m01 = v[1]; - m02 = v[2]; - } else if (row == 1) { - m10 = v[0]; - m11 = v[1]; - m12 = v[2]; - } else if (row == 2) { - m20 = v[0]; - m21 = v[1]; - m22 = v[2]; - } else { - VM_OUT_OF_RANGE; - } -} - -template -void Matrix3::getRow(size_t row, T v[]) const { - assert(v != 0); - assert(row < 3); - if (row == 0) { - v[0] = m00; - v[1] = m01; - v[2] = m02; - } else if (row == 1) { - v[0] = m10; - v[1] = m11; - v[2] = m12; - } else if (row == 2) { - v[0] = m20; - v[1] = m21; - v[2] = m22; - } else { - VM_OUT_OF_RANGE; - } -} - -template -void Matrix3::getRow(size_t row, Vector3* v) const { - assert(v != 0); - assert(row < 3); - if (row == 0) { - v->x = m00; - v->y = m01; - v->z = m02; - } else if (row == 1) { - v->x = m10; - v->y = m11; - v->z = m12; - } else if (row == 2) { - v->x = m20; - v->y = m21; - v->z = m22; - } else { - VM_OUT_OF_RANGE; - } -} - -template -void Matrix3::setColumn(size_t column, T x, T y, T z) { - assert(column < 3); - if (column == 0) { - m00 = x; - m10 = y; - m20 = z; - } else if (column == 1) { - m01 = x; - m11 = y; - m21 = z; - } else if (column == 2) { - m02 = x; - m12 = y; - m22 = z; - } else { - VM_OUT_OF_RANGE; - } -} - -template -void Matrix3::setColumn(size_t column, const Vector3& v) { - assert(column < 3); - if (column == 0) { - m00 = v.x; - m10 = v.y; - m20 = v.z; - } else if (column == 1) { - m01 = v.x; - m11 = v.y; - m21 = v.z; - } else if (column == 2) { - m02 = v.x; - m12 = v.y; - m22 = v.z; - } else { - VM_OUT_OF_RANGE; - } -} - -template -void Matrix3::setColumn(size_t column, const T v[]) { - assert(v != 0); - assert(column < 3); - if (column == 0) { - m00 = v[0]; - m10 = v[1]; - m20 = v[2]; - } else if (column == 1) { - m01 = v[0]; - m11 = v[1]; - m21 = v[2]; - } else if (column == 2) { - m02 = v[0]; - m12 = v[1]; - m22 = v[2]; - } else { - VM_OUT_OF_RANGE; - } -} - - -template -void Matrix3::getColumn(size_t column, Vector3* v) const { - assert(column < 3); - assert(v != 0); - if (column == 0) { - v->x = m00; - v->y = m10; - v->z = m20; - } else if (column == 1) { - v->x = m01; - v->y = m11; - v->z = m21; - } else if (column == 2) { - v->x = m02; - v->y = m12; - v->z = m22; - } else { - VM_OUT_OF_RANGE; - } -} - -template -void Matrix3::getColumn(size_t column, T v[]) const { - assert(column < 3); - assert(v != 0); - if (column == 0) { - v[0] = m00; - v[1] = m10; - v[2] = m20; - } else if (column == 1) { - v[0] = m01; - v[1] = m11; - v[2] = m21; - } else if (column == 2) { - v[0] = m02; - v[1] = m12; - v[2] = m22; - } else { - VM_OUT_OF_RANGE; - } -} - -template -T Matrix3::getScale() const { - return SVD(0); -} - -template -void Matrix3::add(T scalar) { - m00 += scalar; m01 += scalar; m02 += scalar; - m10 += scalar; m11 += scalar; m12 += scalar; - m20 += scalar; m21 += scalar; m22 += scalar; -} - -template -void Matrix3::sub(T scalar) { - add(-scalar); -} - -template -void Matrix3::add(T scalar, const Matrix3& m1) { - set(m1); - add(scalar); -} - - -template -void Matrix3::add(const Matrix3& m1, const Matrix3& m2) { - // note this is alias safe. - set( - m1.m00 + m2.m00, - m1.m01 + m2.m01, - m1.m02 + m2.m02, - m1.m10 + m2.m10, - m1.m11 + m2.m11, - m1.m12 + m2.m12, - m1.m20 + m2.m20, - m1.m21 + m2.m21, - m1.m22 + m2.m22 - ); -} - - -template -void Matrix3::add(const Matrix3& m1) { - m00 += m1.m00; m01 += m1.m01; m02 += m1.m02; - m10 += m1.m10; m11 += m1.m11; m12 += m1.m12; - m20 += m1.m20; m21 += m1.m21; m22 += m1.m22; -} - - -template -void Matrix3::sub(const Matrix3& m1, const Matrix3& m2) { - // note this is alias safe. - set( - m1.m00 - m2.m00, - m1.m01 - m2.m01, - m1.m02 - m2.m02, - m1.m10 - m2.m10, - m1.m11 - m2.m11, - m1.m12 - m2.m12, - m1.m20 - m2.m20, - m1.m21 - m2.m21, - m1.m22 - m2.m22 - ); -} - -template -void Matrix3::sub(const Matrix3& m1) { - m00 -= m1.m00; m01 -= m1.m01; m02 -= m1.m02; - m10 -= m1.m10; m11 -= m1.m11; m12 -= m1.m12; - m20 -= m1.m20; m21 -= m1.m21; m22 -= m1.m22; -} - - -template -void Matrix3::transpose() { - T tmp = m01; - m01 = m10; - m10 = tmp; - - tmp = m02; - m02 = m20; - m20 = tmp; - - tmp = m12; - m12 = m21; - m21 = tmp; -} - - -template -void Matrix3::transpose(const Matrix3& m1) { - // alias-safe - set(m1); - transpose(); -} - - -template -void Matrix3::invert(const Matrix3& m1) { - // alias-safe way. - set(m1); - invert(); -} - - -template -void Matrix3::invert() { - T s = determinant(); - // zero div may happen - s = 1/s; - // alias-safe way. - set( - m11*m22 - m12*m21, m02*m21 - m01*m22, m01*m12 - m02*m11, - m12*m20 - m10*m22, m00*m22 - m02*m20, m02*m10 - m00*m12, - m10*m21 - m11*m20, m01*m20 - m00*m21, m00*m11 - m01*m10 - ); - mul(s); -} - - -template -T Matrix3::determinant() const { - // less *,+,- calculation than expanded expression. - return m00*(m11*m22 - m21*m12) - - m01*(m10*m22 - m20*m12) - + m02*(m10*m21 - m20*m11); -} - - -template -void Matrix3::set(T scale) { - m00 = scale; m01 = 0.0; m02 = 0.0; - m10 = 0.0; m11 = scale; m12 = 0.0; - m20 = 0.0; m21 = 0.0; m22 = scale; -} - -template -void Matrix3::rotX(T angle) { - T c = VmUtil::cos(angle); - T s = VmUtil::sin(angle); - m00 = 1.0; m01 = 0.0; m02 = 0.0; - m10 = 0.0; m11 = c; m12 = -s; - m20 = 0.0; m21 = s; m22 = c; -} - -template -void Matrix3::rotY(T angle) { - T c = VmUtil::cos(angle); - T s = VmUtil::sin(angle); - m00 = c; m01 = 0.0; m02 = s; - m10 = 0.0; m11 = 1.0; m12 = 0.0; - m20 = -s; m21 = 0.0; m22 = c; -} - -template -void Matrix3::rotZ(T angle) { - T c = VmUtil::cos(angle); - T s = VmUtil::sin(angle); - m00 = c; m01 = -s; m02 = 0.0; - m10 = s; m11 = c; m12 = 0.0; - m20 = 0.0; m21 = 0.0; m22 = 1.0; -} - -template -void Matrix3::mul(T scalar) { - m00 *= scalar; m01 *= scalar; m02 *= scalar; - m10 *= scalar; m11 *= scalar; m12 *= scalar; - m20 *= scalar; m21 *= scalar; m22 *= scalar; -} - -template -void Matrix3::mul(T scalar, const Matrix3& m1) { - set(m1); - mul(scalar); -} - -template -void Matrix3::mul(const Matrix3& m1) { - mul(*this, m1); -} - - -template -void Matrix3::mul(const Matrix3& m1, const Matrix3& m2) { - // alias-safe way. - set( - m1.m00*m2.m00 + m1.m01*m2.m10 + m1.m02*m2.m20, - m1.m00*m2.m01 + m1.m01*m2.m11 + m1.m02*m2.m21, - m1.m00*m2.m02 + m1.m01*m2.m12 + m1.m02*m2.m22, - - m1.m10*m2.m00 + m1.m11*m2.m10 + m1.m12*m2.m20, - m1.m10*m2.m01 + m1.m11*m2.m11 + m1.m12*m2.m21, - m1.m10*m2.m02 + m1.m11*m2.m12 + m1.m12*m2.m22, - - m1.m20*m2.m00 + m1.m21*m2.m10 + m1.m22*m2.m20, - m1.m20*m2.m01 + m1.m21*m2.m11 + m1.m22*m2.m21, - m1.m20*m2.m02 + m1.m21*m2.m12 + m1.m22*m2.m22 - ); -} - -template -void Matrix3::mulTransposeRight(const Matrix3& m1, const Matrix3& m2) { - // alias-safe way. - set( - m1.m00*m2.m00 + m1.m01*m2.m01 + m1.m02*m2.m02, - m1.m00*m2.m10 + m1.m01*m2.m11 + m1.m02*m2.m12, - m1.m00*m2.m20 + m1.m01*m2.m21 + m1.m02*m2.m22, - - m1.m10*m2.m00 + m1.m11*m2.m01 + m1.m12*m2.m02, - m1.m10*m2.m10 + m1.m11*m2.m11 + m1.m12*m2.m12, - m1.m10*m2.m20 + m1.m11*m2.m21 + m1.m12*m2.m22, - - m1.m20*m2.m00 + m1.m21*m2.m01 + m1.m22*m2.m02, - m1.m20*m2.m10 + m1.m21*m2.m11 + m1.m22*m2.m12, - m1.m20*m2.m20 + m1.m21*m2.m21 + m1.m22*m2.m22 - ); -} - -template -void Matrix3::mulTransposeLeft(const Matrix3& m1, const Matrix3& m2) { - // alias-safe way. - set( - m1.m00*m2.m00 + m1.m10*m2.m10 + m1.m20*m2.m20, - m1.m00*m2.m01 + m1.m10*m2.m11 + m1.m20*m2.m21, - m1.m00*m2.m02 + m1.m10*m2.m12 + m1.m20*m2.m22, - - m1.m01*m2.m00 + m1.m11*m2.m10 + m1.m21*m2.m20, - m1.m01*m2.m01 + m1.m11*m2.m11 + m1.m21*m2.m21, - m1.m01*m2.m02 + m1.m11*m2.m12 + m1.m21*m2.m22, - - m1.m02*m2.m00 + m1.m12*m2.m10 + m1.m22*m2.m20, - m1.m02*m2.m01 + m1.m12*m2.m11 + m1.m22*m2.m21, - m1.m02*m2.m02 + m1.m12*m2.m12 + m1.m22*m2.m22 - ); -} - - -template -bool Matrix3::equals(const Matrix3& m1) const { - return m00 == m1.m00 - && m01 == m1.m01 - && m02 == m1.m02 - && m10 == m1.m10 - && m11 == m1.m11 - && m12 == m1.m12 - && m20 == m1.m20 - && m21 == m1.m21 - && m22 == m1.m22; -} - -template -bool Matrix3::epsilonEquals(const Matrix3& m1, T epsilon) const { - return abs(m00 - m1.m00) <= epsilon - && abs(m01 - m1.m01) <= epsilon - && abs(m02 - m1.m02 ) <= epsilon - - && abs(m10 - m1.m10) <= epsilon - && abs(m11 - m1.m11) <= epsilon - && abs(m12 - m1.m12) <= epsilon - - && abs(m20 - m1.m20) <= epsilon - && abs(m21 - m1.m21) <= epsilon - && abs(m22 - m1.m22) <= epsilon; -} - - -template -void Matrix3::setZero() { - m00 = 0.0; m01 = 0.0; m02 = 0.0; - m10 = 0.0; m11 = 0.0; m12 = 0.0; - m20 = 0.0; m21 = 0.0; m22 = 0.0; -} - -template -void Matrix3::negate() { - m00 = -m00; m01 = -m01; m02 = -m02; - m10 = -m10; m11 = -m11; m12 = -m12; - m20 = -m20; m21 = -m21; m22 = -m22; -} - - -template -void Matrix3::transform(const Tuple3& t, Tuple3* result) const { - // alias-safe - result->set( - m00*t.x + m01*t.y + m02*t.z, - m10*t.x + m11*t.y + m12*t.z, - m20*t.x + m21*t.y + m22*t.z - ); -} - - -template -T Matrix3::SVD(Matrix3* rot) const { - // this is a simple svd. - // Not complete but fast and reasonable. - - /* - * SVD scale factors(squared) are the 3 roots of - * - * | xI - M*MT | = 0. - * - * This will be expanded as follows - * - * x^3 - A x^2 + B x - C = 0 - * - * where A, B, C can be denoted by 3 roots x0, x1, x2. - * - * A = (x0+x1+x2), B = (x0x1+x1x2+x2x0), C = x0x1x2. - * - * An avarage of x0,x1,x2 is needed here. C^(1/3) is a cross product - * normalization factor. - * So here, I use A/3. Note that x should be sqrt'ed for the - * actual factor. - */ - - T s = VmUtil::sqrt(( - m00*m00 + m10*m10 + m20*m20 + - m01*m01 + m11*m11 + m21*m21 + - m02*m02 + m12*m12 + m22*m22 - )/3.0 - ); - - if (rot) { - // zero-div may occur. - double n = 1/VmUtil::sqrt(m00*m00 + m10*m10 + m20*m20); - rot->m00 = m00*n; - rot->m10 = m10*n; - rot->m20 = m20*n; - - n = 1/VmUtil::sqrt(m01*m01 + m11*m11 + m21*m21); - rot->m01 = m01*n; - rot->m11 = m11*n; - rot->m21 = m21*n; - - n = 1/VmUtil::sqrt(m02*m02 + m12*m12 + m22*m22); - rot->m02 = m02*n; - rot->m12 = m12*n; - rot->m22 = m22*n; - } - - return s; -} - - -template -void Matrix3::setFromQuat(T x, T y, T z, T w) { - T n = x*x + y*y + z*z + w*w; - T s = (n > 0.0) ? (2.0/n) : 0.0; - - T xs = x*s, ys = y*s, zs = z*s; - T wx = w*xs, wy = w*ys, wz = w*zs; - T xx = x*xs, xy = x*ys, xz = x*zs; - T yy = y*ys, yz = y*zs, zz = z*zs; - - m00 = 1.0 - (yy + zz); m01 = xy - wz; m02 = xz + wy; - m10 = xy + wz; m11 = 1.0 - (xx + zz); m12 = yz - wx; - m20 = xz - wy; m21 = yz + wx; m22 = 1.0 - (xx + yy); -} - -template -void Matrix3::setFromAxisAngle(T x, T y, T z, T angle) { - // Taken from Rick's which is taken from Wertz. pg. 412 - // Bug Fixed and changed into right-handed by hiranabe - T n = VmUtil::sqrt(x*x + y*y + z*z); - // zero-div may occur - n = 1/n; - x *= n; - y *= n; - z *= n; - T c = VmUtil::cos(angle); - T s = VmUtil::sin(angle); - T omc = 1.0 - c; - m00 = c + x*x*omc; - m11 = c + y*y*omc; - m22 = c + z*z*omc; - - T tmp1 = x*y*omc; - T tmp2 = z*s; - m01 = tmp1 - tmp2; - m10 = tmp1 + tmp2; - - tmp1 = x*z*omc; - tmp2 = y*s; - m02 = tmp1 + tmp2; - m20 = tmp1 - tmp2; - - tmp1 = y*z*omc; - tmp2 = x*s; - m12 = tmp1 - tmp2; - m21 = tmp1 + tmp2; -} - -#ifdef VM_INCLUDE_TOSTRING -template -VM_STRING_STD::string Matrix3::toString() const { - VM_TOSTRING -} -#endif /* VM_INCLUDE_TOSTRING */ - -VM_END_NS - -#ifdef VM_INCLUDE_IO -template -VM_IOSTREAM_STD::ostream& operator<<(VM_IOSTREAM_STD::ostream& o, const VM_VECMATH_NS::Matrix3& t1) { - return o << - "[ ["< -VM_IOSTREAM_STD::istream& operator>>(VM_IOSTREAM_STD::istream& i, const VM_VECMATH_NS::Matrix3& t1) { - - char c; - - i >> c; - i >> c; - i >> (T) t1.m00; - i >> c; - i >> (T) t1.m01; - i >> c; - i >> (T) t1.m02; - i >> c; - i >> c; - i >> (T) t1.m10; - i >> c; - i >> (T) t1.m11; - i >> c; - i >> (T) t1.m12; - i >> c; - i >> c; - i >> (T) t1.m20; - i >> c; - i >> (T) t1.m21; - i >> c; - i >> (T) t1.m22; - i >> c; - i >> c; - - return i; -} -// Ende Änderung Marcus - -#endif /* VM_INCLUDE_IO */ - - -#endif /* MATRIX3_H */ diff --git a/Utilities/vecmath/Matrix3_.h b/Utilities/vecmath/Matrix3_.h deleted file mode 100644 index 80d6b9e311..0000000000 --- a/Utilities/vecmath/Matrix3_.h +++ /dev/null @@ -1,806 +0,0 @@ -/* - Copyright (C) 1997,1998,1999 - Kenji Hiranabe, Eiwa System Management, Inc. - - This program is free software. - Implemented by Kenji Hiranabe(hiranabe@esm.co.jp), - conforming to the Java(TM) 3D API specification by Sun Microsystems. - - Permission to use, copy, modify, distribute and sell this software - and its documentation for any purpose is hereby granted without fee, - provided that the above copyright notice appear in all copies and - that both that copyright notice and this permission notice appear - in supporting documentation. Kenji Hiranabe and Eiwa System Management,Inc. - makes no representations about the suitability of this software for any - purpose. It is provided "AS IS" with NO WARRANTY. -*/ -#ifndef MATRIX3__H -#define MATRIX3__H - -#include "VmUtil.h" -#include "Point3.h" -#include "Vector3.h" - -VM_BEGIN_NS - -template class Quat4; -template class AxisAngle4; - -/** - * A 3 x 3 matrix. - * Primarily to support rotations - * @version specification 1.1, implementation $Revision$, $Date$ - * @author Kenji hiranabe - */ -template -class Matrix3 { -protected: - static T abs(T t) { return VmUtil::abs(t); } - static T sin(T t) { return VmUtil::sin(t); } - static T cos(T t) { return VmUtil::cos(t); } -/* - * $Log$ - * Revision 1.3 2005/10/13 13:50:04 maleike - * FIX: doxygen warnings - * - * Revision 1.2 2003/04/22 14:42:11 max - * made inclusions of vecmath header files "local" (for gcc 3.3 support) - * - * Revision 1.1 2002/11/16 12:25:36 mark - * vecmath bibliothek - * in cvs, da einige bugs behoben - * - * Revision 1.3 1999/10/06 02:52:46 hiranabe - * Java3D 1.2 and namespace - * - * Revision 1.2 1999/05/26 00:59:37 hiranabe - * support Visual C++ - * - * Revision 1.1 1999/03/04 11:07:09 hiranabe - * Initial revision - * - * Revision 1.1 1999/03/04 11:07:09 hiranabe - * Initial revision - * - */ -public: - /** - * the type for values - */ - typedef T value_type; - /** - * the type for index - */ - typedef size_t size_type; - /** - * dimension - */ - enum { DIMENSION = 3 }; - /** - * the type for tuple - */ - typedef Tuple3 tuple_type; - /** - * the type for vector - */ - typedef Vector3 vector_type; - /** - * the type for point - */ - typedef Point3 point_type; - - /** - * The first element of the first row. - */ - T m00; - - /** - * The second element of the first row. - */ - T m01; - - /** - * third element of the first row. - */ - T m02; - - /** - * The first element of the second row. - */ - T m10; - - /** - * The second element of the second row. - */ - T m11; - - /** - * The third element of the second row. - */ - T m12; - - /** - * The first element of the third row. - */ - T m20; - - /** - * The second element of the third row. - */ - T m21; - - /** - * The third element of the third row. - */ - T m22; - - /** - * Constrcts and initializes a Matrix3 from the specified nine values. - * @param m00 the [0][0] element - * @param m01 the [0][1] element - * @param m02 the [0][2] element - * @param m10 the [1][0] element - * @param m11 the [1][1] element - * @param m12 the [1][2] element - * @param m20 the [2][0] element - * @param m21 the [2][1] element - * @param m22 the [2][2] element - */ - Matrix3(T m00, T m01, T m02, - T m10, T m11, T m12, - T m20, T m21, T m22); - - /** - * Constructs and initializes a Matrix3 from the specified 9 - * element array. this.m00 =v[0], this.m01=v[1], etc. - * @param v the array of length 9 containing in order - */ - Matrix3(const T v[]); - - /** - * Constructs and initializes a Matrix3 from the specified 3x3 - * element array. this.m00 =m[0][0], this.m01=m[0][1], etc. - * @param m the array of 3 x 3 containing in order - */ -#ifdef VM_INCLUDE_CONVERSION_FROM_2DARRAY - Matrix3(const T m[][3]); -#endif - -#if 0 - /** - * Constructs a new matrix with the same values as the Matrix3f parameter. - * @param m1 The source matrix. - */ - Matrix3(Matrix3f m1): - m00(m1.m00), m01(m1.m01), m02(m1.m02), - m10(m1.m10), m11(m1.m11), m12(m1.m12), - m20(m1.m20), m21(m1.m21), m22(m1.m22) { } -#endif - - /** - * Constructs and initializes a Matrix3 to all zeros. - */ - Matrix3(); - - /** - * Sets 9 values - * @param m00 the [0][0] element - * @param m01 the [0][1] element - * @param m02 the [0][2] element - * @param m10 the [1][0] element - * @param m11 the [1][1] element - * @param m12 the [1][2] element - * @param m20 the [2][0] element - * @param m21 the [2][1] element - * @param m22 the [2][2] element - */ - void set(T m00, T m01, T m02, - T m10, T m11, T m12, - T m20, T m21, T m22); - - /** - * Sets the value of this matrix to the value of the Matrix3 - * argument. - * @param m1 The source matrix. - */ - void set(const Matrix3& m1); - - /** - * Sets the values in this Matrix3 equal to the row-major array parameter - * (ie, the first four elements of the array will be copied into the first - * row of this matrix, etc.). - * @param m the array of length 9 containing in order - */ - void set(const T m[]); - - /** - * Sets the values in this Matrix3 equal to the row-major array parameter - * (ie, the first four elements of the array will be copied into the first - * row of this matrix, etc.). - * @param m the array of 3x3 containing in order (T m[3][3]) - */ -#ifdef VM_INCLUDE_CONVERSION_FROM_2DARRAY - void set(const T m[][3]); -#endif - - /** - * Sets this Matrix3 to identity. - */ - void setIdentity(); - - /** - * Sets the scale component of the current matrix by factoring out the - * current scale (by doing an SVD) from the rotational component and - * multiplying by the new scale. - * @param scale the new scale amount - */ - void setScale(T scale); - - /** - * Sets the specified element of this matrix3d to the value provided. - * @param row the row number to be modified (zero indexed) - * @param column the column number to be modified (zero indexed) - * @param value the new value - */ - void setElement(size_type row, size_type column, T value); - - /** - * Retrieves the value at the specified row and column of this matrix. - * @param row the row number to be retrieved (zero indexed) - * @param column the column number to be retrieved (zero indexed) - * @return the value at the indexed element - */ - T getElement(size_type row, size_type column) const; - - /** - * Retrieves the lvalue at the specified row and column of this matrix. - * @param row the row number to be retrieved (zero indexed) - * @param column the column number to be retrieved (zero indexed) - * @return the lvalue at the indexed element - */ - T& getElementReference(size_type row, size_type column); - - /** - * Sets the specified row of this matrix3d to the three values provided. - * @param row the row number to be modified (zero indexed) - * @param x the first column element - * @param y the second column element - * @param z the third column element - */ - void setRow(size_type row, T x, T y, T z); - - /** - * Sets the specified row of this matrix3d to the Vector provided. - * @param row the row number to be modified (zero indexed) - * @param v the replacement row - */ - void setRow(size_type row, const Vector3& v); - - /** - * Sets the specified row of this matrix3 to the four values provided. - * @param row the row number to be modified (zero indexed) - * @param v the replacement row - */ - void setRow(size_type row, const T v[]); - - /** - * Copies the matrix values in the specified row into the - * array parameter. - * @param row the matrix row - * @param v The array into which the matrix row values will be copied - */ - void getRow(size_type row, T v[]) const; - - /** - * Copies the matrix values in the specified row into the - * vector parameter. - * @param row the matrix row - * @param v The vector into which the matrix row values will be copied - */ - void getRow(size_type row, Vector3* v) const; - - /** - * Sets the specified column of this matrix3 to the three values provided. - * @param column the column number to be modified (zero indexed) - * @param x the first row element - * @param y the second row element - * @param z the third row element - */ - void setColumn(size_type column, T x, T y, T z); - - /** - * Sets the specified column of this matrix3d to the vector provided. - * @param column the column number to be modified (zero indexed) - * @param v the replacement column - */ - void setColumn(size_type column, const Vector3& v); - - /** - * Sets the specified column of this matrix3d to the four values provided. - * @param column the column number to be modified (zero indexed) - * @param v the replacement column - */ - void setColumn(size_type column, const T v[]); - - /** - * Copies the matrix values in the specified column into the vector - * parameter. - * @param column the matrix column - * @param v The vector into which the matrix row values will be copied - */ - void getColumn(size_type column, Vector3* v) const; - - /** - * Copies the matrix values in the specified column into the array - * parameter. - * @param column the matrix column - * @param v The array into which the matrix row values will be copied - */ - void getColumn(size_type column, T v[]) const; - - /** - * Performs an SVD normalization of this matrix to calculate and return the - * uniform scale factor. This matrix is not modified. - * @return the scale factor of this matrix - */ - T getScale() const; - - /** - * Adds a scalar to each component of this matrix. - * @param scalar The scalar adder. - */ - void add(T scalar); - - /** - * Subtracts a scalar from each component of this matrix. - * @param scalar The scalar adder. - */ - void sub(T scalar); - - /** - * Adds a scalar to each component of the matrix m1 and places - * the result into this. Matrix m1 is not modified. - * note this method is alias-safe. - * @param scalar The scalar adder. - * @param m1 The original matrix values. - */ - void add(T scalar, const Matrix3& m1); - - /** - * Sets the value of this matrix to the matrix sum of matrices m1 and m2. - * note this method is alias-safe. - * @param m1 the first matrix - * @param m2 the second matrix - */ - void add(const Matrix3& m1, const Matrix3& m2); - - /** - * Sets the value of this matrix to sum of itself and matrix m1. - * @param m1 the other matrix - */ - void add(const Matrix3& m1); - - /** - * Sets the value of this matrix to the matrix difference - * of matrices m1 and m2. - * note this method is alias-safe. - * @param m1 the first matrix - * @param m2 the second matrix - */ - void sub(const Matrix3& m1, const Matrix3& m2); - - /** - * Sets the value of this matrix to the matrix difference of itself - * and matrix m1 (this = this - m1). - * @param m1 the other matrix - */ - void sub(const Matrix3& m1); - - /** - * Sets the value of this matrix to its transpose. - */ - void transpose(); - - /** - * Sets the value of this matrix to the transpose of the argument matrix. - * note this method is alias-safe - * @param m1 the matrix to be transposed - */ - void transpose(const Matrix3& m1); - - /** - * Sets the value of this matrix to the matrix conversion of the - * quaternion argument. - * @param q1 the quaternion to be converted - */ - void set(const Quat4& q1); // moved to the implementation file - - /** - * Sets the value of this matrix to the matrix conversion of the - * axis and angle argument. - * @param a1 the axis and angle to be converted - */ - void set(const AxisAngle4& a1); // moved to the implementation file - -#if 0 - /** - * Sets the value of this matrix to the matrix conversion of the - * single precision quaternion argument. - * @param q1 the quaternion to be converted - */ - void set(Quat4f q1) { - setFromQuat(q1.x, q1.y, q1.z, q1.w); - } - - /** - * Sets the value of this matrix to the matrix conversion of the - * single precision axis and angle argument. - * @param a1 the axis and angle to be converted - */ - void set(AxisAngle4f a1) { - setFromAxisAngle(a1.x, a1.y, a1.z, a1.angle); - } - /** - * Sets the value of this matrix to the double value of the Matrix3f - * argument. - * @param m1 the matrix3f to be converted to double - */ - void set(Matrix3f m1) { - m00 = m1.m00; m01 = m1.m01; m02 = m1.m02; - m10 = m1.m10; m11 = m1.m11; m12 = m1.m12; - m20 = m1.m20; m21 = m1.m21; m22 = m1.m22; - } - -#endif - - /** - * Sets the value of this matrix to the matrix inverse - * of the passed matrix m1. - * @param m1 the matrix to be inverted - */ - void invert(const Matrix3& m1); - - /** - * Sets the value of this matrix to its inverse. - */ - void invert(); - - /** - * Computes the determinant of this matrix. - * @return the determinant of the matrix - */ - T determinant() const; - - /** - * Sets the value of this matrix to a scale matrix with the - * passed scale amount. - * @param scale the scale factor for the matrix - */ - void set(T scale); - - /** - * Sets the value of this matrix to a rotation matrix about the x axis - * by the passed angle. - * @param angle the angle to rotate about the X axis in radians - */ - void rotX(T angle); - - /** - * Sets the value of this matrix to a rotation matrix about the y axis - * by the passed angle. - * @param angle the angle to rotate about the Y axis in radians - */ - void rotY(T angle); - - /** - * Sets the value of this matrix to a rotation matrix about the z axis - * by the passed angle. - * @param angle the angle to rotate about the Z axis in radians - */ - void rotZ(T angle); - - /** - * Multiplies each element of this matrix by a scalar. - * @param scalar The scalar multiplier. - */ - void mul(T scalar); - - /** - * Multiplies each element of matrix m1 by a scalar and places the result - * into this. Matrix m1 is not modified. - * @param scalar The scalar multiplier. - * @param m1 The original matrix. - */ - void mul(T scalar, const Matrix3& m1); - - /** - * Sets the value of this matrix to the result of multiplying itself - * with matrix m1. - * @param m1 the other matrix - */ - void mul(const Matrix3& m1); - - /** - * Sets the value of this matrix to the result of multiplying - * the two argument matrices together. - * note this method is alias-safe. - * @param m1 the first matrix - * @param m2 the second matrix - */ - void mul(const Matrix3& m1, const Matrix3& m2); - - /** - * Multiplies this matrix by matrix m1, does an SVD normalization of the - * result, and places the result back into this matrix this = - * SVDnorm(this*m1). - * @param m1 the matrix on the right hand side of the multiplication - */ - void mulNormalize(const Matrix3& m1) { - mul(m1); - SVD(this); - } - - - /** - * Multiplies matrix m1 by matrix m2, does an SVD normalization of the - * result, and places the result into this matrix this = SVDnorm(m1*m2). - * @param m1 the matrix on the left hand side of the multiplication - * @param m2 the matrix on the right hand side of the multiplication - */ - void mulNormalize(const Matrix3& m1, const Matrix3& m2) { - mul(m1, m2); - SVD(this); - } - - /** - * Multiplies the transpose of matrix m1 times the transpose of matrix m2, - * and places the result into this. - * @param m1 The matrix on the left hand side of the multiplication - * @param m2 The matrix on the right hand side of the multiplication - */ - void mulTransposeBoth(const Matrix3& m1, const Matrix3& m2) { - mul(m2, m1); - transpose(); - } - - /** - * Multiplies matrix m1 times the transpose of matrix m2, and places the - * result into this. - * @param m1 The matrix on the left hand side of the multiplication - * @param m2 The matrix on the right hand side of the multiplication - */ - void mulTransposeRight(const Matrix3& m1, const Matrix3& m2); - - /** - * Multiplies the transpose of matrix m1 times matrix m2, and places the - * result into this. - * @param m1 The matrix on the left hand side of the multiplication - * @param m2 The matrix on the right hand side of the multiplication - */ - void mulTransposeLeft(const Matrix3& m1, const Matrix3& m2); - - /** - * Performs singular value decomposition normalization of this matrix. - */ - void normalize() { - SVD(this); - } - - /** - * Perform singular value decomposition normalization of matrix m1 and - * place the normalized values into this. - * @param m1 Provides the matrix values to be normalized - */ - void normalize(const Matrix3& m1) { - set(m1); - SVD(this); - } - - /** - * Perform cross product normalization of this matrix. - */ - void normalizeCP() { - T s = VmUtil::pow(VmUtil::abs(determinant()), T(-1.0/3.0)); - mul(s); - } - - /** - * Perform cross product normalization of matrix m1 and place the - * normalized values into this. - * @param m1 Provides the matrix values to be normalized - */ - void normalizeCP(const Matrix3& m1) { - set(m1); - normalizeCP(); - } - - - - /** - * Returns true if all of the data members of Matrix3 m1 are - * equal to the corresponding data members in this Matrix3. - * @param m1 The matrix with which the comparison is made. - * @return true or false - */ - bool equals(const Matrix3& m1) const; - - /** - * Returns true if the L-infinite distance between this matrix and matrix - * m1 is less than or equal to the epsilon parameter, otherwise returns - * false. The L-infinite distance is equal to MAX[i=0,1,2,3 ; j=0,1,2,3 ; - * abs(this.m(i,j) - m1.m(i,j)] - * @param m1 The matrix to be compared to this matrix - * @param epsilon the threshold value - */ - bool epsilonEquals(const Matrix3& m1, T epsilon) const; - - /** - * Sets this matrix to all zeros. - */ - void setZero(); - - /** - * Negates the value of this matrix: this = -this. - */ - void negate(); - - /** - * Sets the value of this matrix equal to the negation of of the Matrix3 - * parameter. - * @param m1 The source matrix - */ - void negate(const Matrix3& m1) { - set(m1); - negate(); - } - - /** - * Transform the vector vec using this Matrix3 and place the - * result back into vec. - * @param t the vector to be transformed - */ - void transform(Tuple3* t) const { - transform(*t, t); - } - - /** - * Transform the vector vec using this Matrix3 and place the - * result into vecOut. - * note this method is alias-safe - * @param t the double precision vector to be transformed - * @param result the vector into which the transformed values are placed - */ - void transform(const Tuple3& t, Tuple3* result) const; - - /** - * Returns a hash number based on the data values in this - * object. Two different Matrix3 objects with identical data values - * (ie, returns true for equals(Matrix3) ) will return the same hash - * number. Two objects with different data members may return the - * same hash value, although this is not likely. - * @return the integer hash value - */ - size_t hashCode() const { - return VmUtil::hashCode(sizeof *this, this); - } - - /** - * Returns a string that contains the values of this Matrix3. - * @return the String representation - */ -#ifdef VM_INCLUDE_TOSTRING -VM_STRING_STD::string toString() const; -#endif - -protected: - /** - * Performs SVD on this matrix and gets scale and rotation. - * Rotation is placed into rot. - * @param rot the rotation factor. if null, ignored - * @return scale factor - */ - T SVD(Matrix3* rot) const; - - /** - * Sets this from a Quat4 elements - */ - void setFromQuat(T x, T y, T z, T w); - - /** - * Sets this from a Quat4 elements - */ - void setFromAxisAngle(T x, T y, T z, T angle); - -public: - // copy constructor and operator = is made by complier - - bool operator==(const Matrix3& m1) const { - return equals(m1); - } -#ifdef VM_INCLUDE_SUBSCRIPTION_OPERATOR - T operator()(size_t row, size_t col) const { - return getElement(row, col); - } - T& operator()(size_t row, size_t col) { - return getElementReference(row, col); - } -#endif - - Matrix3& operator+=(const Matrix3& m1) { - add(m1); - return *this; - } - Matrix3& operator-=(const Matrix3& m1) { - sub(m1); - return *this; - } - Matrix3& operator*=(const Matrix3& m1) { - mul(m1); - return *this; - } - Matrix3& operator*=(T s) { - mul(s); - return *this; - } - Matrix3 operator+(const Matrix3& m1) const { - return (Matrix3(*this)).operator+=(m1); - } - Matrix3 operator-(const Matrix3& m1) const { - return (Matrix3(*this)).operator-=(m1); - } - Matrix3 operator*(const Matrix3& m1) const { - return (Matrix3(*this)).operator*=(m1); - } - Matrix3 operator*(T s) const { - return (Matrix3(*this)).operator*=(s); - } - -}; - -template -inline -Matrix3 operator*(T s, const Matrix3& m) { - return (Matrix3(m)).operator*=(s); -} - -template -inline -Matrix3 operator*(const Matrix3& m1, const Matrix3& m2) { - return (Matrix3(m1)).operator*=(m2); -} - -template -inline -Tuple3 operator*(const Matrix3& m, const Tuple3& t) { - Tuple3 out; - m.transform(t,&out); - return out; -} - -template -inline -Vector3 operator*(const Matrix3& m, const Vector3& t) { - return operator*(m, (const Tuple3&)t); -} - -template -inline -Point3 operator*(const Matrix3& m, const Point3& t) { - return operator*(m, (const Tuple3&)t); -} - -VM_END_NS - -#ifdef VM_INCLUDE_IO -template -VM_IOSTREAM_STD::ostream& operator<<(VM_IOSTREAM_STD::ostream& o, const VM_VECMATH_NS::Matrix3& t1); -#endif - -VM_BEGIN_NS - -typedef Matrix3 Matrix3d; -typedef Matrix3 Matrix3f; - -VM_END_NS - -#endif /* MATRIX3__H */ diff --git a/Utilities/vecmath/Matrix4.h b/Utilities/vecmath/Matrix4.h deleted file mode 100644 index 1fe89a785e..0000000000 --- a/Utilities/vecmath/Matrix4.h +++ /dev/null @@ -1,1275 +0,0 @@ -/* - Copyright (C) 1997,1998,1999 - Kenji Hiranabe, Eiwa System Management, Inc. - - This program is free software. - Implemented by Kenji Hiranabe(hiranabe@esm.co.jp), - conforming to the Java(TM) 3D API specification by Sun Microsystems. - - Permission to use, copy, modify, distribute and sell this software - and its documentation for any purpose is hereby granted without fee, - provided that the above copyright notice appear in all copies and - that both that copyright notice and this permission notice appear - in supporting documentation. Kenji Hiranabe and Eiwa System Management,Inc. - makes no representations about the suitability of this software for any - purpose. It is provided "AS IS" with NO WARRANTY. -*/ -#ifndef MATRIX4_H -#define MATRIX4_H - -#include "VmUtil.h" -#include "Quat4.h" // not very good. use temlate export later -#include "AxisAngle4.h" -#include "Matrix4_.h" -#include "Matrix3.h" // not very good. use template export later - -VM_BEGIN_NS - -template -Matrix4::Matrix4(T n00, T n01, T n02, T n03, - T n10, T n11, T n12, T n13, - T n20, T n21, T n22, T n23, - T n30, T n31, T n32, T n33): - m00(n00), m01(n01), m02(n02), m03(n03), - m10(n10), m11(n11), m12(n12), m13(n13), - m20(n20), m21(n21), m22(n22), m23(n23), - m30(n30), m31(n31), m32(n32), m33(n33) { } - -template -Matrix4::Matrix4(const T v[]): - m00(v[ 0]), m01(v[ 1]), m02(v[ 2]), m03(v[ 3]), - m10(v[ 4]), m11(v[ 5]), m12(v[ 6]), m13(v[ 7]), - m20(v[ 8]), m21(v[ 9]), m22(v[10]), m23(v[11]), - m30(v[12]), m31(v[13]), m32(v[14]), m33(v[15]) { } - -#ifdef VM_INCLUDE_CONVERSION_FROM_2DARRAY -template -Matrix4::Matrix4(const T v[][4]): - m00(v[0][0]), m01(v[0][1]), m02(v[0][2]), m03(v[0][3]), - m10(v[1][0]), m11(v[1][1]), m12(v[1][2]), m13(v[1][3]), - m20(v[2][0]), m21(v[2][1]), m22(v[2][2]), m23(v[2][3]), - m30(v[3][0]), m31(v[3][1]), m32(v[3][2]), m33(v[3][3]) { } -#endif - - -template -Matrix4::Matrix4(): - m00(0), m01(0), m02(0), m03(0), - m10(0), m11(0), m12(0), m13(0), - m20(0), m21(0), m22(0), m23(0), - m30(0), m31(0), m32(0), m33(0) { } - - -template -void Matrix4::set(T n00, T n01, T n02, T n03, - T n10, T n11, T n12, T n13, - T n20, T n21, T n22, T n23, - T n30, T n31, T n32, T n33) { - m00 = n00; m01 = n01; m02 = n02; m03 = n03; - m10 = n10; m11 = n11; m12 = n12; m13 = n13; - m20 = n20; m21 = n21; m22 = n22; m23 = n23; - m30 = n30; m31 = n31; m32 = n32; m33 = n33; -} - -template -void Matrix4::set(const Matrix4& m1) { - m00 = m1.m00; m01 = m1.m01; m02 = m1.m02; m03 = m1.m03; - m10 = m1.m10; m11 = m1.m11; m12 = m1.m12; m13 = m1.m13; - m20 = m1.m20; m21 = m1.m21; m22 = m1.m22; m23 = m1.m23; - m30 = m1.m30; m31 = m1.m31; m32 = m1.m32; m33 = m1.m33; -} - -template -void Matrix4::set(const T m[]) { - assert(m != 0); - m00 = m[ 0]; m01 = m[ 1]; m02 = m[ 2]; m03 = m[ 3]; - m10 = m[ 4]; m11 = m[ 5]; m12 = m[ 6]; m13 = m[ 7]; - m20 = m[ 8]; m21 = m[ 9]; m22 = m[10]; m23 = m[11]; - m30 = m[12]; m31 = m[13]; m32 = m[14]; m33 = m[15]; -} - -#ifdef VM_INCLUDE_CONVERSION_FROM_2DARRAY -template -void Matrix4::set(const T m[][4]) { - assert(m != 0); - m00 = v[0][0]; m01 = v[0][1]; m02 = v[0][2]; m03 = v[0][3]; - m10 = v[1][0]; m11 = v[1][1]; m12 = v[1][2]; m13 = v[1][3]; - m20 = v[2][0]; m21 = v[2][1]; m22 = v[2][2]; m23 = v[2][3]; - m30 = v[3][0]; m31 = v[3][1]; m32 = v[3][2]; m33 = v[3][3]; -} -#endif - -template -void Matrix4::set(const Matrix3& m1) { - m00 = m1.m00; m01 = m1.m01; m02 = m1.m02; m03 = 0.0; - m10 = m1.m10; m11 = m1.m11; m12 = m1.m12; m13 = 0.0; - m20 = m1.m20; m21 = m1.m21; m22 = m1.m22; m23 = 0.0; - m30 = 0.0; m31 = 0.0; m32 = 0.0; m33 = 1.0; -} - - -template -void Matrix4::set(const Quat4& q1) { - setFromQuat(q1.x, q1.y, q1.z, q1.w); -} - - -template -void Matrix4::set(const AxisAngle4& a1) { - setFromAxisAngle(a1.x, a1.y, a1.z, a1.angle); -} - -template -void Matrix4::setIdentity() { - m00 = 1.0; m01 = 0.0; m02 = 0.0; m03 = 0.0; - m10 = 0.0; m11 = 1.0; m12 = 0.0; m13 = 0.0; - m20 = 0.0; m21 = 0.0; m22 = 1.0; m23 = 0.0; - m30 = 0.0; m31 = 0.0; m32 = 0.0; m33 = 1.0; -} - -template -Matrix4::Matrix4(const Quat4& q1, const Vector3& t1, T s) { - set(q1, t1, s); -} - -template -Matrix4::Matrix4(const Matrix3& m1, const Vector3& t1, T s) { - set(m1, t1, s); -} - -template -void Matrix4::setElement(size_t row, size_t column, T value) { - assert(row < 4); - assert(column < 4); - if (row == 0) - if (column == 0) - m00 = value; - else if (column == 1) - m01 = value; - else if (column == 2) - m02 = value; - else if (column == 3) - m03 = value; - else - VM_OUT_OF_RANGE; - else if (row == 1) - if (column == 0) - m10 = value; - else if (column == 1) - m11 = value; - else if (column == 2) - m12 = value; - else if (column == 3) - m13 = value; - else - VM_OUT_OF_RANGE; - else if (row == 2) - if (column == 0) - m20 = value; - else if (column == 1) - m21 = value; - else if (column == 2) - m22 = value; - else if (column == 3) - m23 = value; - else - VM_OUT_OF_RANGE; - else if (row == 3) - if (column == 0) - m30 = value; - else if (column == 1) - m31 = value; - else if (column == 2) - m32 = value; - else if (column == 3) - m33 = value; - else - VM_OUT_OF_RANGE; - else - VM_OUT_OF_RANGE; -} - -template -T Matrix4::getElement(size_t row, size_t column) const { - if (row == 0) - if (column == 0) - return m00; - else if (column == 1) - return m01; - else if (column == 2) - return m02; - else if (column == 3) - return m03; - else - VM_OUT_OF_RANGE; - else if (row == 1) - if (column == 0) - return m10; - else if (column == 1) - return m11; - else if (column == 2) - return m12; - else if (column == 3) - return m13; - else - VM_OUT_OF_RANGE; - else if (row == 2) - if (column == 0) - return m20; - else if (column == 1) - return m21; - else if (column == 2) - return m22; - else if (column == 3) - return m23; - else - VM_OUT_OF_RANGE; - else if (row == 3) - if (column == 0) - return m30; - else if (column == 1) - return m31; - else if (column == 2) - return m32; - else if (column == 3) - return m33; - else - VM_OUT_OF_RANGE; - else - VM_OUT_OF_RANGE; - - // error! - return 0; -} - -template -T& Matrix4::getElementReference(size_t row, size_t column) { - if (row == 0) - if (column == 0) - return m00; - else if (column == 1) - return m01; - else if (column == 2) - return m02; - else if (column == 3) - return m03; - else - VM_OUT_OF_RANGE; - else if (row == 1) - if (column == 0) - return m10; - else if (column == 1) - return m11; - else if (column == 2) - return m12; - else if (column == 3) - return m13; - else - VM_OUT_OF_RANGE; - else if (row == 2) - if (column == 0) - return m20; - else if (column == 1) - return m21; - else if (column == 2) - return m22; - else if (column == 3) - return m23; - else - VM_OUT_OF_RANGE; - else if (row == 3) - if (column == 0) - return m30; - else if (column == 1) - return m31; - else if (column == 2) - return m32; - else if (column == 3) - return m33; - else - VM_OUT_OF_RANGE; - else - VM_OUT_OF_RANGE; - - // error anyway - static T dummy; - return dummy; -} - - - -template -void Matrix4::get(Matrix3* m1) const { - assert(m1 != 0); - SVD(m1, 0); -} - - -template -T Matrix4::get(Matrix3* m1, Vector3* t1) const { - assert(m1 != 0); - assert(t1 != 0); - get(t1); - return SVD(m1, 0); -} - -template -void Matrix4::get(Quat4* q1) const { - assert(q1 != 0); - - q1->set(*this); - q1->normalize(); -} - -template -void Matrix4::getRotationScale(Matrix3* m1) const { - assert(m1 != 0); - m1->m00 = m00; m1->m01 = m01; m1->m02 = m02; - m1->m10 = m10; m1->m11 = m11; m1->m12 = m12; - m1->m20 = m20; m1->m21 = m21; m1->m22 = m22; -} - -template -T Matrix4::getScale() const { - return SVD(0, 0); -} - -template -void Matrix4::setRotationScale(const Matrix3& m1) { - m00 = m1.m00; m01 = m1.m01; m02 = m1.m02; - m10 = m1.m10; m11 = m1.m11; m12 = m1.m12; - m20 = m1.m20; m21 = m1.m21; m22 = m1.m22; -} - -template -void Matrix4::setScale(T scale) { - // note: this don't change m44. - SVD(0, this); - mulRotationScale(scale); -} - -template -void Matrix4::setRow(size_t row, T x, T y, T z, T w) { - assert(row < 4); - if (row == 0) { - m00 = x; - m01 = y; - m02 = z; - m03 = w; - } else if (row == 1) { - m10 = x; - m11 = y; - m12 = z; - m13 = w; - } else if (row == 2) { - m20 = x; - m21 = y; - m22 = z; - m23 = w; - } else if (row == 3) { - m30 = x; - m31 = y; - m32 = z; - m33 = w; - } else { - VM_OUT_OF_RANGE; - } -} - -template -void Matrix4::setRow(size_t row, const Vector4& v) { - assert(row < 4); - if (row == 0) { - m00 = v.x; - m01 = v.y; - m02 = v.z; - m03 = v.w; - } else if (row == 1) { - m10 = v.x; - m11 = v.y; - m12 = v.z; - m13 = v.w; - } else if (row == 2) { - m20 = v.x; - m21 = v.y; - m22 = v.z; - m23 = v.w; - } else if (row == 3) { - m30 = v.x; - m31 = v.y; - m32 = v.z; - m33 = v.w; - } else { - VM_OUT_OF_RANGE; - } -} - -template -void Matrix4::setRow(size_t row, const T v[]) { - if (row == 0) { - m00 = v[0]; - m01 = v[1]; - m02 = v[2]; - m03 = v[3]; - } else if (row == 1) { - m10 = v[0]; - m11 = v[1]; - m12 = v[2]; - m13 = v[3]; - } else if (row == 2) { - m20 = v[0]; - m21 = v[1]; - m22 = v[2]; - m23 = v[3]; - } else if (row == 3) { - m30 = v[0]; - m31 = v[1]; - m32 = v[2]; - m33 = v[3]; - } else { - VM_OUT_OF_RANGE; - } -} - -template -void Matrix4::getRow(size_t row, Vector4* v) const { - assert(row < 4); - assert(v != 0); - if (row == 0) { - v->x = m00; - v->y = m01; - v->z = m02; - v->w = m03; - } else if (row == 1) { - v->x = m10; - v->y = m11; - v->z = m12; - v->w = m13; - } else if (row == 2) { - v->x = m20; - v->y = m21; - v->z = m22; - v->w = m23; - } else if (row == 3) { - v->x = m30; - v->y = m31; - v->z = m32; - v->w = m33; - } else { - VM_OUT_OF_RANGE; - } -} - -template -void Matrix4::getRow(size_t row, T v[]) const { - assert(row < 4); - if (row == 0) { - v[0] = m00; - v[1] = m01; - v[2] = m02; - v[3] = m03; - } else if (row == 1) { - v[0] = m10; - v[1] = m11; - v[2] = m12; - v[3] = m13; - } else if (row == 2) { - v[0] = m20; - v[1] = m21; - v[2] = m22; - v[3] = m23; - } else if (row == 3) { - v[0] = m30; - v[1] = m31; - v[2] = m32; - v[3] = m33; - } else { - VM_OUT_OF_RANGE; - } -} - -template -void Matrix4::setColumn(size_t column, T x, T y, T z, T w) { - assert(column < 4); - if (column == 0) { - m00 = x; - m10 = y; - m20 = z; - m30 = w; - } else if (column == 1) { - m01 = x; - m11 = y; - m21 = z; - m31 = w; - } else if (column == 2) { - m02 = x; - m12 = y; - m22 = z; - m32 = w; - } else if (column == 3) { - m03 = x; - m13 = y; - m23 = z; - m33 = w; - } else { - VM_OUT_OF_RANGE; - } -} - -template -void Matrix4::setColumn(size_t column, const Vector4& v) { - if (column == 0) { - m00 = v.x; - m10 = v.y; - m20 = v.z; - m30 = v.w; - } else if (column == 1) { - m01 = v.x; - m11 = v.y; - m21 = v.z; - m31 = v.w; - } else if (column == 2) { - m02 = v.x; - m12 = v.y; - m22 = v.z; - m32 = v.w; - } else if (column == 3) { - m03 = v.x; - m13 = v.y; - m23 = v.z; - m33 = v.w; - } else { - VM_OUT_OF_RANGE; - } -} - -template -void Matrix4::setColumn(size_t column, const T v[]) { - if (column == 0) { - m00 = v[0]; - m10 = v[1]; - m20 = v[2]; - m30 = v[3]; - } else if (column == 1) { - m01 = v[0]; - m11 = v[1]; - m21 = v[2]; - m31 = v[3]; - } else if (column == 2) { - m02 = v[0]; - m12 = v[1]; - m22 = v[2]; - m32 = v[3]; - } else if (column == 3) { - m03 = v[0]; - m13 = v[1]; - m23 = v[2]; - m33 = v[3]; - } else { - VM_OUT_OF_RANGE; - } -} - -template -void Matrix4::getColumn(size_t column, Vector4* v) const { - assert(column < 4); - assert(v != 0); - if (column == 0) { - v->x = m00; - v->y = m10; - v->z = m20; - v->w = m30; - } else if (column == 1) { - v->x = m01; - v->y = m11; - v->z = m21; - v->w = m31; - } else if (column == 2) { - v->x = m02; - v->y = m12; - v->z = m22; - v->w = m32; - } else if (column == 3) { - v->x = m03; - v->y = m13; - v->z = m23; - v->w = m33; - } else { - VM_OUT_OF_RANGE; - } -} - -template -void Matrix4::getColumn(size_t column, T v[]) const { - assert(column < 4); - assert(v != 0); - if (column == 0) { - v[0] = m00; - v[1] = m10; - v[2] = m20; - v[3] = m30; - } else if (column == 1) { - v[0] = m01; - v[1] = m11; - v[2] = m21; - v[3] = m31; - } else if (column == 2) { - v[0] = m02; - v[1] = m12; - v[2] = m22; - v[3] = m32; - } else if (column == 3) { - v[0] = m03; - v[1] = m13; - v[2] = m23; - v[3] = m33; - } else { - VM_OUT_OF_RANGE; - } -} - -template -void Matrix4::add(T scalar) { - m00 += scalar; m01 += scalar; m02 += scalar; m03 += scalar; - m10 += scalar; m11 += scalar; m12 += scalar; m13 += scalar; - m20 += scalar; m21 += scalar; m22 += scalar; m23 += scalar; - m30 += scalar; m31 += scalar; m32 += scalar; m33 += scalar; -} - -template -void Matrix4::sub(T scalar) { - add(-scalar); -} - -template -void Matrix4::add(const Matrix4& m1, const Matrix4& m2) { - // note this is alias safe. - set( - m1.m00 + m2.m00, - m1.m01 + m2.m01, - m1.m02 + m2.m02, - m1.m03 + m2.m03, - m1.m10 + m2.m10, - m1.m11 + m2.m11, - m1.m12 + m2.m12, - m1.m13 + m2.m13, - m1.m20 + m2.m20, - m1.m21 + m2.m21, - m1.m22 + m2.m22, - m1.m23 + m2.m23, - m1.m30 + m2.m30, - m1.m31 + m2.m31, - m1.m32 + m2.m32, - m1.m33 + m2.m33 - ); -} - -template -void Matrix4::add(const Matrix4& m1) { - m00 += m1.m00; m01 += m1.m01; m02 += m1.m02; m03 += m1.m03; - m10 += m1.m10; m11 += m1.m11; m12 += m1.m12; m13 += m1.m13; - m20 += m1.m20; m21 += m1.m21; m22 += m1.m22; m23 += m1.m23; - m30 += m1.m30; m31 += m1.m31; m32 += m1.m32; m33 += m1.m33; -} - - -template -void Matrix4::sub(const Matrix4& m1, const Matrix4& m2) { - // note this is alias safe. - set( - m1.m00 - m2.m00, - m1.m01 - m2.m01, - m1.m02 - m2.m02, - m1.m03 - m2.m03, - m1.m10 - m2.m10, - m1.m11 - m2.m11, - m1.m12 - m2.m12, - m1.m13 - m2.m13, - m1.m20 - m2.m20, - m1.m21 - m2.m21, - m1.m22 - m2.m22, - m1.m23 - m2.m23, - m1.m30 - m2.m30, - m1.m31 - m2.m31, - m1.m32 - m2.m32, - m1.m33 - m2.m33 - ); - } - -template -void Matrix4::sub(const Matrix4& m1) { - m00 -= m1.m00; m01 -= m1.m01; m02 -= m1.m02; m03 -= m1.m03; - m10 -= m1.m10; m11 -= m1.m11; m12 -= m1.m12; m13 -= m1.m13; - m20 -= m1.m20; m21 -= m1.m21; m22 -= m1.m22; m23 -= m1.m23; - m30 -= m1.m30; m31 -= m1.m31; m32 -= m1.m32; m33 -= m1.m33; -} - -template -void Matrix4::transpose() { - T tmp = m01; m01 = m10; m10 = tmp; - tmp = m02; m02 = m20; m20 = tmp; - tmp = m03; m03 = m30; m30 = tmp; - tmp = m12; m12 = m21; m21 = tmp; - tmp = m13; m13 = m31; m31 = tmp; - tmp = m23; m23 = m32; m32 = tmp; -} - - -template -void Matrix4::set(const Quat4& q1, const Vector3& t1, T s) { - set(q1); - mulRotationScale(s); - m03 = t1.x; - m13 = t1.y; - m23 = t1.z; -} - - -template -void Matrix4::invert(const Matrix4& m1) { - set(m1); - invert(); -} - - -template -void Matrix4::invert() { - T s = determinant(); - if (s == 0.0) - return; - s = 1/s; - // alias-safe way. - // less *,+,- calculation than expanded expression. - set( - m11*(m22*m33 - m23*m32) + m12*(m23*m31 - m21*m33) + m13*(m21*m32 - m22*m31), - m21*(m02*m33 - m03*m32) + m22*(m03*m31 - m01*m33) + m23*(m01*m32 - m02*m31), - m31*(m02*m13 - m03*m12) + m32*(m03*m11 - m01*m13) + m33*(m01*m12 - m02*m11), - m01*(m13*m22 - m12*m23) + m02*(m11*m23 - m13*m21) + m03*(m12*m21 - m11*m22), - - m12*(m20*m33 - m23*m30) + m13*(m22*m30 - m20*m32) + m10*(m23*m32 - m22*m33), - m22*(m00*m33 - m03*m30) + m23*(m02*m30 - m00*m32) + m20*(m03*m32 - m02*m33), - m32*(m00*m13 - m03*m10) + m33*(m02*m10 - m00*m12) + m30*(m03*m12 - m02*m13), - m02*(m13*m20 - m10*m23) + m03*(m10*m22 - m12*m20) + m00*(m12*m23 - m13*m22), - - m13*(m20*m31 - m21*m30) + m10*(m21*m33 - m23*m31) + m11*(m23*m30 - m20*m33), - m23*(m00*m31 - m01*m30) + m20*(m01*m33 - m03*m31) + m21*(m03*m30 - m00*m33), - m33*(m00*m11 - m01*m10) + m30*(m01*m13 - m03*m11) + m31*(m03*m10 - m00*m13), - m03*(m11*m20 - m10*m21) + m00*(m13*m21 - m11*m23) + m01*(m10*m23 - m13*m20), - - m10*(m22*m31 - m21*m32) + m11*(m20*m32 - m22*m30) + m12*(m21*m30 - m20*m31), - m20*(m02*m31 - m01*m32) + m21*(m00*m32 - m02*m30) + m22*(m01*m30 - m00*m31), - m30*(m02*m11 - m01*m12) + m31*(m00*m12 - m02*m10) + m32*(m01*m10 - m00*m11), - m00*(m11*m22 - m12*m21) + m01*(m12*m20 - m10*m22) + m02*(m10*m21 - m11*m20) - ); - - mul(s); -} - -template -T Matrix4::determinant() const { - // less *,+,- calculation than expanded expression. - return - (m00*m11 - m01*m10)*(m22*m33 - m23*m32) - -(m00*m12 - m02*m10)*(m21*m33 - m23*m31) - +(m00*m13 - m03*m10)*(m21*m32 - m22*m31) - +(m01*m12 - m02*m11)*(m20*m33 - m23*m30) - -(m01*m13 - m03*m11)*(m20*m32 - m22*m30) - +(m02*m13 - m03*m12)*(m20*m31 - m21*m30); -} - -template -void Matrix4::set(T scale) { - m00 = scale; m01 = 0.0; m02 = 0.0; m03 = 0.0; - m10 = 0.0; m11 = scale; m12 = 0.0; m13 = 0.0; - m20 = 0.0; m21 = 0.0; m22 = scale; m23 = 0.0; - m30 = 0.0; m31 = 0.0; m32 = 0.0; m33 = 1.0; -} - -template -void Matrix4::set(const Vector3& v1, T scale) { - m00 = scale; m01 = 0.0; m02 = 0.0; m03 = scale*v1.x; - m10 = 0.0; m11 = scale; m12 = 0.0; m13 = scale*v1.y; - m20 = 0.0; m21 = 0.0; m22 = scale; m23 = scale*v1.z; - m30 = 0.0; m31 = 0.0; m32 = 0.0; m33 = 1.0; -} - -template -void Matrix4::set(const Matrix3& m1, const Vector3& t1, T scale) { - setRotationScale(m1); - mulRotationScale(scale); - setTranslation(t1); - m33 = 1.0; -} - -template -void Matrix4::rotX(T angle) { - T c = VmUtil::cos(angle); - T s = VmUtil::sin(angle); - m00 = 1.0; m01 = 0.0; m02 = 0.0; m03 = 0.0; - m10 = 0.0; m11 = c; m12 = -s; m13 = 0.0; - m20 = 0.0; m21 = s; m22 = c; m23 = 0.0; - m30 = 0.0; m31 = 0.0; m32 = 0.0; m33 = 1.0; -} - - -template -void Matrix4::rotY(T angle) { - T c = VmUtil::cos(angle); - T s = VmUtil::sin(angle); - m00 = c; m01 = 0.0; m02 = s; m03 = 0.0; - m10 = 0.0; m11 = 1.0; m12 = 0.0; m13 = 0.0; - m20 = -s; m21 = 0.0; m22 = c; m23 = 0.0; - m30 = 0.0; m31 = 0.0; m32 = 0.0; m33 = 1.0; -} - - -template -void Matrix4::rotZ(T angle) { - T c = VmUtil::cos(angle); - T s = VmUtil::sin(angle); - m00 = c; m01 = -s; m02 = 0.0; m03 = 0.0; - m10 = s; m11 = c; m12 = 0.0; m13 = 0.0; - m20 = 0.0; m21 = 0.0; m22 = 1.0; m23 = 0.0; - m30 = 0.0; m31 = 0.0; m32 = 0.0; m33 = 1.0; -} - - -template -void Matrix4::mul(T scalar) { - m00 *= scalar; m01 *= scalar; m02 *= scalar; m03 *= scalar; - m10 *= scalar; m11 *= scalar; m12 *= scalar; m13 *= scalar; - m20 *= scalar; m21 *= scalar; m22 *= scalar; m23 *= scalar; - m30 *= scalar; m31 *= scalar; m32 *= scalar; m33 *= scalar; -} - - -template -void Matrix4::mul(const Matrix4& m1, const Matrix4& m2) { - // alias-safe way - set( - m1.m00*m2.m00 + m1.m01*m2.m10 + m1.m02*m2.m20 + m1.m03*m2.m30, - m1.m00*m2.m01 + m1.m01*m2.m11 + m1.m02*m2.m21 + m1.m03*m2.m31, - m1.m00*m2.m02 + m1.m01*m2.m12 + m1.m02*m2.m22 + m1.m03*m2.m32, - m1.m00*m2.m03 + m1.m01*m2.m13 + m1.m02*m2.m23 + m1.m03*m2.m33, - - m1.m10*m2.m00 + m1.m11*m2.m10 + m1.m12*m2.m20 + m1.m13*m2.m30, - m1.m10*m2.m01 + m1.m11*m2.m11 + m1.m12*m2.m21 + m1.m13*m2.m31, - m1.m10*m2.m02 + m1.m11*m2.m12 + m1.m12*m2.m22 + m1.m13*m2.m32, - m1.m10*m2.m03 + m1.m11*m2.m13 + m1.m12*m2.m23 + m1.m13*m2.m33, - - m1.m20*m2.m00 + m1.m21*m2.m10 + m1.m22*m2.m20 + m1.m23*m2.m30, - m1.m20*m2.m01 + m1.m21*m2.m11 + m1.m22*m2.m21 + m1.m23*m2.m31, - m1.m20*m2.m02 + m1.m21*m2.m12 + m1.m22*m2.m22 + m1.m23*m2.m32, - m1.m20*m2.m03 + m1.m21*m2.m13 + m1.m22*m2.m23 + m1.m23*m2.m33, - - m1.m30*m2.m00 + m1.m31*m2.m10 + m1.m32*m2.m20 + m1.m33*m2.m30, - m1.m30*m2.m01 + m1.m31*m2.m11 + m1.m32*m2.m21 + m1.m33*m2.m31, - m1.m30*m2.m02 + m1.m31*m2.m12 + m1.m32*m2.m22 + m1.m33*m2.m32, - m1.m30*m2.m03 + m1.m31*m2.m13 + m1.m32*m2.m23 + m1.m33*m2.m33 - ); -} - -template -void Matrix4::mulTransposeRight(const Matrix4& m1, const Matrix4& m2) { - // alias-safe way. - set( - m1.m00*m2.m00 + m1.m01*m2.m01 + m1.m02*m2.m02 + m1.m03*m2.m03, - m1.m00*m2.m10 + m1.m01*m2.m11 + m1.m02*m2.m12 + m1.m03*m2.m13, - m1.m00*m2.m20 + m1.m01*m2.m21 + m1.m02*m2.m22 + m1.m03*m2.m23, - m1.m00*m2.m30 + m1.m01*m2.m31 + m1.m02*m2.m32 + m1.m03*m2.m33, - - m1.m10*m2.m00 + m1.m11*m2.m01 + m1.m12*m2.m02 + m1.m13*m2.m03, - m1.m10*m2.m10 + m1.m11*m2.m11 + m1.m12*m2.m12 + m1.m13*m2.m13, - m1.m10*m2.m20 + m1.m11*m2.m21 + m1.m12*m2.m22 + m1.m13*m2.m23, - m1.m10*m2.m30 + m1.m11*m2.m31 + m1.m12*m2.m32 + m1.m13*m2.m33, - - m1.m20*m2.m00 + m1.m21*m2.m01 + m1.m22*m2.m02 + m1.m23*m2.m03, - m1.m20*m2.m10 + m1.m21*m2.m11 + m1.m22*m2.m12 + m1.m23*m2.m13, - m1.m20*m2.m20 + m1.m21*m2.m21 + m1.m22*m2.m22 + m1.m23*m2.m23, - m1.m20*m2.m30 + m1.m21*m2.m31 + m1.m22*m2.m32 + m1.m23*m2.m33, - - m1.m30*m2.m00 + m1.m31*m2.m01 + m1.m32*m2.m02 + m1.m33*m2.m03, - m1.m30*m2.m10 + m1.m31*m2.m11 + m1.m32*m2.m12 + m1.m33*m2.m13, - m1.m30*m2.m20 + m1.m31*m2.m21 + m1.m32*m2.m22 + m1.m33*m2.m23, - m1.m30*m2.m30 + m1.m31*m2.m31 + m1.m32*m2.m32 + m1.m33*m2.m33 - ); -} - - -template -void Matrix4::mulTransposeLeft(const Matrix4& m1, const Matrix4& m2) { - // alias-safe way. - set( - m1.m00*m2.m00 + m1.m10*m2.m10 + m1.m20*m2.m20 + m1.m30*m2.m30, - m1.m00*m2.m01 + m1.m10*m2.m11 + m1.m20*m2.m21 + m1.m30*m2.m31, - m1.m00*m2.m02 + m1.m10*m2.m12 + m1.m20*m2.m22 + m1.m30*m2.m32, - m1.m00*m2.m03 + m1.m10*m2.m13 + m1.m20*m2.m23 + m1.m30*m2.m33, - - m1.m01*m2.m00 + m1.m11*m2.m10 + m1.m21*m2.m20 + m1.m31*m2.m30, - m1.m01*m2.m01 + m1.m11*m2.m11 + m1.m21*m2.m21 + m1.m31*m2.m31, - m1.m01*m2.m02 + m1.m11*m2.m12 + m1.m21*m2.m22 + m1.m31*m2.m32, - m1.m01*m2.m03 + m1.m11*m2.m13 + m1.m21*m2.m23 + m1.m31*m2.m33, - - m1.m02*m2.m00 + m1.m12*m2.m10 + m1.m22*m2.m20 + m1.m32*m2.m30, - m1.m02*m2.m01 + m1.m12*m2.m11 + m1.m22*m2.m21 + m1.m32*m2.m31, - m1.m02*m2.m02 + m1.m12*m2.m12 + m1.m22*m2.m22 + m1.m32*m2.m32, - m1.m02*m2.m03 + m1.m12*m2.m13 + m1.m22*m2.m23 + m1.m32*m2.m33, - - m1.m03*m2.m00 + m1.m13*m2.m10 + m1.m23*m2.m20 + m1.m33*m2.m30, - m1.m03*m2.m01 + m1.m13*m2.m11 + m1.m23*m2.m21 + m1.m33*m2.m31, - m1.m03*m2.m02 + m1.m13*m2.m12 + m1.m23*m2.m22 + m1.m33*m2.m32, - m1.m03*m2.m03 + m1.m13*m2.m13 + m1.m23*m2.m23 + m1.m33*m2.m33 - ); -} - -template -bool Matrix4::equals(const Matrix4& m1) const { - return m00 == m1.m00 - && m01 == m1.m01 - && m02 == m1.m02 - && m03 == m1.m03 - && m10 == m1.m10 - && m11 == m1.m11 - && m12 == m1.m12 - && m13 == m1.m13 - && m20 == m1.m20 - && m21 == m1.m21 - && m22 == m1.m22 - && m23 == m1.m23 - && m30 == m1.m30 - && m31 == m1.m31 - && m32 == m1.m32 - && m33 == m1.m33; -} - -template -bool Matrix4::epsilonEquals(const Matrix4& m1, T epsilon) const { - return abs(m00 - m1.m00) <= epsilon - && abs(m01 - m1.m01) <= epsilon - && abs(m02 - m1.m02 ) <= epsilon - && abs(m03 - m1.m03) <= epsilon - - && abs(m10 - m1.m10) <= epsilon - && abs(m11 - m1.m11) <= epsilon - && abs(m12 - m1.m12) <= epsilon - && abs(m13 - m1.m13) <= epsilon - - && abs(m20 - m1.m20) <= epsilon - && abs(m21 - m1.m21) <= epsilon - && abs(m22 - m1.m22) <= epsilon - && abs(m23 - m1.m23) <= epsilon - - && abs(m30 - m1.m30) <= epsilon - && abs(m31 - m1.m31) <= epsilon - && abs(m32 - m1.m32) <= epsilon - && abs(m33 - m1.m33) <= epsilon; -} - - - -template -void Matrix4::transform(const Tuple4& vec, Tuple4* vecOut) const { - // alias-safe - assert(vecOut != 0); - vecOut->set( - m00*vec.x + m01*vec.y + m02*vec.z + m03*vec.w, - m10*vec.x + m11*vec.y + m12*vec.z + m13*vec.w, - m20*vec.x + m21*vec.y + m22*vec.z + m23*vec.w, - m30*vec.x + m31*vec.y + m32*vec.z + m33*vec.w - ); -} - - -template -void Matrix4::transform(const Point3& point, Point3* pointOut) const { - assert(pointOut != 0); - pointOut->set( - m00*point.x + m01*point.y + m02*point.z + m03, - m10*point.x + m11*point.y + m12*point.z + m13, - m20*point.x + m21*point.y + m22*point.z + m23 - ); -} - - -template -void Matrix4::transform(const Vector3& normal, Vector3* normalOut) const { - normalOut->set( - m00 * normal.x + m01 * normal.y + m02 * normal.z, - m10 * normal.x + m11 * normal.y + m12 * normal.z, - m20 * normal.x + m21 * normal.y + m22 * normal.z - ); -} - - -template -void Matrix4::setRotation(const Matrix3& m1) { - T scale = SVD(0, 0); - setRotationScale(m1); - mulRotationScale(scale); -} - - -template -void Matrix4::setRotation(const Quat4& q1) { - T scale = SVD(0, 0); - // save other values - T tx = m03; - T ty = m13; - T tz = m23; - T w0 = m30; - T w1 = m31; - T w2 = m32; - T w3 = m33; - - set(q1); - mulRotationScale(scale); - - // set back - m03 = tx; - m13 = ty; - m23 = tz; - m30 = w0; - m31 = w1; - m32 = w2; - m33 = w3; -} - - -template -void Matrix4::setRotation(const AxisAngle4& a1) { - T scale = SVD(0, 0); - // save other values - T tx = m03; - T ty = m13; - T tz = m23; - T w0 = m30; - T w1 = m31; - T w2 = m32; - T w3 = m33; - - set(a1); - mulRotationScale(scale); - - // set back - m03 = tx; - m13 = ty; - m23 = tz; - m30 = w0; - m31 = w1; - m32 = w2; - m33 = w3; -} - - -template -void Matrix4::setZero() { - m00 = 0.0; m01 = 0.0; m02 = 0.0; m03 = 0.0; - m10 = 0.0; m11 = 0.0; m12 = 0.0; m13 = 0.0; - m20 = 0.0; m21 = 0.0; m22 = 0.0; m23 = 0.0; - m30 = 0.0; m31 = 0.0; m32 = 0.0; m33 = 0.0; -} - - -template -void Matrix4::negate() { - m00 = -m00; m01 = -m01; m02 = -m02; m03 = -m03; - m10 = -m10; m11 = -m11; m12 = -m12; m13 = -m13; - m20 = -m20; m21 = -m21; m22 = -m22; m23 = -m23; - m30 = -m30; m31 = -m31; m32 = -m32; m33 = -m33; -} - - -template -T Matrix4::SVD(Matrix3* rot3, Matrix4* rot4) const { - // this is a simple svd. - // Not complete but fast and reasonable. - // See comment in Matrix3d. - - T s = VmUtil::sqrt( - ( - m00*m00 + m10*m10 + m20*m20 + - m01*m01 + m11*m11 + m21*m21 + - m02*m02 + m12*m12 + m22*m22 - )/3.0 - ); - - if (rot3) { - this->getRotationScale(rot3); - // zero-div may occur. - double n = 1/VmUtil::sqrt(m00*m00 + m10*m10 + m20*m20); - rot3->m00 *= n; - rot3->m10 *= n; - rot3->m20 *= n; - - n = 1/VmUtil::sqrt(m01*m01 + m11*m11 + m21*m21); - rot3->m01 *= n; - rot3->m11 *= n; - rot3->m21 *= n; - - n = 1/VmUtil::sqrt(m02*m02 + m12*m12 + m22*m22); - rot3->m02 *= n; - rot3->m12 *= n; - rot3->m22 *= n; - } - - if (rot4) { - if (rot4 != this) - rot4->setRotationScale(*this); // private method - - // zero-div may occur. - double n = 1/VmUtil::sqrt(m00*m00 + m10*m10 + m20*m20); - rot4->m00 *= n; - rot4->m10 *= n; - rot4->m20 *= n; - - n = 1/VmUtil::sqrt(m01*m01 + m11*m11 + m21*m21); - rot4->m01 *= n; - rot4->m11 *= n; - rot4->m21 *= n; - - n = 1/VmUtil::sqrt(m02*m02 + m12*m12 + m22*m22); - rot4->m02 *= n; - rot4->m12 *= n; - rot4->m22 *= n; - } - - return s; -} - - -template -void Matrix4::mulRotationScale(T scale) { - m00 *= scale; m01 *= scale; m02 *= scale; - m10 *= scale; m11 *= scale; m12 *= scale; - m20 *= scale; m21 *= scale; m22 *= scale; -} - - -template -void Matrix4::setRotationScale(const Matrix4& m1) { - m00 = m1.m00; m01 = m1.m01; m02 = m1.m02; - m10 = m1.m10; m11 = m1.m11; m12 = m1.m12; - m20 = m1.m20; m21 = m1.m21; m22 = m1.m22; -} - - -template -void Matrix4::setFromQuat(T x, T y, T z, T w) { - T n = x*x + y*y + z*z + w*w; - T s = (n > 0.0) ? (2.0/n) : 0.0; - - T xs = x*s, ys = y*s, zs = z*s; - T wx = w*xs, wy = w*ys, wz = w*zs; - T xx = x*xs, xy = x*ys, xz = x*zs; - T yy = y*ys, yz = y*zs, zz = z*zs; - - setIdentity(); - m00 = 1.0 - (yy + zz); m01 = xy - wz; m02 = xz + wy; - m10 = xy + wz; m11 = 1.0 - (xx + zz); m12 = yz - wx; - m20 = xz - wy; m21 = yz + wx; m22 = 1.0 - (xx + yy); -} - - -template -void Matrix4::setFromAxisAngle(T x, T y, T z, T angle) { - // Taken from Rick's which is taken from Wertz. pg. 412 - // Bug Fixed and changed into right-handed by hiranabe - T n = VmUtil::sqrt(x*x + y*y + z*z); - // zero-div may occur - n = 1/n; - x *= n; - y *= n; - z *= n; - T c = VmUtil::cos(angle); - T s = VmUtil::sin(angle); - T omc = 1.0 - c; - m00 = c + x*x*omc; - m11 = c + y*y*omc; - m22 = c + z*z*omc; - - T tmp1 = x*y*omc; - T tmp2 = z*s; - m01 = tmp1 - tmp2; - m10 = tmp1 + tmp2; - - tmp1 = x*z*omc; - tmp2 = y*s; - m02 = tmp1 + tmp2; - m20 = tmp1 - tmp2; - - tmp1 = y*z*omc; - tmp2 = x*s; - m12 = tmp1 - tmp2; - m21 = tmp1 + tmp2; -} - -#ifdef VM_INCLUDE_TOSTRING -template -VM_STRING_STD::string Matrix4::toString() const { - VM_TOSTRING -} -#endif /* VM_INCLUDE_TOSTRING */ - -VM_END_NS - -#ifdef VM_INCLUDE_IO -template -VM_IOSTREAM_STD::ostream& operator<<(VM_IOSTREAM_STD::ostream& o, const VM_VECMATH_NS::Matrix4& t1) { - return o << - "[ ["< -VM_IOSTREAM_STD::istream& operator>>(VM_IOSTREAM_STD::istream& i, const VM_VECMATH_NS::Matrix4& m ) { - - char c; - - i >> c; - i >> c; - i >> (T) m.m00; - i >> c; - i >> (T) m.m01; - i >> c; - i >> (T) m.m02; - i >> c; - i >> (T) m.m03; - i >> c; - i>> c; - i >> (T) m.m10; - i >> c; - i >> (T) m.m11; - i >> c; - i >> (T) m.m12; - i >> c; - i >> (T) m.m13; - i >> c; - i >> c; - i >> (T) m.m20; - i >> c; - i >> (T) m.m21; - i >> c; - i >> (T) m.m22; - i >> c; - i >> (T) m.m23; - i >> c; - i >> c; - i >> (T) m.m30; - i >> c; - i >> (T) m.m31; - i >> c; - i >> (T) m.m32; - i >> c; - i >> (T) m.m33; - i >> c; - i >> c; - - return i; -} - -#endif - - -#endif /* MATRIX4_H */ diff --git a/Utilities/vecmath/Matrix4_.h b/Utilities/vecmath/Matrix4_.h deleted file mode 100644 index adc840531b..0000000000 --- a/Utilities/vecmath/Matrix4_.h +++ /dev/null @@ -1,1383 +0,0 @@ -/* - Copyright (C) 1997,1998,1999 - Kenji Hiranabe, Eiwa System Management, Inc. - - This program is free software. - Implemented by Kenji Hiranabe(hiranabe@esm.co.jp), - conforming to the Java(TM) 3D API specification by Sun Microsystems. - - Permission to use, copy, modify, distribute and sell this software - and its documentation for any purpose is hereby granted without fee, - provided that the above copyright notice appear in all copies and - that both that copyright notice and this permission notice appear - in supporting documentation. Kenji Hiranabe and Eiwa System Management,Inc. - makes no representations about the suitability of this software for any - purpose. It is provided "AS IS" with NO WARRANTY. -*/ -#ifndef MATRIX4__H -#define MATRIX4__H - -#include "VmUtil.h" -#include "Matrix3_.h" -#include "Vector4.h" -#include "Point4.h" - -VM_BEGIN_NS - -/** - * A 4 x 4 matrix. - * @version specification 1.1, implementation $Revision$, $Date$ - * @author Kenji hiranabe - */ -template -class Matrix4 { -protected: - static T abs(T t) { return VmUtil::abs(t); } -/* - * $Log$ - * Revision 1.3 2005/10/13 13:50:04 maleike - * FIX: doxygen warnings - * - * Revision 1.2 2003/04/22 14:42:11 max - * made inclusions of vecmath header files "local" (for gcc 3.3 support) - * - * Revision 1.1 2002/11/16 12:25:36 mark - * vecmath bibliothek - * in cvs, da einige bugs behoben - * - * Revision 1.3 1999/10/06 02:52:46 hiranabe - * Java3D 1.2 and namespace - * - * Revision 1.2 1999/05/26 00:59:37 hiranabe - * support Visual C++ - * - * Revision 1.1 1999/03/04 11:07:09 hiranabe - * Initial revision - * - * Revision 1.1 1999/03/04 11:07:09 hiranabe - * Initial revision - * - */ -public: - /** - * the type for values - */ - typedef T value_type; - /** - * the type for index - */ - typedef size_t size_type; - /** - * dimension - */ - enum { DIMENSION = 4 }; - /** - * the type for tuple - */ - typedef Tuple4 tuple_type; - /** - * the type for vector - */ - typedef Vector4 vector_type; - /** - * the type for point - */ - typedef Point4 point_type; - - /** - * The first element of the first row. - */ - T m00; - - /** - * The second element of the first row. - */ - T m01; - - /** - * third element of the first row. - */ - T m02; - - /** - * The fourth element of the first row. - */ - T m03; - - /** - * The first element of the second row. - */ - T m10; - - /** - * The second element of the second row. - */ - T m11; - - /** - * The third element of the second row. - */ - T m12; - - /** - * The fourth element of the second row. - */ - T m13; - - /** - * The first element of the third row. - */ - T m20; - - /** - * The second element of the third row. - */ - T m21; - - /** - * The third element of the third row. - */ - T m22; - - /** - * The fourth element of the third row. - */ - T m23; - - /** - * The first element of the fourth row. - */ - T m30; - - /** - * The second element of the fourth row. - */ - T m31; - - /** - * The third element of the fourth row. - */ - T m32; - - /** - * The fourth element of the fourth row. - */ - T m33; - - /** - * Constructs and initializes a Matrix4 from the specified 16 values. - * @param m00 the [0][0] element - * @param m01 the [0][1] element - * @param m02 the [0][2] element - * @param m03 the [0][3] element - * @param m10 the [1][0] element - * @param m11 the [1][1] element - * @param m12 the [1][2] element - * @param m13 the [1][3] element - * @param m20 the [2][0] element - * @param m21 the [2][1] element - * @param m22 the [2][2] element - * @param m23 the [2][3] element - * @param m30 the [3][0] element - * @param m31 the [3][1] element - * @param m32 the [3][2] element - * @param m33 the [3][3] element - */ - Matrix4(T m00, T m01, T m02, T m03, - T m10, T m11, T m12, T m13, - T m20, T m21, T m22, T m23, - T m30, T m31, T m32, T m33); - - /** - * Constructs and initializes a Matrix4 from the specified 16 - * element array. this.m00 =v[0], this.m01=v[1], etc. - * @param v the array of length 16 containing in order - */ - Matrix4(const T v[]); - - /** - * Constructs and initializes a Matrix4 from the specified 4x4 - * element array. this.m00 =m[0][0], this.m01=m[0][1], etc. - * @param m the array of 4 x 4 containing in order - */ - Matrix4(const T m[][4]); - - /** - * Constructs and initializes a Matrix4 from the quaternion, - * translation, and scale values; the scale is applied only to the - * rotational components of the matrix (upper 3x3) and not to the - * translational components. - * @param q1 The quaternion value representing the rotational component - * @param t1 The translational component of the matrix - * @param s The scale value applied to the rotational components - */ - Matrix4(const Quat4& q1, const Vector3& t1, T s); - -#if 0 - /** - * Constructs and initializes a Matrix4 from the quaternion, - * translation, and scale values; the scale is applied only to the - * rotational components of the matrix (upper 3x3) and not to the - * translational components. - * @param q1 The quaternion value representing the rotational component - * @param t1 The translational component of the matrix - * @param s The scale value applied to the rotational components - */ - Matrix4(Quat4f q1, Vector3d t1, T s) { - set(q1, t1, s); - } - - /** - * Constructs a new matrix with the same values as the Matrix4f parameter. - * @param m1 The source matrix. - */ - Matrix4(Matrix4f m1) { - set(m1); - } - - /** - * Constructs and initializes a Matrix4 from the rotation matrix, - * translation, and scale values; the scale is applied only to the - * rotational components of the matrix (upper 3x3) and not to the - * translational components. - * @param m1 The rotation matrix representing the rotational components - * @param t1 The translational components of the matrix - * @param s The scale value applied to the rotational components - */ - Matrix4(Matrix3f m1, Vector3d t1, T s) { - // why no set(Matrix3f, Vector3d, T) ? - // set(Matrix3f, Vector3f, float) is there. - // feel inconsistent. - set(m1); - mulRotationScale(s); - setTranslation(t1); - m33 = 1.0; - } -#endif - - /** - * Constructs and initializes a Matrix4 from the rotation matrix, - * translation, and scale values; the scale is applied only to the - * rotational components of the matrix (upper 3x3) and not to the - * translational components. - * @param m1 The rotation matrix representing the rotational components - * @param t1 The translational components of the matrix - * @param s The scale value applied to the rotational components - */ - Matrix4(const Matrix3& m1, const Vector3& t1, T s); - - /** - * Constructs and initializes a Matrix4 to all zeros. - */ - Matrix4(); - - /** - * Sets 16 values - * @param m00 the [0][0] element - * @param m01 the [0][1] element - * @param m02 the [0][2] element - * @param m03 the [0][3] element - * @param m10 the [1][0] element - * @param m11 the [1][1] element - * @param m12 the [1][2] element - * @param m13 the [1][3] element - * @param m20 the [2][0] element - * @param m21 the [2][1] element - * @param m22 the [2][2] element - * @param m23 the [2][3] element - * @param m30 the [3][0] element - * @param m31 the [3][1] element - * @param m32 the [3][2] element - * @param m33 the [3][3] element - */ - void set(T m00, T m01, T m02, T m03, - T m10, T m11, T m12, T m13, - T m20, T m21, T m22, T m23, - T m30, T m31, T m32, T m33); - - /** - * Sets the values in this Matrix4 equal to the row-major array parameter - * (ie, the first four elements of the array will be copied into the first - * row of this matrix, etc.). - */ - void set(const T m[]); - - /** - * Sets the values in this Matrix4 equal to the row-major array parameter - * (ie, the first four elements of the array will be copied into the first - * row of this matrix, etc.). - */ - void set(const T m[][4]); - - /** - * Sets the value of this matrix to a copy of the - * passed matrix m1. - * @param m1 the matrix to be copied - */ - void set(const Matrix4& m1); - - /** - * Sets the rotational component (upper 3x3) of this matrix to the matrix - * values in the T precision Matrix3d argument; the other elements of - * this matrix are initialized as if this were an identity matrix - * (ie, affine matrix with no translational component). - * @param m1 the 3x3 matrix - */ - void set(const Matrix3& m1); - - /** - * Sets the value of this matrix to the matrix conversion of the - * (T precision) quaternion argument. - * @param q1 the quaternion to be converted - */ - void set(const Quat4& q1); - - /** - * Sets the value of this matrix to the matrix conversion of the - * T precision axis and angle argument. - * @param a1 the axis and angle to be converted - */ - void set(const AxisAngle4& a1); - - /** - * Sets this Matrix4 to identity. - */ - void setIdentity(); - - /** - * Sets the specified element of this matrix4d to the value provided. - * @param row the row number to be modified (zero indexed) - * @param column the column number to be modified (zero indexed) - * @param value the new value - */ - void setElement(size_t row, size_t column, T value); - - /** - * Retrieves the value at the specified row and column of this matrix. - * @param row the row number to be retrieved (zero indexed) - * @param column the column number to be retrieved (zero indexed) - * @return the value at the indexed element - */ - T getElement(size_t row, size_t column) const; - - /** - * Retrieves the lvalue at the specified row and column of this matrix. - * @param row the row number to be retrieved (zero indexed) - * @param column the column number to be retrieved (zero indexed) - * @return the lvalue at the indexed element - */ - T& getElementReference(size_type row, size_type column); - - /** - * Performs an SVD normalization of this matrix in order to acquire the - * normalized rotational component; the values are placed into the Matrix3d parameter. - * @param m1 matrix into which the rotational component is placed - */ - void get(Matrix3* m1) const; - -#if 0 - /** - * Performs an SVD normalization of this matrix in order to acquire the - * normalized rotational component; the values are placed into the Matrix3f parameter. - * @param m1 matrix into which the rotational component is placed - */ - void get(Matrix3f m1) const{ - SVD(m1); - } -#endif - - /** - * Performs an SVD normalization of this matrix to calculate the rotation - * as a 3x3 matrix, the translation, and the scale. None of the matrix values are modified. - * @param m1 The normalized matrix representing the rotation - * @param t1 The translation component - * @return The scale component of this transform - */ - T get(Matrix3* m1, Vector3* t1) const; - - /** - * Performs an SVD normalization of this matrix in order to acquire the - * normalized rotational component; the values are placed into - * the Quat4f parameter. - * @param q1 quaternion into which the rotation component is placed - */ - void get(Quat4* q1) const; - -#if 0 - /** - * Performs an SVD normalization of this matrix to calculate the rotation - * as a 3x3 matrix, the translation, and the scale. None of the matrix values are modified. - * @param m1 The normalized matrix representing the rotation - * @param t1 The translation component - * @return The scale component of this transform - */ - T get(Matrix3f m1, Vector3d t1) { - get(t1); - return SVD(m1); - } - - /** - * Performs an SVD normalization of this matrix in order to acquire the - * normalized rotational component; the values are placed into - * the Quat4f parameter. - * @param q1 quaternion into which the rotation component is placed - */ - void get(Quat4f q1) { - q1.set(this); - q1.normalize(); - } - - - /** - * Gets the upper 3x3 values of this matrix and places them into the matrix m1. - * @param m1 The matrix that will hold the values - */ - void getRotationScale(Matrix3f m1) { - m1.m00 = (float)m00; m1.m01 = (float)m01; m1.m02 = (float)m02; - m1.m10 = (float)m10; m1.m11 = (float)m11; m1.m12 = (float)m12; - m1.m20 = (float)m20; m1.m21 = (float)m21; m1.m22 = (float)m22; - } -#endif - - /** - * Retrieves the translational components of this matrix. - * @param trans the vector that will receive the translational component - */ - void get(Vector3* trans) const { - assert(trans != 0); - trans->x = m03; - trans->y = m13; - trans->z = m23; - } - - - /** - * Gets the upper 3x3 values of this matrix and places them into the matrix m1. - * @param m1 The matrix that will hold the values - */ - void getRotationScale(Matrix3* m1) const; - - /** - * Performs an SVD normalization of this matrix to calculate and return the - * uniform scale factor. This matrix is not modified. - * @return the scale factor of this matrix - */ - T getScale() const; - - /** - * Replaces the upper 3x3 matrix values of this matrix with the values in the matrix m1. - * @param m1 The matrix that will be the new upper 3x3 - */ - void setRotationScale(const Matrix3& m1); - -#if 0 - /** - * Replaces the upper 3x3 matrix values of this matrix with the values in the matrix m1. - * @param m1 The matrix that will be the new upper 3x3 - */ - void setRotationScale(Matrix3f m1) { - m00 = m1.m00; m01 = m1.m01; m02 = m1.m02; - m10 = m1.m10; m11 = m1.m11; m12 = m1.m12; - m20 = m1.m20; m21 = m1.m21; m22 = m1.m22; - } -#endif - - /** - * Sets the scale component of the current matrix by factoring out the - * current scale (by doing an SVD) from the rotational component and - * multiplying by the new scale. - * note: this method doesn't change m44. - * @param scale the new scale amount - */ - void setScale(T scale); - - /** - * Sets the specified row of this matrix4d to the four values provided. - * @param row the row number to be modified (zero indexed) - * @param x the first column element - * @param y the second column element - * @param z the third column element - * @param w the fourth column element - */ - void setRow(size_t row, T x, T y, T z, T w); - - /** - * Sets the specified row of this matrix4d to the Vector provided. - * @param row the row number to be modified (zero indexed) - * @param v the replacement row - */ - void setRow(size_t row, const Vector4& v); - - /** - * Sets the specified row of this matrix4d to the four values provided. - * @param row the row number to be modified (zero indexed) - * @param v the replacement row - */ - void setRow(size_t row, const T v[]); - - /** - * Copies the matrix values in the specified row into the - * vector parameter. - * @param row the matrix row - * @param v The vector into which the matrix row values will be copied - */ - void getRow(size_t row, Vector4* v) const; - - /** - * Copies the matrix values in the specified row into the - * array parameter. - * @param row the matrix row - * @param v The array into which the matrix row values will be copied - */ - void getRow(size_t row, T v[]) const; - - /** - * Sets the specified column of this matrix4d to the four values provided. - * @param column the column number to be modified (zero indexed) - * @param x the first row element - * @param y the second row element - * @param z the third row element - * @param w the fourth row element - */ - void setColumn(size_t column, T x, T y, T z, T w); - - /** - * Sets the specified column of this matrix4d to the vector provided. - * @param column the column number to be modified (zero indexed) - * @param v the replacement column - */ - void setColumn(size_t column, const Vector4& v); - - /** - * Sets the specified column of this matrix4d to the four values provided. - * @param column the column number to be modified (zero indexed) - * @param v the replacement column - */ - void setColumn(size_t column, const T v[]); - - /** - * Copies the matrix values in the specified column into the - * vector parameter. - * @param column the matrix column - * @param v The vector into which the matrix column values will be copied - */ - void getColumn(size_t column, Vector4* v) const; - - /** - * Copies the matrix values in the specified column into the - * array parameter. - * @param column the matrix column - * @param v The array into which the matrix column values will be copied - */ - void getColumn(size_t column, T v[]) const; - - /** - * Adds a scalar to each component of this matrix. - * @param scalar The scalar adder. - */ - void add(T scalar); - - /** - * Subtracts a scalar from each component of this matrix. - * @param scalar The scalar adder. - */ - void sub(T scalar); - - /** - * Adds a scalar to each component of the matrix m1 and places - * the result into this. Matrix m1 is not modified. - * @param scalar The scalar adder. - * @param m1 The original matrix values. - */ - void add(T scalar, const Matrix4& m1) { - set(m1); - add(scalar); - } - - /** - * Sets the value of this matrix to the matrix sum of matrices m1 and m2. - * @param m1 the first matrix - * @param m2 the second matrix - */ - void add(const Matrix4& m1, const Matrix4& m2); - - /** - * Sets the value of this matrix to sum of itself and matrix m1. - * @param m1 the other matrix - */ - void add(const Matrix4& m1); - - /** - * Sets the value of this matrix to the matrix difference - * of matrices m1 and m2. - * @param m1 the first matrix - * @param m2 the second matrix - */ - void sub(const Matrix4& m1, const Matrix4& m2); - - /** - * Sets the value of this matrix to the matrix difference of itself - * and matrix m1 (this = this - m1). - * @param m1 the other matrix - */ - void sub(const Matrix4& m1); - - /** - * Sets the value of this matrix to its transpose. - */ - void transpose(); - - /** - * Sets the value of this matrix to the transpose of the argument matrix - * @param m1 the matrix to be transposed - */ - void transpose(const Matrix4& m1) { - // alias-safe - set(m1); - transpose(); - } - -#if 0 - /** - * Sets the rotational component (upper 3x3) of this matrix to the matrix - * values in the single precision Matrix3f argument; the other elements of - * this matrix are initialized as if this were an identity matrix - * (ie, affine matrix with no translational component). - * @param m1 the 3x3 matrix - */ - void set(Matrix3f m1) { - m00 = m1.m00; m01 = m1.m01; m02 = m1.m02; m03 = 0.0; - m10 = m1.m10; m11 = m1.m11; m12 = m1.m12; m13 = 0.0; - m20 = m1.m20; m21 = m1.m21; m22 = m1.m22; m23 = 0.0; - m30 = 0.0; m31 = 0.0; m32 = 0.0; m33 = 1.0; - } - - /** - * Sets the value of this matrix to the matrix conversion of the - * single precision quaternion argument. - * @param q1 the quaternion to be converted - */ - void set(Quat4f q1) { - setFromQuat(q1.x, q1.y, q1.z, q1.w); - } - - /** - * Sets the value of this matrix to the matrix conversion of the - * single precision axis and angle argument. - * @param a1 the axis and angle to be converted - */ - void set(AxisAngle4f a1) { - setFromAxisAngle(a1.x, a1.y, a1.z, a1.angle); - } -#endif - - /** - * Sets the value of this matrix from the rotation expressed by the - * quaternion q1, the translation t1, and the scale s. - * @param q1 the rotation expressed as a quaternion - * @param t1 the translation - * @param s the scale value - */ - void set(const Quat4& q1, const Vector3& t1, T s); - -#if 0 - /** - * Sets the value of this matrix from the rotation expressed by the - * quaternion q1, the translation t1, and the scale s. - * @param q1 the rotation expressed as a quaternion - * @param t1 the translation - * @param s the scale value - */ - void set(Quat4f q1, Vector3d t1, T s) { - set(q1); - mulRotationScale(s); - m03 = t1.x; - m13 = t1.y; - m23 = t1.z; - } - - /** - * Sets the value of this matrix from the rotation expressed by the - * quaternion q1, the translation t1, and the scale s. - * @param q1 the rotation expressed as a quaternion - * @param t1 the translation - * @param s the scale value - */ - void set(Quat4f q1, Vector3f t1, float s) { - set(q1); - mulRotationScale(s); - m03 = t1.x; - m13 = t1.y; - m23 = t1.z; - } - - /** - * Sets the value of this matrix to the T value of the - * passed matrix4f. - * @param m1 the matrix4f - */ - void set(Matrix4f m1) { - m00 = m1.m00; m01 = m1.m01; m02 = m1.m02; m03 = m1.m03; - m10 = m1.m10; m11 = m1.m11; m12 = m1.m12; m13 = m1.m13; - m20 = m1.m20; m21 = m1.m21; m22 = m1.m22; m23 = m1.m23; - m30 = m1.m30; m31 = m1.m31; m32 = m1.m32; m33 = m1.m33; - } -#endif - - /** - * Sets the value of this matrix to the matrix inverse - * of the passed matrix m1. - * @param m1 the matrix to be inverted - */ - void invert(const Matrix4& m1); - - /** - * Sets the value of this matrix to its inverse. - */ - void invert(); - - /** - * Computes the determinant of this matrix. - * @return the determinant of the matrix - */ - T determinant() const; - - /** - * Sets the value of this matrix to a scale matrix with the - * passed scale amount. - * @param scale the scale factor for the matrix - */ - void set(T scale); - - /** - * Modifies the translational components of this matrix to the values of - * the Vector3d argument; the other values of this matrix are not modified. - * @param trans the translational component - */ - void setTranslation(const Vector3& trans) { - m03 = trans.x; - m13 = trans.y; - m23 = trans.z; - } - - /** - * Sets the value of this matrix to a translate matrix by the - * passed translation value. - * @param v1 the translation amount - */ - void set(const Vector3& v1) { - setIdentity(); - setTranslation(v1); - } - - /** - * Sets the value of this matrix to a scale and translation matrix; - * scale is not applied to the translation and all of the matrix - * values are modified. - * @param scale the scale factor for the matrix - * @param v1 the translation amount - */ - void set(T scale, const Vector3& v1) { - set(scale); - setTranslation(v1); - } - - /** - * Sets the value of this matrix to a scale and translation matrix; - * the translation is scaled by the scale factor and all of the - * matrix values are modified. - * @param v1 the translation amount - * @param scale the scale factor for the matrix - */ - void set(const Vector3& v1, T scale); - -#if 0 - /** - * Sets the value of this matrix from the rotation expressed by the - * rotation matrix m1, the translation t1, and the scale s. The translation - * is not modified by the scale. - * @param m1 The rotation component - * @param t1 The translation component - * @param scale The scale component - */ - void set(Matrix3f m1, Vector3f t1, float scale) { - setRotationScale(m1); - mulRotationScale(scale); - setTranslation(t1); - m33 = 1.0; - } -#endif - - /** - * Sets the value of this matrix from the rotation expressed by the - * rotation matrix m1, the translation t1, and the scale s. The translation - * is not modified by the scale. - * @param m1 The rotation component - * @param t1 The translation component - * @param scale The scale component - */ - void set(const Matrix3& m1, const Vector3& t1, T scale); - - /** - * Sets the value of this matrix to a rotation matrix about the x axis - * by the passed angle. - * @param angle the angle to rotate about the X axis in radians - */ - void rotX(T angle); - - /** - * Sets the value of this matrix to a rotation matrix about the y axis - * by the passed angle. - * @param angle the angle to rotate about the Y axis in radians - */ - void rotY(T angle); - - /** - * Sets the value of this matrix to a rotation matrix about the z axis - * by the passed angle. - * @param angle the angle to rotate about the Z axis in radians - */ - void rotZ(T angle); - - /** - * Multiplies each element of this matrix by a scalar. - * @param scalar The scalar multiplier. - */ - void mul(T scalar); - - /** - * Multiplies each element of matrix m1 by a scalar and places the result - * into this. Matrix m1 is not modified. - * @param scalar The scalar multiplier. - * @param m1 The original matrix. - */ - void mul(T scalar, const Matrix4& m1) { - set(m1); - mul(scalar); - } - - /** - * Sets the value of this matrix to the result of multiplying itself - * with matrix m1. - * @param m1 the other matrix - */ - void mul(const Matrix4& m1) { - mul(*this, m1); - } - - /** - * Sets the value of this matrix to the result of multiplying - * the two argument matrices together. - * @param m1 the first matrix - * @param m2 the second matrix - */ - void mul(const Matrix4& m1, const Matrix4& m2); - - /** - * Multiplies the transpose of matrix m1 times the transpose of matrix m2, - * and places the result into this. - * @param m1 The matrix on the left hand side of the multiplication - * @param m2 The matrix on the right hand side of the multiplication - */ - void mulTransposeBoth(const Matrix4& m1, const Matrix4& m2) { - mul(m2, m1); - transpose(); - } - - /** - * Multiplies matrix m1 times the transpose of matrix m2, and places the - * result into this. - * @param m1 The matrix on the left hand side of the multiplication - * @param m2 The matrix on the right hand side of the multiplication - */ - void mulTransposeRight(const Matrix4& m1, const Matrix4& m2); - - /** - * Multiplies the transpose of matrix m1 times matrix m2, and places the - * result into this. - * @param m1 The matrix on the left hand side of the multiplication - * @param m2 The matrix on the right hand side of the multiplication - */ - void mulTransposeLeft(const Matrix4& m1, const Matrix4& m2); - - /** - * Returns true if all of the data members of Matrix4 m1 are - * equal to the corresponding data members in this Matrix4. - * @param m1 The matrix with which the comparison is made. - * @return true or false - */ - bool equals(const Matrix4& m1) const; - - /** - * Returns true if the L-infinite distance between this matrix and matrix - * m1 is less than or equal to the epsilon parameter, otherwise returns - * false. The L-infinite distance is equal to MAX[i=0,1,2,3 ; j=0,1,2,3 ; - * abs(this.m(i,j) - m1.m(i,j)] - * @param m1 The matrix to be compared to this matrix - * @param epsilon the threshold value - */ - bool epsilonEquals(const Matrix4& m1, T epsilon) const; - - /** - * Returns a hash number based on the data values in this - * object. Two different Matrix4 objects with identical data values - * (ie, returns true for equals(Matrix4) ) will return the same hash - * number. Two objects with different data members may return the - * same hash value, although this is not likely. - * @return the integer hash value - */ - size_t hashCode() const { - return VmUtil::hashCode(sizeof *this, this); - } - - /** - * Transform the vector vec using this Matrix4 and place the - * result into vecOut. - * @param vec the T precision vector to be transformed - * @param vecOut the vector into which the transformed values are placed - */ - void transform(const Tuple4& vec, Tuple4* vecOut) const; - - /** - * Transform the vector vec using this Matrix4 and place the - * result back into vec. - * @param vec the T precision vector to be transformed - */ - void transform(Tuple4* vec) const { - transform(*vec, vec); - } - -#if 0 - /** - * Transform the vector vec using this Matrix4 and place the - * result into vecOut. - * @param vec the single precision vector to be transformed - * @param vecOut the vector into which the transformed values are placed - */ - void transform(Tuple4f vec, Tuple4f vecOut) { - // alias-safe - vecOut.set( - (float)(m00*vec.x + m01*vec.y + m02*vec.z + m03*vec.w), - (float)(m10*vec.x + m11*vec.y + m12*vec.z + m13*vec.w), - (float)(m20*vec.x + m21*vec.y + m22*vec.z + m23*vec.w), - (float)(m30*vec.x + m31*vec.y + m32*vec.z + m33*vec.w) - ); - } - - - /** - * Transform the vector vec using this Matrix4 and place the - * result back into vec. - * @param vec the single precision vector to be transformed - */ - void transform(Tuple4f vec) { - transform(vec, vec); - } -#endif - - /** - * Transforms the point parameter with this Matrix4 and places the result - * into pointOut. The fourth element of the point input paramter is assumed - * to be one. - * @param point the input point to be transformed. - * @param pointOut the transformed point - */ - void transform(const Point3& point, Point3* pointOut) const; - - - /** - * Transforms the point parameter with this Matrix4 and - * places the result back into point. The fourth element of the - * point input paramter is assumed to be one. - * @param point the input point to be transformed. - */ - void transform(Point3* point) const { - assert(point != 0); - transform(*point, point); - } - -#if 0 - /** - * Transforms the point parameter with this Matrix4 and places the result - * into pointOut. The fourth element of the point input paramter is assumed - * to be one. - * @param point the input point to be transformed. - * @param pointOut the transformed point - */ - void transform(Point3f point, Point3f pointOut) { - pointOut.set( - (float)(m00*point.x + m01*point.y + m02*point.z + m03), - (float)(m10*point.x + m11*point.y + m12*point.z + m13), - (float)(m20*point.x + m21*point.y + m22*point.z + m23) - ); - } - - /** - * Transforms the point parameter with this Matrix4 and - * places the result back into point. The fourth element of the - * point input paramter is assumed to be one. - * @param point the input point to be transformed. - */ - void transform(Point3f point) { - transform(point, point); - } -#endif - - /** - * Transforms the normal parameter by this Matrix4 and places the value - * into normalOut. The fourth element of the normal is assumed to be zero. - * @param normal the input normal to be transformed. - * @param normalOut the transformed normal - */ - void transform(const Vector3& normal, Vector3* normalOut) const; - - /** - * Transforms the normal parameter by this transform and places the value - * back into normal. The fourth element of the normal is assumed to be zero. - * @param normal the input normal to be transformed. - */ - void transform(Vector3* normal) const { - assert(normal != 0); - transform(*normal, normal); - } - -#if 0 - /** - * Transforms the normal parameter by this Matrix4 and places the value - * into normalOut. The fourth element of the normal is assumed to be zero. - * @param normal the input normal to be transformed. - * @param normalOut the transformed normal - */ - void transform(Vector3f normal, Vector3f normalOut) { - normalOut.set( - (float)(m00 * normal.x + m01 * normal.y + m02 * normal.z), - (float)(m10 * normal.x + m11 * normal.y + m12 * normal.z), - (float)(m20 * normal.x + m21 * normal.y + m22 * normal.z) - ); - } - - /** - * Transforms the normal parameter by this transform and places the value - * back into normal. The fourth element of the normal is assumed to be zero. - * @param normal the input normal to be transformed. - */ - void transform(Vector3f normal) { - transform(normal, normal); - } -#endif - - /** - * Sets the rotational component (upper 3x3) of this matrix to the matrix - * values in the T precision Matrix3d argument; the other elements of - * this matrix are unchanged; a singular value decomposition is performed - * on this object's upper 3x3 matrix to factor out the scale, then this - * object's upper 3x3 matrix components are replaced by the passed rotation - * components, and then the scale is reapplied to the rotational - * components. - * @param m1 T precision 3x3 matrix - */ - void setRotation(const Matrix3& m1); - -#if 0 - /** - * Sets the rotational component (upper 3x3) of this matrix to the matrix - * values in the single precision Matrix3f argument; the other elements of - * this matrix are unchanged; a singular value decomposition is performed - * on this object's upper 3x3 matrix to factor out the scale, then this - * object's upper 3x3 matrix components are replaced by the passed rotation - * components, and then the scale is reapplied to the rotational - * components. - * @param m1 single precision 3x3 matrix - */ - void setRotation(Matrix3f m1) { - T scale = SVD(null, null); - setRotationScale(m1); - mulRotationScale(scale); - } - - /** - * Sets the rotational component (upper 3x3) of this matrix to the matrix - * equivalent values of the quaternion argument; the other elements of this - * matrix are unchanged; a singular value decomposition is performed on - * this object's upper 3x3 matrix to factor out the scale, then this - * object's upper 3x3 matrix components are replaced by the matrix - * equivalent of the quaternion, and then the scale is reapplied to the - * rotational components. - * @param q1 the quaternion that specifies the rotation - */ - void setRotation(Quat4f q1) { - T scale = SVD(null, null); - - // save other values - T tx = m03; - T ty = m13; - T tz = m23; - T w0 = m30; - T w1 = m31; - T w2 = m32; - T w3 = m33; - - set(q1); - mulRotationScale(scale); - - // set back - m03 = tx; - m13 = ty; - m23 = tz; - m30 = w0; - m31 = w1; - m32 = w2; - m33 = w3; - } -#endif - - /** - * Sets the rotational component (upper 3x3) of this matrix to the matrix - * equivalent values of the quaternion argument; the other elements of this - * matrix are unchanged; a singular value decomposition is performed on - * this object's upper 3x3 matrix to factor out the scale, then this - * object's upper 3x3 matrix components are replaced by the matrix - * equivalent of the quaternion, and then the scale is reapplied to the - * rotational components. - * @param q1 the quaternion that specifies the rotation - */ - void setRotation(const Quat4& q1); - - /** - * Sets the rotational component (upper 3x3) of this matrix to the matrix - * equivalent values of the axis-angle argument; the other elements of this - * matrix are unchanged; a singular value decomposition is performed on - * this object's upper 3x3 matrix to factor out the scale, then this - * object's upper 3x3 matrix components are replaced by the matrix - * equivalent of the axis-angle, and then the scale is reapplied to the - * rotational components. - * @param a1 the axis-angle to be converted (x, y, z, angle) - */ - void setRotation(const AxisAngle4& a1); - - /** - * Sets this matrix to all zeros. - */ - void setZero(); - - /** - * Negates the value of this matrix: this = -this. - */ - void negate(); - - /** - * Sets the value of this matrix equal to the negation of of the Matrix4 - * parameter. - * @param m1 The source matrix - */ - void negate(const Matrix4& m1) { - set(m1); - negate(); - } - - /** - * Returns a string that contains the values of this Matrix4. - * @return the String representation - */ -#ifdef VM_INCLUDE_TOSTRING -VM_STRING_STD::string toString() const; -#endif - -protected: - /** - * Performs SVD on this matrix and gets scale and rotation. - * Rotation is placed into rot3, and rot4. - * @param rot3 the rotation factor(Matrix3d). if null, ignored - * @param rot4 the rotation factor(Matrix4) only upper 3x3 elements are changed. if null, ignored - * @return scale factor - */ - T SVD(Matrix3* rot3, Matrix4* rot4) const; - -#if 0 - /** - * Performs SVD on this matrix and gets the scale and the pure rotation. - * The pure rotation is placed into rot. - * @param rot the rotation factor. - * @return scale factor - */ - private float SVD(Matrix3f rot) { - // this is a simple svd. - // Not complete but fast and reasonable. - // See comment in Matrix3d. - - T s = Math.sqrt( - ( - m00*m00 + m10*m10 + m20*m20 + - m01*m01 + m11*m11 + m21*m21 + - m02*m02 + m12*m12 + m22*m22 - )/3.0 - ); - - // zero-div may occur. - T t = (s == 0.0 ? 0.0 : 1.0/s); - - if (rot != null) { - this.getRotationScale(rot); - rot.mul((float)t); - } - - return (float)s; - } -#endif - - /** - * Multiplies 3x3 upper elements of this matrix by a scalar. - * The other elements are unchanged. - */ - void mulRotationScale(T scale); - - /** - * Sets only 3x3 upper elements of this matrix to that of m1. - * The other elements are unchanged. - */ - void setRotationScale(const Matrix4& m1); - - /** - * Sets this matrix from the 4 values of quaternion. - * @param x q.x - * @param y q.y - * @param z q.z - * @param w q.w - */ - void setFromQuat(T x, T y, T z, T w); - - /** - * Sets this matrix from the 4 values of axisAngle. - * @param x a.x - * @param y a.y - * @param z a.z - * @param angle a.angle - */ - void setFromAxisAngle(T x, T y, T z, T angle); - -#if 0 - /** - * Modifies the translational components of this matrix to the values of - * the Vector3f argument; the other values of this matrix are not modified. - * @param trans the translational component - */ - private void setTranslation(Vector3f trans) { - m03 = trans.x; - m13 = trans.y; - m23 = trans.z; - } -#endif - -public: - // copy constructor and operator = is made by complier - - bool operator==(const Matrix4& m1) const { - return equals(m1); - } -#ifdef VM_INCLUDE_SUBSCRIPTION_OPERATOR - T operator()(size_t row, size_t col) const { - return getElement(row, col); - } - T& operator()(size_t row, size_t col) { - return getElementReference(row, col); - } -#endif - Matrix4& operator+=(const Matrix4& m1) { - add(m1); - return *this; - } - Matrix4& operator-=(const Matrix4& m1) { - sub(m1); - return *this; - } - Matrix4& operator*=(const Matrix4& m1) { - mul(m1); - return *this; - } - Matrix4& operator*=(T s) { - mul(s); - return *this; - } - Matrix4 operator+(const Matrix4& m1) const { - return (Matrix4(*this)).operator+=(m1); - } - Matrix4 operator-(const Matrix4& m1) const { - return (Matrix4(*this)).operator-=(m1); - } - Matrix4 operator*(const Matrix4& m1) const { - return (Matrix4(*this)).operator*=(m1); - } - Matrix4 operator*(T s) const { - return (Matrix4(*this)).operator*=(s); - } - -}; - -template -inline -Matrix4 operator*(T s, const Matrix4& m) { - return (Matrix4(m)).operator*=(s); -} - -template -inline -Matrix4 operator*(const Matrix4& m1, const Matrix4& m2) { - return (Matrix4(m1)).operator*=(m2); -} - -template -inline -Tuple4 operator*(const Matrix4& m, const Tuple4& t) { - Tuple4 out; - m.transform(t,&out); - return out; -} - -// bug fixed, 12.11.2002 M.Hastenteufel -// tuple3 -> Tuple4 -template -inline -Vector4 operator*(const Matrix4& m, const Vector4& t) { - return operator*(m, (const Tuple4&)t); -} - -// bug fixed, 12.11.2002 M.Hastenteufel -// tuple3 -> Tuple4 -template -inline -Point4 operator*(const Matrix4& m, const Point4& t) { - return operator*(m, (const Tuple4&)t); -} - -template -inline -Vector3 operator*(const Matrix4& m, const Vector3& t) { - Vector3 out; - m.transform(t,&out); - return out; -} - -template -inline -Point3 operator*(const Matrix4& m, const Point3& t) { - Point3 out; - m.transform(t,&out); - return out; -} - -VM_END_NS - -#ifdef VM_INCLUDE_IO -template -VM_IOSTREAM_STD::ostream& operator<<(VM_IOSTREAM_STD::ostream& o, const VM_VECMATH_NS::Matrix4& t1); -#endif - -VM_BEGIN_NS - -typedef Matrix4 Matrix4d; -typedef Matrix4 Matrix4f; - -VM_END_NS - - -#endif /* MATRIX4__H */ diff --git a/Utilities/vecmath/Point2.h b/Utilities/vecmath/Point2.h deleted file mode 100644 index d4d88a8956..0000000000 --- a/Utilities/vecmath/Point2.h +++ /dev/null @@ -1,154 +0,0 @@ -/* - Copyright (C) 1997,1998,1999 - Kenji Hiranabe, Eiwa System Management, Inc. - - This program is free software. - Implemented by Kenji Hiranabe(hiranabe@esm.co.jp), - conforming to the Java(TM) 3D API specification by Sun Microsystems. - - Permission to use, copy, modify, distribute and sell this software - and its documentation for any purpose is hereby granted without fee, - provided that the above copyright notice appear in all copies and - that both that copyright notice and this permission notice appear - in supporting documentation. Kenji Hiranabe and Eiwa System Management,Inc. - makes no representations about the suitability of this software for any - purpose. It is provided "AS IS" with NO WARRANTY. -*/ -#ifndef POINT2_H -#define POINT2_H - -#include "VmUtil.h" -#include "Tuple2.h" - -VM_BEGIN_NS - -/** - * A 2 element point that is represented by x,y coordinates. - * @version specification 1.1, implementation $Revision$, $Date$ - * @author Kenji hiranabe - */ -template -class Point2 : public Tuple2 { -/* - * $Log$ - * Revision 1.3 2005/10/06 15:27:15 nolden - * FIX: gcc4 compatibility - * - * Revision 1.2 2003/04/22 14:42:11 max - * made inclusions of vecmath header files "local" (for gcc 3.3 support) - * - * Revision 1.1 2002/11/16 12:25:36 mark - * vecmath bibliothek - * in cvs, da einige bugs behoben - * - * Revision 1.4 1999/10/06 02:52:46 hiranabe - * Java3D 1.2 and namespace - * - * Revision 1.3 1999/09/10 02:19:20 hiranabe - * distance*() method to const - * - * Revision 1.2 1999/05/26 00:59:37 hiranabe - * support Visual C++ - * - * Revision 1.1 1999/03/04 11:07:09 hiranabe - * Initial revision - * - * Revision 1.1 1999/03/04 11:07:09 hiranabe - * Initial revision - * - */ -public: - /** - * Constructs and initializes a Point2 from the specified xy coordinates. - * @param x the x coordinate - * @param y the y coordinate - */ - Point2(T x, T y): Tuple2(x, y) { } - - /** - * Constructs and initializes a Point2 from the specified array. - * @param p the array of length 2 containing xy in order - */ - Point2(const T p[]): Tuple2(p) { } - - /** - * Constructs and initializes a Point2 from the specified Tuple2. - * @param t1 the Tuple2 containing the initialization x y data - */ - Point2(const Tuple2& t1): Tuple2(t1) { } - - /** - * Constructs and initializes a Point2 to (0,0). - */ - Point2(): Tuple2() { } - - /** - * Computes the square of the distance between this point and point p1. - * @param p1 the other point - */ - T distanceSquared(const Point2& p1) const { - T dx = this->x - p1.x; - T dy = this->y - p1.y; - return dx*dx + dy*dy; - } - - /** - * Computes the distance between this point and point p1. - * @param p1 the other point - */ - T distance(const Point2& p1) const { - return VmUtil::sqrt(distanceSquared(p1)); - } - - /** - * Computes the L-1 (Manhattan) distance between this point and point p1. - * The L-1 distance is equal to abs(x1-x2) + abs(y1-y2). - * @param p1 the other point - */ - T distanceL1(const Point2& p1) const { - return VmUtil::abs(this->x-p1.x) + VmUtil::abs(this->y-p1.y); - } - - /** - * Computes the L-infinite distance between this point and point p1. - * The L-infinite distance is equal to MAX[abs(x1-x2), abs(y1-y2)]. - * @param p1 the other point - */ - T distanceLinf(const Point2& p1) const { - return VmUtil::max(VmUtil::abs(this->x-p1.x), VmUtil::abs(this->y-p1.y)); - } - - // copy constructor and operator = is made by complier - - Point2& operator=(const Tuple2& t) { - Tuple2::operator=(t); - return *this; - } -}; - -VM_END_NS - -#ifdef VM_INCLUDE_IO -template -inline -VM_IOSTREAM_STD::ostream& operator<<(VM_IOSTREAM_STD::ostream& o, const VM_VECMATH_NS::Point2& t1) { - return operator<<(o, (const VM_VECMATH_NS::Tuple2&)t1); -} -#endif - -VM_BEGIN_NS - -typedef Point2 Point2d; -typedef Point2 Point2f; - -/* - * 0. value_type typedef added - * 1. copy constructo, oeprator = are delegated to compiler - * 4. typdef value type - * 7. typedefs for , - * removed construction from Vector2f - */ - -VM_END_NS - -#endif /* POINT2_H */ diff --git a/Utilities/vecmath/Point3.h b/Utilities/vecmath/Point3.h deleted file mode 100644 index 4338ee70c3..0000000000 --- a/Utilities/vecmath/Point3.h +++ /dev/null @@ -1,170 +0,0 @@ -/* - Copyright (C) 1997,1998,1999 - Kenji Hiranabe, Eiwa System Management, Inc. - - This program is free software. - Implemented by Kenji Hiranabe(hiranabe@esm.co.jp), - conforming to the Java(TM) 3D API specification by Sun Microsystems. - - Permission to use, copy, modify, distribute and sell this software - and its documentation for any purpose is hereby granted without fee, - provided that the above copyright notice appear in all copies and - that both that copyright notice and this permission notice appear - in supporting documentation. Kenji Hiranabe and Eiwa System Management,Inc. - makes no representations about the suitability of this software for any - purpose. It is provided "AS IS" with NO WARRANTY. -*/ -#ifndef POINT3_H -#define POINT3_H - -#include "VmUtil.h" -#include "Tuple3.h" -#include "Point4.h" - -VM_BEGIN_NS - -/** - * A 3 element point that is represented by x,y,z coordinates. - * @version specification 1.1, implementation $Revision$, $Date$ - * @author Kenji hiranabe - */ -template -class Point3 : public Tuple3 { -/* - * $Log$ - * Revision 1.3 2005/10/06 15:27:15 nolden - * FIX: gcc4 compatibility - * - * Revision 1.2 2003/04/22 14:42:11 max - * made inclusions of vecmath header files "local" (for gcc 3.3 support) - * - * Revision 1.1 2002/11/16 12:25:36 mark - * vecmath bibliothek - * in cvs, da einige bugs behoben - * - * Revision 1.4 1999/10/06 02:52:46 hiranabe - * Java3D 1.2 and namespace - * - * Revision 1.3 1999/09/10 02:19:09 hiranabe - * distance*() method to const - * - * Revision 1.2 1999/05/26 00:59:37 hiranabe - * support Visual C++ - * - * Revision 1.1 1999/03/04 11:07:09 hiranabe - * Initial revision - * - * Revision 1.1 1999/03/04 11:07:09 hiranabe - * Initial revision - * - */ - /** - * Constructs and initializes a Point3 from the specified xyz coordinates. - * @param x the x coordinate - * @param y the y coordinate - * @param z the z coordinate - */ -public: - Point3(T x, T y, T z): Tuple3(x, y, z) { } - - /** - * Constructs and initializes a Point3 from the specified array. - * @param p the array of length 3 containing xyz in order - */ - Point3(const T p[]): Tuple3(p) { } - - /** - * Constructs and initializes a Point3 from the specified Tuple3d. - * @param t1 the Tuple3d containing the initialization x y z data - */ - Point3(const Tuple3& t1): Tuple3(t1) { } - - /** - * Constructs and initializes a Point3 to (0,0,0). - */ - Point3(): Tuple3() { } - - /** - * Computes the square of the distance between this point and point p1. - * @param p1 the other point - * @return the square of distance between these two points as a float - */ - T distanceSquared(const Point3& p1) const { - T dx = this->x - p1.x; - T dy = this->y - p1.y; - T dz = this->z - p1.z; - return dx*dx + dy*dy + dz*dz; - } - - /** - * Returns the distance between this point and point p1. - * @param p1 the other point - * @return the distance between these two points as a float - */ - T distance(const Point3& p1) const { - return VmUtil::sqrt(distanceSquared(p1)); - } - - /** - * Computes the L-1 (Manhattan) distance between this point and point p1. - * The L-1 distance is equal to abs(x1-x2) + abs(y1-y2). - * @param p1 the other point - */ - T distanceL1(const Point3& p1) const { - return VmUtil::abs(this->x-p1.x) + VmUtil::abs(this->y-p1.y) + VmUtil::abs(this->z-p1.z); - } - - /** - * Computes the L-infinite distance between this point and point p1. - * The L-infinite distance is equal to MAX[abs(x1-x2), abs(y1-y2)]. - * @param p1 the other point - */ - T distanceLinf(const Point3& p1) const { - return VmUtil::max(VmUtil::abs(this->x-p1.x), VmUtil::abs(this->y-p1.y), VmUtil::abs(this->z-p1.z)); - } - - /** - * Multiplies each of the x,y,z components of the Point4 parameter - * by 1/w and places the projected values into this point. - * @param p1 the source Point4, which is not modified - */ - void project(const Point4& p1) { - // zero div may occur. - this->x = p1.x/p1.w; - this->y = p1.y/p1.w; - this->z = p1.z/p1.w; - } - - // copy constructor and operator = is made by complier - - Point3& operator=(const Tuple3& t) { - Tuple3::operator=(t); - return *this; - } -}; - -VM_END_NS - -template -inline -VM_VECMATH_NS::Point3 operator*(T s, const VM_VECMATH_NS::Point3& t1) { - return operator*(s, (const VM_VECMATH_NS::Tuple3&)t1); -} - -#ifdef VM_INCLUDE_IO -template -inline -VM_IOSTREAM_STD::ostream& operator<<(VM_IOSTREAM_STD::ostream& o, const VM_VECMATH_NS::Point3& t1) { - return operator<<(o, (const VM_VECMATH_NS::Tuple3&)t1); -} -#endif - -VM_BEGIN_NS - -typedef Point3 Point3d; -typedef Point3 Point3f; - -VM_END_NS - - -#endif /* POINT3_H */ diff --git a/Utilities/vecmath/Point4.h b/Utilities/vecmath/Point4.h deleted file mode 100644 index ca0d8b0f3f..0000000000 --- a/Utilities/vecmath/Point4.h +++ /dev/null @@ -1,205 +0,0 @@ -/* - Copyright (C) 1997,1998,1999 - Kenji Hiranabe, Eiwa System Management, Inc. - - This program is free software. - Implemented by Kenji Hiranabe(hiranabe@esm.co.jp), - conforming to the Java(TM) 3D API specification by Sun Microsystems. - - Permission to use, copy, modify, distribute and sell this software - and its documentation for any purpose is hereby granted without fee, - provided that the above copyright notice appear in all copies and - that both that copyright notice and this permission notice appear - in supporting documentation. Kenji Hiranabe and Eiwa System Management,Inc. - makes no representations about the suitability of this software for any - purpose. It is provided "AS IS" with NO WARRANTY. -*/ -#ifndef POINT4_H -#define POINT4_H - -#include "VmUtil.h" -#include "Tuple4.h" -#include "Tuple3.h" - -VM_BEGIN_NS - -/** - * A 4 element point that is represented x,y,z,w coordinates. - * @version specification 1.1, implementation $Revision$, $Date$ - * @author Kenji hiranabe - */ -template -class Point4 : public Tuple4 { -/* - * $Log$ - * Revision 1.3 2005/10/06 15:27:15 nolden - * FIX: gcc4 compatibility - * - * Revision 1.2 2003/04/22 14:42:11 max - * made inclusions of vecmath header files "local" (for gcc 3.3 support) - * - * Revision 1.1 2002/11/16 12:25:36 mark - * vecmath bibliothek - * in cvs, da einige bugs behoben - * - * Revision 1.3 1999/10/06 02:52:46 hiranabe - * Java3D 1.2 and namespace - * - * Revision 1.2 1999/05/26 00:59:37 hiranabe - * support Visual C++ - * - * Revision 1.1 1999/03/04 11:07:09 hiranabe - * Initial revision - * - * Revision 1.1 1999/03/04 11:07:09 hiranabe - * Initial revision - * - */ -public: - /** - * Constructs and initializes a Point4 from the specified xyzw coordinates. - * @param x the x coordinate - * @param y the y coordinate - * @param z the z coordinate - * @param w the w coordinate - */ - Point4(T x, T y, T z, T w): Tuple4(x, y, z, w) { } - - /** - * Constructs and initializes a Point4 from the specified array. - * @param p the array of length 4 containing xyzw in order - */ - Point4(const T p[]): Tuple4(p) { } - - /** - * Constructs and initializes a Point4 from the specified Tuple4d. - * @param t1 the Tuple4d containing the initialization x y z w data - */ - Point4(const Tuple4& t1): Tuple4(t1) { } - - /** - * Constructs and initializes a Point4 to (0,0,0,0). - */ - Point4(): Tuple4() { } - - /** - * Constructs and initializes a Point4 from the specified Tuple3. - * The x,y,z components of this point are set to the corresponding - * components - * of tuple t1. The w component of this point is set to 1. - * - * @param t1 the tuple to be copied - * @since Java3D 1.2 - */ - Point4(const Tuple3& t1): Tuple4(t1.x, t1.y, t1.z, 1) { } - - /** - * Sets the x,y,z components of this point to the corresponding - * components of tuple t1. The w component of this point is set to 1. - * - * NOTE: - * This method's name should be 'set'. Newer compilers support - * 'using Tuple4::set;' and use the name 'set'. - * but for now, renamed to 'set3'. - * - * @param t1 the tuple to be copied - * @since Java3D 1.2 - */ - void set3(const Tuple3& t1) { - this->x = t1.x; - this->y = t1.y; - this->z = t1.z; - this->w = 1; - } - - /** - * Computes the square of the distance between this point and point p1. - * @param p1 the other point - * @return the square of distance between this point and p1 - */ - T distanceSquared(const Point4& p1) const { - T dx = this->x - p1.x; - T dy = this->y - p1.y; - T dz = this->z - p1.z; - T dw = this->w - p1.w; - return dx*dx + dy*dy + dz*dz + dw*dw; - } - - /** - * Returns the distance between this point and point p1. - * @param p1 the other point - * @return the distance between this point and point p1. - */ - T distance(const Point4& p1) const { - return VmUtil::sqrt(distanceSquared(p1)); - } - - /** - * Computes the L-1 (Manhattan) distance between this point and point p1. - * The L-1 distance is equal to abs(x1-x2) + abs(y1-y2) - * + abs(z1-z2) + abs(w1-w2). - * @param p1 the other point - * @return L-1 distance - */ - T distanceL1(const Point4& p1) const { - return VmUtil::abs(this->x-p1.x) + VmUtil::abs(this->y-p1.y) - + VmUtil::abs(this->z-p1.z) + VmUtil::abs(this->w-p1.w); - } - - /** - * Computes the L-infinite distance between this point and point p1. - * The L-infinite distance is equal to MAX[abs(x1-x2), abs(y1-y2), abs(z1-z2), abs(w1-w2)]. - * @param p1 the other point - * @return L-infinite distance - */ - T distanceLinf(const Point4& p1) const { - return VmUtil::max(VmUtil::abs(this->x-p1.x), VmUtil::abs(this->y-p1.y), VmUtil::abs(this->z-p1.z), VmUtil::abs(this->w-p1.w)); - } - - /** - * Multiplies each of the x,y,z components of the Point4 parameter by 1/w, - * places the projected values into this point, and places a 1 as the w - * parameter of this point. - * @param p1 the source Point4, which is not modified - */ - void project(const Point4& p1) { - // zero div may occur. - this->x = p1.x/p1.w; - this->y = p1.y/p1.w; - this->z = p1.z/p1.w; - this->w = 1; - } - - // copy constructor and operator = is made by complier - - Point4& operator=(const Tuple4& t) { - Tuple4::operator=(t); - return *this; - } -}; - -VM_END_NS - -template -inline -VM_VECMATH_NS::Point4 operator*(T s, const VM_VECMATH_NS::Point4& t1) { - return operator*(s, (const VM_VECMATH_NS::Tuple4&)t1); -} - -#ifdef VM_INCLUDE_IO -template -inline -VM_IOSTREAM_STD::ostream& operator<<(VM_IOSTREAM_STD::ostream& o, const VM_VECMATH_NS::Point4& t1) { - return operator<<(o, (const VM_VECMATH_NS::Tuple4&)t1); -} -#endif - -VM_BEGIN_NS - -typedef Point4 Point4d; -typedef Point4 Point4f; - -VM_END_NS - -#endif /* POINT4_H */ - diff --git a/Utilities/vecmath/Quat4.h b/Utilities/vecmath/Quat4.h deleted file mode 100644 index f973f4f033..0000000000 --- a/Utilities/vecmath/Quat4.h +++ /dev/null @@ -1,221 +0,0 @@ -/* - Copyright (C) 1997,1998,1999 - Kenji Hiranabe, Eiwa System Management, Inc. - - This program is free software. - Implemented by Kenji Hiranabe(hiranabe@esm.co.jp), - conforming to the Java(TM) 3D API specification by Sun Microsystems. - - Permission to use, copy, modify, distribute and sell this software - and its documentation for any purpose is hereby granted without fee, - provided that the above copyright notice appear in all copies and - that both that copyright notice and this permission notice appear - in supporting documentation. Kenji Hiranabe and Eiwa System Management,Inc. - makes no representations about the suitability of this software for any - purpose. It is provided "AS IS" with NO WARRANTY. -*/ -#ifndef QUAT4_H -#define QUAT4_H - -#include "VmUtil.h" -#include "Quat4_.h" -#include "AxisAngle4_.h" - -VM_BEGIN_NS - -template -void Quat4::mul(const Quat4& q1, const Quat4& q2) { - // store on stack for aliasing-safty - set( - q1.x*q2.w + q1.w*q2.x + q1.y*q2.z - q1.z*q2.y, - q1.y*q2.w + q1.w*q2.y + q1.z*q2.x - q1.x*q2.z, - q1.z*q2.w + q1.w*q2.z + q1.x*q2.y - q1.y*q2.x, - q1.w*q2.w - q1.x*q2.x - q1.y*q2.y - q1.z*q2.z - ); -} - -template -void Quat4::mul(const Quat4& q1) { - // store on stack for aliasing-safty - set( - this->x*q1.w + this->w*q1.x + this->y*q1.z - this->z*q1.y, - this->y*q1.w + this->w*q1.y + this->z*q1.x - this->x*q1.z, - this->z*q1.w + this->w*q1.z + this->x*q1.y - this->y*q1.x, - this->w*q1.w - this->x*q1.x - this->y*q1.y - this->z*q1.z - ); -} - -template -void Quat4::mulInverse(const Quat4& q1, const Quat4& q2) { - T n = norm(); - // zero-div may occur. - n = 1/n; - // store on stack once for aliasing-safty - set( - (q1.x*q2.w - q1.w*q2.x - q1.y*q2.z + q1.z*q2.y)*n, - (q1.y*q2.w - q1.w*q2.y - q1.z*q2.x + q1.x*q2.z)*n, - (q1.z*q2.w - q1.w*q2.z - q1.x*q2.y + q1.y*q2.x)*n, - (q1.w*q2.w + q1.x*q2.x + q1.y*q2.y + q1.z*q2.z)*n - ); -} - - -template -void Quat4::mulInverse(const Quat4& q1) { - T n = norm(); - // zero-div may occur. - n = 1/n; - // store on stack once for aliasing-safty - set( - (this->x*q1.w - this->w*q1.x - this->y*q1.z + this->z*q1.y)*n, - (this->y*q1.w - this->w*q1.y - this->z*q1.x + this->x*q1.z)*n, - (this->z*q1.w - this->w*q1.z - this->x*q1.y + this->y*q1.x)*n, - (this->w*q1.w + this->x*q1.x + this->y*q1.y + this->z*q1.z)*n - ); -} - - -template -void Quat4::set(const Matrix4& m1) { - setFromMat( - m1.m00, m1.m01, m1.m02, - m1.m10, m1.m11, m1.m12, - m1.m20, m1.m21, m1.m22 - ); -} - - -template -void Quat4::set(const Matrix3& m1) { - setFromMat( - m1.m00, m1.m01, m1.m02, - m1.m10, m1.m11, m1.m12, - m1.m20, m1.m21, m1.m22 - ); -} - - -template -void Quat4::set(const AxisAngle4& a1) { - this->x = a1.x; - this->y = a1.y; - this->z = a1.z; - T n = VmUtil::sqrt(this->x*this->x + this->y*this->y + this->z*this->z); - // zero-div may occur. - T s = VmUtil::sin(0.5*a1.angle)/n; - this->x *= s; - this->y *= s; - this->z *= s; - this->w = VmUtil::cos(0.5*a1.angle); -} - - -template -void Quat4::interpolate(const Quat4& q1, T alpha) { - // From Hoggar. - normalize(); - T n1 = VmUtil::sqrt(q1.norm()); - // zero-div may occur. - T x1 = q1.x/n1; - T y1 = q1.y/n1; - T z1 = q1.z/n1; - T w1 = q1.w/n1; - - // t is cosine (dot product) - T t = this->x*x1 + this->y*y1 + this->z*z1 + this->w*w1; - - // same quaternion (avoid domain error) - if (1.0 <= VmUtil::abs(t)) - return; - - // t is now theta - t = VmUtil::acos(t); - - T sin_t = VmUtil::sin(t); - - // same quaternion (avoid zero-div) - if (sin_t == 0.0) - return; - - T s = VmUtil::sin((1.0-alpha)*t)/sin_t; - t = VmUtil::sin(alpha*t)/sin_t; - - // set values - this->x = s*this->x + t*x1; - this->y = s*this->y + t*y1; - this->z = s*this->z + t*z1; - this->w = s*this->w + t*w1; -} - -template -void Quat4::interpolate(const Quat4& q1, const Quat4& q2, T alpha) { - set(q1); - interpolate(q2, alpha); -} - - -template -void Quat4::setFromMat(T m00, T m01, T m02, - T m10, T m11, T m12, - T m20, T m21, T m22) { - // From Ken Shoemake - // (ftp://ftp.cis.upenn.edu/pub/graphics/shoemake) - - T s; - T tr = m00 + m11 + m22; - if (tr >= 0.0) { - s = VmUtil::sqrt(tr + 1.0); - this->w = s*0.5; - s = 0.5/s; - this->x = (m21 - m12)*s; - this->y = (m02 - m20)*s; - this->z = (m10 - m01)*s; - } else { - T maxm = VmUtil::max(m00, m11, m22); - if (maxm == m00) { - s = VmUtil::sqrt(m00 - (m11 + m22) + 1.0); - this->x = s*0.5; - s = 0.5/s; - this->y = (m01 + m10)*s; - this->z = (m20 + m02)*s; - this->w = (m21 - m12)*s; - } else if (maxm == m11) { - s = VmUtil::sqrt(m11 - (m22 + m00) + 1.0); - this->y = s*0.5; - s = 0.5/s; - this->z = (m12 + m21)*s; - this->x = (m01 + m10)*s; - this->w = (m02 - m20)*s; - } else { - s = VmUtil::sqrt(m22 - (m00 + m11) + 1.0); - this->z = s*0.5; - s = 0.5/s; - this->x = (m20 + m02)*s; - this->y = (m12 + m21)*s; - this->w = (m10 - m01)*s; - } - } -} - -template -Quat4& Quat4::operator*=(const Quat4& m1) { - mul(m1); - return *this; -} - -template -Quat4 Quat4::operator*(const Quat4& m1) const { - return (Quat4(*this)).operator*=(m1); -} - -VM_END_NS - -#ifdef VM_INCLUDE_IO -template -inline -VM_IOSTREAM_STD::ostream& operator<<(VM_IOSTREAM_STD::ostream& o, const VM_VECMATH_NS::Quat4& q1) { - return operator<<(o, (const VM_VECMATH_NS::Tuple4&)q1); -} -#endif - -#endif /* QUAT4_H */ diff --git a/Utilities/vecmath/Quat4_.h b/Utilities/vecmath/Quat4_.h deleted file mode 100644 index 6a039b6b0b..0000000000 --- a/Utilities/vecmath/Quat4_.h +++ /dev/null @@ -1,348 +0,0 @@ -/* - Copyright (C) 1997,1998,1999 - Kenji Hiranabe, Eiwa System Management, Inc. - - This program is free software. - Implemented by Kenji Hiranabe(hiranabe@esm.co.jp), - conforming to the Java(TM) 3D API specification by Sun Microsystems. - - Permission to use, copy, modify, distribute and sell this software - and its documentation for any purpose is hereby granted without fee, - provided that the above copyright notice appear in all copies and - that both that copyright notice and this permission notice appear - in supporting documentation. Kenji Hiranabe and Eiwa System Management,Inc. - makes no representations about the suitability of this software for any - purpose. It is provided "AS IS" with NO WARRANTY. -*/ -#ifndef QUAT4__H -#define QUAT4__H - -#include "VmUtil.h" -#include "Tuple4.h" -#include "Matrix4_.h" - -VM_BEGIN_NS - -/** - * A 4 element quaternion represented by x,y,z,w coordinates. - * @version specification 1.1, implementation $Revision$, $Date$ - * @author Kenji hiranabe - */ -template -class Quat4 : public Tuple4 { -/* - * $Log$ - * Revision 1.3 2005/10/06 15:27:15 nolden - * FIX: gcc4 compatibility - * - * Revision 1.2 2003/04/22 14:42:11 max - * made inclusions of vecmath header files "local" (for gcc 3.3 support) - * - * Revision 1.1 2002/11/16 12:25:36 mark - * vecmath bibliothek - * in cvs, da einige bugs behoben - * - * Revision 1.3 1999/10/06 02:52:46 hiranabe - * Java3D 1.2 and namespace - * - * Revision 1.2 1999/05/26 00:59:37 hiranabe - * support Visual C++ - * - * Revision 1.1 1999/03/04 11:07:09 hiranabe - * Initial revision - * - * Revision 1.1 1999/03/04 11:07:09 hiranabe - * Initial revision - * - */ -public: - /** - * Constructs and initializes a Quat4 from the specified xyzw coordinates. - * @param x the x coordinate - * @param y the y coordinate - * @param z the z coordinate - * @param w the w scalar component - */ - Quat4(T x, T y, T z, T w): Tuple4(x, y, z, w) { } - - /** - * Constructs and initializes a Quat4 from the array of length 4. - * @param v the array of length 4 containing xyzw in order - */ - Quat4(const T v[]): Tuple4(v) { } - - - /** - * Constructs and initializes a Quat4 from the specified Tuple4d. - * @param t1 the Tuple4d containing the initialization x y z w data - */ - Quat4(const Tuple4& t1): Tuple4(t1) { } - -#if 0 - /** - * Constructs and initializes a Quat4 from the specified Quat4f. - * @param q1 the Quat4f containing the initialization x y z w data - */ - Quat4(Quat4f q1) { - super(q1); - } - - /** - * Constructs and initializes a Quat4 from the specified Tuple4f. - * @param t1 the Tuple4f containing the initialization x y z w data - */ - Quat4(Tuple4f t1) { - super(t1); - } -#endif - - /** - * Constructs and initializes a Quat4 to (0,0,0,0). - */ - Quat4(): Tuple4() { } - - /** - * Sets the value of this tuple to the value of tuple t1. - * note: other set methods hides this set. - * @param t1 the tuple to be copied - */ - void set(const Tuple4& t1) { - Tuple4::set(t1); - } - - /** - * Sets the value of this tuple to the specified xyzw coordinates. - * note: other set methods hides this set. - * @param x the x coordinate - * @param y the y coordinate - * @param z the z coordinate - * @param w the w coordinate - */ - void set(T x, T y, T z, T w) { - Tuple4::set(x, y, z, w); - } - - - /** - * Sets the value of this quaternion to the conjugate of quaternion q1. - * @param q1 the source vector - */ - void conjugate(const Quat4& q1) { - this->x = -q1.x; - this->y = -q1.y; - this->z = -q1.z; - this->w = q1.w; - } - - /** - * Negate the value of of each of this quaternion's x,y,z coordinates - * in place. - */ - void conjugate() { - this->x = -this->x; - this->y = -this->y; - this->z = -this->z; - } - - /** - * Sets the value of this quaternion to the quaternion product of - * quaternions q1 and q2 (this = q1 * q2). - * Note that this is safe for aliasing (e.g. this can be q1 or q2). - * @param q1 the first quaternion - * @param q2 the second quaternion - */ - void mul(const Quat4& q1, const Quat4& q2); - - /** - * Sets the value of this quaternion to the quaternion product of - * itself and q1 (this = this * q1). - * @param q1 the other quaternion - */ - void mul(const Quat4& q1); - - /** - * - * Multiplies quaternion q1 by the inverse of quaternion q2 and places - * the value into this quaternion. The value of both argument quaternions - * is preservered (this = q1 * q2^-1). - * @param q1 the left quaternion - * @param q2 the right quaternion - */ - void mulInverse(const Quat4& q1, const Quat4& q2); - - /** - * Multiplies this quaternion by the inverse of quaternion q1 and places - * the value into this quaternion. The value of the argument quaternion - * is preserved (this = this * q^-1). - * @param q1 the other quaternion - */ - void mulInverse(const Quat4& q1); - -protected: - T norm() const { - return this->x*this->x + this->y*this->y + this->z*this->z + this->w*this->w; - } - void setFromMat(T m00, T m01, T m02, - T m10, T m11, T m12, - T m20, T m21, T m22); - -public: - /** - * Sets the value of this quaternion to quaternion inverse of quaternion q1. - * @param q1 the quaternion to be inverted - */ - void inverse(const Quat4& q1) { - T n = q1.norm(); - // zero-div may occur. - this->x = -q1.x/n; - this->y = -q1.y/n; - this->z = -q1.z/n; - this->w = q1.w/n; - } - - /** - * Sets the value of this quaternion to the quaternion inverse of itself. - */ - void inverse() { - T n = norm(); - // zero-div may occur. - this->x = -this->x/n; - this->y = -this->y/n; - this->z = -this->z/n; - this->w /= n; - } - - /** - * Sets the value of this quaternion to the normalized value - * of quaternion q1. - * @param q1 the quaternion to be normalized. - */ - void normalize(const Quat4& q1) { - T n = VmUtil::sqrt(q1.norm()); - // zero-div may occur. - this->x = q1.x/n; - this->y = q1.y/n; - this->z = q1.z/n; - this->w = q1.w/n; - } - - /** - * Normalizes the value of this quaternion in place. - */ - void normalize() { - T n = VmUtil::sqrt(norm()); - // zero-div may occur. - this->x /= n; - this->y /= n; - this->z /= n; - this->w /= n; - } - -#if 0 - /** - * Sets the value of this quaternion to the rotational component of - * the passed matrix. - * @param m1 the matrix4f - */ - void set(Matrix4f m1) { - setFromMat( - m1.m00, m1.m01, m1.m02, - m1.m10, m1.m11, m1.m12, - m1.m20, m1.m21, m1.m22 - ); - } - - /** - * Sets the value of this quaternion to the rotational component of - * the passed matrix. - * @param m1 the matrix3f - */ - void set(Matrix3f m1) { - setFromMat( - m1.m00, m1.m01, m1.m02, - m1.m10, m1.m11, m1.m12, - m1.m20, m1.m21, m1.m22 - ); - } - - /** - * Sets the value of this quaternion to the equivalent rotation of teh - * AxisAngle argument. - * @param a1 the axis-angle - */ - void set(AxisAngle4f a1) { - x = a1.x; - y = a1.y; - z = a1.z; - T n = Math.sqrt(x*x + y*y + z*z); - // zero-div may occur. - T s = Math.sin(0.5*a1.angle)/n; - x *= s; - y *= s; - z *= s; - w = Math.cos(0.5*a1.angle); - } - -#endif - - /** - * Sets the value of this quaternion to the rotational component of - * the passed matrix. - * @param m1 the matrix4d - */ - void set(const Matrix4& m1); - - /** - * Sets the value of this quaternion to the rotational component of - * the passed matrix. - * @param m1 the matrix3d - */ - void set(const Matrix3& m1); - - - /** - * Sets the value of this quaternion to the equivalent rotation of teh - * AxisAngle argument. - * @param a1 the axis-angle - */ - void set(const AxisAngle4& a1); - - /** - * Performs a great circle interpolation between this quaternion and the - * quaternion parameter and places the result into this quaternion. - * @param q1 the other quaternion - * @param alpha the alpha interpolation parameter - */ - void interpolate(const Quat4& q1, T alpha); - - /** - * Performs a great circle interpolation between quaternion q1 and - * quaternion q2 and places the result into this quaternion. - * @param q1 the first quaternion - * @param q2 the second quaternion - * @param alpha the alpha interpolation parameter - */ - void interpolate(const Quat4& q1, const Quat4& q2, T alpha); - - // copy constructor and operator = is made by complier - - Quat4& operator*=(const Quat4& m1); - Quat4 operator*(const Quat4& m1) const; -}; - -VM_END_NS - -#ifdef VM_INCLUDE_IO -template -VM_IOSTREAM_STD::ostream& operator<<(VM_IOSTREAM_STD::ostream& o, const VM_VECMATH_NS::Quat4& q1); -#endif - -VM_BEGIN_NS - -typedef Quat4 Quat4d; -typedef Quat4 Quat4f; - -VM_END_NS - - -#endif /* QUAT4__H */ diff --git a/Utilities/vecmath/README b/Utilities/vecmath/README deleted file mode 100644 index 126b3f75c5..0000000000 --- a/Utilities/vecmath/README +++ /dev/null @@ -1,134 +0,0 @@ ------------------------------------------------------ - C++ port of unofficial javax.vecmath package - by Kenji Hiranabe - - 3/5 ,1999 version 1.1-1.0 - 5/25 ,1999 version 1.1-1.1 - 6/12 ,1999 version 1.1-1.2 - 10/5 ,1999 version 1.2-1.3 - 10/22 ,1999 version 1.2-1.4 ------------------------------------------------------ - -* INTRODUCTION - -This is a C++ port of unofficial free implementation -(source code release) of Java(TM) 3D API 1.2 -vecmath package. - -This package supports vector/point transformation math -often utilized in computer graphics. - -The included classes are the followings. - - * Tuples - - Tuple2 Tuple3 Tuple4 - | | | - +Vector2 +Vector3 +Vector4 - +Point2 +Point3 +Point4 - +TexCoord2 +Color3 +Quat4 - +Color4 - AxisAngle4 - - * Matrices - - Matrix3 Matrix4 - -These classes are (optionally) in the namespace of 'kh_vecmath'. - -You can download the zipped or tar+gzipped source code from; - - http://www.esm.co.jp/divisions/open-sys/java/vecmath/ - -* FEATURES - - ** Highest priority to SPEED. No 'new' operators, no arrays, no virual functions. - ** All files are *.h template header files. No need for linking libraries. - ** Has a test suite. - ** Aliasing-safe. i.e. v.cross(v,v1) or m.mul(m1,m) works. - ** optional IO stream and string conversion support. - ** Java3D 1.2 specification is implemented, but no GVector and GMatrix yet. - ** Works with standard C++ library (STL). - -* INSTALL - -1. unzip and untar the downloaded file, like; - % gunzip vecmath-c++-1.1-1.1.tar.gz - % tar xvf vecmath-c++-1.1-1.1.tar -2. place all *.h files into your header directory. - % cp vecmath-c++/*.h -3. write your C++ code, hello-vecmath.cpp - - #include - #include - using namespace kh_vecmath; // depends on vm_config.h - int main(int, char**) { - Matrix3d m(1,2,3,4,5,6,7,8,9); - Vector3d v(2,3,4); - cout << m*v; - return 0; - } - -4. compile, and run. don't forget to set include path to - when compilation. - -on unix, - % g++ -I hello-vecmath.cpp -o hello-vecmath - % hello-vecmath - -5. (20,47,74) is printed, voila ! -6. if needed, configure "vm_conf.h". -7. if needed, compile test programs(test-*.cpp) and run. -on unix, - % cp Makefile.unix Makefile - % make test - -on Windows with Visual Studio, use 'vecmath.dsw'for workspace. - -* TESTED PLATFORMS AND COMPILERS - -(1) Sun Solaris2.6 on SPARCStation with gcc2.7.2(+ libstdc++-2.8.1.1), - gcc2.8.1 and egcs1.1.2 - -for gcc2.7.2, gcc2.8.1 namespace is not supported. vm_conf.h will automaticlly -turns off VM_INCLUDE_NAMESPACE and eliminates namespace kh_vecmath. - -(2) Visual C++ 6.0 sp2 - (Thanks > "Lucas Ammon" ) - -(3) Windows 95 + Cygwin b20 egcs-2.91.66 19990314 (egcs-1.1.2 release) - (Thanks > Takayuki MATSUOKA ) - -(4) IRIX6.4 + MIPSPro7.2 - (Thanks > Katsuaki KAWACHI ) - -(5) Visual C++ 5.0 - (Thanks > Takayuki MATSUOKA ) - Add "/D TESTALL" and "/I .\\" to preprocessor macro when building - test project. - -..... please report on your platforms ! ..... - - -* TIPS - -** If you don't want namespace, #undef VM_INCLUDE_NAMESPAE in vm_conf.h. - -** If you don't want toString() method, #undef VM_INCLUDE_TOSTRING - in vm_conf.h. This may solve compilation errors in other compilers. - -** If you don't want cout << operation, #undef VM_INCLUDE_IO - in vm_conf.h. This may solve compilation errors in other compilers. - -** All the math functions such as sin,cos,atan2 are encapsulated -in VmUtil.h. If you have your own faster version, adjust the file. - -* FEEDBACK - -Any bug reports or comments are welcome. -If you think this package is useful, PLEASE give me feedback. -I would like to hear what kind of applications you are working on ! - ---- - Eiwa System Management, Inc. http://www.esm.co.jp/ - Kenji Hiranabe mailto:hiranabe@esm.co.jp diff --git a/Utilities/vecmath/TexCoord2.h b/Utilities/vecmath/TexCoord2.h deleted file mode 100644 index b9207de210..0000000000 --- a/Utilities/vecmath/TexCoord2.h +++ /dev/null @@ -1,83 +0,0 @@ -/* - Copyright (C) 1997,1998,1999 - Kenji Hiranabe, Eiwa System Management, Inc. - - This program is free software. - Implemented by Kenji Hiranabe(hiranabe@esm.co.jp), - conforming to the Java(TM) 3D API specification by Sun Microsystems. - - Permission to use, copy, modify, distribute and sell this software - and its documentation for any purpose is hereby granted without fee, - provided that the above copyright notice appear in all copies and - that both that copyright notice and this permission notice appear - in supporting documentation. Kenji Hiranabe and Eiwa System Management,Inc. - makes no representations about the suitability of this software for any - purpose. It is provided "AS IS" with NO WARRANTY. -*/ -#ifndef TEXCOORD2_H -#define TEXCOORD2_H - -#include "VmUtil.h" -#include "Tuple2.h" - -VM_BEGIN_NS - -/** - * A 2 element texture coordinate that is represented by x,y coordinates. - * @version specification 1.1, implementation $Revision$, $Date$ - * @author Kenji hiranabe - */ -template -class TexCoord2 : public Tuple2 { -/* - * $Log$ - * Revision 1.3 2005/10/13 13:42:39 maleike - * FIX: doxygen warnings - * - * Revision 1.2 2003/04/22 14:42:11 max - * made inclusions of vecmath header files "local" (for gcc 3.3 support) - * - * Revision 1.1 2002/11/16 12:25:36 mark - * vecmath bibliothek - * in cvs, da einige bugs behoben - * - * Revision 1.3 1999/10/06 02:52:46 hiranabe - * Java3D 1.2 and namespace - * - * Revision 1.2 1999/05/26 00:59:37 hiranabe - * support Visual C++ - * - * Revision 1.1 1999/03/04 11:07:09 hiranabe - * Initial revision - * - * Revision 1.1 1999/03/04 11:07:09 hiranabe - * Initial revision - * - */ -public: - /** - * Constructs and initializes a TexCoord2 from the specified xy coordinates. - * @param x the x coordinate - * @param y the y coordinate - */ - TexCoord2(T x, T y): Tuple2(x, y) { } - - /** - * Constructs and initializes a TexCoord2 from the specified array. - * @param v The array of length 2 containing xy in order - */ - TexCoord2(const T v[]): Tuple2(v) { } - - /** - * Constructs and initializes a TexCoord2 to (0,0). - */ - TexCoord2(): Tuple2() { } - -}; - -typedef TexCoord2 TexCoord2f; -typedef TexCoord2 TexCoord2d; - -VM_END_NS - -#endif /* TEXCOORD2_H */ diff --git a/Utilities/vecmath/Tuple2.h b/Utilities/vecmath/Tuple2.h deleted file mode 100644 index 5a91b31315..0000000000 --- a/Utilities/vecmath/Tuple2.h +++ /dev/null @@ -1,496 +0,0 @@ -/* - Copyright (C) 1997,1998,1999 - Kenji Hiranabe, Eiwa System Management, Inc. - - This program is free software. - Implemented by Kenji Hiranabe(hiranabe@esm.co.jp), - conforming to the Java(TM) 3D API specification by Sun Microsystems. - - Permission to use, copy, modify, distribute and sell this software - and its documentation for any purpose is hereby granted without fee, - provided that the above copyright notice appear in all copies and - that both that copyright notice and this permission notice appear - in supporting documentation. Kenji Hiranabe and Eiwa System Management,Inc. - makes no representations about the suitability of this software for any - purpose. It is provided "AS IS" with NO WARRANTY. -*/ -#ifndef TUPLE2_H -#define TUPLE2_H - -#include "VmUtil.h" - -VM_BEGIN_NS - -/** - * A generic 2 element tuple that is represented by - * point x,y coordinates. - * @version specification 1.1, implementation $Revision$, $Date$ - * @author Kenji hiranabe - */ -template -class Tuple2 { -/* - * $Log$ - * Revision 1.2 2003/04/22 14:42:11 max - * made inclusions of vecmath header files "local" (for gcc 3.3 support) - * - * Revision 1.1 2002/11/16 12:25:36 mark - * vecmath bibliothek - * in cvs, da einige bugs behoben - * - * Revision 1.4 1999/10/22 08:37:10 hiranabe - * added operator=. work around for IRIX6.4 + MIPSPro7.2. - * Thanks > Katsuaki KAWACHI - * - * Revision 1.3 1999/10/06 02:52:46 hiranabe - * Java3D 1.2 and namespace - * - * Revision 1.2 1999/05/26 00:59:37 hiranabe - * support Visual C++ - * - * Revision 1.1 1999/03/04 11:07:09 hiranabe - * Initial revision - * - * Revision 1.1 1999/03/04 11:07:09 hiranabe - * Initial revision - * - */ -public: - /** - * the type for values - */ - typedef T value_type; - /** - * the type for index - */ - typedef size_t size_type; - /** - * dimension - */ - enum { DIMENSION = 2 }; - - /** - * The x coordinate. - */ - T x; - - /** - * The y coordinate. - */ - T y; - - /** - * Constructs and initializes a Tuple from the specified xy coordinates. - * @param xvalue the x coordinate - * @param yvalue the y coordinate - */ - Tuple2(T xvalue, T yvalue): x(xvalue), y(yvalue) { } - - /** - * Constructs and initializes a Tuple from the specified array. - * @param t the array of length 2 containing xy in order - */ - Tuple2(const T t[]): x(t[0]), y(t[1]) { } - - -#if 0 - /** - * Constructs and initializes a Tuple2 from the specified Tuple2f. - * this is special version for float to double or complex - * @param t1 the Tuple2 containing the initialization x y data - */ - Tuple2(const Tuple2& t1): x(t1.x), y(t1.y) { } - -#endif - - /** - * Constructs and initializes a Tuple2 to (0,0). - */ - Tuple2(): x(0), y(0) { } - - /** - * Sets the value of this tuple to the specified xy coordinates. - * @param xvalue the x coordinate - * @param yvalue the y coordinate - */ - void set(T xvalue, T yvalue) { - x = xvalue; - y = yvalue; - } - - /** - * Sets the value of this tuple from the 2 values specified in the array. - * @param t the array of length 2 containing xy in order - */ - void set(const T t[]) { - x = t[0]; - y = t[1]; - } - - /** - * Sets the value of this tuple to the value of the Tuple2 argument. - * @param t1 the tuple to be copied - */ - void set(const Tuple2& t1) { - x = t1.x; - y = t1.y; - } - - /** - * Copies the value of the elements of this tuple into the array t[]. - * @param t the array that will contain the values of the vector - * asserting t has room for 2 values. - */ - void get(T t[]) const { - t[0] = x; - t[1] = y; - } - - /** - * Gets the value of this tuple and copies the values into the Tuple2. - * @param t Tuple2 object into which that values of this object are copied - */ - void get(Tuple2* t) const { - assert(t); - t->x = x; - t->y = y; - } - - /** - * Sets the value of this tuple to the vector sum of tuples t1 and t2. - * @param t1 the first tuple - * @param t2 the second tuple - */ - void add(const Tuple2& t1, const Tuple2& t2) { - x = t1.x + t2.x; - y = t1.y + t2.y; - } - - /** - * Sets the value of this tuple to the vector sum of itself and tuple t1. - * @param t1 the other tuple - */ - void add(const Tuple2& t1) { - x += t1.x; - y += t1.y; - } - - /** - * Sets the value of this tuple to the vector difference of tuple t1 and t2 (this = t1 - t2). - * @param t1 the first tuple - * @param t2 the second tuple - */ - void sub(const Tuple2& t1, const Tuple2& t2) { - x = t1.x - t2.x; - y = t1.y - t2.y; - } - - /** - * Sets the value of this tuple to the vector difference of itself and tuple t1 (this = this - t1). - * @param t1 the other tuple - */ - void sub(const Tuple2& t1) { - x -= t1.x; - y -= t1.y; - } - - /** - * Sets the value of this tuple to the negation of tuple t1. - * @param t1 the source vector - */ - void negate(const Tuple2& t1) { - x = -t1.x; - y = -t1.y; - } - - /** - * Negates the value of this vector in place. - */ - void negate() { - x = -x; - y = -y; - } - - /** - * Sets the value of this tuple to the scalar multiplication of tuple t1. - * @param s the scalar value - * @param t1 the source tuple - */ - void scale(T s, const Tuple2& t1) { - x = s*t1.x; - y = s*t1.y; - } - - /** - * Sets the value of this tuple to the scalar multiplication of itself. - * @param s the scalar value - */ - void scale(T s) { - x *= s; - y *= s; - } - - /** - * Sets the value of this tuple to the scalar multiplication of tuple t1 and then - * adds tuple t2 (this = s*t1 + t2). - * @param s the scalar value - * @param t1 the tuple to be multipled - * @param t2 the tuple to be added - */ - void scaleAdd(T s, const Tuple2& t1, const Tuple2& t2) { - x = s*t1.x + t2.x; - y = s*t1.y + t2.y; - } - - /** - * Sets the value of this tuple to the scalar multiplication of itself and then - * adds tuple t1 (this = s*this + t1). - * @param s the scalar value - * @param t1 the tuple to be added - */ - void scaleAdd(T s, const Tuple2& t1) { - x = s*x + t1.x; - y = s*y + t1.y; - } - - /** - * Returns a hash number based on the data values in this object. - * Two different Tuple2 objects with identical data values - * (ie, returns true for equals(Tuple2) ) will return the same hash number. - * Two vectors with different data members may return the same hash value, - * although this is not likely. - */ - size_t hashCode() const { - return VmUtil::hashCode(sizeof *this, this); - } - - /** - * Returns true if all of the data members of Tuple2 t1 are equal to the corresponding - * data members in this - * @param t1 the vector with which the comparison is made. - */ - bool equals(const Tuple2& t1) const { - return t1.x == x && t1.y == y; - } - - /** - * Returns true if the L-infinite distance between this tuple and tuple t1 is - * less than or equal to the epsilon parameter, otherwise returns false. The L-infinite - * distance is equal to MAX[abs(x1-x2), abs(y1-y2)]. - * @param t1 the tuple to be compared to this tuple - * @param epsilon the threshold value - */ - bool epsilonEquals(const Tuple2& t1, T epsilon) const { - return (VmUtil::abs(t1.x - x) <= epsilon) && - (VmUtil::abs(t1.y - y) <= epsilon); - } - - /** - * Clamps the tuple parameter to the range [low, high] and places the values - * into this tuple. - * @param min the lowest value in the tuple after clamping - * @param max the highest value in the tuple after clamping - * @param t the source tuple, which will not be modified - */ - void clamp(T min, T max, const Tuple2& t) { - set(t); - clamp(min, max); - } - - /** - * Clamps the minimum value of the tuple parameter to the min parameter - * and places the values into this tuple. - * @param min the lowest value in the tuple after clamping - * @parm t the source tuple, which will not be modified - */ - void clampMin(T min, const Tuple2& t) { - set(t); - clampMin(min); - } - - /** - * Clamps the maximum value of the tuple parameter to the max parameter and - * places the values into this tuple. - * @param max the highest value in the tuple after clamping - * @param t the source tuple, which will not be modified - */ - void clampMax(T max, const Tuple2& t) { - set(t); - clampMax(max); - } - - - /** - * Sets each component of the tuple parameter to its absolute value and - * places the modified values into this tuple. - * @param t the source tuple, which will not be modified - */ - void absolute(const Tuple2& t) { - set(t); - absolute(); - } - - /** - * Clamps this tuple to the range [low, high]. - * @param min the lowest value in this tuple after clamping - * @param max the highest value in this tuple after clamping - */ - void clamp(T min, T max) { - clampMin(min); - clampMax(max); - } - - /** - * Clamps the minimum value of this tuple to the min parameter. - * @param min the lowest value in this tuple after clamping - */ - void clampMin(T min) { - if (x < min) - x = min; - if (y < min) - y = min; - } - - /** - * Clamps the maximum value of this tuple to the max parameter. - * @param max the highest value in the tuple after clamping - */ - void clampMax(T max) { - if (x > max) - x = max; - if (y > max) - y = max; - } - - /** - * Sets each component of this tuple to its absolute value. - */ - void absolute() { - if (x < 0.0) - x = -x; - if (y < 0.0) - y = -y; - } - - /** - * Linearly interpolates between tuples t1 and t2 and places the - * result into this tuple: this = (1-alpha)*t1 + alpha*t2. - * @param t1 the first tuple - * @param t2 the second tuple - * @param alpha the alpha interpolation parameter - */ - void interpolate(const Tuple2& t1, const Tuple2& t2, T alpha) { - set(t1); - interpolate(t2, alpha); - } - - - /** - * Linearly interpolates between this tuple and tuple t1 and places the - * result into this tuple: this = (1-alpha)*this + alpha*t1. - * @param t1 the first tuple - * @param alpha the alpha interpolation parameter - * - */ - void interpolate(const Tuple2& t1, T alpha) { - T beta = 1 - alpha; - x = beta*x + alpha*t1.x; - y = beta*y + alpha*t1.y; - } - - /** - * Returns a string that contains the values of this Tuple2. The form is (x,y). - * @return the String representation - */ -#ifdef VM_INCLUDE_TOSTRING -VM_STRING_STD::string toString() const { - VM_TOSTRING - } -#endif - - // copy constructor and operator = is made by complier - - bool operator==(const Tuple2& t1) const { - return equals(t1); - } - -#ifdef VM_INCLUDE_SUBSCRIPTION_OPERATOR - T operator[](size_t index) const { - assert(index < (size_t)DIMENSION); - switch (index) { - case 0: - return x; - case 1: - return y; - default: - // error ! - return 0; - } - } - T& operator[](size_t index) { - static T dummy; - assert(index < (size_t)DIMENSION); - switch (index) { - case 0: - return x; - case 1: - return y; - default: - // error ! - return dummy; - } - } -#endif - - Tuple2& operator=(const Tuple2& t1) { - set(t1); - return *this; - } - - Tuple2& operator+=(const Tuple2& t1) { - add(t1); - return *this; - } - Tuple2& operator-=(const Tuple2& t1) { - sub(t1); - return *this; - } - Tuple2& operator*=(T s) { - scale(s); - return *this; - } - Tuple2 operator+(const Tuple2& t1) const { - return (Tuple2(*this)).operator+=(t1); - } - Tuple2 operator-(const Tuple2& t1) const { - return (Tuple2(*this)).operator-=(t1); - } - Tuple2 operator*(T s) const { - return (Tuple2(*this)).operator*=(s); - } -}; - -VM_END_NS - -template -inline -VM_VECMATH_NS::Tuple2 operator*(T s, const VM_VECMATH_NS::Tuple2& t1) { - return (VM_VECMATH_NS::Tuple2(t1)).operator*=(s); -} - -#ifdef VM_INCLUDE_IO -template -VM_IOSTREAM_STD::ostream& operator<<(VM_IOSTREAM_STD::ostream& o, const VM_VECMATH_NS::Tuple2& t1) { - return o << "(" << t1.x << "," << t1.y << ")"; -} -#endif - -VM_BEGIN_NS - -typedef Tuple2 Tuple2d; -typedef Tuple2 Tuple2f; - -VM_END_NS - - -#endif /* TUPLE2_H */ diff --git a/Utilities/vecmath/Tuple3.h b/Utilities/vecmath/Tuple3.h deleted file mode 100644 index 057f4dd007..0000000000 --- a/Utilities/vecmath/Tuple3.h +++ /dev/null @@ -1,588 +0,0 @@ -/* - Copyright (C) 1997,1998,1999 - Kenji Hiranabe, Eiwa System Management, Inc. - - This program is free software. - Implemented by Kenji Hiranabe(hiranabe@esm.co.jp), - conforming to the Java(TM) 3D API specification by Sun Microsystems. - - Permission to use, copy, modify, distribute and sell this software - and its documentation for any purpose is hereby granted without fee, - provided that the above copyright notice appear in all copies and - that both that copyright notice and this permission notice appear - in supporting documentation. Kenji Hiranabe and Eiwa System Management,Inc. - makes no representations about the suitability of this software for any - purpose. It is provided "AS IS" with NO WARRANTY. -*/ -#ifndef TUPLE3_H -#define TUPLE3_H - -#include "VmUtil.h" - -VM_BEGIN_NS - -/** - * A generic 3 element tuple that is represented by - * x,y and z coordinates. - * @version specification 1.1, implementation $Revision$, $Date$ - * @author Kenji hiranabe - */ -template -class Tuple3 { -/* - * $Log$ - * Revision 1.4 2003/08/14 16:22:51 max - * added vmless function object, which allows Tuple3 to be used in sorted stl-containers - * - * Revision 1.3 2003/04/22 14:42:11 max - * made inclusions of vecmath header files "local" (for gcc 3.3 support) - * - * Revision 1.2 2003/02/08 16:25:58 peter - * added istream >> operator - * - * Revision 1.1 2002/11/16 12:25:36 mark - * vecmath bibliothek - * in cvs, da einige bugs behoben - * - * Revision 1.5 1999/10/22 08:37:25 hiranabe - * added operator=. work around for IRIX6.4 + MIPSPro7.2. - * Thanks > Katsuaki KAWACHI - * - * Revision 1.4 1999/10/06 02:52:46 hiranabe - * Java3D 1.2 and namespace - * - * Revision 1.3 1999/06/07 12:47:35 hiranabe - * VM_INCLUDE_STRING -> VM_INCLUDE_TOSTRING - * thanks > kawachi@cim.pe.u-tokyo.ac.jp - * - * Revision 1.2 1999/05/26 00:59:37 hiranabe - * support Visual C++ - * - * Revision 1.1 1999/03/04 11:07:09 hiranabe - * Initial revision - * - * Revision 1.1 1999/03/04 11:07:09 hiranabe - * Initial revision - * - */ -public: - /** - * the type for values - */ - typedef T value_type; - /** - * the type for index - */ - typedef size_t size_type; - /** - * dimension - */ - enum { DIMENSION = 3 }; - /** - * The x coordinate. - */ - T x; - - /** - * The y coordinate. - */ - T y; - - /** - * The z coordinate. - */ - T z; - - /** - * Constructs and initializes a Tuple3 from the specified xyz coordinates. - * @param xvalue the x coordinate - * @param yvalue the y coordinate - * @param zvalue the z coordinate - */ - Tuple3(T xvalue, T yvalue, T zvalue): x(xvalue), y(yvalue), z(zvalue) { } - - /** - * Constructs and initializes a Tuple3 from the specified array. - * @param t the array of length 3 containing xyz in order - */ - Tuple3(const T t[]): x(t[0]), y(t[1]), z(t[2]) { } - - /** - * Constructs and initializes a Tuple3 to (0,0,0). - */ - Tuple3(): x(0), y(0), z(0) { } - - /** - * Sets the value of this tuple to the specified xyz coordinates. - * @param xvalue the x coordinate - * @param yvalue the y coordinate - * @param zvalue the z coordinate - */ - void set(T xvalue, T yvalue, T zvalue) { - x = xvalue; - y = yvalue; - z = zvalue; - } - - /** - * Sets the value of this tuple from the 3 values specified in the array. - * @param t the array of length 3 containing xyz in order - */ - void set(const T t[]) { - x = t[0]; - y = t[1]; - z = t[2]; - } - - /** - * Sets the value of this tuple to the value of the Tuple3 argument. - * @param t1 the tuple to be copied - */ - void set(const Tuple3& t1) { - x = t1.x; - y = t1.y; - z = t1.z; - } - - /** - * Copies the value of the elements of this tuple into the array t[]. - * @param t the array that will contain the values of the vector - */ - void get(T t[]) const { - t[0] = x; - t[1] = y; - t[2] = z; - } - - /** - * Gets the value of this tuple and copies the values into the Tuple3. - * @param t Tuple3 object into which that values of this object are copied - */ - void get(Tuple3* t) const { - assert(t); - t->x = x; - t->y = y; - t->z = z; - } - - /** - * Sets the value of this tuple to the vector sum of tuples t1 and t2. - * @param t1 the first tuple - * @param t2 the second tuple - */ - void add(const Tuple3& t1, const Tuple3& t2) { - x = t1.x + t2.x; - y = t1.y + t2.y; - z = t1.z + t2.z; - } - - /** - * Sets the value of this tuple to the vector sum of itself and tuple t1. - * @param t1 the other tuple - */ - void add(const Tuple3& t1) { - x += t1.x; - y += t1.y; - z += t1.z; - } - - - /** - * Sets the value of this tuple to the vector difference of tuple t1 and t2 (this = t1 - t2). - * @param t1 the first tuple - * @param t2 the second tuple - */ - void sub(const Tuple3& t1, const Tuple3& t2) { - x = t1.x - t2.x; - y = t1.y - t2.y; - z = t1.z - t2.z; - } - - /** - * Sets the value of this tuple to the vector difference of itself and tuple t1 (this = this - t1). - * @param t1 the other tuple - */ - void sub(const Tuple3& t1) { - x -= t1.x; - y -= t1.y; - z -= t1.z; - } - - /** - * Sets the value of this tuple to the negation of tuple t1. - * @param t1 the source vector - */ - void negate(const Tuple3& t1) { - x = -t1.x; - y = -t1.y; - z = -t1.z; - } - - /** - * Negates the value of this vector in place. - */ - void negate() { - x = -x; - y = -y; - z = -z; - } - - - /** - * Sets the value of this tuple to the scalar multiplication of tuple t1. - * @param s the scalar value - * @param t1 the source tuple - */ - void scale(T s, const Tuple3& t1) { - x = s*t1.x; - y = s*t1.y; - z = s*t1.z; - } - - /** - * Sets the value of this tuple to the scalar multiplication of itself. - * @param s the scalar value - */ - void scale(T s) { - x *= s; - y *= s; - z *= s; - } - - /** - * Sets the value of this tuple to the scalar multiplication of tuple t1 and then - * adds tuple t2 (this = s*t1 + t2). - * @param s the scalar value - * @param t1 the tuple to be multipled - * @param t2 the tuple to be added - */ - void scaleAdd(T s, const Tuple3& t1, const Tuple3& t2) { - x = s*t1.x + t2.x; - y = s*t1.y + t2.y; - z = s*t1.z + t2.z; - } - - /** - * Sets the value of this tuple to the scalar multiplication of itself and then - * adds tuple t1 (this = s*this + t1). - * @param s the scalar value - * @param t1 the tuple to be added - */ - void scaleAdd(T s, const Tuple3& t1) { - x = s*x + t1.x; - y = s*y + t1.y; - z = s*z + t1.z; - } - - /** - * Returns a hash number based on the data values in this object. - * Two different Tuple3 objects with identical data values - * (ie, returns true for equals(Tuple3) ) will return the same hash number. - * Two vectors with different data members may return the same hash value, - * although this is not likely. - */ - size_t hashCode() const { - return VmUtil::hashCode(sizeof *this, this); - } - - /** - * Returns true if all of the data members of Tuple3 t1 are equal to the corresponding - * data members in this - * @param t1 the vector with which the comparison is made. - */ - bool equals(const Tuple3& t1) const { - return t1.x == x && t1.y == y && t1.z == z; - } - - /** - * Returns true if the L-infinite distance between this tuple and tuple t1 is - * less than or equal to the epsilon parameter, otherwise returns false. The L-infinite - * distance is equal to MAX[abs(x1-x2), abs(y1-y2)]. - * @param t1 the tuple to be compared to this tuple - * @param epsilon the threshold value - */ - bool epsilonEquals(const Tuple3& t1, T epsilon) const { - return (VmUtil::abs(t1.x - x) <= epsilon) && - (VmUtil::abs(t1.y - y) <= epsilon) && - (VmUtil::abs(t1.z - z) <= epsilon); - } - - /** - * Sets each component of the tuple parameter to its absolute value and - * places the modified values into this tuple. - * @param t the source tuple, which will not be modified - */ - void absolute(const Tuple3& t) { - set(t); - absolute(); - } - - /** - * Sets each component of this tuple to its absolute value. - */ - void absolute() { - if (x < 0.0) - x = -x; - if (y < 0.0) - y = -y; - if (z < 0.0) - z = -z; - } - - /** - * Clamps this tuple to the range [low, high]. - * @param min the lowest value in this tuple after clamping - * @param max the highest value in this tuple after clamping - */ - void clamp(T min, T max) { - clampMin(min); - clampMax(max); - } - - /** - * Clamps the tuple parameter to the range [low, high] and places the values - * into this tuple. - * @param min the lowest value in the tuple after clamping - * @param max the highest value in the tuple after clamping - * @param t the source tuple, which will not be modified - */ - void clamp(T min, T max, const Tuple3& t) { - set(t); - clamp(min, max); - } - - /** - * Clamps the minimum value of this tuple to the min parameter. - * @param min the lowest value in this tuple after clamping - */ - void clampMin(T min) { - if (x < min) - x = min; - if (y < min) - y = min; - if (z < min) - z = min; - } - - /** - * Clamps the minimum value of the tuple parameter to the min parameter - * and places the values into this tuple. - * @param min the lowest value in the tuple after clamping - * @parm t the source tuple, which will not be modified - */ - void clampMin(T min, const Tuple3& t) { - set(t); - clampMin(min); - } - - /** - * Clamps the maximum value of the tuple parameter to the max parameter and - * places the values into this tuple. - * @param max the highest value in the tuple after clamping - * @param t the source tuple, which will not be modified - */ - void clampMax(T max, const Tuple3& t) { - set(t); - clampMax(max); - } - - - /** - * Clamps the maximum value of this tuple to the max parameter. - * @param max the highest value in the tuple after clamping - */ - void clampMax(T max) { - if (x > max) - x = max; - if (y > max) - y = max; - if (z > max) - z = max; - } - - /** - * Linearly interpolates between tuples t1 and t2 and places the - * result into this tuple: this = (1-alpha)*t1 + alpha*t2. - * @param t1 the first tuple - * @param t2 the second tuple - * @param alpha the alpha interpolation parameter - */ - void interpolate(const Tuple3& t1, const Tuple3& t2, T alpha) { - set(t1); - interpolate(t2, alpha); - } - - - /** - * Linearly interpolates between this tuple and tuple t1 and places the - * result into this tuple: this = (1-alpha)*this + alpha*t1. - * @param t1 the first tuple - * @param alpha the alpha interpolation parameter - */ - void interpolate(const Tuple3& t1, T alpha) { - T beta = 1 - alpha; - x = beta*x + alpha*t1.x; - y = beta*y + alpha*t1.y; - z = beta*z + alpha*t1.z; - } - - /** - * Returns a string that contains the values of this Tuple3. The form is (x,y,z). - * @return the String representation - */ -#ifdef VM_INCLUDE_TOSTRING - VM_STRING_STD::string toString() const { - VM_TOSTRING - } -#endif - - // copy constructor and operator = is made by complier - - bool operator==(const Tuple3& t1) const { - return equals(t1); - } - -#ifdef VM_INCLUDE_SUBSCRIPTION_OPERATOR - T operator[](size_t index) const { - static T dummy; - assert(index < (size_t)DIMENSION); - switch (index) { - case 0: - return x; - case 1: - return y; - case 2: - return z; - default: - // error ! - return 0; - } - } - T& operator[](size_t index) { - static T dummy; - assert(index < (size_t)DIMENSION); - switch (index) { - case 0: - return x; - case 1: - return y; - case 2: - return z; - default: - // error ! - return dummy; - } - } -#endif - - Tuple3& operator=(const Tuple3& t1) { - set(t1); - return *this; - } - - Tuple3& operator+=(const Tuple3& t1) { - add(t1); - return *this; - } - Tuple3& operator-=(const Tuple3& t1) { - sub(t1); - return *this; - } - Tuple3& operator*=(T s) { - scale(s); - return *this; - } - Tuple3 operator+(const Tuple3& t1) const { - return (Tuple3(*this)).operator+=(t1); - } - Tuple3 operator-(const Tuple3& t1) const { - return (Tuple3(*this)).operator-=(t1); - } - Tuple3 operator*(T s) const { - return (Tuple3(*this)).operator*=(s); - } - -}; - -VM_END_NS - -#ifdef VM_INCLUDE_IO -template -VM_IOSTREAM_STD::ostream& operator<<(VM_IOSTREAM_STD::ostream& o, const VM_VECMATH_NS::Tuple3& t1) { - return o << "(" << t1.x << "," << t1.y << "," << t1.z << ")"; -} - -template -VM_IOSTREAM_STD::istream& operator>>(VM_IOSTREAM_STD::istream& i, VM_VECMATH_NS::Tuple3& t1) { - - char c; - - i >> c; - i >> t1.x; - i >> c; - i >> t1.y; - i >> c; - i >> t1.z; - i >> c; - - return i; -} - -#endif - -template -inline -VM_VECMATH_NS::Tuple3 operator*(T s, const VM_VECMATH_NS::Tuple3& t1) { - return (VM_VECMATH_NS::Tuple3(t1)).operator*=(s); -} - -VM_BEGIN_NS - -typedef Tuple3 Tuple3d; -typedef Tuple3 Tuple3f; - - - -/** - * Function object which provides a strict weak ordering of tuples. This allows - * tuples/points/vectors to be used in sorted STL containers like maps, sets - * etc... - */ -template -struct vmless -{ - /** - * Orders the tuples by their z,y and x values. z has the highest priority, x the smallest - * @param vec1 the first tuple - * @param vec2 the second type - * @returns true if vec1 < vec2, false otherwise. - */ - bool operator() ( const Tuple3& t1, const Tuple3& t2 ) const - { - if ( t1.z < t2.z ) - return true; - else if ( t1.z > t2.z ) - return false; - else if ( t1.z == t2.z ) - { - if ( t1.y < t2.y ) - return true; - else if ( t1.y > t2.y ) - return false; - else if ( t1.y == t2.y ) - { - if ( t1.x < t2.x ) - return true; - else if ( t1.x > t2.x ) - return false; - else if ( t1.x == t2.x ) - return false; - } - } - return false; //the impossible happened! - } -}; - -VM_END_NS - -#endif /* TUPLE3_H */ diff --git a/Utilities/vecmath/Tuple4.h b/Utilities/vecmath/Tuple4.h deleted file mode 100644 index 8c2fb6737d..0000000000 --- a/Utilities/vecmath/Tuple4.h +++ /dev/null @@ -1,587 +0,0 @@ -/* - Copyright (C) 1997,1998,1999 - Kenji Hiranabe, Eiwa System Management, Inc. - - This program is free software. - Implemented by Kenji Hiranabe(hiranabe@esm.co.jp), - conforming to the Java(TM) 3D API specification by Sun Microsystems. - - Permission to use, copy, modify, distribute and sell this software - and its documentation for any purpose is hereby granted without fee, - provided that the above copyright notice appear in all copies and - that both that copyright notice and this permission notice appear - in supporting documentation. Kenji Hiranabe and Eiwa System Management,Inc. - makes no representations about the suitability of this software for any - purpose. It is provided "AS IS" with NO WARRANTY. -*/ -#ifndef TUPLE4_H -#define TUPLE4_H - -#include "VmUtil.h" - -VM_BEGIN_NS - -/** - * A generic 4 element tuple that is represented by - * x,y,z and w coordinates. - * @version specification 1.1, implementation $Revision$, $Date$ - * @author Kenji hiranabe - */ -template -class Tuple4 { -/* - * $Log$ - * Revision 1.4 2005/10/06 15:27:15 nolden - * FIX: gcc4 compatibility - * - * Revision 1.3 2003/04/22 14:42:11 max - * made inclusions of vecmath header files "local" (for gcc 3.3 support) - * - * Revision 1.2 2003/02/08 16:25:42 peter - * added istream >> operator - * - * Revision 1.1 2002/11/16 12:25:36 mark - * vecmath bibliothek - * in cvs, da einige bugs behoben - * - * Revision 1.5 1999/10/22 08:37:34 hiranabe - * added operator=. work around for IRIX6.4 + MIPSPro7.2. - * Thanks > Katsuaki KAWACHI - * - * Revision 1.4 1999/10/06 02:52:46 hiranabe - * Java3D 1.2 and namespace - * - * Revision 1.3 1999/06/07 12:47:35 hiranabe - * VM_INCLUDE_STRING -> VM_INCLUDE_TOSTRING - * thanks > kawachi@cim.pe.u-tokyo.ac.jp - * - * Revision 1.2 1999/05/26 00:59:37 hiranabe - * support Visual C++ - * - * Revision 1.1 1999/03/04 11:07:09 hiranabe - * Initial revision - * - * Revision 1.1 1999/03/04 11:07:09 hiranabe - * Initial revision - * - */ -public: - /** - * the type for values - */ - typedef T value_type; - /** - * the type for index - */ - typedef size_t size_type; - /** - * dimension - */ - enum { DIMENSION = 4 }; - - /** - * The x coordinate. - */ - T x; - - /** - * The y coordinate. - */ - T y; - - /** - * The z coordinate. - */ - T z; - - /** - * The w coordinate. - */ - T w; - - /** - * Constructs and initializes a Tuple4 from the specified xyzw coordinates. - * @param xvalue the x coordinate - * @param yvalue the y coordinate - * @param zvalue the z coordinate - * @param wvalue the w coordinate - */ - Tuple4(T xvalue, T yvalue, T zvalue, T wvalue): - x(xvalue), y(yvalue), z(zvalue), w(wvalue) { } - - /** - * Constructs and initializes a Tuple4 from the specified array. - * @param t the array of length 4 containing xyzw in order - */ - Tuple4(const T t[]): x(t[0]), y(t[1]), z(t[2]), w(t[3]) { } - - /** - * Constructs and initializes a Tuple4 to (0,0,0,0). - */ - Tuple4(): x(0), y(0), z(0), w(0) { } - - /** - * Sets the value of this tuple to the specified xyzw coordinates. - * @param xvalue the x coordinate - * @param yvalue the y coordinate - * @param zvalue the z coordinate - * @param wvalue the w coordinate - */ - void set(T xvalue, T yvalue, T zvalue, T wvalue) { - x = xvalue; - y = yvalue; - z = zvalue; - w = wvalue; - } - - /** - * Sets the value of this tuple from the 4 values specified in the array. - * @param t the array of length 4 containing xyzw in order - */ - void set(const T t[]) { - x = t[0]; - y = t[1]; - z = t[2]; - w = t[3]; - } - - /** - * Sets the value of this tuple to the value of tuple t1. - * @param t1 the tuple to be copied - */ - void set(const Tuple4& t1) { - x = t1.x; - y = t1.y; - z = t1.z; - w = t1.w; - } - - /** - * Copies the value of the elements of this tuple into the array t[]. - * @param t the array that will contain the values of the vector - */ - void get(T t[]) const { - t[0] = x; - t[1] = y; - t[2] = z; - t[3] = w; - } - - /** - * Gets the value of this tuple and copies the values into the Tuple4. - * @param t Tuple4 object into which that values of this object are copied - */ - void get(Tuple4* t) const { - assert(t); - t->x = x; - t->y = y; - t->z = z; - t->w = w; - } - - /** - * Sets the value of this tuple to the vector sum of tuples t1 and t2. - * @param t1 the first tuple - * @param t2 the second tuple - */ - void add(const Tuple4& t1, const Tuple4& t2) { - x = t1.x + t2.x; - y = t1.y + t2.y; - z = t1.z + t2.z; - w = t1.w + t2.w; - } - - /** - * Sets the value of this tuple to the vector sum of itself and tuple t1. - * @param t1 the other tuple - */ - void add(const Tuple4& t1) { - x += t1.x; - y += t1.y; - z += t1.z; - w += t1.w; - } - - - /** - * Sets the value of this tuple to the vector difference of tuple t1 and t2 (this = t1 - t2). - * @param t1 the first tuple - * @param t2 the second tuple - */ - void sub(const Tuple4& t1, const Tuple4& t2) { - x = t1.x - t2.x; - y = t1.y - t2.y; - z = t1.z - t2.z; - w = t1.w - t2.w; - } - - /** - * Sets the value of this tuple to the vector difference of itself and tuple t1 (this = this - t1). - * @param t1 the other tuple - */ - void sub(const Tuple4& t1) { - x -= t1.x; - y -= t1.y; - z -= t1.z; - w -= t1.w; - } - - /** - * Sets the value of this tuple to the negation of tuple t1. - * @param t1 the source vector - */ - void negate(const Tuple4& t1) { - x = -t1.x; - y = -t1.y; - z = -t1.z; - w = -t1.w; - } - - /** - * Negates the value of this vector in place. - */ - void negate() { - x = -x; - y = -y; - z = -z; - w = -w; - } - - - /** - * Sets the value of this tuple to the scalar multiplication of tuple t1. - * @param s the scalar value - * @param t1 the source tuple - */ - void scale(T s, const Tuple4& t1) { - x = s*t1.x; - y = s*t1.y; - z = s*t1.z; - w = s*t1.w; - } - - /** - * Sets the value of this tuple to the scalar multiplication of itself. - * @param s the scalar value - */ - void scale(T s) { - x *= s; - y *= s; - z *= s; - w *= s; - } - - /** - * Sets the value of this tuple to the scalar multiplication of tuple t1 and then - * adds tuple t2 (this = s*t1 + t2). - * @param s the scalar value - * @param t1 the tuple to be multipled - * @param t2 the tuple to be added - */ - void scaleAdd(T s, const Tuple4& t1, const Tuple4& t2) { - x = s*t1.x + t2.x; - y = s*t1.y + t2.y; - z = s*t1.z + t2.z; - w = s*t1.w + t2.w; - } - - /** - * Sets the value of this tuple to the scalar multiplication of itself and then - * adds tuple t1 (this = s*this + t1). - * @param s the scalar value - * @param t1 the tuple to be added - */ - // Bug fixed, 12.11.2002 - void scaleAdd(T s, const Tuple4& t1) { - x = s*x + t1.x; - y = s*y + t1.y; - z = s*z + t1.z; - w = s*w + t1.w; - } - - /** - * Returns a hash number based on the data values in this object. - * Two different Tuple4 objects with identical data values - * (ie, returns true for equals(Tuple4) ) will return the same hash number. - * Two vectors with different data members may return the same hash value, - * although this is not likely. - */ - size_t hashCode() const { - return VmUtil::hashCode(sizeof *this, this); - } - - /** - * Returns true if all of the data members of Tuple4 t1 are equal to the corresponding - * data members in this - * @param t1 the vector with which the comparison is made. - */ - bool equals(const Tuple4& t1) const { - return x == t1.x && y == t1.y && z == t1.z && w == t1.w; - } - - /** - * Returns true if the L-infinite distance between this tuple and tuple t1 is - * less than or equal to the epsilon parameter, otherwise returns false. The L-infinite - * distance is equal to MAX[abs(x1-x2), abs(y1-y2), abs(z1-z2), abs(w1-w2)]. - * @param t1 the tuple to be compared to this tuple - * @param epsilon the threshold value - */ - bool epsilonEquals(const Tuple4& t1, T epsilon) const { - return (VmUtil::abs(t1.x - x) <= epsilon) && - (VmUtil::abs(t1.y - y) <= epsilon) && - (VmUtil::abs(t1.z - z) <= epsilon) && - (VmUtil::abs(t1.w - w) <= epsilon); - } - - /** - * Clamps the tuple parameter to the range [low, high] and places the values - * into this tuple. - * @param min the lowest value in the tuple after clamping - * @param max the highest value in the tuple after clamping - * @param t the source tuple, which will not be modified - */ - void clamp(T min, T max, const Tuple4& t) { - set(t); - clamp(min, max); - } - - /** - * Clamps the minimum value of the tuple parameter to the min parameter - * and places the values into this tuple. - * @param min the lowest value in the tuple after clamping - * @parm t the source tuple, which will not be modified - */ - void clampMin(T min, const Tuple4& t) { - set(t); - clampMin(min); - } - - /** - * Clamps the maximum value of the tuple parameter to the max parameter and - * places the values into this tuple. - * @param max the highest value in the tuple after clamping - * @param t the source tuple, which will not be modified - */ - void clampMax(T max, const Tuple4& t) { - set(t); - clampMax(max); - } - - - /** - * Sets each component of the tuple parameter to its absolute value and - * places the modified values into this tuple. - * @param t the source tuple, which will not be modified - */ - void absolute(const Tuple4& t) { - set(t); - absolute(); - } - - /** - * Clamps this tuple to the range [low, high]. - * @param min the lowest value in this tuple after clamping - * @param max the highest value in this tuple after clamping - */ - void clamp(T min, T max) { - clampMin(min); - clampMax(max); - } - - /** - * Clamps the minimum value of this tuple to the min parameter. - * @param min the lowest value in this tuple after clamping - */ - void clampMin(T min) { - if (x < min) - x = min; - if (y < min) - y = min; - if (z < min) - z = min; - if (w < min) - w = min; - } - - /** - * Clamps the maximum value of this tuple to the max parameter. - * @param max the highest value in the tuple after clamping - */ - void clampMax(T max) { - if (x > max) - x = max; - if (y > max) - y = max; - if (z > max) - z = max; - if (w > max) - w = max; - } - - /** - * Sets each component of this tuple to its absolute value. - */ - void absolute() { - if (x < 0.0) - x = -x; - if (y < 0.0) - y = -y; - if (z < 0.0) - z = -z; - if (w < 0.0) - w = -w; - } - - /** - * Linearly interpolates between tuples t1 and t2 and places the - * result into this tuple: this = (1-alpha)*t1 + alpha*t2. - * @param t1 the first tuple - * @param t2 the second tuple - * @param alpha the alpha interpolation parameter - */ - void interpolate(const Tuple4& t1, const Tuple4& t2, T alpha) { - set(t1); - interpolate(t2, alpha); - } - - - /** - * Linearly interpolates between this tuple and tuple t1 and places the - * result into this tuple: this = (1-alpha)*this + alpha*t1. - * @param t1 the first tuple - * @param alpha the alpha interpolation parameter - * - */ - void interpolate(const Tuple4& t1, T alpha) { - T beta = 1 - alpha; - x = beta*x + alpha*t1.x; - y = beta*y + alpha*t1.y; - z = beta*z + alpha*t1.z; - w = beta*w + alpha*t1.w; - } - - /** - * Returns a string that contains the values of this Tuple4. The form is (x,y,z,w). - * @return the String representation - */ -#ifdef VM_INCLUDE_TOSTRING - VM_STRING_STD::string toString() const { - VM_TOSTRING - } -#endif - - // copy constructor and operator = is made by complier - - bool operator==(const Tuple4& t1) const { - return equals(t1); - } -#ifdef VM_INCLUDE_SUBSCRIPTION_OPERATOR - T operator[](size_t index) const { - assert(index < (size_t)DIMENSION); - switch (index) { - case 0: - return x; - case 1: - return y; - case 2: - return z; - case 3: - return w; - default: - // error ! - return 0; - } - } - T operator[](size_t index) const { - static T dummy; - assert(index < (size_t)DIMENSION); - switch (index) { - case 0: - return x; - case 1: - return y; - case 2: - return z; - case 3: - return w; - default: - // error ! - return dummy; - } - } -#endif - - Tuple4& operator=(const Tuple4& t1) { - set(t1); - return *this; - } - - Tuple4& operator+=(const Tuple4& t1) { - add(t1); - return *this; - } - Tuple4& operator-=(const Tuple4& t1) { - sub(t1); - return *this; - } - Tuple4& operator*=(T s) { - scale(s); - return *this; - } - Tuple4 operator+(const Tuple4& t1) const { - return (Tuple4(*this)).operator+=(t1); - } - Tuple4 operator-(const Tuple4& t1) const { - return (Tuple4(*this)).operator-=(t1); - } - Tuple4 operator*(T s) const { - return (Tuple4(*this)).operator*=(s); - } - -}; - -VM_END_NS - -template -inline -VM_VECMATH_NS::Tuple4 operator*(T s, const VM_VECMATH_NS::Tuple4& t1) { - return (VM_VECMATH_NS::Tuple4(t1)).operator*=(s); -} - -#ifdef VM_INCLUDE_IO -template -VM_IOSTREAM_STD::ostream& operator<<(VM_IOSTREAM_STD::ostream& o, const VM_VECMATH_NS::Tuple4& t1) { - return o << "(" << t1.x << "," << t1.y << "," << t1.z << "," << t1.w << ")"; -} - -// Anfang Änderung Marcus -template -VM_IOSTREAM_STD::istream& operator>>(VM_IOSTREAM_STD::istream& i, const VM_VECMATH_NS::Tuple4& t1) { - - char c; - - i >> c; - i >> t1.x; - i >> c; - i >> t1.y; - i >> c; - i >> t1.z; - i >> c; - i >> t1.w; - i >> c; - - return i; -} -// Ende Änderung Marcus - -#endif - -VM_BEGIN_NS - -typedef Tuple4 Tuple4d; -typedef Tuple4 Tuple4f; - -VM_END_NS - - -#endif /* TUPLE4_H */ diff --git a/Utilities/vecmath/Vector2.h b/Utilities/vecmath/Vector2.h deleted file mode 100644 index 4df2d92305..0000000000 --- a/Utilities/vecmath/Vector2.h +++ /dev/null @@ -1,185 +0,0 @@ -/* - Copyright (C) 1997,1998,1999 - Kenji Hiranabe, Eiwa System Management, Inc. - - This program is free software. - Implemented by Kenji Hiranabe(hiranabe@esm.co.jp), - conforming to the Java(TM) 3D API specification by Sun Microsystems. - - Permission to use, copy, modify, distribute and sell this software - and its documentation for any purpose is hereby granted without fee, - provided that the above copyright notice appear in all copies and - that both that copyright notice and this permission notice appear - in supporting documentation. Kenji Hiranabe and Eiwa System Management,Inc. - makes no representations about the suitability of this software for any - purpose. It is provided "AS IS" with NO WARRANTY. -*/ -#ifndef VECTOR2_H -#define VECTOR2_H - -#include "VmUtil.h" -#include "Tuple2.h" - -VM_BEGIN_NS - -/** - * A 2 element vector that is represented by x,y coordinates. - * @version specification 1.1, implementation $Revision$, $Date$ - * @author Kenji hiranabe - */ - -template -class Vector2 : public Tuple2 { -/* - * $Log$ - * Revision 1.4 2005/10/06 15:27:15 nolden - * FIX: gcc4 compatibility - * - * Revision 1.3 2003/11/04 14:19:17 nolden - * gcc2 compatibility fix - * - * Revision 1.2 2003/04/22 14:42:11 max - * made inclusions of vecmath header files "local" (for gcc 3.3 support) - * - * Revision 1.1 2002/11/16 12:25:36 mark - * vecmath bibliothek - * in cvs, da einige bugs behoben - * - * Revision 1.3 1999/10/06 02:52:46 hiranabe - * Java3D 1.2 and namespace - * - * Revision 1.2 1999/05/26 00:59:37 hiranabe - * support Visual C++ - * - * Revision 1.1 1999/03/04 11:07:09 hiranabe - * Initial revision - * - * Revision 1.1 1999/03/04 11:07:09 hiranabe - * Initial revision - * - */ -public: - /** - * Constructs and initializes a Vector2 from the specified xy coordinates. - * @param x the x coordinate - * @param y the y coordinate - */ - Vector2(T x, T y) : Tuple2(x, y) { } - - /** - * Constructs and initializes a Vector2 from the specified array. - * @param v the array of length 2 containing xy in order - */ - Vector2(const T v[]) : Tuple2(v) { } - - /** - * Constructs and initializes a Vector2 from the specified Tuple2. - * @param t1 the Tuple2 containing the initialization x y data - */ - Vector2(const Tuple2& t1) : Tuple2(t1) { } - - /** - * Constructs and initializes a Vector2 to (0,0). - */ - Vector2(): Tuple2() { } - - /** - * Computes the dot product of the this vector and vector v1. - * @param v1 the other vector - */ - T dot(const Vector2& v1) const { - return this->x*v1.x + this->y*v1.y; - } - - /** - * Returns the squared length of this vector. - * @return the squared length of this vector - */ - T lengthSquared() const { - return this->x*this->x + this->y*this->y; - } - - /** - * Returns the length of this vector. - * @return the length of this vector - */ - T length() const { - return VmUtil::sqrt(lengthSquared()); - } - - /** - * Normalizes this vector in place. - */ - void normalize() { - T d = length(); - - // zero-div may occur. - this->x /= d; - this->y /= d; - } - - /** - * Sets the value of this vector to the normalization of vector v1. - * @param v1 the un-normalized vector - */ - void normalize(const Vector2& v1) { - // "this->" is necessary for compatibility with std::set in gcc2 - this->set(v1); - normalize(); - } - - /** - * Returns the angle in radians between this vector and - * the vector parameter; the return value is constrained to the - * range [0,PI]. - * @param v1 the other vector - * @return the angle in radians in the range [0,PI] - */ - T angle(const Vector2& v1) const { - // stabler than acos - return VmUtil::abs(VmUtil::atan2(this->x*v1.y - this->y*v1.x , dot(v1))); - } - - // copy constructor and operator = is made by complier - - Vector2& operator=(const Tuple2& t) { - Tuple2::operator=(t); - return *this; - } - -}; - -/* - * 0. value_type typedef added - * 1. copy constructo, oeprator = are delegated to compiler - * 4. typdef value type - * 7. typedefs for , - * removed construction from Vector2f - */ - -VM_END_NS - -template -inline -VM_VECMATH_NS::Vector2 operator*(T s, const VM_VECMATH_NS::Vector2& t1) { - return operator*(s, (const VM_VECMATH_NS::Tuple2&)t1); -} - -#ifdef VM_INCLUDE_IO -template -inline -VM_IOSTREAM_STD::ostream& operator<<(VM_IOSTREAM_STD::ostream& o, const VM_VECMATH_NS::Vector2& t1) { - return operator<<(o, (const VM_VECMATH_NS::Tuple2&)t1); -} -#endif - -VM_BEGIN_NS - -typedef Vector2 Vector2d; -typedef Vector2 Vector2f; - -VM_END_NS - - - -#endif /* VECTOR2_H */ diff --git a/Utilities/vecmath/Vector3.h b/Utilities/vecmath/Vector3.h deleted file mode 100644 index ba8c782a4a..0000000000 --- a/Utilities/vecmath/Vector3.h +++ /dev/null @@ -1,239 +0,0 @@ -/* - Copyright (C) 1997,1998,1999 - Kenji Hiranabe, Eiwa System Management, Inc. - - This program is free software. - Implemented by Kenji Hiranabe(hiranabe@esm.co.jp), - conforming to the Java(TM) 3D API specification by Sun Microsystems. - - Permission to use, copy, modify, distribute and sell this software - and its documentation for any purpose is hereby granted without fee, - provided that the above copyright notice appear in all copies and - that both that copyright notice and this permission notice appear - in supporting documentation. Kenji Hiranabe and Eiwa System Management,Inc. - makes no representations about the suitability of this software for any - purpose. It is provided "AS IS" with NO WARRANTY. -*/ -#ifndef VECTOR3_H -#define VECTOR3_H - -#include "Tuple3.h" - -VM_BEGIN_NS - -/** - * A 3 element vector that is represented by - * x,y,z coordinates. If this value represents a normal, then it should be - * normalized. - * @version specification 1.1, implementation $Revision$, $Date$ - * @author Kenji hiranabe - */ -template -class Vector3 : public Tuple3 { -/* - * $Log$ - * Revision 1.5 2005/08/01 15:51:30 nolden - * COMP: gcc 3.4 issues - * - * Revision 1.4 2003/11/04 14:19:17 nolden - * gcc2 compatibility fix - * - * Revision 1.3 2003/04/22 14:42:11 max - * made inclusions of vecmath header files "local" (for gcc 3.3 support) - * - * Revision 1.2 2002/12/09 13:02:33 tobias - * added functions cart2sphere() and sphere2cart() for transformation from - * cartesian to spherical coordinates and vice versa - * - * Revision 1.1 2002/11/16 12:25:36 mark - * vecmath bibliothek - * in cvs, da einige bugs behoben - * - * Revision 1.3 1999/10/06 02:52:46 hiranabe - * Java3D 1.2 and namespace - * - * Revision 1.2 1999/05/26 00:59:37 hiranabe - * support Visual C++ - * - * Revision 1.1 1999/03/04 11:07:09 hiranabe - * Initial revision - * - * Revision 1.1 1999/03/04 11:07:09 hiranabe - * Initial revision - * - */ -public: - /** - * Constructs and initializes a Vector3 from the specified xyz coordinates. - * @param x the x coordinate - * @param y the y coordinate - * @param z the z coordinate - */ - Vector3(T x, T y, T z): Tuple3(x, y, z) { } - - /** - * Constructs and initializes a Vector3 from the specified array of length 3. - * @param v the array of length 3 containing xyz in order - */ - Vector3(const T v[]): Tuple3(v) { } - - /** - * Constructs and initializes a Vector3 from the specified Tuple3d. - * @param t1 the Tuple3d containing the initialization x y z data - */ - Vector3(const Tuple3& t1): Tuple3(t1) { } - - /** - * Constructs and initializes a Vector3 to (0,0,0). - */ - Vector3(): Tuple3() { } - - /** - * Sets this vector to be the vector cross product of vectors v1 and v2. - * @param v1 the first vector - * @param v2 the second vector - */ - void cross(const Vector3& v1, const Vector3& v2) { - // store on stack once for aliasing-safty - // i.e. safe when a.cross(a, b) - - // this-> is necessary for compatibility with std::set in gcc2 - this->set( - v1.y*v2.z - v1.z*v2.y, - v1.z*v2.x - v1.x*v2.z, - v1.x*v2.y - v1.y*v2.x - ); - } - - - /** - * Sets the value of this vector to the normalization of vector v1. - * @param v1 the un-normalized vector - */ - void normalize(const Vector3& v1) { - // this-> is necessary for compatibility with std::set in gcc2 - this->set(v1); - normalize(); - } - - /** - * Normalizes this vector in place. - */ - void normalize() { - T d = length(); - - // zero-div may occur. - this->x /= d; - this->y /= d; - this->z /= d; - } - - /** - * Computes the dot product of the this vector and vector v1. - * @param v1 the other vector - */ - T dot(const Vector3& v1) const { - return this->x*v1.x +this->y*v1.y +this->z*v1.z; - } - - - /** - * Returns the squared length of this vector. - * @return the squared length of this vector - */ - T lengthSquared() const { - return this->x*this->x + this->y*this->y + this->z*this->z; - } - - /** - * Returns the length of this vector. - * @return the length of this vector - */ - T length() const { - return VmUtil::sqrt(lengthSquared()); - } - - /** - * Returns the angle in radians between this vector and - * the vector parameter; the return value is constrained to the - * range [0,PI]. - * @param v1 the other vector - * @return the angle in radians in the range [0,PI] - */ - T angle(const Vector3& v1) const { - // return (double)Math.acos(dot(v1)/v1.length()/v.length()); - // Numerically, near 0 and PI are very bad condition for acos. - // In 3-space, |atan2(sin,cos)| is much stable. - Vector3 c; - c.cross(*this, v1); - T sin = c.length(); - - return VmUtil::abs(VmUtil::atan2(sin, dot(v1))); - } - - /** - * Transforms cartesian into spherical coordinates - * Spherical coordinates are encoded as follows: - * x: azimuth angle in xy-plane from x-axis, [-PI,PI] - * y: polar angle from z-axis, [0,PI] - * z: distance from origin (radius) - * @return the vector in spherical coordinates - */ - Vector3 cart2sphere() const { - - T radius = length(); - if (radius == 0) return Vector3( 0, 0, 0 ); - - T polar = VmUtil::acos( this->z / radius ); - T azimuth = VmUtil::atan2( this->y, this->x ); - return Vector3( azimuth, polar, radius ); - } - - /** - * Transforms spherical into cartesian coordinates - * Spherical coordinates are encoded as follows: - * x: azimuth angle in xy-plane from x-axis, [-PI,PI] - * y: polar angle from z-axis, [0,PI] - * z: distance from origin (radius) - * @return the vector in cartesian coordinates - */ - Vector3 sphere2cart() const { - - T cartX = this->z * VmUtil::cos( this->x ) * VmUtil::sin( this->y ); - T cartY = this->z * VmUtil::sin( this->x ) * VmUtil::sin( this->y ); - T cartZ = this->z * VmUtil::cos( this->y ); - return Vector3( cartX, cartY, cartZ ); - } - - // copy constructor and operator = is made by complier - - Vector3& operator=(const Tuple3& t) { - Tuple3::operator=(t); - return *this; - } -}; - -VM_END_NS - -template -inline -VM_VECMATH_NS::Vector3 operator*(T s, const VM_VECMATH_NS::Vector3& t1) { - return operator*(s, (const VM_VECMATH_NS::Tuple3&)t1); -} - -#ifdef VM_INCLUDE_IO -template -inline -VM_IOSTREAM_STD::ostream& operator<<(VM_IOSTREAM_STD::ostream& o, const VM_VECMATH_NS::Vector3& t1) { - return operator<<(o, (const VM_VECMATH_NS::Tuple3&)t1); -} -#endif - -VM_BEGIN_NS - -typedef Vector3 Vector3d; -typedef Vector3 Vector3f; - -VM_END_NS - -#endif /* VECTOR3_H */ diff --git a/Utilities/vecmath/Vector4.h b/Utilities/vecmath/Vector4.h deleted file mode 100644 index 406fe06240..0000000000 --- a/Utilities/vecmath/Vector4.h +++ /dev/null @@ -1,214 +0,0 @@ -/* - Copyright (C) 1997,1998,1999 - Kenji Hiranabe, Eiwa System Management, Inc. - - This program is free software. - Implemented by Kenji Hiranabe(hiranabe@esm.co.jp), - conforming to the Java(TM) 3D API specification by Sun Microsystems. - - Permission to use, copy, modify, distribute and sell this software - and its documentation for any purpose is hereby granted without fee, - provided that the above copyright notice appear in all copies and - that both that copyright notice and this permission notice appear - in supporting documentation. Kenji Hiranabe and Eiwa System Management,Inc. - makes no representations about the suitability of this software for any - purpose. It is provided "AS IS" with NO WARRANTY. -*/ -#ifndef VECTOR4_H -#define VECTOR4_H - -#include "VmUtil.h" -#include "Tuple4.h" -#include "Tuple3.h" - -VM_BEGIN_NS - -/** - * A 4 element vector that is represented by x,y,z,w coordinates. - * @version specification 1.1, implementation $Revision$, $Date$ - * @author Kenji hiranabe - */ -template -class Vector4 : public Tuple4 { -/* - * $Log$ - * Revision 1.3 2005/10/06 15:27:15 nolden - * FIX: gcc4 compatibility - * - * Revision 1.2 2003/04/22 14:42:11 max - * made inclusions of vecmath header files "local" (for gcc 3.3 support) - * - * Revision 1.1 2002/11/16 12:25:36 mark - * vecmath bibliothek - * in cvs, da einige bugs behoben - * - * Revision 1.3 1999/10/06 02:52:46 hiranabe - * Java3D 1.2 and namespace - * - * Revision 1.2 1999/05/26 00:59:37 hiranabe - * support Visual C++ - * - * Revision 1.1 1999/03/04 11:07:09 hiranabe - * Initial revision - * - * Revision 1.1 1999/03/04 11:07:09 hiranabe - * Initial revision - * - */ -public: - - /** - * Constructs and initializes a Vector4 from the specified xyzw coordinates. - * @param x the x coordinate - * @param y the y coordinate - * @param z the z coordinate - * @param w the w coordinate - */ - Vector4(T x, T y, T z, T w): Tuple4(x, y, z, w) { } - - /** - * Constructs and initializes a Vector4 from the specified array of length 4. - * @param v the array of length 4 containing xyzw in order - */ - Vector4(const T v[]): Tuple4(v) { } - - /** - * Constructs and initializes a Vector4 from the specified Tuple4d. - * @param t1 the Tuple4d containing the initialization x y z w data - */ - Vector4(const Tuple4& t1): Tuple4(t1) { } - - /** - * Constructs and initializes a Vector4 to (0,0,0,0). - */ - Vector4(): Tuple4() { } - - /** - * Constructs and initializes a Vector4 from the specified Tuple3. - * The x,y,z components of this point are set to the corresponding - * components - * of tuple t1. The w component of this point is set to 0. - * - * @param t1 the tuple to be copied - * @since Java3D 1.2 - */ - Vector4(const Tuple3& t1): Tuple4(t1.x, t1.y, t1.z, 0) { } - - /** - * Sets the x,y,z components of this point to the corresponding - * components of tuple t1. The w component of this point is set to 1. - * - * NOTE: - * This method's name should be 'set'. Newer compilers support - * 'using Tuple4::set;' and use the name 'set'. - * but for now, renamed to 'set3'. - * - * @param t1 the tuple to be copied - * @since Java3D 1.2 - */ - void set3(const Tuple3& t1) { - this->x = t1.x; - this->y = t1.y; - this->z = t1.z; - this->w = 0; - } - - - - /** - * Returns the squared length of this vector. - * @return the squared length of this vector - */ - T lengthSquared() const { - return this->x*this->x + this->y*this->y + this->z*this->z + this->w*this->w; - } - - /** - * Returns the length of this vector. - * @return the length of this vector - */ - T length() const { - return VmUtil::sqrt(lengthSquared()); - } - - /** - * Computes the dot product of the this vector and vector v1. - * @param v1 the other vector - * @return the dot product of this vector and vector v1 - */ - T dot(const Vector4& v1) const { - return this->x*v1.x + this->y*v1.y + this->z*v1.z + this->w*v1.w; - } - - /** - * Sets the value of this vector to the normalization of vector v1. - * @param v1 the un-normalized vector - */ - void normalize(const Vector4& v1) { - Tuple4::set(v1); - normalize(); - } - - /** - * Normalizes this vector in place. - */ - void normalize() { - T d = length(); - - // zero-div may occur. - this->x /= d; - this->y /= d; - this->z /= d; - this->w /= d; - } - - /** - * Returns the (4-space) angle in radians between this vector and - * the vector parameter; the return value is constrained to the - * range [0,PI]. - * @param v1 the other vector - * @return the angle in radians in the range [0,PI] - */ - T angle(const Vector4& v1) const { - // zero div may occur. - T d = dot(v1); - T v1_length = v1.length(); - T v_length = length(); - - // numerically, domain error may occur - return T(acos(d/v1_length/v_length)); - } - - // copy constructor and operator = is made by complier - - Vector4& operator=(const Tuple4& t) { - Tuple4::operator=(t); - return *this; - } -}; - -VM_END_NS - -template -inline -VM_VECMATH_NS::Vector4 operator*(T s, const VM_VECMATH_NS::Vector4& t1) { - return operator*(s, (const VM_VECMATH_NS::Tuple4&)t1); -} - -#ifdef VM_INCLUDE_IO -template -inline -VM_IOSTREAM_STD::ostream& operator<<(VM_IOSTREAM_STD::ostream& o, const VM_VECMATH_NS::Vector4& t1) { - return operator<<(o, (const VM_VECMATH_NS::Tuple4&)t1); -} -#endif - -VM_BEGIN_NS - -typedef Vector4 Vector4d; -typedef Vector4 Vector4f; - -VM_END_NS - - -#endif /* VECTOR4_H */ diff --git a/Utilities/vecmath/VmUtil.h b/Utilities/vecmath/VmUtil.h deleted file mode 100644 index 8ccdbc9eeb..0000000000 --- a/Utilities/vecmath/VmUtil.h +++ /dev/null @@ -1,121 +0,0 @@ -/* - Copyright (C) 1997,1998,1999 - Kenji Hiranabe, Eiwa System Management, Inc. - - This program is free software. - Implemented by Kenji Hiranabe(hiranabe@esm.co.jp), - conforming to the Java(TM) 3D API specification by Sun Microsystems. - - Permission to use, copy, modify, distribute and sell this software - and its documentation for any purpose is hereby granted without fee, - provided that the above copyright notice appear in all copies and - that both that copyright notice and this permission notice appear - in supporting documentation. Kenji Hiranabe and Eiwa System Management,Inc. - makes no representations about the suitability of this software for any - purpose. It is provided "AS IS" with NO WARRANTY. -*/ -#ifndef VMUTIL_H -#define VMUTIL_H - -#include "vm_conf.h" - -#ifdef VM_STD_C_HEADERS -# include -# include -# include -# include -#else -# include -# include -# include -# include -#endif - -#ifdef VM_INCLUDE_IO -# ifdef VM_USE_OLDIOSTREAM -# include -# else -# include -# endif -# ifdef VM_INCLUDE_TOSTRING -# include -# ifdef VM_USE_STRINGSTREAM -# include -# define VM_TOSTRING VM_STRING_STD::stringstream s; s << *this; return s.str(); -# else -# ifdef _MSC_VER -# ifdef VM_USE_OLDIOSTREAM -# include -# define VM_TOSTRING strstream s; s << *this << ends; VM_STRING_STD::string str = s.str(); s.rdbuf()->freeze(0); return str; -# else -# include -# define VM_TOSTRING VM_IOSTREAM_STD::strstream s; s << *this << VM_IOSTREAM_STD::ends; VM_STRING_STD::string str = s.str(); s.freeze(0); return str; -# endif -# else -# include -# define VM_TOSTRING strstream s; s << *this << ends; VM_STRING_STD::string str = s.str(); s.freeze(0); return str; -# endif -# endif -# endif -#endif - -/** - * to be defined for exceptions - */ -#define VM_OUT_OF_RANGE - -#ifdef abs -#undef abs -#endif - -#ifdef max -#undef max -#endif - -#ifdef min -#undef min -#endif - -VM_BEGIN_NS - -/** - * VmUtil class. - * static utility functions are defined here for portability reasons. - */ -template -struct VmUtil { - // prefer to cmath for portability - static T abs(T t) { return t > 0 ? t : -t; } - static T max(T a, T b) { return a < b ? b : a; } - static T max(T a, T b, T c) { return max(max(a, b), c); } - static T max(T a, T b, T c, T d) { return max(max(a, b), max(c, d)); } - static T min(T a, T b) { return a < b ? a : b; } - static T min(T a, T b, T c) { return min(min(a, b), c); } - static T min(T a, T b, T c, T d) { return min(min(a, b), min(c, d)); } - static T sin(T x) { return T(VM_MATH_STD::sin(x)); } - static T cos(T x) { return T(VM_MATH_STD::cos(x)); } - static T atan2(T y, T x) { return T(VM_MATH_STD::atan2(y, x)); } - static T acos(T x) { return T(VM_MATH_STD::acos(x)); } - static T sqrt(T x) { return T(VM_MATH_STD::sqrt(x)); } - static T pow(T x, T y) { return T(VM_MATH_STD::pow(x, y)); } - static size_t hashCode(size_t size, const void* ptr) { - // idea is from Bjarne Stroustrup 3rd $17.6.2.3 - size_t res = 0; - const char* p = (const char*)ptr; // reinterpret_cast - while (size--) - res = (res << 1) ^ *p++; - return res; - } -}; - -/** - * Helper class useful when you add class T to hash_map - */ -template -struct VmHash { - size_t operator()(const T& t) const { return t.hashCode(); } -}; - -VM_END_NS - -#endif /* VMUTIL_H */ diff --git a/Utilities/vecmath/hello-vecmath.cpp b/Utilities/vecmath/hello-vecmath.cpp deleted file mode 100644 index be305e85e1..0000000000 --- a/Utilities/vecmath/hello-vecmath.cpp +++ /dev/null @@ -1,28 +0,0 @@ -/* - Copyright (C) 1997,1998,1999 - Kenji Hiranabe, Eiwa System Management, Inc. - - This program is free software. - Implemented by Kenji Hiranabe(hiranabe@esm.co.jp), - conforming to the Java(TM) 3D API specification by Sun Microsystems. - - Permission to use, copy, modify, distribute and sell this software - and its documentation for any purpose is hereby granted without fee, - provided that the above copyright notice appear in all copies and - that both that copyright notice and this permission notice appear - in supporting documentation. Kenji Hiranabe and Eiwa System Management,Inc. - makes no representations about the suitability of this software for any - purpose. It is provided "AS IS" with NO WARRANTY. -*/ - -#include -#include - -using namespace kh_vecmath; - -int main(int, char**) { - Matrix3d m(1,2,3,4,5,6,7,8,9); - Vector3d v(2,3,4); - cout << m*v << endl; - return 0; -} diff --git a/Utilities/vecmath/test-1.cpp b/Utilities/vecmath/test-1.cpp deleted file mode 100644 index a03ce36032..0000000000 --- a/Utilities/vecmath/test-1.cpp +++ /dev/null @@ -1,75 +0,0 @@ -/* - Copyright (C) 1997,1998,1999 - Kenji Hiranabe, Eiwa System Management, Inc. - - This program is free software. - Implemented by Kenji Hiranabe(hiranabe@esm.co.jp), - conforming to the Java(TM) 3D API specification by Sun Microsystems. - - Permission to use, copy, modify, distribute and sell this software - and its documentation for any purpose is hereby granted without fee, - provided that the above copyright notice appear in all copies and - that both that copyright notice and this permission notice appear - in supporting documentation. Kenji Hiranabe and Eiwa System Management,Inc. - makes no representations about the suitability of this software for any - purpose. It is provided "AS IS" with NO WARRANTY. -*/ -#include "vecmath.h" - - -/* - * test of instanciation - */ -//template class Tuple2; -//template class Tuple2; -//template class Vector2; -//template class Vector2; -//template class Point2; - -#ifdef VM_INCLUDE_NAMESPACE -using namespace kh_vecmath; -#endif - - -/** - * test for Vector2, Tuple2, Point2 - */ -#ifdef TESTALL -int test_1() { -#else -int main(int, char**) { -#endif - // creation, == - Tuple2 d(1,2); - d += Tuple2(2,3); - assert(d == Tuple2(3,5)); - - // size_type, hashCode - Tuple2 f(1,2); - Tuple2f::size_type hashf = f.hashCode(); - Point2f p1(1,2); - Point2f p2(1,2.0001f); - Point2f::size_type hashp1 = p1.hashCode(); - Point2f::size_type hashp2 = p2.hashCode(); - assert(hashf == hashp1); - assert(hashp1 != hashp2); // fails very very rarely. - - // set - f.set(1, 2); - f *= 3; - float farray[] = { 3, 6}; - assert(f == Tuple2(farray)); -#ifdef VM_INCLUDE_TOSTRING - assert(f.toString() == "(3,6)"); -#endif - - // get - Tuple2f::value_type farray2[2]; - f.get(farray2); - assert(farray2[0] == 3 && farray2[1] == 6); - Tuple2f ff2; - f.get(&ff2); - assert(ff2 == Tuple2f(3,6)); - - return 0; -} diff --git a/Utilities/vecmath/test-10.cpp b/Utilities/vecmath/test-10.cpp deleted file mode 100644 index 1dd6af00b1..0000000000 --- a/Utilities/vecmath/test-10.cpp +++ /dev/null @@ -1,42 +0,0 @@ -/* - Copyright (C) 1997,1998,1999 - Kenji Hiranabe, Eiwa System Management, Inc. - - This program is free software. - Implemented by Kenji Hiranabe(hiranabe@esm.co.jp), - conforming to the Java(TM) 3D API specification by Sun Microsystems. - - Permission to use, copy, modify, distribute and sell this software - and its documentation for any purpose is hereby granted without fee, - provided that the above copyright notice appear in all copies and - that both that copyright notice and this permission notice appear - in supporting documentation. Kenji Hiranabe and Eiwa System Management,Inc. - makes no representations about the suitability of this software for any - purpose. It is provided "AS IS" with NO WARRANTY. -*/ -#include - -#include "TexCoord2.h" -#include "Color3.h" -#include "Color4.h" - -#ifdef VM_INCLUDE_NAMESPACE -using namespace kh_vecmath; -#endif - -/** - * test for Simple tuples. - */ -#ifdef TESTALL -int test_10() { -#else -int main(int, char**) { -#endif - Color4 c; - TexCoord2f tc; - Color3b cb(255, 123, 254); - cb.x = 0; - tc.x = 10; - c.y = 1.0f; - return 0; -} diff --git a/Utilities/vecmath/test-11.cpp b/Utilities/vecmath/test-11.cpp deleted file mode 100644 index caf9fb361a..0000000000 --- a/Utilities/vecmath/test-11.cpp +++ /dev/null @@ -1,755 +0,0 @@ -/* - Copyright (C) 1997,1998,1999 - Kenji Hiranabe, Eiwa System Management, Inc. - - This program is free software. - Implemented by Kenji Hiranabe(hiranabe@esm.co.jp), - conforming to the Java(TM) 3D API specification by Sun Microsystems. - - Permission to use, copy, modify, distribute and sell this software - and its documentation for any purpose is hereby granted without fee, - provided that the above copyright notice appear in all copies and - that both that copyright notice and this permission notice appear - in supporting documentation. Kenji Hiranabe and Eiwa System Management,Inc. - makes no representations about the suitability of this software for any - purpose. It is provided "AS IS" with NO WARRANTY. -*/ -#ifndef M_PI -#define M_PI 3.14159265358979323846 -#endif - - - -#include "vecmath.h" -#define assert_(c,m) assert(((void)m, c)); -static double epsilon = 1.0e-5; - -#ifdef VM_INCLUDE_NAMESPACE -using namespace kh_vecmath; -#endif - - -template -T abs(T a) { return a < 0 ? -a : a; } - -bool equals_v(double m1, double m2) { return abs(m1 - m2) < epsilon;} -bool equals_v(float m1, float m2) { return abs(m1 - m2) < (float)epsilon;} -bool equals(const Matrix3d& m1, const Matrix3d& m2) { return m1.epsilonEquals(m2, epsilon);} -bool equals(const Matrix3f& m1, const Matrix3f& m2) { return m1.epsilonEquals(m2, epsilon);} -bool equals(const Matrix4d& m1, const Matrix4d& m2) { return m1.epsilonEquals(m2, epsilon);} -bool equals(const Matrix4f& m1, const Matrix4f& m2) { return m1.epsilonEquals(m2, epsilon);} -bool equals(const Tuple4d& m1, const Tuple4d& m2) { return m1.epsilonEquals(m2, epsilon);} -bool equals(const Tuple3d& m1, const Tuple3d& m2) { return m1.epsilonEquals(m2, epsilon);} -bool equals(const Point4d& m1, const Point4d& m2) { return m1.epsilonEquals(m2, epsilon);} -bool equals(const Point3d& m1, const Point3d& m2) { return m1.epsilonEquals(m2, epsilon);} -bool equals(const Vector4d& m1, const Vector4d& m2) { return m1.epsilonEquals(m2, epsilon);} -bool equals(const Vector3d& m1, const Vector3d& m2) { return m1.epsilonEquals(m2, epsilon);} -bool equals(const Tuple4f& m1, const Tuple4f& m2) { return m1.epsilonEquals(m2, epsilon);} -bool equals(const Tuple3f& m1, const Tuple3f& m2) { return m1.epsilonEquals(m2, epsilon);} -bool equals(const Point4f& m1, const Point4f& m2) { return m1.epsilonEquals(m2, epsilon);} -bool equals(const Point3f& m1, const Point3f& m2) { return m1.epsilonEquals(m2, epsilon);} -bool equals(const Vector4f& m1, const Vector4f& m2) { return m1.epsilonEquals(m2, epsilon);} -bool equals(const Vector3f& m1, const Vector3f& m2) { return m1.epsilonEquals(m2, epsilon);} -bool equals(const AxisAngle4d& a1, const AxisAngle4d& a2) { - if (0 < a1.x*a2.x + a1.y*a2.y + a1.z*a2.z) { // same direction - return equals_v(a1.y*a2.z - a1.z*a2.y, 0) && - equals_v(a1.z*a2.x - a1.x*a2.z, 0) && - equals_v(a1.x*a2.y - a1.y*a2.x, 0) && - equals_v(a1.angle, a2.angle); - } else { - return equals_v(a1.y*a2.z - a1.z*a2.y, 0) && - equals_v(a1.z*a2.x - a1.x*a2.z, 0) && - equals_v(a1.x*a2.y - a1.y*a2.x, 0) && - ( - equals_v(a1.angle, -a2.angle) || - equals_v(a1.angle + a2.angle, 2*M_PI) || - equals_v(a1.angle + a2.angle, -2*M_PI) - ); - } -} -bool equals(const AxisAngle4f& a1, const AxisAngle4f& a2) { - if (0 < a1.x*a2.x + a1.y*a2.y + a1.z*a2.z) { // same direction - return equals_v(a1.y*a2.z - a1.z*a2.y, 0) && - equals_v(a1.z*a2.x - a1.x*a2.z, 0) && - equals_v(a1.x*a2.y - a1.y*a2.x, 0) && - equals_v(a1.angle, a2.angle); - } else { - return equals_v(a1.y*a2.z - a1.z*a2.y, 0) && - equals_v(a1.z*a2.x - a1.x*a2.z, 0) && - equals_v(a1.x*a2.y - a1.y*a2.x, 0) && - ( - equals_v(a1.angle, -a2.angle) || - equals_v(a1.angle + a2.angle, (float)(2*M_PI)) || - equals_v(a1.angle + a2.angle, (float)(-2*M_PI)) - ); - } -} - -template -void Vector3Test(T) { - Vector3 zeroVector; - Vector3 v1(2,3,4); - Vector3 v2(2,5,-8); - Vector3 v3; - v3.cross(v1, v2); - - // check cross and dot. - assert(equals_v(v3.dot(v1), 0)); - assert(equals_v(v3.dot(v2), 0)); - - // check alias-safe - v1.cross(v1, v2); - assert(equals(v1, Vector3(-44,24,4))); - - // check length - assert(equals_v(v2.lengthSquared(), (T)93)); - assert(equals_v(v2.length(), (T)sqrt(93))); - - // check normalize - v1.set(v2); - v2.normalize(); - assert(equals_v(v2.length(), 1)); - v1.cross(v2,v1); - assert(equals(v1, zeroVector)); - - // check Angle - v1.set(1,2,3); - v2.set(-1,-6,-3); - T ang = v1.angle(v2); - assert(equals_v(T(v1.length()*v2.length()*cos(ang)), v1.dot(v2))); - - // check Angle (0) - v1.set(v2); - ang = v1.angle(v2); - assert(equals_v(ang, 0)); - assert(equals_v(T(v1.length()*v2.length()*cos(ang)), v1.dot(v2))); - - // check small Angle - v1.set(1,2,3); - v2.set(1,2,T(3.00001)); - ang = v1.angle(v2); - assert(equals_v(T(v1.length()*v2.length()*cos(ang)), v1.dot(v2))); - - // check large Angle - v1.set(1,2,3); - v2.set(-1,-2,T(-3.00001)); - ang = v1.angle(v2); - assert(equals_v(T(v1.length()*v2.length()*cos(ang)), v1.dot(v2))); -} - -template -void Matrix3Test(T) { - Matrix3 O = Matrix3(); - Matrix3 I = Matrix3(); I.setIdentity(); - Matrix3 m1 =Matrix3(); - Matrix3 m2 = Matrix3(); - const T v[] = { 2,1,4, 1,-2,3, -3,-1,1 }; - - // check get/set - for (int i = 0; i < 3; i++) { - for (int j = 0; j < 3; j++) - m1.setElement(i, j, i*2*j + 3); - } - for (int i2 = 0; i2 < 3; i2++) { - for (int j = 0; j < 3; j++) - assert(equals_v(m1.getElement(i2, j), i2*2*j + 3)); - } - - // check mul with O, I - m1.set(v); - m2 = m1; - m2.mul(O); - assert(equals(m2, O)); - m2.mul(m1, I); - assert(equals(m2, m1)); - - // check determinant - assert(equals_v(m1.determinant(), -36)); - - // check negate, add - m2.negate(m1); - m2.add(m1); - assert(equals(m2, O)); - - // check mul, sub - m2.negate(m1); - Matrix3 m3 = m1; - m3.sub(m2); - m3.mul(0.5); - assert(equals(m1, m3)); - - // check invert - m3.invert(m2); - m3.mul(m2); - assert(equals(m3, I)); - - // translate - Point3 p1 = Point3(1,2,3); - - // rotZ - // rotate (1,0,0) 30degree abount z axis -> (cos 30,sin 30,0) - p1.set(1,0,0); - m1.rotZ(T(M_PI/6)); - m1.transform(&p1); - assert(equals(p1, Point3(cos(M_PI/6), sin(M_PI/6), 0))); - - // rotY - // rotate() (1,0,0) 60degree about y axis -> (cos 60,0,-sin 60) - p1.set(1,0,0); - m1.rotY(T(M_PI/3)); - m1.transform(&p1); - assert(equals(p1, Point3(cos(M_PI/3), 0, -sin(M_PI/3)))); - - // rot around arbitary axis - // rotate() (1,0,0) 60degree about y axis -> (cos 60,0,-sin 60) - AxisAngle4 a1 = AxisAngle4(0,1,0,T(M_PI/3)); - p1.set(1,0,0); - m1.set(a1); - m1.transform(p1, &p1); - assert(equals(p1, Point3(cos(M_PI/3), 0, -sin(M_PI/3)))); - - // use quat. - Quat4 q1 = Quat4(); - p1.set(1,0,0); - q1.set(a1); - m2.set(q1); - assert(equals(m1, m2)); - m2.transform(p1, &p1); - assert(equals(p1, Point3(cos(M_PI/3), 0, -sin(M_PI/3)))); - - // Mat <-> Quat <-> Axis - a1.set(1,2,-3,T(M_PI/3)); - Mat3QuatAxisAngle(a1); - - // Mat <-> Quat <-> Axis (near PI case) - a1.set(1,2,3,T(M_PI)); - Mat3QuatAxisAngle(a1); - // Mat <-> Quat <-> Axis (near PI, X major case ) - a1.set(1,T(.1),T(.1),T(M_PI)); - Mat3QuatAxisAngle(a1); - // Mat <-> Quat <-> Axis (near PI, Y major case ) - a1.set(T(.1),1,T(.1),T(M_PI)); - Mat3QuatAxisAngle(a1); - // Mat <-> Quat <-> Axis (near PI, Z major case ) - a1.set(T(.1),T(.1),1,T(M_PI)); - Mat3QuatAxisAngle(a1); - - // isometric view 3 times 2/3 turn - a1.set(1,1,1,T(2*M_PI/3)); - m1.set(a1); - //printf("m1="+m1); - p1.set(1,0,0); - //printf("p1="+p1); - m1.transform(&p1); - //printf("after transform p1="+p1); - assert(equals(p1, Point3(0,1,0))); - m1.transform(&p1); - assert(equals(p1, Point3(0,0,1))); - m1.transform(&p1); - assert(equals(p1, Point3(1,0,0))); - - // check normalize, normalizeCP - m1.set(a1); - assert(equals_v(m1.determinant(), 1)); - assert(equals_v(m1.getScale(), 1)); - m2.set(a1); - m2.normalize(); - assert(equals(m1, m2)); - m2.set(a1); - m2.normalizeCP(); - assert(equals(m1, m2)); - T scale = 3.0; - m2.rotZ(T(-M_PI/4)); - m2.mul(scale); - assert(equals_v(m2.determinant(), scale*scale*scale)); - assert(equals_v(m2.getScale(), scale)); - m2.normalize(); - assert(equals_v(m2.determinant(), 1)); - assert(equals_v(m2.getScale(), 1)); - m2.rotX(T(M_PI/3)); - m2.mul(scale); - assert(equals_v(m2.determinant(), scale*scale*scale)); - assert(equals_v(m2.getScale(), scale)); - m2.normalizeCP(); - assert(equals_v(m2.determinant(), 1)); - assert(equals_v(m2.getScale(), 1)); - - // transpose and inverse - m1.set(a1); - m2.invert(m1); - m1.transpose(); - assert(equals(m1, m2)); -} - -template -void Mat4QuatAxisAngle(AxisAngle4& a1) { - Matrix4 m1 = Matrix4(); - Matrix4 m2 = Matrix4(); - AxisAngle4 a2 = AxisAngle4(); - Quat4 q1 = Quat4(); - Quat4 q2 = Quat4(); - - // Axis <-> Quat - q1.set(a1); - a2.set(q1); - // a1.v parallels to a2.v - assert(equals(a1, a2)); - q2 = Quat4(); - q2.set(a2); - assert(equals(q1, q2)); - - // Quat <-> Mat - q1.set(a1); - m1.set(q1); - q2.set(m1); - assert(equals(q1, q2)); - m2.set(q2); - assert(equals(m1, m2)); - - // Mat <-> AxisAngle - m1.set(a1); - a2.set(m1); - //System.out.println("a1="+a1); - //System.out.println("a2="+a2); - //System.out.println("m1="+m1); - assert(equals(a1, a2)); - m2.set(a1); - assert(equals(m1, m2)); - a1.x *= 2; a1.y *= 2; a1.z *= 2; - m2.set(a1); - a1.x = -a1.x; a1.y = -a1.y; a1.z = -a1.z; a1.angle = -a1.angle; - m2.set(a1); - assert(equals(m1, m2)); -} - - -template -void Mat3QuatAxisAngle(AxisAngle4& a1) { - Matrix3 m1 = Matrix3(); - Matrix3 m2 = Matrix3(); - AxisAngle4 a2 = AxisAngle4(); - Quat4 q1 = Quat4(); - Quat4 q2 = Quat4(); - - // Axis <-> Quat - q1.set(a1); - a2.set(q1); - // a1.v parallels to a2.v - assert(equals(a1, a2)); - q2 = Quat4(); - q2.set(a2); - assert(equals(q1, q2)); - - // Quat <-> Mat - q1.set(a1); - m1.set(q1); - q2.set(m1); - assert(equals(q1, q2)); - m2.set(q2); - assert(equals(m1, m2)); - - // Mat <-> AxisAngle - m1.set(a1); - a2.set(m1); - //printf("a1="+a1); - //printf("a2="+a2); - //printf("m1="+m1); - assert(equals(a1, a2)); - m2.set(a1); - assert(equals(m1, m2)); - a1.x *= 2; a1.y *= 2; a1.z *= 2; - m2.set(a1); - a1.x = -a1.x; a1.y = -a1.y; a1.z = -a1.z; a1.angle = -a1.angle; - m2.set(a1); - assert(equals(m1, m2)); - -} - -template -void Matrix4Test(T) { - Matrix4 O = Matrix4(); - Matrix4 I = Matrix4(); I.setIdentity(); - Matrix4 m1 = Matrix4(); - Matrix4 m2 = Matrix4(); - - // check get/set - for (int i = 0; i < 4; i++) { - for (int j = 0; j < 4; j++) - m1.setElement(i, j, i*2*j + 3); - } - for (int i2 = 0; i2 < 4; i2++) { - for (int j = 0; j < 4; j++) - assert(equals_v(m1.getElement(i2, j), i2*2*j + 3)); - } - - // check mul with O, I - m1 = Matrix4( - 2,1,4,1, - -2,3,-3,1, - -1,1,2,2, - 0,8,1,-10); - m2 = Matrix4(m1); - m2.mul(O); - assert_(equals(m2, O), "O = m2 x O"); - m2.mul(m1, I); - // printf("m2 = %s", m2.toString().c_str()); - // printf("m1 = %s", m1.toString().c_str()); - assert_(equals(m2, m1), "m2 = m1 x I"); - - // check negate, add - m2.negate(m1); - m2.add(m1); - assert(equals(m2, O)); - - // check mul, sub - T v[] = { 5,1,4,0, - 2,3,-4,-1, - 2,3,-4,-1, - 1,1,1,1}; - m2.set(v); - m2.negate(m1); - Matrix4 m3 = Matrix4(m1); - m3.sub(m2); - m3.mul(0.5); - assert(equals(m1, m3)); - - //printf("4"); - - // check invert - m2 = Matrix4( - .5,1,4,1, - -2,3,-4,-1, - 1,9,100,2, - -20,2,1,9); - m3.invert(m2); - m3.mul(m2); - assert(equals(m3, I)); - - //printf("5"); - - // translate - m1 = Matrix4( - -1,2,0,3, - -1,1,-3,-1, - 1,2,1,1, - 0,0,0,1); - Point3 p1 = Point3(1,2,3); - Vector3 v1 = Vector3(1,2,3); - Vector4 V2 = Vector4(2,-1,-4,1); - - // printf("m1=" + m1.toString()); - // assert(m1.toString().equals("[" + NL + - // " [-1.0 2.0 0.0 3.0]" + NL + - // " [-1.0 1.0 -3.0 -1.0]" + NL + - // " [1.0 2.0 1.0 1.0]" + NL + - // " [0.0 0.0 0.0 1.0] ]")); - - //printf("6"); - m1.transform(&p1); - assert(equals(p1, Point3(6,-9,9))); - // printf("7"); - m1.transform(V2,&V2); - assert(equals(V2, Vector4(-1,8,-3,1))); - // printf("8"); - - - - // rotZ - // rotate (1,0,0) 30degree abount z axis -> (cos 30,sin 30,0) - p1.set(1,0,0); - m1.rotZ(T(M_PI/6)); - m1.transform(&p1); - assert(equals(p1, Point3(cos(M_PI/6), sin(M_PI/6), 0))); - // printf("9"); - - // rotY - // rotate() (1,0,0) 60degree about y axis -> (cos 60,0,-sin 60) - p1.set(1,0,0); - m1.rotY(T(M_PI/3)); - m1.transform(&p1); - assert(equals(p1, Point3( cos(M_PI/3), 0, -sin(M_PI/3)))); - // printf("10"); - - // rot around arbitary axis - // rotate() (1,0,0) 60degree about y axis -> (cos 60,0,-sin 60) - AxisAngle4 a1 = AxisAngle4(0,1,0,T(M_PI/3)); - p1.set(1,0,0); - m1.set(a1); - m1.transform(p1, &p1); - assert(equals(p1, Point3( - cos(M_PI/3), - 0, - -sin(M_PI/3)))); - // printf("11"); - - // use quat. - Quat4 q1 = Quat4(); - p1.set(1,0,0); - q1.set(a1); - m2.set(q1); - assert(equals(m1, m2)); - // printf("12"); - m2.transform(p1, &p1); - assert(equals(p1, Point3(cos(M_PI/3), 0, -sin(M_PI/3)))); - // printf("13"); - - // Mat <-> Quat <-> Axis - a1.set(1,2,-3,T(M_PI/3)); - Mat4QuatAxisAngle(a1); - - // Mat <-> Quat <-> Axis (near PI case) - a1.set(1,2,3,T(M_PI)); - Mat4QuatAxisAngle(a1); - // Mat <-> Quat <-> Axis (near PI, X major case ) - a1.set(1,T(.1),T(.1),T(M_PI)); - Mat4QuatAxisAngle(a1); - // Mat <-> Quat <-> Axis (near PI, Y major case ) - a1.set(T(.1),1,T(.1),T(M_PI)); - Mat4QuatAxisAngle(a1); - // Mat <-> Quat <-> Axis (near PI, Z major case ) - a1.set(T(.1),T(.1),1,T(M_PI)); - Mat4QuatAxisAngle(a1); - - // isometric view 3 times 2/3 turn - a1.set(1,1,1,T(2*M_PI/3)); - m1.set(a1); - //printf("m1="+m1); - p1.set(1,0,0); - //printf("p1="+p1); - m1.transform(&p1); - //printf("after transform p1="+p1); - assert(equals(p1, Point3(0,1,0))); - // printf("14"); - m1.transform(&p1); - assert(equals(p1, Point3(0,0,1))); - //printf("15"); - m1.transform(&p1); - assert(equals(p1, Point3(1,0,0))); - // printf("16"); - - // check getScale - m1.set(a1); - assert(equals_v(m1.determinant(), 1)); - assert(equals_v(m1.getScale(), 1)); - // printf("17"); - m2.set(a1); - - // transpose and inverse - m1.set(a1); - m2.invert(m1); - m1.transpose(); - assert(equals(m1, m2)); - // printf("18"); - - // rot, scale, trans - Matrix3 n1; - n1.set(a1); - Matrix3 n2; - v1.set(2, -1, -1); - m1.set(n1, v1, T(0.4)); - m2.set(n1, v1, T(0.4)); - Vector3 v2 = Vector3(); - T s = m1.get(&n2, &v2); - assert(equals(n1, n2)); - assert(equals_v(s, T(0.4))); - assert(equals(v1, v2)); - assert(equals(m1, m2)); // not modified - -} - -#if 0 -static void GMatrixTest() { - GMatrix I44 = new GMatrix(4,4); // Identity 4x4 - GMatrix O44 = new GMatrix(4,4); O44.setZero(); // O 4x4 - GMatrix O34 = new GMatrix(3,4); O34.setZero(); // O 3x4 - GMatrix m1 = new GMatrix(3,4); - GMatrix m2 = new GMatrix(3,4); - Matrix3 mm1 = new Matrix3(); - Matrix3 mm2 = new Matrix3(); - - // get/setElement - for (int i = 0; i < 3; i++) - for (int j = 0; j < 4; j++) { - m1.setElement(i,j,(i+1)*(j+2)); - if (j < 3) - mm1.setElement(i,j,(i+1)*(j+2)); - } - for (int i = 0; i < 3; i++) - for (int j = 0; j < 4; j++) { - assert(equals(m1.getElement(i,j),(i+1)*(j+2))); - } - - m1.get(mm2); - assert(equals(mm1, mm2)); - - // mul with I,O - m2.mul(m1, I44); - assert(equals(m1, m2)); - m2.mul(m1, O44); - assert(equals(O34, m2)); - - // LUD - Matrix4 mm3 = new Matrix4( - 1, 2, 3, 4, - -2, 3, -1, 3, - -1, -2, -4, 1, - 1, 1, -1, -2 - ); - Matrix4 mm4 = new Matrix4(); - Matrix4 mm5 = new Matrix4(); - mm5.set(mm3); - - // setSize, invert - m1.setSize(4, 4); - m2.setSize(4, 4); - m1.set(mm3); - // printf("m1=" + m1.toString()); - //assert(m1.toString().equals("[" + NL + - //" [1.0 2.0 3.0 4.0]" + NL + - // " [-2.0 3.0 -1.0 3.0]" + NL + - // " [-1.0 -2.0 -4.0 1.0]" + NL + - // " [1.0 1.0 -1.0 -2.0] ]")); - - m2.set(m1); - m1.invert(); - mm3.invert(); - // printf("mm3 = "+mm3.toString()); - // printf("mm5 = "+mm5.toString()); - mm5.mul(mm3); - // printf("mm5(==I) = "+mm5.toString()); - assert(equals(mm5, new Matrix4(1,0,0,0, - 0,1,0,0, - 0,0,1,0, - 0,0,0,1))); - - m1.get(mm4); - // printf("m1 = "+m1.toString()); - // printf("mm3 = "+mm3.toString()); - // printf("mm4 = "+mm4.toString()); - assert(equals(mm3, mm4)); - // printf("m1 = "+m1.toString()); - // printf("m2 = "+m2.toString()); - m1.mul(m2); - // printf("m1*m2 = "+m1.toString()); - assert(equals(m1, I44)); - - // LUD - Matrix4 mm6 = new Matrix4( - 1, 2, 3, 4, - -2, 3, -1, 3, - -1, -2, -4, 1, - 1, 1, -1, -2 - ); - Vector4 vv1 = new Vector4(1,-1,-1,2); - Vector4 vv2 = new Vector4(); - Vector4 vv3 = new Vector4(4,2,7,-3); - mm6.transform(vv1, vv2); - // printf("mm6 = "+mm6.toString()); - // printf("vv1 = "+vv1.toString()); - // printf("vv2 = "+vv2.toString()); - // printf("vv3 = "+vv3.toString()); - assert(equals(vv2, vv3)); - - m1.set(mm6); - GVector x = new GVector(4); - GVector v2 = new GVector(4); - GVector b = new GVector(4); - x.set(vv1); // (1,-1,-1,2) - b.set(vv3); // (4,2,7,-3) - GVector mx = new GVector(4); - mx.mul(m1, x); // M*x = (4,2,7,-3) - assert(equals(mx, b)); - - GVector p = new GVector(4); - m1.LUD(m2, p); - assert(checkLUD(m1, m2, p)); - GVector xx = new GVector(4); - xx.LUDBackSolve(m2, b, p); - assert(equals(xx, x)); - - GMatrix u = new GMatrix(m1.getNumRow(), m1.getNumRow()); - GMatrix w = new GMatrix(m1.getNumRow(), m1.getNumCol()); - GMatrix v = new GMatrix(m1.getNumCol(), m1.getNumCol()); - int rank = m1.SVD(u, w, v); - assert(rank == 4); - assert(checkSVD(m1, u, w, v)); - xx.SVDBackSolve(u, w, v, b); - assert(equals(xx, x)); - - // overwrite m1 -LUD-> m1 - // m1.LUD(m1, p); - // xx.LUDBackSolve(m2, b, p); - // assert(equals(xx, x)); -} - -static bool checkLUD(GMatrix m, GMatrix LU, GVector permutation) { - int n = m.getNumCol(); - bool ok = true; - for (int i = 0; i < n; i++) { - for (int j = 0; j < n; j++) { - T aij = 0.0; - int min = i < j ? i : j; - for (int k = 0; k <= min; k++) { - if (i != k) - aij += LU.getElement(i, k)*LU.getElement(k, j); - else - aij += LU.getElement(k, j); - } - if (abs(aij - m.getElement((int)permutation.getElement(i),j)) > epsilon) { - printf("a["+i+","+j+"] = "+aij+"(LU)ij ! = "+m.getElement((int)permutation.getElement(i),j)); - ok = false; - } - } - } - return ok; -} - -static bool checkSVD(GMatrix m, GMatrix u, GMatrix w, GMatrix v) { - bool ok = true; - int wsize = w.getNumRow() < w.getNumRow() ? w.getNumRow() : w.getNumCol(); - - for (int i = 0; i < m.getNumRow(); i++) { - for (int j = 0; j < m.getNumCol(); j++) { - T sum = 0.0; - for (int k = 0; k < m.getNumCol(); k++) { - sum += u.getElement(i,k)*w.getElement(k,k)*v.getElement(j,k); - } - /* check if SVD is OK */ - if (epsilon < abs(m.getElement(i, j)-sum)) { - printf("(SVD)ij = "+sum +" != a["+i+","+j+"] = "+m.getElement(i,j)); - ok = false; - } - } - - } - if (!ok) { - System.out.print("[W] = "); - printf(w); - System.out.print("[U] = "); - printf(u); - System.out.print("[V] = "); - printf(v); - } - return ok; -} - -#endif - -/** - * test for Mat/Quat/AxisAngle rotations - */ -#ifdef TESTALL -int test_11() { -#else -int main(int, char**) { -#endif - Vector3Test(1.0); - Vector3Test(1.0f); - - Matrix3Test(1.0); - Matrix3Test(1.0f); - - Matrix4Test(1.0); - Matrix4Test(1.0f); - return 0; -} diff --git a/Utilities/vecmath/test-12.cpp b/Utilities/vecmath/test-12.cpp deleted file mode 100644 index c33f88862f..0000000000 --- a/Utilities/vecmath/test-12.cpp +++ /dev/null @@ -1,75 +0,0 @@ -/* - Copyright (C) 1997,1998,1999 - Kenji Hiranabe, Eiwa System Management, Inc. - - This program is free software. - Implemented by Kenji Hiranabe(hiranabe@esm.co.jp), - conforming to the Java(TM) 3D API specification by Sun Microsystems. - - Permission to use, copy, modify, distribute and sell this software - and its documentation for any purpose is hereby granted without fee, - provided that the above copyright notice appear in all copies and - that both that copyright notice and this permission notice appear - in supporting documentation. Kenji Hiranabe and Eiwa System Management,Inc. - makes no representations about the suitability of this software for any - purpose. It is provided "AS IS" with NO WARRANTY. -*/ -#ifndef M_PI -#define M_PI 3.14159265358979323846 -#endif - - - -#include - -#ifdef VM_INCLUDE_NAMESPACE -using namespace kh_vecmath; -#endif - -#ifdef VM_USE_STD_NAMESPACE -using namespace std; -#endif - -/** - * test for toString() - */ -#ifdef TESTALL -int test_12() { -#else -int main(int, char**) { -#endif -#ifdef VM_INCLUDE_TOSTRING - AxisAngle4d aa(1,2,3,4); - cout << aa.toString() << endl; - assert(aa.toString() == "(1,2,3,4)"); - - Color3d c3(1,2,3); - cout << c3.toString() << endl; - assert(c3.toString() == "(1,2,3)"); - - Color4f c4(1,2,3,4); - cout << c4.toString() << endl; - assert(c4.toString() == "(1,2,3,4)"); - - Matrix3d m3d(1,2,3,4,5,6,7,8,9); - cout << m3d.toString() << endl; - assert(m3d.toString() == - "[ [1,2,3]\n" - " [4,5,6]\n" - " [7,8,9] ]"); - - Point2f p2f(3,4); - cout << p2f.toString() << endl; - assert(p2f.toString() == "(3,4)"); - - Quat4d q4d(3,4,1,2); - cout << q4d.toString() << endl; - assert(q4d.toString() == "(3,4,1,2)"); - - Vector4d v4d(3,4,1,2); - cout << v4d.toString() << endl; - assert(v4d.toString() == "(3,4,1,2)"); -#endif - - return 0; -} diff --git a/Utilities/vecmath/test-2.cpp b/Utilities/vecmath/test-2.cpp deleted file mode 100644 index 2ad0f3ed2a..0000000000 --- a/Utilities/vecmath/test-2.cpp +++ /dev/null @@ -1,49 +0,0 @@ -/* - Copyright (C) 1997,1998,1999 - Kenji Hiranabe, Eiwa System Management, Inc. - - This program is free software. - Implemented by Kenji Hiranabe(hiranabe@esm.co.jp), - conforming to the Java(TM) 3D API specification by Sun Microsystems. - - Permission to use, copy, modify, distribute and sell this software - and its documentation for any purpose is hereby granted without fee, - provided that the above copyright notice appear in all copies and - that both that copyright notice and this permission notice appear - in supporting documentation. Kenji Hiranabe and Eiwa System Management,Inc. - makes no representations about the suitability of this software for any - purpose. It is provided "AS IS" with NO WARRANTY. -*/ -#include "Vector2.h" -#include "Tuple2.h" -#include "Point2.h" - -#ifdef VM_INCLUDE_NAMESPACE -using namespace kh_vecmath; -#endif - -/** - * test-2 for Vector2 - */ -#ifdef TESTALL -int test_2() { -#else -int main(int, char**) { -#endif - Point2d p1(1,2); - Point2d p2(4,6); - - // distance - Point2d::value_type d = p1.distance(p2); - assert(fabs(d - 5) < 1.0e-5); - - // distance L1 - d = p1.distanceL1(p2); - assert(d == 7); - - // distance Linf - d = p1.distanceLinf(p2); - assert(d == 4); - - return 0; -} diff --git a/Utilities/vecmath/test-3.cpp b/Utilities/vecmath/test-3.cpp deleted file mode 100644 index f374e7182b..0000000000 --- a/Utilities/vecmath/test-3.cpp +++ /dev/null @@ -1,77 +0,0 @@ -/* - Copyright (C) 1997,1998,1999 - Kenji Hiranabe, Eiwa System Management, Inc. - - This program is free software. - Implemented by Kenji Hiranabe(hiranabe@esm.co.jp), - conforming to the Java(TM) 3D API specification by Sun Microsystems. - - Permission to use, copy, modify, distribute and sell this software - and its documentation for any purpose is hereby granted without fee, - provided that the above copyright notice appear in all copies and - that both that copyright notice and this permission notice appear - in supporting documentation. Kenji Hiranabe and Eiwa System Management,Inc. - makes no representations about the suitability of this software for any - purpose. It is provided "AS IS" with NO WARRANTY. -*/ -#include "Vector2.h" -#include "Tuple2.h" -#include "Point2.h" - -#ifndef M_PI -#define M_PI 3.14159265358979323846 -#endif - -#ifdef VM_INCLUDE_NAMESPACE -using namespace kh_vecmath; -#endif - -template -bool equals(T a, S b) { - return fabs(a - b) < 1.0e-8; -} - -/** - * test-3 for Vector2 - */ -#ifdef TESTALL -int test_3() { -#else -int main(int, char**) { -#endif - Vector2d p1(1,2); - Vector2d p2(4,6); - - // dot product - Vector2d::value_type d = p1.dot(p2); - assert(equals(d, 16)); - - // length - d = p1.length(); - assert(equals(d, sqrt(p1.dot(p1)))); - - // normalize - p1.normalize(); - assert(equals(p1.x,1/d)); - assert(equals(p1.y,2/d)); - - p1.set(-1,3); - d = p1.length(); - p2.normalize(p1); - assert(equals(p2.x,-1/d)); - assert(equals(p2.y, 3/d)); - - // angle - p1.set(3, 4); - p2.set(-4, 3); - d = p1.angle(p2); - assert(equals(d, M_PI/2)); - d = p2.angle(p1); - assert(equals(d, M_PI/2)); - d = p1.angle(p1); - assert(equals(d, 0)); - d = p2.angle(p2); - assert(equals(d, 0)); - - return 0; -} diff --git a/Utilities/vecmath/test-4.cpp b/Utilities/vecmath/test-4.cpp deleted file mode 100644 index b90690d8ab..0000000000 --- a/Utilities/vecmath/test-4.cpp +++ /dev/null @@ -1,58 +0,0 @@ -/* - Copyright (C) 1997,1998,1999 - Kenji Hiranabe, Eiwa System Management, Inc. - - This program is free software. - Implemented by Kenji Hiranabe(hiranabe@esm.co.jp), - conforming to the Java(TM) 3D API specification by Sun Microsystems. - - Permission to use, copy, modify, distribute and sell this software - and its documentation for any purpose is hereby granted without fee, - provided that the above copyright notice appear in all copies and - that both that copyright notice and this permission notice appear - in supporting documentation. Kenji Hiranabe and Eiwa System Management,Inc. - makes no representations about the suitability of this software for any - purpose. It is provided "AS IS" with NO WARRANTY. -*/ -#include "Point3.h" -#include "Vector3.h" - -#ifdef VM_INCLUDE_NAMESPACE -using namespace kh_vecmath; -#endif - -template -bool equals(T a, S b) { - return fabs(a - b) < 1.0e-8; -} - -/** - * test for Point3 - */ -#ifdef TESTALL -int test_4() { -#else -int main(int, char**) { -#endif - Point3d p1(1,2,3); - Point3d p2(4,6,1); - - // distance - Point3d::value_type d = p1.distance(p2); - Vector3d dv = p2 - p1; - assert(equals(d, dv.length())); - - // distance L1 - d = p1.distanceL1(p2); - assert(d == 9); - - // distance Linf - d = p1.distanceLinf(p2); - assert(d == 4); - - // project - p1.project(Point4d(6, 4, 2, 2)); - assert(p1 == Point3d(3, 2, 1)); - - return 0; -} diff --git a/Utilities/vecmath/test-5.cpp b/Utilities/vecmath/test-5.cpp deleted file mode 100644 index 06ed35188a..0000000000 --- a/Utilities/vecmath/test-5.cpp +++ /dev/null @@ -1,73 +0,0 @@ -/* - Copyright (C) 1997,1998,1999 - Kenji Hiranabe, Eiwa System Management, Inc. - - This program is free software. - Implemented by Kenji Hiranabe(hiranabe@esm.co.jp), - conforming to the Java(TM) 3D API specification by Sun Microsystems. - - Permission to use, copy, modify, distribute and sell this software - and its documentation for any purpose is hereby granted without fee, - provided that the above copyright notice appear in all copies and - that both that copyright notice and this permission notice appear - in supporting documentation. Kenji Hiranabe and Eiwa System Management,Inc. - makes no representations about the suitability of this software for any - purpose. It is provided "AS IS" with NO WARRANTY. -*/ -#include "Vector3.h" - -template -bool equals(T a, S b) { - return fabs(a - b) < 1.0e-8; -} - -#ifdef VM_INCLUDE_NAMESPACE -using namespace kh_vecmath; -#endif - -/** - * test for Vector3 - */ -#ifdef TESTALL -int test_5() { -#else -int main(int, char**) { -#endif - Vector3d p1(1,2,3); - Vector3d p2(4,6,1); - - // dot product - Vector3d::value_type d = p1.dot(p2); - assert(equals(d, 19)); - - // length - d = p1.length(); - assert(equals(d, sqrt(p1.dot(p1)))); - - // normalize - p1.normalize(); - assert(equals(p1.x,1/d)); - assert(equals(p1.y,2/d)); - assert(equals(p1.z,3/d)); - - p1.set(-1,3,1); - d = p1.length(); - p2.normalize(p1); - assert(equals(p2.x,-1/d)); - assert(equals(p2.y, 3/d)); - assert(equals(p2.z, 1/d)); - - // angle - p1.set(3, 4, 1); - p2.set(-4, 3, 1); - d = p1.angle(p2); - assert(equals(d, acos(p1.dot(p2)/p1.length()/p2.length()))); - d = p2.angle(p1); - assert(equals(d, acos(p1.dot(p2)/p1.length()/p2.length()))); - d = p1.angle(p1); - assert(equals(d, 0)); - d = p2.angle(p2); - assert(equals(d, 0)); - - return 0; -} diff --git a/Utilities/vecmath/test-6.cpp b/Utilities/vecmath/test-6.cpp deleted file mode 100644 index eedee5aade..0000000000 --- a/Utilities/vecmath/test-6.cpp +++ /dev/null @@ -1,60 +0,0 @@ -/* - Copyright (C) 1997,1998,1999 - Kenji Hiranabe, Eiwa System Management, Inc. - - This program is free software. - Implemented by Kenji Hiranabe(hiranabe@esm.co.jp), - conforming to the Java(TM) 3D API specification by Sun Microsystems. - - Permission to use, copy, modify, distribute and sell this software - and its documentation for any purpose is hereby granted without fee, - provided that the above copyright notice appear in all copies and - that both that copyright notice and this permission notice appear - in supporting documentation. Kenji Hiranabe and Eiwa System Management,Inc. - makes no representations about the suitability of this software for any - purpose. It is provided "AS IS" with NO WARRANTY. -*/ -#include "Point4.h" -#include "Vector4.h" - -template -bool equals(T a, S b) { - return fabs(a - b) < 1.0e-8; -} - -#ifdef VM_INCLUDE_NAMESPACE -using namespace kh_vecmath; -#endif - -/** - * test for Point4 - */ -#ifdef TESTALL -int test_6() { -#else -int main(int, char**) { -#endif - const double da[] = - { 1, 2, 3, 4, 5 }; - Point4d p1(da); - Point4d p2(4, 6, 1, -1); - - // distance - Point4d::value_type d = p1.distance(p2); - Vector4d dv = p2 - p1; - assert(equals(d, dv.length())); - - // distance L1 - d = p1.distanceL1(p2); - assert(d == 14); - - // distance Linf - d = p1.distanceLinf(p2); - assert(d == 5); - - // project - p1.project(Point4d(6, 4, 2, 2)); - assert(p1 == Point4d(3, 2, 1, 1)); - - return 0; -} diff --git a/Utilities/vecmath/test-7.cpp b/Utilities/vecmath/test-7.cpp deleted file mode 100644 index ddcdeeb86e..0000000000 --- a/Utilities/vecmath/test-7.cpp +++ /dev/null @@ -1,75 +0,0 @@ -/* - Copyright (C) 1997,1998,1999 - Kenji Hiranabe, Eiwa System Management, Inc. - - This program is free software. - Implemented by Kenji Hiranabe(hiranabe@esm.co.jp), - conforming to the Java(TM) 3D API specification by Sun Microsystems. - - Permission to use, copy, modify, distribute and sell this software - and its documentation for any purpose is hereby granted without fee, - provided that the above copyright notice appear in all copies and - that both that copyright notice and this permission notice appear - in supporting documentation. Kenji Hiranabe and Eiwa System Management,Inc. - makes no representations about the suitability of this software for any - purpose. It is provided "AS IS" with NO WARRANTY. -*/ -#include "Vector4.h" - -template -bool equals(T a, S b) { - return fabs(a - b) < 1.0e-8; -} - -#ifdef VM_INCLUDE_NAMESPACE -using namespace kh_vecmath; -#endif - -/** - * test for Vector4 - */ -#ifdef TESTALL -int test_7() { -#else -int main(int, char**) { -#endif - Vector4d p1(1,2,3,4); - Vector4d p2(4,6,1,5); - - // dot product - Vector4d::value_type d = p1.dot(p2); - assert(equals(d, 39)); - - // length - d = p1.length(); - assert(equals(d, sqrt(p1.dot(p1)))); - - // normalize - p1.normalize(); - assert(equals(p1.x,1/d)); - assert(equals(p1.y,2/d)); - assert(equals(p1.z,3/d)); - assert(equals(p1.w,4/d)); - - p1.set(-1,3,1,2); - d = p1.length(); - p2.normalize(p1); - assert(equals(p2.x,-1/d)); - assert(equals(p2.y, 3/d)); - assert(equals(p2.z, 1/d)); - assert(equals(p2.w, 2/d)); - - // angle - p1.set(3, 4, 1, -2); - p2.set(-4, 3, 1, -1); - d = p1.angle(p2); - assert(equals(d, acos(p1.dot(p2)/p1.length()/p2.length()))); - d = p2.angle(p1); - assert(equals(d, acos(p1.dot(p2)/p1.length()/p2.length()))); - d = p1.angle(p1); - assert(equals(d, 0)); - d = p2.angle(p2); - assert(equals(d, 0)); - - return 0; -} diff --git a/Utilities/vecmath/test-8.cpp b/Utilities/vecmath/test-8.cpp deleted file mode 100644 index 72a0c4c19e..0000000000 --- a/Utilities/vecmath/test-8.cpp +++ /dev/null @@ -1,201 +0,0 @@ -/* - Copyright (C) 1997,1998,1999 - Kenji Hiranabe, Eiwa System Management, Inc. - - This program is free software. - Implemented by Kenji Hiranabe(hiranabe@esm.co.jp), - conforming to the Java(TM) 3D API specification by Sun Microsystems. - - Permission to use, copy, modify, distribute and sell this software - and its documentation for any purpose is hereby granted without fee, - provided that the above copyright notice appear in all copies and - that both that copyright notice and this permission notice appear - in supporting documentation. Kenji Hiranabe and Eiwa System Management,Inc. - makes no representations about the suitability of this software for any - purpose. It is provided "AS IS" with NO WARRANTY. -*/ -#include "Matrix3.h" - -template -bool equals(T a, S b) { - return fabs(a - b) < 1.0e-5; -} - -#ifdef VM_INCLUDE_NAMESPACE -using namespace kh_vecmath; -#endif - -template -void f(T) { - /* - * constructors - */ - Matrix3 m1(1,2,3, - 4,5,6, - 7,8,9); - - T array[] = {1,2,3,4,5,6,7,8,9}; - // const T array2[3][3] = {{1,2,3},{4,5,6},{7,8,9}}; - // Matrix3 m3(array2); - Matrix3 m2(array); - Matrix3 m3(m1); - - -#ifdef VM_INCLUDE_SUBSCRIPTION_OPERATOR - assert(m1(0,0) == 1); - assert(m1(0,1) == 2); - assert(m1(0,2) == 3); - assert(m1(1,0) == 4); - assert(m1(1,1) == 5); - assert(m1(1,2) == 6); - assert(m1(2,0) == 7); - assert(m1(2,1) == 8); - assert(m1(2,2) == 9); -#endif - assert(m1.getElement(0,0) == 1); - assert(m1.getElement(0,1) == 2); - assert(m1.getElement(0,2) == 3); - assert(m1.getElement(1,0) == 4); - assert(m1.getElement(1,1) == 5); - assert(m1.getElement(1,2) == 6); - assert(m1.getElement(2,0) == 7); - assert(m1.getElement(2,1) == 8); - assert(m1.getElement(2,2) == 9); - assert(m1 == m2); - assert(m1 == m3); - - /* - * set/get row/column - */ - m1.setIdentity(); - m1.setScale(2); - assert(m1 == Matrix3(2,0,0,0,2,0,0,0,2)); -#ifdef VM_INCLUDE_SUBSCRIPTION_OPERATOR - for (unsigned i = 0; i < 3; i++) - for (unsigned j = 0; j < 3; j++) - m1(i,j) = 10*i + j; - for (unsigned i2 = 0; i2 < 3; i2++) - for (unsigned j = 0; j < 3; j++) - assert(m1(i2,j) == 10*i2 + j); -#endif - - for (unsigned ii = 0; ii< 3; ii++) - for (unsigned j = 0; j < 3; j++) - m1.setElement(ii,j, 10*ii + j); - for (unsigned iii = 0; iii < 3; iii++) - for (unsigned j = 0; j < 3; j++) - assert(m1.getElement(iii,j) == 10*iii + j); - - - for (unsigned j = 0; j < 3; j++) { - Vector3 v1(10*j,6*j,j); - Vector3 v2; - m1.setRow(j, v1); - m1.getRow(j, &v2); - assert(v1 == v2); - } - - for (unsigned i3 = 0; i3 < 3; i3++) { - T t[] = { 1, 2, 3 }; - T s[3]; - m1.setRow(i3, t); - m1.getRow(i3, s); - for (unsigned j = 0; j < 3; j ++) - assert(t[j] == s[j]); - } - - for (unsigned i4 = 0; i4 < 3; i4++) { - Vector3 v1(7*i4,6*i4,i4); - Vector3 v2; - m1.setColumn(i4, v1); - m1.getColumn(i4, &v2); - assert(v1 == v2); - } - - for (unsigned i5 = 0; i5 < 3; i5++) { - T t[] = { 1, 2, 3 }; - T s[3]; - m1.setColumn(i5, t); - m1.getColumn(i5, s); - for (unsigned j = 0; j < 3; j ++) - assert(t[j] == s[j]); - } - - /* - * scales - */ - m1.setIdentity(); - for (unsigned i6 = 1; i6 < 10; i6++) { - m1.setScale(i6); - T s = m1.getScale(); - assert(equals(s, i6)); - } - - /* - * add/sub - */ - m1.set(1, 2, 3, - 4, 5, 6, - 9, 3, 4); - m2.add(10, m1); - m2.sub(10); - assert(m1 == m2); - - /** - * negate - */ - m1.set(1, 2, 3, - 4, 5, 6, - 9, 3, 4); - m2.negate(m1); - m3.add(m1, m2); - assert(m3 == Matrix3(0,0,0,0,0,0,0,0,0)); - - /* - * transpose - */ - m2.transpose(m1); - m2.transpose(); - assert(m1 == m2); - - /* - * invert - */ - m2.invert(m1); - m2 *= m1; -#ifdef VM_INCLUDE_SUBSCRIPTION_OPERATOR - assert(equals(m2(0,0),1)); - assert(equals(m2(0,1),0)); - assert(equals(m2(0,2),0)); - assert(equals(m2(1,0),0)); - assert(equals(m2(1,1),1)); - assert(equals(m2(1,2),0)); - assert(equals(m2(2,0),0)); - assert(equals(m2(2,1),0)); - assert(equals(m2(2,2),1)); -#endif - assert(equals(m2.getElement(0,0),1)); - assert(equals(m2.getElement(0,1),0)); - assert(equals(m2.getElement(0,2),0)); - assert(equals(m2.getElement(1,0),0)); - assert(equals(m2.getElement(1,1),1)); - assert(equals(m2.getElement(1,2),0)); - assert(equals(m2.getElement(2,0),0)); - assert(equals(m2.getElement(2,1),0)); - assert(equals(m2.getElement(2,2),1)); - -} - -/** - * test for Matrix3 - */ -#ifdef TESTALL -int test_8() { -#else -int main(int, char**) { -#endif - f(1.0); - f(1.0f); - return 0; -} - diff --git a/Utilities/vecmath/test-9.cpp b/Utilities/vecmath/test-9.cpp deleted file mode 100644 index ecce2b591b..0000000000 --- a/Utilities/vecmath/test-9.cpp +++ /dev/null @@ -1,217 +0,0 @@ -/* - Copyright (C) 1997,1998,1999 - Kenji Hiranabe, Eiwa System Management, Inc. - - This program is free software. - Implemented by Kenji Hiranabe(hiranabe@esm.co.jp), - conforming to the Java(TM) 3D API specification by Sun Microsystems. - - Permission to use, copy, modify, distribute and sell this software - and its documentation for any purpose is hereby granted without fee, - provided that the above copyright notice appear in all copies and - that both that copyright notice and this permission notice appear - in supporting documentation. Kenji Hiranabe and Eiwa System Management,Inc. - makes no representations about the suitability of this software for any - purpose. It is provided "AS IS" with NO WARRANTY. -*/ -#include "Matrix4.h" - -template -bool equals(T a, S b) { - return fabs(a - b) < 1.0e-5; -} - -#ifdef VM_INCLUDE_NAMESPACE -using namespace kh_vecmath; -#endif - -template -void f(T) { - /* - * constructors - */ - Matrix4 m1(1,2,3,4, - 5,6,7,8, - 9,10,11,12, - 13,14,15,16); - - T array[] = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16}; - Matrix4 m2(array); - -#ifdef VM_INCLUDE_CONVERSION_FROM_2DARRAY - T array2[4][4] = {{1,2,3,4},{5,6,7,8},{9,10,11,12},{13,14,15,16}}; - Matrix4 m3(array2); -#else - Matrix4 m3(m2); -#endif - - int k = 0; - for (unsigned i = 0; i < Matrix4::DIMENSION; i++) { - for (unsigned j = 0; j < Matrix4::DIMENSION; j++) { - k++; -#ifdef VM_INCLUDE_SUBSCRIPTION_OPERATOR - assert(m1(i,j) == k); - assert(m2(i,j) == k); - assert(m3(i,j) == k); -#endif - assert(m1.getElement(i,j) == k); - assert(m2.getElement(i,j) == k); - assert(m3.getElement(i,j) == k); - } - } - assert(m1 == m2); - assert(m1 == m3); - - /* - * set/get row/column - */ - m1.setIdentity(); - m1.setScale(2); - assert(m1 == Matrix4(2,0,0,0, - 0,2,0,0, - 0,0,2,0, - 0,0,0,1)); - -#ifdef VM_INCLUDE_SUBSCRIPTION_OPERATOR - for (unsigned i = 0; i < 4; i++) - for (unsigned j = 0; j < 4; j++) - m1(i,j) = 10*i + j; - for (unsigned ii = 0; ii < 4; ii++) - for (unsigned j = 0; j < 4; j++) - assert(10*ii + j == m1(ii,j)); -#endif - for (unsigned i2 = 0; i2 < 4; i2++) - for (unsigned j = 0; j < 4; j++) - m1.setElement(i2,j,10*i2 + j); - for (unsigned i3 = 0; i3 < 4; i3++) - for (unsigned j = 0; j < 4; j++) - assert(10*i3 + j == m1.getElement(i3,j)); - - for (unsigned i4 = 0; i4 < 4; i4++) { - Vector4 v1(10*i4,6*i4,i4,17*i4); - Vector4 v2; - m1.setRow(i4, v1); - m1.getRow(i4, &v2); - assert(v1 == v2); - } - - for (unsigned i5 = 0; i5 < 4; i5++) { - const T t[] = { 1, 2, 3, 4 }; - T s[4]; - m1.setRow(i5, t); - m1.getRow(i5, s); - for (unsigned j = 0; j < 4; j ++) - assert(t[j] == s[j]); - } - - for (unsigned i6 = 0; i6 < 4; i6++) { - Vector4 v1(7*i6,5*i6,i6,13*(-i6)); - Vector4 v2; - m1.setColumn(i6, v1); - m1.getColumn(i6, &v2); - assert(v1 == v2); - } - - for (unsigned i7 = 0; i7 < 4; i7++) { - const T t[] = { 1, 2, 3, 4}; - T s[4]; - m1.setColumn(i7, t); - m1.getColumn(i7, s); - for (unsigned j = 0; j < 4; j ++) - assert(t[j] == s[j]); - } - - /* - * scales - */ - m1.setIdentity(); - for (unsigned i8 = 1; i8 < 10; i8++) { - m1.setScale(i8); - T s = m1.getScale(); - assert(equals(s, i8)); - } - - /* - * add/sub - */ - m1.set(1, 2, 3, 4, - 5, 6, 7, 8, - 9, 10,11,12, - 13,14,15,16); - m2.add(10, m1); - m2.sub(10); - assert(m1 == m2); - - /** - * negate - */ - m1.set(1, 2, 3, 10, - 4, 5, 6, 11, - 2, 5, 1, 100, - 9, 3, 4, 12); - m2.negate(m1); - m3.add(m1, m2); - assert(m3 == Matrix4(0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0)); - - /* - * transpose - */ - m2.transpose(m1); - m2.transpose(); - assert(m1 == m2); - - /* - * invert - */ - m2.invert(m1); - m2 *= m1; -#ifdef VM_INCLUDE_SUBSCRIPTION_OPERATOR - assert(equals(m2(0,0),1)); - assert(equals(m2(0,1),0)); - assert(equals(m2(0,2),0)); - assert(equals(m2(0,3),0)); - assert(equals(m2(1,0),0)); - assert(equals(m2(1,1),1)); - assert(equals(m2(1,2),0)); - assert(equals(m2(1,3),0)); - assert(equals(m2(2,0),0)); - assert(equals(m2(2,1),0)); - assert(equals(m2(2,2),1)); - assert(equals(m2(2,3),0)); - assert(equals(m2(3,0),0)); - assert(equals(m2(3,1),0)); - assert(equals(m2(3,2),0)); - assert(equals(m2(3,3),1)); -#endif - assert(equals(m2.getElement(0,0),1)); - assert(equals(m2.getElement(0,1),0)); - assert(equals(m2.getElement(0,2),0)); - assert(equals(m2.getElement(0,3),0)); - assert(equals(m2.getElement(1,0),0)); - assert(equals(m2.getElement(1,1),1)); - assert(equals(m2.getElement(1,2),0)); - assert(equals(m2.getElement(1,3),0)); - assert(equals(m2.getElement(2,0),0)); - assert(equals(m2.getElement(2,1),0)); - assert(equals(m2.getElement(2,2),1)); - assert(equals(m2.getElement(2,3),0)); - assert(equals(m2.getElement(3,0),0)); - assert(equals(m2.getElement(3,1),0)); - assert(equals(m2.getElement(3,2),0)); - assert(equals(m2.getElement(3,3),1)); - -} - -/** - * test for Matrix3 - */ -#ifdef TESTALL -int test_9() { -#else -int main(int, char**) { -#endif - f(1.0); - f(1.0f); - return 0; -} - diff --git a/Utilities/vecmath/test-all.cpp b/Utilities/vecmath/test-all.cpp deleted file mode 100644 index 12bd0ff8e2..0000000000 --- a/Utilities/vecmath/test-all.cpp +++ /dev/null @@ -1,57 +0,0 @@ -#include - -extern int test_1(); -extern int test_2(); -extern int test_3(); -extern int test_4(); -extern int test_5(); -extern int test_6(); -extern int test_7(); -extern int test_8(); -extern int test_9(); -extern int test_10(); -extern int test_11(); -extern int test_12(); - -int main(int, char**) { - int ret = 0; - ret = test_1(); - if (ret == 0) - printf("test 1 success\n"); - ret = test_2(); - if (ret == 0) - printf("test 2 success\n"); - ret = test_3(); - if (ret == 0) - printf("test 3 success\n"); - ret = test_4(); - if (ret == 0) - printf("test 4 success\n"); - ret = test_5(); - if (ret == 0) - printf("test 5 success\n"); - ret = test_6(); - if (ret == 0) - printf("test 6 success\n"); - ret = test_7(); - if (ret == 0) - printf("test 7 success\n"); - ret = test_8(); - if (ret == 0) - printf("test 8 success\n"); - ret = test_9(); - if (ret == 0) - printf("test 9 success\n"); - ret = test_10(); - if (ret == 0) - printf("test 10 success\n"); - ret = test_11(); - if (ret == 0) - printf("test 11 success\n"); - ret = test_12(); - if (ret == 0) - printf("test 12 success\n"); - ret = printf("** all test success.\n"); - return 0; -} - diff --git a/Utilities/vecmath/vecmath.h b/Utilities/vecmath/vecmath.h deleted file mode 100644 index c80a4e2df1..0000000000 --- a/Utilities/vecmath/vecmath.h +++ /dev/null @@ -1,43 +0,0 @@ -/* - Copyright (C) 1997,1998,1999 - Kenji Hiranabe, Eiwa System Management, Inc. - - This program is free software. - Implemented by Kenji Hiranabe(hiranabe@esm.co.jp), - conforming to the Java(TM) 3D API specification by Sun Microsystems. - - Permission to use, copy, modify, distribute and sell this software - and its documentation for any purpose is hereby granted without fee, - provided that the above copyright notice appear in all copies and - that both that copyright notice and this permission notice appear - in supporting documentation. Kenji Hiranabe and Eiwa System Management,Inc. - makes no representations about the suitability of this software for any - purpose. It is provided "AS IS" with NO WARRANTY. -*/ -#ifndef VECMATH_H -#define VECMATH_H - -#include "vm_conf.h" -#include "VmUtil.h" -#include "AxisAngle4_.h" -#include "AxisAngle4.h" -#include "Color3.h" -#include "Color4.h" -#include "Matrix3.h" -#include "Matrix3_.h" -#include "Matrix4.h" -#include "Matrix4_.h" -#include "Point2.h" -#include "Point3.h" -#include "Point4.h" -#include "Quat4.h" -#include "Quat4_.h" -#include "TexCoord2.h" -#include "Tuple2.h" -#include "Tuple3.h" -#include "Tuple4.h" -#include "Vector2.h" -#include "Vector3.h" -#include "Vector4.h" - -#endif /* VECMATH_H */ diff --git a/Utilities/vecmath/vm_conf.h b/Utilities/vecmath/vm_conf.h deleted file mode 100644 index adb7bd7332..0000000000 --- a/Utilities/vecmath/vm_conf.h +++ /dev/null @@ -1,139 +0,0 @@ -/* - Copyright (C) 1997,1998,1999 - Kenji Hiranabe, Eiwa System Management, Inc. - - This program is free software. - Implemented by Kenji Hiranabe(hiranabe@esm.co.jp), - conforming to the Java(TM) 3D API specification by Sun Microsystems. - - Permission to use, copy, modify, distribute and sell this software - and its documentation for any purpose is hereby granted without fee, - provided that the above copyright notice appear in all copies and - that both that copyright notice and this permission notice appear - in supporting documentation. Kenji Hiranabe and Eiwa System Management,Inc. - makes no representations about the suitability of this software for any - purpose. It is provided "AS IS" with NO WARRANTY. -*/ -#ifndef VM_CONF_H -#define VM_CONF_H - -/* ----------------------------------------------------------- - * you can configure these defines. - * commented lines 34/41 out, Christoph Giess 11.12.2000 - * ----------------------------------------------------------- */ - -/* - * can do 'cout << vec;' - */ -#define VM_INCLUDE_IO - -/* - * can do 'vec.toString();' - * automatically defines VM_INCLUDE_IO - */ -/* #define VM_INCLUDE_TOSTRING */ - -/* - * places this library in 'kh_vecmath' namespace - * later section can turn this off(earlyer version than egcs1.1.2 ). - * - */ -// #define VM_INCLUDE_NAMESPACE - -/* - * can do 'double a[3][3]; mat.set(a);' - * don't define this in gcc 2.7.2.(template bug). - */ -// #define VM_INCLUDE_CONVERSION_FROM_2DARRAY - -/* - * can do 'mat(i,j); v[i];' - * defining this can be a performance problem. - */ -// #define VM_INCLUDE_SUBSCRIPTION_OPERATOR - -/* - * use cmath, cstddef, .... cXXXX type header - * otherwise use traditional math, stddef .. - */ -#define VM_STD_C_HEADERS - -/* - * uses std:: namespace for sqrt, atan2, ... - * depends on whether system include files exports these raw names - */ -#define VM_USE_STD_NAMESPACE - -/* - * uses exception mechanizm (not supported now) - */ -//#define VM_USE_EXCEPTION - -/* - * uses old non STL version of iostream library (currently only used for MSVC) - */ -//#define VM_USE_OLDIOSTREAM - - -/* ----------------------------------------------------------- - * end user customization section - * ----------------------------------------------------------- */ - -// gcc earlier than egcs1.1.2, doesn't support namespace -#if !((__GNUC__ >= 2 && __GNUC_MINOR__ >= 91)|| (__GNUC__ >= 3)) -#undef VM_INCLUDE_NAMESPACE -#undef VM_USE_STD_NAMESPACE -#endif - - -#ifdef _MSC_VER -# ifndef VM_USE_STD_NAMESPACE -# define VM_USE_STD_NAMESPACE -# endif -#endif - -#ifdef __BORLANDC__ -# ifndef VM_USE_STD_NAMESPACE -# define VM_USE_STD_NAMESPACE -# endif -#endif - -//#define VM_USE_STD_NAMESPACE -#ifdef VM_INCLUDE_NAMESPACE -# define VM_VECMATH_NS kh_vecmath -# define VM_BEGIN_NS namespace kh_vecmath { -# define VM_END_NS } -#else -# define VM_VECMATH_NS -# define VM_BEGIN_NS -# define VM_END_NS -#endif - - -#ifdef VM_INCLUDE_TOSTRING -# ifndef VM_INCLUDE_IO -# define VM_INCLUDE_IO -# endif -#endif - -#ifdef VM_USE_STD_NAMESPACE -# define VM_STD std -#else -# define VM_STD -#endif - -#ifdef _MSC_VER -# define VM_MATH_STD -# define VM_STRING_STD VM_STD -#else -# define VM_MATH_STD VM_STD -# define VM_STRING_STD VM_STD -#endif - -#ifdef VM_USE_OLDIOSTREAM -# define VM_IOSTREAM_STD -#else -# define VM_IOSTREAM_STD VM_STD -#endif - -#endif /* VM_CONF_H */