pax_global_header00006660000000000000000000000064130451100730014504gustar00rootroot0000000000000052 comment=a96352428e6f8d0fe2169bd2d5db274e1245a420 visp-3.0.1/000077500000000000000000000000001304511007300124665ustar00rootroot00000000000000visp-3.0.1/.gitignore000066400000000000000000000001411304511007300144520ustar00rootroot00000000000000*~ */CMakeFiles CMakeCache.txt .DS_Store CMakeLists.txt.user* platforms/ios/build_framework.pyc visp-3.0.1/.travis.yml000066400000000000000000000040501304511007300145760ustar00rootroot00000000000000language: cpp os: - linux - osx env: - VISP_INPUT_IMAGE_PATH=${TRAVIS_BUILD_DIR} compiler: - gcc - clang sudo: required dist: trusty before_install: - cd ${TRAVIS_BUILD_DIR} && { curl -O http://visp-doc.inria.fr/download/dataset/ViSP-images-3.0.0.zip ; cd -; } - unzip ${TRAVIS_BUILD_DIR}/ViSP-images-3.0.0.zip -d ${TRAVIS_BUILD_DIR} # Get libs for OSX - "if [ $TRAVIS_OS_NAME = 'osx' ]; then brew update; fi" #- "if [ $TRAVIS_OS_NAME = 'osx' ]; then brew tap homebrew/science; fi" #- "if [ $TRAVIS_OS_NAME = 'osx' ]; then brew install opencv3; fi" - "if [ $TRAVIS_OS_NAME = 'osx' ]; then brew install libxml2 libdc1394 gsl; fi" # Get libs for Linux - "if [ $TRAVIS_OS_NAME = 'linux' ]; then sudo apt-get update -qq; fi" - "if [ $TRAVIS_OS_NAME = 'linux' ]; then sudo apt-get install -qq cmake libopencv-dev libx11-dev; fi" - "if [ $TRAVIS_OS_NAME = 'linux' ]; then sudo apt-get install -qq liblapack-dev libgsl0-dev; fi" - "if [ $TRAVIS_OS_NAME = 'linux' ]; then sudo apt-get install -qq libdc1394-22-dev libv4l-dev; fi" - "if [ $TRAVIS_OS_NAME = 'linux' ]; then sudo apt-get install -qq libcoin80-dev; fi" - "if [ $TRAVIS_OS_NAME = 'linux' ]; then sudo apt-get install -qq libxml2-dev; fi" - "if [ $TRAVIS_OS_NAME = 'linux' ]; then sudo apt-get install -qq libjpeg-dev libpng12-dev; fi" - "if [ $TRAVIS_OS_NAME = 'linux' ]; then sudo apt-get install -qq libswscale-dev libavutil-dev; fi" - "if [ $TRAVIS_OS_NAME = 'linux' ]; then sudo apt-get install -qq libavformat-dev; fi" - "if [ $TRAVIS_OS_NAME = 'linux' ]; then sudo apt-get install -qq libavcodec-dev libbz2-dev; fi" - "if [ $TRAVIS_OS_NAME = 'linux' ]; then sudo apt-get install -qq libogre-1.9-dev libois-dev; fi" - "if [ $TRAVIS_OS_NAME = 'linux' ]; then sudo apt-get install -qq libzbar-dev libdmtx-dev; fi" before_script: - mkdir build - cd build - cmake .. # Show 3rd parties that are detected - cat ViSP-third-party.txt script: - make - ctest notifications: email: - Fabien.Spindler@inria.fr on_success: change on_failure: always visp-3.0.1/3rdparty/000077500000000000000000000000001304511007300142365ustar00rootroot00000000000000visp-3.0.1/3rdparty/libatidaq-c.orig/000077500000000000000000000000001304511007300173475ustar00rootroot00000000000000visp-3.0.1/3rdparty/libatidaq-c.orig/CMakeLists.txt000066400000000000000000000121271304511007300221120ustar00rootroot00000000000000project(ati) cmake_minimum_required(VERSION 2.8) ########### already in VISP # remove all matching elements from the list macro(vp_list_filterout lst regex) foreach(item ${${lst}}) if(item MATCHES "${regex}") list(REMOVE_ITEM ${lst} "${item}") endif() endforeach() endmacro() set(VP_COMPILER_FAIL_REGEX "command line option .* is valid for .* but not for C\\+\\+" # GNU "command line option .* is valid for .* but not for C" # GNU "unrecognized .*option" # GNU "unknown .*option" # Clang "ignoring unknown option" # MSVC "warning D9002" # MSVC, any lang "option .*not supported" # Intel "[Uu]nknown option" # HP "[Ww]arning: [Oo]ption" # SunPro "command option .* is not recognized" # XL "not supported in this configuration; ignored" # AIX "File with unknown suffix passed to linker" # PGI "WARNING: unknown flag:" # Open64 ) macro(vp_check_compiler_flag LANG FLAG RESULT) if(NOT DEFINED ${RESULT}) if("_${LANG}_" MATCHES "_CXX_") set(_fname "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/src.cxx") if("${CMAKE_CXX_FLAGS} ${FLAG} " MATCHES "-Werror " OR "${CMAKE_CXX_FLAGS} ${FLAG} " MATCHES "-Werror=unknown-pragmas ") file(WRITE "${_fname}" "int main() { return 0; }\n") else() file(WRITE "${_fname}" "#pragma\nint main() { return 0; }\n") endif() elseif("_${LANG}_" MATCHES "_C_") set(_fname "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/src.c") if("${CMAKE_C_FLAGS} ${FLAG} " MATCHES "-Werror " OR "${CMAKE_C_FLAGS} ${FLAG} " MATCHES "-Werror=unknown-pragmas ") file(WRITE "${_fname}" "int main(void) { return 0; }\n") else() file(WRITE "${_fname}" "#pragma\nint main(void) { return 0; }\n") endif() elseif("_${LANG}_" MATCHES "_OBJCXX_") set(_fname "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/src.mm") if("${CMAKE_CXX_FLAGS} ${FLAG} " MATCHES "-Werror " OR "${CMAKE_CXX_FLAGS} ${FLAG} " MATCHES "-Werror=unknown-pragmas ") file(WRITE "${_fname}" "int main() { return 0; }\n") else() file(WRITE "${_fname}" "#pragma\nint main() { return 0; }\n") endif() else() unset(_fname) endif() if(_fname) message(STATUS "Performing Test ${RESULT}") try_compile(${RESULT} "${CMAKE_BINARY_DIR}" "${_fname}" COMPILE_DEFINITIONS "${FLAG}" OUTPUT_VARIABLE OUTPUT) foreach(_regex ${VP_COMPILER_FAIL_REGEX}) if("${OUTPUT}" MATCHES "${_regex}") set(${RESULT} 0) break() endif() endforeach() if(${RESULT}) set(${RESULT} 1 CACHE INTERNAL "Test ${RESULT}") message(STATUS "Performing Test ${RESULT} - Success") else() message(STATUS "Performing Test ${RESULT} - Failed") set(${RESULT} "" CACHE INTERNAL "Test ${RESULT}") endif() else() set(${RESULT} 0) endif() endif() endmacro() macro(vp_check_flag_support lang flag varname) if("_${lang}_" MATCHES "_CXX_") set(_lang CXX) elseif("_${lang}_" MATCHES "_C_") set(_lang C) else() set(_lang ${lang}) endif() string(TOUPPER "${flag}" ${varname}) string(REGEX REPLACE "^(/|-)" "HAVE_${_lang}_" ${varname} "${${varname}}") string(REGEX REPLACE " -|-|=| |\\." "_" ${varname} "${${varname}}") vp_check_compiler_flag("${_lang}" "${ARGN} ${flag}" ${${varname}}) endmacro() # turns off warnings macro(vp_warnings_disable) set(_flag_vars "") set(_msvc_warnings "") set(_gxx_warnings "") foreach(arg ${ARGN}) if(arg MATCHES "^CMAKE_") list(APPEND _flag_vars ${arg}) elseif(arg MATCHES "^/wd") list(APPEND _msvc_warnings ${arg}) elseif(arg MATCHES "^-W") list(APPEND _gxx_warnings ${arg}) endif() endforeach() if(MSVC AND _msvc_warnings AND _flag_vars) foreach(var ${_flag_vars}) foreach(warning ${_msvc_warnings}) set(${var} "${${var}} ${warning}") endforeach() endforeach() elseif((CMAKE_COMPILER_IS_GNUCXX OR ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")) AND _gxx_warnings AND _flag_vars) foreach(var ${_flag_vars}) foreach(warning ${_gxx_warnings}) if(NOT warning MATCHES "^-Wno-") string(REPLACE "${warning}" "" ${var} "${${var}}") string(REPLACE "-W" "-Wno-" warning "${warning}") endif() vp_check_flag_support(${var} "${warning}" _varname) if(${_varname}) set(${var} "${${var}} ${warning}") endif() endforeach() endforeach() endif() unset(_flag_vars) unset(_msvc_warnings) unset(_gxx_warnings) endmacro() set(ATIDAQ_LIBRARY atidaq) add_subdirectory(ATIDAQ) include_directories(${PROJECT_SOURCE_DIR}/ATIDAQ) #add_executable(ftconvert Samples/ftconvert.c) #target_link_libraries(ftconvert ${ATIDAQ_LIBRARY}) add_executable(ftconvert test/ftconvert.cpp) target_link_libraries(ftconvert ${ATIDAQ_LIBRARY}) visp-3.0.1/3rdparty/libatidaq-c.orig/readme.txt000066400000000000000000000137071304511007300213550ustar00rootroot00000000000000ATI DAQ F/T C Library (v1.0.6) ----------------------------------------- The purpose of this C library is to load and parse calibration files for ATI DAQ F/T transducers, and perform the necessary calculations to convert raw voltages from a data acquisition system into forces and torques. Neither the library itself or the sample applications provide hardware I/O. These functions must be provided by your hardware's device drivers. If you are developing an application for the Windows environment, we recommend you use the ATIDAQFT ActiveX Automation Server or the ATICombinedDAQFT .NET assembly. Licensing --------- All of the software including in this package is distributed under the MIT License: Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. http://www.opensource.org/licenses/mit-license.html Library Files ----------------- The following files should be compiled as part of your project: ftconfig.c ftrt.c dom.c expatls.c node.c stack.c xmlparse.c xmlrole.c xmltok.c In addition to the above files, the files "events.c", "xmltok_impl.c", and "xmltok_ns.c" are also included in this library, but are not meant to be directly compiled, as they are '#include'd into other library files. None of these files are intended to be modified. Sample Applications ---------------------------- Two sample applications are included in the Samples folder. ftconvert.c - demonstrates configuring a DAQ F/T system and performing force/torque calculations; converts a sample set of voltages into forces and torques. calinfo.c - demonstrates retrieving information from the calibration file such as the transducer's rated loads, calibration date, and other information. Programming Interface ------------------------------- The functions supported for public use are: createCalibration - Loads calibration info for a transducer from a calibration file destroyCalibration - Frees memory allocated by a successful call to createCalibration SetToolTransform - Performs a 6-axis translation/rotation on the transducer's coordinate system SetForceUnits - Sets the units of force output SetTorqueUnits - Sets the units of torque outputEnables or disables temperature compensation, if available Bias - Stores a voltage reading to be subtracted from subsequent readings, effectively "zeroing" the transducer output to remove tooling weight, etc. ConvertToFT - Converts an array of voltages into forces and torques These functions are documented in ftconfig.h. You can also read information about the transducer system and calibration from the Calibration and other structures. These structures should be treated as read-only and should only be manipulated through the functions listed above. The sample application calinfo.c shows how to retrieve this information. The general structure of an application should follow the following structure: 1. Call the createCalibration() method to load a calibration file into memory. 2. Call the SetForceUnits(), SetTorqueUnits(), SetCalibration(), and SetToolTransform() functions to configure the system. 3. Use device driver calls to retrieve an array of voltages from your data acquisition system. 4. Use the Bias() function to store a baseline reading (zero the transducer) 5. Use the ConvertToFT() function to convert another array of voltages into forces and torques. The Bias reading will be subtracted automatically. 6. Call the destroyCalibration() function to free memory allocated for the Calibration structure created in step 1. Optimizing Your Application -------------------------------------- The bare minimum calculations for converting voltages into forces and torques are in ftrt.c. To isolate this section of the code, simply compile ftrc.c. This file #includes ftrc.h, but none of the other files. This can be useful, for example, in an embedded application where the configuration never changes. You can write a separate configuration program to run on a PC, which sends the contents of the Calibration.rt structure to a local copy of the RTCoefs structure in the embedded system. Version History ---------------------- 1.0.6 Added support for kN-m torque units, changed reference to ActiveX server to also reference .NET assembly. 1.0.5 Moved some declarations out of .h files into .c files to avoid multiple definition errors. Added ftsharedrt.h 1.0.4 Added newlines to the ends of several files to avoid warnings when compiling with gcc. FTconfig.c was using '/t' instead of '\t' for tab character, which caused warnings under gcc, but no warnings or errors under Visual C++. 1.0.3 Added comments to ftconvert.c explaining hardware temperature compensation. 1.0.2 Fixed memory leaks 1.0.0 No changes Released 2-1-02 0.7.1 Added necessary licensing info to all files Beta released 10-5-01 0.7.0 Initial beta release; no known bugs; compiles with no errors or warnings in Microsoft Visual Studio.NET Beta released 10-2-01visp-3.0.1/3rdparty/libatidaq-c.orig/samples/000077500000000000000000000000001304511007300210135ustar00rootroot00000000000000visp-3.0.1/3rdparty/libatidaq-c.orig/samples/calinfo.c000066400000000000000000000102631304511007300225740ustar00rootroot00000000000000/* ATIDAQ F/T C Library * v1.0.1 * Copyright (c) 2001 ATI Industrial Automation * * The MIT License * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR * OTHER DEALINGS IN THE SOFTWARE. */ /* calinfo.c - demonstrates retrieving information from the calibration file such as the transducer's rated loads, calibration date, and other information. */ #include #include #include "..\ATIDAQ\ftconfig.h" int main(int argc, char *argv[]) { char *calfilepath; // name of calibration file unsigned short index; // index of calibration in file (second parameter; default = 1) Calibration *cal; // struct containing calibration information unsigned short i,j; // loop variables // parse arguments switch (argc) { case 2: index=1; break; case 3: index=atoi(argv[2]); break; default: printf("\nUsage: calinfo [calfile] [index]\n"); printf(" [calfile]: path to calibration file\n"); printf(" [index] : index of calibration in file (default=1)\n"); scanf("."); return 0; } calfilepath=argv[1]; // create Calibration struct cal=createCalibration(calfilepath,index); if (cal==NULL) { printf("\nSpecified calibration could not be loaded.\n"); scanf("."); return 0; } // display info from calibration file printf("Calibration Information for %s, index #%i\n",calfilepath,index); printf(" Serial: %s\n",cal->Serial); printf(" Body Style: %s\n",cal->BodyStyle); printf(" Calibration: %s\n",cal->PartNumber); printf(" Calibration Date: %s\n",cal->CalDate); printf(" Family: %s\n",cal->Family); printf(" # Channels: %i\n",cal->rt.NumChannels); printf(" # Axes: %i\n",cal->rt.NumAxes); printf(" Force Units: %s\n",cal->ForceUnits); printf(" Torque Units: %s\n",cal->TorqueUnits); printf("Temperature Compensation: %s\n",(cal->TempCompAvailable ? "Yes" : "No")); // print maximum loads of axes printf("\nRated Loads\n"); for (i=0;irt.NumAxes;i++) { char *units; if ((cal->AxisNames[i])[0]=='F') { units=cal->ForceUnits; } else units=cal->TorqueUnits; printf("%s: %f %s\n",cal->AxisNames[i],cal->MaxLoads[i],units); } // print working calibration matrix printf("\nWorking Calibration Matrix\n"); printf(" "); for (i=0;irt.NumChannels-1;i++) printf("G%i ",i); printf("\n"); for (i=0;irt.NumAxes;i++) { printf("%s: ",cal->AxisNames[i]); for (j=0;jrt.NumChannels-1;j++) printf("%13.5e ",cal->rt.working_matrix[i][j]); printf("\n"); } // print temperature compensation information, if available if (cal->TempCompAvailable) { printf("\nTemperature Compensation Information\n"); printf("BS: "); for (i=0;irt.NumChannels-1;i++) { printf("%13.5e ",cal->rt.bias_slopes[i]); } printf("\nGS: "); for (i=0;irt.NumChannels-1;i++) { printf("%13.5e ",cal->rt.gain_slopes[i]); } printf("\nTherm: %f\n",cal->rt.thermistor); } // free memory allocated to Calibration structure destroyCalibration(cal); //wait for a keypress scanf("."); return 0; } visp-3.0.1/3rdparty/libatidaq-c.orig/samples/ftconvert.c000066400000000000000000000135671304511007300232050ustar00rootroot00000000000000/* ATIDAQ F/T C Library * v1.0.2 * Copyright (c) 2001 ATI Industrial Automation * * The MIT License * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR * OTHER DEALINGS IN THE SOFTWARE. */ /* ftconvert.c - demonstrates configuring a DAQ F/T system and performing force/torque calculations; converts a sample set of voltages into forces and torques. Sam Skuce - v.1.0.2 - February.19.2004 - added some comments just before the declaration of SampleBias explaining the difference between hardware and software temp comp */ #include #include #include "ftconfig.h" int main(int argc, char *argv[]) { char *calfilepath; // name of calibration file unsigned short index; // index of calibration in file (second parameter; default = 1) Calibration *cal; // struct containing calibration information unsigned short i; // loop variable used to print results short sts; // return value from functions // In this sample application, readings have been hard-coded for demonstration. // A working application would retrieve these vectors from a data acquisition system. // PLEASE NOTE: There are 7 elements in the bias and reading arrays. The first 6 are // the gage values you would retrieve from the transducer. The seventh represents the // thermistor gage, which is only meaningful if your sensor uses software temperature // compensation. If your sensor uses hardware temperature compensation (all sensors // sold after mid-2003 do), the last value is meaningless, and you can just use a 6 element // array. float SampleBias[7]={0.2651,-0.0177,-0.0384,-0.0427,-0.1891,0.1373,-3.2423}; float SampleReading[7]={-3.2863,0.3875,-3.4877,0.4043,-3.9341,0.5474,-3.2106}; // This sample transform includes a translation along the Z-axis and a rotation about the X-axis. float SampleTT[6]={0,0,20,45,0,0}; float FT[6]; // This array will hold the resultant force/torque vector. // parse arguments switch (argc) { case 2: index=1; break; case 3: index=atoi(argv[2]); break; default: printf("\nUsage: calinfo [calfile] [index]\n"); printf(" [calfile]: path to calibration file\n"); printf(" [index] : index of calibration in file (default=1)\n"); scanf("."); return 0; } calfilepath=argv[1]; // create Calibration struct cal=createCalibration(calfilepath,index); if (cal==NULL) { printf("\nSpecified calibration could not be loaded.\n"); scanf("."); return 0; } // Set force units. // This step is optional; by default, the units are inherited from the calibration file. sts=SetForceUnits(cal,"N"); switch (sts) { case 0: break; // successful completion case 1: printf("Invalid Calibration struct"); return 0; case 2: printf("Invalid force units"); return 0; default: printf("Unknown error"); return 0; } // Set torque units. // This step is optional; by default, the units are inherited from the calibration file. sts=SetTorqueUnits(cal,"N-m"); switch (sts) { case 0: break; // successful completion case 1: printf("Invalid Calibration struct"); return 0; case 2: printf("Invalid torque units"); return 0; default: printf("Unknown error"); return 0; } // Set tool transform. // This line is only required if you want to move or rotate the sensor's coordinate system. // This example tool transform translates the coordinate system 20 mm along the Z-axis // and rotates it 45 degrees about the X-axis. sts=SetToolTransform(cal,SampleTT,"mm","degrees"); switch (sts) { case 0: break; // successful completion case 1: printf("Invalid Calibration struct"); return 0; case 2: printf("Invalid distance units"); return 0; case 3: printf("Invalid angle units"); return 0; default: printf("Unknown error"); return 0; } // Temperature compensation is on by default if it is available. // To explicitly disable temperature compensation, uncomment the following code /*SetTempComp(cal,FALSE); // disable temperature compensation switch (sts) { case 0: break; // successful completion case 1: printf("Invalid Calibration struct"); return 0; case 2: printf("Temperature Compensation not available on this transducer"); return 0; default: printf("Unknown error"); return 0; }*/ // store an unloaded measurement; this removes the effect of tooling weight Bias(cal,SampleBias); // convert a loaded measurement into forces and torques ConvertToFT(cal,SampleReading,FT); // print results printf("Bias reading:\n"); for (i=0;i<7;i++) printf("%9.6f ",SampleBias[i]); printf("\nMeasurement:\n"); for (i=0;i<7;i++) printf("%9.6f ",SampleReading[i]); printf("\nResult:\n"); for (i=0;i<6;i++) printf("%9.6f ",FT[i]); // free memory allocated to Calibration structure destroyCalibration(cal); //wait for a keypress scanf("."); return 0; } visp-3.0.1/3rdparty/libatidaq-c.orig/samples/makefile000066400000000000000000000030171304511007300225140ustar00rootroot00000000000000#makefile for ftconvert and calinfo #use 'make ftconvert' to make ftconvert sample and 'make calinfo' to make calinfo #uses gcc, needs modifications for other compilers. object_compile = gcc -c exe_compile = gcc -o remove_command = rm ftconvert: ftconvert.o ftconfig.o ftrt.o dom.o expatls.o node.o stack.o xmlparse.o xmlrole.o xmltok.o $(exe_compile) ftconvert.exe ftconvert.o ftconfig.o ftrt.o dom.o expatls.o node.o stack.o xmlparse.o xmlrole.o xmltok.o ftconvert.o: ftconvert.c ../atidaq/ftconfig.h $(object_compile) ftconvert.c ftconfig.o: ../atidaq/ftconfig.c ../atidaq/ftconfig.h $(object_compile) ../atidaq/ftconfig.c ftrt.o: ../atidaq/ftrt.c ../atidaq/ftrt.h ../atidaq/ftsharedrt.h $(object_compile) ../atidaq/ftrt.c dom.o: ../atidaq/dom.c $(object_compile) ../atidaq/dom.c expatls.o: ../atidaq/expatls.c $(object_compile) ../atidaq/expatls.c node.o: ../atidaq/node.c $(object_compile) ../atidaq/node.c stack.o: ../atidaq/stack.c $(object_compile) ../atidaq/stack.c xmlparse.o: ../atidaq/xmlparse.c $(object_compile) ../atidaq/xmlparse.c xmlrole.o: ../atidaq/xmlrole.c $(object_compile) ../atidaq/xmlrole.c xmltok.o: ../atidaq/xmltok.c $(object_compile) ../atidaq/xmltok.c calinfo: calinfo.o ftconfig.o ftrt.o dom.o expatls.o node.o stack.o xmlparse.o xmlrole.o xmltok.o $(exe_compile) calinfo.exe calinfo.o ftconfig.o ftrt.o dom.o expatls.o node.o stack.o xmlparse.o xmlrole.o xmltok.o calinfo.o: calinfo.c ../atidaq/ftconfig.h $(object_compile) calinfo.c clean: $(remove_command) *.o *.exe visp-3.0.1/3rdparty/libatidaq-c/000077500000000000000000000000001304511007300164105ustar00rootroot00000000000000visp-3.0.1/3rdparty/libatidaq-c/CMakeLists.txt000066400000000000000000000022031304511007300211450ustar00rootroot00000000000000project(${ATIDAQ_LIBRARY}) vp_include_directories(${CMAKE_CURRENT_SOURCE_DIR}) file(GLOB lib_srcs *.c) file(GLOB lib_hdrs *.h) vp_list_filterout(lib_srcs xmltok_impl.c) vp_list_filterout(lib_hdrs xmltok_impl.h) vp_list_filterout(lib_srcs xmltok_ns.c) vp_list_filterout(lib_srcs events.c) add_library(${ATIDAQ_LIBRARY} STATIC ${lib_srcs} ${lib_hdrs}) if(CMAKE_COMPILER_IS_GNUCXX) set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fPIC") endif() if(ENABLE_SOLUTION_FOLDERS) set_target_properties(${ATIDAQ_LIBRARY} PROPERTIES FOLDER "3rdparty") endif() vp_warnings_disable(CMAKE_C_FLAGS -Wunused-parameter) if(ENABLE_SOLUTION_FOLDERS) set_target_properties(${ATIDAQ_LIBRARY} PROPERTIES FOLDER "3rdparty") endif() set_target_properties(${ATIDAQ_LIBRARY} PROPERTIES OUTPUT_NAME ${ATIDAQ_LIBRARY} DEBUG_POSTFIX "${VISP_DEBUG_POSTFIX}" COMPILE_PDB_NAME ${ATIDAQ_LIBRARY} COMPILE_PDB_NAME_DEBUG "${ATIDAQ_LIBRARY}${VISP_DEBUG_POSTFIX}" ARCHIVE_OUTPUT_DIRECTORY ${VISP_3P_LIBRARY_OUTPUT_PATH} ) if(NOT BUILD_SHARED_LIBS) vp_install_target(${ATIDAQ_LIBRARY} EXPORT VISPModules ARCHIVE DESTINATION ${VISP_3P_LIB_INSTALL_PATH} COMPONENT dev) endif() visp-3.0.1/3rdparty/libatidaq-c/ascii.h000066400000000000000000000056331304511007300176600ustar00rootroot00000000000000/* Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd * * The MIT License * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR * OTHER DEALINGS IN THE SOFTWARE. */ #define ASCII_A 0x41 #define ASCII_B 0x42 #define ASCII_C 0x43 #define ASCII_D 0x44 #define ASCII_E 0x45 #define ASCII_F 0x46 #define ASCII_G 0x47 #define ASCII_H 0x48 #define ASCII_I 0x49 #define ASCII_J 0x4A #define ASCII_K 0x4B #define ASCII_L 0x4C #define ASCII_M 0x4D #define ASCII_N 0x4E #define ASCII_O 0x4F #define ASCII_P 0x50 #define ASCII_Q 0x51 #define ASCII_R 0x52 #define ASCII_S 0x53 #define ASCII_T 0x54 #define ASCII_U 0x55 #define ASCII_V 0x56 #define ASCII_W 0x57 #define ASCII_X 0x58 #define ASCII_Y 0x59 #define ASCII_Z 0x5A #define ASCII_a 0x61 #define ASCII_b 0x62 #define ASCII_c 0x63 #define ASCII_d 0x64 #define ASCII_e 0x65 #define ASCII_f 0x66 #define ASCII_g 0x67 #define ASCII_h 0x68 #define ASCII_i 0x69 #define ASCII_j 0x6A #define ASCII_k 0x6B #define ASCII_l 0x6C #define ASCII_m 0x6D #define ASCII_n 0x6E #define ASCII_o 0x6F #define ASCII_p 0x70 #define ASCII_q 0x71 #define ASCII_r 0x72 #define ASCII_s 0x73 #define ASCII_t 0x74 #define ASCII_u 0x75 #define ASCII_v 0x76 #define ASCII_w 0x77 #define ASCII_x 0x78 #define ASCII_y 0x79 #define ASCII_z 0x7A #define ASCII_0 0x30 #define ASCII_1 0x31 #define ASCII_2 0x32 #define ASCII_3 0x33 #define ASCII_4 0x34 #define ASCII_5 0x35 #define ASCII_6 0x36 #define ASCII_7 0x37 #define ASCII_8 0x38 #define ASCII_9 0x39 #define ASCII_TAB 0x09 #define ASCII_SPACE 0x20 #define ASCII_EXCL 0x21 #define ASCII_QUOT 0x22 #define ASCII_AMP 0x26 #define ASCII_APOS 0x27 #define ASCII_MINUS 0x2D #define ASCII_PERIOD 0x2E #define ASCII_COLON 0x3A #define ASCII_SEMI 0x3B #define ASCII_LT 0x3C #define ASCII_EQUALS 0x3D #define ASCII_GT 0x3E #define ASCII_LSQB 0x5B #define ASCII_RSQB 0x5D #define ASCII_UNDERSCORE 0x5F visp-3.0.1/3rdparty/libatidaq-c/asciitab.h000066400000000000000000000054641304511007300203510ustar00rootroot00000000000000/* Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd * * The MIT License * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR * OTHER DEALINGS IN THE SOFTWARE. */ /* 0x00 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML, /* 0x04 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML, /* 0x08 */ BT_NONXML, BT_S, BT_LF, BT_NONXML, /* 0x0C */ BT_NONXML, BT_CR, BT_NONXML, BT_NONXML, /* 0x10 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML, /* 0x14 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML, /* 0x18 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML, /* 0x1C */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML, /* 0x20 */ BT_S, BT_EXCL, BT_QUOT, BT_NUM, /* 0x24 */ BT_OTHER, BT_PERCNT, BT_AMP, BT_APOS, /* 0x28 */ BT_LPAR, BT_RPAR, BT_AST, BT_PLUS, /* 0x2C */ BT_COMMA, BT_MINUS, BT_NAME, BT_SOL, /* 0x30 */ BT_DIGIT, BT_DIGIT, BT_DIGIT, BT_DIGIT, /* 0x34 */ BT_DIGIT, BT_DIGIT, BT_DIGIT, BT_DIGIT, /* 0x38 */ BT_DIGIT, BT_DIGIT, BT_COLON, BT_SEMI, /* 0x3C */ BT_LT, BT_EQUALS, BT_GT, BT_QUEST, /* 0x40 */ BT_OTHER, BT_HEX, BT_HEX, BT_HEX, /* 0x44 */ BT_HEX, BT_HEX, BT_HEX, BT_NMSTRT, /* 0x48 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, /* 0x4C */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, /* 0x50 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, /* 0x54 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, /* 0x58 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_LSQB, /* 0x5C */ BT_OTHER, BT_RSQB, BT_OTHER, BT_NMSTRT, /* 0x60 */ BT_OTHER, BT_HEX, BT_HEX, BT_HEX, /* 0x64 */ BT_HEX, BT_HEX, BT_HEX, BT_NMSTRT, /* 0x68 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, /* 0x6C */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, /* 0x70 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, /* 0x74 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, /* 0x78 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_OTHER, /* 0x7C */ BT_VERBAR, BT_OTHER, BT_OTHER, BT_OTHER, visp-3.0.1/3rdparty/libatidaq-c/dom.c000066400000000000000000000435441304511007300173450ustar00rootroot00000000000000/* domc document object model library in c * Copyright (c) 2001 Michael B. Allen * * The MIT License * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR * OTHER DEALINGS IN THE SOFTWARE. */ /* dom.c - document object model interface modifications: June.15.2005 - Sam Skuce (ATI Industrial Automation) and Gabriel Baud-Bovy - moved definition of DOM_Exception into dom.c from dom.h. */ #include #include #include #include #include "dom.h" unsigned short DOM_Exception; // GBB: used to be in dom.h (now defined as extern) /* prototypes required for node.c */ DOM_Node *Document_createNode(DOM_Document *doc, unsigned short nodeType); NodeEntry *NodeList_remove(DOM_NodeList *nl, DOM_Node *oldChild); NodeEntry *NodeList_append(DOM_NodeList *nl, DOM_Node *newChild); DOM_NodeList *Document_createNodeList(DOM_Document *doc); DOM_NamedNodeMap *Document_createNamedNodeMap(DOM_Document *doc); /* DOM_Exception */ //DBL unsigned short DOM_Exception; DOM_String * DOM_Exception_message(unsigned short exception) { switch (exception) { case DOM_NO_ERR: return "The operation was successfull."; case DOM_INDEX_SIZE_ERR: return "The index specified was out of range."; case DOM_HIERARCHY_REQUEST_ERR: return "The request violated tree hierarchy constraints."; case DOM_WRONG_DOCUMENT_ERR: return "The document context is invalid."; case DOM_INVALID_CHARACTER_ERR: return "An inappropriate character was encountered."; case DOM_NOT_FOUND_ERR: return "The specified node was not found."; case DOM_NOT_SUPPORTED_ERR: return "The requested operation is not supported."; case DOM_INUSE_ATTRIBUTE_ERR: return "The attribute is being used elsewhere."; case DOM_NO_MEMORY_ERR: return "No memory is available."; case DOM_NULL_POINTER_ERR: return "A parameter was null."; case DOM_SYSTEM_ERR: return "An external function error occured."; case DOM_XML_PARSER_ERR: return "An XML parser error occured."; case DOM_DOMSTRING_SIZE_ERR: case DOM_NO_DATA_ALLOWED_ERR: case DOM_NO_MODIFICATION_ALLOWED_ERR: break; } return "No description available."; } /* DOM_Implementation and DOM_ImplementationLS */ int DOM_Implementation_hasFeature(DOM_String *feature, DOM_String *version) { if (DOM_String_cmp(feature, "XML") == 0 && (version == NULL || version[0] == '\0' || DOM_String_cmp(version, "1.0"))) { return 1; } return 0; } DOM_DocumentType * DOM_Implementation_createDocumentType(DOM_String *qualifiedName, DOM_String *publicId, DOM_String systemId) { return NULL; } DOM_Document * DOM_Implementation_createDocument(DOM_String *namespaceURI, DOM_String *qualifiedName, DOM_DocumentType *doctype) { DOM_Document *doc; doc = Document_createNode(NULL, DOM_DOCUMENT_NODE); if (doc) { doc->nodeName = "#document"; } return doc; } DOM_String * DOM_Element_getAttribute(const DOM_Element *element, const DOM_String *name) { DOM_Node *node; DOM_String *r = NULL; if (element && name && element->attributes) { if ((node = DOM_NamedNodeMap_getNamedItem(element->attributes, name))) { r = DOM_String_dup(node->nodeValue); } else { r = DOM_String_dup(""); } if (r == NULL) { DOM_Exception = DOM_NO_MEMORY_ERR; return NULL; } } return r; } void DOM_Element_setAttribute(DOM_Element *element, const DOM_String *name, const DOM_String *value) { if (element && name && value && element->attributes) { DOM_Attr *attr; attr = DOM_NamedNodeMap_getNamedItem(element->attributes, name); if (attr) { free(attr->nodeValue); attr->nodeValue = attr->u.Attr.value = DOM_String_dup(value); if (attr->nodeValue) { } else { DOM_Exception = DOM_NO_MEMORY_ERR; DOM_Document_destroyNode(attr->ownerDocument, attr); } } else { attr = DOM_Document_createAttribute(element->ownerDocument, name); if (attr) { free(attr->nodeValue); attr->nodeValue = attr->u.Attr.value = DOM_String_dup(value); if (attr->nodeValue) { DOM_NamedNodeMap_setNamedItem(element->attributes, attr); } else { DOM_Exception = DOM_NO_MEMORY_ERR; DOM_Document_destroyNode(attr->ownerDocument, attr); } } } } } void DOM_Element_removeAttribute(DOM_Element *element, const DOM_String *name) { if (element && name) { DOM_Attr *attr = DOM_NamedNodeMap_removeNamedItem(element->attributes, name); if (attr) { DOM_Document_destroyNode(attr->ownerDocument, attr); } } } DOM_Attr * DOM_Element_getAttributeNode(const DOM_Element *element, const DOM_String *name) { if (element && name) { return DOM_NamedNodeMap_getNamedItem(element->attributes, name); } return NULL; } DOM_Attr * DOM_Element_setAttributeNode(DOM_Element *element, DOM_Attr *newAttr) { if (element && newAttr) { return DOM_NamedNodeMap_setNamedItem(element->attributes, newAttr); } return NULL; } DOM_Attr * DOM_Element_removeAttributeNode(DOM_Element *element, DOM_Attr *oldAttr) { if (element && oldAttr && NodeList_remove(element->attributes, oldAttr)) { return oldAttr; } return NULL; } void preorderTraversal(DOM_NodeList *list, DOM_Node *node, const DOM_String *tagname) { DOM_Node *n; if (list && node && tagname) { if (DOM_String_cmp(tagname, node->nodeName) == 0) { NodeList_append(list, node); } for (n = node->firstChild; n != NULL; n = n->nextSibling) { preorderTraversal(list, n, tagname); } } } DOM_NodeList * DOM_Element_getElementsByTagName(DOM_Element *element, const DOM_String *name) { DOM_NodeList *list; if (element && name && (list = Document_createNodeList(element->ownerDocument))) { preorderTraversal(list, element, name); return list; } return NULL; } void DOM_Element_normalize(DOM_Element *element) { DOM_Node *node; DOM_Text *last = NULL; if (element) { for (node = element->firstChild; node != NULL; node = node->nextSibling) { if (node->nodeType == DOM_TEXT_NODE) { if (last) { DOM_CharacterData_insertData(node, 0, last->nodeValue); DOM_Node_removeChild(element, last); DOM_Document_destroyNode(last->ownerDocument, last); if (DOM_Exception) { return; } } last = node; } else { last = NULL; DOM_Element_normalize(node); } } } } DOM_String * DOM_CharacterData_substringData(DOM_CharacterData *data, unsigned long offset, unsigned long count) { DOM_String *sub; unsigned long dlen; if (data == NULL) { DOM_Exception = DOM_NULL_POINTER_ERR; return NULL; } if ((dlen = offset) >= data->u.CharacterData.length) { DOM_Exception = DOM_INDEX_SIZE_ERR; return NULL; } if (count > dlen || (offset + count) > dlen) { count = dlen - offset; } sub = malloc(count + 1); if (sub) { memcpy(sub, data->nodeValue + offset, count); sub[count] = '\0'; } else { DOM_Exception = DOM_NO_MEMORY_ERR; } return sub; } void DOM_CharacterData_appendData(DOM_CharacterData *data, const DOM_String *arg) { DOM_String *str; DOM_String *tmp; unsigned long dlen, alen, tot; if (data == NULL) { DOM_Exception = DOM_NULL_POINTER_ERR; return; } if (arg) { dlen = data->u.CharacterData.length; alen = (unsigned long) DOM_String_len(arg); tot = dlen + alen; if ((str = malloc(tot + 1)) == NULL) { DOM_Exception = DOM_NO_MEMORY_ERR; return; } memcpy(str, data->nodeValue, dlen); memcpy(str + dlen, arg, alen); str[tot] = '\0'; tmp = data->nodeValue; data->nodeValue = data->u.CharacterData.data = str; data->u.CharacterData.length = tot; free(tmp); } } void DOM_CharacterData_insertData(DOM_CharacterData *data, unsigned long offset, const DOM_String *arg) { DOM_String *str; DOM_String *tmp; unsigned long dlen, alen, tot; if (data == NULL) { DOM_Exception = DOM_NULL_POINTER_ERR; return; } if (arg) { if (offset >= (dlen = data->u.CharacterData.length)) { DOM_Exception = DOM_INDEX_SIZE_ERR; return; } alen = (unsigned long) DOM_String_len(arg); tot = dlen + alen; if ((str = malloc(tot + 1)) == NULL) { DOM_Exception = DOM_NO_MEMORY_ERR; return; } memcpy(str, data->nodeValue, offset); memcpy(str + offset, arg, alen); memcpy(str + offset + alen, data->nodeValue + offset, dlen - offset); str[tot] = '\0'; tmp = data->nodeValue; data->nodeValue = data->u.CharacterData.data = str; data->u.CharacterData.length = tot; free(tmp); } } void DOM_CharacterData_deleteData(DOM_CharacterData *data, unsigned long offset, unsigned long count) { DOM_String *str; DOM_String *tmp; unsigned long dlen, tot, left; if (data == NULL) { DOM_Exception = DOM_NULL_POINTER_ERR; return; } if (offset < (dlen = data->u.CharacterData.length)) { DOM_Exception = DOM_INDEX_SIZE_ERR; return; } if (count > dlen || (offset + count) > dlen) { count = dlen - offset; } tot = dlen - count; left = dlen - offset - count; if ((str = malloc(tot + 1)) == NULL) { DOM_Exception = DOM_NO_MEMORY_ERR; return; } memcpy(str, data->nodeValue, offset); memcpy(str + offset, data->nodeValue + offset + count, left); str[tot] = '\0'; tmp = data->nodeValue; data->nodeValue = data->u.CharacterData.data = str; data->u.CharacterData.length = tot; free(tmp); } void DOM_CharacterData_replaceData(DOM_CharacterData *data, unsigned long offset, unsigned long count, const DOM_String *arg) { DOM_CharacterData_deleteData(data, offset, count); DOM_CharacterData_insertData(data, offset, arg); } DOM_Text * DOM_Text_splitText(DOM_Text *text, unsigned long offset) { DOM_Text *node; if (text && text->parentNode) { node = DOM_Document_createTextNode(text->ownerDocument, text->nodeValue + offset); if (node) { DOM_CharacterData_deleteData(text, offset, LONG_MAX); DOM_Node_insertBefore(text->parentNode, node, text->nextSibling); return node; } } return NULL; } DOM_Element * DOM_Document_createElement(DOM_Document *doc, const DOM_String *tagName) { DOM_Element *element; element = Document_createNode(doc, DOM_ELEMENT_NODE); if (element) { element->nodeName = element->u.Element.tagName = DOM_String_dup(tagName); element->attributes = Document_createNamedNodeMap(doc); if (element->nodeName == NULL || element->attributes == NULL) { DOM_Exception = DOM_NO_MEMORY_ERR; DOM_Document_destroyNode(doc, element); return NULL; } } return element; } DOM_DocumentFragment * DOM_Document_createDocumentFragment(DOM_Document *doc) { DOM_DocumentFragment *frag; frag = Document_createNode(doc, DOM_DOCUMENT_FRAGMENT_NODE); if (frag) { frag->nodeName = "#document-fragment"; } return frag; } DOM_Text * DOM_Document_createTextNode(DOM_Document *doc, const DOM_String *data) { DOM_Text *text; text = Document_createNode(doc, DOM_TEXT_NODE); if (text) { text->nodeName = "#text"; text->nodeValue = text->u.CharacterData.data = DOM_String_dup(data); if (text->nodeValue == NULL) { DOM_Exception = DOM_NO_MEMORY_ERR; DOM_Document_destroyNode(doc, text); return NULL; } text->u.CharacterData.length = (unsigned long) DOM_String_len(data); } return text; } DOM_Comment * DOM_Document_createComment(DOM_Document *doc, const DOM_String *data) { DOM_Comment *comment; comment = Document_createNode(doc, DOM_COMMENT_NODE); if (comment) { comment->nodeName = "#comment"; comment->nodeValue = comment->u.CharacterData.data = DOM_String_dup(data); if (comment->nodeValue == NULL) { DOM_Exception = DOM_NO_MEMORY_ERR; DOM_Document_destroyNode(doc, comment); return NULL; } comment->u.CharacterData.length = (unsigned long) DOM_String_len(data); } return comment; } DOM_CDATASection * DOM_Document_createCDATASection(DOM_Document *doc, const DOM_String *data) { DOM_CDATASection *cdata; cdata = Document_createNode(doc, DOM_CDATA_SECTION_NODE); if (cdata) { cdata->nodeName = "#cdata-section"; cdata->nodeValue = cdata->u.CharacterData.data = DOM_String_dup(data); if (cdata->u.CharacterData.data == NULL) { DOM_Exception = DOM_NO_MEMORY_ERR; DOM_Document_destroyNode(doc, cdata); return NULL; } cdata->u.CharacterData.length = (unsigned long) DOM_String_len(data); } return cdata; } DOM_ProcessingInstruction * DOM_Document_createProcessingInstruction(DOM_Document *doc, const DOM_String *target, const DOM_String *data) { DOM_ProcessingInstruction *pi; pi = Document_createNode(doc, DOM_PROCESSING_INSTRUCTION_NODE); if (pi) { pi->nodeName = pi->u.ProcessingInstruction.target = DOM_String_dup(target); pi->nodeValue = pi->u.ProcessingInstruction.data = DOM_String_dup(data); if (pi->nodeName == NULL || pi->nodeValue == NULL) { DOM_Exception = DOM_NO_MEMORY_ERR; DOM_Document_destroyNode(doc, pi); return NULL; } } return pi; } DOM_Attr * DOM_Document_createAttribute(DOM_Document *doc, const DOM_String *name) { DOM_Attr *attr; attr = Document_createNode(doc, DOM_ATTRIBUTE_NODE); if (attr) { attr->nodeName = attr->u.Attr.name = DOM_String_dup(name); attr->nodeValue = attr->u.Attr.value = DOM_String_dup(""); if (attr->nodeName == NULL || attr->nodeValue == NULL) { DOM_Exception = DOM_NO_MEMORY_ERR; DOM_Document_destroyNode(doc, attr); return NULL; } } return attr; } DOM_EntityReference * DOM_Docuement_createEntityReference(DOM_Document *doc, const DOM_String *name) { DOM_EntityReference *eref; eref = Document_createNode(doc, DOM_ENTITY_REFERENCE_NODE); return eref; } DOM_NodeList * DOM_Document_getElementsByTagName(DOM_Document *doc, const DOM_String *tagname) { if (doc && tagname) { return DOM_Element_getElementsByTagName(doc->u.Document.documentElement, tagname); } return NULL; } /* Temporary functions */ void DOM_Node_printNode(DOM_Node *node) { if (node == NULL) { printf("node was null\n"); return; } printf("nodeName=%s,nodeValue=%s,", node->nodeName, node->nodeValue); switch (node->nodeType) { case DOM_ELEMENT_NODE: printf("type=DOM_ELEMENT_NODE"); break; case DOM_ATTRIBUTE_NODE: printf("type=DOM_ATTRIBUTE_NODE"); break; case DOM_TEXT_NODE: printf("type=DOM_TEXT_NODE"); break; case DOM_CDATA_SECTION_NODE: printf("type=DOM_CDATA_SECTION_NODE"); break; case DOM_ENTITY_REFERENCE_NODE: printf("type=DOM_ENTITY_REFERENCE_NODE"); break; case DOM_ENTITY_NODE: printf("type=DOM_ENTITY_NODE"); break; case DOM_PROCESSING_INSTRUCTION_NODE: printf("type=DOM_PROCESSING_INSTRUCTION_NODE"); break; case DOM_COMMENT_NODE: printf("type=DOM_COMMENT_NODE"); break; case DOM_DOCUMENT_NODE: printf("type=DOM_DOCUMENT_NODE"); break; case DOM_DOCUMENT_TYPE_NODE: printf("type=DOM_DOCUMENT_TYPE_NODE"); break; case DOM_DOCUMENT_FRAGMENT_NODE: printf("type=DOM_DOCUMENT_FRAGMENT_NODE"); break; case DOM_NOTATION_NODE: printf("type=DOM_NOTATION_NODE"); break; } printf(",parentNode->nodeName=%s,firstChild->nodeName=%s", (node->parentNode == NULL ? "(null)" : node->parentNode->nodeName), (node->firstChild == NULL ? "(null)" : node->firstChild->nodeName)); printf(",lastChild->nodeName=%s,childNodes->length=%lu", (node->lastChild == NULL ? "(null)" : node->lastChild->nodeName), (node->childNodes == NULL ? 0 : node->childNodes->length)); printf(",previousSibling->nodeName=%s,nextSibling->nodeName=%s,attributes->length=%lu\n", (node->previousSibling == NULL ? "(null)" : node->previousSibling->nodeName), (node->nextSibling == NULL ? "(null)": node->nextSibling->nodeName), (node->attributes == NULL ? 0 : node->attributes->length)); fflush(stdout); } //ATI_strdup added by DBL char *ATI_strdup(const char *s) { // Returns a pointer to a copy of the string s size_t t; char *p; t=strlen(s)+1; // add one for termination character p = malloc(sizeof(char) * t); if (p==NULL) return p; *p='\0'; strcat(p,s); return p; } visp-3.0.1/3rdparty/libatidaq-c/dom.h000066400000000000000000000332211304511007300173410ustar00rootroot00000000000000/* domc document object model library in c * Copyright (c) 2001 Michael B. Allen * * The MIT License * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR * OTHER DEALINGS IN THE SOFTWARE. */ /* dom.h - document object model interface modifications: june.15.2005 - Sam Skuce (ATI Industrial Automation) and Gabriel Baud-Bovy - changed DOM_Exception to an extern to avoid redefinition problems */ #ifndef DOM_H #define DOM_H #include #include #include /* DOM_String */ typedef char DOM_String; #define DOM_String_dup ATI_strdup // changed from strdup to ATI_strdup by DBL char *ATI_strdup(const char *s); // line added by DBL #define DOM_String_len strlen #define DOM_String_cmp strcmp /* DOM_TimeStamp - Introduced in DOM Level 2 */ typedef time_t DOM_TimeStamp; /* DOM_Exception */ extern unsigned short DOM_Exception; // GBB: added extern (declaration moved in dom.c) #define DOM_NO_ERR 0 #define DOM_INDEX_SIZE_ERR 1 #define DOM_DOMSTRING_SIZE_ERR 2 #define DOM_HIERARCHY_REQUEST_ERR 3 #define DOM_WRONG_DOCUMENT_ERR 4 #define DOM_INVALID_CHARACTER_ERR 5 #define DOM_NO_DATA_ALLOWED_ERR 6 #define DOM_NO_MODIFICATION_ALLOWED_ERR 7 #define DOM_NOT_FOUND_ERR 8 #define DOM_NOT_SUPPORTED_ERR 9 #define DOM_INUSE_ATTRIBUTE_ERR 10 #define DOM_NO_MEMORY_ERR 11 #define DOM_NULL_POINTER_ERR 12 #define DOM_SYSTEM_ERR 13 #define DOM_XML_PARSER_ERR 14 DOM_String *DOM_Exception_message(unsigned short); /* DOM_EventException - Introduced in DOM Level 2 */ extern unsigned short DOM_EventException; #define DOM_UNSPECIFIED_EVENT_TYPE_ERR 0 /* DOM_Node */ typedef struct DOM_Node DOM_Node; typedef struct DOM_NodeList DOM_NodeList; typedef struct DOM_NodeList DOM_NamedNodeMap; typedef struct NodeEntry NodeEntry; typedef DOM_Node DOM_Attr; typedef DOM_Node DOM_Element; typedef DOM_Node DOM_CharacterData; typedef DOM_CharacterData DOM_Text; typedef DOM_CharacterData DOM_Comment; typedef DOM_Text DOM_CDATASection; typedef DOM_Node DOM_DocumentType; typedef DOM_Node DOM_Notation; typedef DOM_Node DOM_Entity; typedef DOM_Node DOM_EntityReference; typedef DOM_Node DOM_ProcessingInstruction; typedef DOM_Node DOM_DocumentFragment; typedef DOM_Node DOM_Document; typedef DOM_Document DOM_DocumentLS; /* Introduced in DOM Level 2: */ typedef DOM_Node DOM_EventTarget; typedef struct ListenerEntry ListenerEntry; typedef DOM_Document DOM_DocumentEvent; typedef DOM_Document DOM_AbstractView; typedef DOM_Document DOM_DocumentView; #define DOM_ELEMENT_NODE 1 #define DOM_ATTRIBUTE_NODE 2 #define DOM_TEXT_NODE 3 #define DOM_CDATA_SECTION_NODE 4 #define DOM_ENTITY_REFERENCE_NODE 5 #define DOM_ENTITY_NODE 6 #define DOM_PROCESSING_INSTRUCTION_NODE 7 #define DOM_COMMENT_NODE 8 #define DOM_DOCUMENT_NODE 9 #define DOM_DOCUMENT_TYPE_NODE 10 #define DOM_DOCUMENT_FRAGMENT_NODE 11 #define DOM_NOTATION_NODE 12 /* events forward references - Introduced in DOM Level 2 */ typedef struct DOM_Event DOM_Event; typedef struct DOM_Event DOM_UIEvent; typedef DOM_UIEvent DOM_KeyEvent; typedef struct DOM_Event DOM_MutationEvent; typedef void (*DOM_EventListener)(DOM_Event *evt); struct ListenerEntry { DOM_String *type; DOM_EventListener listener_fn; int useCapture; }; struct DOM_Node { DOM_String *nodeName; DOM_String *nodeValue; unsigned short nodeType; DOM_Node *parentNode; DOM_NodeList *childNodes; DOM_Node *firstChild; DOM_Node *lastChild; DOM_Node *previousSibling; DOM_Node *nextSibling; DOM_NamedNodeMap *attributes; DOM_Document *ownerDocument; /* Custom Fields */ void *userPtr; unsigned int listeners_len; ListenerEntry **listeners; union { struct { DOM_String *name; int specified; DOM_String *value; } Attr; struct { DOM_String *tagName; } Element; struct { DOM_String *name; DOM_NamedNodeMap *entities; DOM_NamedNodeMap *notations; } DocumentType; struct { DOM_String *data; unsigned long length; } CharacterData; struct { DOM_String *publicId; DOM_String *systemId; } Notation; struct { DOM_String *publicId; DOM_String *systemId; DOM_String *notationName; } Entity; struct { DOM_String *target; DOM_String *data; } ProcessingInstruction; struct { DOM_DocumentType *doctype; DOM_Element *documentElement; /* DOM_Document implements both DOM_DocumentView and DOM_AbstractView? */ DOM_DocumentView *document; DOM_AbstractView *defaultView; } Document; } u; }; DOM_Node *DOM_Node_insertBefore(DOM_Node *node, DOM_Node *newChild, DOM_Node *refChild); DOM_Node *DOM_Node_replaceChild(DOM_Node *node, DOM_Node *newChild, DOM_Node *oldChild); DOM_Node *DOM_Node_removeChild(DOM_Node *node, DOM_Node *oldChild); DOM_Node *DOM_Node_appendChild(DOM_Node *node, DOM_Node *newChild); int DOM_Node_hasChildNodes(const DOM_Node *node); DOM_Node *DOM_Node_cloneNode(DOM_Node *node, int deep); /* DOM_NodeList, DOM_NamedNodeMap */ struct NodeEntry { NodeEntry *prev; NodeEntry *next; DOM_Node *node; }; struct DOM_NodeList { unsigned long length; NodeEntry *first; NodeEntry *last; }; DOM_Node *DOM_NodeList_item(const DOM_NodeList *nl, unsigned long index); DOM_Node *DOM_NamedNodeMap_getNamedItem(const DOM_NamedNodeMap *map, const DOM_String *name); DOM_Node *DOM_NamedNodeMap_setNamedItem(DOM_NamedNodeMap *map, DOM_Node *arg); DOM_Node *DOM_NamedNodeMap_removeNamedItem(DOM_NamedNodeMap *map, const DOM_String *name); DOM_Node *DOM_NamedNodeMap_item(const DOM_NamedNodeMap *map, unsigned long index); /* DOM_Implementation */ int DOM_Implementation_hasFeature(DOM_String *feature, DOM_String *version); DOM_DocumentType *DOM_Implementation_createDocumentType(DOM_String *qualifiedName, DOM_String *publicId, DOM_String systemId); DOM_Document *DOM_Implementation_createDocument(DOM_String *namespaceURI, DOM_String *qualifiedName, DOM_DocumentType *doctype); /* DOM_Element */ DOM_String *DOM_Element_getAttribute(const DOM_Element *element, const DOM_String *name); void DOM_Element_setAttribute(DOM_Element *element, const DOM_String *name, const DOM_String *value); void DOM_Element_removeAttribute(DOM_Element *element, const DOM_String *name); DOM_Attr *DOM_Element_getAttributeNode(const DOM_Element *element, const DOM_String *name); DOM_Attr *DOM_Element_setAttributeNode(DOM_Element *element, DOM_Attr *newAttr); DOM_Attr *DOM_Element_removeAttributeNode(DOM_Element *element, DOM_Attr *oldAttr); DOM_NodeList *DOM_Element_getElementsByTagName(DOM_Element *element, const DOM_String *name); void DOM_Element_normalize(DOM_Element *element); /* DOM_CharacterData */ DOM_String *DOM_CharacterData_substringData(DOM_CharacterData *data, unsigned long offset, unsigned long count); void DOM_CharacterData_appendData(DOM_CharacterData *data, const DOM_String *arg); void DOM_CharacterData_insertData(DOM_CharacterData *data, unsigned long offset, const DOM_String *arg); void DOM_CharacterData_deleteData(DOM_CharacterData *data, unsigned long offset, unsigned long count); void DOM_CharacterData_replaceData(DOM_CharacterData *data, unsigned long offset, unsigned long count, const DOM_String *arg); /* DOM_Text */ DOM_Text *DOM_Text_splitText(DOM_Text *text, unsigned long offset); /* DOM_Document */ DOM_Element *DOM_Document_createElement(DOM_Document *doc, const DOM_String *tagName); DOM_DocumentFragment *DOM_Document_createDocumentFragment(DOM_Document *doc); DOM_Text *DOM_Document_createTextNode(DOM_Document *doc, const DOM_String *data); DOM_Comment *DOM_Document_createComment(DOM_Document *doc, const DOM_String *data); DOM_CDATASection *DOM_Document_createCDATASection(DOM_Document *doc, const DOM_String *data); DOM_ProcessingInstruction *DOM_Document_createProcessingInstruction(DOM_Document *doc, const DOM_String *target, const DOM_String *data); DOM_Attr *DOM_Document_createAttribute(DOM_Document *doc, const DOM_String *name); DOM_EntityReference *DOM_Docuement_createEntityReference(DOM_Document *doc, const DOM_String *name); DOM_NodeList *DOM_Document_getElementsByTagName(DOM_Document *doc, const DOM_String *tagname); void DOM_Document_destroyNode(DOM_Document *doc, DOM_Node *node); void DOM_Document_destroyNodeList(DOM_Document *doc, DOM_NodeList *nl, int free_nodes); void DOM_Document_destroyNamedNodeMap(DOM_Document *doc, DOM_NamedNodeMap *nnm, int free_nodes); /* DOM_DocumentLS - Based roughly on Load and Save WD * http://www.w3.org/TR/2001/WD-DOM-Level-3-ASLS-20010607/load-save.html */ int DOM_DocumentLS_load(DOM_DocumentLS *doc, const DOM_String *uri); int DOM_DocumentLS_save(DOM_DocumentLS *doc, const DOM_String *uri, const DOM_Node *node); /* Events - Introduced in DOM Level 2 * http://www.w3.org/TR/2000/REC-DOM-Level-2-Events-20001113/events.html */ /* DOM_Event - Introduced in DOM Level 2 */ #define DOM_EVENT_CAPTURING_PHASE 1 #define DOM_EVENT_AT_TARGET 2 #define DOM_EVENT_BUBBLING_PHASE 3 struct DOM_Event { DOM_String *type; DOM_EventTarget *target; DOM_EventTarget *currentTarget; unsigned short eventPhase; int bubbles; int cancelable; DOM_TimeStamp timeStamp; /* custom -- do not touch */ int pd; int sp; /* UIEvent members */ DOM_AbstractView *view; long detail; union { struct { DOM_String *outputString; unsigned long keyVal; unsigned long virtKeyVal; int inputGenerated; int numPad; } KeyEvent; //DBL struct { /* maybe later */ //DBL } MouseEvent; struct { DOM_Node *relatedNode; DOM_String *prevValue; DOM_String *newValue; DOM_String *attName; unsigned short attrChange; } MutationEvent; } u; }; void DOM_Event_stopPropagation(DOM_Event *evt); void DOM_Event_preventDefault(DOM_Event *evt); void DOM_Event_initEvent(DOM_Event *evt, const DOM_String *eventTypeArg, int canBubbleArg, int cancelableArg); /* DOM_DocumentEvent - Introduced in DOM Level 2 */ DOM_Event *DOM_DocumentEvent_createEvent(DOM_DocumentEvent *doc, const DOM_String *eventType); void DOM_DocumentEvent_destroyEvent(DOM_DocumentEvent *doc, DOM_Event *evt); /* DOM_UIEvent */ void DOM_UIEvent_initUIEvent(DOM_UIEvent *evt, DOM_String *typeArg, int canBubbleArg, int cancelableArg, DOM_AbstractView *viewArg, long detailArg); /* DOM_EventTarget - Introduced in DOM Level 2 */ void DOM_EventTarget_addEventListener(DOM_EventTarget *target, const DOM_String *type, DOM_EventListener listener, int useCapture); void DOM_EventTarget_removeEventListener(DOM_EventTarget *target, const DOM_String *type, DOM_EventListener listener, int useCapture); int DOM_EventTarget_dispatchEvent(DOM_EventTarget *target, DOM_Event *evt); /* DOM_KeyEvent - Introduced in DOM Level 3 * http://www.w3.org/TR/2001/WD-DOM-Level-3-Events-20010410/events.html */ int DOM_KeyEvent_checkModifier(unsigned long modifier); void DOM_KeyEvent_initKeyEvent(DOM_KeyEvent *evt, const DOM_String *typeArg, int canBubbleArg, int cancelableArg, DOM_AbstractView *viewArg, unsigned short detailArg, DOM_String *outputStringArg, unsigned long keyValArg, unsigned long virtKeyValArg, int inputGeneratedArg, int numPadArg); void DOM_KeyEvent_initModifier(unsigned long modifier, int value); /* MutationEvent */ #define DOM_MUTATION_EVENT_MODIFICATION 1 #define DOM_MUTATION_EVENT_ADDITION 2 #define DOM_MUTATION_EVENT_REMOVAL 3 void DOM_MutationEvent_initMutationEvent(DOM_MutationEvent *evt, DOM_String *typeArg, int canBubbleArg, int cancelableArg, DOM_Node *relatedNodeArg, DOM_String *prevValueArg, DOM_String *newValueArg, DOM_String *attrNameArg, unsigned short attrChangeArg); /* Temporary Functions */ void DOM_Node_printNode(DOM_Node *node); char *target2str(char *buf, DOM_EventTarget *target); #endif /* DOM_H */ visp-3.0.1/3rdparty/libatidaq-c/events.c000066400000000000000000000237411304511007300200670ustar00rootroot00000000000000/* domc document object model library in c * Copyright (c) 2001 Michael B. Allen * * The MIT License * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR * OTHER DEALINGS IN THE SOFTWARE. */ /* events.c */ #include #include #include "dom.h" /* DOM_EventException */ unsigned short DOM_EventException; /* DOM_DocumentEvent - Introduced in DOM Level 2 */ void DOM_DocumentEvent_destroyEvent(DOM_DocumentEvent *doc, DOM_Event *evt) { if (doc && evt) { if (evt->type) { free(evt->type); } free(evt); } } DOM_Event * DOM_DocumentEvent_createEvent(DOM_DocumentEvent *doc, const DOM_String *eventType) { DOM_Event *evt; if (doc == NULL || eventType == NULL) { DOM_Exception = DOM_NULL_POINTER_ERR; return NULL; } if (DOM_String_cmp(eventType, "Events") == 0 || DOM_String_cmp(eventType, "UIEvents") == 0 || DOM_String_cmp(eventType, "KeyEvents") == 0) { evt = calloc(sizeof *evt, 1); if (evt == NULL) { DOM_Exception = DOM_NO_MEMORY_ERR; return NULL; } } else { DOM_Exception = DOM_NOT_SUPPORTED_ERR; return NULL; } return evt; } /* DOM_Event - Introduced in DOM Level 2 */ void DOM_Event_stopPropagation(DOM_Event *evt) { if (evt) { evt->sp = 1; } } void DOM_Event_preventDefault(DOM_Event *evt) { if (evt && evt->cancelable) { evt->pd = 1; } } void DOM_Event_initEvent(DOM_Event *evt, const DOM_String *eventTypeArg, int canBubbleArg, int cancelableArg) { if (evt == NULL || eventTypeArg == NULL) { DOM_Exception = DOM_NULL_POINTER_ERR; return; } if (evt->type) { free(evt->type); } evt->type = DOM_String_dup(eventTypeArg); if (evt->type == NULL) { DOM_Exception = DOM_NO_MEMORY_ERR; return; } evt->bubbles = canBubbleArg; evt->cancelable = cancelableArg; } /* DOM_UIEvent */ void DOM_UIEvent_initUIEvent(DOM_UIEvent *evt, DOM_String *typeArg, int canBubbleArg, int cancelableArg, DOM_AbstractView *viewArg, long detailArg) { DOM_Event_initEvent(evt, typeArg, canBubbleArg, cancelableArg); if (DOM_Exception) { return; } evt->view = viewArg; evt->detail = detailArg; } /* DOM_EventTarget - Introduced in DOM Level 2 */ void DOM_EventTarget_addEventListener(DOM_EventTarget *target, const DOM_String *type, DOM_EventListener listener, int useCapture) { ListenerEntry *e; unsigned int i, opos = -1; if (target == NULL || type == NULL || listener == NULL) { DOM_Exception = DOM_NULL_POINTER_ERR; return; } for (i = 0; i < target->listeners_len; i++) { e = target->listeners[i]; /* skip duplicates */ if (e == NULL) { if (opos == -1) { opos = i; /* find open position for new entry */ } } else if (e->listener_fn == listener && e->useCapture == useCapture && DOM_String_cmp(e->type, type) == 0) { return; } } if ((e = malloc(sizeof *e)) == NULL || (e->type = DOM_String_dup(type)) == NULL) { DOM_Exception = DOM_NO_MEMORY_ERR; free(e); return; } e->listener_fn = listener; e->useCapture = useCapture; if (opos == -1) { target->listeners = realloc(target->listeners, sizeof *e * (target->listeners_len + 1)); if (target->listeners == NULL) { DOM_Exception = DOM_NO_MEMORY_ERR; free(e); return; } target->listeners[target->listeners_len++] = e; } else { target->listeners[opos] = e; } } void DOM_EventTarget_removeEventListener(DOM_EventTarget *target, const DOM_String *type, DOM_EventListener listener, int useCapture) { ListenerEntry *e; unsigned int i; if (target == NULL || type == NULL || listener == NULL) { DOM_Exception = DOM_NULL_POINTER_ERR; return; } for (i = 0; i < target->listeners_len; i++) { e = target->listeners[i]; if (e && e->listener_fn == listener && e->useCapture == useCapture && DOM_String_cmp(e->type, type) == 0) { target->listeners[i] = NULL; free(e->type); free(e); return; } } } int DOM_EventTarget_dispatchEvent(DOM_EventTarget *target, DOM_Event *evt) { DOM_EventTarget **targets, *t; ListenerEntry *e; unsigned int tcount, i, j, lcount; if (target == NULL || evt == NULL) { DOM_Exception = DOM_NULL_POINTER_ERR; return 1; } if (evt->type == NULL || *evt->type == '\0') { DOM_EventException = DOM_UNSPECIFIED_EVENT_TYPE_ERR; return 1; } evt->target = target; /* post-initialization */ evt->timeStamp = time(NULL); if (evt->timeStamp == (time_t)-1) { DOM_Exception = DOM_SYSTEM_ERR; return 1; } evt->sp = 0; evt->pd = 0; tcount = 0; /* count targets/ancestors */ for (t = target->parentNode; t; t = t->parentNode) { tcount++; } if (tcount) { targets = malloc(sizeof *targets * tcount); if (targets == NULL) { DOM_Exception = DOM_NO_MEMORY_ERR; return 1; } } i = tcount; /* save state of tree in targets array */ for (t = target->parentNode; t; t = t->parentNode) { targets[--i] = t; } /* Trigger capturers */ evt->eventPhase = DOM_EVENT_CAPTURING_PHASE; for (i = 0; i < tcount && evt->sp == 0; i++) { DOM_EventListener cpy_of_listener_fns[targets[i]->listeners_len]; /* use stack ok? */ t = targets[i]; lcount = t->listeners_len; /* copy listener functions */ for (j = 0; j < lcount; j++) { e = t->listeners[j]; cpy_of_listener_fns[j] = e ? e->listener_fn : NULL; } evt->currentTarget = t; for (j = 0; j < lcount; j++) { e = t->listeners[j]; /* If the entry is NULL, the listener has * since been removed and is therefore skipped. If it * is not NULL but the listener functions do not match, * it was removed but another listener was added in * its place and therefore should be skipped. However, * if a listener is removed but then added again * while the current set is still being processed * there is a chance that it will be tiggered if it * meets the criteria tested below. Regardless of * the slim chances of this occuring (have to be the * same listener function added to the same array * index ... etc), it will need to be fixed. */ if (e && e->listener_fn == cpy_of_listener_fns[j] && e->useCapture && DOM_String_cmp(e->type, evt->type) == 0) { cpy_of_listener_fns[j](evt); /* invoke the listener function */ } } } /* Trigger regular listeners */ evt->eventPhase = DOM_EVENT_AT_TARGET; if (target->listeners_len && evt->sp == 0) { DOM_EventListener cpy_of_listener_fns[target->listeners_len]; lcount = target->listeners_len; for (j = 0; j < lcount; j++) { e = target->listeners[j]; cpy_of_listener_fns[j] = e ? e->listener_fn : NULL; } evt->currentTarget = target; for (j = 0; j < lcount; j++) { e = target->listeners[j]; if (e && cpy_of_listener_fns[j] && e->useCapture == 0 && DOM_String_cmp(e->type, evt->type) == 0) { cpy_of_listener_fns[j](evt); } } } /* Trigger bubblers */ evt->eventPhase = DOM_EVENT_BUBBLING_PHASE; i = tcount; while (i-- && evt->bubbles && evt->sp == 0) { DOM_EventListener cpy_of_listener_fns[targets[i]->listeners_len]; t = targets[i]; lcount = t->listeners_len; for (j = 0; j < lcount; j++) { e = t->listeners[j]; cpy_of_listener_fns[j] = e ? e->listener_fn : NULL; } evt->currentTarget = t; for (j = 0; j < lcount; j++) { e = t->listeners[j]; if (e && cpy_of_listener_fns[j] && e->useCapture == 0 && DOM_String_cmp(e->type, evt->type) == 0) { cpy_of_listener_fns[j](evt); } } } if (targets) { free(targets); } return evt->pd; } /* DOM_KeyEvent - Introduced in DOM Level 3 * http://www.w3.org/TR/2001/WD-DOM-Level-3-Events-20010410/events.html */ int DOM_KeyEvent_checkModifier(unsigned long modifier) { return 0; } void DOM_KeyEvent_initKeyEvent(DOM_KeyEvent *evt, const DOM_String *typeArg, int canBubbleArg, int cancelableArg, DOM_AbstractView *viewArg, unsigned short detailArg, DOM_String *outputStringArg, unsigned long keyValArg, unsigned long virtKeyValArg, int inputGeneratedArg, int numPadArg) { } void DOM_KeyEvent_initModifier(unsigned long modifier, int value) { } /* MutationEvent */ void DOM_MutationEvent_initMutationEvent(DOM_MutationEvent *evt, DOM_String *typeArg, int canBubbleArg, int cancelableArg, DOM_Node *relatedNodeArg, DOM_String *prevValueArg, DOM_String *newValueArg, DOM_String *attrNameArg, unsigned short attrChangeArg) { } visp-3.0.1/3rdparty/libatidaq-c/expatls.c000066400000000000000000000167211304511007300202430ustar00rootroot00000000000000/* domc document object model library in c * Copyright (c) 2001 Michael B. Allen * * The MIT License * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR * OTHER DEALINGS IN THE SOFTWARE. */ /* expatls.c - DOM_DocumentLS */ #include #include #include #include "xmlparse.h" #include "stack.h" #include "dom.h" const char *SP = " "; #define INDENT(n) ((n) > 8 ? SP : (SP + (32 - (n) * 4))) #define BUF_SIZ 8192 void start_fn(void *userData, const XML_Char *name, const XML_Char **atts) { struct stack *stk = (struct stack *) userData; DOM_Node *parent, *child; int i; if (stk == NULL || name == NULL || atts == NULL) { DOM_Exception = DOM_NULL_POINTER_ERR; return; } parent = (DOM_Node *) stack_peek(stk); if (parent == NULL) { DOM_Exception = DOM_SYSTEM_ERR; return; } child = DOM_Document_createElement(parent->ownerDocument, name); if (child == NULL) { return; } for (i = 0; atts[i]; i += 2) { DOM_Element_setAttribute(child, atts[i], atts[i + 1]); if (DOM_Exception) { return; } } if (DOM_Node_appendChild(parent, child) == NULL) { return; } if (stack_push(stk, child) == 0) { DOM_Exception = DOM_SYSTEM_ERR; } } void end_fn(void *userData, const XML_Char *name) { stack_pop((struct stack *)userData); } void chardata_fn(void *userData, const XML_Char *s, int len) { struct stack *stk = (struct stack *) userData; DOM_String *str; DOM_Text *tex; DOM_Node *parent; if (stk == NULL || s == NULL || len == 0) { DOM_Exception = DOM_NULL_POINTER_ERR; return; } parent = (DOM_Node *) stack_peek(stk); if (parent == NULL) { DOM_Exception = DOM_SYSTEM_ERR; return; } if ((str = (DOM_String *) malloc(len + 1)) == NULL) { DOM_Exception = DOM_NO_MEMORY_ERR; return; } memcpy(str, s, len); str[len] = '\0'; tex = DOM_Document_createTextNode(parent->ownerDocument, str); free(str); if (tex == NULL) { return; } DOM_Node_appendChild(parent, tex); if (DOM_Exception) { DOM_Document_destroyNode(parent->ownerDocument, tex); } } void comment_fn(void *userData, const XML_Char *s) { struct stack *stk = (struct stack *) userData; DOM_Comment *com; DOM_Node *parent; parent = (DOM_Node *) stack_peek(stk); if (parent == NULL) { DOM_Exception = DOM_SYSTEM_ERR; return; } if ((com = DOM_Document_createComment(parent->ownerDocument, s))) { DOM_Node_appendChild(parent, com); if (DOM_Exception) { DOM_Document_destroyNode(parent->ownerDocument, com); } } } void processing_fn(void *userData, const XML_Char *target, const XML_Char *data) { struct stack *stk = (struct stack *) userData; DOM_ProcessingInstruction *pi; DOM_Node *parent; parent = (DOM_Node *) stack_peek(stk); if (parent == NULL) { DOM_Exception = DOM_SYSTEM_ERR; return; } if ((pi = DOM_Document_createProcessingInstruction(parent->ownerDocument, target, data))) { DOM_Node_appendChild(parent, pi); if (DOM_Exception) { DOM_Document_destroyNode(parent->ownerDocument, pi); } } } int DOM_DocumentLS_load(DOM_Document *doc, const DOM_String *uri) { FILE *fd; XML_Parser p; struct stack *stk; size_t n; // was ssize_t (DBL) void *buf; int ret, done; DOM_Exception=DOM_NO_ERR; //line added by DBL if (doc == NULL || uri == NULL) { DOM_Exception = DOM_NULL_POINTER_ERR; return 0; } fd = fopen(uri, "r"); if (fd == NULL) { DOM_Exception = DOM_SYSTEM_ERR; return 0; } p = XML_ParserCreate(NULL); if (p == NULL) { DOM_Exception = DOM_XML_PARSER_ERR; fclose(fd); return 0; } stk = stack_new(INT_MAX); if (stk == NULL || stack_push(stk, doc) == 0) { DOM_Exception = DOM_SYSTEM_ERR; XML_ParserFree(p); fclose(fd); stack_del(stk, NULL); return 0; } XML_SetElementHandler(p, start_fn, end_fn); XML_SetCharacterDataHandler(p, chardata_fn); XML_SetCommentHandler(p, comment_fn); XML_SetProcessingInstructionHandler(p , processing_fn); XML_SetUserData(p, stk); ret = 1; for ( ;; ) { if ((buf = XML_GetBuffer(p, BUF_SIZ)) == NULL) { DOM_Exception = DOM_NO_MEMORY_ERR; ret = 0; break; } if ((n = fread(buf, 1, BUF_SIZ, fd)) == 0 && ferror(fd)) { DOM_Exception = DOM_SYSTEM_ERR; ret = 0; break; } if (XML_ParseBuffer(p, (int) n, (done = feof(fd))) == 0 || DOM_Exception) { if (DOM_Exception == 0) { DOM_Exception = DOM_XML_PARSER_ERR; } ret = 0; break; } if (done) { break; } } stack_del(stk, NULL); XML_ParserFree(p); fclose(fd); return ret; } void DocumentLS_save(FILE *fd, const DOM_Node *node, int indent) { NodeEntry *e; DOM_Node *c; if (fd == NULL || node == NULL) { return; } switch (node->nodeType) { case DOM_ELEMENT_NODE: fprintf(fd, "%s<%s", INDENT(indent), node->nodeName); for (e = node->attributes->first; e != NULL; e = e->next) { fprintf(fd, " %s=\"%s\"", e->node->nodeName, e->node->nodeValue); } if (DOM_Node_hasChildNodes(node)) { fprintf(fd, ">\n"); for (c = node->firstChild; c != NULL; c = c->nextSibling) { DocumentLS_save(fd, c, indent + 1); } fprintf(fd, "%s\n", INDENT(indent), node->nodeName); } else { fprintf(fd, "/>\n"); } break; case DOM_ATTRIBUTE_NODE: break; case DOM_TEXT_NODE: fprintf(fd, "%s\n", node->nodeValue); break; case DOM_CDATA_SECTION_NODE: break; case DOM_ENTITY_REFERENCE_NODE: break; case DOM_ENTITY_NODE: break; case DOM_PROCESSING_INSTRUCTION_NODE: break; case DOM_COMMENT_NODE: fprintf(fd, "%s\n", INDENT(indent), node->nodeValue); break; case DOM_DOCUMENT_NODE: DocumentLS_save(fd, node->u.Document.documentElement, 0); break; case DOM_DOCUMENT_TYPE_NODE: break; case DOM_DOCUMENT_FRAGMENT_NODE: break; case DOM_NOTATION_NODE: break; } } int DOM_DocumentLS_save(DOM_Document *doc, const DOM_String *uri, const DOM_Node *node) { FILE *fd; if (doc == NULL && node == NULL) { DOM_Exception = DOM_NULL_POINTER_ERR; return 0; } fd = fopen(uri, "w"); if (fd) { DocumentLS_save(fd, doc ? doc : node, 0); fclose(fd); return 1; } return 0; } visp-3.0.1/3rdparty/libatidaq-c/ftconfig.c000066400000000000000000000537051304511007300203650ustar00rootroot00000000000000/* ATIDAQ F/T C Library * v1.0.2 * Copyright (c) 2001 ATI Industrial Automation * * The MIT License * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR * OTHER DEALINGS IN THE SOFTWARE. */ /* ftconfig.c - calibration file and configuration routines History dec.14.2007 - Sam Skuce (ATI Industrial Automation) Added support for kN-m torque units. */ #include "dom.h" // GBB: added #include "ftconfig.h" // GBB: ftconfig.h modified to include strcutures in ftrt.h #include // sin(), cos() #include //------------------------------------------------- // private functions //------------------------------------------------- // from ftrt.h (these functions are defined in ftrt.c) extern void RTConvertToFT(RTCoefs *coefs, float voltages[],float result[],BOOL tempcomp); extern void RTBias(RTCoefs *coefs, float voltages[]); // void mmult(float *array1, float *array2, float *result,unsigned short r1,unsigned short c1,unsigned short c2); extern void mmult(float *a, unsigned short ra, unsigned short ca, unsigned short dca, float *b, unsigned short cb, unsigned short dcb, float *c, unsigned short dcc); // GBB: moved here these definitions from config.h void ResetDefaults(Calibration *cal); short CalcMatrix(Calibration *cal); short GetMatrix(Calibration *cal, float *result); short TTM(Transform xform,float result[6][6],Units ForceUnits,Units TorqueUnits); float ForceConv(char *Units); float TorqueConv(char *Units); float DistConv(char *Units); float AngleConv(char *Units); short ReadAttribute(const DOM_Element *elem, char **attValue, char *attName, BOOL required, char *defaultValue); void Separate(char *ValueList,float results[],unsigned short numValues); unsigned short FindText(char *str, unsigned short StartPos); unsigned short FindSpace(char *str, unsigned short StartPos); char *mid(char *instr,unsigned short startpos,unsigned short length); //---------------------------------------------- // "public" functions //---------------------------------------------- short SetToolTransform(Calibration *cal, float Vector[6],char *DistUnits,char *AngleUnits) { short i; if (cal==NULL) return 1; if (DistConv(DistUnits)==0) return 2; if (AngleConv(AngleUnits)==0) return 3; for(i=0;i<6;i++) cal->cfg.UserTransform.TT[i]=Vector[i]; free(cal->cfg.UserTransform.DistUnits); cal->cfg.UserTransform.DistUnits=ATI_strdup(DistUnits); free(cal->cfg.UserTransform.AngleUnits); cal->cfg.UserTransform.AngleUnits=ATI_strdup(AngleUnits); return CalcMatrix(cal); } // SetToolTransform() short SetForceUnits(Calibration *cal, char *NewUnits) { if (cal==NULL) return 1; if (ForceConv(NewUnits)==0) return 2; free(cal->cfg.ForceUnits); cal->cfg.ForceUnits=ATI_strdup(NewUnits); return CalcMatrix(cal); } // SetForceUnits() short SetTorqueUnits(Calibration *cal, char *NewUnits) { if (cal==NULL) return 1; if (TorqueConv(NewUnits)==0) return 2; free(cal->cfg.TorqueUnits); cal->cfg.TorqueUnits=ATI_strdup(NewUnits); return CalcMatrix(cal); } // SetTorqueUnits() short SetTempComp(Calibration *cal, int TCEnabled) { if (cal==NULL) return 1; if (TCEnabled) if (cal->TempCompAvailable) { cal->cfg.TempCompEnabled=TRUE; } else return 2; else cal->cfg.TempCompEnabled=FALSE; return 0; } // SetTempComp(); Calibration *createCalibration(char *CalFilePath,unsigned short index) { // This function creates and populate a Calibration structure from a file. Calibration *cal; DOM_DocumentLS *doc; // contains DOM document of calibration file DOM_Element *eRoot; // points to document root element ("FTSensor") DOM_Node *node; // multipurpose variable for nodes in the cal file DOM_Element *eCalibration; // points to Calibration element DOM_NodeList *calibrationNodelist; //node lists in the cal file DOM_NodeList *axisNodelist; DOM_NodeList *childNodelist; char *temp; // temporary string value for reading in attributes unsigned short i,j; // counter variables float temparray[MAX_GAUGES]; // used when loading calibration rows float scale; // used when loading calibration rows cal=(Calibration *) calloc(1,sizeof(Calibration)); doc = DOM_Implementation_createDocument(NULL, NULL, NULL); // initialize DOM document if (DOM_DocumentLS_load(doc,CalFilePath)!=1) { // open calibration file free(cal); DOM_Document_destroyNode(doc, doc); // clean up DOM stuff return NULL; } eRoot=doc->u.Document.documentElement; if (strcmp(eRoot->nodeName,"FTSensor")!=0) { // make sure we're loading the right kind of file free(cal); DOM_Document_destroyNode(doc, doc); // clean up DOM stuff return NULL; } ReadAttribute(eRoot,&temp,"Serial",TRUE,""); cal->Serial=ATI_strdup(temp); free(temp); ReadAttribute(eRoot,&temp,"BodyStyle",TRUE,""); cal->BodyStyle=ATI_strdup(temp); free(temp); ReadAttribute(eRoot,&temp,"NumGages",TRUE,""); cal->rt.NumChannels=atoi(temp)+1; // add one to NumGages for the temperature channel. free(temp); ReadAttribute(eRoot,&temp,"Family",TRUE,""); cal->Family=ATI_strdup(temp); free(temp); // find calibration specified by index calibrationNodelist=DOM_Element_getElementsByTagName(eRoot,"Calibration"); if ((calibrationNodelist->length) < index || index < 1) { // determine if invalid calibration index was used return NULL; } eCalibration=DOM_NodeList_item(calibrationNodelist,index-1); // set Calibration structure attributes found in Calibration element ReadAttribute(eCalibration,&temp,"PartNumber",TRUE,""); cal->PartNumber=ATI_strdup(temp); free(temp); ReadAttribute(eCalibration,&temp,"CalDate",TRUE,""); cal->CalDate=ATI_strdup(temp); free(temp); ReadAttribute(eCalibration,&temp,"ForceUnits",TRUE,""); cal->ForceUnits=ATI_strdup(temp); free(temp); ReadAttribute(eCalibration,&temp,"TorqueUnits",TRUE,""); cal->TorqueUnits=ATI_strdup(temp); free(temp); ReadAttribute(eCalibration,&temp,"DistUnits",TRUE,""); cal->BasicTransform.DistUnits=ATI_strdup(temp); cal->cfg.UserTransform.DistUnits=ATI_strdup(temp); free(temp); ReadAttribute(eCalibration,&temp,"AngleUnits",FALSE,"degrees"); cal->BasicTransform.AngleUnits=ATI_strdup(temp); cal->cfg.UserTransform.AngleUnits=ATI_strdup(temp); free(temp); // initialize temp comp variables cal->TempCompAvailable=FALSE; for (i=0;irt.bias_slopes[i]=0; cal->rt.gain_slopes[i]=0; } cal->rt.thermistor=0; // store basic matrix axisNodelist=DOM_Element_getElementsByTagName(eCalibration,"Axis"); cal->rt.NumAxes=(unsigned short) axisNodelist->length; for (i=0;ilength;i++) { node=DOM_NodeList_item(axisNodelist,i); ReadAttribute(node, &temp, "scale", FALSE,"1"); scale=(float) atof(temp); free(temp); ReadAttribute(node, &temp, "values", TRUE,""); Separate(temp,temparray,(unsigned short)(cal->rt.NumChannels-1)); for(j=0;jrt.NumChannels-1;j++) { cal->BasicMatrix[i][j]=temparray[j]/scale; } free(temp); ReadAttribute(node, &temp, "max", FALSE,"0"); cal->MaxLoads[i]=(float) atof(temp); free(temp); ReadAttribute(node, &temp, "Name", TRUE,""); cal->AxisNames[i]=ATI_strdup(temp); free(temp); } childNodelist=eCalibration->childNodes; for (i=0; i < childNodelist->length; i++) { node=DOM_NodeList_item(childNodelist,i); if (strcmp(node->nodeName,"BasicTransform")==0) { ReadAttribute(node, &temp, "Dx", FALSE,"0"); cal->BasicTransform.TT[0]=(float) atof(temp); free(temp); ReadAttribute(node, &temp, "Dy", FALSE,"0"); cal->BasicTransform.TT[1]=(float) atof(temp); free(temp); ReadAttribute(node, &temp, "Dz", FALSE,"0"); cal->BasicTransform.TT[2]=(float) atof(temp); free(temp); ReadAttribute(node, &temp, "Rx", FALSE,"0"); cal->BasicTransform.TT[3]=(float) atof(temp); free(temp); ReadAttribute(node, &temp, "Ry", FALSE,"0"); cal->BasicTransform.TT[4]=(float) atof(temp); free(temp); ReadAttribute(node, &temp, "Rz", FALSE,"0"); cal->BasicTransform.TT[5]=(float) atof(temp); free(temp); } else if (strcmp(node->nodeName,"BiasSlope")==0) { ReadAttribute(node, &temp, "values", TRUE,""); Separate(temp,cal->rt.bias_slopes,(unsigned short)(cal->rt.NumChannels-1)); free(temp); cal->TempCompAvailable = TRUE; } else if (strcmp(node->nodeName,"GainSlope")==0) { ReadAttribute(node, &temp, "values", TRUE,""); Separate(temp,cal->rt.gain_slopes,(unsigned short)(cal->rt.NumChannels-1)); free(temp); cal->TempCompAvailable = TRUE; } else if (strcmp(node->nodeName,"Thermistor")==0) { ReadAttribute(node, &temp, "value", TRUE,""); cal->rt.thermistor = (float) atof(temp); free(temp); } } DOM_Document_destroyNodeList(eRoot->ownerDocument, calibrationNodelist,0); DOM_Document_destroyNodeList(eRoot->ownerDocument, axisNodelist,0); DOM_Document_destroyNode(doc, doc); // clean up DOM stuff ResetDefaults(cal); // calculate working matrix and set default values return cal; } // createCalibration(); void destroyCalibration(Calibration *cal) { // frees all memory allocated for a Calibration structure int i; if (cal==NULL) return; for(i=0;iAxisNames[i]); free(cal->BasicTransform.AngleUnits); free(cal->BasicTransform.DistUnits); free(cal->cfg.UserTransform.AngleUnits); free(cal->cfg.UserTransform.DistUnits); free(cal->cfg.ForceUnits); free(cal->cfg.TorqueUnits); free(cal->BodyStyle); free(cal->Family); free(cal->Serial); free(cal->CalDate); free(cal->PartNumber); free(cal->ForceUnits); free(cal->TorqueUnits); free(cal); return; } // destroyCalibration() void Bias(Calibration *cal, float voltages[]) { RTBias(&cal->rt,voltages); } // Bias() void ConvertToFT(Calibration *cal, float voltages[],float result[]) { RTConvertToFT(&cal->rt,voltages,result,cal->cfg.TempCompEnabled); } // ConvertToFT() // from calinfo.c void printCalInfo(Calibration *cal) { unsigned short i,j; // loop variables // display info from calibration file printf("Calibration Information:\n"); printf(" Serial: %s\n",cal->Serial); printf(" Body Style: %s\n",cal->BodyStyle); printf(" Calibration: %s\n",cal->PartNumber); printf(" Calibration Date: %s\n",cal->CalDate); printf(" Family: %s\n",cal->Family); printf(" # Channels: %i\n",cal->rt.NumChannels); printf(" # Axes: %i\n",cal->rt.NumAxes); printf(" Force Units: %s\n",cal->ForceUnits); printf(" Torque Units: %s\n",cal->TorqueUnits); printf("Temperature Compensation: %s\n",(cal->TempCompAvailable ? "Yes" : "No")); // print maximum loads of axes printf("\nRated Loads\n"); for (i=0;irt.NumAxes;i++) { char *units; if ((cal->AxisNames[i])[0]=='F') { units=cal->ForceUnits; } else units=cal->TorqueUnits; printf("%s: %f %s\n",cal->AxisNames[i],cal->MaxLoads[i],units); } // print working calibration matrix printf("\nWorking Calibration Matrix\n"); printf(" "); for (i=0;irt.NumChannels-1;i++) printf("G%i ",i); printf("\n"); for (i=0;irt.NumAxes;i++) { printf("%s: ",cal->AxisNames[i]); for (j=0;jrt.NumChannels-1;j++) printf("%13.5e ",cal->rt.working_matrix[i][j]); printf("\n"); } // print temperature compensation information, if available if (cal->TempCompAvailable) { printf("\nTemperature Compensation Information\n"); printf("BS: "); for (i=0;irt.NumChannels-1;i++) { printf("%13.5e ",cal->rt.bias_slopes[i]); } printf("\nGS: "); for (i=0;irt.NumChannels-1;i++) { printf("%13.5e ",cal->rt.gain_slopes[i]); } printf("\nTherm: %f\n",cal->rt.thermistor); } } //---------------------------------------------- // "private" functions //---------------------------------------------- void ResetDefaults(Calibration *cal) { // Restores all configuration options to their default values unsigned short i; cal->cfg.ForceUnits=ATI_strdup(cal->ForceUnits); // set output units to calibration file defaults cal->cfg.TorqueUnits=ATI_strdup(cal->TorqueUnits); for (i=0;i<6;i++) // clear user Tool Transform cal->cfg.UserTransform.TT[i]=0; for (i=0;i < cal->rt.NumChannels-1;i++) { // clear bias vectors cal->rt.bias_vector[i]=0; cal->rt.TCbias_vector[i]=0; } cal->rt.bias_vector[cal->rt.NumChannels-1]=0; // thermistor reading of bias vector cal->cfg.TempCompEnabled=cal->TempCompAvailable; // turn temp comp on by default, if available CalcMatrix(cal); // compute working matrix and store in rt } // ResetDefaults() short CalcMatrix(Calibration *cal) { // Computes a working matrix (based on BasicMatrix, tool transforms, and units) // and stores it in the rt structure return GetMatrix(cal,*cal->rt.working_matrix); } //CalcMatrix() short GetMatrix(Calibration *cal, float *result) { // Calculates a working matrix based on the basic matrix, // basic tool transform, user tool transform, and user units, // and stores in result. float UserTTM[6][6]; // the User tool transform matrix float BasicTTM[6][6]; // basic (built-in) tool transform matrix float result1[6][MAX_GAUGES]; // temporary intermediate result float FConv, TConv; // unit conversion factors unsigned short i, j; // loop variables unsigned short NumGauges=cal->rt.NumChannels-1; // number of strain gages short sts; // return value if (cal->rt.NumAxes==6) { sts=TTM(cal->BasicTransform,BasicTTM,cal->ForceUnits,cal->TorqueUnits); if (sts!=0) return 1; // error in tool transform units sts=TTM(cal->cfg.UserTransform,UserTTM,cal->ForceUnits,cal->TorqueUnits); if (sts!=0) return 1; // error in tool transform units mmult(*BasicTTM,6,6,6, *cal->BasicMatrix,NumGauges,MAX_GAUGES, *result1,MAX_GAUGES); mmult(*UserTTM,6,6,6, // compute working matrix *result1,NumGauges,MAX_GAUGES, result,MAX_GAUGES); } else { // No transforms allowed except for 6-axis transducers result=*cal->BasicMatrix; } //Apply units change FConv = ForceConv(cal->cfg.ForceUnits) / ForceConv(cal->ForceUnits); TConv = TorqueConv(cal->cfg.TorqueUnits) / TorqueConv(cal->TorqueUnits); for(i=0;irt.NumAxes;i++) //forces for(j=0;jAxisNames[i])[0]=='F') { result[i*MAX_GAUGES+j] = result[i*MAX_GAUGES+j] * FConv; if (FConv==0) return 2; } else { result[i*MAX_GAUGES+j] = result[i*MAX_GAUGES+j] * TConv; if (TConv==0) return 2; } return 0; } // GetMatrix() short TTM(Transform xform,float result[6][6],Units ForceUnits,Units TorqueUnits) { // calculates a tool transform matrix and stores in result float R[3][3]; // rotation matrix float sx, sy, sz, cx, cy, cz, dx, dy, dz; unsigned short i, j; // loop variables float DC,AC; // distance conversion factor and angle conversion factor if ((DistConv(xform.DistUnits)==0) || (AngleConv(xform.AngleUnits)==0)) return 1; // invalid units DC = TorqueConv(TorqueUnits) / (ForceConv(ForceUnits) * DistConv(xform.DistUnits)); AC = (float) 1.0/AngleConv(xform.AngleUnits); // calculate sin & cos of angles sx = (float) sin(PI/180 * xform.TT[3] * AC); cx = (float) cos(PI/180 * xform.TT[3] * AC); sy = (float) sin(PI/180 * xform.TT[4] * AC); cy = (float) cos(PI/180 * xform.TT[4] * AC); sz = (float) sin(PI/180 * xform.TT[5] * AC); cz = (float) cos(PI/180 * xform.TT[5] * AC); // calculate Dx, Dy, Dz dx = xform.TT[0]*DC; dy = xform.TT[1]*DC; dz = xform.TT[2]*DC; // calculate rotation matrix R[0][0] = cy * cz; R[0][1] = sx * sy * cz + cx * sz; R[0][2] = sx * sz - cx * sy * cz; R[1][0] = -cy * sz; R[1][1] = -sx * sy * sz + cx * cz; R[1][2] = sx * cz + cx * sy * sz; R[2][0] = sy; R[2][1] = -sx * cy; R[2][2] = cx * cy; // calculate transformation matrix for(i=0;i<=5;i++) for(j=0;j<=5;j++) result[i][j]=0; result[0][0] = R[0][0]; result[0][1] = R[0][1]; result[0][2] = R[0][2]; result[1][0] = R[1][0]; result[1][1] = R[1][1]; result[1][2] = R[1][2]; result[2][0] = R[2][0]; result[2][1] = R[2][1]; result[2][2] = R[2][2]; result[3][0] = R[0][2] * dy - R[0][1] * dz; result[3][1] = R[0][0] * dz - R[0][2] * dx; result[3][2] = R[0][1] * dx - R[0][0] * dy; result[3][3] = R[0][0]; result[3][4] = R[0][1]; result[3][5] = R[0][2]; result[4][0] = R[1][2] * dy - R[1][1] * dz; result[4][1] = R[1][0] * dz - R[1][2] * dx; result[4][2] = R[1][1] * dx - R[1][0] * dy; result[4][3] = R[1][0]; result[4][4] = R[1][1]; result[4][5] = R[1][2]; result[5][0] = R[2][2] * dy - R[2][1] * dz; result[5][1] = R[2][0] * dz - R[2][2] * dx; result[5][2] = R[2][1] * dx - R[2][0] * dy; result[5][3] = R[2][0]; result[5][4] = R[2][1]; result[5][5] = R[2][2]; return 0; } // TTM() float ForceConv(Units units) { if ((strcmp(units,"lb")==0) || (strcmp(units,"lbf")==0)) { return (float) 1; } else if ((strcmp(units,"klb")==0) || (strcmp(units,"klbf")==0)) { return (float) 0.001; } else if (strcmp(units,"N")==0) { return (float) 4.44822161526; } else if (strcmp(units,"kN")==0) { return (float) 0.00444822161526; } else if (strcmp(units,"kg")==0) { return (float) 0.45359237; } else if (strcmp(units,"g")==0) { return (float) 453.59237; } else return (float) 0; } // ForceConv() float TorqueConv(Units units) { if ((strcmp(units,"in-lb")==0) || (strcmp(units,"in-lbf")==0) || (strcmp(units,"lb-in")==0) || (strcmp(units,"lbf-in")==0)) { return (float) 1; } else if ((strcmp(units,"ft-lb")==0) || (strcmp(units,"lb-ft")==0) || (strcmp(units,"ft-lbf")==0) || (strcmp(units,"lbf-ft")==0)) { return (float) 0.08333333333; } else if ((strcmp(units,"N-m")==0) || (strcmp(units,"Nm")==0)) { return (float) 0.112984829028; } else if ((strcmp(units,"N-mm")==0) || (strcmp(units,"Nmm")==0)) { return (float) 112.984829028; } else if ((strcmp(units,"kg-cm")==0) || (strcmp(units,"kgcm")==0)) { return (float) 1.1521246198; }else if ( (strcmp(units, "kN-m" ) == 0 ) || ( strcmp( units, "kNm" ) == 0 ) ){ return (float) 0.000112984829028; } else return (float) 0; } // TorqueConv() float DistConv(Units units) { if (strcmp(units,"in")==0) { return (float) 1; } else if (strcmp(units,"m")==0) { return (float) 0.0254; } else if (strcmp(units,"cm")==0) { return (float) 2.54; } else if (strcmp(units,"mm")==0) { return (float) 25.4; } else if (strcmp(units,"ft")==0) { return (float) 0.08333333333; } else return (float) 0; } // DistConv() float AngleConv(Units u) { if ((strcmp(u,"deg")==0) || (strcmp(u,"degrees")==0) || (strcmp(u,"degree")==0)) { return (float) 1; } else if ((strcmp(u,"rad")==0) || (strcmp(u,"radians")==0) || (strcmp(u,"radian")==0)) { return (float) PI / 180; } else return (float) 0; } // AngleConv() short ReadAttribute(const DOM_Element *elem, char **attValue, char *attName, BOOL required, char *defaultValue) { (*attValue)=DOM_Element_getAttribute(elem,attName); if (strcmp(*attValue,"")==0) { if (required==TRUE) { return 1; } else { free(*attValue); *attValue=ATI_strdup(defaultValue); } } return 0; } // ReadAttribute() void Separate(char *ValueList,float results[],unsigned short numValues) { // parses a space- or tab- delimited string into an array of floats unsigned short i; unsigned short StartPos, EndPos; char *word; StartPos=FindText(ValueList,0); // find start of first value for (i=0;iNumChannels-1; i++) { if (tempcomp==TRUE) { cvoltages[i]=TempComp(coefs,voltages[i],voltages[coefs->NumChannels-1],i) - coefs->TCbias_vector[i]; } else { cvoltages[i]=voltages[i]-coefs->bias_vector[i]; } } // perform matrix math mmult(*coefs->working_matrix,coefs->NumAxes,(unsigned short)(coefs->NumChannels-1),MAX_GAUGES, cvoltages,1,1, result,1); } void RTBias(RTCoefs *coefs, float voltages[]) { unsigned short i; for (i=0; iNumChannels-1; i++) { coefs->bias_vector[i]=voltages[i]; coefs->TCbias_vector[i]=TempComp(coefs,voltages[i],voltages[coefs->NumChannels-1],i); } // store bias thermistor value, although it is no longer needed coefs->bias_vector[coefs->NumChannels-1]=voltages[coefs->NumChannels-1]; } //-------------------------------------- // private routines definitions void mmult(float *a, unsigned short ra, unsigned short ca, unsigned short dca, float *b, unsigned short cb, unsigned short dcb, float *c, unsigned short dcc) { //multiplies two matrices; must be properly dimensioned unsigned short i,j,k; for (i=0;ibias_slopes[i] * (T - coefs->thermistor)) / (1 - coefs->gain_slopes[i] * (T - coefs->thermistor))); } visp-3.0.1/3rdparty/libatidaq-c/ftrt.h000066400000000000000000000037571304511007300175540ustar00rootroot00000000000000/* ATIDAQ F/T C Library * * Copyright (c) ATI Industrial Automation * * The MIT License * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR * OTHER DEALINGS IN THE SOFTWARE. */ /* ftrt.c - routines for realtime calculation of forces and torques from voltages modifications: june.15.2005 - Sam Skuce (ATI Industrial Automation) - moved some structs and #defines into ftsharedrt.h */ #include "ftsharedrt.h" /*june.15.2005 - ss - added */ void RTConvertToFT(RTCoefs *coefs, float voltages[],float result[],BOOL tempcomp); void RTBias(RTCoefs *coefs, float voltages[]); //------------------------------------------------- //private routines //void mmult(float *array1, float *array2, float *result,unsigned short r1,unsigned short c1,unsigned short c2); void mmult(float *a, unsigned short ra, unsigned short ca, unsigned short dca, float *b, unsigned short cb, unsigned short dcb, float *c, unsigned short dcc); float TempComp(RTCoefs *coefs,float G,float T,unsigned short i); visp-3.0.1/3rdparty/libatidaq-c/ftsharedrt.h000066400000000000000000000037041304511007300207330ustar00rootroot00000000000000/* ATIDAQ F/T C Library * * Copyright (c) ATI Industrial Automation * * The MIT License * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR * OTHER DEALINGS IN THE SOFTWARE. */ /* ftsharedrt.h - definitions useful in multiple places in the ATI DAQ FT C Library Initial Version - June.14.2005 - Sam Skuce (ATI Industrial Automation) */ #ifndef FTSHAREDRT_H #define FTSHAREDRT_H #ifdef __cplusplus extern "C" { #endif #define MAX_AXES 6 #define MAX_GAUGES 8 #define TRUE 1 #define FALSE 0 typedef int BOOL; typedef struct RTCoefs RTCoefs; // calibration information required for F/T conversions struct RTCoefs { unsigned short NumChannels; unsigned short NumAxes; float working_matrix[MAX_AXES][MAX_GAUGES]; float bias_slopes[MAX_GAUGES]; float gain_slopes[MAX_GAUGES]; float thermistor; float bias_vector[MAX_GAUGES+1]; float TCbias_vector[MAX_GAUGES]; }; #ifdef __cplusplus } #endif #endif /*__FTSHAREDRT_H*/ visp-3.0.1/3rdparty/libatidaq-c/iasciitab.h000066400000000000000000000055731304511007300205230ustar00rootroot00000000000000/* Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd * * The MIT License * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR * OTHER DEALINGS IN THE SOFTWARE. */ /* Like asciitab.h, except that 0xD has code BT_S rather than BT_CR */ /* 0x00 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML, /* 0x04 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML, /* 0x08 */ BT_NONXML, BT_S, BT_LF, BT_NONXML, /* 0x0C */ BT_NONXML, BT_S, BT_NONXML, BT_NONXML, /* 0x10 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML, /* 0x14 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML, /* 0x18 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML, /* 0x1C */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML, /* 0x20 */ BT_S, BT_EXCL, BT_QUOT, BT_NUM, /* 0x24 */ BT_OTHER, BT_PERCNT, BT_AMP, BT_APOS, /* 0x28 */ BT_LPAR, BT_RPAR, BT_AST, BT_PLUS, /* 0x2C */ BT_COMMA, BT_MINUS, BT_NAME, BT_SOL, /* 0x30 */ BT_DIGIT, BT_DIGIT, BT_DIGIT, BT_DIGIT, /* 0x34 */ BT_DIGIT, BT_DIGIT, BT_DIGIT, BT_DIGIT, /* 0x38 */ BT_DIGIT, BT_DIGIT, BT_COLON, BT_SEMI, /* 0x3C */ BT_LT, BT_EQUALS, BT_GT, BT_QUEST, /* 0x40 */ BT_OTHER, BT_HEX, BT_HEX, BT_HEX, /* 0x44 */ BT_HEX, BT_HEX, BT_HEX, BT_NMSTRT, /* 0x48 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, /* 0x4C */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, /* 0x50 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, /* 0x54 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, /* 0x58 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_LSQB, /* 0x5C */ BT_OTHER, BT_RSQB, BT_OTHER, BT_NMSTRT, /* 0x60 */ BT_OTHER, BT_HEX, BT_HEX, BT_HEX, /* 0x64 */ BT_HEX, BT_HEX, BT_HEX, BT_NMSTRT, /* 0x68 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, /* 0x6C */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, /* 0x70 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, /* 0x74 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, /* 0x78 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_OTHER, /* 0x7C */ BT_VERBAR, BT_OTHER, BT_OTHER, BT_OTHER, visp-3.0.1/3rdparty/libatidaq-c/latin1tab.h000066400000000000000000000055511304511007300204460ustar00rootroot00000000000000/* Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd * * The MIT License * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR * OTHER DEALINGS IN THE SOFTWARE. */ /* 0x80 */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER, /* 0x84 */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER, /* 0x88 */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER, /* 0x8C */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER, /* 0x90 */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER, /* 0x94 */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER, /* 0x98 */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER, /* 0x9C */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER, /* 0xA0 */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER, /* 0xA4 */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER, /* 0xA8 */ BT_OTHER, BT_OTHER, BT_NMSTRT, BT_OTHER, /* 0xAC */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER, /* 0xB0 */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER, /* 0xB4 */ BT_OTHER, BT_NMSTRT, BT_OTHER, BT_NAME, /* 0xB8 */ BT_OTHER, BT_OTHER, BT_NMSTRT, BT_OTHER, /* 0xBC */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER, /* 0xC0 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, /* 0xC4 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, /* 0xC8 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, /* 0xCC */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, /* 0xD0 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, /* 0xD4 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_OTHER, /* 0xD8 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, /* 0xDC */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, /* 0xE0 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, /* 0xE4 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, /* 0xE8 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, /* 0xEC */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, /* 0xF0 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, /* 0xF4 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_OTHER, /* 0xF8 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, /* 0xFC */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, visp-3.0.1/3rdparty/libatidaq-c/nametab.h000066400000000000000000000203111304511007300201650ustar00rootroot00000000000000/* Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd * * The MIT License * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR * OTHER DEALINGS IN THE SOFTWARE. */ static const unsigned namingBitmap[] = { 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0x00000000, 0x04000000, 0x87FFFFFE, 0x07FFFFFE, 0x00000000, 0x00000000, 0xFF7FFFFF, 0xFF7FFFFF, 0xFFFFFFFF, 0x7FF3FFFF, 0xFFFFFDFE, 0x7FFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFE00F, 0xFC31FFFF, 0x00FFFFFF, 0x00000000, 0xFFFF0000, 0xFFFFFFFF, 0xFFFFFFFF, 0xF80001FF, 0x00000003, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xFFFFD740, 0xFFFFFFFB, 0x547F7FFF, 0x000FFFFD, 0xFFFFDFFE, 0xFFFFFFFF, 0xDFFEFFFF, 0xFFFFFFFF, 0xFFFF0003, 0xFFFFFFFF, 0xFFFF199F, 0x033FCFFF, 0x00000000, 0xFFFE0000, 0x027FFFFF, 0xFFFFFFFE, 0x0000007F, 0x00000000, 0xFFFF0000, 0x000707FF, 0x00000000, 0x07FFFFFE, 0x000007FE, 0xFFFE0000, 0xFFFFFFFF, 0x7CFFFFFF, 0x002F7FFF, 0x00000060, 0xFFFFFFE0, 0x23FFFFFF, 0xFF000000, 0x00000003, 0xFFF99FE0, 0x03C5FDFF, 0xB0000000, 0x00030003, 0xFFF987E0, 0x036DFDFF, 0x5E000000, 0x001C0000, 0xFFFBAFE0, 0x23EDFDFF, 0x00000000, 0x00000001, 0xFFF99FE0, 0x23CDFDFF, 0xB0000000, 0x00000003, 0xD63DC7E0, 0x03BFC718, 0x00000000, 0x00000000, 0xFFFDDFE0, 0x03EFFDFF, 0x00000000, 0x00000003, 0xFFFDDFE0, 0x03EFFDFF, 0x40000000, 0x00000003, 0xFFFDDFE0, 0x03FFFDFF, 0x00000000, 0x00000003, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xFFFFFFFE, 0x000D7FFF, 0x0000003F, 0x00000000, 0xFEF02596, 0x200D6CAE, 0x0000001F, 0x00000000, 0x00000000, 0x00000000, 0xFFFFFEFF, 0x000003FF, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xFFFFFFFF, 0xFFFF003F, 0x007FFFFF, 0x0007DAED, 0x50000000, 0x82315001, 0x002C62AB, 0x40000000, 0xF580C900, 0x00000007, 0x02010800, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0x0FFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0x03FFFFFF, 0x3F3FFFFF, 0xFFFFFFFF, 0xAAFF3F3F, 0x3FFFFFFF, 0xFFFFFFFF, 0x5FDFFFFF, 0x0FCF1FDC, 0x1FDC1FFF, 0x00000000, 0x00004C40, 0x00000000, 0x00000000, 0x00000007, 0x00000000, 0x00000000, 0x00000000, 0x00000080, 0x000003FE, 0xFFFFFFFE, 0xFFFFFFFF, 0x001FFFFF, 0xFFFFFFFE, 0xFFFFFFFF, 0x07FFFFFF, 0xFFFFFFE0, 0x00001FFF, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0x0000003F, 0x00000000, 0x00000000, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0x0000000F, 0x00000000, 0x00000000, 0x00000000, 0x07FF6000, 0x87FFFFFE, 0x07FFFFFE, 0x00000000, 0x00800000, 0xFF7FFFFF, 0xFF7FFFFF, 0x00FFFFFF, 0x00000000, 0xFFFF0000, 0xFFFFFFFF, 0xFFFFFFFF, 0xF80001FF, 0x00030003, 0x00000000, 0xFFFFFFFF, 0xFFFFFFFF, 0x0000003F, 0x00000003, 0xFFFFD7C0, 0xFFFFFFFB, 0x547F7FFF, 0x000FFFFD, 0xFFFFDFFE, 0xFFFFFFFF, 0xDFFEFFFF, 0xFFFFFFFF, 0xFFFF007B, 0xFFFFFFFF, 0xFFFF199F, 0x033FCFFF, 0x00000000, 0xFFFE0000, 0x027FFFFF, 0xFFFFFFFE, 0xFFFE007F, 0xBBFFFFFB, 0xFFFF0016, 0x000707FF, 0x00000000, 0x07FFFFFE, 0x0007FFFF, 0xFFFF03FF, 0xFFFFFFFF, 0x7CFFFFFF, 0xFFEF7FFF, 0x03FF3DFF, 0xFFFFFFEE, 0xF3FFFFFF, 0xFF1E3FFF, 0x0000FFCF, 0xFFF99FEE, 0xD3C5FDFF, 0xB080399F, 0x0003FFCF, 0xFFF987E4, 0xD36DFDFF, 0x5E003987, 0x001FFFC0, 0xFFFBAFEE, 0xF3EDFDFF, 0x00003BBF, 0x0000FFC1, 0xFFF99FEE, 0xF3CDFDFF, 0xB0C0398F, 0x0000FFC3, 0xD63DC7EC, 0xC3BFC718, 0x00803DC7, 0x0000FF80, 0xFFFDDFEE, 0xC3EFFDFF, 0x00603DDF, 0x0000FFC3, 0xFFFDDFEC, 0xC3EFFDFF, 0x40603DDF, 0x0000FFC3, 0xFFFDDFEC, 0xC3FFFDFF, 0x00803DCF, 0x0000FFC3, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xFFFFFFFE, 0x07FF7FFF, 0x03FF7FFF, 0x00000000, 0xFEF02596, 0x3BFF6CAE, 0x03FF3F5F, 0x00000000, 0x03000000, 0xC2A003FF, 0xFFFFFEFF, 0xFFFE03FF, 0xFEBF0FDF, 0x02FE3FFF, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x1FFF0000, 0x00000002, 0x000000A0, 0x003EFFFE, 0xFFFFFFFE, 0xFFFFFFFF, 0x661FFFFF, 0xFFFFFFFE, 0xFFFFFFFF, 0x77FFFFFF, }; static const unsigned char nmstrtPages[] = { 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x00, 0x00, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0x13, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x15, 0x16, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x17, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, }; static const unsigned char namePages[] = { 0x19, 0x03, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x00, 0x00, 0x1F, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x10, 0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0x13, 0x26, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x27, 0x16, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x17, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, }; visp-3.0.1/3rdparty/libatidaq-c/node.c000066400000000000000000000445031304511007300175070ustar00rootroot00000000000000/* domc document object model library in c * Copyright (c) 2001 Michael B. Allen * * The MIT License * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR * OTHER DEALINGS IN THE SOFTWARE. */ /* node.c - DOM_NodeList, DOM_NamedNodeMap, and DOM_Node */ #include "dom.h" /* NodeList */ DOM_NodeList * Document_createNodeList(DOM_Document *doc) { DOM_NodeList *r; if ((r = calloc(sizeof *r, 1)) == NULL) { DOM_Exception = DOM_NO_MEMORY_ERR; } return r; } void DOM_Document_destroyNodeList(DOM_Document *doc, DOM_NodeList *nl, int free_nodes) { if (nl) { NodeEntry *e, *tmp; e = nl->first; while (e != NULL) { if (free_nodes) { DOM_Document_destroyNode(doc, e->node); } tmp = e; e = e->next; free(tmp); } free(nl); } } DOM_Node * DOM_NodeList_item(const DOM_NodeList *list, unsigned long index) { if (list && index < list->length) { NodeEntry *e; for (e = list->first; e != NULL; e = e->next, index--) { if (index == 0) { return e->node; } } } return NULL; } NodeEntry * NodeList_insert(DOM_NodeList *nl, DOM_Node *newChild, DOM_Node *refChild) { NodeEntry *e; if (nl == NULL) { DOM_Exception = DOM_NULL_POINTER_ERR; return NULL; } if ((e = calloc(sizeof *e, 1)) == NULL) { DOM_Exception = DOM_NO_MEMORY_ERR; return NULL; } e->node = newChild; if (nl->length == 0) { nl->first = nl->last = e; } else if (refChild == NULL) { e->prev = nl->last; nl->last->next = e; nl->last = e; } else { NodeEntry *s; for (s = nl->first; s != NULL && s->node != refChild; s = s->next) { ; } if (s == NULL || s->node != refChild) { DOM_Exception = DOM_NOT_FOUND_ERR; free(e); return NULL; } e->prev = s->prev; e->next = s; if (s == nl->first) { nl->first = e; } else { s->prev->next = e; } s->prev = e; } nl->length++; return e; } NodeEntry * NodeList_replace(DOM_NodeList *nl, DOM_Node *newChild, DOM_Node *oldChild) { NodeEntry *e; if (nl == NULL) { DOM_Exception = DOM_NULL_POINTER_ERR; return NULL; } for (e = nl->first; e != NULL && e->node != oldChild; e = e->next) { ; } if (e == NULL) { DOM_Exception = DOM_NOT_FOUND_ERR; return NULL; } e->node = newChild; return e; } NodeEntry * NodeList_remove(DOM_NodeList *nl, DOM_Node *oldChild) { NodeEntry *e; if (nl == NULL) { DOM_Exception = DOM_NULL_POINTER_ERR; return NULL; } for (e = nl->first; e != NULL && e->node != oldChild; e = e->next) { ; } if (e == NULL) { return NULL; } if (nl->first == nl->last) { nl->first = nl->last = NULL; } else if (e == nl->first) { nl->first = e->next; nl->first->prev = NULL; } else if (e == nl->last) { nl->last = e->prev; nl->last->next = NULL; } else { e->prev->next = e->next; e->next->prev = e->prev; } nl->length--; return e; } NodeEntry * NodeList_append(DOM_NodeList *nl, DOM_Node *newChild) { NodeEntry *e; if (nl == NULL) { DOM_Exception = DOM_NULL_POINTER_ERR; return NULL; } if ((e = calloc(sizeof *e, 1)) == NULL) { DOM_Exception = DOM_NO_MEMORY_ERR; return NULL; } e->node = newChild; if (nl->first == NULL) { nl->first = nl->last = e; } else { nl->last->next = e; e->prev = nl->last; nl->last = e; } nl->length++; return e; } /* NamedNodeMap */ void DOM_Document_destroyNamedNodeMap(DOM_Document *doc, DOM_NamedNodeMap *map, int free_nodes) { DOM_Document_destroyNodeList(doc, map, free_nodes); } DOM_NamedNodeMap * Document_createNamedNodeMap(DOM_Document *doc) { return Document_createNodeList(doc); } DOM_Node * DOM_NamedNodeMap_getNamedItem(const DOM_NamedNodeMap *map, const DOM_String *name) { NodeEntry *e; if (map && name) { for (e = map->first; e != NULL; e = e->next) { if (DOM_String_cmp(name, e->node->nodeName) == 0) { return e->node; } } } return NULL; } DOM_Node * DOM_NamedNodeMap_setNamedItem(DOM_NamedNodeMap *map, DOM_Node *arg) { NodeEntry *e; if (map && arg) { for (e = map->first; e != NULL && arg != e->node; e = e->next) { ; } if (e) { DOM_Node *tmp = e->node; e->node = arg; return tmp; } NodeList_append(map, arg); } return NULL; } DOM_Node * DOM_NamedNodeMap_removeNamedItem(DOM_NamedNodeMap *map, const DOM_String *name) { NodeEntry *e; DOM_Node *r = NULL; if (map && name) { for (e = map->first; e != NULL; e = e->next) { if (DOM_String_cmp(name, e->node->nodeName) == 0 && NodeList_remove(map, e->node)) { r = e->node; free(e); break; } } } return r; } DOM_Node * DOM_NamedNodeMap_item(const DOM_NamedNodeMap *map, unsigned long index) { if (map && index < map->length) { NodeEntry *e; for (e = map->first; e != NULL; e = e->next, index--) { if (index == 0) { return e->node; } } } return NULL; } /* Node */ void DOM_Document_destroyNode(DOM_Document *doc, DOM_Node *node) { if (node == NULL) { return; } if (node->childNodes) { DOM_Document_destroyNodeList(doc, node->childNodes, 1); } if (node->listeners) { unsigned int i; for (i = 0; i < node->listeners_len; i++) { if (node->listeners[i]) { free(node->listeners[i]->type); free(node->listeners[i]); } } free(node->listeners); } switch(node->nodeType) { case DOM_ELEMENT_NODE: DOM_Document_destroyNamedNodeMap(doc, node->attributes, 1); free(node->nodeName); break; case DOM_TEXT_NODE: case DOM_COMMENT_NODE: case DOM_CDATA_SECTION_NODE: free(node->nodeValue); break; case DOM_ATTRIBUTE_NODE: free(node->nodeName); free(node->nodeValue); break; case DOM_ENTITY_REFERENCE_NODE: case DOM_ENTITY_NODE: break; case DOM_PROCESSING_INSTRUCTION_NODE: free(node->nodeName); free(node->nodeValue); break; case DOM_DOCUMENT_NODE: case DOM_DOCUMENT_TYPE_NODE: case DOM_NOTATION_NODE: break; } free(node); } DOM_Node * Document_createNode(DOM_Document *doc, unsigned short nodeType) { DOM_Node *node; if (nodeType != DOM_DOCUMENT_NODE && doc == NULL) { DOM_Exception = DOM_NULL_POINTER_ERR; return NULL; } node = calloc(sizeof *node, 1); if (node == NULL) { DOM_Exception = DOM_NO_MEMORY_ERR; return NULL; } node->nodeType = nodeType; node->ownerDocument = doc; switch (nodeType) { case DOM_DOCUMENT_NODE: node->ownerDocument = node; case DOM_ELEMENT_NODE: case DOM_ATTRIBUTE_NODE: case DOM_ENTITY_REFERENCE_NODE: case DOM_ENTITY_NODE: case DOM_DOCUMENT_FRAGMENT_NODE: node->childNodes = Document_createNodeList(doc); if (node->childNodes == NULL) { DOM_Document_destroyNode(doc, node); return NULL; } } return node; } #define CANNOT_HAVE_CHILDREN(t) ((t) == DOM_PROCESSING_INSTRUCTION_NODE || \ (t) == DOM_COMMENT_NODE || (t) == DOM_TEXT_NODE || \ (t) == DOM_CDATA_SECTION_NODE || (t) == DOM_NOTATION_NODE) int Node_isAncestor(const DOM_Node *node, const DOM_Node *parent) { if (parent == NULL) { return 0; } else if (node == parent) { return 1; } return Node_isAncestor(node, parent->parentNode); } DOM_Node * DOM_Node_insertBefore(DOM_Node *node, DOM_Node *newChild, DOM_Node *refChild) { NodeEntry *e; int addingDocumentElement; if (node == NULL || newChild == NULL) { DOM_Exception = DOM_NULL_POINTER_ERR; return NULL; } if (newChild->ownerDocument != node->ownerDocument) { DOM_Exception = DOM_WRONG_DOCUMENT_ERR; return NULL; } addingDocumentElement = node->nodeType == DOM_DOCUMENT_NODE && newChild->nodeType == DOM_ELEMENT_NODE; if ((refChild != NULL && refChild->parentNode != node) || CANNOT_HAVE_CHILDREN(node->nodeType) || Node_isAncestor(newChild, node) || (addingDocumentElement && node->u.Document.documentElement)) { DOM_Exception = DOM_HIERARCHY_REQUEST_ERR; return NULL; } if (newChild->nodeType == DOM_DOCUMENT_FRAGMENT_NODE) { DOM_Node *n, *nxt; for (n = newChild->firstChild; n != NULL; n = nxt) { nxt = n->nextSibling; if (DOM_Node_removeChild(newChild, n) == NULL) { return NULL; } if (DOM_Node_insertBefore(node, n, refChild) == NULL) { DOM_Document_destroyNode(n->ownerDocument, n); return NULL; } } return newChild; } if ((e = NodeList_insert(node->childNodes, newChild, refChild)) == NULL) { return NULL; } if (node->firstChild == NULL) { node->firstChild = node->lastChild = newChild; newChild->previousSibling = NULL; newChild->nextSibling = NULL; } else if (refChild == NULL) { newChild->previousSibling = node->lastChild; node->lastChild->nextSibling = newChild; node->lastChild = newChild; newChild->nextSibling = NULL; } else { newChild->previousSibling = refChild->previousSibling; newChild->nextSibling = refChild; if (refChild == node->firstChild) { node->firstChild = newChild; newChild->previousSibling = NULL; } else { refChild->previousSibling->nextSibling = newChild; } refChild->previousSibling = newChild; } newChild->parentNode = node; if (addingDocumentElement) { node->u.Document.documentElement = newChild; } return newChild; } DOM_Node * DOM_Node_replaceChild(DOM_Node *node, DOM_Node *newChild, DOM_Node *oldChild) { DOM_Node *tmp; int addingDocumentElement; if (node == NULL || newChild == NULL || oldChild == NULL) { DOM_Exception = DOM_NULL_POINTER_ERR; return NULL; } if (newChild->ownerDocument != node->ownerDocument || oldChild->ownerDocument != node->ownerDocument) { DOM_Exception = DOM_WRONG_DOCUMENT_ERR; return NULL; } addingDocumentElement = node->nodeType == DOM_DOCUMENT_NODE && newChild->nodeType == DOM_ELEMENT_NODE; if (oldChild->parentNode != node || Node_isAncestor(newChild, node) || (addingDocumentElement && node->u.Document.documentElement && oldChild->nodeType != DOM_ELEMENT_NODE)) { DOM_Exception = DOM_HIERARCHY_REQUEST_ERR; return NULL; } for (tmp = node->firstChild; tmp != NULL && tmp != oldChild; tmp = tmp->nextSibling) { ; } if (tmp != oldChild) { DOM_Exception = DOM_NOT_FOUND_ERR; return NULL; } if (newChild->nodeType == DOM_DOCUMENT_FRAGMENT_NODE) { DOM_Node *n, *nxt; for (n = newChild->firstChild; n != NULL; n = nxt) { nxt = n->nextSibling; if (DOM_Node_removeChild(newChild, n) == NULL) { return NULL; } if (DOM_Node_insertBefore(node, n, oldChild) == NULL) { DOM_Document_destroyNode(n->ownerDocument, n); return NULL; } } if (DOM_Node_removeChild(node, oldChild) == NULL) { return NULL; } return oldChild; } DOM_Node_removeChild(node, newChild); if (NodeList_replace(node->childNodes, newChild, oldChild) == NULL) { return NULL; } node->firstChild = node->childNodes->first->node; node->lastChild = node->childNodes->last->node; if ((newChild->previousSibling = oldChild->previousSibling)) { newChild->previousSibling->nextSibling = newChild; } if ((newChild->nextSibling = oldChild->nextSibling)) { newChild->nextSibling->previousSibling = newChild; } newChild->parentNode = node; oldChild->parentNode = NULL; oldChild->previousSibling = NULL; oldChild->nextSibling = NULL; if (addingDocumentElement) { node->u.Document.documentElement = newChild; } return oldChild; } DOM_Node * DOM_Node_removeChild(DOM_Node *node, DOM_Node *oldChild) { NodeEntry *e; if (node == NULL || oldChild == NULL) { DOM_Exception = DOM_NULL_POINTER_ERR; return NULL; } if (oldChild->ownerDocument != node->ownerDocument) { DOM_Exception = DOM_WRONG_DOCUMENT_ERR; return NULL; } if ((e = NodeList_remove(node->childNodes, oldChild)) == NULL) { return NULL; } else { free(e); } if (node->firstChild == node->lastChild) { node->firstChild = node->lastChild = NULL; } else if (oldChild == node->firstChild) { node->firstChild = oldChild->nextSibling; node->firstChild->previousSibling = NULL; } else if (oldChild == node->lastChild) { node->lastChild = oldChild->previousSibling; node->lastChild->nextSibling = NULL; } else { oldChild->previousSibling->nextSibling = oldChild->nextSibling; oldChild->nextSibling->previousSibling = oldChild->previousSibling; } oldChild->previousSibling = NULL; oldChild->nextSibling = NULL; oldChild->parentNode = NULL; if (node->nodeType == DOM_DOCUMENT_NODE && oldChild->nodeType == DOM_ELEMENT_NODE) { node->u.Document.documentElement = NULL; } return oldChild; } DOM_Node * DOM_Node_appendChild(DOM_Node *node, DOM_Node *newChild) { int addingDocumentElement; if (node == NULL || newChild == NULL) { DOM_Exception = DOM_NULL_POINTER_ERR; return NULL; } if (newChild->ownerDocument != node->ownerDocument) { DOM_Exception = DOM_WRONG_DOCUMENT_ERR; return NULL; } addingDocumentElement = node->nodeType == DOM_DOCUMENT_NODE && newChild->nodeType == DOM_ELEMENT_NODE; if (CANNOT_HAVE_CHILDREN(node->nodeType) || Node_isAncestor(newChild, node) || (addingDocumentElement && node->u.Document.documentElement)) { DOM_Exception = DOM_HIERARCHY_REQUEST_ERR; return NULL; } if (newChild->nodeType == DOM_DOCUMENT_FRAGMENT_NODE) { DOM_Node *n, *nxt; for (n = newChild->firstChild; n != NULL; n = nxt) { nxt = n->nextSibling; if (DOM_Node_removeChild(newChild, n) == NULL) { return NULL; } if (DOM_Node_appendChild(node, n) == NULL) { DOM_Document_destroyNode(n->ownerDocument, n); return NULL; } } return newChild; } DOM_Node_removeChild(node, newChild); if (NodeList_append(node->childNodes, newChild) == NULL) { return NULL; } if (node->firstChild == NULL) { node->firstChild = node->lastChild = newChild; newChild->previousSibling = NULL; newChild->nextSibling = NULL; } else { node->lastChild->nextSibling = newChild; newChild->previousSibling = node->lastChild; node->lastChild = newChild; } newChild->nextSibling = NULL; newChild->parentNode = node; if (addingDocumentElement) { node->u.Document.documentElement = newChild; } return newChild; } int DOM_Node_hasChildNodes(const DOM_Node *node) { return node != NULL && node->firstChild; } DOM_Node * DOM_Node_cloneNode(DOM_Node *node, int deep) { DOM_Node *clone = NULL; DOM_Node *ntmp, *ctmp; NodeEntry *e; if (node == NULL) { DOM_Exception = DOM_NULL_POINTER_ERR; return NULL; } switch(node->nodeType) { case DOM_ELEMENT_NODE: clone = DOM_Document_createElement(node->ownerDocument, node->nodeName); if (clone) { for (e = node->attributes->first; e != NULL; e = e->next) { if ((ctmp = DOM_Node_cloneNode(e->node, deep)) == NULL || NodeList_append(clone->attributes, ctmp) == NULL) { DOM_Document_destroyNode(clone->ownerDocument, ctmp); DOM_Document_destroyNode(clone->ownerDocument, clone); return NULL; } } } break; case DOM_ATTRIBUTE_NODE: if ((clone = DOM_Document_createAttribute(node->ownerDocument, node->nodeName))) { clone->u.Attr.specified = node->u.Attr.specified; free(clone->nodeValue); clone->u.Attr.value = clone->nodeValue = DOM_String_dup(node->nodeValue); if (clone->u.Attr.value == NULL) { DOM_Exception = DOM_NO_MEMORY_ERR; return NULL; } } break; case DOM_COMMENT_NODE: clone = DOM_Document_createComment(node->ownerDocument, node->nodeValue); break; case DOM_TEXT_NODE: clone = DOM_Document_createTextNode(node->ownerDocument, node->nodeValue); break; case DOM_CDATA_SECTION_NODE: clone = DOM_Document_createCDATASection(node->ownerDocument, node->nodeValue); break; case DOM_DOCUMENT_NODE: clone = DOM_Implementation_createDocument(NULL, NULL, NULL); break; case DOM_DOCUMENT_FRAGMENT_NODE: clone = DOM_Document_createDocumentFragment(node->ownerDocument); break; case DOM_PROCESSING_INSTRUCTION_NODE: clone = DOM_Document_createProcessingInstruction(node->ownerDocument, node->u.ProcessingInstruction.target, node->u.ProcessingInstruction.data); break; case DOM_ENTITY_REFERENCE_NODE: case DOM_ENTITY_NODE: case DOM_DOCUMENT_TYPE_NODE: case DOM_NOTATION_NODE: DOM_Exception = DOM_NOT_SUPPORTED_ERR; return NULL; } if (clone && node->childNodes) { for (ntmp = node->firstChild; ntmp != NULL; ntmp = ntmp->nextSibling) { ctmp = DOM_Node_cloneNode(ntmp, deep); if (ctmp == NULL || DOM_Node_appendChild(clone, ctmp) == NULL) { DOM_Document_destroyNode(clone->ownerDocument, ctmp); DOM_Document_destroyNode(clone->ownerDocument, clone); return NULL; } } } //DBL: erase next line if (DOM_Node_hasChildNodes(node)) {} return clone; } visp-3.0.1/3rdparty/libatidaq-c/readme.txt000066400000000000000000000137071304511007300204160ustar00rootroot00000000000000ATI DAQ F/T C Library (v1.0.6) ----------------------------------------- The purpose of this C library is to load and parse calibration files for ATI DAQ F/T transducers, and perform the necessary calculations to convert raw voltages from a data acquisition system into forces and torques. Neither the library itself or the sample applications provide hardware I/O. These functions must be provided by your hardware's device drivers. If you are developing an application for the Windows environment, we recommend you use the ATIDAQFT ActiveX Automation Server or the ATICombinedDAQFT .NET assembly. Licensing --------- All of the software including in this package is distributed under the MIT License: Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. http://www.opensource.org/licenses/mit-license.html Library Files ----------------- The following files should be compiled as part of your project: ftconfig.c ftrt.c dom.c expatls.c node.c stack.c xmlparse.c xmlrole.c xmltok.c In addition to the above files, the files "events.c", "xmltok_impl.c", and "xmltok_ns.c" are also included in this library, but are not meant to be directly compiled, as they are '#include'd into other library files. None of these files are intended to be modified. Sample Applications ---------------------------- Two sample applications are included in the Samples folder. ftconvert.c - demonstrates configuring a DAQ F/T system and performing force/torque calculations; converts a sample set of voltages into forces and torques. calinfo.c - demonstrates retrieving information from the calibration file such as the transducer's rated loads, calibration date, and other information. Programming Interface ------------------------------- The functions supported for public use are: createCalibration - Loads calibration info for a transducer from a calibration file destroyCalibration - Frees memory allocated by a successful call to createCalibration SetToolTransform - Performs a 6-axis translation/rotation on the transducer's coordinate system SetForceUnits - Sets the units of force output SetTorqueUnits - Sets the units of torque outputEnables or disables temperature compensation, if available Bias - Stores a voltage reading to be subtracted from subsequent readings, effectively "zeroing" the transducer output to remove tooling weight, etc. ConvertToFT - Converts an array of voltages into forces and torques These functions are documented in ftconfig.h. You can also read information about the transducer system and calibration from the Calibration and other structures. These structures should be treated as read-only and should only be manipulated through the functions listed above. The sample application calinfo.c shows how to retrieve this information. The general structure of an application should follow the following structure: 1. Call the createCalibration() method to load a calibration file into memory. 2. Call the SetForceUnits(), SetTorqueUnits(), SetCalibration(), and SetToolTransform() functions to configure the system. 3. Use device driver calls to retrieve an array of voltages from your data acquisition system. 4. Use the Bias() function to store a baseline reading (zero the transducer) 5. Use the ConvertToFT() function to convert another array of voltages into forces and torques. The Bias reading will be subtracted automatically. 6. Call the destroyCalibration() function to free memory allocated for the Calibration structure created in step 1. Optimizing Your Application -------------------------------------- The bare minimum calculations for converting voltages into forces and torques are in ftrt.c. To isolate this section of the code, simply compile ftrc.c. This file #includes ftrc.h, but none of the other files. This can be useful, for example, in an embedded application where the configuration never changes. You can write a separate configuration program to run on a PC, which sends the contents of the Calibration.rt structure to a local copy of the RTCoefs structure in the embedded system. Version History ---------------------- 1.0.6 Added support for kN-m torque units, changed reference to ActiveX server to also reference .NET assembly. 1.0.5 Moved some declarations out of .h files into .c files to avoid multiple definition errors. Added ftsharedrt.h 1.0.4 Added newlines to the ends of several files to avoid warnings when compiling with gcc. FTconfig.c was using '/t' instead of '\t' for tab character, which caused warnings under gcc, but no warnings or errors under Visual C++. 1.0.3 Added comments to ftconvert.c explaining hardware temperature compensation. 1.0.2 Fixed memory leaks 1.0.0 No changes Released 2-1-02 0.7.1 Added necessary licensing info to all files Beta released 10-5-01 0.7.0 Initial beta release; no known bugs; compiles with no errors or warnings in Microsoft Visual Studio.NET Beta released 10-2-01visp-3.0.1/3rdparty/libatidaq-c/stack.c000066400000000000000000000077411304511007300176720ustar00rootroot00000000000000/* * Copyright (c) 2001 Michael B. Allen * * The MIT License * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR * OTHER DEALINGS IN THE SOFTWARE. */ /* stack.c - a dynamically resizing stack */ #include #include #include #include "stack.h" #define STACK_INIT_SIZE 32 struct stack { unsigned int max_size; unsigned int sp; unsigned int size; unsigned int iter; void **array; }; struct stack * stack_new(unsigned int max_size) { struct stack *s = malloc(sizeof *s); if (s) { s->max_size = max_size; s->size = max_size < STACK_INIT_SIZE ? max_size : STACK_INIT_SIZE; s->sp = 0; s->array = malloc(sizeof *s->array * s->size); if (s->array == NULL) { free(s); s = NULL; } } return s; } void stack_del(struct stack *s, void (*free_data_fn)(void *)) { if (s == NULL) { return; } if (free_data_fn) { while (s->sp > 0) { free_data_fn(s->array[--(s->sp)]); } } free(s->array); free(s); } void stack_clear(struct stack *s, void (*free_data_fn)(void *)) { if (s == NULL) { return; } if (free_data_fn) { while (s->sp > 0) { free_data_fn(s->array[--(s->sp)]); } } } void stack_iterate(struct stack *s) { if (s) { s->iter = 0; } } void * stack_next(struct stack *s) { if (s && s->iter < s->sp) { return s->array[s->iter++]; } return NULL; } void * stack_peek(struct stack *s) { if (s == NULL || s->sp == 0) { return NULL; } return s->array[s->sp - 1]; } int stack_push(struct stack *s, void *data) { if (s == NULL) { return 0; } if (s->sp == s->size) { void **new_array; unsigned int new_size; if (s->size == s->max_size) { return 0; } if (s->size * 2 > s->max_size) { new_size = s->max_size; } else { new_size = s->size * 2; } new_array = realloc(s->array, sizeof *s->array * new_size); if (new_array == NULL) { return 0; } s->size = new_size; s->array = new_array; } assert(s->sp >= 0 && s->sp <= s->size); s->array[s->sp++] = data; return 1; } void * stack_pop(struct stack *s) { if (s == NULL || s->sp == 0) { return NULL; } if (s->size >= STACK_INIT_SIZE * 4 && s->sp < s->size / 4) { void **new_array; unsigned int new_size = s->size / 2; new_array = realloc(s->array, sizeof *s->array * new_size); if (new_array) { s->array = new_array; s->size = new_size; } } assert(s->sp > 0 && s->sp <= s->size); return s->array[--(s->sp)]; } int stack_is_empty(const struct stack *s) { return s == NULL || s->sp == 0; } unsigned int stack_size(const struct stack *s) { return s == NULL ? 0 : s->sp; } visp-3.0.1/3rdparty/libatidaq-c/stack.h000066400000000000000000000033661304511007300176760ustar00rootroot00000000000000/* * Copyright (c) 2001 Michael B. Allen * * The MIT License * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR * OTHER DEALINGS IN THE SOFTWARE. */ /* stack.h - a dynamically resizing stack */ #ifndef STACK_H #define STACK_H struct stack; struct stack *stack_new(unsigned int max_size); void stack_del(struct stack *s, void (*free_data_fn)(void *)); void stack_clear(struct stack *s, void (*free_data_fn)(void *)); int stack_push(struct stack *s, void *data); void *stack_pop(struct stack *s); int stack_is_empty(const struct stack *s); unsigned int stack_size(const struct stack *s); void stack_iterate(struct stack *s); void *stack_next(struct stack *s); void *stack_peek(struct stack *s); #endif /* STACK_H */ visp-3.0.1/3rdparty/libatidaq-c/utf8tab.h000066400000000000000000000054701304511007300201440ustar00rootroot00000000000000/* Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd * * The MIT License * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR * OTHER DEALINGS IN THE SOFTWARE. */ /* 0x80 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL, /* 0x84 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL, /* 0x88 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL, /* 0x8C */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL, /* 0x90 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL, /* 0x94 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL, /* 0x98 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL, /* 0x9C */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL, /* 0xA0 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL, /* 0xA4 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL, /* 0xA8 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL, /* 0xAC */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL, /* 0xB0 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL, /* 0xB4 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL, /* 0xB8 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL, /* 0xBC */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL, /* 0xC0 */ BT_LEAD2, BT_LEAD2, BT_LEAD2, BT_LEAD2, /* 0xC4 */ BT_LEAD2, BT_LEAD2, BT_LEAD2, BT_LEAD2, /* 0xC8 */ BT_LEAD2, BT_LEAD2, BT_LEAD2, BT_LEAD2, /* 0xCC */ BT_LEAD2, BT_LEAD2, BT_LEAD2, BT_LEAD2, /* 0xD0 */ BT_LEAD2, BT_LEAD2, BT_LEAD2, BT_LEAD2, /* 0xD4 */ BT_LEAD2, BT_LEAD2, BT_LEAD2, BT_LEAD2, /* 0xD8 */ BT_LEAD2, BT_LEAD2, BT_LEAD2, BT_LEAD2, /* 0xDC */ BT_LEAD2, BT_LEAD2, BT_LEAD2, BT_LEAD2, /* 0xE0 */ BT_LEAD3, BT_LEAD3, BT_LEAD3, BT_LEAD3, /* 0xE4 */ BT_LEAD3, BT_LEAD3, BT_LEAD3, BT_LEAD3, /* 0xE8 */ BT_LEAD3, BT_LEAD3, BT_LEAD3, BT_LEAD3, /* 0xEC */ BT_LEAD3, BT_LEAD3, BT_LEAD3, BT_LEAD3, /* 0xF0 */ BT_LEAD4, BT_LEAD4, BT_LEAD4, BT_LEAD4, /* 0xF4 */ BT_LEAD4, BT_NONXML, BT_NONXML, BT_NONXML, /* 0xF8 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML, /* 0xFC */ BT_NONXML, BT_NONXML, BT_MALFORM, BT_MALFORM, visp-3.0.1/3rdparty/libatidaq-c/xmldef.h000066400000000000000000000043621304511007300200450ustar00rootroot00000000000000/* Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd * * The MIT License * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR * OTHER DEALINGS IN THE SOFTWARE. */ #include #ifdef XML_WINLIB #define WIN32_LEAN_AND_MEAN #define STRICT #include #define malloc(x) HeapAlloc(GetProcessHeap(), 0, (x)) #define calloc(x, y) HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, (x)*(y)) #define free(x) HeapFree(GetProcessHeap(), 0, (x)) #define realloc(x, y) HeapReAlloc(GetProcessHeap(), 0, x, y) #define abort() /* as nothing */ #else /* not XML_WINLIB */ #include #endif /* not XML_WINLIB */ /* This file can be used for any definitions needed in particular environments. */ /* Mozilla specific defines */ #ifdef MOZILLA_CLIENT #include "nspr.h" #define malloc(x) PR_Malloc((size_t)(x)) #define realloc(x, y) PR_Realloc((x), (size_t)(y)) #define calloc(x, y) PR_Calloc((x),(y)) #define free(x) PR_Free(x) #if PR_BYTES_PER_INT != 4 #define int int32 #endif /* Enable Unicode string processing in expat. */ #ifndef XML_UNICODE #define XML_UNICODE #endif /* Enable external parameter entity parsing in expat */ #ifndef XML_DTD #define XML_DTD 1 #endif #endif /* MOZILLA_CLIENT */ visp-3.0.1/3rdparty/libatidaq-c/xmlparse.c000066400000000000000000003344041304511007300204170ustar00rootroot00000000000000/* Copyright (c) 1998, 1999, 2000 Thai Open Source Software Center Ltd * * The MIT License * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR * OTHER DEALINGS IN THE SOFTWARE. */ #include "xmldef.h" #include "xmlparse.h" #include #ifdef XML_UNICODE #define XML_ENCODE_MAX XML_UTF16_ENCODE_MAX #define XmlConvert XmlUtf16Convert #define XmlGetInternalEncoding XmlGetUtf16InternalEncoding #define XmlGetInternalEncodingNS XmlGetUtf16InternalEncodingNS #define XmlEncode XmlUtf16Encode #define MUST_CONVERT(enc, s) (!(enc)->isUtf16 || (((unsigned long)s) & 1)) typedef unsigned short ICHAR; #else #define XML_ENCODE_MAX XML_UTF8_ENCODE_MAX #define XmlConvert XmlUtf8Convert #define XmlGetInternalEncoding XmlGetUtf8InternalEncoding #define XmlGetInternalEncodingNS XmlGetUtf8InternalEncodingNS #define XmlEncode XmlUtf8Encode #define MUST_CONVERT(enc, s) (!(enc)->isUtf8) typedef char ICHAR; #endif #ifndef XML_NS #define XmlInitEncodingNS XmlInitEncoding #define XmlInitUnknownEncodingNS XmlInitUnknownEncoding #undef XmlGetInternalEncodingNS #define XmlGetInternalEncodingNS XmlGetInternalEncoding #define XmlParseXmlDeclNS XmlParseXmlDecl #endif #ifdef XML_UNICODE_WCHAR_T #define XML_T(x) L ## x #else #define XML_T(x) x #endif /* Round up n to be a multiple of sz, where sz is a power of 2. */ #define ROUND_UP(n, sz) (((n) + ((sz) - 1)) & ~((sz) - 1)) #include "xmltok.h" #include "xmlrole.h" typedef const XML_Char *KEY; typedef struct { KEY name; } NAMED; typedef struct { NAMED **v; size_t size; size_t used; size_t usedLim; } HASH_TABLE; typedef struct { NAMED **p; NAMED **end; } HASH_TABLE_ITER; #define INIT_TAG_BUF_SIZE 32 /* must be a multiple of sizeof(XML_Char) */ #define INIT_DATA_BUF_SIZE 1024 #define INIT_ATTS_SIZE 16 #define INIT_BLOCK_SIZE 1024 #define INIT_BUFFER_SIZE 1024 #define EXPAND_SPARE 24 typedef struct binding { struct prefix *prefix; struct binding *nextTagBinding; struct binding *prevPrefixBinding; const struct attribute_id *attId; XML_Char *uri; int uriLen; int uriAlloc; } BINDING; typedef struct prefix { const XML_Char *name; BINDING *binding; } PREFIX; typedef struct { const XML_Char *str; const XML_Char *localPart; int uriLen; } TAG_NAME; typedef struct tag { struct tag *parent; const char *rawName; int rawNameLength; TAG_NAME name; char *buf; char *bufEnd; BINDING *bindings; } TAG; typedef struct { const XML_Char *name; const XML_Char *textPtr; int textLen; const XML_Char *systemId; const XML_Char *base; const XML_Char *publicId; const XML_Char *notation; char open; } ENTITY; typedef struct block { struct block *next; int size; XML_Char s[1]; } BLOCK; typedef struct { BLOCK *blocks; BLOCK *freeBlocks; const XML_Char *end; XML_Char *ptr; XML_Char *start; } STRING_POOL; /* The XML_Char before the name is used to determine whether an attribute has been specified. */ typedef struct attribute_id { XML_Char *name; PREFIX *prefix; char maybeTokenized; char xmlns; } ATTRIBUTE_ID; typedef struct { const ATTRIBUTE_ID *id; char isCdata; const XML_Char *value; } DEFAULT_ATTRIBUTE; typedef struct { const XML_Char *name; PREFIX *prefix; const ATTRIBUTE_ID *idAtt; int nDefaultAtts; int allocDefaultAtts; DEFAULT_ATTRIBUTE *defaultAtts; } ELEMENT_TYPE; typedef struct { HASH_TABLE generalEntities; HASH_TABLE elementTypes; HASH_TABLE attributeIds; HASH_TABLE prefixes; STRING_POOL pool; int complete; int standalone; #ifdef XML_DTD HASH_TABLE paramEntities; #endif /* XML_DTD */ PREFIX defaultPrefix; } DTD; typedef struct open_internal_entity { const char *internalEventPtr; const char *internalEventEndPtr; struct open_internal_entity *next; ENTITY *entity; } OPEN_INTERNAL_ENTITY; typedef enum XML_Error Processor(XML_Parser parser, const char *start, const char *end, const char **endPtr); static Processor prologProcessor; static Processor prologInitProcessor; static Processor contentProcessor; static Processor cdataSectionProcessor; #ifdef XML_DTD static Processor ignoreSectionProcessor; #endif /* XML_DTD */ static Processor epilogProcessor; static Processor errorProcessor; static Processor externalEntityInitProcessor; static Processor externalEntityInitProcessor2; static Processor externalEntityInitProcessor3; static Processor externalEntityContentProcessor; static enum XML_Error handleUnknownEncoding(XML_Parser parser, const XML_Char *encodingName); static enum XML_Error processXmlDecl(XML_Parser parser, int isGeneralTextEntity, const char *, const char *); static enum XML_Error initializeEncoding(XML_Parser parser); static enum XML_Error doProlog(XML_Parser parser, const ENCODING *enc, const char *s, const char *end, int tok, const char *next, const char **nextPtr); static enum XML_Error processInternalParamEntity(XML_Parser parser, ENTITY *entity); static enum XML_Error doContent(XML_Parser parser, int startTagLevel, const ENCODING *enc, const char *start, const char *end, const char **endPtr); static enum XML_Error doCdataSection(XML_Parser parser, const ENCODING *, const char **startPtr, const char *end, const char **nextPtr); #ifdef XML_DTD static enum XML_Error doIgnoreSection(XML_Parser parser, const ENCODING *, const char **startPtr, const char *end, const char **nextPtr); #endif /* XML_DTD */ static enum XML_Error storeAtts(XML_Parser parser, const ENCODING *, const char *s, TAG_NAME *tagNamePtr, BINDING **bindingsPtr); static int addBinding(XML_Parser parser, PREFIX *prefix, const ATTRIBUTE_ID *attId, const XML_Char *uri, BINDING **bindingsPtr); static int defineAttribute(ELEMENT_TYPE *type, ATTRIBUTE_ID *, int isCdata, int isId, const XML_Char *dfltValue); static enum XML_Error storeAttributeValue(XML_Parser parser, const ENCODING *, int isCdata, const char *, const char *, STRING_POOL *); static enum XML_Error appendAttributeValue(XML_Parser parser, const ENCODING *, int isCdata, const char *, const char *, STRING_POOL *); static ATTRIBUTE_ID * getAttributeId(XML_Parser parser, const ENCODING *enc, const char *start, const char *end); static int setElementTypePrefix(XML_Parser parser, ELEMENT_TYPE *); static enum XML_Error storeEntityValue(XML_Parser parser, const ENCODING *enc, const char *start, const char *end); static int reportProcessingInstruction(XML_Parser parser, const ENCODING *enc, const char *start, const char *end); static int reportComment(XML_Parser parser, const ENCODING *enc, const char *start, const char *end); static void reportDefault(XML_Parser parser, const ENCODING *enc, const char *start, const char *end); static const XML_Char *getContext(XML_Parser parser); static int setContext(XML_Parser parser, const XML_Char *context); static void normalizePublicId(XML_Char *s); static int dtdInit(DTD *); static void dtdDestroy(DTD *); static int dtdCopy(DTD *newDtd, const DTD *oldDtd); static int copyEntityTable(HASH_TABLE *, STRING_POOL *, const HASH_TABLE *); #ifdef XML_DTD static void dtdSwap(DTD *, DTD *); #endif /* XML_DTD */ static NAMED *lookup(HASH_TABLE *table, KEY name, size_t createSize); static void hashTableInit(HASH_TABLE *); static void hashTableDestroy(HASH_TABLE *); static void hashTableIterInit(HASH_TABLE_ITER *, const HASH_TABLE *); static NAMED *hashTableIterNext(HASH_TABLE_ITER *); static void poolInit(STRING_POOL *); static void poolClear(STRING_POOL *); static void poolDestroy(STRING_POOL *); static XML_Char *poolAppend(STRING_POOL *pool, const ENCODING *enc, const char *ptr, const char *end); static XML_Char *poolStoreString(STRING_POOL *pool, const ENCODING *enc, const char *ptr, const char *end); static int poolGrow(STRING_POOL *pool); static const XML_Char *poolCopyString(STRING_POOL *pool, const XML_Char *s); static const XML_Char *poolCopyStringN(STRING_POOL *pool, const XML_Char *s, int n); #define poolStart(pool) ((pool)->start) #define poolEnd(pool) ((pool)->ptr) #define poolLength(pool) ((pool)->ptr - (pool)->start) #define poolChop(pool) ((void)--(pool->ptr)) #define poolLastChar(pool) (((pool)->ptr)[-1]) #define poolDiscard(pool) ((pool)->ptr = (pool)->start) #define poolFinish(pool) ((pool)->start = (pool)->ptr) #define poolAppendChar(pool, c) \ (((pool)->ptr == (pool)->end && !poolGrow(pool)) \ ? 0 \ : ((*((pool)->ptr)++ = c), 1)) typedef struct { /* The first member must be userData so that the XML_GetUserData macro works. */ void *m_userData; void *m_handlerArg; char *m_buffer; /* first character to be parsed */ const char *m_bufferPtr; /* past last character to be parsed */ char *m_bufferEnd; /* allocated end of buffer */ const char *m_bufferLim; long m_parseEndByteIndex; const char *m_parseEndPtr; XML_Char *m_dataBuf; XML_Char *m_dataBufEnd; XML_StartElementHandler m_startElementHandler; XML_EndElementHandler m_endElementHandler; XML_CharacterDataHandler m_characterDataHandler; XML_ProcessingInstructionHandler m_processingInstructionHandler; XML_CommentHandler m_commentHandler; XML_StartCdataSectionHandler m_startCdataSectionHandler; XML_EndCdataSectionHandler m_endCdataSectionHandler; XML_DefaultHandler m_defaultHandler; XML_StartDoctypeDeclHandler m_startDoctypeDeclHandler; XML_EndDoctypeDeclHandler m_endDoctypeDeclHandler; XML_UnparsedEntityDeclHandler m_unparsedEntityDeclHandler; XML_NotationDeclHandler m_notationDeclHandler; XML_ExternalParsedEntityDeclHandler m_externalParsedEntityDeclHandler; XML_InternalParsedEntityDeclHandler m_internalParsedEntityDeclHandler; XML_StartNamespaceDeclHandler m_startNamespaceDeclHandler; XML_EndNamespaceDeclHandler m_endNamespaceDeclHandler; XML_NotStandaloneHandler m_notStandaloneHandler; XML_ExternalEntityRefHandler m_externalEntityRefHandler; void *m_externalEntityRefHandlerArg; XML_UnknownEncodingHandler m_unknownEncodingHandler; const ENCODING *m_encoding; INIT_ENCODING m_initEncoding; const ENCODING *m_internalEncoding; const XML_Char *m_protocolEncodingName; int m_ns; void *m_unknownEncodingMem; void *m_unknownEncodingData; void *m_unknownEncodingHandlerData; void (*m_unknownEncodingRelease)(void *); PROLOG_STATE m_prologState; Processor *m_processor; enum XML_Error m_errorCode; const char *m_eventPtr; const char *m_eventEndPtr; const char *m_positionPtr; OPEN_INTERNAL_ENTITY *m_openInternalEntities; int m_defaultExpandInternalEntities; int m_tagLevel; ENTITY *m_declEntity; const XML_Char *m_declNotationName; const XML_Char *m_declNotationPublicId; ELEMENT_TYPE *m_declElementType; ATTRIBUTE_ID *m_declAttributeId; char m_declAttributeIsCdata; char m_declAttributeIsId; DTD m_dtd; const XML_Char *m_curBase; TAG *m_tagStack; TAG *m_freeTagList; BINDING *m_inheritedBindings; BINDING *m_freeBindingList; int m_attsSize; int m_nSpecifiedAtts; int m_idAttIndex; ATTRIBUTE *m_atts; POSITION m_position; STRING_POOL m_tempPool; STRING_POOL m_temp2Pool; char *m_groupConnector; unsigned m_groupSize; int m_hadExternalDoctype; XML_Char m_namespaceSeparator; #ifdef XML_DTD enum XML_ParamEntityParsing m_paramEntityParsing; XML_Parser m_parentParser; #endif } Parser; #define userData (((Parser *)parser)->m_userData) #define handlerArg (((Parser *)parser)->m_handlerArg) #define startElementHandler (((Parser *)parser)->m_startElementHandler) #define endElementHandler (((Parser *)parser)->m_endElementHandler) #define characterDataHandler (((Parser *)parser)->m_characterDataHandler) #define processingInstructionHandler (((Parser *)parser)->m_processingInstructionHandler) #define commentHandler (((Parser *)parser)->m_commentHandler) #define startCdataSectionHandler (((Parser *)parser)->m_startCdataSectionHandler) #define endCdataSectionHandler (((Parser *)parser)->m_endCdataSectionHandler) #define defaultHandler (((Parser *)parser)->m_defaultHandler) #define startDoctypeDeclHandler (((Parser *)parser)->m_startDoctypeDeclHandler) #define endDoctypeDeclHandler (((Parser *)parser)->m_endDoctypeDeclHandler) #define unparsedEntityDeclHandler (((Parser *)parser)->m_unparsedEntityDeclHandler) #define notationDeclHandler (((Parser *)parser)->m_notationDeclHandler) #define externalParsedEntityDeclHandler (((Parser *)parser)->m_externalParsedEntityDeclHandler) #define internalParsedEntityDeclHandler (((Parser *)parser)->m_internalParsedEntityDeclHandler) #define startNamespaceDeclHandler (((Parser *)parser)->m_startNamespaceDeclHandler) #define endNamespaceDeclHandler (((Parser *)parser)->m_endNamespaceDeclHandler) #define notStandaloneHandler (((Parser *)parser)->m_notStandaloneHandler) #define externalEntityRefHandler (((Parser *)parser)->m_externalEntityRefHandler) #define externalEntityRefHandlerArg (((Parser *)parser)->m_externalEntityRefHandlerArg) #define unknownEncodingHandler (((Parser *)parser)->m_unknownEncodingHandler) #define encoding (((Parser *)parser)->m_encoding) #define initEncoding (((Parser *)parser)->m_initEncoding) #define internalEncoding (((Parser *)parser)->m_internalEncoding) #define unknownEncodingMem (((Parser *)parser)->m_unknownEncodingMem) #define unknownEncodingData (((Parser *)parser)->m_unknownEncodingData) #define unknownEncodingHandlerData \ (((Parser *)parser)->m_unknownEncodingHandlerData) #define unknownEncodingRelease (((Parser *)parser)->m_unknownEncodingRelease) #define protocolEncodingName (((Parser *)parser)->m_protocolEncodingName) #define ns (((Parser *)parser)->m_ns) #define prologState (((Parser *)parser)->m_prologState) #define processor (((Parser *)parser)->m_processor) #define errorCode (((Parser *)parser)->m_errorCode) #define eventPtr (((Parser *)parser)->m_eventPtr) #define eventEndPtr (((Parser *)parser)->m_eventEndPtr) #define positionPtr (((Parser *)parser)->m_positionPtr) #define position (((Parser *)parser)->m_position) #define openInternalEntities (((Parser *)parser)->m_openInternalEntities) #define defaultExpandInternalEntities (((Parser *)parser)->m_defaultExpandInternalEntities) #define tagLevel (((Parser *)parser)->m_tagLevel) #define buffer (((Parser *)parser)->m_buffer) #define bufferPtr (((Parser *)parser)->m_bufferPtr) #define bufferEnd (((Parser *)parser)->m_bufferEnd) #define parseEndByteIndex (((Parser *)parser)->m_parseEndByteIndex) #define parseEndPtr (((Parser *)parser)->m_parseEndPtr) #define bufferLim (((Parser *)parser)->m_bufferLim) #define dataBuf (((Parser *)parser)->m_dataBuf) #define dataBufEnd (((Parser *)parser)->m_dataBufEnd) #define dtd (((Parser *)parser)->m_dtd) #define curBase (((Parser *)parser)->m_curBase) #define declEntity (((Parser *)parser)->m_declEntity) #define declNotationName (((Parser *)parser)->m_declNotationName) #define declNotationPublicId (((Parser *)parser)->m_declNotationPublicId) #define declElementType (((Parser *)parser)->m_declElementType) #define declAttributeId (((Parser *)parser)->m_declAttributeId) #define declAttributeIsCdata (((Parser *)parser)->m_declAttributeIsCdata) #define declAttributeIsId (((Parser *)parser)->m_declAttributeIsId) #define freeTagList (((Parser *)parser)->m_freeTagList) #define freeBindingList (((Parser *)parser)->m_freeBindingList) #define inheritedBindings (((Parser *)parser)->m_inheritedBindings) #define tagStack (((Parser *)parser)->m_tagStack) #define atts (((Parser *)parser)->m_atts) #define attsSize (((Parser *)parser)->m_attsSize) #define nSpecifiedAtts (((Parser *)parser)->m_nSpecifiedAtts) #define idAttIndex (((Parser *)parser)->m_idAttIndex) #define tempPool (((Parser *)parser)->m_tempPool) #define temp2Pool (((Parser *)parser)->m_temp2Pool) #define groupConnector (((Parser *)parser)->m_groupConnector) #define groupSize (((Parser *)parser)->m_groupSize) #define hadExternalDoctype (((Parser *)parser)->m_hadExternalDoctype) #define namespaceSeparator (((Parser *)parser)->m_namespaceSeparator) #ifdef XML_DTD #define parentParser (((Parser *)parser)->m_parentParser) #define paramEntityParsing (((Parser *)parser)->m_paramEntityParsing) #endif /* XML_DTD */ #ifdef _MSC_VER #ifdef _DEBUG Parser *asParser(XML_Parser parser) { return parser; } #endif #endif XML_Parser XML_ParserCreate(const XML_Char *encodingName) { XML_Parser parser = malloc(sizeof(Parser)); if (!parser) return parser; processor = prologInitProcessor; XmlPrologStateInit(&prologState); userData = 0; handlerArg = 0; startElementHandler = 0; endElementHandler = 0; characterDataHandler = 0; processingInstructionHandler = 0; commentHandler = 0; startCdataSectionHandler = 0; endCdataSectionHandler = 0; defaultHandler = 0; startDoctypeDeclHandler = 0; endDoctypeDeclHandler = 0; unparsedEntityDeclHandler = 0; notationDeclHandler = 0; externalParsedEntityDeclHandler = 0; internalParsedEntityDeclHandler = 0; startNamespaceDeclHandler = 0; endNamespaceDeclHandler = 0; notStandaloneHandler = 0; externalEntityRefHandler = 0; externalEntityRefHandlerArg = parser; unknownEncodingHandler = 0; buffer = 0; bufferPtr = 0; bufferEnd = 0; parseEndByteIndex = 0; parseEndPtr = 0; bufferLim = 0; declElementType = 0; declAttributeId = 0; declEntity = 0; declNotationName = 0; declNotationPublicId = 0; memset(&position, 0, sizeof(POSITION)); errorCode = XML_ERROR_NONE; eventPtr = 0; eventEndPtr = 0; positionPtr = 0; openInternalEntities = 0; tagLevel = 0; tagStack = 0; freeTagList = 0; freeBindingList = 0; inheritedBindings = 0; attsSize = INIT_ATTS_SIZE; atts = malloc(attsSize * sizeof(ATTRIBUTE)); nSpecifiedAtts = 0; dataBuf = malloc(INIT_DATA_BUF_SIZE * sizeof(XML_Char)); groupSize = 0; groupConnector = 0; hadExternalDoctype = 0; unknownEncodingMem = 0; unknownEncodingRelease = 0; unknownEncodingData = 0; unknownEncodingHandlerData = 0; namespaceSeparator = '!'; #ifdef XML_DTD parentParser = 0; paramEntityParsing = XML_PARAM_ENTITY_PARSING_NEVER; #endif ns = 0; poolInit(&tempPool); poolInit(&temp2Pool); protocolEncodingName = encodingName ? poolCopyString(&tempPool, encodingName) : 0; curBase = 0; if (!dtdInit(&dtd) || !atts || !dataBuf || (encodingName && !protocolEncodingName)) { XML_ParserFree(parser); return 0; } dataBufEnd = dataBuf + INIT_DATA_BUF_SIZE; XmlInitEncoding(&initEncoding, &encoding, 0); internalEncoding = XmlGetInternalEncoding(); return parser; } XML_Parser XML_ParserCreateNS(const XML_Char *encodingName, XML_Char nsSep) { static const XML_Char implicitContext[] = { XML_T('x'), XML_T('m'), XML_T('l'), XML_T('='), XML_T('h'), XML_T('t'), XML_T('t'), XML_T('p'), XML_T(':'), XML_T('/'), XML_T('/'), XML_T('w'), XML_T('w'), XML_T('w'), XML_T('.'), XML_T('w'), XML_T('3'), XML_T('.'), XML_T('o'), XML_T('r'), XML_T('g'), XML_T('/'), XML_T('X'), XML_T('M'), XML_T('L'), XML_T('/'), XML_T('1'), XML_T('9'), XML_T('9'), XML_T('8'), XML_T('/'), XML_T('n'), XML_T('a'), XML_T('m'), XML_T('e'), XML_T('s'), XML_T('p'), XML_T('a'), XML_T('c'), XML_T('e'), XML_T('\0') }; XML_Parser parser = XML_ParserCreate(encodingName); if (parser) { XmlInitEncodingNS(&initEncoding, &encoding, 0); ns = 1; internalEncoding = XmlGetInternalEncodingNS(); namespaceSeparator = nsSep; } if (!setContext(parser, implicitContext)) { XML_ParserFree(parser); return 0; } return parser; } int XML_SetEncoding(XML_Parser parser, const XML_Char *encodingName) { if (!encodingName) protocolEncodingName = 0; else { protocolEncodingName = poolCopyString(&tempPool, encodingName); if (!protocolEncodingName) return 0; } return 1; } XML_Parser XML_ExternalEntityParserCreate(XML_Parser oldParser, const XML_Char *context, const XML_Char *encodingName) { XML_Parser parser = oldParser; DTD *oldDtd = &dtd; XML_StartElementHandler oldStartElementHandler = startElementHandler; XML_EndElementHandler oldEndElementHandler = endElementHandler; XML_CharacterDataHandler oldCharacterDataHandler = characterDataHandler; XML_ProcessingInstructionHandler oldProcessingInstructionHandler = processingInstructionHandler; XML_CommentHandler oldCommentHandler = commentHandler; XML_StartCdataSectionHandler oldStartCdataSectionHandler = startCdataSectionHandler; XML_EndCdataSectionHandler oldEndCdataSectionHandler = endCdataSectionHandler; XML_DefaultHandler oldDefaultHandler = defaultHandler; XML_UnparsedEntityDeclHandler oldUnparsedEntityDeclHandler = unparsedEntityDeclHandler; XML_NotationDeclHandler oldNotationDeclHandler = notationDeclHandler; XML_ExternalParsedEntityDeclHandler oldExternalParsedEntityDeclHandler = externalParsedEntityDeclHandler; XML_InternalParsedEntityDeclHandler oldInternalParsedEntityDeclHandler = internalParsedEntityDeclHandler; XML_StartNamespaceDeclHandler oldStartNamespaceDeclHandler = startNamespaceDeclHandler; XML_EndNamespaceDeclHandler oldEndNamespaceDeclHandler = endNamespaceDeclHandler; XML_NotStandaloneHandler oldNotStandaloneHandler = notStandaloneHandler; XML_ExternalEntityRefHandler oldExternalEntityRefHandler = externalEntityRefHandler; XML_UnknownEncodingHandler oldUnknownEncodingHandler = unknownEncodingHandler; void *oldUserData = userData; void *oldHandlerArg = handlerArg; int oldDefaultExpandInternalEntities = defaultExpandInternalEntities; void *oldExternalEntityRefHandlerArg = externalEntityRefHandlerArg; #ifdef XML_DTD int oldParamEntityParsing = paramEntityParsing; #endif parser = (ns ? XML_ParserCreateNS(encodingName, namespaceSeparator) : XML_ParserCreate(encodingName)); if (!parser) return 0; startElementHandler = oldStartElementHandler; endElementHandler = oldEndElementHandler; characterDataHandler = oldCharacterDataHandler; processingInstructionHandler = oldProcessingInstructionHandler; commentHandler = oldCommentHandler; startCdataSectionHandler = oldStartCdataSectionHandler; endCdataSectionHandler = oldEndCdataSectionHandler; defaultHandler = oldDefaultHandler; unparsedEntityDeclHandler = oldUnparsedEntityDeclHandler; notationDeclHandler = oldNotationDeclHandler; externalParsedEntityDeclHandler = oldExternalParsedEntityDeclHandler; internalParsedEntityDeclHandler = oldInternalParsedEntityDeclHandler; startNamespaceDeclHandler = oldStartNamespaceDeclHandler; endNamespaceDeclHandler = oldEndNamespaceDeclHandler; notStandaloneHandler = oldNotStandaloneHandler; externalEntityRefHandler = oldExternalEntityRefHandler; unknownEncodingHandler = oldUnknownEncodingHandler; userData = oldUserData; if (oldUserData == oldHandlerArg) handlerArg = userData; else handlerArg = parser; if (oldExternalEntityRefHandlerArg != oldParser) externalEntityRefHandlerArg = oldExternalEntityRefHandlerArg; defaultExpandInternalEntities = oldDefaultExpandInternalEntities; #ifdef XML_DTD paramEntityParsing = oldParamEntityParsing; if (context) { #endif /* XML_DTD */ if (!dtdCopy(&dtd, oldDtd) || !setContext(parser, context)) { XML_ParserFree(parser); return 0; } processor = externalEntityInitProcessor; #ifdef XML_DTD } else { dtdSwap(&dtd, oldDtd); parentParser = oldParser; XmlPrologStateInitExternalEntity(&prologState); dtd.complete = 1; hadExternalDoctype = 1; } #endif /* XML_DTD */ return parser; } static void destroyBindings(BINDING *bindings) { for (;;) { BINDING *b = bindings; if (!b) break; bindings = b->nextTagBinding; free(b->uri); free(b); } } void XML_ParserFree(XML_Parser parser) { for (;;) { TAG *p; if (tagStack == 0) { if (freeTagList == 0) break; tagStack = freeTagList; freeTagList = 0; } p = tagStack; tagStack = tagStack->parent; free(p->buf); destroyBindings(p->bindings); free(p); } destroyBindings(freeBindingList); destroyBindings(inheritedBindings); poolDestroy(&tempPool); poolDestroy(&temp2Pool); #ifdef XML_DTD if (parentParser) { if (hadExternalDoctype) dtd.complete = 0; dtdSwap(&dtd, &((Parser *)parentParser)->m_dtd); } #endif /* XML_DTD */ dtdDestroy(&dtd); free((void *)atts); free(groupConnector); free(buffer); free(dataBuf); free(unknownEncodingMem); if (unknownEncodingRelease) unknownEncodingRelease(unknownEncodingData); free(parser); } void XML_UseParserAsHandlerArg(XML_Parser parser) { handlerArg = parser; } void XML_SetUserData(XML_Parser parser, void *p) { if (handlerArg == userData) handlerArg = userData = p; else userData = p; } int XML_SetBase(XML_Parser parser, const XML_Char *p) { if (p) { p = poolCopyString(&dtd.pool, p); if (!p) return 0; curBase = p; } else curBase = 0; return 1; } const XML_Char *XML_GetBase(XML_Parser parser) { return curBase; } int XML_GetSpecifiedAttributeCount(XML_Parser parser) { return nSpecifiedAtts; } int XML_GetIdAttributeIndex(XML_Parser parser) { return idAttIndex; } void XML_SetElementHandler(XML_Parser parser, XML_StartElementHandler start, XML_EndElementHandler end) { startElementHandler = start; endElementHandler = end; } void XML_SetCharacterDataHandler(XML_Parser parser, XML_CharacterDataHandler handler) { characterDataHandler = handler; } void XML_SetProcessingInstructionHandler(XML_Parser parser, XML_ProcessingInstructionHandler handler) { processingInstructionHandler = handler; } void XML_SetCommentHandler(XML_Parser parser, XML_CommentHandler handler) { commentHandler = handler; } void XML_SetCdataSectionHandler(XML_Parser parser, XML_StartCdataSectionHandler start, XML_EndCdataSectionHandler end) { startCdataSectionHandler = start; endCdataSectionHandler = end; } void XML_SetDefaultHandler(XML_Parser parser, XML_DefaultHandler handler) { defaultHandler = handler; defaultExpandInternalEntities = 0; } void XML_SetDefaultHandlerExpand(XML_Parser parser, XML_DefaultHandler handler) { defaultHandler = handler; defaultExpandInternalEntities = 1; } void XML_SetDoctypeDeclHandler(XML_Parser parser, XML_StartDoctypeDeclHandler start, XML_EndDoctypeDeclHandler end) { startDoctypeDeclHandler = start; endDoctypeDeclHandler = end; } void XML_SetUnparsedEntityDeclHandler(XML_Parser parser, XML_UnparsedEntityDeclHandler handler) { unparsedEntityDeclHandler = handler; } void XML_SetExternalParsedEntityDeclHandler(XML_Parser parser, XML_ExternalParsedEntityDeclHandler handler) { externalParsedEntityDeclHandler = handler; } void XML_SetInternalParsedEntityDeclHandler(XML_Parser parser, XML_InternalParsedEntityDeclHandler handler) { internalParsedEntityDeclHandler = handler; } void XML_SetNotationDeclHandler(XML_Parser parser, XML_NotationDeclHandler handler) { notationDeclHandler = handler; } void XML_SetNamespaceDeclHandler(XML_Parser parser, XML_StartNamespaceDeclHandler start, XML_EndNamespaceDeclHandler end) { startNamespaceDeclHandler = start; endNamespaceDeclHandler = end; } void XML_SetNotStandaloneHandler(XML_Parser parser, XML_NotStandaloneHandler handler) { notStandaloneHandler = handler; } void XML_SetExternalEntityRefHandler(XML_Parser parser, XML_ExternalEntityRefHandler handler) { externalEntityRefHandler = handler; } void XML_SetExternalEntityRefHandlerArg(XML_Parser parser, void *arg) { if (arg) externalEntityRefHandlerArg = arg; else externalEntityRefHandlerArg = parser; } void XML_SetUnknownEncodingHandler(XML_Parser parser, XML_UnknownEncodingHandler handler, void *data) { unknownEncodingHandler = handler; unknownEncodingHandlerData = data; } int XML_SetParamEntityParsing(XML_Parser parser, enum XML_ParamEntityParsing parsing) { #ifdef XML_DTD paramEntityParsing = parsing; return 1; #else return parsing == XML_PARAM_ENTITY_PARSING_NEVER; #endif } int XML_Parse(XML_Parser parser, const char *s, int len, int isFinal) { if (len == 0) { if (!isFinal) return 1; positionPtr = bufferPtr; errorCode = processor(parser, bufferPtr, parseEndPtr = bufferEnd, 0); if (errorCode == XML_ERROR_NONE) return 1; eventEndPtr = eventPtr; processor = errorProcessor; return 0; } else if (bufferPtr == bufferEnd) { const char *end; int nLeftOver; parseEndByteIndex += len; positionPtr = s; if (isFinal) { errorCode = processor(parser, s, parseEndPtr = s + len, 0); if (errorCode == XML_ERROR_NONE) return 1; eventEndPtr = eventPtr; processor = errorProcessor; return 0; } errorCode = processor(parser, s, parseEndPtr = s + len, &end); if (errorCode != XML_ERROR_NONE) { eventEndPtr = eventPtr; processor = errorProcessor; return 0; } XmlUpdatePosition(encoding, positionPtr, end, &position); nLeftOver = (int) (s + len - end); if (nLeftOver) { if (buffer == 0 || nLeftOver > bufferLim - buffer) { /* FIXME avoid integer overflow */ buffer = buffer == 0 ? malloc(len * 2) : realloc(buffer, len * 2); /* FIXME storage leak if realloc fails */ if (!buffer) { errorCode = XML_ERROR_NO_MEMORY; eventPtr = eventEndPtr = 0; processor = errorProcessor; return 0; } bufferLim = buffer + len * 2; } memcpy(buffer, end, nLeftOver); bufferPtr = buffer; bufferEnd = buffer + nLeftOver; } return 1; } else { memcpy(XML_GetBuffer(parser, len), s, len); return XML_ParseBuffer(parser, len, isFinal); } } int XML_ParseBuffer(XML_Parser parser, int len, int isFinal) { const char *start = bufferPtr; positionPtr = start; bufferEnd += len; parseEndByteIndex += len; errorCode = processor(parser, start, parseEndPtr = bufferEnd, isFinal ? (const char **)0 : &bufferPtr); if (errorCode == XML_ERROR_NONE) { if (!isFinal) XmlUpdatePosition(encoding, positionPtr, bufferPtr, &position); return 1; } else { eventEndPtr = eventPtr; processor = errorProcessor; return 0; } } void *XML_GetBuffer(XML_Parser parser, int len) { if (len > bufferLim - bufferEnd) { /* FIXME avoid integer overflow */ int neededSize = (int) (len + (bufferEnd - bufferPtr)); if (neededSize <= bufferLim - buffer) { memmove(buffer, bufferPtr, bufferEnd - bufferPtr); bufferEnd = buffer + (bufferEnd - bufferPtr); bufferPtr = buffer; } else { char *newBuf; int bufferSize = (int) (bufferLim - bufferPtr); if (bufferSize == 0) bufferSize = INIT_BUFFER_SIZE; do { bufferSize *= 2; } while (bufferSize < neededSize); newBuf = malloc(bufferSize); if (newBuf == 0) { errorCode = XML_ERROR_NO_MEMORY; return 0; } bufferLim = newBuf + bufferSize; if (bufferPtr) { memcpy(newBuf, bufferPtr, bufferEnd - bufferPtr); free(buffer); } bufferEnd = newBuf + (bufferEnd - bufferPtr); bufferPtr = buffer = newBuf; } } return bufferEnd; } enum XML_Error XML_GetErrorCode(XML_Parser parser) { return errorCode; } long XML_GetCurrentByteIndex(XML_Parser parser) { if (eventPtr) return parseEndByteIndex - (parseEndPtr - eventPtr); return -1; } int XML_GetCurrentByteCount(XML_Parser parser) { if (eventEndPtr && eventPtr) return (int) (eventEndPtr - eventPtr); return 0; } int XML_GetCurrentLineNumber(XML_Parser parser) { if (eventPtr) { XmlUpdatePosition(encoding, positionPtr, eventPtr, &position); positionPtr = eventPtr; } return position.lineNumber + 1; } int XML_GetCurrentColumnNumber(XML_Parser parser) { if (eventPtr) { XmlUpdatePosition(encoding, positionPtr, eventPtr, &position); positionPtr = eventPtr; } return position.columnNumber; } void XML_DefaultCurrent(XML_Parser parser) { if (defaultHandler) { if (openInternalEntities) reportDefault(parser, internalEncoding, openInternalEntities->internalEventPtr, openInternalEntities->internalEventEndPtr); else reportDefault(parser, encoding, eventPtr, eventEndPtr); } } const XML_LChar *XML_ErrorString(int code) { static const XML_LChar *message[] = { 0, XML_T("out of memory"), XML_T("syntax error"), XML_T("no element found"), XML_T("not well-formed"), XML_T("unclosed token"), XML_T("unclosed token"), XML_T("mismatched tag"), XML_T("duplicate attribute"), XML_T("junk after document element"), XML_T("illegal parameter entity reference"), XML_T("undefined entity"), XML_T("recursive entity reference"), XML_T("asynchronous entity"), XML_T("reference to invalid character number"), XML_T("reference to binary entity"), XML_T("reference to external entity in attribute"), XML_T("xml processing instruction not at start of external entity"), XML_T("unknown encoding"), XML_T("encoding specified in XML declaration is incorrect"), XML_T("unclosed CDATA section"), XML_T("error in processing external entity reference"), XML_T("document is not standalone") }; if (code > 0 && code < sizeof(message)/sizeof(message[0])) return message[code]; return 0; } static enum XML_Error contentProcessor(XML_Parser parser, const char *start, const char *end, const char **endPtr) { return doContent(parser, 0, encoding, start, end, endPtr); } static enum XML_Error externalEntityInitProcessor(XML_Parser parser, const char *start, const char *end, const char **endPtr) { enum XML_Error result = initializeEncoding(parser); if (result != XML_ERROR_NONE) return result; processor = externalEntityInitProcessor2; return externalEntityInitProcessor2(parser, start, end, endPtr); } static enum XML_Error externalEntityInitProcessor2(XML_Parser parser, const char *start, const char *end, const char **endPtr) { const char *next; int tok = XmlContentTok(encoding, start, end, &next); switch (tok) { case XML_TOK_BOM: start = next; break; case XML_TOK_PARTIAL: if (endPtr) { *endPtr = start; return XML_ERROR_NONE; } eventPtr = start; return XML_ERROR_UNCLOSED_TOKEN; case XML_TOK_PARTIAL_CHAR: if (endPtr) { *endPtr = start; return XML_ERROR_NONE; } eventPtr = start; return XML_ERROR_PARTIAL_CHAR; } processor = externalEntityInitProcessor3; return externalEntityInitProcessor3(parser, start, end, endPtr); } static enum XML_Error externalEntityInitProcessor3(XML_Parser parser, const char *start, const char *end, const char **endPtr) { const char *next; int tok = XmlContentTok(encoding, start, end, &next); switch (tok) { case XML_TOK_XML_DECL: { enum XML_Error result = processXmlDecl(parser, 1, start, next); if (result != XML_ERROR_NONE) return result; start = next; } break; case XML_TOK_PARTIAL: if (endPtr) { *endPtr = start; return XML_ERROR_NONE; } eventPtr = start; return XML_ERROR_UNCLOSED_TOKEN; case XML_TOK_PARTIAL_CHAR: if (endPtr) { *endPtr = start; return XML_ERROR_NONE; } eventPtr = start; return XML_ERROR_PARTIAL_CHAR; } processor = externalEntityContentProcessor; tagLevel = 1; return doContent(parser, 1, encoding, start, end, endPtr); } static enum XML_Error externalEntityContentProcessor(XML_Parser parser, const char *start, const char *end, const char **endPtr) { return doContent(parser, 1, encoding, start, end, endPtr); } static enum XML_Error doContent(XML_Parser parser, int startTagLevel, const ENCODING *enc, const char *s, const char *end, const char **nextPtr) { const char **eventPP; const char **eventEndPP; if (enc == encoding) { eventPP = &eventPtr; eventEndPP = &eventEndPtr; } else { eventPP = &(openInternalEntities->internalEventPtr); eventEndPP = &(openInternalEntities->internalEventEndPtr); } *eventPP = s; for (;;) { const char *next = s; /* XmlContentTok doesn't always set the last arg */ int tok = XmlContentTok(enc, s, end, &next); *eventEndPP = next; switch (tok) { case XML_TOK_TRAILING_CR: if (nextPtr) { *nextPtr = s; return XML_ERROR_NONE; } *eventEndPP = end; if (characterDataHandler) { XML_Char c = 0xA; characterDataHandler(handlerArg, &c, 1); } else if (defaultHandler) reportDefault(parser, enc, s, end); if (startTagLevel == 0) return XML_ERROR_NO_ELEMENTS; if (tagLevel != startTagLevel) return XML_ERROR_ASYNC_ENTITY; return XML_ERROR_NONE; case XML_TOK_NONE: if (nextPtr) { *nextPtr = s; return XML_ERROR_NONE; } if (startTagLevel > 0) { if (tagLevel != startTagLevel) return XML_ERROR_ASYNC_ENTITY; return XML_ERROR_NONE; } return XML_ERROR_NO_ELEMENTS; case XML_TOK_INVALID: *eventPP = next; return XML_ERROR_INVALID_TOKEN; case XML_TOK_PARTIAL: if (nextPtr) { *nextPtr = s; return XML_ERROR_NONE; } return XML_ERROR_UNCLOSED_TOKEN; case XML_TOK_PARTIAL_CHAR: if (nextPtr) { *nextPtr = s; return XML_ERROR_NONE; } return XML_ERROR_PARTIAL_CHAR; case XML_TOK_ENTITY_REF: { const XML_Char *name; ENTITY *entity; XML_Char ch = XmlPredefinedEntityName(enc, s + enc->minBytesPerChar, next - enc->minBytesPerChar); if (ch) { if (characterDataHandler) characterDataHandler(handlerArg, &ch, 1); else if (defaultHandler) reportDefault(parser, enc, s, next); break; } name = poolStoreString(&dtd.pool, enc, s + enc->minBytesPerChar, next - enc->minBytesPerChar); if (!name) return XML_ERROR_NO_MEMORY; entity = (ENTITY *)lookup(&dtd.generalEntities, name, 0); poolDiscard(&dtd.pool); if (!entity) { if (dtd.complete || dtd.standalone) return XML_ERROR_UNDEFINED_ENTITY; if (defaultHandler) reportDefault(parser, enc, s, next); break; } if (entity->open) return XML_ERROR_RECURSIVE_ENTITY_REF; if (entity->notation) return XML_ERROR_BINARY_ENTITY_REF; if (entity) { if (entity->textPtr) { enum XML_Error result; OPEN_INTERNAL_ENTITY openEntity; if (defaultHandler && !defaultExpandInternalEntities) { reportDefault(parser, enc, s, next); break; } entity->open = 1; openEntity.next = openInternalEntities; openInternalEntities = &openEntity; openEntity.entity = entity; openEntity.internalEventPtr = 0; openEntity.internalEventEndPtr = 0; result = doContent(parser, tagLevel, internalEncoding, (char *)entity->textPtr, (char *)(entity->textPtr + entity->textLen), 0); entity->open = 0; openInternalEntities = openEntity.next; if (result) return result; } else if (externalEntityRefHandler) { const XML_Char *context; entity->open = 1; context = getContext(parser); entity->open = 0; if (!context) return XML_ERROR_NO_MEMORY; if (!externalEntityRefHandler(externalEntityRefHandlerArg, context, entity->base, entity->systemId, entity->publicId)) return XML_ERROR_EXTERNAL_ENTITY_HANDLING; poolDiscard(&tempPool); } else if (defaultHandler) reportDefault(parser, enc, s, next); } break; } case XML_TOK_START_TAG_WITH_ATTS: if (!startElementHandler) { enum XML_Error result = storeAtts(parser, enc, s, 0, 0); if (result) return result; } /* fall through */ case XML_TOK_START_TAG_NO_ATTS: { TAG *tag; if (freeTagList) { tag = freeTagList; freeTagList = freeTagList->parent; } else { tag = malloc(sizeof(TAG)); if (!tag) return XML_ERROR_NO_MEMORY; tag->buf = malloc(INIT_TAG_BUF_SIZE); if (!tag->buf) return XML_ERROR_NO_MEMORY; tag->bufEnd = tag->buf + INIT_TAG_BUF_SIZE; } tag->bindings = 0; tag->parent = tagStack; tagStack = tag; tag->name.localPart = 0; tag->rawName = s + enc->minBytesPerChar; tag->rawNameLength = XmlNameLength(enc, tag->rawName); if (nextPtr) { /* Need to guarantee that: tag->buf + ROUND_UP(tag->rawNameLength, sizeof(XML_Char)) <= tag->bufEnd - sizeof(XML_Char) */ if (tag->rawNameLength + (int)(sizeof(XML_Char) - 1) + (int)sizeof(XML_Char) > tag->bufEnd - tag->buf) { int bufSize = tag->rawNameLength * 4; bufSize = ROUND_UP(bufSize, sizeof(XML_Char)); tag->buf = realloc(tag->buf, bufSize); if (!tag->buf) return XML_ERROR_NO_MEMORY; tag->bufEnd = tag->buf + bufSize; } memcpy(tag->buf, tag->rawName, tag->rawNameLength); tag->rawName = tag->buf; } ++tagLevel; if (startElementHandler) { enum XML_Error result; XML_Char *toPtr; for (;;) { const char *rawNameEnd = tag->rawName + tag->rawNameLength; const char *fromPtr = tag->rawName; int bufSize; if (nextPtr) toPtr = (XML_Char *)(tag->buf + ROUND_UP(tag->rawNameLength, sizeof(XML_Char))); else toPtr = (XML_Char *)tag->buf; tag->name.str = toPtr; XmlConvert(enc, &fromPtr, rawNameEnd, (ICHAR **)&toPtr, (ICHAR *)tag->bufEnd - 1); if (fromPtr == rawNameEnd) break; bufSize = (int) ((tag->bufEnd - tag->buf) << 1); tag->buf = realloc(tag->buf, bufSize); if (!tag->buf) return XML_ERROR_NO_MEMORY; tag->bufEnd = tag->buf + bufSize; if (nextPtr) tag->rawName = tag->buf; } *toPtr = XML_T('\0'); result = storeAtts(parser, enc, s, &(tag->name), &(tag->bindings)); if (result) return result; startElementHandler(handlerArg, tag->name.str, (const XML_Char **)atts); poolClear(&tempPool); } else { tag->name.str = 0; if (defaultHandler) reportDefault(parser, enc, s, next); } break; } case XML_TOK_EMPTY_ELEMENT_WITH_ATTS: if (!startElementHandler) { enum XML_Error result = storeAtts(parser, enc, s, 0, 0); if (result) return result; } /* fall through */ case XML_TOK_EMPTY_ELEMENT_NO_ATTS: if (startElementHandler || endElementHandler) { const char *rawName = s + enc->minBytesPerChar; enum XML_Error result; BINDING *bindings = 0; TAG_NAME name; name.str = poolStoreString(&tempPool, enc, rawName, rawName + XmlNameLength(enc, rawName)); if (!name.str) return XML_ERROR_NO_MEMORY; poolFinish(&tempPool); result = storeAtts(parser, enc, s, &name, &bindings); if (result) return result; poolFinish(&tempPool); if (startElementHandler) startElementHandler(handlerArg, name.str, (const XML_Char **)atts); if (endElementHandler) { if (startElementHandler) *eventPP = *eventEndPP; endElementHandler(handlerArg, name.str); } poolClear(&tempPool); while (bindings) { BINDING *b = bindings; if (endNamespaceDeclHandler) endNamespaceDeclHandler(handlerArg, b->prefix->name); bindings = bindings->nextTagBinding; b->nextTagBinding = freeBindingList; freeBindingList = b; b->prefix->binding = b->prevPrefixBinding; } } else if (defaultHandler) reportDefault(parser, enc, s, next); if (tagLevel == 0) return epilogProcessor(parser, next, end, nextPtr); break; case XML_TOK_END_TAG: if (tagLevel == startTagLevel) return XML_ERROR_ASYNC_ENTITY; else { int len; const char *rawName; TAG *tag = tagStack; tagStack = tag->parent; tag->parent = freeTagList; freeTagList = tag; rawName = s + enc->minBytesPerChar*2; len = XmlNameLength(enc, rawName); if (len != tag->rawNameLength || memcmp(tag->rawName, rawName, len) != 0) { *eventPP = rawName; return XML_ERROR_TAG_MISMATCH; } --tagLevel; if (endElementHandler && tag->name.str) { if (tag->name.localPart) { XML_Char *to = (XML_Char *)tag->name.str + tag->name.uriLen; const XML_Char *from = tag->name.localPart; while ((*to++ = *from++) != 0) ; } endElementHandler(handlerArg, tag->name.str); } else if (defaultHandler) reportDefault(parser, enc, s, next); while (tag->bindings) { BINDING *b = tag->bindings; if (endNamespaceDeclHandler) endNamespaceDeclHandler(handlerArg, b->prefix->name); tag->bindings = tag->bindings->nextTagBinding; b->nextTagBinding = freeBindingList; freeBindingList = b; b->prefix->binding = b->prevPrefixBinding; } if (tagLevel == 0) return epilogProcessor(parser, next, end, nextPtr); } break; case XML_TOK_CHAR_REF: { int n = XmlCharRefNumber(enc, s); if (n < 0) return XML_ERROR_BAD_CHAR_REF; if (characterDataHandler) { XML_Char buf[XML_ENCODE_MAX]; characterDataHandler(handlerArg, buf, XmlEncode(n, (ICHAR *)buf)); } else if (defaultHandler) reportDefault(parser, enc, s, next); } break; case XML_TOK_XML_DECL: return XML_ERROR_MISPLACED_XML_PI; case XML_TOK_DATA_NEWLINE: if (characterDataHandler) { XML_Char c = 0xA; characterDataHandler(handlerArg, &c, 1); } else if (defaultHandler) reportDefault(parser, enc, s, next); break; case XML_TOK_CDATA_SECT_OPEN: { enum XML_Error result; if (startCdataSectionHandler) startCdataSectionHandler(handlerArg); #if 0 /* Suppose you doing a transformation on a document that involves changing only the character data. You set up a defaultHandler and a characterDataHandler. The defaultHandler simply copies characters through. The characterDataHandler does the transformation and writes the characters out escaping them as necessary. This case will fail to work if we leave out the following two lines (because & and < inside CDATA sections will be incorrectly escaped). However, now we have a start/endCdataSectionHandler, so it seems easier to let the user deal with this. */ else if (characterDataHandler) characterDataHandler(handlerArg, dataBuf, 0); #endif else if (defaultHandler) reportDefault(parser, enc, s, next); result = doCdataSection(parser, enc, &next, end, nextPtr); if (!next) { processor = cdataSectionProcessor; return result; } } break; case XML_TOK_TRAILING_RSQB: if (nextPtr) { *nextPtr = s; return XML_ERROR_NONE; } if (characterDataHandler) { if (MUST_CONVERT(enc, s)) { ICHAR *dataPtr = (ICHAR *)dataBuf; XmlConvert(enc, &s, end, &dataPtr, (ICHAR *)dataBufEnd); characterDataHandler(handlerArg, dataBuf, (int)(dataPtr - (ICHAR *)dataBuf)); // int added by DBL } else characterDataHandler(handlerArg, (XML_Char *)s, (int)((XML_Char *)end - (XML_Char *)s));// int added by DBL } else if (defaultHandler) reportDefault(parser, enc, s, end); if (startTagLevel == 0) { *eventPP = end; return XML_ERROR_NO_ELEMENTS; } if (tagLevel != startTagLevel) { *eventPP = end; return XML_ERROR_ASYNC_ENTITY; } return XML_ERROR_NONE; case XML_TOK_DATA_CHARS: if (characterDataHandler) { if (MUST_CONVERT(enc, s)) { for (;;) { ICHAR *dataPtr = (ICHAR *)dataBuf; XmlConvert(enc, &s, next, &dataPtr, (ICHAR *)dataBufEnd); *eventEndPP = s; characterDataHandler(handlerArg, dataBuf, (int)(dataPtr - (ICHAR *)dataBuf));// int added by DBL if (s == next) break; *eventPP = s; } } else characterDataHandler(handlerArg, (XML_Char *)s, (int)((XML_Char *)next - (XML_Char *)s));// int added by DBL } else if (defaultHandler) reportDefault(parser, enc, s, next); break; case XML_TOK_PI: if (!reportProcessingInstruction(parser, enc, s, next)) return XML_ERROR_NO_MEMORY; break; case XML_TOK_COMMENT: if (!reportComment(parser, enc, s, next)) return XML_ERROR_NO_MEMORY; break; default: if (defaultHandler) reportDefault(parser, enc, s, next); break; } *eventPP = s = next; } /* not reached */ } /* If tagNamePtr is non-null, build a real list of attributes, otherwise just check the attributes for well-formedness. */ static enum XML_Error storeAtts(XML_Parser parser, const ENCODING *enc, const char *attStr, TAG_NAME *tagNamePtr, BINDING **bindingsPtr) { ELEMENT_TYPE *elementType = 0; int nDefaultAtts = 0; const XML_Char **appAtts; /* the attribute list to pass to the application */ int attIndex = 0; int i; int n; int nPrefixes = 0; BINDING *binding; const XML_Char *localPart; /* lookup the element type name */ if (tagNamePtr) { elementType = (ELEMENT_TYPE *)lookup(&dtd.elementTypes, tagNamePtr->str, 0); if (!elementType) { tagNamePtr->str = poolCopyString(&dtd.pool, tagNamePtr->str); if (!tagNamePtr->str) return XML_ERROR_NO_MEMORY; elementType = (ELEMENT_TYPE *)lookup(&dtd.elementTypes, tagNamePtr->str, sizeof(ELEMENT_TYPE)); if (!elementType) return XML_ERROR_NO_MEMORY; if (ns && !setElementTypePrefix(parser, elementType)) return XML_ERROR_NO_MEMORY; } nDefaultAtts = elementType->nDefaultAtts; } /* get the attributes from the tokenizer */ n = XmlGetAttributes(enc, attStr, attsSize, atts); if (n + nDefaultAtts > attsSize) { int oldAttsSize = attsSize; attsSize = n + nDefaultAtts + INIT_ATTS_SIZE; atts = realloc((void *)atts, attsSize * sizeof(ATTRIBUTE)); if (!atts) return XML_ERROR_NO_MEMORY; if (n > oldAttsSize) XmlGetAttributes(enc, attStr, n, atts); } appAtts = (const XML_Char **)atts; for (i = 0; i < n; i++) { /* add the name and value to the attribute list */ ATTRIBUTE_ID *attId = getAttributeId(parser, enc, atts[i].name, atts[i].name + XmlNameLength(enc, atts[i].name)); if (!attId) return XML_ERROR_NO_MEMORY; /* detect duplicate attributes */ if ((attId->name)[-1]) { if (enc == encoding) eventPtr = atts[i].name; return XML_ERROR_DUPLICATE_ATTRIBUTE; } (attId->name)[-1] = 1; appAtts[attIndex++] = attId->name; if (!atts[i].normalized) { enum XML_Error result; int isCdata = 1; /* figure out whether declared as other than CDATA */ if (attId->maybeTokenized) { int j; for (j = 0; j < nDefaultAtts; j++) { if (attId == elementType->defaultAtts[j].id) { isCdata = elementType->defaultAtts[j].isCdata; break; } } } /* normalize the attribute value */ result = storeAttributeValue(parser, enc, isCdata, atts[i].valuePtr, atts[i].valueEnd, &tempPool); if (result) return result; if (tagNamePtr) { appAtts[attIndex] = poolStart(&tempPool); poolFinish(&tempPool); } else poolDiscard(&tempPool); } else if (tagNamePtr) { /* the value did not need normalizing */ appAtts[attIndex] = poolStoreString(&tempPool, enc, atts[i].valuePtr, atts[i].valueEnd); if (appAtts[attIndex] == 0) return XML_ERROR_NO_MEMORY; poolFinish(&tempPool); } /* handle prefixed attribute names */ if (attId->prefix && tagNamePtr) { if (attId->xmlns) { /* deal with namespace declarations here */ if (!addBinding(parser, attId->prefix, attId, appAtts[attIndex], bindingsPtr)) return XML_ERROR_NO_MEMORY; --attIndex; } else { /* deal with other prefixed names later */ attIndex++; nPrefixes++; (attId->name)[-1] = 2; } } else attIndex++; } if (tagNamePtr) { int j; nSpecifiedAtts = attIndex; if (elementType->idAtt && (elementType->idAtt->name)[-1]) { for (i = 0; i < attIndex; i += 2) if (appAtts[i] == elementType->idAtt->name) { idAttIndex = i; break; } } else idAttIndex = -1; /* do attribute defaulting */ for (j = 0; j < nDefaultAtts; j++) { const DEFAULT_ATTRIBUTE *da = elementType->defaultAtts + j; if (!(da->id->name)[-1] && da->value) { if (da->id->prefix) { if (da->id->xmlns) { if (!addBinding(parser, da->id->prefix, da->id, da->value, bindingsPtr)) return XML_ERROR_NO_MEMORY; } else { (da->id->name)[-1] = 2; nPrefixes++; appAtts[attIndex++] = da->id->name; appAtts[attIndex++] = da->value; } } else { (da->id->name)[-1] = 1; appAtts[attIndex++] = da->id->name; appAtts[attIndex++] = da->value; } } } appAtts[attIndex] = 0; } i = 0; if (nPrefixes) { /* expand prefixed attribute names */ for (; i < attIndex; i += 2) { if (appAtts[i][-1] == 2) { ATTRIBUTE_ID *id; ((XML_Char *)(appAtts[i]))[-1] = 0; id = (ATTRIBUTE_ID *)lookup(&dtd.attributeIds, appAtts[i], 0); if (id->prefix->binding) { int j; const BINDING *b = id->prefix->binding; const XML_Char *s = appAtts[i]; for (j = 0; j < b->uriLen; j++) { if (!poolAppendChar(&tempPool, b->uri[j])) return XML_ERROR_NO_MEMORY; } while (*s++ != ':') ; do { if (!poolAppendChar(&tempPool, *s)) return XML_ERROR_NO_MEMORY; } while (*s++); appAtts[i] = poolStart(&tempPool); poolFinish(&tempPool); } if (!--nPrefixes) break; } else ((XML_Char *)(appAtts[i]))[-1] = 0; } } /* clear the flags that say whether attributes were specified */ for (; i < attIndex; i += 2) ((XML_Char *)(appAtts[i]))[-1] = 0; if (!tagNamePtr) return XML_ERROR_NONE; for (binding = *bindingsPtr; binding; binding = binding->nextTagBinding) binding->attId->name[-1] = 0; /* expand the element type name */ if (elementType->prefix) { binding = elementType->prefix->binding; if (!binding) return XML_ERROR_NONE; localPart = tagNamePtr->str; while (*localPart++ != XML_T(':')) ; } else if (dtd.defaultPrefix.binding) { binding = dtd.defaultPrefix.binding; localPart = tagNamePtr->str; } else return XML_ERROR_NONE; tagNamePtr->localPart = localPart; tagNamePtr->uriLen = binding->uriLen; for (i = 0; localPart[i++];) ; n = i + binding->uriLen; if (n > binding->uriAlloc) { TAG *p; XML_Char *uri = malloc((n + EXPAND_SPARE) * sizeof(XML_Char)); if (!uri) return XML_ERROR_NO_MEMORY; binding->uriAlloc = n + EXPAND_SPARE; memcpy(uri, binding->uri, binding->uriLen * sizeof(XML_Char)); for (p = tagStack; p; p = p->parent) if (p->name.str == binding->uri) p->name.str = uri; free(binding->uri); binding->uri = uri; } memcpy(binding->uri + binding->uriLen, localPart, i * sizeof(XML_Char)); tagNamePtr->str = binding->uri; return XML_ERROR_NONE; } static int addBinding(XML_Parser parser, PREFIX *prefix, const ATTRIBUTE_ID *attId, const XML_Char *uri, BINDING **bindingsPtr) { BINDING *b; int len; for (len = 0; uri[len]; len++) ; if (namespaceSeparator) len++; if (freeBindingList) { b = freeBindingList; if (len > b->uriAlloc) { b->uri = realloc(b->uri, sizeof(XML_Char) * (len + EXPAND_SPARE)); if (!b->uri) return 0; b->uriAlloc = len + EXPAND_SPARE; } freeBindingList = b->nextTagBinding; } else { b = malloc(sizeof(BINDING)); if (!b) return 0; b->uri = malloc(sizeof(XML_Char) * (len + EXPAND_SPARE)); if (!b->uri) { free(b); return 0; } b->uriAlloc = len + EXPAND_SPARE; } b->uriLen = len; memcpy(b->uri, uri, len * sizeof(XML_Char)); if (namespaceSeparator) b->uri[len - 1] = namespaceSeparator; b->prefix = prefix; b->attId = attId; b->prevPrefixBinding = prefix->binding; if (*uri == XML_T('\0') && prefix == &dtd.defaultPrefix) prefix->binding = 0; else prefix->binding = b; b->nextTagBinding = *bindingsPtr; *bindingsPtr = b; if (startNamespaceDeclHandler) startNamespaceDeclHandler(handlerArg, prefix->name, prefix->binding ? uri : 0); return 1; } /* The idea here is to avoid using stack for each CDATA section when the whole file is parsed with one call. */ static enum XML_Error cdataSectionProcessor(XML_Parser parser, const char *start, const char *end, const char **endPtr) { enum XML_Error result = doCdataSection(parser, encoding, &start, end, endPtr); if (start) { processor = contentProcessor; return contentProcessor(parser, start, end, endPtr); } return result; } /* startPtr gets set to non-null is the section is closed, and to null if the section is not yet closed. */ static enum XML_Error doCdataSection(XML_Parser parser, const ENCODING *enc, const char **startPtr, const char *end, const char **nextPtr) { const char *s = *startPtr; const char **eventPP; const char **eventEndPP; if (enc == encoding) { eventPP = &eventPtr; *eventPP = s; eventEndPP = &eventEndPtr; } else { eventPP = &(openInternalEntities->internalEventPtr); eventEndPP = &(openInternalEntities->internalEventEndPtr); } *eventPP = s; *startPtr = 0; for (;;) { const char *next; int tok = XmlCdataSectionTok(enc, s, end, &next); *eventEndPP = next; switch (tok) { case XML_TOK_CDATA_SECT_CLOSE: if (endCdataSectionHandler) endCdataSectionHandler(handlerArg); #if 0 /* see comment under XML_TOK_CDATA_SECT_OPEN */ else if (characterDataHandler) characterDataHandler(handlerArg, dataBuf, 0); #endif else if (defaultHandler) reportDefault(parser, enc, s, next); *startPtr = next; return XML_ERROR_NONE; case XML_TOK_DATA_NEWLINE: if (characterDataHandler) { XML_Char c = 0xA; characterDataHandler(handlerArg, &c, 1); } else if (defaultHandler) reportDefault(parser, enc, s, next); break; case XML_TOK_DATA_CHARS: if (characterDataHandler) { if (MUST_CONVERT(enc, s)) { for (;;) { ICHAR *dataPtr = (ICHAR *)dataBuf; XmlConvert(enc, &s, next, &dataPtr, (ICHAR *)dataBufEnd); *eventEndPP = next; characterDataHandler(handlerArg, dataBuf, (int)(dataPtr - (ICHAR *)dataBuf));// int added by DBL if (s == next) break; *eventPP = s; } } else characterDataHandler(handlerArg, (XML_Char *)s, (int)((XML_Char *)next - (XML_Char *)s));// int added by DBL } else if (defaultHandler) reportDefault(parser, enc, s, next); break; case XML_TOK_INVALID: *eventPP = next; return XML_ERROR_INVALID_TOKEN; case XML_TOK_PARTIAL_CHAR: if (nextPtr) { *nextPtr = s; return XML_ERROR_NONE; } return XML_ERROR_PARTIAL_CHAR; case XML_TOK_PARTIAL: case XML_TOK_NONE: if (nextPtr) { *nextPtr = s; return XML_ERROR_NONE; } return XML_ERROR_UNCLOSED_CDATA_SECTION; default: abort(); } *eventPP = s = next; } /* not reached */ } #ifdef XML_DTD /* The idea here is to avoid using stack for each IGNORE section when the whole file is parsed with one call. */ static enum XML_Error ignoreSectionProcessor(XML_Parser parser, const char *start, const char *end, const char **endPtr) { enum XML_Error result = doIgnoreSection(parser, encoding, &start, end, endPtr); if (start) { processor = prologProcessor; return prologProcessor(parser, start, end, endPtr); } return result; } /* startPtr gets set to non-null is the section is closed, and to null if the section is not yet closed. */ static enum XML_Error doIgnoreSection(XML_Parser parser, const ENCODING *enc, const char **startPtr, const char *end, const char **nextPtr) { const char *next; int tok; const char *s = *startPtr; const char **eventPP; const char **eventEndPP; if (enc == encoding) { eventPP = &eventPtr; *eventPP = s; eventEndPP = &eventEndPtr; } else { eventPP = &(openInternalEntities->internalEventPtr); eventEndPP = &(openInternalEntities->internalEventEndPtr); } *eventPP = s; *startPtr = 0; tok = XmlIgnoreSectionTok(enc, s, end, &next); *eventEndPP = next; switch (tok) { case XML_TOK_IGNORE_SECT: if (defaultHandler) reportDefault(parser, enc, s, next); *startPtr = next; return XML_ERROR_NONE; case XML_TOK_INVALID: *eventPP = next; return XML_ERROR_INVALID_TOKEN; case XML_TOK_PARTIAL_CHAR: if (nextPtr) { *nextPtr = s; return XML_ERROR_NONE; } return XML_ERROR_PARTIAL_CHAR; case XML_TOK_PARTIAL: case XML_TOK_NONE: if (nextPtr) { *nextPtr = s; return XML_ERROR_NONE; } return XML_ERROR_SYNTAX; /* XML_ERROR_UNCLOSED_IGNORE_SECTION */ default: abort(); } /* not reached */ } #endif /* XML_DTD */ static enum XML_Error initializeEncoding(XML_Parser parser) { const char *s; #ifdef XML_UNICODE char encodingBuf[128]; if (!protocolEncodingName) s = 0; else { int i; for (i = 0; protocolEncodingName[i]; i++) { if (i == sizeof(encodingBuf) - 1 || (protocolEncodingName[i] & ~0x7f) != 0) { encodingBuf[0] = '\0'; break; } encodingBuf[i] = (char)protocolEncodingName[i]; } encodingBuf[i] = '\0'; s = encodingBuf; } #else s = protocolEncodingName; #endif if ((ns ? XmlInitEncodingNS : XmlInitEncoding)(&initEncoding, &encoding, s)) return XML_ERROR_NONE; return handleUnknownEncoding(parser, protocolEncodingName); } static enum XML_Error processXmlDecl(XML_Parser parser, int isGeneralTextEntity, const char *s, const char *next) { const char *encodingName = 0; const ENCODING *newEncoding = 0; const char *version; int standalone = -1; if (!(ns ? XmlParseXmlDeclNS : XmlParseXmlDecl)(isGeneralTextEntity, encoding, s, next, &eventPtr, &version, &encodingName, &newEncoding, &standalone)) return XML_ERROR_SYNTAX; if (!isGeneralTextEntity && standalone == 1) { dtd.standalone = 1; #ifdef XML_DTD if (paramEntityParsing == XML_PARAM_ENTITY_PARSING_UNLESS_STANDALONE) paramEntityParsing = XML_PARAM_ENTITY_PARSING_NEVER; #endif /* XML_DTD */ } if (defaultHandler) reportDefault(parser, encoding, s, next); if (!protocolEncodingName) { if (newEncoding) { if (newEncoding->minBytesPerChar != encoding->minBytesPerChar) { eventPtr = encodingName; return XML_ERROR_INCORRECT_ENCODING; } encoding = newEncoding; } else if (encodingName) { enum XML_Error result; const XML_Char *s = poolStoreString(&tempPool, encoding, encodingName, encodingName + XmlNameLength(encoding, encodingName)); if (!s) return XML_ERROR_NO_MEMORY; result = handleUnknownEncoding(parser, s); poolDiscard(&tempPool); if (result == XML_ERROR_UNKNOWN_ENCODING) eventPtr = encodingName; return result; } } return XML_ERROR_NONE; } static enum XML_Error handleUnknownEncoding(XML_Parser parser, const XML_Char *encodingName) { if (unknownEncodingHandler) { XML_Encoding info; int i; for (i = 0; i < 256; i++) info.map[i] = -1; info.convert = 0; info.data = 0; info.release = 0; if (unknownEncodingHandler(unknownEncodingHandlerData, encodingName, &info)) { ENCODING *enc; unknownEncodingMem = malloc(XmlSizeOfUnknownEncoding()); if (!unknownEncodingMem) { if (info.release) info.release(info.data); return XML_ERROR_NO_MEMORY; } enc = (ns ? XmlInitUnknownEncodingNS : XmlInitUnknownEncoding)(unknownEncodingMem, info.map, info.convert, info.data); if (enc) { unknownEncodingData = info.data; unknownEncodingRelease = info.release; encoding = enc; return XML_ERROR_NONE; } } if (info.release) info.release(info.data); } return XML_ERROR_UNKNOWN_ENCODING; } static enum XML_Error prologInitProcessor(XML_Parser parser, const char *s, const char *end, const char **nextPtr) { enum XML_Error result = initializeEncoding(parser); if (result != XML_ERROR_NONE) return result; processor = prologProcessor; return prologProcessor(parser, s, end, nextPtr); } static enum XML_Error prologProcessor(XML_Parser parser, const char *s, const char *end, const char **nextPtr) { const char *next; int tok = XmlPrologTok(encoding, s, end, &next); return doProlog(parser, encoding, s, end, tok, next, nextPtr); } static enum XML_Error doProlog(XML_Parser parser, const ENCODING *enc, const char *s, const char *end, int tok, const char *next, const char **nextPtr) { #ifdef XML_DTD static const XML_Char externalSubsetName[] = { '#' , '\0' }; #endif /* XML_DTD */ const char **eventPP; const char **eventEndPP; if (enc == encoding) { eventPP = &eventPtr; eventEndPP = &eventEndPtr; } else { eventPP = &(openInternalEntities->internalEventPtr); eventEndPP = &(openInternalEntities->internalEventEndPtr); } for (;;) { int role; *eventPP = s; *eventEndPP = next; if (tok <= 0) { if (nextPtr != 0 && tok != XML_TOK_INVALID) { *nextPtr = s; return XML_ERROR_NONE; } switch (tok) { case XML_TOK_INVALID: *eventPP = next; return XML_ERROR_INVALID_TOKEN; case XML_TOK_PARTIAL: return XML_ERROR_UNCLOSED_TOKEN; case XML_TOK_PARTIAL_CHAR: return XML_ERROR_PARTIAL_CHAR; case XML_TOK_NONE: #ifdef XML_DTD if (enc != encoding) return XML_ERROR_NONE; if (parentParser) { if (XmlTokenRole(&prologState, XML_TOK_NONE, end, end, enc) == XML_ROLE_ERROR) return XML_ERROR_SYNTAX; hadExternalDoctype = 0; return XML_ERROR_NONE; } #endif /* XML_DTD */ return XML_ERROR_NO_ELEMENTS; default: tok = -tok; next = end; break; } } role = XmlTokenRole(&prologState, tok, s, next, enc); switch (role) { case XML_ROLE_XML_DECL: { enum XML_Error result = processXmlDecl(parser, 0, s, next); if (result != XML_ERROR_NONE) return result; enc = encoding; } break; case XML_ROLE_DOCTYPE_NAME: if (startDoctypeDeclHandler) { const XML_Char *name = poolStoreString(&tempPool, enc, s, next); if (!name) return XML_ERROR_NO_MEMORY; startDoctypeDeclHandler(handlerArg, name); poolClear(&tempPool); } break; #ifdef XML_DTD case XML_ROLE_TEXT_DECL: { enum XML_Error result = processXmlDecl(parser, 1, s, next); if (result != XML_ERROR_NONE) return result; enc = encoding; } break; #endif /* XML_DTD */ case XML_ROLE_DOCTYPE_PUBLIC_ID: #ifdef XML_DTD declEntity = (ENTITY *)lookup(&dtd.paramEntities, externalSubsetName, sizeof(ENTITY)); if (!declEntity) return XML_ERROR_NO_MEMORY; #endif /* XML_DTD */ /* fall through */ case XML_ROLE_ENTITY_PUBLIC_ID: if (!XmlIsPublicId(enc, s, next, eventPP)) return XML_ERROR_SYNTAX; if (declEntity) { XML_Char *tem = poolStoreString(&dtd.pool, enc, s + enc->minBytesPerChar, next - enc->minBytesPerChar); if (!tem) return XML_ERROR_NO_MEMORY; normalizePublicId(tem); declEntity->publicId = tem; poolFinish(&dtd.pool); } break; case XML_ROLE_DOCTYPE_CLOSE: if (dtd.complete && hadExternalDoctype) { dtd.complete = 0; #ifdef XML_DTD if (paramEntityParsing && externalEntityRefHandler) { ENTITY *entity = (ENTITY *)lookup(&dtd.paramEntities, externalSubsetName, 0); if (!externalEntityRefHandler(externalEntityRefHandlerArg, 0, entity->base, entity->systemId, entity->publicId)) return XML_ERROR_EXTERNAL_ENTITY_HANDLING; } #endif /* XML_DTD */ if (!dtd.complete && !dtd.standalone && notStandaloneHandler && !notStandaloneHandler(handlerArg)) return XML_ERROR_NOT_STANDALONE; } if (endDoctypeDeclHandler) endDoctypeDeclHandler(handlerArg); break; case XML_ROLE_INSTANCE_START: processor = contentProcessor; return contentProcessor(parser, s, end, nextPtr); case XML_ROLE_ATTLIST_ELEMENT_NAME: { const XML_Char *name = poolStoreString(&dtd.pool, enc, s, next); if (!name) return XML_ERROR_NO_MEMORY; declElementType = (ELEMENT_TYPE *)lookup(&dtd.elementTypes, name, sizeof(ELEMENT_TYPE)); if (!declElementType) return XML_ERROR_NO_MEMORY; if (declElementType->name != name) poolDiscard(&dtd.pool); else { poolFinish(&dtd.pool); if (!setElementTypePrefix(parser, declElementType)) return XML_ERROR_NO_MEMORY; } break; } case XML_ROLE_ATTRIBUTE_NAME: declAttributeId = getAttributeId(parser, enc, s, next); if (!declAttributeId) return XML_ERROR_NO_MEMORY; declAttributeIsCdata = 0; declAttributeIsId = 0; break; case XML_ROLE_ATTRIBUTE_TYPE_CDATA: declAttributeIsCdata = 1; break; case XML_ROLE_ATTRIBUTE_TYPE_ID: declAttributeIsId = 1; break; case XML_ROLE_IMPLIED_ATTRIBUTE_VALUE: case XML_ROLE_REQUIRED_ATTRIBUTE_VALUE: if (dtd.complete && !defineAttribute(declElementType, declAttributeId, declAttributeIsCdata, declAttributeIsId, 0)) return XML_ERROR_NO_MEMORY; break; case XML_ROLE_DEFAULT_ATTRIBUTE_VALUE: case XML_ROLE_FIXED_ATTRIBUTE_VALUE: { const XML_Char *attVal; enum XML_Error result = storeAttributeValue(parser, enc, declAttributeIsCdata, s + enc->minBytesPerChar, next - enc->minBytesPerChar, &dtd.pool); if (result) return result; attVal = poolStart(&dtd.pool); poolFinish(&dtd.pool); if (dtd.complete // ID attributes aren't allowed to have a default && !defineAttribute(declElementType, declAttributeId, declAttributeIsCdata, 0, attVal)) return XML_ERROR_NO_MEMORY; break; } case XML_ROLE_ENTITY_VALUE: { enum XML_Error result = storeEntityValue(parser, enc, s + enc->minBytesPerChar, next - enc->minBytesPerChar); if (declEntity) { declEntity->textPtr = poolStart(&dtd.pool); declEntity->textLen = (int) poolLength(&dtd.pool); poolFinish(&dtd.pool); if (internalParsedEntityDeclHandler // Check it's not a parameter entity && ((ENTITY *)lookup(&dtd.generalEntities, declEntity->name, 0) == declEntity)) { *eventEndPP = s; internalParsedEntityDeclHandler(handlerArg, declEntity->name, declEntity->textPtr, declEntity->textLen); } } else poolDiscard(&dtd.pool); if (result != XML_ERROR_NONE) return result; } break; case XML_ROLE_DOCTYPE_SYSTEM_ID: if (!dtd.standalone #ifdef XML_DTD && !paramEntityParsing #endif /* XML_DTD */ && notStandaloneHandler && !notStandaloneHandler(handlerArg)) return XML_ERROR_NOT_STANDALONE; hadExternalDoctype = 1; #ifndef XML_DTD break; #else /* XML_DTD */ if (!declEntity) { declEntity = (ENTITY *)lookup(&dtd.paramEntities, externalSubsetName, sizeof(ENTITY)); if (!declEntity) return XML_ERROR_NO_MEMORY; } /* fall through */ #endif /* XML_DTD */ case XML_ROLE_ENTITY_SYSTEM_ID: if (declEntity) { declEntity->systemId = poolStoreString(&dtd.pool, enc, s + enc->minBytesPerChar, next - enc->minBytesPerChar); if (!declEntity->systemId) return XML_ERROR_NO_MEMORY; declEntity->base = curBase; poolFinish(&dtd.pool); } break; case XML_ROLE_ENTITY_NOTATION_NAME: if (declEntity) { declEntity->notation = poolStoreString(&dtd.pool, enc, s, next); if (!declEntity->notation) return XML_ERROR_NO_MEMORY; poolFinish(&dtd.pool); if (unparsedEntityDeclHandler) { *eventEndPP = s; unparsedEntityDeclHandler(handlerArg, declEntity->name, declEntity->base, declEntity->systemId, declEntity->publicId, declEntity->notation); } } break; case XML_ROLE_EXTERNAL_GENERAL_ENTITY_NO_NOTATION: if (declEntity && externalParsedEntityDeclHandler) { *eventEndPP = s; externalParsedEntityDeclHandler(handlerArg, declEntity->name, declEntity->base, declEntity->systemId, declEntity->publicId); } break; case XML_ROLE_GENERAL_ENTITY_NAME: { const XML_Char *name; if (XmlPredefinedEntityName(enc, s, next)) { declEntity = 0; break; } name = poolStoreString(&dtd.pool, enc, s, next); if (!name) return XML_ERROR_NO_MEMORY; if (dtd.complete) { declEntity = (ENTITY *)lookup(&dtd.generalEntities, name, sizeof(ENTITY)); if (!declEntity) return XML_ERROR_NO_MEMORY; if (declEntity->name != name) { poolDiscard(&dtd.pool); declEntity = 0; } else poolFinish(&dtd.pool); } else { poolDiscard(&dtd.pool); declEntity = 0; } } break; case XML_ROLE_PARAM_ENTITY_NAME: #ifdef XML_DTD if (dtd.complete) { const XML_Char *name = poolStoreString(&dtd.pool, enc, s, next); if (!name) return XML_ERROR_NO_MEMORY; declEntity = (ENTITY *)lookup(&dtd.paramEntities, name, sizeof(ENTITY)); if (!declEntity) return XML_ERROR_NO_MEMORY; if (declEntity->name != name) { poolDiscard(&dtd.pool); declEntity = 0; } else poolFinish(&dtd.pool); } #else /* not XML_DTD */ declEntity = 0; #endif /* not XML_DTD */ break; case XML_ROLE_NOTATION_NAME: declNotationPublicId = 0; declNotationName = 0; if (notationDeclHandler) { declNotationName = poolStoreString(&tempPool, enc, s, next); if (!declNotationName) return XML_ERROR_NO_MEMORY; poolFinish(&tempPool); } break; case XML_ROLE_NOTATION_PUBLIC_ID: if (!XmlIsPublicId(enc, s, next, eventPP)) return XML_ERROR_SYNTAX; if (declNotationName) { XML_Char *tem = poolStoreString(&tempPool, enc, s + enc->minBytesPerChar, next - enc->minBytesPerChar); if (!tem) return XML_ERROR_NO_MEMORY; normalizePublicId(tem); declNotationPublicId = tem; poolFinish(&tempPool); } break; case XML_ROLE_NOTATION_SYSTEM_ID: if (declNotationName && notationDeclHandler) { const XML_Char *systemId = poolStoreString(&tempPool, enc, s + enc->minBytesPerChar, next - enc->minBytesPerChar); if (!systemId) return XML_ERROR_NO_MEMORY; *eventEndPP = s; notationDeclHandler(handlerArg, declNotationName, curBase, systemId, declNotationPublicId); } poolClear(&tempPool); break; case XML_ROLE_NOTATION_NO_SYSTEM_ID: if (declNotationPublicId && notationDeclHandler) { *eventEndPP = s; notationDeclHandler(handlerArg, declNotationName, curBase, 0, declNotationPublicId); } poolClear(&tempPool); break; case XML_ROLE_ERROR: switch (tok) { case XML_TOK_PARAM_ENTITY_REF: return XML_ERROR_PARAM_ENTITY_REF; case XML_TOK_XML_DECL: return XML_ERROR_MISPLACED_XML_PI; default: return XML_ERROR_SYNTAX; } #ifdef XML_DTD case XML_ROLE_IGNORE_SECT: { enum XML_Error result; if (defaultHandler) reportDefault(parser, enc, s, next); result = doIgnoreSection(parser, enc, &next, end, nextPtr); if (!next) { processor = ignoreSectionProcessor; return result; } } break; #endif /* XML_DTD */ case XML_ROLE_GROUP_OPEN: if (prologState.level >= groupSize) { if (groupSize) groupConnector = realloc(groupConnector, groupSize *= 2); else groupConnector = malloc(groupSize = 32); if (!groupConnector) return XML_ERROR_NO_MEMORY; } groupConnector[prologState.level] = 0; break; case XML_ROLE_GROUP_SEQUENCE: if (groupConnector[prologState.level] == '|') return XML_ERROR_SYNTAX; groupConnector[prologState.level] = ','; break; case XML_ROLE_GROUP_CHOICE: if (groupConnector[prologState.level] == ',') return XML_ERROR_SYNTAX; groupConnector[prologState.level] = '|'; break; case XML_ROLE_PARAM_ENTITY_REF: #ifdef XML_DTD case XML_ROLE_INNER_PARAM_ENTITY_REF: if (paramEntityParsing && (dtd.complete || role == XML_ROLE_INNER_PARAM_ENTITY_REF)) { const XML_Char *name; ENTITY *entity; name = poolStoreString(&dtd.pool, enc, s + enc->minBytesPerChar, next - enc->minBytesPerChar); if (!name) return XML_ERROR_NO_MEMORY; entity = (ENTITY *)lookup(&dtd.paramEntities, name, 0); poolDiscard(&dtd.pool); if (!entity) { /* FIXME what to do if !dtd.complete? */ return XML_ERROR_UNDEFINED_ENTITY; } if (entity->open) return XML_ERROR_RECURSIVE_ENTITY_REF; if (entity->textPtr) { enum XML_Error result; result = processInternalParamEntity(parser, entity); if (result != XML_ERROR_NONE) return result; break; } if (role == XML_ROLE_INNER_PARAM_ENTITY_REF) return XML_ERROR_PARAM_ENTITY_REF; if (externalEntityRefHandler) { dtd.complete = 0; entity->open = 1; if (!externalEntityRefHandler(externalEntityRefHandlerArg, 0, entity->base, entity->systemId, entity->publicId)) { entity->open = 0; return XML_ERROR_EXTERNAL_ENTITY_HANDLING; } entity->open = 0; if (dtd.complete) break; } } #endif /* XML_DTD */ if (!dtd.standalone && notStandaloneHandler && !notStandaloneHandler(handlerArg)) return XML_ERROR_NOT_STANDALONE; dtd.complete = 0; if (defaultHandler) reportDefault(parser, enc, s, next); break; case XML_ROLE_NONE: switch (tok) { case XML_TOK_PI: if (!reportProcessingInstruction(parser, enc, s, next)) return XML_ERROR_NO_MEMORY; break; case XML_TOK_COMMENT: if (!reportComment(parser, enc, s, next)) return XML_ERROR_NO_MEMORY; break; } break; } if (defaultHandler) { switch (tok) { case XML_TOK_PI: case XML_TOK_COMMENT: case XML_TOK_BOM: case XML_TOK_XML_DECL: #ifdef XML_DTD case XML_TOK_IGNORE_SECT: #endif /* XML_DTD */ case XML_TOK_PARAM_ENTITY_REF: break; default: #ifdef XML_DTD if (role != XML_ROLE_IGNORE_SECT) #endif /* XML_DTD */ reportDefault(parser, enc, s, next); } } s = next; tok = XmlPrologTok(enc, s, end, &next); } /* not reached */ } static enum XML_Error epilogProcessor(XML_Parser parser, const char *s, const char *end, const char **nextPtr) { processor = epilogProcessor; eventPtr = s; for (;;) { const char *next; int tok = XmlPrologTok(encoding, s, end, &next); eventEndPtr = next; switch (tok) { case -XML_TOK_PROLOG_S: if (defaultHandler) { eventEndPtr = end; reportDefault(parser, encoding, s, end); } /* fall through */ case XML_TOK_NONE: if (nextPtr) *nextPtr = end; return XML_ERROR_NONE; case XML_TOK_PROLOG_S: if (defaultHandler) reportDefault(parser, encoding, s, next); break; case XML_TOK_PI: if (!reportProcessingInstruction(parser, encoding, s, next)) return XML_ERROR_NO_MEMORY; break; case XML_TOK_COMMENT: if (!reportComment(parser, encoding, s, next)) return XML_ERROR_NO_MEMORY; break; case XML_TOK_INVALID: eventPtr = next; return XML_ERROR_INVALID_TOKEN; case XML_TOK_PARTIAL: if (nextPtr) { *nextPtr = s; return XML_ERROR_NONE; } return XML_ERROR_UNCLOSED_TOKEN; case XML_TOK_PARTIAL_CHAR: if (nextPtr) { *nextPtr = s; return XML_ERROR_NONE; } return XML_ERROR_PARTIAL_CHAR; default: return XML_ERROR_JUNK_AFTER_DOC_ELEMENT; } eventPtr = s = next; } } #ifdef XML_DTD static enum XML_Error processInternalParamEntity(XML_Parser parser, ENTITY *entity) { const char *s, *end, *next; int tok; enum XML_Error result; OPEN_INTERNAL_ENTITY openEntity; entity->open = 1; openEntity.next = openInternalEntities; openInternalEntities = &openEntity; openEntity.entity = entity; openEntity.internalEventPtr = 0; openEntity.internalEventEndPtr = 0; s = (char *)entity->textPtr; end = (char *)(entity->textPtr + entity->textLen); tok = XmlPrologTok(internalEncoding, s, end, &next); result = doProlog(parser, internalEncoding, s, end, tok, next, 0); entity->open = 0; openInternalEntities = openEntity.next; return result; } #endif /* XML_DTD */ static enum XML_Error errorProcessor(XML_Parser parser, const char *s, const char *end, const char **nextPtr) { return errorCode; } static enum XML_Error storeAttributeValue(XML_Parser parser, const ENCODING *enc, int isCdata, const char *ptr, const char *end, STRING_POOL *pool) { enum XML_Error result = appendAttributeValue(parser, enc, isCdata, ptr, end, pool); if (result) return result; if (!isCdata && poolLength(pool) && poolLastChar(pool) == 0x20) poolChop(pool); if (!poolAppendChar(pool, XML_T('\0'))) return XML_ERROR_NO_MEMORY; return XML_ERROR_NONE; } static enum XML_Error appendAttributeValue(XML_Parser parser, const ENCODING *enc, int isCdata, const char *ptr, const char *end, STRING_POOL *pool) { for (;;) { const char *next; int tok = XmlAttributeValueTok(enc, ptr, end, &next); switch (tok) { case XML_TOK_NONE: return XML_ERROR_NONE; case XML_TOK_INVALID: if (enc == encoding) eventPtr = next; return XML_ERROR_INVALID_TOKEN; case XML_TOK_PARTIAL: if (enc == encoding) eventPtr = ptr; return XML_ERROR_INVALID_TOKEN; case XML_TOK_CHAR_REF: { XML_Char buf[XML_ENCODE_MAX]; int i; int n = XmlCharRefNumber(enc, ptr); if (n < 0) { if (enc == encoding) eventPtr = ptr; return XML_ERROR_BAD_CHAR_REF; } if (!isCdata && n == 0x20 /* space */ && (poolLength(pool) == 0 || poolLastChar(pool) == 0x20)) break; n = XmlEncode(n, (ICHAR *)buf); if (!n) { if (enc == encoding) eventPtr = ptr; return XML_ERROR_BAD_CHAR_REF; } for (i = 0; i < n; i++) { if (!poolAppendChar(pool, buf[i])) return XML_ERROR_NO_MEMORY; } } break; case XML_TOK_DATA_CHARS: if (!poolAppend(pool, enc, ptr, next)) return XML_ERROR_NO_MEMORY; break; break; case XML_TOK_TRAILING_CR: next = ptr + enc->minBytesPerChar; /* fall through */ case XML_TOK_ATTRIBUTE_VALUE_S: case XML_TOK_DATA_NEWLINE: if (!isCdata && (poolLength(pool) == 0 || poolLastChar(pool) == 0x20)) break; if (!poolAppendChar(pool, 0x20)) return XML_ERROR_NO_MEMORY; break; case XML_TOK_ENTITY_REF: { const XML_Char *name; ENTITY *entity; XML_Char ch = XmlPredefinedEntityName(enc, ptr + enc->minBytesPerChar, next - enc->minBytesPerChar); if (ch) { if (!poolAppendChar(pool, ch)) return XML_ERROR_NO_MEMORY; break; } name = poolStoreString(&temp2Pool, enc, ptr + enc->minBytesPerChar, next - enc->minBytesPerChar); if (!name) return XML_ERROR_NO_MEMORY; entity = (ENTITY *)lookup(&dtd.generalEntities, name, 0); poolDiscard(&temp2Pool); if (!entity) { if (dtd.complete) { if (enc == encoding) eventPtr = ptr; return XML_ERROR_UNDEFINED_ENTITY; } } else if (entity->open) { if (enc == encoding) eventPtr = ptr; return XML_ERROR_RECURSIVE_ENTITY_REF; } else if (entity->notation) { if (enc == encoding) eventPtr = ptr; return XML_ERROR_BINARY_ENTITY_REF; } else if (!entity->textPtr) { if (enc == encoding) eventPtr = ptr; return XML_ERROR_ATTRIBUTE_EXTERNAL_ENTITY_REF; } else { enum XML_Error result; const XML_Char *textEnd = entity->textPtr + entity->textLen; entity->open = 1; result = appendAttributeValue(parser, internalEncoding, isCdata, (char *)entity->textPtr, (char *)textEnd, pool); entity->open = 0; if (result) return result; } } break; default: abort(); } ptr = next; } /* not reached */ } static enum XML_Error storeEntityValue(XML_Parser parser, const ENCODING *enc, const char *entityTextPtr, const char *entityTextEnd) { STRING_POOL *pool = &(dtd.pool); for (;;) { const char *next; int tok = XmlEntityValueTok(enc, entityTextPtr, entityTextEnd, &next); switch (tok) { case XML_TOK_PARAM_ENTITY_REF: #ifdef XML_DTD if (parentParser || enc != encoding) { enum XML_Error result; const XML_Char *name; ENTITY *entity; name = poolStoreString(&tempPool, enc, entityTextPtr + enc->minBytesPerChar, next - enc->minBytesPerChar); if (!name) return XML_ERROR_NO_MEMORY; entity = (ENTITY *)lookup(&dtd.paramEntities, name, 0); poolDiscard(&tempPool); if (!entity) { if (enc == encoding) eventPtr = entityTextPtr; return XML_ERROR_UNDEFINED_ENTITY; } if (entity->open) { if (enc == encoding) eventPtr = entityTextPtr; return XML_ERROR_RECURSIVE_ENTITY_REF; } if (entity->systemId) { if (enc == encoding) eventPtr = entityTextPtr; return XML_ERROR_PARAM_ENTITY_REF; } entity->open = 1; result = storeEntityValue(parser, internalEncoding, (char *)entity->textPtr, (char *)(entity->textPtr + entity->textLen)); entity->open = 0; if (result) return result; break; } #endif /* XML_DTD */ eventPtr = entityTextPtr; return XML_ERROR_SYNTAX; case XML_TOK_NONE: return XML_ERROR_NONE; case XML_TOK_ENTITY_REF: case XML_TOK_DATA_CHARS: if (!poolAppend(pool, enc, entityTextPtr, next)) return XML_ERROR_NO_MEMORY; break; case XML_TOK_TRAILING_CR: next = entityTextPtr + enc->minBytesPerChar; /* fall through */ case XML_TOK_DATA_NEWLINE: if (pool->end == pool->ptr && !poolGrow(pool)) return XML_ERROR_NO_MEMORY; *(pool->ptr)++ = 0xA; break; case XML_TOK_CHAR_REF: { XML_Char buf[XML_ENCODE_MAX]; int i; int n = XmlCharRefNumber(enc, entityTextPtr); if (n < 0) { if (enc == encoding) eventPtr = entityTextPtr; return XML_ERROR_BAD_CHAR_REF; } n = XmlEncode(n, (ICHAR *)buf); if (!n) { if (enc == encoding) eventPtr = entityTextPtr; return XML_ERROR_BAD_CHAR_REF; } for (i = 0; i < n; i++) { if (pool->end == pool->ptr && !poolGrow(pool)) return XML_ERROR_NO_MEMORY; *(pool->ptr)++ = buf[i]; } } break; case XML_TOK_PARTIAL: if (enc == encoding) eventPtr = entityTextPtr; return XML_ERROR_INVALID_TOKEN; case XML_TOK_INVALID: if (enc == encoding) eventPtr = next; return XML_ERROR_INVALID_TOKEN; default: abort(); } entityTextPtr = next; } /* not reached */ } static void normalizeLines(XML_Char *s) { XML_Char *p; for (;; s++) { if (*s == XML_T('\0')) return; if (*s == 0xD) break; } p = s; do { if (*s == 0xD) { *p++ = 0xA; if (*++s == 0xA) s++; } else *p++ = *s++; } while (*s); *p = XML_T('\0'); } static int reportProcessingInstruction(XML_Parser parser, const ENCODING *enc, const char *start, const char *end) { const XML_Char *target; XML_Char *data; const char *tem; if (!processingInstructionHandler) { if (defaultHandler) reportDefault(parser, enc, start, end); return 1; } start += enc->minBytesPerChar * 2; tem = start + XmlNameLength(enc, start); target = poolStoreString(&tempPool, enc, start, tem); if (!target) return 0; poolFinish(&tempPool); data = poolStoreString(&tempPool, enc, XmlSkipS(enc, tem), end - enc->minBytesPerChar*2); if (!data) return 0; normalizeLines(data); processingInstructionHandler(handlerArg, target, data); poolClear(&tempPool); return 1; } static int reportComment(XML_Parser parser, const ENCODING *enc, const char *start, const char *end) { XML_Char *data; if (!commentHandler) { if (defaultHandler) reportDefault(parser, enc, start, end); return 1; } data = poolStoreString(&tempPool, enc, start + enc->minBytesPerChar * 4, end - enc->minBytesPerChar * 3); if (!data) return 0; normalizeLines(data); commentHandler(handlerArg, data); poolClear(&tempPool); return 1; } static void reportDefault(XML_Parser parser, const ENCODING *enc, const char *s, const char *end) { if (MUST_CONVERT(enc, s)) { const char **eventPP; const char **eventEndPP; if (enc == encoding) { eventPP = &eventPtr; eventEndPP = &eventEndPtr; } else { eventPP = &(openInternalEntities->internalEventPtr); eventEndPP = &(openInternalEntities->internalEventEndPtr); } do { ICHAR *dataPtr = (ICHAR *)dataBuf; XmlConvert(enc, &s, end, &dataPtr, (ICHAR *)dataBufEnd); *eventEndPP = s; defaultHandler(handlerArg, dataBuf, (int)(dataPtr - (ICHAR *)dataBuf));// int added by DBL *eventPP = s; } while (s != end); } else defaultHandler(handlerArg, (XML_Char *)s, (int)((XML_Char *)end - (XML_Char *)s));// int added by DBL } static int defineAttribute(ELEMENT_TYPE *type, ATTRIBUTE_ID *attId, int isCdata, int isId, const XML_Char *value) { DEFAULT_ATTRIBUTE *att; if (value || isId) { /* The handling of default attributes gets messed up if we have a default which duplicates a non-default. */ int i; for (i = 0; i < type->nDefaultAtts; i++) if (attId == type->defaultAtts[i].id) return 1; if (isId && !type->idAtt && !attId->xmlns) type->idAtt = attId; } if (type->nDefaultAtts == type->allocDefaultAtts) { if (type->allocDefaultAtts == 0) { type->allocDefaultAtts = 8; type->defaultAtts = malloc(type->allocDefaultAtts*sizeof(DEFAULT_ATTRIBUTE)); } else { type->allocDefaultAtts *= 2; type->defaultAtts = realloc(type->defaultAtts, type->allocDefaultAtts*sizeof(DEFAULT_ATTRIBUTE)); } if (!type->defaultAtts) return 0; } att = type->defaultAtts + type->nDefaultAtts; att->id = attId; att->value = value; att->isCdata = isCdata; if (!isCdata) attId->maybeTokenized = 1; type->nDefaultAtts += 1; return 1; } static int setElementTypePrefix(XML_Parser parser, ELEMENT_TYPE *elementType) { const XML_Char *name; for (name = elementType->name; *name; name++) { if (*name == XML_T(':')) { PREFIX *prefix; const XML_Char *s; for (s = elementType->name; s != name; s++) { if (!poolAppendChar(&dtd.pool, *s)) return 0; } if (!poolAppendChar(&dtd.pool, XML_T('\0'))) return 0; prefix = (PREFIX *)lookup(&dtd.prefixes, poolStart(&dtd.pool), sizeof(PREFIX)); if (!prefix) return 0; if (prefix->name == poolStart(&dtd.pool)) poolFinish(&dtd.pool); else poolDiscard(&dtd.pool); elementType->prefix = prefix; } } return 1; } static ATTRIBUTE_ID * getAttributeId(XML_Parser parser, const ENCODING *enc, const char *start, const char *end) { ATTRIBUTE_ID *id; const XML_Char *name; if (!poolAppendChar(&dtd.pool, XML_T('\0'))) return 0; name = poolStoreString(&dtd.pool, enc, start, end); if (!name) return 0; ++name; id = (ATTRIBUTE_ID *)lookup(&dtd.attributeIds, name, sizeof(ATTRIBUTE_ID)); if (!id) return 0; if (id->name != name) poolDiscard(&dtd.pool); else { poolFinish(&dtd.pool); if (!ns) ; else if (name[0] == 'x' && name[1] == 'm' && name[2] == 'l' && name[3] == 'n' && name[4] == 's' && (name[5] == XML_T('\0') || name[5] == XML_T(':'))) { if (name[5] == '\0') id->prefix = &dtd.defaultPrefix; else id->prefix = (PREFIX *)lookup(&dtd.prefixes, name + 6, sizeof(PREFIX)); id->xmlns = 1; } else { int i; for (i = 0; name[i]; i++) { if (name[i] == XML_T(':')) { int j; for (j = 0; j < i; j++) { if (!poolAppendChar(&dtd.pool, name[j])) return 0; } if (!poolAppendChar(&dtd.pool, XML_T('\0'))) return 0; id->prefix = (PREFIX *)lookup(&dtd.prefixes, poolStart(&dtd.pool), sizeof(PREFIX)); if (id->prefix->name == poolStart(&dtd.pool)) poolFinish(&dtd.pool); else poolDiscard(&dtd.pool); break; } } } } return id; } #define CONTEXT_SEP XML_T('\f') static const XML_Char *getContext(XML_Parser parser) { HASH_TABLE_ITER iter; int needSep = 0; if (dtd.defaultPrefix.binding) { int i; int len; if (!poolAppendChar(&tempPool, XML_T('='))) return 0; len = dtd.defaultPrefix.binding->uriLen; if (namespaceSeparator != XML_T('\0')) len--; for (i = 0; i < len; i++) if (!poolAppendChar(&tempPool, dtd.defaultPrefix.binding->uri[i])) return 0; needSep = 1; } hashTableIterInit(&iter, &(dtd.prefixes)); for (;;) { int i; int len; const XML_Char *s; PREFIX *prefix = (PREFIX *)hashTableIterNext(&iter); if (!prefix) break; if (!prefix->binding) continue; if (needSep && !poolAppendChar(&tempPool, CONTEXT_SEP)) return 0; for (s = prefix->name; *s; s++) if (!poolAppendChar(&tempPool, *s)) return 0; if (!poolAppendChar(&tempPool, XML_T('='))) return 0; len = prefix->binding->uriLen; if (namespaceSeparator != XML_T('\0')) len--; for (i = 0; i < len; i++) if (!poolAppendChar(&tempPool, prefix->binding->uri[i])) return 0; needSep = 1; } hashTableIterInit(&iter, &(dtd.generalEntities)); for (;;) { const XML_Char *s; ENTITY *e = (ENTITY *)hashTableIterNext(&iter); if (!e) break; if (!e->open) continue; if (needSep && !poolAppendChar(&tempPool, CONTEXT_SEP)) return 0; for (s = e->name; *s; s++) if (!poolAppendChar(&tempPool, *s)) return 0; needSep = 1; } if (!poolAppendChar(&tempPool, XML_T('\0'))) return 0; return tempPool.start; } static int setContext(XML_Parser parser, const XML_Char *context) { const XML_Char *s = context; while (*context != XML_T('\0')) { if (*s == CONTEXT_SEP || *s == XML_T('\0')) { ENTITY *e; if (!poolAppendChar(&tempPool, XML_T('\0'))) return 0; e = (ENTITY *)lookup(&dtd.generalEntities, poolStart(&tempPool), 0); if (e) e->open = 1; if (*s != XML_T('\0')) s++; context = s; poolDiscard(&tempPool); } else if (*s == '=') { PREFIX *prefix; if (poolLength(&tempPool) == 0) prefix = &dtd.defaultPrefix; else { if (!poolAppendChar(&tempPool, XML_T('\0'))) return 0; prefix = (PREFIX *)lookup(&dtd.prefixes, poolStart(&tempPool), sizeof(PREFIX)); if (!prefix) return 0; if (prefix->name == poolStart(&tempPool)) { prefix->name = poolCopyString(&dtd.pool, prefix->name); if (!prefix->name) return 0; } poolDiscard(&tempPool); } for (context = s + 1; *context != CONTEXT_SEP && *context != XML_T('\0'); context++) if (!poolAppendChar(&tempPool, *context)) return 0; if (!poolAppendChar(&tempPool, XML_T('\0'))) return 0; if (!addBinding(parser, prefix, 0, poolStart(&tempPool), &inheritedBindings)) return 0; poolDiscard(&tempPool); if (*context != XML_T('\0')) ++context; s = context; } else { if (!poolAppendChar(&tempPool, *s)) return 0; s++; } } return 1; } static void normalizePublicId(XML_Char *publicId) { XML_Char *p = publicId; XML_Char *s; for (s = publicId; *s; s++) { switch (*s) { case 0x20: case 0xD: case 0xA: if (p != publicId && p[-1] != 0x20) *p++ = 0x20; break; default: *p++ = *s; } } if (p != publicId && p[-1] == 0x20) --p; *p = XML_T('\0'); } static int dtdInit(DTD *p) { poolInit(&(p->pool)); hashTableInit(&(p->generalEntities)); hashTableInit(&(p->elementTypes)); hashTableInit(&(p->attributeIds)); hashTableInit(&(p->prefixes)); p->complete = 1; p->standalone = 0; #ifdef XML_DTD hashTableInit(&(p->paramEntities)); #endif /* XML_DTD */ p->defaultPrefix.name = 0; p->defaultPrefix.binding = 0; return 1; } #ifdef XML_DTD static void dtdSwap(DTD *p1, DTD *p2) { DTD tem; memcpy(&tem, p1, sizeof(DTD)); memcpy(p1, p2, sizeof(DTD)); memcpy(p2, &tem, sizeof(DTD)); } #endif /* XML_DTD */ static void dtdDestroy(DTD *p) { HASH_TABLE_ITER iter; hashTableIterInit(&iter, &(p->elementTypes)); for (;;) { ELEMENT_TYPE *e = (ELEMENT_TYPE *)hashTableIterNext(&iter); if (!e) break; if (e->allocDefaultAtts != 0) free(e->defaultAtts); } hashTableDestroy(&(p->generalEntities)); #ifdef XML_DTD hashTableDestroy(&(p->paramEntities)); #endif /* XML_DTD */ hashTableDestroy(&(p->elementTypes)); hashTableDestroy(&(p->attributeIds)); hashTableDestroy(&(p->prefixes)); poolDestroy(&(p->pool)); } /* Do a deep copy of the DTD. Return 0 for out of memory; non-zero otherwise. The new DTD has already been initialized. */ static int dtdCopy(DTD *newDtd, const DTD *oldDtd) { HASH_TABLE_ITER iter; /* Copy the prefix table. */ hashTableIterInit(&iter, &(oldDtd->prefixes)); for (;;) { const XML_Char *name; const PREFIX *oldP = (PREFIX *)hashTableIterNext(&iter); if (!oldP) break; name = poolCopyString(&(newDtd->pool), oldP->name); if (!name) return 0; if (!lookup(&(newDtd->prefixes), name, sizeof(PREFIX))) return 0; } hashTableIterInit(&iter, &(oldDtd->attributeIds)); /* Copy the attribute id table. */ for (;;) { ATTRIBUTE_ID *newA; const XML_Char *name; const ATTRIBUTE_ID *oldA = (ATTRIBUTE_ID *)hashTableIterNext(&iter); if (!oldA) break; /* Remember to allocate the scratch byte before the name. */ if (!poolAppendChar(&(newDtd->pool), XML_T('\0'))) return 0; name = poolCopyString(&(newDtd->pool), oldA->name); if (!name) return 0; ++name; newA = (ATTRIBUTE_ID *)lookup(&(newDtd->attributeIds), name, sizeof(ATTRIBUTE_ID)); if (!newA) return 0; newA->maybeTokenized = oldA->maybeTokenized; if (oldA->prefix) { newA->xmlns = oldA->xmlns; if (oldA->prefix == &oldDtd->defaultPrefix) newA->prefix = &newDtd->defaultPrefix; else newA->prefix = (PREFIX *)lookup(&(newDtd->prefixes), oldA->prefix->name, 0); } } /* Copy the element type table. */ hashTableIterInit(&iter, &(oldDtd->elementTypes)); for (;;) { int i; ELEMENT_TYPE *newE; const XML_Char *name; const ELEMENT_TYPE *oldE = (ELEMENT_TYPE *)hashTableIterNext(&iter); if (!oldE) break; name = poolCopyString(&(newDtd->pool), oldE->name); if (!name) return 0; newE = (ELEMENT_TYPE *)lookup(&(newDtd->elementTypes), name, sizeof(ELEMENT_TYPE)); if (!newE) return 0; if (oldE->nDefaultAtts) { newE->defaultAtts = (DEFAULT_ATTRIBUTE *)malloc(oldE->nDefaultAtts * sizeof(DEFAULT_ATTRIBUTE)); if (!newE->defaultAtts) return 0; } if (oldE->idAtt) newE->idAtt = (ATTRIBUTE_ID *)lookup(&(newDtd->attributeIds), oldE->idAtt->name, 0); newE->allocDefaultAtts = newE->nDefaultAtts = oldE->nDefaultAtts; if (oldE->prefix) newE->prefix = (PREFIX *)lookup(&(newDtd->prefixes), oldE->prefix->name, 0); for (i = 0; i < newE->nDefaultAtts; i++) { newE->defaultAtts[i].id = (ATTRIBUTE_ID *)lookup(&(newDtd->attributeIds), oldE->defaultAtts[i].id->name, 0); newE->defaultAtts[i].isCdata = oldE->defaultAtts[i].isCdata; if (oldE->defaultAtts[i].value) { newE->defaultAtts[i].value = poolCopyString(&(newDtd->pool), oldE->defaultAtts[i].value); if (!newE->defaultAtts[i].value) return 0; } else newE->defaultAtts[i].value = 0; } } /* Copy the entity tables. */ if (!copyEntityTable(&(newDtd->generalEntities), &(newDtd->pool), &(oldDtd->generalEntities))) return 0; #ifdef XML_DTD if (!copyEntityTable(&(newDtd->paramEntities), &(newDtd->pool), &(oldDtd->paramEntities))) return 0; #endif /* XML_DTD */ newDtd->complete = oldDtd->complete; newDtd->standalone = oldDtd->standalone; return 1; } static int copyEntityTable(HASH_TABLE *newTable, STRING_POOL *newPool, const HASH_TABLE *oldTable) { HASH_TABLE_ITER iter; const XML_Char *cachedOldBase = 0; const XML_Char *cachedNewBase = 0; hashTableIterInit(&iter, oldTable); for (;;) { ENTITY *newE; const XML_Char *name; const ENTITY *oldE = (ENTITY *)hashTableIterNext(&iter); if (!oldE) break; name = poolCopyString(newPool, oldE->name); if (!name) return 0; newE = (ENTITY *)lookup(newTable, name, sizeof(ENTITY)); if (!newE) return 0; if (oldE->systemId) { const XML_Char *tem = poolCopyString(newPool, oldE->systemId); if (!tem) return 0; newE->systemId = tem; if (oldE->base) { if (oldE->base == cachedOldBase) newE->base = cachedNewBase; else { cachedOldBase = oldE->base; tem = poolCopyString(newPool, cachedOldBase); if (!tem) return 0; cachedNewBase = newE->base = tem; } } } else { const XML_Char *tem = poolCopyStringN(newPool, oldE->textPtr, oldE->textLen); if (!tem) return 0; newE->textPtr = tem; newE->textLen = oldE->textLen; } if (oldE->notation) { const XML_Char *tem = poolCopyString(newPool, oldE->notation); if (!tem) return 0; newE->notation = tem; } } return 1; } #define INIT_SIZE 64 static int keyeq(KEY s1, KEY s2) { for (; *s1 == *s2; s1++, s2++) if (*s1 == 0) return 1; return 0; } static unsigned long hash(KEY s) { unsigned long h = 0; while (*s) h = (h << 5) + h + (unsigned char)*s++; return h; } static NAMED *lookup(HASH_TABLE *table, KEY name, size_t createSize) { size_t i; if (table->size == 0) { if (!createSize) return 0; table->v = calloc(INIT_SIZE, sizeof(NAMED *)); if (!table->v) return 0; table->size = INIT_SIZE; table->usedLim = INIT_SIZE / 2; i = hash(name) & (table->size - 1); } else { unsigned long h = hash(name); for (i = h & (table->size - 1); table->v[i]; i == 0 ? i = table->size - 1 : --i) { if (keyeq(name, table->v[i]->name)) return table->v[i]; } if (!createSize) return 0; if (table->used == table->usedLim) { /* check for overflow */ size_t newSize = table->size * 2; NAMED **newV = calloc(newSize, sizeof(NAMED *)); if (!newV) return 0; for (i = 0; i < table->size; i++) if (table->v[i]) { size_t j; for (j = hash(table->v[i]->name) & (newSize - 1); newV[j]; j == 0 ? j = newSize - 1 : --j) ; newV[j] = table->v[i]; } free(table->v); table->v = newV; table->size = newSize; table->usedLim = newSize/2; for (i = h & (table->size - 1); table->v[i]; i == 0 ? i = table->size - 1 : --i) ; } } table->v[i] = calloc(1, createSize); if (!table->v[i]) return 0; table->v[i]->name = name; (table->used)++; return table->v[i]; } static void hashTableDestroy(HASH_TABLE *table) { size_t i; for (i = 0; i < table->size; i++) { NAMED *p = table->v[i]; if (p) free(p); } if (table->v) free(table->v); } static void hashTableInit(HASH_TABLE *p) { p->size = 0; p->usedLim = 0; p->used = 0; p->v = 0; } static void hashTableIterInit(HASH_TABLE_ITER *iter, const HASH_TABLE *table) { iter->p = table->v; iter->end = iter->p + table->size; } static NAMED *hashTableIterNext(HASH_TABLE_ITER *iter) { while (iter->p != iter->end) { NAMED *tem = *(iter->p)++; if (tem) return tem; } return 0; } static void poolInit(STRING_POOL *pool) { pool->blocks = 0; pool->freeBlocks = 0; pool->start = 0; pool->ptr = 0; pool->end = 0; } static void poolClear(STRING_POOL *pool) { if (!pool->freeBlocks) pool->freeBlocks = pool->blocks; else { BLOCK *p = pool->blocks; while (p) { BLOCK *tem = p->next; p->next = pool->freeBlocks; pool->freeBlocks = p; p = tem; } } pool->blocks = 0; pool->start = 0; pool->ptr = 0; pool->end = 0; } static void poolDestroy(STRING_POOL *pool) { BLOCK *p = pool->blocks; while (p) { BLOCK *tem = p->next; free(p); p = tem; } pool->blocks = 0; p = pool->freeBlocks; while (p) { BLOCK *tem = p->next; free(p); p = tem; } pool->freeBlocks = 0; pool->ptr = 0; pool->start = 0; pool->end = 0; } static XML_Char *poolAppend(STRING_POOL *pool, const ENCODING *enc, const char *ptr, const char *end) { if (!pool->ptr && !poolGrow(pool)) return 0; for (;;) { XmlConvert(enc, &ptr, end, (ICHAR **)&(pool->ptr), (ICHAR *)pool->end); if (ptr == end) break; if (!poolGrow(pool)) return 0; } return pool->start; } static const XML_Char *poolCopyString(STRING_POOL *pool, const XML_Char *s) { do { if (!poolAppendChar(pool, *s)) return 0; } while (*s++); s = pool->start; poolFinish(pool); return s; } static const XML_Char *poolCopyStringN(STRING_POOL *pool, const XML_Char *s, int n) { if (!pool->ptr && !poolGrow(pool)) return 0; for (; n > 0; --n, s++) { if (!poolAppendChar(pool, *s)) return 0; } s = pool->start; poolFinish(pool); return s; } static XML_Char *poolStoreString(STRING_POOL *pool, const ENCODING *enc, const char *ptr, const char *end) { if (!poolAppend(pool, enc, ptr, end)) return 0; if (pool->ptr == pool->end && !poolGrow(pool)) return 0; *(pool->ptr)++ = 0; return pool->start; } static int poolGrow(STRING_POOL *pool) { if (pool->freeBlocks) { if (pool->start == 0) { pool->blocks = pool->freeBlocks; pool->freeBlocks = pool->freeBlocks->next; pool->blocks->next = 0; pool->start = pool->blocks->s; pool->end = pool->start + pool->blocks->size; pool->ptr = pool->start; return 1; } if (pool->end - pool->start < pool->freeBlocks->size) { BLOCK *tem = pool->freeBlocks->next; pool->freeBlocks->next = pool->blocks; pool->blocks = pool->freeBlocks; pool->freeBlocks = tem; memcpy(pool->blocks->s, pool->start, (pool->end - pool->start) * sizeof(XML_Char)); pool->ptr = pool->blocks->s + (pool->ptr - pool->start); pool->start = pool->blocks->s; pool->end = pool->start + pool->blocks->size; return 1; } } if (pool->blocks && pool->start == pool->blocks->s) { int blockSize = (int) ((pool->end - pool->start)*2); pool->blocks = realloc(pool->blocks, offsetof(BLOCK, s) + blockSize * sizeof(XML_Char)); if (!pool->blocks) return 0; pool->blocks->size = blockSize; pool->ptr = pool->blocks->s + (pool->ptr - pool->start); pool->start = pool->blocks->s; pool->end = pool->start + blockSize; } else { BLOCK *tem; int blockSize = (int) (pool->end - pool->start); if (blockSize < INIT_BLOCK_SIZE) blockSize = INIT_BLOCK_SIZE; else blockSize *= 2; tem = malloc(offsetof(BLOCK, s) + blockSize * sizeof(XML_Char)); if (!tem) return 0; tem->size = blockSize; tem->next = pool->blocks; pool->blocks = tem; if (pool->ptr != pool->start) memcpy(tem->s, pool->start, (pool->ptr - pool->start) * sizeof(XML_Char)); pool->ptr = tem->s + (pool->ptr - pool->start); pool->start = tem->s; pool->end = tem->s + blockSize; } return 1; } visp-3.0.1/3rdparty/libatidaq-c/xmlparse.h000066400000000000000000000521411304511007300204170ustar00rootroot00000000000000/* Copyright (c) 1998, 1999, 2000 Thai Open Source Software Center Ltd * * The MIT License * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR * OTHER DEALINGS IN THE SOFTWARE. */ #ifndef XmlParse_INCLUDED #define XmlParse_INCLUDED 1 #ifdef __cplusplus extern "C" { #endif #ifndef XMLPARSEAPI #define XMLPARSEAPI /* as nothing */ #endif typedef void *XML_Parser; #ifdef XML_UNICODE_WCHAR_T /* XML_UNICODE_WCHAR_T will work only if sizeof(wchar_t) == 2 and wchar_t uses Unicode. */ /* Information is UTF-16 encoded as wchar_ts */ #ifndef XML_UNICODE #define XML_UNICODE #endif #include typedef wchar_t XML_Char; typedef wchar_t XML_LChar; #else /* not XML_UNICODE_WCHAR_T */ #ifdef XML_UNICODE /* Information is UTF-16 encoded as unsigned shorts */ typedef unsigned short XML_Char; typedef char XML_LChar; #else /* not XML_UNICODE */ /* Information is UTF-8 encoded. */ typedef char XML_Char; typedef char XML_LChar; #endif /* not XML_UNICODE */ #endif /* not XML_UNICODE_WCHAR_T */ /* Constructs a new parser; encoding is the encoding specified by the external protocol or null if there is none specified. */ XML_Parser XMLPARSEAPI XML_ParserCreate(const XML_Char *encoding); /* Constructs a new parser and namespace processor. Element type names and attribute names that belong to a namespace will be expanded; unprefixed attribute names are never expanded; unprefixed element type names are expanded only if there is a default namespace. The expanded name is the concatenation of the namespace URI, the namespace separator character, and the local part of the name. If the namespace separator is '\0' then the namespace URI and the local part will be concatenated without any separator. When a namespace is not declared, the name and prefix will be passed through without expansion. */ XML_Parser XMLPARSEAPI XML_ParserCreateNS(const XML_Char *encoding, XML_Char namespaceSeparator); /* atts is array of name/value pairs, terminated by 0; names and values are 0 terminated. */ typedef void (*XML_StartElementHandler)(void *userData, const XML_Char *name, const XML_Char **atts); typedef void (*XML_EndElementHandler)(void *userData, const XML_Char *name); /* s is not 0 terminated. */ typedef void (*XML_CharacterDataHandler)(void *userData, const XML_Char *s, int len); /* target and data are 0 terminated */ typedef void (*XML_ProcessingInstructionHandler)(void *userData, const XML_Char *target, const XML_Char *data); /* data is 0 terminated */ typedef void (*XML_CommentHandler)(void *userData, const XML_Char *data); typedef void (*XML_StartCdataSectionHandler)(void *userData); typedef void (*XML_EndCdataSectionHandler)(void *userData); /* This is called for any characters in the XML document for which there is no applicable handler. This includes both characters that are part of markup which is of a kind that is not reported (comments, markup declarations), or characters that are part of a construct which could be reported but for which no handler has been supplied. The characters are passed exactly as they were in the XML document except that they will be encoded in UTF-8. Line boundaries are not normalized. Note that a byte order mark character is not passed to the default handler. There are no guarantees about how characters are divided between calls to the default handler: for example, a comment might be split between multiple calls. */ typedef void (*XML_DefaultHandler)(void *userData, const XML_Char *s, int len); /* This is called for the start of the DOCTYPE declaration when the name of the DOCTYPE is encountered. */ typedef void (*XML_StartDoctypeDeclHandler)(void *userData, const XML_Char *doctypeName); /* This is called for the start of the DOCTYPE declaration when the closing > is encountered, but after processing any external subset. */ typedef void (*XML_EndDoctypeDeclHandler)(void *userData); /* This is called for a declaration of an unparsed (NDATA) entity. The base argument is whatever was set by XML_SetBase. The entityName, systemId and notationName arguments will never be null. The other arguments may be. */ typedef void (*XML_UnparsedEntityDeclHandler)(void *userData, const XML_Char *entityName, const XML_Char *base, const XML_Char *systemId, const XML_Char *publicId, const XML_Char *notationName); /* This is called for a declaration of notation. The base argument is whatever was set by XML_SetBase. The notationName will never be null. The other arguments can be. */ typedef void (*XML_NotationDeclHandler)(void *userData, const XML_Char *notationName, const XML_Char *base, const XML_Char *systemId, const XML_Char *publicId); typedef void (*XML_ExternalParsedEntityDeclHandler)(void *userData, const XML_Char *entityName, const XML_Char *base, const XML_Char *systemId, const XML_Char *publicId); typedef void (*XML_InternalParsedEntityDeclHandler)(void *userData, const XML_Char *entityName, const XML_Char *replacementText, int replacementTextLength); /* When namespace processing is enabled, these are called once for each namespace declaration. The call to the start and end element handlers occur between the calls to the start and end namespace declaration handlers. For an xmlns attribute, prefix will be null. For an xmlns="" attribute, uri will be null. */ typedef void (*XML_StartNamespaceDeclHandler)(void *userData, const XML_Char *prefix, const XML_Char *uri); typedef void (*XML_EndNamespaceDeclHandler)(void *userData, const XML_Char *prefix); /* This is called if the document is not standalone (it has an external subset or a reference to a parameter entity, but does not have standalone="yes"). If this handler returns 0, then processing will not continue, and the parser will return a XML_ERROR_NOT_STANDALONE error. */ typedef int (*XML_NotStandaloneHandler)(void *userData); /* This is called for a reference to an external parsed general entity. The referenced entity is not automatically parsed. The application can parse it immediately or later using XML_ExternalEntityParserCreate. The parser argument is the parser parsing the entity containing the reference; it can be passed as the parser argument to XML_ExternalEntityParserCreate. The systemId argument is the system identifier as specified in the entity declaration; it will not be null. The base argument is the system identifier that should be used as the base for resolving systemId if systemId was relative; this is set by XML_SetBase; it may be null. The publicId argument is the public identifier as specified in the entity declaration, or null if none was specified; the whitespace in the public identifier will have been normalized as required by the XML spec. The context argument specifies the parsing context in the format expected by the context argument to XML_ExternalEntityParserCreate; context is valid only until the handler returns, so if the referenced entity is to be parsed later, it must be copied. The handler should return 0 if processing should not continue because of a fatal error in the handling of the external entity. In this case the calling parser will return an XML_ERROR_EXTERNAL_ENTITY_HANDLING error. Note that unlike other handlers the first argument is the parser, not userData. */ typedef int (*XML_ExternalEntityRefHandler)(XML_Parser parser, const XML_Char *context, const XML_Char *base, const XML_Char *systemId, const XML_Char *publicId); /* This structure is filled in by the XML_UnknownEncodingHandler to provide information to the parser about encodings that are unknown to the parser. The map[b] member gives information about byte sequences whose first byte is b. If map[b] is c where c is >= 0, then b by itself encodes the Unicode scalar value c. If map[b] is -1, then the byte sequence is malformed. If map[b] is -n, where n >= 2, then b is the first byte of an n-byte sequence that encodes a single Unicode scalar value. The data member will be passed as the first argument to the convert function. The convert function is used to convert multibyte sequences; s will point to a n-byte sequence where map[(unsigned char)*s] == -n. The convert function must return the Unicode scalar value represented by this byte sequence or -1 if the byte sequence is malformed. The convert function may be null if the encoding is a single-byte encoding, that is if map[b] >= -1 for all bytes b. When the parser is finished with the encoding, then if release is not null, it will call release passing it the data member; once release has been called, the convert function will not be called again. Expat places certain restrictions on the encodings that are supported using this mechanism. 1. Every ASCII character that can appear in a well-formed XML document, other than the characters $@\^`{}~ must be represented by a single byte, and that byte must be the same byte that represents that character in ASCII. 2. No character may require more than 4 bytes to encode. 3. All characters encoded must have Unicode scalar values <= 0xFFFF, (ie characters that would be encoded by surrogates in UTF-16 are not allowed). Note that this restriction doesn't apply to the built-in support for UTF-8 and UTF-16. 4. No Unicode character may be encoded by more than one distinct sequence of bytes. */ typedef struct { int map[256]; void *data; int (*convert)(void *data, const char *s); void (*release)(void *data); } XML_Encoding; /* This is called for an encoding that is unknown to the parser. The encodingHandlerData argument is that which was passed as the second argument to XML_SetUnknownEncodingHandler. The name argument gives the name of the encoding as specified in the encoding declaration. If the callback can provide information about the encoding, it must fill in the XML_Encoding structure, and return 1. Otherwise it must return 0. If info does not describe a suitable encoding, then the parser will return an XML_UNKNOWN_ENCODING error. */ typedef int (*XML_UnknownEncodingHandler)(void *encodingHandlerData, const XML_Char *name, XML_Encoding *info); void XMLPARSEAPI XML_SetElementHandler(XML_Parser parser, XML_StartElementHandler start, XML_EndElementHandler end); void XMLPARSEAPI XML_SetCharacterDataHandler(XML_Parser parser, XML_CharacterDataHandler handler); void XMLPARSEAPI XML_SetProcessingInstructionHandler(XML_Parser parser, XML_ProcessingInstructionHandler handler); void XMLPARSEAPI XML_SetCommentHandler(XML_Parser parser, XML_CommentHandler handler); void XMLPARSEAPI XML_SetCdataSectionHandler(XML_Parser parser, XML_StartCdataSectionHandler start, XML_EndCdataSectionHandler end); /* This sets the default handler and also inhibits expansion of internal entities. The entity reference will be passed to the default handler. */ void XMLPARSEAPI XML_SetDefaultHandler(XML_Parser parser, XML_DefaultHandler handler); /* This sets the default handler but does not inhibit expansion of internal entities. The entity reference will not be passed to the default handler. */ void XMLPARSEAPI XML_SetDefaultHandlerExpand(XML_Parser parser, XML_DefaultHandler handler); void XMLPARSEAPI XML_SetDoctypeDeclHandler(XML_Parser parser, XML_StartDoctypeDeclHandler start, XML_EndDoctypeDeclHandler end); void XMLPARSEAPI XML_SetUnparsedEntityDeclHandler(XML_Parser parser, XML_UnparsedEntityDeclHandler handler); void XMLPARSEAPI XML_SetNotationDeclHandler(XML_Parser parser, XML_NotationDeclHandler handler); void XMLPARSEAPI XML_SetExternalParsedEntityDeclHandler(XML_Parser parser, XML_ExternalParsedEntityDeclHandler handler); void XMLPARSEAPI XML_SetInternalParsedEntityDeclHandler(XML_Parser parser, XML_InternalParsedEntityDeclHandler handler); void XMLPARSEAPI XML_SetNamespaceDeclHandler(XML_Parser parser, XML_StartNamespaceDeclHandler start, XML_EndNamespaceDeclHandler end); void XMLPARSEAPI XML_SetNotStandaloneHandler(XML_Parser parser, XML_NotStandaloneHandler handler); void XMLPARSEAPI XML_SetExternalEntityRefHandler(XML_Parser parser, XML_ExternalEntityRefHandler handler); /* If a non-null value for arg is specified here, then it will be passed as the first argument to the external entity ref handler instead of the parser object. */ void XMLPARSEAPI XML_SetExternalEntityRefHandlerArg(XML_Parser, void *arg); void XMLPARSEAPI XML_SetUnknownEncodingHandler(XML_Parser parser, XML_UnknownEncodingHandler handler, void *encodingHandlerData); /* This can be called within a handler for a start element, end element, processing instruction or character data. It causes the corresponding markup to be passed to the default handler. */ void XMLPARSEAPI XML_DefaultCurrent(XML_Parser parser); /* This value is passed as the userData argument to callbacks. */ void XMLPARSEAPI XML_SetUserData(XML_Parser parser, void *userData); /* Returns the last value set by XML_SetUserData or null. */ #define XML_GetUserData(parser) (*(void **)(parser)) /* This is equivalent to supplying an encoding argument to XML_ParserCreate. It must not be called after XML_Parse or XML_ParseBuffer. */ int XMLPARSEAPI XML_SetEncoding(XML_Parser parser, const XML_Char *encoding); /* If this function is called, then the parser will be passed as the first argument to callbacks instead of userData. The userData will still be accessible using XML_GetUserData. */ void XMLPARSEAPI XML_UseParserAsHandlerArg(XML_Parser parser); /* Sets the base to be used for resolving relative URIs in system identifiers in declarations. Resolving relative identifiers is left to the application: this value will be passed through as the base argument to the XML_ExternalEntityRefHandler, XML_NotationDeclHandler and XML_UnparsedEntityDeclHandler. The base argument will be copied. Returns zero if out of memory, non-zero otherwise. */ int XMLPARSEAPI XML_SetBase(XML_Parser parser, const XML_Char *base); const XML_Char XMLPARSEAPI * XML_GetBase(XML_Parser parser); /* Returns the number of the attribute/value pairs passed in last call to the XML_StartElementHandler that were specified in the start-tag rather than defaulted. Each attribute/value pair counts as 2; thus this correspondds to an index into the atts array passed to the XML_StartElementHandler. */ int XMLPARSEAPI XML_GetSpecifiedAttributeCount(XML_Parser parser); /* Returns the index of the ID attribute passed in the last call to XML_StartElementHandler, or -1 if there is no ID attribute. Each attribute/value pair counts as 2; thus this correspondds to an index into the atts array passed to the XML_StartElementHandler. */ int XMLPARSEAPI XML_GetIdAttributeIndex(XML_Parser parser); /* Parses some input. Returns 0 if a fatal error is detected. The last call to XML_Parse must have isFinal true; len may be zero for this call (or any other). */ int XMLPARSEAPI XML_Parse(XML_Parser parser, const char *s, int len, int isFinal); void XMLPARSEAPI * XML_GetBuffer(XML_Parser parser, int len); int XMLPARSEAPI XML_ParseBuffer(XML_Parser parser, int len, int isFinal); /* Creates an XML_Parser object that can parse an external general entity; context is a '\0'-terminated string specifying the parse context; encoding is a '\0'-terminated string giving the name of the externally specified encoding, or null if there is no externally specified encoding. The context string consists of a sequence of tokens separated by formfeeds (\f); a token consisting of a name specifies that the general entity of the name is open; a token of the form prefix=uri specifies the namespace for a particular prefix; a token of the form =uri specifies the default namespace. This can be called at any point after the first call to an ExternalEntityRefHandler so longer as the parser has not yet been freed. The new parser is completely independent and may safely be used in a separate thread. The handlers and userData are initialized from the parser argument. Returns 0 if out of memory. Otherwise returns a new XML_Parser object. */ XML_Parser XMLPARSEAPI XML_ExternalEntityParserCreate(XML_Parser parser, const XML_Char *context, const XML_Char *encoding); enum XML_ParamEntityParsing { XML_PARAM_ENTITY_PARSING_NEVER, XML_PARAM_ENTITY_PARSING_UNLESS_STANDALONE, XML_PARAM_ENTITY_PARSING_ALWAYS }; /* Controls parsing of parameter entities (including the external DTD subset). If parsing of parameter entities is enabled, then references to external parameter entities (including the external DTD subset) will be passed to the handler set with XML_SetExternalEntityRefHandler. The context passed will be 0. Unlike external general entities, external parameter entities can only be parsed synchronously. If the external parameter entity is to be parsed, it must be parsed during the call to the external entity ref handler: the complete sequence of XML_ExternalEntityParserCreate, XML_Parse/XML_ParseBuffer and XML_ParserFree calls must be made during this call. After XML_ExternalEntityParserCreate has been called to create the parser for the external parameter entity (context must be 0 for this call), it is illegal to make any calls on the old parser until XML_ParserFree has been called on the newly created parser. If the library has been compiled without support for parameter entity parsing (ie without XML_DTD being defined), then XML_SetParamEntityParsing will return 0 if parsing of parameter entities is requested; otherwise it will return non-zero. */ int XMLPARSEAPI XML_SetParamEntityParsing(XML_Parser parser, enum XML_ParamEntityParsing parsing); enum XML_Error { XML_ERROR_NONE, XML_ERROR_NO_MEMORY, XML_ERROR_SYNTAX, XML_ERROR_NO_ELEMENTS, XML_ERROR_INVALID_TOKEN, XML_ERROR_UNCLOSED_TOKEN, XML_ERROR_PARTIAL_CHAR, XML_ERROR_TAG_MISMATCH, XML_ERROR_DUPLICATE_ATTRIBUTE, XML_ERROR_JUNK_AFTER_DOC_ELEMENT, XML_ERROR_PARAM_ENTITY_REF, XML_ERROR_UNDEFINED_ENTITY, XML_ERROR_RECURSIVE_ENTITY_REF, XML_ERROR_ASYNC_ENTITY, XML_ERROR_BAD_CHAR_REF, XML_ERROR_BINARY_ENTITY_REF, XML_ERROR_ATTRIBUTE_EXTERNAL_ENTITY_REF, XML_ERROR_MISPLACED_XML_PI, XML_ERROR_UNKNOWN_ENCODING, XML_ERROR_INCORRECT_ENCODING, XML_ERROR_UNCLOSED_CDATA_SECTION, XML_ERROR_EXTERNAL_ENTITY_HANDLING, XML_ERROR_NOT_STANDALONE }; /* If XML_Parse or XML_ParseBuffer have returned 0, then XML_GetErrorCode returns information about the error. */ enum XML_Error XMLPARSEAPI XML_GetErrorCode(XML_Parser parser); /* These functions return information about the current parse location. They may be called when XML_Parse or XML_ParseBuffer return 0; in this case the location is the location of the character at which the error was detected. They may also be called from any other callback called to report some parse event; in this the location is the location of the first of the sequence of characters that generated the event. */ int XMLPARSEAPI XML_GetCurrentLineNumber(XML_Parser parser); int XMLPARSEAPI XML_GetCurrentColumnNumber(XML_Parser parser); long XMLPARSEAPI XML_GetCurrentByteIndex(XML_Parser parser); /* Return the number of bytes in the current event. Returns 0 if the event is in an internal entity. */ int XMLPARSEAPI XML_GetCurrentByteCount(XML_Parser parser); /* For backwards compatibility with previous versions. */ #define XML_GetErrorLineNumber XML_GetCurrentLineNumber #define XML_GetErrorColumnNumber XML_GetCurrentColumnNumber #define XML_GetErrorByteIndex XML_GetCurrentByteIndex /* Frees memory used by the parser. */ void XMLPARSEAPI XML_ParserFree(XML_Parser parser); /* Returns a string describing the error. */ const XML_LChar XMLPARSEAPI *XML_ErrorString(int code); #ifdef __cplusplus } #endif #endif /* not XmlParse_INCLUDED */ visp-3.0.1/3rdparty/libatidaq-c/xmlrole.c000066400000000000000000000741621304511007300202500ustar00rootroot00000000000000/* Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd * * The MIT License * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR * OTHER DEALINGS IN THE SOFTWARE. */ #include "xmldef.h" #include "xmlrole.h" #include "ascii.h" /* Doesn't check: that ,| are not mixed in a model group content of literals */ static const char KW_ANY[] = { ASCII_A, ASCII_N, ASCII_Y, '\0' }; static const char KW_ATTLIST[] = { ASCII_A, ASCII_T, ASCII_T, ASCII_L, ASCII_I, ASCII_S, ASCII_T, '\0' }; static const char KW_CDATA[] = { ASCII_C, ASCII_D, ASCII_A, ASCII_T, ASCII_A, '\0' }; static const char KW_DOCTYPE[] = { ASCII_D, ASCII_O, ASCII_C, ASCII_T, ASCII_Y, ASCII_P, ASCII_E, '\0' }; static const char KW_ELEMENT[] = { ASCII_E, ASCII_L, ASCII_E, ASCII_M, ASCII_E, ASCII_N, ASCII_T, '\0' }; static const char KW_EMPTY[] = { ASCII_E, ASCII_M, ASCII_P, ASCII_T, ASCII_Y, '\0' }; static const char KW_ENTITIES[] = { ASCII_E, ASCII_N, ASCII_T, ASCII_I, ASCII_T, ASCII_I, ASCII_E, ASCII_S, '\0' }; static const char KW_ENTITY[] = { ASCII_E, ASCII_N, ASCII_T, ASCII_I, ASCII_T, ASCII_Y, '\0' }; static const char KW_FIXED[] = { ASCII_F, ASCII_I, ASCII_X, ASCII_E, ASCII_D, '\0' }; static const char KW_ID[] = { ASCII_I, ASCII_D, '\0' }; static const char KW_IDREF[] = { ASCII_I, ASCII_D, ASCII_R, ASCII_E, ASCII_F, '\0' }; static const char KW_IDREFS[] = { ASCII_I, ASCII_D, ASCII_R, ASCII_E, ASCII_F, ASCII_S, '\0' }; static const char KW_IGNORE[] = { ASCII_I, ASCII_G, ASCII_N, ASCII_O, ASCII_R, ASCII_E, '\0' }; static const char KW_IMPLIED[] = { ASCII_I, ASCII_M, ASCII_P, ASCII_L, ASCII_I, ASCII_E, ASCII_D, '\0' }; static const char KW_INCLUDE[] = { ASCII_I, ASCII_N, ASCII_C, ASCII_L, ASCII_U, ASCII_D, ASCII_E, '\0' }; static const char KW_NDATA[] = { ASCII_N, ASCII_D, ASCII_A, ASCII_T, ASCII_A, '\0' }; static const char KW_NMTOKEN[] = { ASCII_N, ASCII_M, ASCII_T, ASCII_O, ASCII_K, ASCII_E, ASCII_N, '\0' }; static const char KW_NMTOKENS[] = { ASCII_N, ASCII_M, ASCII_T, ASCII_O, ASCII_K, ASCII_E, ASCII_N, ASCII_S, '\0' }; static const char KW_NOTATION[] = { ASCII_N, ASCII_O, ASCII_T, ASCII_A, ASCII_T, ASCII_I, ASCII_O, ASCII_N, '\0' }; static const char KW_PCDATA[] = { ASCII_P, ASCII_C, ASCII_D, ASCII_A, ASCII_T, ASCII_A, '\0' }; static const char KW_PUBLIC[] = { ASCII_P, ASCII_U, ASCII_B, ASCII_L, ASCII_I, ASCII_C, '\0' }; static const char KW_REQUIRED[] = { ASCII_R, ASCII_E, ASCII_Q, ASCII_U, ASCII_I, ASCII_R, ASCII_E, ASCII_D, '\0' }; static const char KW_SYSTEM[] = { ASCII_S, ASCII_Y, ASCII_S, ASCII_T, ASCII_E, ASCII_M, '\0' }; #ifndef MIN_BYTES_PER_CHAR #define MIN_BYTES_PER_CHAR(enc) ((enc)->minBytesPerChar) #endif #ifdef XML_DTD #define setTopLevel(state) \ ((state)->handler = ((state)->documentEntity \ ? internalSubset \ : externalSubset1)) #else /* not XML_DTD */ #define setTopLevel(state) ((state)->handler = internalSubset) #endif /* not XML_DTD */ typedef int PROLOG_HANDLER(PROLOG_STATE *state, int tok, const char *ptr, const char *end, const ENCODING *enc); static PROLOG_HANDLER prolog0, prolog1, prolog2, doctype0, doctype1, doctype2, doctype3, doctype4, doctype5, internalSubset, entity0, entity1, entity2, entity3, entity4, entity5, entity6, entity7, entity8, entity9, notation0, notation1, notation2, notation3, notation4, attlist0, attlist1, attlist2, attlist3, attlist4, attlist5, attlist6, attlist7, attlist8, attlist9, element0, element1, element2, element3, element4, element5, element6, element7, #ifdef XML_DTD externalSubset0, externalSubset1, condSect0, condSect1, condSect2, #endif /* XML_DTD */ declClose, error; static int common(PROLOG_STATE *state, int tok); static int prolog0(PROLOG_STATE *state, int tok, const char *ptr, const char *end, const ENCODING *enc) { switch (tok) { case XML_TOK_PROLOG_S: state->handler = prolog1; return XML_ROLE_NONE; case XML_TOK_XML_DECL: state->handler = prolog1; return XML_ROLE_XML_DECL; case XML_TOK_PI: state->handler = prolog1; return XML_ROLE_NONE; case XML_TOK_COMMENT: state->handler = prolog1; case XML_TOK_BOM: return XML_ROLE_NONE; case XML_TOK_DECL_OPEN: if (!XmlNameMatchesAscii(enc, ptr + 2 * MIN_BYTES_PER_CHAR(enc), end, KW_DOCTYPE)) break; state->handler = doctype0; return XML_ROLE_NONE; case XML_TOK_INSTANCE_START: state->handler = error; return XML_ROLE_INSTANCE_START; } return common(state, tok); } static int prolog1(PROLOG_STATE *state, int tok, const char *ptr, const char *end, const ENCODING *enc) { switch (tok) { case XML_TOK_PROLOG_S: return XML_ROLE_NONE; case XML_TOK_PI: case XML_TOK_COMMENT: case XML_TOK_BOM: return XML_ROLE_NONE; case XML_TOK_DECL_OPEN: if (!XmlNameMatchesAscii(enc, ptr + 2 * MIN_BYTES_PER_CHAR(enc), end, KW_DOCTYPE)) break; state->handler = doctype0; return XML_ROLE_NONE; case XML_TOK_INSTANCE_START: state->handler = error; return XML_ROLE_INSTANCE_START; } return common(state, tok); } static int prolog2(PROLOG_STATE *state, int tok, const char *ptr, const char *end, const ENCODING *enc) { switch (tok) { case XML_TOK_PROLOG_S: return XML_ROLE_NONE; case XML_TOK_PI: case XML_TOK_COMMENT: return XML_ROLE_NONE; case XML_TOK_INSTANCE_START: state->handler = error; return XML_ROLE_INSTANCE_START; } return common(state, tok); } static int doctype0(PROLOG_STATE *state, int tok, const char *ptr, const char *end, const ENCODING *enc) { switch (tok) { case XML_TOK_PROLOG_S: return XML_ROLE_NONE; case XML_TOK_NAME: case XML_TOK_PREFIXED_NAME: state->handler = doctype1; return XML_ROLE_DOCTYPE_NAME; } return common(state, tok); } static int doctype1(PROLOG_STATE *state, int tok, const char *ptr, const char *end, const ENCODING *enc) { switch (tok) { case XML_TOK_PROLOG_S: return XML_ROLE_NONE; case XML_TOK_OPEN_BRACKET: state->handler = internalSubset; return XML_ROLE_NONE; case XML_TOK_DECL_CLOSE: state->handler = prolog2; return XML_ROLE_DOCTYPE_CLOSE; case XML_TOK_NAME: if (XmlNameMatchesAscii(enc, ptr, end, KW_SYSTEM)) { state->handler = doctype3; return XML_ROLE_NONE; } if (XmlNameMatchesAscii(enc, ptr, end, KW_PUBLIC)) { state->handler = doctype2; return XML_ROLE_NONE; } break; } return common(state, tok); } static int doctype2(PROLOG_STATE *state, int tok, const char *ptr, const char *end, const ENCODING *enc) { switch (tok) { case XML_TOK_PROLOG_S: return XML_ROLE_NONE; case XML_TOK_LITERAL: state->handler = doctype3; return XML_ROLE_DOCTYPE_PUBLIC_ID; } return common(state, tok); } static int doctype3(PROLOG_STATE *state, int tok, const char *ptr, const char *end, const ENCODING *enc) { switch (tok) { case XML_TOK_PROLOG_S: return XML_ROLE_NONE; case XML_TOK_LITERAL: state->handler = doctype4; return XML_ROLE_DOCTYPE_SYSTEM_ID; } return common(state, tok); } static int doctype4(PROLOG_STATE *state, int tok, const char *ptr, const char *end, const ENCODING *enc) { switch (tok) { case XML_TOK_PROLOG_S: return XML_ROLE_NONE; case XML_TOK_OPEN_BRACKET: state->handler = internalSubset; return XML_ROLE_NONE; case XML_TOK_DECL_CLOSE: state->handler = prolog2; return XML_ROLE_DOCTYPE_CLOSE; } return common(state, tok); } static int doctype5(PROLOG_STATE *state, int tok, const char *ptr, const char *end, const ENCODING *enc) { switch (tok) { case XML_TOK_PROLOG_S: return XML_ROLE_NONE; case XML_TOK_DECL_CLOSE: state->handler = prolog2; return XML_ROLE_DOCTYPE_CLOSE; } return common(state, tok); } static int internalSubset(PROLOG_STATE *state, int tok, const char *ptr, const char *end, const ENCODING *enc) { switch (tok) { case XML_TOK_PROLOG_S: return XML_ROLE_NONE; case XML_TOK_DECL_OPEN: if (XmlNameMatchesAscii(enc, ptr + 2 * MIN_BYTES_PER_CHAR(enc), end, KW_ENTITY)) { state->handler = entity0; return XML_ROLE_NONE; } if (XmlNameMatchesAscii(enc, ptr + 2 * MIN_BYTES_PER_CHAR(enc), end, KW_ATTLIST)) { state->handler = attlist0; return XML_ROLE_NONE; } if (XmlNameMatchesAscii(enc, ptr + 2 * MIN_BYTES_PER_CHAR(enc), end, KW_ELEMENT)) { state->handler = element0; return XML_ROLE_NONE; } if (XmlNameMatchesAscii(enc, ptr + 2 * MIN_BYTES_PER_CHAR(enc), end, KW_NOTATION)) { state->handler = notation0; return XML_ROLE_NONE; } break; case XML_TOK_PI: case XML_TOK_COMMENT: return XML_ROLE_NONE; case XML_TOK_PARAM_ENTITY_REF: return XML_ROLE_PARAM_ENTITY_REF; case XML_TOK_CLOSE_BRACKET: state->handler = doctype5; return XML_ROLE_NONE; } return common(state, tok); } #ifdef XML_DTD static int externalSubset0(PROLOG_STATE *state, int tok, const char *ptr, const char *end, const ENCODING *enc) { state->handler = externalSubset1; if (tok == XML_TOK_XML_DECL) return XML_ROLE_TEXT_DECL; return externalSubset1(state, tok, ptr, end, enc); } static int externalSubset1(PROLOG_STATE *state, int tok, const char *ptr, const char *end, const ENCODING *enc) { switch (tok) { case XML_TOK_COND_SECT_OPEN: state->handler = condSect0; return XML_ROLE_NONE; case XML_TOK_COND_SECT_CLOSE: if (state->includeLevel == 0) break; state->includeLevel -= 1; return XML_ROLE_NONE; case XML_TOK_PROLOG_S: return XML_ROLE_NONE; case XML_TOK_CLOSE_BRACKET: break; case XML_TOK_NONE: if (state->includeLevel) break; return XML_ROLE_NONE; default: return internalSubset(state, tok, ptr, end, enc); } return common(state, tok); } #endif /* XML_DTD */ static int entity0(PROLOG_STATE *state, int tok, const char *ptr, const char *end, const ENCODING *enc) { switch (tok) { case XML_TOK_PROLOG_S: return XML_ROLE_NONE; case XML_TOK_PERCENT: state->handler = entity1; return XML_ROLE_NONE; case XML_TOK_NAME: state->handler = entity2; return XML_ROLE_GENERAL_ENTITY_NAME; } return common(state, tok); } static int entity1(PROLOG_STATE *state, int tok, const char *ptr, const char *end, const ENCODING *enc) { switch (tok) { case XML_TOK_PROLOG_S: return XML_ROLE_NONE; case XML_TOK_NAME: state->handler = entity7; return XML_ROLE_PARAM_ENTITY_NAME; } return common(state, tok); } static int entity2(PROLOG_STATE *state, int tok, const char *ptr, const char *end, const ENCODING *enc) { switch (tok) { case XML_TOK_PROLOG_S: return XML_ROLE_NONE; case XML_TOK_NAME: if (XmlNameMatchesAscii(enc, ptr, end, KW_SYSTEM)) { state->handler = entity4; return XML_ROLE_NONE; } if (XmlNameMatchesAscii(enc, ptr, end, KW_PUBLIC)) { state->handler = entity3; return XML_ROLE_NONE; } break; case XML_TOK_LITERAL: state->handler = declClose; return XML_ROLE_ENTITY_VALUE; } return common(state, tok); } static int entity3(PROLOG_STATE *state, int tok, const char *ptr, const char *end, const ENCODING *enc) { switch (tok) { case XML_TOK_PROLOG_S: return XML_ROLE_NONE; case XML_TOK_LITERAL: state->handler = entity4; return XML_ROLE_ENTITY_PUBLIC_ID; } return common(state, tok); } static int entity4(PROLOG_STATE *state, int tok, const char *ptr, const char *end, const ENCODING *enc) { switch (tok) { case XML_TOK_PROLOG_S: return XML_ROLE_NONE; case XML_TOK_LITERAL: state->handler = entity5; return XML_ROLE_ENTITY_SYSTEM_ID; } return common(state, tok); } static int entity5(PROLOG_STATE *state, int tok, const char *ptr, const char *end, const ENCODING *enc) { switch (tok) { case XML_TOK_PROLOG_S: return XML_ROLE_NONE; case XML_TOK_DECL_CLOSE: setTopLevel(state); return XML_ROLE_EXTERNAL_GENERAL_ENTITY_NO_NOTATION; case XML_TOK_NAME: if (XmlNameMatchesAscii(enc, ptr, end, KW_NDATA)) { state->handler = entity6; return XML_ROLE_NONE; } break; } return common(state, tok); } static int entity6(PROLOG_STATE *state, int tok, const char *ptr, const char *end, const ENCODING *enc) { switch (tok) { case XML_TOK_PROLOG_S: return XML_ROLE_NONE; case XML_TOK_NAME: state->handler = declClose; return XML_ROLE_ENTITY_NOTATION_NAME; } return common(state, tok); } static int entity7(PROLOG_STATE *state, int tok, const char *ptr, const char *end, const ENCODING *enc) { switch (tok) { case XML_TOK_PROLOG_S: return XML_ROLE_NONE; case XML_TOK_NAME: if (XmlNameMatchesAscii(enc, ptr, end, KW_SYSTEM)) { state->handler = entity9; return XML_ROLE_NONE; } if (XmlNameMatchesAscii(enc, ptr, end, KW_PUBLIC)) { state->handler = entity8; return XML_ROLE_NONE; } break; case XML_TOK_LITERAL: state->handler = declClose; return XML_ROLE_ENTITY_VALUE; } return common(state, tok); } static int entity8(PROLOG_STATE *state, int tok, const char *ptr, const char *end, const ENCODING *enc) { switch (tok) { case XML_TOK_PROLOG_S: return XML_ROLE_NONE; case XML_TOK_LITERAL: state->handler = entity9; return XML_ROLE_ENTITY_PUBLIC_ID; } return common(state, tok); } static int entity9(PROLOG_STATE *state, int tok, const char *ptr, const char *end, const ENCODING *enc) { switch (tok) { case XML_TOK_PROLOG_S: return XML_ROLE_NONE; case XML_TOK_LITERAL: state->handler = declClose; return XML_ROLE_ENTITY_SYSTEM_ID; } return common(state, tok); } static int notation0(PROLOG_STATE *state, int tok, const char *ptr, const char *end, const ENCODING *enc) { switch (tok) { case XML_TOK_PROLOG_S: return XML_ROLE_NONE; case XML_TOK_NAME: state->handler = notation1; return XML_ROLE_NOTATION_NAME; } return common(state, tok); } static int notation1(PROLOG_STATE *state, int tok, const char *ptr, const char *end, const ENCODING *enc) { switch (tok) { case XML_TOK_PROLOG_S: return XML_ROLE_NONE; case XML_TOK_NAME: if (XmlNameMatchesAscii(enc, ptr, end, KW_SYSTEM)) { state->handler = notation3; return XML_ROLE_NONE; } if (XmlNameMatchesAscii(enc, ptr, end, KW_PUBLIC)) { state->handler = notation2; return XML_ROLE_NONE; } break; } return common(state, tok); } static int notation2(PROLOG_STATE *state, int tok, const char *ptr, const char *end, const ENCODING *enc) { switch (tok) { case XML_TOK_PROLOG_S: return XML_ROLE_NONE; case XML_TOK_LITERAL: state->handler = notation4; return XML_ROLE_NOTATION_PUBLIC_ID; } return common(state, tok); } static int notation3(PROLOG_STATE *state, int tok, const char *ptr, const char *end, const ENCODING *enc) { switch (tok) { case XML_TOK_PROLOG_S: return XML_ROLE_NONE; case XML_TOK_LITERAL: state->handler = declClose; return XML_ROLE_NOTATION_SYSTEM_ID; } return common(state, tok); } static int notation4(PROLOG_STATE *state, int tok, const char *ptr, const char *end, const ENCODING *enc) { switch (tok) { case XML_TOK_PROLOG_S: return XML_ROLE_NONE; case XML_TOK_LITERAL: state->handler = declClose; return XML_ROLE_NOTATION_SYSTEM_ID; case XML_TOK_DECL_CLOSE: setTopLevel(state); return XML_ROLE_NOTATION_NO_SYSTEM_ID; } return common(state, tok); } static int attlist0(PROLOG_STATE *state, int tok, const char *ptr, const char *end, const ENCODING *enc) { switch (tok) { case XML_TOK_PROLOG_S: return XML_ROLE_NONE; case XML_TOK_NAME: case XML_TOK_PREFIXED_NAME: state->handler = attlist1; return XML_ROLE_ATTLIST_ELEMENT_NAME; } return common(state, tok); } static int attlist1(PROLOG_STATE *state, int tok, const char *ptr, const char *end, const ENCODING *enc) { switch (tok) { case XML_TOK_PROLOG_S: return XML_ROLE_NONE; case XML_TOK_DECL_CLOSE: setTopLevel(state); return XML_ROLE_NONE; case XML_TOK_NAME: case XML_TOK_PREFIXED_NAME: state->handler = attlist2; return XML_ROLE_ATTRIBUTE_NAME; } return common(state, tok); } static int attlist2(PROLOG_STATE *state, int tok, const char *ptr, const char *end, const ENCODING *enc) { switch (tok) { case XML_TOK_PROLOG_S: return XML_ROLE_NONE; case XML_TOK_NAME: { static const char *types[] = { KW_CDATA, KW_ID, KW_IDREF, KW_IDREFS, KW_ENTITY, KW_ENTITIES, KW_NMTOKEN, KW_NMTOKENS, }; int i; for (i = 0; i < (int)(sizeof(types)/sizeof(types[0])); i++) if (XmlNameMatchesAscii(enc, ptr, end, types[i])) { state->handler = attlist8; return XML_ROLE_ATTRIBUTE_TYPE_CDATA + i; } } if (XmlNameMatchesAscii(enc, ptr, end, KW_NOTATION)) { state->handler = attlist5; return XML_ROLE_NONE; } break; case XML_TOK_OPEN_PAREN: state->handler = attlist3; return XML_ROLE_NONE; } return common(state, tok); } static int attlist3(PROLOG_STATE *state, int tok, const char *ptr, const char *end, const ENCODING *enc) { switch (tok) { case XML_TOK_PROLOG_S: return XML_ROLE_NONE; case XML_TOK_NMTOKEN: case XML_TOK_NAME: case XML_TOK_PREFIXED_NAME: state->handler = attlist4; return XML_ROLE_ATTRIBUTE_ENUM_VALUE; } return common(state, tok); } static int attlist4(PROLOG_STATE *state, int tok, const char *ptr, const char *end, const ENCODING *enc) { switch (tok) { case XML_TOK_PROLOG_S: return XML_ROLE_NONE; case XML_TOK_CLOSE_PAREN: state->handler = attlist8; return XML_ROLE_NONE; case XML_TOK_OR: state->handler = attlist3; return XML_ROLE_NONE; } return common(state, tok); } static int attlist5(PROLOG_STATE *state, int tok, const char *ptr, const char *end, const ENCODING *enc) { switch (tok) { case XML_TOK_PROLOG_S: return XML_ROLE_NONE; case XML_TOK_OPEN_PAREN: state->handler = attlist6; return XML_ROLE_NONE; } return common(state, tok); } static int attlist6(PROLOG_STATE *state, int tok, const char *ptr, const char *end, const ENCODING *enc) { switch (tok) { case XML_TOK_PROLOG_S: return XML_ROLE_NONE; case XML_TOK_NAME: state->handler = attlist7; return XML_ROLE_ATTRIBUTE_NOTATION_VALUE; } return common(state, tok); } static int attlist7(PROLOG_STATE *state, int tok, const char *ptr, const char *end, const ENCODING *enc) { switch (tok) { case XML_TOK_PROLOG_S: return XML_ROLE_NONE; case XML_TOK_CLOSE_PAREN: state->handler = attlist8; return XML_ROLE_NONE; case XML_TOK_OR: state->handler = attlist6; return XML_ROLE_NONE; } return common(state, tok); } /* default value */ static int attlist8(PROLOG_STATE *state, int tok, const char *ptr, const char *end, const ENCODING *enc) { switch (tok) { case XML_TOK_PROLOG_S: return XML_ROLE_NONE; case XML_TOK_POUND_NAME: if (XmlNameMatchesAscii(enc, ptr + MIN_BYTES_PER_CHAR(enc), end, KW_IMPLIED)) { state->handler = attlist1; return XML_ROLE_IMPLIED_ATTRIBUTE_VALUE; } if (XmlNameMatchesAscii(enc, ptr + MIN_BYTES_PER_CHAR(enc), end, KW_REQUIRED)) { state->handler = attlist1; return XML_ROLE_REQUIRED_ATTRIBUTE_VALUE; } if (XmlNameMatchesAscii(enc, ptr + MIN_BYTES_PER_CHAR(enc), end, KW_FIXED)) { state->handler = attlist9; return XML_ROLE_NONE; } break; case XML_TOK_LITERAL: state->handler = attlist1; return XML_ROLE_DEFAULT_ATTRIBUTE_VALUE; } return common(state, tok); } static int attlist9(PROLOG_STATE *state, int tok, const char *ptr, const char *end, const ENCODING *enc) { switch (tok) { case XML_TOK_PROLOG_S: return XML_ROLE_NONE; case XML_TOK_LITERAL: state->handler = attlist1; return XML_ROLE_FIXED_ATTRIBUTE_VALUE; } return common(state, tok); } static int element0(PROLOG_STATE *state, int tok, const char *ptr, const char *end, const ENCODING *enc) { switch (tok) { case XML_TOK_PROLOG_S: return XML_ROLE_NONE; case XML_TOK_NAME: case XML_TOK_PREFIXED_NAME: state->handler = element1; return XML_ROLE_ELEMENT_NAME; } return common(state, tok); } static int element1(PROLOG_STATE *state, int tok, const char *ptr, const char *end, const ENCODING *enc) { switch (tok) { case XML_TOK_PROLOG_S: return XML_ROLE_NONE; case XML_TOK_NAME: if (XmlNameMatchesAscii(enc, ptr, end, KW_EMPTY)) { state->handler = declClose; return XML_ROLE_CONTENT_EMPTY; } if (XmlNameMatchesAscii(enc, ptr, end, KW_ANY)) { state->handler = declClose; return XML_ROLE_CONTENT_ANY; } break; case XML_TOK_OPEN_PAREN: state->handler = element2; state->level = 1; return XML_ROLE_GROUP_OPEN; } return common(state, tok); } static int element2(PROLOG_STATE *state, int tok, const char *ptr, const char *end, const ENCODING *enc) { switch (tok) { case XML_TOK_PROLOG_S: return XML_ROLE_NONE; case XML_TOK_POUND_NAME: if (XmlNameMatchesAscii(enc, ptr + MIN_BYTES_PER_CHAR(enc), end, KW_PCDATA)) { state->handler = element3; return XML_ROLE_CONTENT_PCDATA; } break; case XML_TOK_OPEN_PAREN: state->level = 2; state->handler = element6; return XML_ROLE_GROUP_OPEN; case XML_TOK_NAME: case XML_TOK_PREFIXED_NAME: state->handler = element7; return XML_ROLE_CONTENT_ELEMENT; case XML_TOK_NAME_QUESTION: state->handler = element7; return XML_ROLE_CONTENT_ELEMENT_OPT; case XML_TOK_NAME_ASTERISK: state->handler = element7; return XML_ROLE_CONTENT_ELEMENT_REP; case XML_TOK_NAME_PLUS: state->handler = element7; return XML_ROLE_CONTENT_ELEMENT_PLUS; } return common(state, tok); } static int element3(PROLOG_STATE *state, int tok, const char *ptr, const char *end, const ENCODING *enc) { switch (tok) { case XML_TOK_PROLOG_S: return XML_ROLE_NONE; case XML_TOK_CLOSE_PAREN: case XML_TOK_CLOSE_PAREN_ASTERISK: state->handler = declClose; return XML_ROLE_GROUP_CLOSE_REP; case XML_TOK_OR: state->handler = element4; return XML_ROLE_NONE; } return common(state, tok); } static int element4(PROLOG_STATE *state, int tok, const char *ptr, const char *end, const ENCODING *enc) { switch (tok) { case XML_TOK_PROLOG_S: return XML_ROLE_NONE; case XML_TOK_NAME: case XML_TOK_PREFIXED_NAME: state->handler = element5; return XML_ROLE_CONTENT_ELEMENT; } return common(state, tok); } static int element5(PROLOG_STATE *state, int tok, const char *ptr, const char *end, const ENCODING *enc) { switch (tok) { case XML_TOK_PROLOG_S: return XML_ROLE_NONE; case XML_TOK_CLOSE_PAREN_ASTERISK: state->handler = declClose; return XML_ROLE_GROUP_CLOSE_REP; case XML_TOK_OR: state->handler = element4; return XML_ROLE_NONE; } return common(state, tok); } static int element6(PROLOG_STATE *state, int tok, const char *ptr, const char *end, const ENCODING *enc) { switch (tok) { case XML_TOK_PROLOG_S: return XML_ROLE_NONE; case XML_TOK_OPEN_PAREN: state->level += 1; return XML_ROLE_GROUP_OPEN; case XML_TOK_NAME: case XML_TOK_PREFIXED_NAME: state->handler = element7; return XML_ROLE_CONTENT_ELEMENT; case XML_TOK_NAME_QUESTION: state->handler = element7; return XML_ROLE_CONTENT_ELEMENT_OPT; case XML_TOK_NAME_ASTERISK: state->handler = element7; return XML_ROLE_CONTENT_ELEMENT_REP; case XML_TOK_NAME_PLUS: state->handler = element7; return XML_ROLE_CONTENT_ELEMENT_PLUS; } return common(state, tok); } static int element7(PROLOG_STATE *state, int tok, const char *ptr, const char *end, const ENCODING *enc) { switch (tok) { case XML_TOK_PROLOG_S: return XML_ROLE_NONE; case XML_TOK_CLOSE_PAREN: state->level -= 1; if (state->level == 0) state->handler = declClose; return XML_ROLE_GROUP_CLOSE; case XML_TOK_CLOSE_PAREN_ASTERISK: state->level -= 1; if (state->level == 0) state->handler = declClose; return XML_ROLE_GROUP_CLOSE_REP; case XML_TOK_CLOSE_PAREN_QUESTION: state->level -= 1; if (state->level == 0) state->handler = declClose; return XML_ROLE_GROUP_CLOSE_OPT; case XML_TOK_CLOSE_PAREN_PLUS: state->level -= 1; if (state->level == 0) state->handler = declClose; return XML_ROLE_GROUP_CLOSE_PLUS; case XML_TOK_COMMA: state->handler = element6; return XML_ROLE_GROUP_SEQUENCE; case XML_TOK_OR: state->handler = element6; return XML_ROLE_GROUP_CHOICE; } return common(state, tok); } #ifdef XML_DTD static int condSect0(PROLOG_STATE *state, int tok, const char *ptr, const char *end, const ENCODING *enc) { switch (tok) { case XML_TOK_PROLOG_S: return XML_ROLE_NONE; case XML_TOK_NAME: if (XmlNameMatchesAscii(enc, ptr, end, KW_INCLUDE)) { state->handler = condSect1; return XML_ROLE_NONE; } if (XmlNameMatchesAscii(enc, ptr, end, KW_IGNORE)) { state->handler = condSect2; return XML_ROLE_NONE; } break; } return common(state, tok); } static int condSect1(PROLOG_STATE *state, int tok, const char *ptr, const char *end, const ENCODING *enc) { switch (tok) { case XML_TOK_PROLOG_S: return XML_ROLE_NONE; case XML_TOK_OPEN_BRACKET: state->handler = externalSubset1; state->includeLevel += 1; return XML_ROLE_NONE; } return common(state, tok); } static int condSect2(PROLOG_STATE *state, int tok, const char *ptr, const char *end, const ENCODING *enc) { switch (tok) { case XML_TOK_PROLOG_S: return XML_ROLE_NONE; case XML_TOK_OPEN_BRACKET: state->handler = externalSubset1; return XML_ROLE_IGNORE_SECT; } return common(state, tok); } #endif /* XML_DTD */ static int declClose(PROLOG_STATE *state, int tok, const char *ptr, const char *end, const ENCODING *enc) { switch (tok) { case XML_TOK_PROLOG_S: return XML_ROLE_NONE; case XML_TOK_DECL_CLOSE: setTopLevel(state); return XML_ROLE_NONE; } return common(state, tok); } #if 0 static int ignore(PROLOG_STATE *state, int tok, const char *ptr, const char *end, const ENCODING *enc) { switch (tok) { case XML_TOK_DECL_CLOSE: state->handler = internalSubset; return 0; default: return XML_ROLE_NONE; } return common(state, tok); } #endif static int error(PROLOG_STATE *state, int tok, const char *ptr, const char *end, const ENCODING *enc) { return XML_ROLE_NONE; } static int common(PROLOG_STATE *state, int tok) { #ifdef XML_DTD if (!state->documentEntity && tok == XML_TOK_PARAM_ENTITY_REF) return XML_ROLE_INNER_PARAM_ENTITY_REF; #endif state->handler = error; return XML_ROLE_ERROR; } void XmlPrologStateInit(PROLOG_STATE *state) { state->handler = prolog0; #ifdef XML_DTD state->documentEntity = 1; state->includeLevel = 0; #endif /* XML_DTD */ } #ifdef XML_DTD void XmlPrologStateInitExternalEntity(PROLOG_STATE *state) { state->handler = externalSubset0; state->documentEntity = 0; state->includeLevel = 0; } #endif /* XML_DTD */ visp-3.0.1/3rdparty/libatidaq-c/xmlrole.h000066400000000000000000000071101304511007300202420ustar00rootroot00000000000000/* Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd * * The MIT License * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR * OTHER DEALINGS IN THE SOFTWARE. */ #ifndef XmlRole_INCLUDED #define XmlRole_INCLUDED 1 #include "xmltok.h" #ifdef __cplusplus extern "C" { #endif enum { XML_ROLE_ERROR = -1, XML_ROLE_NONE = 0, XML_ROLE_XML_DECL, XML_ROLE_INSTANCE_START, XML_ROLE_DOCTYPE_NAME, XML_ROLE_DOCTYPE_SYSTEM_ID, XML_ROLE_DOCTYPE_PUBLIC_ID, XML_ROLE_DOCTYPE_CLOSE, XML_ROLE_GENERAL_ENTITY_NAME, XML_ROLE_PARAM_ENTITY_NAME, XML_ROLE_ENTITY_VALUE, XML_ROLE_ENTITY_SYSTEM_ID, XML_ROLE_ENTITY_PUBLIC_ID, XML_ROLE_ENTITY_NOTATION_NAME, XML_ROLE_NOTATION_NAME, XML_ROLE_NOTATION_SYSTEM_ID, XML_ROLE_NOTATION_NO_SYSTEM_ID, XML_ROLE_NOTATION_PUBLIC_ID, XML_ROLE_ATTRIBUTE_NAME, XML_ROLE_ATTRIBUTE_TYPE_CDATA, XML_ROLE_ATTRIBUTE_TYPE_ID, XML_ROLE_ATTRIBUTE_TYPE_IDREF, XML_ROLE_ATTRIBUTE_TYPE_IDREFS, XML_ROLE_ATTRIBUTE_TYPE_ENTITY, XML_ROLE_ATTRIBUTE_TYPE_ENTITIES, XML_ROLE_ATTRIBUTE_TYPE_NMTOKEN, XML_ROLE_ATTRIBUTE_TYPE_NMTOKENS, XML_ROLE_ATTRIBUTE_ENUM_VALUE, XML_ROLE_ATTRIBUTE_NOTATION_VALUE, XML_ROLE_ATTLIST_ELEMENT_NAME, XML_ROLE_IMPLIED_ATTRIBUTE_VALUE, XML_ROLE_REQUIRED_ATTRIBUTE_VALUE, XML_ROLE_DEFAULT_ATTRIBUTE_VALUE, XML_ROLE_FIXED_ATTRIBUTE_VALUE, XML_ROLE_ELEMENT_NAME, XML_ROLE_CONTENT_ANY, XML_ROLE_CONTENT_EMPTY, XML_ROLE_CONTENT_PCDATA, XML_ROLE_GROUP_OPEN, XML_ROLE_GROUP_CLOSE, XML_ROLE_GROUP_CLOSE_REP, XML_ROLE_GROUP_CLOSE_OPT, XML_ROLE_GROUP_CLOSE_PLUS, XML_ROLE_GROUP_CHOICE, XML_ROLE_GROUP_SEQUENCE, XML_ROLE_CONTENT_ELEMENT, XML_ROLE_CONTENT_ELEMENT_REP, XML_ROLE_CONTENT_ELEMENT_OPT, XML_ROLE_CONTENT_ELEMENT_PLUS, #ifdef XML_DTD XML_ROLE_TEXT_DECL, XML_ROLE_IGNORE_SECT, XML_ROLE_INNER_PARAM_ENTITY_REF, #endif /* XML_DTD */ XML_ROLE_PARAM_ENTITY_REF, XML_ROLE_EXTERNAL_GENERAL_ENTITY_NO_NOTATION }; typedef struct prolog_state { int (*handler)(struct prolog_state *state, int tok, const char *ptr, const char *end, const ENCODING *enc); unsigned level; #ifdef XML_DTD unsigned includeLevel; int documentEntity; #endif /* XML_DTD */ } PROLOG_STATE; void XMLTOKAPI XmlPrologStateInit(PROLOG_STATE *); #ifdef XML_DTD void XMLTOKAPI XmlPrologStateInitExternalEntity(PROLOG_STATE *); #endif /* XML_DTD */ #define XmlTokenRole(state, tok, ptr, end, enc) \ (((state)->handler)(state, tok, ptr, end, enc)) #ifdef __cplusplus } #endif #endif /* not XmlRole_INCLUDED */ visp-3.0.1/3rdparty/libatidaq-c/xmltok.c000066400000000000000000001170021304511007300200730ustar00rootroot00000000000000/* Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd * * The MIT License * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR * OTHER DEALINGS IN THE SOFTWARE. */ #include "xmldef.h" #include "xmltok.h" #include "nametab.h" #ifdef XML_DTD #define IGNORE_SECTION_TOK_VTABLE , PREFIX(ignoreSectionTok) #else #define IGNORE_SECTION_TOK_VTABLE /* as nothing */ #endif #define VTABLE1 \ { PREFIX(prologTok), PREFIX(contentTok), \ PREFIX(cdataSectionTok) IGNORE_SECTION_TOK_VTABLE }, \ { PREFIX(attributeValueTok), PREFIX(entityValueTok) }, \ PREFIX(sameName), \ PREFIX(nameMatchesAscii), \ PREFIX(nameLength), \ PREFIX(skipS), \ PREFIX(getAtts), \ PREFIX(charRefNumber), \ PREFIX(predefinedEntityName), \ PREFIX(updatePosition), \ PREFIX(isPublicId) #define VTABLE VTABLE1, PREFIX(toUtf8), PREFIX(toUtf16) #define UCS2_GET_NAMING(pages, hi, lo) \ (namingBitmap[(pages[hi] << 3) + ((lo) >> 5)] & (1 << ((lo) & 0x1F))) /* A 2 byte UTF-8 representation splits the characters 11 bits between the bottom 5 and 6 bits of the bytes. We need 8 bits to index into pages, 3 bits to add to that index and 5 bits to generate the mask. */ #define UTF8_GET_NAMING2(pages, byte) \ (namingBitmap[((pages)[(((byte)[0]) >> 2) & 7] << 3) \ + ((((byte)[0]) & 3) << 1) \ + ((((byte)[1]) >> 5) & 1)] \ & (1 << (((byte)[1]) & 0x1F))) /* A 3 byte UTF-8 representation splits the characters 16 bits between the bottom 4, 6 and 6 bits of the bytes. We need 8 bits to index into pages, 3 bits to add to that index and 5 bits to generate the mask. */ #define UTF8_GET_NAMING3(pages, byte) \ (namingBitmap[((pages)[((((byte)[0]) & 0xF) << 4) \ + ((((byte)[1]) >> 2) & 0xF)] \ << 3) \ + ((((byte)[1]) & 3) << 1) \ + ((((byte)[2]) >> 5) & 1)] \ & (1 << (((byte)[2]) & 0x1F))) #define UTF8_GET_NAMING(pages, p, n) \ ((n) == 2 \ ? UTF8_GET_NAMING2(pages, (const unsigned char *)(p)) \ : ((n) == 3 \ ? UTF8_GET_NAMING3(pages, (const unsigned char *)(p)) \ : 0)) #define UTF8_INVALID3(p) \ ((*p) == 0xED \ ? (((p)[1] & 0x20) != 0) \ : ((*p) == 0xEF \ ? ((p)[1] == 0xBF && ((p)[2] == 0xBF || (p)[2] == 0xBE)) \ : 0)) #define UTF8_INVALID4(p) ((*p) == 0xF4 && ((p)[1] & 0x30) != 0) static int isNever(const ENCODING *enc, const char *p) { return 0; } static int utf8_isName2(const ENCODING *enc, const char *p) { return UTF8_GET_NAMING2(namePages, (const unsigned char *)p); } static int utf8_isName3(const ENCODING *enc, const char *p) { return UTF8_GET_NAMING3(namePages, (const unsigned char *)p); } #define utf8_isName4 isNever static int utf8_isNmstrt2(const ENCODING *enc, const char *p) { return UTF8_GET_NAMING2(nmstrtPages, (const unsigned char *)p); } static int utf8_isNmstrt3(const ENCODING *enc, const char *p) { return UTF8_GET_NAMING3(nmstrtPages, (const unsigned char *)p); } #define utf8_isNmstrt4 isNever #define utf8_isInvalid2 isNever static int utf8_isInvalid3(const ENCODING *enc, const char *p) { return UTF8_INVALID3((const unsigned char *)p); } static int utf8_isInvalid4(const ENCODING *enc, const char *p) { return UTF8_INVALID4((const unsigned char *)p); } struct normal_encoding { ENCODING enc; unsigned char type[256]; #ifdef XML_MIN_SIZE int (*byteType)(const ENCODING *, const char *); int (*isNameMin)(const ENCODING *, const char *); int (*isNmstrtMin)(const ENCODING *, const char *); int (*byteToAscii)(const ENCODING *, const char *); int (*charMatches)(const ENCODING *, const char *, int); #endif /* XML_MIN_SIZE */ int (*isName2)(const ENCODING *, const char *); int (*isName3)(const ENCODING *, const char *); int (*isName4)(const ENCODING *, const char *); int (*isNmstrt2)(const ENCODING *, const char *); int (*isNmstrt3)(const ENCODING *, const char *); int (*isNmstrt4)(const ENCODING *, const char *); int (*isInvalid2)(const ENCODING *, const char *); int (*isInvalid3)(const ENCODING *, const char *); int (*isInvalid4)(const ENCODING *, const char *); }; #ifdef XML_MIN_SIZE #define STANDARD_VTABLE(E) \ E ## byteType, \ E ## isNameMin, \ E ## isNmstrtMin, \ E ## byteToAscii, \ E ## charMatches, #else #define STANDARD_VTABLE(E) /* as nothing */ #endif #define NORMAL_VTABLE(E) \ E ## isName2, \ E ## isName3, \ E ## isName4, \ E ## isNmstrt2, \ E ## isNmstrt3, \ E ## isNmstrt4, \ E ## isInvalid2, \ E ## isInvalid3, \ E ## isInvalid4 static int checkCharRefNumber(int); #include "xmltok_impl.h" #include "ascii.h" #ifdef XML_MIN_SIZE #define sb_isNameMin isNever #define sb_isNmstrtMin isNever #endif #ifdef XML_MIN_SIZE #define MINBPC(enc) ((enc)->minBytesPerChar) #else /* minimum bytes per character */ #define MINBPC(enc) 1 #endif #define SB_BYTE_TYPE(enc, p) \ (((struct normal_encoding *)(enc))->type[(unsigned char)*(p)]) #ifdef XML_MIN_SIZE static int sb_byteType(const ENCODING *enc, const char *p) { return SB_BYTE_TYPE(enc, p); } #define BYTE_TYPE(enc, p) \ (((const struct normal_encoding *)(enc))->byteType(enc, p)) #else #define BYTE_TYPE(enc, p) SB_BYTE_TYPE(enc, p) #endif #ifdef XML_MIN_SIZE #define BYTE_TO_ASCII(enc, p) \ (((const struct normal_encoding *)(enc))->byteToAscii(enc, p)) static int sb_byteToAscii(const ENCODING *enc, const char *p) { return *p; } #else #define BYTE_TO_ASCII(enc, p) (*(p)) #endif #define IS_NAME_CHAR(enc, p, n) \ (((const struct normal_encoding *)(enc))->isName ## n(enc, p)) #define IS_NMSTRT_CHAR(enc, p, n) \ (((const struct normal_encoding *)(enc))->isNmstrt ## n(enc, p)) #define IS_INVALID_CHAR(enc, p, n) \ (((const struct normal_encoding *)(enc))->isInvalid ## n(enc, p)) #ifdef XML_MIN_SIZE #define IS_NAME_CHAR_MINBPC(enc, p) \ (((const struct normal_encoding *)(enc))->isNameMin(enc, p)) #define IS_NMSTRT_CHAR_MINBPC(enc, p) \ (((const struct normal_encoding *)(enc))->isNmstrtMin(enc, p)) #else #define IS_NAME_CHAR_MINBPC(enc, p) (0) #define IS_NMSTRT_CHAR_MINBPC(enc, p) (0) #endif #ifdef XML_MIN_SIZE #define CHAR_MATCHES(enc, p, c) \ (((const struct normal_encoding *)(enc))->charMatches(enc, p, c)) static int sb_charMatches(const ENCODING *enc, const char *p, int c) { return *p == c; } #else /* c is an ASCII character */ #define CHAR_MATCHES(enc, p, c) (*(p) == c) #endif #define PREFIX(ident) normal_ ## ident #include "xmltok_impl.c" #undef MINBPC #undef BYTE_TYPE #undef BYTE_TO_ASCII #undef CHAR_MATCHES #undef IS_NAME_CHAR #undef IS_NAME_CHAR_MINBPC #undef IS_NMSTRT_CHAR #undef IS_NMSTRT_CHAR_MINBPC #undef IS_INVALID_CHAR enum { /* UTF8_cvalN is value of masked first byte of N byte sequence */ UTF8_cval1 = 0x00, UTF8_cval2 = 0xc0, UTF8_cval3 = 0xe0, UTF8_cval4 = 0xf0 }; static void utf8_toUtf8(const ENCODING *enc, const char **fromP, const char *fromLim, char **toP, const char *toLim) { char *to; const char *from; if (fromLim - *fromP > toLim - *toP) { /* Avoid copying partial characters. */ for (fromLim = *fromP + (toLim - *toP); fromLim > *fromP; fromLim--) if (((unsigned char)fromLim[-1] & 0xc0) != 0x80) break; } for (to = *toP, from = *fromP; from != fromLim; from++, to++) *to = *from; *fromP = from; *toP = to; } static void utf8_toUtf16(const ENCODING *enc, const char **fromP, const char *fromLim, unsigned short **toP, const unsigned short *toLim) { unsigned short *to = *toP; const char *from = *fromP; while (from != fromLim && to != toLim) { switch (((struct normal_encoding *)enc)->type[(unsigned char)*from]) { case BT_LEAD2: *to++ = ((from[0] & 0x1f) << 6) | (from[1] & 0x3f); from += 2; break; case BT_LEAD3: *to++ = ((from[0] & 0xf) << 12) | ((from[1] & 0x3f) << 6) | (from[2] & 0x3f); from += 3; break; case BT_LEAD4: { unsigned long n; if (to + 1 == toLim) break; n = ((from[0] & 0x7) << 18) | ((from[1] & 0x3f) << 12) | ((from[2] & 0x3f) << 6) | (from[3] & 0x3f); n -= 0x10000; to[0] = (unsigned short)((n >> 10) | 0xD800); to[1] = (unsigned short)((n & 0x3FF) | 0xDC00); to += 2; from += 4; } break; default: *to++ = *from++; break; } } *fromP = from; *toP = to; } #ifdef XML_NS static const struct normal_encoding utf8_encoding_ns = { { VTABLE1, utf8_toUtf8, utf8_toUtf16, 1, 1, 0 }, { #include "asciitab.h" #include "utf8tab.h" }, STANDARD_VTABLE(sb_) NORMAL_VTABLE(utf8_) }; #endif static const struct normal_encoding utf8_encoding = { { VTABLE1, utf8_toUtf8, utf8_toUtf16, 1, 1, 0 }, { #define BT_COLON BT_NMSTRT #include "asciitab.h" #undef BT_COLON #include "utf8tab.h" }, STANDARD_VTABLE(sb_) NORMAL_VTABLE(utf8_) }; #ifdef XML_NS static const struct normal_encoding internal_utf8_encoding_ns = { { VTABLE1, utf8_toUtf8, utf8_toUtf16, 1, 1, 0 }, { #include "iasciitab.h" #include "utf8tab.h" }, STANDARD_VTABLE(sb_) NORMAL_VTABLE(utf8_) }; #endif static const struct normal_encoding internal_utf8_encoding = { { VTABLE1, utf8_toUtf8, utf8_toUtf16, 1, 1, 0 }, { #define BT_COLON BT_NMSTRT #include "iasciitab.h" #undef BT_COLON #include "utf8tab.h" }, STANDARD_VTABLE(sb_) NORMAL_VTABLE(utf8_) }; static void latin1_toUtf8(const ENCODING *enc, const char **fromP, const char *fromLim, char **toP, const char *toLim) { for (;;) { unsigned char c; if (*fromP == fromLim) break; c = (unsigned char)**fromP; if (c & 0x80) { if (toLim - *toP < 2) break; *(*toP)++ = ((c >> 6) | UTF8_cval2); *(*toP)++ = ((c & 0x3f) | 0x80); (*fromP)++; } else { if (*toP == toLim) break; *(*toP)++ = *(*fromP)++; } } } static void latin1_toUtf16(const ENCODING *enc, const char **fromP, const char *fromLim, unsigned short **toP, const unsigned short *toLim) { while (*fromP != fromLim && *toP != toLim) *(*toP)++ = (unsigned char)*(*fromP)++; } #ifdef XML_NS static const struct normal_encoding latin1_encoding_ns = { { VTABLE1, latin1_toUtf8, latin1_toUtf16, 1, 0, 0 }, { #include "asciitab.h" #include "latin1tab.h" }, STANDARD_VTABLE(sb_) }; #endif static const struct normal_encoding latin1_encoding = { { VTABLE1, latin1_toUtf8, latin1_toUtf16, 1, 0, 0 }, { #define BT_COLON BT_NMSTRT #include "asciitab.h" #undef BT_COLON #include "latin1tab.h" }, STANDARD_VTABLE(sb_) }; static void ascii_toUtf8(const ENCODING *enc, const char **fromP, const char *fromLim, char **toP, const char *toLim) { while (*fromP != fromLim && *toP != toLim) *(*toP)++ = *(*fromP)++; } #ifdef XML_NS static const struct normal_encoding ascii_encoding_ns = { { VTABLE1, ascii_toUtf8, latin1_toUtf16, 1, 1, 0 }, { #include "asciitab.h" /* BT_NONXML == 0 */ }, STANDARD_VTABLE(sb_) }; #endif static const struct normal_encoding ascii_encoding = { { VTABLE1, ascii_toUtf8, latin1_toUtf16, 1, 1, 0 }, { #define BT_COLON BT_NMSTRT #include "asciitab.h" #undef BT_COLON /* BT_NONXML == 0 */ }, STANDARD_VTABLE(sb_) }; static int unicode_byte_type(char hi, char lo) { switch ((unsigned char)hi) { case 0xD8: case 0xD9: case 0xDA: case 0xDB: return BT_LEAD4; case 0xDC: case 0xDD: case 0xDE: case 0xDF: return BT_TRAIL; case 0xFF: switch ((unsigned char)lo) { case 0xFF: case 0xFE: return BT_NONXML; } break; } return BT_NONASCII; } #define DEFINE_UTF16_TO_UTF8(E) \ static \ void E ## toUtf8(const ENCODING *enc, \ const char **fromP, const char *fromLim, \ char **toP, const char *toLim) \ { \ const char *from; \ for (from = *fromP; from != fromLim; from += 2) { \ int plane; \ unsigned char lo2; \ unsigned char lo = GET_LO(from); \ unsigned char hi = GET_HI(from); \ switch (hi) { \ case 0: \ if (lo < 0x80) { \ if (*toP == toLim) { \ *fromP = from; \ return; \ } \ *(*toP)++ = lo; \ break; \ } \ /* fall through */ \ case 0x1: case 0x2: case 0x3: \ case 0x4: case 0x5: case 0x6: case 0x7: \ if (toLim - *toP < 2) { \ *fromP = from; \ return; \ } \ *(*toP)++ = ((lo >> 6) | (hi << 2) | UTF8_cval2); \ *(*toP)++ = ((lo & 0x3f) | 0x80); \ break; \ default: \ if (toLim - *toP < 3) { \ *fromP = from; \ return; \ } \ /* 16 bits divided 4, 6, 6 amongst 3 bytes */ \ *(*toP)++ = ((hi >> 4) | UTF8_cval3); \ *(*toP)++ = (((hi & 0xf) << 2) | (lo >> 6) | 0x80); \ *(*toP)++ = ((lo & 0x3f) | 0x80); \ break; \ case 0xD8: case 0xD9: case 0xDA: case 0xDB: \ if (toLim - *toP < 4) { \ *fromP = from; \ return; \ } \ plane = (((hi & 0x3) << 2) | ((lo >> 6) & 0x3)) + 1; \ *(*toP)++ = ((plane >> 2) | UTF8_cval4); \ *(*toP)++ = (((lo >> 2) & 0xF) | ((plane & 0x3) << 4) | 0x80); \ from += 2; \ lo2 = GET_LO(from); \ *(*toP)++ = (((lo & 0x3) << 4) \ | ((GET_HI(from) & 0x3) << 2) \ | (lo2 >> 6) \ | 0x80); \ *(*toP)++ = ((lo2 & 0x3f) | 0x80); \ break; \ } \ } \ *fromP = from; \ } #define DEFINE_UTF16_TO_UTF16(E) \ static \ void E ## toUtf16(const ENCODING *enc, \ const char **fromP, const char *fromLim, \ unsigned short **toP, const unsigned short *toLim) \ { \ /* Avoid copying first half only of surrogate */ \ if (fromLim - *fromP > ((toLim - *toP) << 1) \ && (GET_HI(fromLim - 2) & 0xF8) == 0xD8) \ fromLim -= 2; \ for (; *fromP != fromLim && *toP != toLim; *fromP += 2) \ *(*toP)++ = (GET_HI(*fromP) << 8) | GET_LO(*fromP); \ } #define SET2(ptr, ch) \ (((ptr)[0] = ((ch) & 0xff)), ((ptr)[1] = ((ch) >> 8))) #define GET_LO(ptr) ((unsigned char)(ptr)[0]) #define GET_HI(ptr) ((unsigned char)(ptr)[1]) DEFINE_UTF16_TO_UTF8(little2_) DEFINE_UTF16_TO_UTF16(little2_) #undef SET2 #undef GET_LO #undef GET_HI #define SET2(ptr, ch) \ (((ptr)[0] = ((ch) >> 8)), ((ptr)[1] = ((ch) & 0xFF))) #define GET_LO(ptr) ((unsigned char)(ptr)[1]) #define GET_HI(ptr) ((unsigned char)(ptr)[0]) DEFINE_UTF16_TO_UTF8(big2_) DEFINE_UTF16_TO_UTF16(big2_) #undef SET2 #undef GET_LO #undef GET_HI #define LITTLE2_BYTE_TYPE(enc, p) \ ((p)[1] == 0 \ ? ((struct normal_encoding *)(enc))->type[(unsigned char)*(p)] \ : unicode_byte_type((p)[1], (p)[0])) #define LITTLE2_BYTE_TO_ASCII(enc, p) ((p)[1] == 0 ? (p)[0] : -1) #define LITTLE2_CHAR_MATCHES(enc, p, c) ((p)[1] == 0 && (p)[0] == c) #define LITTLE2_IS_NAME_CHAR_MINBPC(enc, p) \ UCS2_GET_NAMING(namePages, (unsigned char)p[1], (unsigned char)p[0]) #define LITTLE2_IS_NMSTRT_CHAR_MINBPC(enc, p) \ UCS2_GET_NAMING(nmstrtPages, (unsigned char)p[1], (unsigned char)p[0]) #ifdef XML_MIN_SIZE static int little2_byteType(const ENCODING *enc, const char *p) { return LITTLE2_BYTE_TYPE(enc, p); } static int little2_byteToAscii(const ENCODING *enc, const char *p) { return LITTLE2_BYTE_TO_ASCII(enc, p); } static int little2_charMatches(const ENCODING *enc, const char *p, int c) { return LITTLE2_CHAR_MATCHES(enc, p, c); } static int little2_isNameMin(const ENCODING *enc, const char *p) { return LITTLE2_IS_NAME_CHAR_MINBPC(enc, p); } static int little2_isNmstrtMin(const ENCODING *enc, const char *p) { return LITTLE2_IS_NMSTRT_CHAR_MINBPC(enc, p); } #undef VTABLE #define VTABLE VTABLE1, little2_toUtf8, little2_toUtf16 #else /* not XML_MIN_SIZE */ #undef PREFIX #define PREFIX(ident) little2_ ## ident #define MINBPC(enc) 2 /* CHAR_MATCHES is guaranteed to have MINBPC bytes available. */ #define BYTE_TYPE(enc, p) LITTLE2_BYTE_TYPE(enc, p) #define BYTE_TO_ASCII(enc, p) LITTLE2_BYTE_TO_ASCII(enc, p) #define CHAR_MATCHES(enc, p, c) LITTLE2_CHAR_MATCHES(enc, p, c) #define IS_NAME_CHAR(enc, p, n) 0 #define IS_NAME_CHAR_MINBPC(enc, p) LITTLE2_IS_NAME_CHAR_MINBPC(enc, p) #define IS_NMSTRT_CHAR(enc, p, n) (0) #define IS_NMSTRT_CHAR_MINBPC(enc, p) LITTLE2_IS_NMSTRT_CHAR_MINBPC(enc, p) #include "xmltok_impl.c" #undef MINBPC #undef BYTE_TYPE #undef BYTE_TO_ASCII #undef CHAR_MATCHES #undef IS_NAME_CHAR #undef IS_NAME_CHAR_MINBPC #undef IS_NMSTRT_CHAR #undef IS_NMSTRT_CHAR_MINBPC #undef IS_INVALID_CHAR #endif /* not XML_MIN_SIZE */ #ifdef XML_NS static const struct normal_encoding little2_encoding_ns = { { VTABLE, 2, 0, #if XML_BYTE_ORDER == 12 1 #else 0 #endif }, { #include "asciitab.h" #include "latin1tab.h" }, STANDARD_VTABLE(little2_) }; #endif static const struct normal_encoding little2_encoding = { { VTABLE, 2, 0, #if XML_BYTE_ORDER == 12 1 #else 0 #endif }, { #define BT_COLON BT_NMSTRT #include "asciitab.h" #undef BT_COLON #include "latin1tab.h" }, STANDARD_VTABLE(little2_) }; #if XML_BYTE_ORDER != 21 #ifdef XML_NS static const struct normal_encoding internal_little2_encoding_ns = { { VTABLE, 2, 0, 1 }, { #include "iasciitab.h" #include "latin1tab.h" }, STANDARD_VTABLE(little2_) }; #endif static const struct normal_encoding internal_little2_encoding = { { VTABLE, 2, 0, 1 }, { #define BT_COLON BT_NMSTRT #include "iasciitab.h" #undef BT_COLON #include "latin1tab.h" }, STANDARD_VTABLE(little2_) }; #endif #define BIG2_BYTE_TYPE(enc, p) \ ((p)[0] == 0 \ ? ((struct normal_encoding *)(enc))->type[(unsigned char)(p)[1]] \ : unicode_byte_type((p)[0], (p)[1])) #define BIG2_BYTE_TO_ASCII(enc, p) ((p)[0] == 0 ? (p)[1] : -1) #define BIG2_CHAR_MATCHES(enc, p, c) ((p)[0] == 0 && (p)[1] == c) #define BIG2_IS_NAME_CHAR_MINBPC(enc, p) \ UCS2_GET_NAMING(namePages, (unsigned char)p[0], (unsigned char)p[1]) #define BIG2_IS_NMSTRT_CHAR_MINBPC(enc, p) \ UCS2_GET_NAMING(nmstrtPages, (unsigned char)p[0], (unsigned char)p[1]) #ifdef XML_MIN_SIZE static int big2_byteType(const ENCODING *enc, const char *p) { return BIG2_BYTE_TYPE(enc, p); } static int big2_byteToAscii(const ENCODING *enc, const char *p) { return BIG2_BYTE_TO_ASCII(enc, p); } static int big2_charMatches(const ENCODING *enc, const char *p, int c) { return BIG2_CHAR_MATCHES(enc, p, c); } static int big2_isNameMin(const ENCODING *enc, const char *p) { return BIG2_IS_NAME_CHAR_MINBPC(enc, p); } static int big2_isNmstrtMin(const ENCODING *enc, const char *p) { return BIG2_IS_NMSTRT_CHAR_MINBPC(enc, p); } #undef VTABLE #define VTABLE VTABLE1, big2_toUtf8, big2_toUtf16 #else /* not XML_MIN_SIZE */ #undef PREFIX #define PREFIX(ident) big2_ ## ident #define MINBPC(enc) 2 /* CHAR_MATCHES is guaranteed to have MINBPC bytes available. */ #define BYTE_TYPE(enc, p) BIG2_BYTE_TYPE(enc, p) #define BYTE_TO_ASCII(enc, p) BIG2_BYTE_TO_ASCII(enc, p) #define CHAR_MATCHES(enc, p, c) BIG2_CHAR_MATCHES(enc, p, c) #define IS_NAME_CHAR(enc, p, n) 0 #define IS_NAME_CHAR_MINBPC(enc, p) BIG2_IS_NAME_CHAR_MINBPC(enc, p) #define IS_NMSTRT_CHAR(enc, p, n) (0) #define IS_NMSTRT_CHAR_MINBPC(enc, p) BIG2_IS_NMSTRT_CHAR_MINBPC(enc, p) #include "xmltok_impl.c" #undef MINBPC #undef BYTE_TYPE #undef BYTE_TO_ASCII #undef CHAR_MATCHES #undef IS_NAME_CHAR #undef IS_NAME_CHAR_MINBPC #undef IS_NMSTRT_CHAR #undef IS_NMSTRT_CHAR_MINBPC #undef IS_INVALID_CHAR #endif /* not XML_MIN_SIZE */ #ifdef XML_NS static const struct normal_encoding big2_encoding_ns = { { VTABLE, 2, 0, #if XML_BYTE_ORDER == 21 1 #else 0 #endif }, { #include "asciitab.h" #include "latin1tab.h" }, STANDARD_VTABLE(big2_) }; #endif static const struct normal_encoding big2_encoding = { { VTABLE, 2, 0, #if XML_BYTE_ORDER == 21 1 #else 0 #endif }, { #define BT_COLON BT_NMSTRT #include "asciitab.h" #undef BT_COLON #include "latin1tab.h" }, STANDARD_VTABLE(big2_) }; #if XML_BYTE_ORDER != 12 #ifdef XML_NS static const struct normal_encoding internal_big2_encoding_ns = { { VTABLE, 2, 0, 1 }, { #include "iasciitab.h" #include "latin1tab.h" }, STANDARD_VTABLE(big2_) }; #endif static const struct normal_encoding internal_big2_encoding = { { VTABLE, 2, 0, 1 }, { #define BT_COLON BT_NMSTRT #include "iasciitab.h" #undef BT_COLON #include "latin1tab.h" }, STANDARD_VTABLE(big2_) }; #endif #undef PREFIX static int streqci(const char *s1, const char *s2) { for (;;) { char c1 = *s1++; char c2 = *s2++; if (ASCII_a <= c1 && c1 <= ASCII_z) c1 += ASCII_A - ASCII_a; if (ASCII_a <= c2 && c2 <= ASCII_z) c2 += ASCII_A - ASCII_a; if (c1 != c2) return 0; if (!c1) break; } return 1; } static void initUpdatePosition(const ENCODING *enc, const char *ptr, const char *end, POSITION *pos) { normal_updatePosition(&utf8_encoding.enc, ptr, end, pos); } static int toAscii(const ENCODING *enc, const char *ptr, const char *end) { char buf[1]; char *p = buf; XmlUtf8Convert(enc, &ptr, end, &p, p + 1); if (p == buf) return -1; else return buf[0]; } static int isSpace(int c) { switch (c) { case 0x20: case 0xD: case 0xA: case 0x9: return 1; } return 0; } /* Return 1 if there's just optional white space or there's an S followed by name=val. */ static int parsePseudoAttribute(const ENCODING *enc, const char *ptr, const char *end, const char **namePtr, const char **nameEndPtr, const char **valPtr, const char **nextTokPtr) { int c; char open; if (ptr == end) { *namePtr = 0; return 1; } if (!isSpace(toAscii(enc, ptr, end))) { *nextTokPtr = ptr; return 0; } do { ptr += enc->minBytesPerChar; } while (isSpace(toAscii(enc, ptr, end))); if (ptr == end) { *namePtr = 0; return 1; } *namePtr = ptr; for (;;) { c = toAscii(enc, ptr, end); if (c == -1) { *nextTokPtr = ptr; return 0; } if (c == ASCII_EQUALS) { *nameEndPtr = ptr; break; } if (isSpace(c)) { *nameEndPtr = ptr; do { ptr += enc->minBytesPerChar; } while (isSpace(c = toAscii(enc, ptr, end))); if (c != ASCII_EQUALS) { *nextTokPtr = ptr; return 0; } break; } ptr += enc->minBytesPerChar; } if (ptr == *namePtr) { *nextTokPtr = ptr; return 0; } ptr += enc->minBytesPerChar; c = toAscii(enc, ptr, end); while (isSpace(c)) { ptr += enc->minBytesPerChar; c = toAscii(enc, ptr, end); } if (c != ASCII_QUOT && c != ASCII_APOS) { *nextTokPtr = ptr; return 0; } open = c; ptr += enc->minBytesPerChar; *valPtr = ptr; for (;; ptr += enc->minBytesPerChar) { c = toAscii(enc, ptr, end); if (c == open) break; if (!(ASCII_a <= c && c <= ASCII_z) && !(ASCII_A <= c && c <= ASCII_Z) && !(ASCII_0 <= c && c <= ASCII_9) && c != ASCII_PERIOD && c != ASCII_MINUS && c != ASCII_UNDERSCORE) { *nextTokPtr = ptr; return 0; } } *nextTokPtr = ptr + enc->minBytesPerChar; return 1; } static const char KW_version[] = { ASCII_v, ASCII_e, ASCII_r, ASCII_s, ASCII_i, ASCII_o, ASCII_n, '\0' }; static const char KW_encoding[] = { ASCII_e, ASCII_n, ASCII_c, ASCII_o, ASCII_d, ASCII_i, ASCII_n, ASCII_g, '\0' }; static const char KW_standalone[] = { ASCII_s, ASCII_t, ASCII_a, ASCII_n, ASCII_d, ASCII_a, ASCII_l, ASCII_o, ASCII_n, ASCII_e, '\0' }; static const char KW_yes[] = { ASCII_y, ASCII_e, ASCII_s, '\0' }; static const char KW_no[] = { ASCII_n, ASCII_o, '\0' }; static int doParseXmlDecl(const ENCODING *(*encodingFinder)(const ENCODING *, const char *, const char *), int isGeneralTextEntity, const ENCODING *enc, const char *ptr, const char *end, const char **badPtr, const char **versionPtr, const char **encodingName, const ENCODING **encoding, int *standalone) { const char *val = 0; const char *name = 0; const char *nameEnd = 0; ptr += 5 * enc->minBytesPerChar; end -= 2 * enc->minBytesPerChar; if (!parsePseudoAttribute(enc, ptr, end, &name, &nameEnd, &val, &ptr) || !name) { *badPtr = ptr; return 0; } if (!XmlNameMatchesAscii(enc, name, nameEnd, KW_version)) { if (!isGeneralTextEntity) { *badPtr = name; return 0; } } else { if (versionPtr) *versionPtr = val; if (!parsePseudoAttribute(enc, ptr, end, &name, &nameEnd, &val, &ptr)) { *badPtr = ptr; return 0; } if (!name) { if (isGeneralTextEntity) { /* a TextDecl must have an EncodingDecl */ *badPtr = ptr; return 0; } return 1; } } if (XmlNameMatchesAscii(enc, name, nameEnd, KW_encoding)) { int c = toAscii(enc, val, end); if (!(ASCII_a <= c && c <= ASCII_z) && !(ASCII_A <= c && c <= ASCII_Z)) { *badPtr = val; return 0; } if (encodingName) *encodingName = val; if (encoding) *encoding = encodingFinder(enc, val, ptr - enc->minBytesPerChar); if (!parsePseudoAttribute(enc, ptr, end, &name, &nameEnd, &val, &ptr)) { *badPtr = ptr; return 0; } if (!name) return 1; } if (!XmlNameMatchesAscii(enc, name, nameEnd, KW_standalone) || isGeneralTextEntity) { *badPtr = name; return 0; } if (XmlNameMatchesAscii(enc, val, ptr - enc->minBytesPerChar, KW_yes)) { if (standalone) *standalone = 1; } else if (XmlNameMatchesAscii(enc, val, ptr - enc->minBytesPerChar, KW_no)) { if (standalone) *standalone = 0; } else { *badPtr = val; return 0; } while (isSpace(toAscii(enc, ptr, end))) ptr += enc->minBytesPerChar; if (ptr != end) { *badPtr = ptr; return 0; } return 1; } static int checkCharRefNumber(int result) { switch (result >> 8) { case 0xD8: case 0xD9: case 0xDA: case 0xDB: case 0xDC: case 0xDD: case 0xDE: case 0xDF: return -1; case 0: if (latin1_encoding.type[result] == BT_NONXML) return -1; break; case 0xFF: if (result == 0xFFFE || result == 0xFFFF) return -1; break; } return result; } int XmlUtf8Encode(int c, char *buf) { enum { /* minN is minimum legal resulting value for N byte sequence */ min2 = 0x80, min3 = 0x800, min4 = 0x10000 }; if (c < 0) return 0; if (c < min2) { buf[0] = (c | UTF8_cval1); return 1; } if (c < min3) { buf[0] = ((c >> 6) | UTF8_cval2); buf[1] = ((c & 0x3f) | 0x80); return 2; } if (c < min4) { buf[0] = ((c >> 12) | UTF8_cval3); buf[1] = (((c >> 6) & 0x3f) | 0x80); buf[2] = ((c & 0x3f) | 0x80); return 3; } if (c < 0x110000) { buf[0] = ((c >> 18) | UTF8_cval4); buf[1] = (((c >> 12) & 0x3f) | 0x80); buf[2] = (((c >> 6) & 0x3f) | 0x80); buf[3] = ((c & 0x3f) | 0x80); return 4; } return 0; } int XmlUtf16Encode(int charNum, unsigned short *buf) { if (charNum < 0) return 0; if (charNum < 0x10000) { buf[0] = charNum; return 1; } if (charNum < 0x110000) { charNum -= 0x10000; buf[0] = (charNum >> 10) + 0xD800; buf[1] = (charNum & 0x3FF) + 0xDC00; return 2; } return 0; } struct unknown_encoding { struct normal_encoding normal; int (*convert)(void *userData, const char *p); void *userData; unsigned short utf16[256]; char utf8[256][4]; }; int XmlSizeOfUnknownEncoding(void) { return sizeof(struct unknown_encoding); } static int unknown_isName(const ENCODING *enc, const char *p) { int c = ((const struct unknown_encoding *)enc) ->convert(((const struct unknown_encoding *)enc)->userData, p); if (c & ~0xFFFF) return 0; return UCS2_GET_NAMING(namePages, c >> 8, c & 0xFF); } static int unknown_isNmstrt(const ENCODING *enc, const char *p) { int c = ((const struct unknown_encoding *)enc) ->convert(((const struct unknown_encoding *)enc)->userData, p); if (c & ~0xFFFF) return 0; return UCS2_GET_NAMING(nmstrtPages, c >> 8, c & 0xFF); } static int unknown_isInvalid(const ENCODING *enc, const char *p) { int c = ((const struct unknown_encoding *)enc) ->convert(((const struct unknown_encoding *)enc)->userData, p); return (c & ~0xFFFF) || checkCharRefNumber(c) < 0; } static void unknown_toUtf8(const ENCODING *enc, const char **fromP, const char *fromLim, char **toP, const char *toLim) { char buf[XML_UTF8_ENCODE_MAX]; for (;;) { const char *utf8; int n; if (*fromP == fromLim) break; utf8 = ((const struct unknown_encoding *)enc)->utf8[(unsigned char)**fromP]; n = *utf8++; if (n == 0) { int c = ((const struct unknown_encoding *)enc) ->convert(((const struct unknown_encoding *)enc)->userData, *fromP); n = XmlUtf8Encode(c, buf); if (n > toLim - *toP) break; utf8 = buf; *fromP += ((const struct normal_encoding *)enc)->type[(unsigned char)**fromP] - (BT_LEAD2 - 2); } else { if (n > toLim - *toP) break; (*fromP)++; } do { *(*toP)++ = *utf8++; } while (--n != 0); } } static void unknown_toUtf16(const ENCODING *enc, const char **fromP, const char *fromLim, unsigned short **toP, const unsigned short *toLim) { while (*fromP != fromLim && *toP != toLim) { unsigned short c = ((const struct unknown_encoding *)enc)->utf16[(unsigned char)**fromP]; if (c == 0) { c = (unsigned short)((const struct unknown_encoding *)enc) ->convert(((const struct unknown_encoding *)enc)->userData, *fromP); *fromP += ((const struct normal_encoding *)enc)->type[(unsigned char)**fromP] - (BT_LEAD2 - 2); } else (*fromP)++; *(*toP)++ = c; } } ENCODING * XmlInitUnknownEncoding(void *mem, int *table, int (*convert)(void *userData, const char *p), void *userData) { int i; struct unknown_encoding *e = mem; for (i = 0; i < (int)sizeof(struct normal_encoding); i++) ((char *)mem)[i] = ((char *)&latin1_encoding)[i]; for (i = 0; i < 128; i++) if (latin1_encoding.type[i] != BT_OTHER && latin1_encoding.type[i] != BT_NONXML && table[i] != i) return 0; for (i = 0; i < 256; i++) { int c = table[i]; if (c == -1) { e->normal.type[i] = BT_MALFORM; /* This shouldn't really get used. */ e->utf16[i] = 0xFFFF; e->utf8[i][0] = 1; e->utf8[i][1] = 0; } else if (c < 0) { if (c < -4) return 0; e->normal.type[i] = BT_LEAD2 - (c + 2); e->utf8[i][0] = 0; e->utf16[i] = 0; } else if (c < 0x80) { if (latin1_encoding.type[c] != BT_OTHER && latin1_encoding.type[c] != BT_NONXML && c != i) return 0; e->normal.type[i] = latin1_encoding.type[c]; e->utf8[i][0] = 1; e->utf8[i][1] = (char)c; e->utf16[i] = c == 0 ? 0xFFFF : c; } else if (checkCharRefNumber(c) < 0) { e->normal.type[i] = BT_NONXML; /* This shouldn't really get used. */ e->utf16[i] = 0xFFFF; e->utf8[i][0] = 1; e->utf8[i][1] = 0; } else { if (c > 0xFFFF) return 0; if (UCS2_GET_NAMING(nmstrtPages, c >> 8, c & 0xff)) e->normal.type[i] = BT_NMSTRT; else if (UCS2_GET_NAMING(namePages, c >> 8, c & 0xff)) e->normal.type[i] = BT_NAME; else e->normal.type[i] = BT_OTHER; e->utf8[i][0] = (char)XmlUtf8Encode(c, e->utf8[i] + 1); e->utf16[i] = c; } } e->userData = userData; e->convert = convert; if (convert) { e->normal.isName2 = unknown_isName; e->normal.isName3 = unknown_isName; e->normal.isName4 = unknown_isName; e->normal.isNmstrt2 = unknown_isNmstrt; e->normal.isNmstrt3 = unknown_isNmstrt; e->normal.isNmstrt4 = unknown_isNmstrt; e->normal.isInvalid2 = unknown_isInvalid; e->normal.isInvalid3 = unknown_isInvalid; e->normal.isInvalid4 = unknown_isInvalid; } e->normal.enc.utf8Convert = unknown_toUtf8; e->normal.enc.utf16Convert = unknown_toUtf16; return &(e->normal.enc); } /* If this enumeration is changed, getEncodingIndex and encodings must also be changed. */ enum { UNKNOWN_ENC = -1, ISO_8859_1_ENC = 0, US_ASCII_ENC, UTF_8_ENC, UTF_16_ENC, UTF_16BE_ENC, UTF_16LE_ENC, /* must match encodingNames up to here */ NO_ENC }; static const char KW_ISO_8859_1[] = { ASCII_I, ASCII_S, ASCII_O, ASCII_MINUS, ASCII_8, ASCII_8, ASCII_5, ASCII_9, ASCII_MINUS, ASCII_1, '\0' }; static const char KW_US_ASCII[] = { ASCII_U, ASCII_S, ASCII_MINUS, ASCII_A, ASCII_S, ASCII_C, ASCII_I, ASCII_I, '\0' }; static const char KW_UTF_8[] = { ASCII_U, ASCII_T, ASCII_F, ASCII_MINUS, ASCII_8, '\0' }; static const char KW_UTF_16[] = { ASCII_U, ASCII_T, ASCII_F, ASCII_MINUS, ASCII_1, ASCII_6, '\0' }; static const char KW_UTF_16BE[] = { ASCII_U, ASCII_T, ASCII_F, ASCII_MINUS, ASCII_1, ASCII_6, ASCII_B, ASCII_E, '\0' }; static const char KW_UTF_16LE[] = { ASCII_U, ASCII_T, ASCII_F, ASCII_MINUS, ASCII_1, ASCII_6, ASCII_L, ASCII_E, '\0' }; static int getEncodingIndex(const char *name) { static const char *encodingNames[] = { KW_ISO_8859_1, KW_US_ASCII, KW_UTF_8, KW_UTF_16, KW_UTF_16BE, KW_UTF_16LE, }; int i; if (name == 0) return NO_ENC; for (i = 0; i < (int)(sizeof(encodingNames)/sizeof(encodingNames[0])); i++) if (streqci(name, encodingNames[i])) return i; return UNKNOWN_ENC; } /* For binary compatibility, we store the index of the encoding specified at initialization in the isUtf16 member. */ #define INIT_ENC_INDEX(enc) ((int)(enc)->initEnc.isUtf16) #define SET_INIT_ENC_INDEX(enc, i) ((enc)->initEnc.isUtf16 = (char)i) /* This is what detects the encoding. encodingTable maps from encoding indices to encodings; INIT_ENC_INDEX(enc) is the index of the external (protocol) specified encoding; state is XML_CONTENT_STATE if we're parsing an external text entity, and XML_PROLOG_STATE otherwise. */ static int initScan(const ENCODING **encodingTable, const INIT_ENCODING *enc, int state, const char *ptr, const char *end, const char **nextTokPtr) { const ENCODING **encPtr; if (ptr == end) return XML_TOK_NONE; encPtr = enc->encPtr; if (ptr + 1 == end) { /* only a single byte available for auto-detection */ #ifndef XML_DTD /* FIXME */ /* a well-formed document entity must have more than one byte */ if (state != XML_CONTENT_STATE) return XML_TOK_PARTIAL; #endif /* so we're parsing an external text entity... */ /* if UTF-16 was externally specified, then we need at least 2 bytes */ switch (INIT_ENC_INDEX(enc)) { case UTF_16_ENC: case UTF_16LE_ENC: case UTF_16BE_ENC: return XML_TOK_PARTIAL; } switch ((unsigned char)*ptr) { case 0xFE: case 0xFF: case 0xEF: /* possibly first byte of UTF-8 BOM */ if (INIT_ENC_INDEX(enc) == ISO_8859_1_ENC && state == XML_CONTENT_STATE) break; /* fall through */ case 0x00: case 0x3C: return XML_TOK_PARTIAL; } } else { switch (((unsigned char)ptr[0] << 8) | (unsigned char)ptr[1]) { case 0xFEFF: if (INIT_ENC_INDEX(enc) == ISO_8859_1_ENC && state == XML_CONTENT_STATE) break; *nextTokPtr = ptr + 2; *encPtr = encodingTable[UTF_16BE_ENC]; return XML_TOK_BOM; /* 00 3C is handled in the default case */ case 0x3C00: if ((INIT_ENC_INDEX(enc) == UTF_16BE_ENC || INIT_ENC_INDEX(enc) == UTF_16_ENC) && state == XML_CONTENT_STATE) break; *encPtr = encodingTable[UTF_16LE_ENC]; return XmlTok(*encPtr, state, ptr, end, nextTokPtr); case 0xFFFE: if (INIT_ENC_INDEX(enc) == ISO_8859_1_ENC && state == XML_CONTENT_STATE) break; *nextTokPtr = ptr + 2; *encPtr = encodingTable[UTF_16LE_ENC]; return XML_TOK_BOM; case 0xEFBB: /* Maybe a UTF-8 BOM (EF BB BF) */ /* If there's an explicitly specified (external) encoding of ISO-8859-1 or some flavour of UTF-16 and this is an external text entity, don't look for the BOM, because it might be a legal data. */ if (state == XML_CONTENT_STATE) { int e = INIT_ENC_INDEX(enc); if (e == ISO_8859_1_ENC || e == UTF_16BE_ENC || e == UTF_16LE_ENC || e == UTF_16_ENC) break; } if (ptr + 2 == end) return XML_TOK_PARTIAL; if ((unsigned char)ptr[2] == 0xBF) { *nextTokPtr = ptr + 3; // line added by DBL *encPtr = encodingTable[UTF_8_ENC]; return XML_TOK_BOM; } break; default: if (ptr[0] == '\0') { /* 0 isn't a legal data character. Furthermore a document entity can only start with ASCII characters. So the only way this can fail to be big-endian UTF-16 if it it's an external parsed general entity that's labelled as UTF-16LE. */ if (state == XML_CONTENT_STATE && INIT_ENC_INDEX(enc) == UTF_16LE_ENC) break; *encPtr = encodingTable[UTF_16BE_ENC]; return XmlTok(*encPtr, state, ptr, end, nextTokPtr); } else if (ptr[1] == '\0') { /* We could recover here in the case: - parsing an external entity - second byte is 0 - no externally specified encoding - no encoding declaration by assuming UTF-16LE. But we don't, because this would mean when presented just with a single byte, we couldn't reliably determine whether we needed further bytes. */ if (state == XML_CONTENT_STATE) break; *encPtr = encodingTable[UTF_16LE_ENC]; return XmlTok(*encPtr, state, ptr, end, nextTokPtr); } break; } } *encPtr = encodingTable[INIT_ENC_INDEX(enc)]; return XmlTok(*encPtr, state, ptr, end, nextTokPtr); } #define NS(x) x #define ns(x) x #include "xmltok_ns.c" #undef NS #undef ns #ifdef XML_NS #define NS(x) x ## NS #define ns(x) x ## _ns #include "xmltok_ns.c" #undef NS #undef ns ENCODING * XmlInitUnknownEncodingNS(void *mem, int *table, int (*convert)(void *userData, const char *p), void *userData) { ENCODING *enc = XmlInitUnknownEncoding(mem, table, convert, userData); if (enc) ((struct normal_encoding *)enc)->type[ASCII_COLON] = BT_COLON; return enc; } #endif /* XML_NS */ visp-3.0.1/3rdparty/libatidaq-c/xmltok.h000066400000000000000000000262251304511007300201060ustar00rootroot00000000000000/* Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd * * The MIT License * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR * OTHER DEALINGS IN THE SOFTWARE. */ #ifndef XmlTok_INCLUDED #define XmlTok_INCLUDED 1 #ifdef __cplusplus extern "C" { #endif #ifndef XMLTOKAPI #define XMLTOKAPI /* as nothing */ #endif /* The following token may be returned by XmlContentTok */ #define XML_TOK_TRAILING_RSQB -5 /* ] or ]] at the end of the scan; might be start of illegal ]]> sequence */ /* The following tokens may be returned by both XmlPrologTok and XmlContentTok */ #define XML_TOK_NONE -4 /* The string to be scanned is empty */ #define XML_TOK_TRAILING_CR -3 /* A CR at the end of the scan; might be part of CRLF sequence */ #define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ #define XML_TOK_PARTIAL -1 /* only part of a token */ #define XML_TOK_INVALID 0 /* The following tokens are returned by XmlContentTok; some are also returned by XmlAttributeValueTok, XmlEntityTok, XmlCdataSectionTok */ #define XML_TOK_START_TAG_WITH_ATTS 1 #define XML_TOK_START_TAG_NO_ATTS 2 #define XML_TOK_EMPTY_ELEMENT_WITH_ATTS 3 /* empty element tag */ #define XML_TOK_EMPTY_ELEMENT_NO_ATTS 4 #define XML_TOK_END_TAG 5 #define XML_TOK_DATA_CHARS 6 #define XML_TOK_DATA_NEWLINE 7 #define XML_TOK_CDATA_SECT_OPEN 8 #define XML_TOK_ENTITY_REF 9 #define XML_TOK_CHAR_REF 10 /* numeric character reference */ /* The following tokens may be returned by both XmlPrologTok and XmlContentTok */ #define XML_TOK_PI 11 /* processing instruction */ #define XML_TOK_XML_DECL 12 /* XML decl or text decl */ #define XML_TOK_COMMENT 13 #define XML_TOK_BOM 14 /* Byte order mark */ /* The following tokens are returned only by XmlPrologTok */ #define XML_TOK_PROLOG_S 15 #define XML_TOK_DECL_OPEN 16 /* */ #define XML_TOK_NAME 18 #define XML_TOK_NMTOKEN 19 #define XML_TOK_POUND_NAME 20 /* #name */ #define XML_TOK_OR 21 /* | */ #define XML_TOK_PERCENT 22 #define XML_TOK_OPEN_PAREN 23 #define XML_TOK_CLOSE_PAREN 24 #define XML_TOK_OPEN_BRACKET 25 #define XML_TOK_CLOSE_BRACKET 26 #define XML_TOK_LITERAL 27 #define XML_TOK_PARAM_ENTITY_REF 28 #define XML_TOK_INSTANCE_START 29 /* The following occur only in element type declarations */ #define XML_TOK_NAME_QUESTION 30 /* name? */ #define XML_TOK_NAME_ASTERISK 31 /* name* */ #define XML_TOK_NAME_PLUS 32 /* name+ */ #define XML_TOK_COND_SECT_OPEN 33 /* */ #define XML_TOK_CLOSE_PAREN_QUESTION 35 /* )? */ #define XML_TOK_CLOSE_PAREN_ASTERISK 36 /* )* */ #define XML_TOK_CLOSE_PAREN_PLUS 37 /* )+ */ #define XML_TOK_COMMA 38 /* The following token is returned only by XmlAttributeValueTok */ #define XML_TOK_ATTRIBUTE_VALUE_S 39 /* The following token is returned only by XmlCdataSectionTok */ #define XML_TOK_CDATA_SECT_CLOSE 40 /* With namespace processing this is returned by XmlPrologTok for a name with a colon. */ #define XML_TOK_PREFIXED_NAME 41 #ifdef XML_DTD #define XML_TOK_IGNORE_SECT 42 #endif /* XML_DTD */ #ifdef XML_DTD #define XML_N_STATES 4 #else /* not XML_DTD */ #define XML_N_STATES 3 #endif /* not XML_DTD */ #define XML_PROLOG_STATE 0 #define XML_CONTENT_STATE 1 #define XML_CDATA_SECTION_STATE 2 #ifdef XML_DTD #define XML_IGNORE_SECTION_STATE 3 #endif /* XML_DTD */ #define XML_N_LITERAL_TYPES 2 #define XML_ATTRIBUTE_VALUE_LITERAL 0 #define XML_ENTITY_VALUE_LITERAL 1 /* The size of the buffer passed to XmlUtf8Encode must be at least this. */ #define XML_UTF8_ENCODE_MAX 4 /* The size of the buffer passed to XmlUtf16Encode must be at least this. */ #define XML_UTF16_ENCODE_MAX 2 typedef struct position { /* first line and first column are 0 not 1 */ unsigned long lineNumber; unsigned long columnNumber; } POSITION; typedef struct { const char *name; const char *valuePtr; const char *valueEnd; char normalized; } ATTRIBUTE; struct encoding; typedef struct encoding ENCODING; struct encoding { int (*scanners[XML_N_STATES])(const ENCODING *, const char *, const char *, const char **); int (*literalScanners[XML_N_LITERAL_TYPES])(const ENCODING *, const char *, const char *, const char **); int (*sameName)(const ENCODING *, const char *, const char *); int (*nameMatchesAscii)(const ENCODING *, const char *, const char *, const char *); int (*nameLength)(const ENCODING *, const char *); const char *(*skipS)(const ENCODING *, const char *); int (*getAtts)(const ENCODING *enc, const char *ptr, int attsMax, ATTRIBUTE *atts); int (*charRefNumber)(const ENCODING *enc, const char *ptr); int (*predefinedEntityName)(const ENCODING *, const char *, const char *); void (*updatePosition)(const ENCODING *, const char *ptr, const char *end, POSITION *); int (*isPublicId)(const ENCODING *enc, const char *ptr, const char *end, const char **badPtr); void (*utf8Convert)(const ENCODING *enc, const char **fromP, const char *fromLim, char **toP, const char *toLim); void (*utf16Convert)(const ENCODING *enc, const char **fromP, const char *fromLim, unsigned short **toP, const unsigned short *toLim); int minBytesPerChar; char isUtf8; char isUtf16; }; /* Scan the string starting at ptr until the end of the next complete token, but do not scan past eptr. Return an integer giving the type of token. Return XML_TOK_NONE when ptr == eptr; nextTokPtr will not be set. Return XML_TOK_PARTIAL when the string does not contain a complete token; nextTokPtr will not be set. Return XML_TOK_INVALID when the string does not start a valid token; nextTokPtr will be set to point to the character which made the token invalid. Otherwise the string starts with a valid token; nextTokPtr will be set to point to the character following the end of that token. Each data character counts as a single token, but adjacent data characters may be returned together. Similarly for characters in the prolog outside literals, comments and processing instructions. */ #define XmlTok(enc, state, ptr, end, nextTokPtr) \ (((enc)->scanners[state])(enc, ptr, end, nextTokPtr)) #define XmlPrologTok(enc, ptr, end, nextTokPtr) \ XmlTok(enc, XML_PROLOG_STATE, ptr, end, nextTokPtr) #define XmlContentTok(enc, ptr, end, nextTokPtr) \ XmlTok(enc, XML_CONTENT_STATE, ptr, end, nextTokPtr) #define XmlCdataSectionTok(enc, ptr, end, nextTokPtr) \ XmlTok(enc, XML_CDATA_SECTION_STATE, ptr, end, nextTokPtr) #ifdef XML_DTD #define XmlIgnoreSectionTok(enc, ptr, end, nextTokPtr) \ XmlTok(enc, XML_IGNORE_SECTION_STATE, ptr, end, nextTokPtr) #endif /* XML_DTD */ /* This is used for performing a 2nd-level tokenization on the content of a literal that has already been returned by XmlTok. */ #define XmlLiteralTok(enc, literalType, ptr, end, nextTokPtr) \ (((enc)->literalScanners[literalType])(enc, ptr, end, nextTokPtr)) #define XmlAttributeValueTok(enc, ptr, end, nextTokPtr) \ XmlLiteralTok(enc, XML_ATTRIBUTE_VALUE_LITERAL, ptr, end, nextTokPtr) #define XmlEntityValueTok(enc, ptr, end, nextTokPtr) \ XmlLiteralTok(enc, XML_ENTITY_VALUE_LITERAL, ptr, end, nextTokPtr) #define XmlSameName(enc, ptr1, ptr2) (((enc)->sameName)(enc, ptr1, ptr2)) #define XmlNameMatchesAscii(enc, ptr1, end1, ptr2) \ (((enc)->nameMatchesAscii)(enc, ptr1, end1, ptr2)) #define XmlNameLength(enc, ptr) \ (((enc)->nameLength)(enc, ptr)) #define XmlSkipS(enc, ptr) \ (((enc)->skipS)(enc, ptr)) #define XmlGetAttributes(enc, ptr, attsMax, atts) \ (((enc)->getAtts)(enc, ptr, attsMax, atts)) #define XmlCharRefNumber(enc, ptr) \ (((enc)->charRefNumber)(enc, ptr)) #define XmlPredefinedEntityName(enc, ptr, end) \ (((enc)->predefinedEntityName)(enc, ptr, end)) #define XmlUpdatePosition(enc, ptr, end, pos) \ (((enc)->updatePosition)(enc, ptr, end, pos)) #define XmlIsPublicId(enc, ptr, end, badPtr) \ (((enc)->isPublicId)(enc, ptr, end, badPtr)) #define XmlUtf8Convert(enc, fromP, fromLim, toP, toLim) \ (((enc)->utf8Convert)(enc, fromP, fromLim, toP, toLim)) #define XmlUtf16Convert(enc, fromP, fromLim, toP, toLim) \ (((enc)->utf16Convert)(enc, fromP, fromLim, toP, toLim)) typedef struct { ENCODING initEnc; const ENCODING **encPtr; } INIT_ENCODING; int XMLTOKAPI XmlParseXmlDecl(int isGeneralTextEntity, const ENCODING *enc, const char *ptr, const char *end, const char **badPtr, const char **versionPtr, const char **encodingNamePtr, const ENCODING **namedEncodingPtr, int *standalonePtr); int XMLTOKAPI XmlInitEncoding(INIT_ENCODING *, const ENCODING **, const char *name); const ENCODING XMLTOKAPI *XmlGetUtf8InternalEncoding(void); const ENCODING XMLTOKAPI *XmlGetUtf16InternalEncoding(void); int XMLTOKAPI XmlUtf8Encode(int charNumber, char *buf); int XMLTOKAPI XmlUtf16Encode(int charNumber, unsigned short *buf); int XMLTOKAPI XmlSizeOfUnknownEncoding(void); ENCODING XMLTOKAPI * XmlInitUnknownEncoding(void *mem, int *table, int (*conv)(void *userData, const char *p), void *userData); int XMLTOKAPI XmlParseXmlDeclNS(int isGeneralTextEntity, const ENCODING *enc, const char *ptr, const char *end, const char **badPtr, const char **versionPtr, const char **encodingNamePtr, const ENCODING **namedEncodingPtr, int *standalonePtr); int XMLTOKAPI XmlInitEncodingNS(INIT_ENCODING *, const ENCODING **, const char *name); const ENCODING XMLTOKAPI *XmlGetUtf8InternalEncodingNS(void); const ENCODING XMLTOKAPI *XmlGetUtf16InternalEncodingNS(void); ENCODING XMLTOKAPI * XmlInitUnknownEncodingNS(void *mem, int *table, int (*conv)(void *userData, const char *p), void *userData); #ifdef __cplusplus } #endif #endif /* not XmlTok_INCLUDED */ visp-3.0.1/3rdparty/libatidaq-c/xmltok_impl.c000066400000000000000000001253061304511007300211220ustar00rootroot00000000000000/* Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd * * The MIT License * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR * OTHER DEALINGS IN THE SOFTWARE. */ #ifndef IS_INVALID_CHAR #define IS_INVALID_CHAR(enc, ptr, n) (0) #endif #define INVALID_LEAD_CASE(n, ptr, nextTokPtr) \ case BT_LEAD ## n: \ if (end - ptr < n) \ return XML_TOK_PARTIAL_CHAR; \ if (IS_INVALID_CHAR(enc, ptr, n)) { \ *(nextTokPtr) = (ptr); \ return XML_TOK_INVALID; \ } \ ptr += n; \ break; #define INVALID_CASES(ptr, nextTokPtr) \ INVALID_LEAD_CASE(2, ptr, nextTokPtr) \ INVALID_LEAD_CASE(3, ptr, nextTokPtr) \ INVALID_LEAD_CASE(4, ptr, nextTokPtr) \ case BT_NONXML: \ case BT_MALFORM: \ case BT_TRAIL: \ *(nextTokPtr) = (ptr); \ return XML_TOK_INVALID; #define CHECK_NAME_CASE(n, enc, ptr, end, nextTokPtr) \ case BT_LEAD ## n: \ if (end - ptr < n) \ return XML_TOK_PARTIAL_CHAR; \ if (!IS_NAME_CHAR(enc, ptr, n)) { \ *nextTokPtr = ptr; \ return XML_TOK_INVALID; \ } \ ptr += n; \ break; #define CHECK_NAME_CASES(enc, ptr, end, nextTokPtr) \ case BT_NONASCII: \ if (!IS_NAME_CHAR_MINBPC(enc, ptr)) { \ *nextTokPtr = ptr; \ return XML_TOK_INVALID; \ } \ case BT_NMSTRT: \ case BT_HEX: \ case BT_DIGIT: \ case BT_NAME: \ case BT_MINUS: \ ptr += MINBPC(enc); \ break; \ CHECK_NAME_CASE(2, enc, ptr, end, nextTokPtr) \ CHECK_NAME_CASE(3, enc, ptr, end, nextTokPtr) \ CHECK_NAME_CASE(4, enc, ptr, end, nextTokPtr) #define CHECK_NMSTRT_CASE(n, enc, ptr, end, nextTokPtr) \ case BT_LEAD ## n: \ if (end - ptr < n) \ return XML_TOK_PARTIAL_CHAR; \ if (!IS_NMSTRT_CHAR(enc, ptr, n)) { \ *nextTokPtr = ptr; \ return XML_TOK_INVALID; \ } \ ptr += n; \ break; #define CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr) \ case BT_NONASCII: \ if (!IS_NMSTRT_CHAR_MINBPC(enc, ptr)) { \ *nextTokPtr = ptr; \ return XML_TOK_INVALID; \ } \ case BT_NMSTRT: \ case BT_HEX: \ ptr += MINBPC(enc); \ break; \ CHECK_NMSTRT_CASE(2, enc, ptr, end, nextTokPtr) \ CHECK_NMSTRT_CASE(3, enc, ptr, end, nextTokPtr) \ CHECK_NMSTRT_CASE(4, enc, ptr, end, nextTokPtr) #ifndef PREFIX #define PREFIX(ident) ident #endif /* ptr points to character following " */ switch (BYTE_TYPE(enc, ptr + MINBPC(enc))) { case BT_S: case BT_CR: case BT_LF: case BT_PERCNT: *nextTokPtr = ptr; return XML_TOK_INVALID; } /* fall through */ case BT_S: case BT_CR: case BT_LF: *nextTokPtr = ptr; return XML_TOK_DECL_OPEN; case BT_NMSTRT: case BT_HEX: ptr += MINBPC(enc); break; default: *nextTokPtr = ptr; return XML_TOK_INVALID; } } return XML_TOK_PARTIAL; } static int PREFIX(checkPiTarget)(const ENCODING *enc, const char *ptr, const char *end, int *tokPtr) { int upper = 0; *tokPtr = XML_TOK_PI; if (end - ptr != MINBPC(enc)*3) return 1; switch (BYTE_TO_ASCII(enc, ptr)) { case ASCII_x: break; case ASCII_X: upper = 1; break; default: return 1; } ptr += MINBPC(enc); switch (BYTE_TO_ASCII(enc, ptr)) { case ASCII_m: break; case ASCII_M: upper = 1; break; default: return 1; } ptr += MINBPC(enc); switch (BYTE_TO_ASCII(enc, ptr)) { case ASCII_l: break; case ASCII_L: upper = 1; break; default: return 1; } if (upper) return 0; *tokPtr = XML_TOK_XML_DECL; return 1; } /* ptr points to character following " 1) { size_t n = end - ptr; if (n & (MINBPC(enc) - 1)) { n &= ~(MINBPC(enc) - 1); if (n == 0) return XML_TOK_PARTIAL; end = ptr + n; } } switch (BYTE_TYPE(enc, ptr)) { case BT_RSQB: ptr += MINBPC(enc); if (ptr == end) return XML_TOK_PARTIAL; if (!CHAR_MATCHES(enc, ptr, ASCII_RSQB)) break; ptr += MINBPC(enc); if (ptr == end) return XML_TOK_PARTIAL; if (!CHAR_MATCHES(enc, ptr, ASCII_GT)) { ptr -= MINBPC(enc); break; } *nextTokPtr = ptr + MINBPC(enc); return XML_TOK_CDATA_SECT_CLOSE; case BT_CR: ptr += MINBPC(enc); if (ptr == end) return XML_TOK_PARTIAL; if (BYTE_TYPE(enc, ptr) == BT_LF) ptr += MINBPC(enc); *nextTokPtr = ptr; return XML_TOK_DATA_NEWLINE; case BT_LF: *nextTokPtr = ptr + MINBPC(enc); return XML_TOK_DATA_NEWLINE; INVALID_CASES(ptr, nextTokPtr) default: ptr += MINBPC(enc); break; } while (ptr != end) { switch (BYTE_TYPE(enc, ptr)) { #define LEAD_CASE(n) \ case BT_LEAD ## n: \ if (end - ptr < n || IS_INVALID_CHAR(enc, ptr, n)) { \ *nextTokPtr = ptr; \ return XML_TOK_DATA_CHARS; \ } \ ptr += n; \ break; LEAD_CASE(2) LEAD_CASE(3) LEAD_CASE(4) #undef LEAD_CASE case BT_NONXML: case BT_MALFORM: case BT_TRAIL: case BT_CR: case BT_LF: case BT_RSQB: *nextTokPtr = ptr; return XML_TOK_DATA_CHARS; default: ptr += MINBPC(enc); break; } } *nextTokPtr = ptr; return XML_TOK_DATA_CHARS; } /* ptr points to character following " 1) { size_t n = end - ptr; if (n & (MINBPC(enc) - 1)) { n &= ~(MINBPC(enc) - 1); if (n == 0) return XML_TOK_PARTIAL; end = ptr + n; } } switch (BYTE_TYPE(enc, ptr)) { case BT_LT: return PREFIX(scanLt)(enc, ptr + MINBPC(enc), end, nextTokPtr); case BT_AMP: return PREFIX(scanRef)(enc, ptr + MINBPC(enc), end, nextTokPtr); case BT_CR: ptr += MINBPC(enc); if (ptr == end) return XML_TOK_TRAILING_CR; if (BYTE_TYPE(enc, ptr) == BT_LF) ptr += MINBPC(enc); *nextTokPtr = ptr; return XML_TOK_DATA_NEWLINE; case BT_LF: *nextTokPtr = ptr + MINBPC(enc); return XML_TOK_DATA_NEWLINE; case BT_RSQB: ptr += MINBPC(enc); if (ptr == end) return XML_TOK_TRAILING_RSQB; if (!CHAR_MATCHES(enc, ptr, ASCII_RSQB)) break; ptr += MINBPC(enc); if (ptr == end) return XML_TOK_TRAILING_RSQB; if (!CHAR_MATCHES(enc, ptr, ASCII_GT)) { ptr -= MINBPC(enc); break; } *nextTokPtr = ptr; return XML_TOK_INVALID; INVALID_CASES(ptr, nextTokPtr) default: ptr += MINBPC(enc); break; } while (ptr != end) { switch (BYTE_TYPE(enc, ptr)) { #define LEAD_CASE(n) \ case BT_LEAD ## n: \ if (end - ptr < n || IS_INVALID_CHAR(enc, ptr, n)) { \ *nextTokPtr = ptr; \ return XML_TOK_DATA_CHARS; \ } \ ptr += n; \ break; LEAD_CASE(2) LEAD_CASE(3) LEAD_CASE(4) #undef LEAD_CASE case BT_RSQB: if (ptr + MINBPC(enc) != end) { if (!CHAR_MATCHES(enc, ptr + MINBPC(enc), ASCII_RSQB)) { ptr += MINBPC(enc); break; } if (ptr + 2*MINBPC(enc) != end) { if (!CHAR_MATCHES(enc, ptr + 2*MINBPC(enc), ASCII_GT)) { ptr += MINBPC(enc); break; } *nextTokPtr = ptr + 2*MINBPC(enc); return XML_TOK_INVALID; } } /* fall through */ case BT_AMP: case BT_LT: case BT_NONXML: case BT_MALFORM: case BT_TRAIL: case BT_CR: case BT_LF: *nextTokPtr = ptr; return XML_TOK_DATA_CHARS; default: ptr += MINBPC(enc); break; } } *nextTokPtr = ptr; return XML_TOK_DATA_CHARS; } /* ptr points to character following "%" */ static int PREFIX(scanPercent)(const ENCODING *enc, const char *ptr, const char *end, const char **nextTokPtr) { if (ptr == end) return XML_TOK_PARTIAL; switch (BYTE_TYPE(enc, ptr)) { CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr) case BT_S: case BT_LF: case BT_CR: case BT_PERCNT: *nextTokPtr = ptr; return XML_TOK_PERCENT; default: *nextTokPtr = ptr; return XML_TOK_INVALID; } while (ptr != end) { switch (BYTE_TYPE(enc, ptr)) { CHECK_NAME_CASES(enc, ptr, end, nextTokPtr) case BT_SEMI: *nextTokPtr = ptr + MINBPC(enc); return XML_TOK_PARAM_ENTITY_REF; default: *nextTokPtr = ptr; return XML_TOK_INVALID; } } return XML_TOK_PARTIAL; } static int PREFIX(scanPoundName)(const ENCODING *enc, const char *ptr, const char *end, const char **nextTokPtr) { if (ptr == end) return XML_TOK_PARTIAL; switch (BYTE_TYPE(enc, ptr)) { CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr) default: *nextTokPtr = ptr; return XML_TOK_INVALID; } while (ptr != end) { switch (BYTE_TYPE(enc, ptr)) { CHECK_NAME_CASES(enc, ptr, end, nextTokPtr) case BT_CR: case BT_LF: case BT_S: case BT_RPAR: case BT_GT: case BT_PERCNT: case BT_VERBAR: *nextTokPtr = ptr; return XML_TOK_POUND_NAME; default: *nextTokPtr = ptr; return XML_TOK_INVALID; } } return -XML_TOK_POUND_NAME; } static int PREFIX(scanLit)(int open, const ENCODING *enc, const char *ptr, const char *end, const char **nextTokPtr) { while (ptr != end) { int t = BYTE_TYPE(enc, ptr); switch (t) { INVALID_CASES(ptr, nextTokPtr) case BT_QUOT: case BT_APOS: ptr += MINBPC(enc); if (t != open) break; if (ptr == end) return -XML_TOK_LITERAL; *nextTokPtr = ptr; switch (BYTE_TYPE(enc, ptr)) { case BT_S: case BT_CR: case BT_LF: case BT_GT: case BT_PERCNT: case BT_LSQB: return XML_TOK_LITERAL; default: return XML_TOK_INVALID; } default: ptr += MINBPC(enc); break; } } return XML_TOK_PARTIAL; } static int PREFIX(prologTok)(const ENCODING *enc, const char *ptr, const char *end, const char **nextTokPtr) { int tok; if (ptr == end) return XML_TOK_NONE; if (MINBPC(enc) > 1) { size_t n = end - ptr; if (n & (MINBPC(enc) - 1)) { n &= ~(MINBPC(enc) - 1); if (n == 0) return XML_TOK_PARTIAL; end = ptr + n; } } switch (BYTE_TYPE(enc, ptr)) { case BT_QUOT: return PREFIX(scanLit)(BT_QUOT, enc, ptr + MINBPC(enc), end, nextTokPtr); case BT_APOS: return PREFIX(scanLit)(BT_APOS, enc, ptr + MINBPC(enc), end, nextTokPtr); case BT_LT: { ptr += MINBPC(enc); if (ptr == end) return XML_TOK_PARTIAL; switch (BYTE_TYPE(enc, ptr)) { case BT_EXCL: return PREFIX(scanDecl)(enc, ptr + MINBPC(enc), end, nextTokPtr); case BT_QUEST: return PREFIX(scanPi)(enc, ptr + MINBPC(enc), end, nextTokPtr); case BT_NMSTRT: case BT_HEX: case BT_NONASCII: case BT_LEAD2: case BT_LEAD3: case BT_LEAD4: *nextTokPtr = ptr - MINBPC(enc); return XML_TOK_INSTANCE_START; } *nextTokPtr = ptr; return XML_TOK_INVALID; } case BT_CR: if (ptr + MINBPC(enc) == end) return -XML_TOK_PROLOG_S; /* fall through */ case BT_S: case BT_LF: for (;;) { ptr += MINBPC(enc); if (ptr == end) break; switch (BYTE_TYPE(enc, ptr)) { case BT_S: case BT_LF: break; case BT_CR: /* don't split CR/LF pair */ if (ptr + MINBPC(enc) != end) break; /* fall through */ default: *nextTokPtr = ptr; return XML_TOK_PROLOG_S; } } *nextTokPtr = ptr; return XML_TOK_PROLOG_S; case BT_PERCNT: return PREFIX(scanPercent)(enc, ptr + MINBPC(enc), end, nextTokPtr); case BT_COMMA: *nextTokPtr = ptr + MINBPC(enc); return XML_TOK_COMMA; case BT_LSQB: *nextTokPtr = ptr + MINBPC(enc); return XML_TOK_OPEN_BRACKET; case BT_RSQB: ptr += MINBPC(enc); if (ptr == end) return -XML_TOK_CLOSE_BRACKET; if (CHAR_MATCHES(enc, ptr, ASCII_RSQB)) { if (ptr + MINBPC(enc) == end) return XML_TOK_PARTIAL; if (CHAR_MATCHES(enc, ptr + MINBPC(enc), ASCII_GT)) { *nextTokPtr = ptr + 2*MINBPC(enc); return XML_TOK_COND_SECT_CLOSE; } } *nextTokPtr = ptr; return XML_TOK_CLOSE_BRACKET; case BT_LPAR: *nextTokPtr = ptr + MINBPC(enc); return XML_TOK_OPEN_PAREN; case BT_RPAR: ptr += MINBPC(enc); if (ptr == end) return -XML_TOK_CLOSE_PAREN; switch (BYTE_TYPE(enc, ptr)) { case BT_AST: *nextTokPtr = ptr + MINBPC(enc); return XML_TOK_CLOSE_PAREN_ASTERISK; case BT_QUEST: *nextTokPtr = ptr + MINBPC(enc); return XML_TOK_CLOSE_PAREN_QUESTION; case BT_PLUS: *nextTokPtr = ptr + MINBPC(enc); return XML_TOK_CLOSE_PAREN_PLUS; case BT_CR: case BT_LF: case BT_S: case BT_GT: case BT_COMMA: case BT_VERBAR: case BT_RPAR: *nextTokPtr = ptr; return XML_TOK_CLOSE_PAREN; } *nextTokPtr = ptr; return XML_TOK_INVALID; case BT_VERBAR: *nextTokPtr = ptr + MINBPC(enc); return XML_TOK_OR; case BT_GT: *nextTokPtr = ptr + MINBPC(enc); return XML_TOK_DECL_CLOSE; case BT_NUM: return PREFIX(scanPoundName)(enc, ptr + MINBPC(enc), end, nextTokPtr); #define LEAD_CASE(n) \ case BT_LEAD ## n: \ if (end - ptr < n) \ return XML_TOK_PARTIAL_CHAR; \ if (IS_NMSTRT_CHAR(enc, ptr, n)) { \ ptr += n; \ tok = XML_TOK_NAME; \ break; \ } \ if (IS_NAME_CHAR(enc, ptr, n)) { \ ptr += n; \ tok = XML_TOK_NMTOKEN; \ break; \ } \ *nextTokPtr = ptr; \ return XML_TOK_INVALID; LEAD_CASE(2) LEAD_CASE(3) LEAD_CASE(4) #undef LEAD_CASE case BT_NMSTRT: case BT_HEX: tok = XML_TOK_NAME; ptr += MINBPC(enc); break; case BT_DIGIT: case BT_NAME: case BT_MINUS: #ifdef XML_NS case BT_COLON: #endif tok = XML_TOK_NMTOKEN; ptr += MINBPC(enc); break; case BT_NONASCII: if (IS_NMSTRT_CHAR_MINBPC(enc, ptr)) { ptr += MINBPC(enc); tok = XML_TOK_NAME; break; } if (IS_NAME_CHAR_MINBPC(enc, ptr)) { ptr += MINBPC(enc); tok = XML_TOK_NMTOKEN; break; } /* fall through */ default: *nextTokPtr = ptr; return XML_TOK_INVALID; } while (ptr != end) { switch (BYTE_TYPE(enc, ptr)) { CHECK_NAME_CASES(enc, ptr, end, nextTokPtr) case BT_GT: case BT_RPAR: case BT_COMMA: case BT_VERBAR: case BT_LSQB: case BT_PERCNT: case BT_S: case BT_CR: case BT_LF: *nextTokPtr = ptr; return tok; #ifdef XML_NS case BT_COLON: ptr += MINBPC(enc); switch (tok) { case XML_TOK_NAME: if (ptr == end) return XML_TOK_PARTIAL; tok = XML_TOK_PREFIXED_NAME; switch (BYTE_TYPE(enc, ptr)) { CHECK_NAME_CASES(enc, ptr, end, nextTokPtr) default: tok = XML_TOK_NMTOKEN; break; } break; case XML_TOK_PREFIXED_NAME: tok = XML_TOK_NMTOKEN; break; } break; #endif case BT_PLUS: if (tok == XML_TOK_NMTOKEN) { *nextTokPtr = ptr; return XML_TOK_INVALID; } *nextTokPtr = ptr + MINBPC(enc); return XML_TOK_NAME_PLUS; case BT_AST: if (tok == XML_TOK_NMTOKEN) { *nextTokPtr = ptr; return XML_TOK_INVALID; } *nextTokPtr = ptr + MINBPC(enc); return XML_TOK_NAME_ASTERISK; case BT_QUEST: if (tok == XML_TOK_NMTOKEN) { *nextTokPtr = ptr; return XML_TOK_INVALID; } *nextTokPtr = ptr + MINBPC(enc); return XML_TOK_NAME_QUESTION; default: *nextTokPtr = ptr; return XML_TOK_INVALID; } } return -tok; } static int PREFIX(attributeValueTok)(const ENCODING *enc, const char *ptr, const char *end, const char **nextTokPtr) { const char *start; if (ptr == end) return XML_TOK_NONE; start = ptr; while (ptr != end) { switch (BYTE_TYPE(enc, ptr)) { #define LEAD_CASE(n) \ case BT_LEAD ## n: ptr += n; break; LEAD_CASE(2) LEAD_CASE(3) LEAD_CASE(4) #undef LEAD_CASE case BT_AMP: if (ptr == start) return PREFIX(scanRef)(enc, ptr + MINBPC(enc), end, nextTokPtr); *nextTokPtr = ptr; return XML_TOK_DATA_CHARS; case BT_LT: /* this is for inside entity references */ *nextTokPtr = ptr; return XML_TOK_INVALID; case BT_LF: if (ptr == start) { *nextTokPtr = ptr + MINBPC(enc); return XML_TOK_DATA_NEWLINE; } *nextTokPtr = ptr; return XML_TOK_DATA_CHARS; case BT_CR: if (ptr == start) { ptr += MINBPC(enc); if (ptr == end) return XML_TOK_TRAILING_CR; if (BYTE_TYPE(enc, ptr) == BT_LF) ptr += MINBPC(enc); *nextTokPtr = ptr; return XML_TOK_DATA_NEWLINE; } *nextTokPtr = ptr; return XML_TOK_DATA_CHARS; case BT_S: if (ptr == start) { *nextTokPtr = ptr + MINBPC(enc); return XML_TOK_ATTRIBUTE_VALUE_S; } *nextTokPtr = ptr; return XML_TOK_DATA_CHARS; default: ptr += MINBPC(enc); break; } } *nextTokPtr = ptr; return XML_TOK_DATA_CHARS; } static int PREFIX(entityValueTok)(const ENCODING *enc, const char *ptr, const char *end, const char **nextTokPtr) { const char *start; if (ptr == end) return XML_TOK_NONE; start = ptr; while (ptr != end) { switch (BYTE_TYPE(enc, ptr)) { #define LEAD_CASE(n) \ case BT_LEAD ## n: ptr += n; break; LEAD_CASE(2) LEAD_CASE(3) LEAD_CASE(4) #undef LEAD_CASE case BT_AMP: if (ptr == start) return PREFIX(scanRef)(enc, ptr + MINBPC(enc), end, nextTokPtr); *nextTokPtr = ptr; return XML_TOK_DATA_CHARS; case BT_PERCNT: if (ptr == start) return PREFIX(scanPercent)(enc, ptr + MINBPC(enc), end, nextTokPtr); *nextTokPtr = ptr; return XML_TOK_DATA_CHARS; case BT_LF: if (ptr == start) { *nextTokPtr = ptr + MINBPC(enc); return XML_TOK_DATA_NEWLINE; } *nextTokPtr = ptr; return XML_TOK_DATA_CHARS; case BT_CR: if (ptr == start) { ptr += MINBPC(enc); if (ptr == end) return XML_TOK_TRAILING_CR; if (BYTE_TYPE(enc, ptr) == BT_LF) ptr += MINBPC(enc); *nextTokPtr = ptr; return XML_TOK_DATA_NEWLINE; } *nextTokPtr = ptr; return XML_TOK_DATA_CHARS; default: ptr += MINBPC(enc); break; } } *nextTokPtr = ptr; return XML_TOK_DATA_CHARS; } #ifdef XML_DTD static int PREFIX(ignoreSectionTok)(const ENCODING *enc, const char *ptr, const char *end, const char **nextTokPtr) { int level = 0; if (MINBPC(enc) > 1) { size_t n = end - ptr; if (n & (MINBPC(enc) - 1)) { n &= ~(MINBPC(enc) - 1); end = ptr + n; } } while (ptr != end) { switch (BYTE_TYPE(enc, ptr)) { INVALID_CASES(ptr, nextTokPtr) case BT_LT: if ((ptr += MINBPC(enc)) == end) return XML_TOK_PARTIAL; if (CHAR_MATCHES(enc, ptr, ASCII_EXCL)) { if ((ptr += MINBPC(enc)) == end) return XML_TOK_PARTIAL; if (CHAR_MATCHES(enc, ptr, ASCII_LSQB)) { ++level; ptr += MINBPC(enc); } } break; case BT_RSQB: if ((ptr += MINBPC(enc)) == end) return XML_TOK_PARTIAL; if (CHAR_MATCHES(enc, ptr, ASCII_RSQB)) { if ((ptr += MINBPC(enc)) == end) return XML_TOK_PARTIAL; if (CHAR_MATCHES(enc, ptr, ASCII_GT)) { ptr += MINBPC(enc); if (level == 0) { *nextTokPtr = ptr; return XML_TOK_IGNORE_SECT; } --level; } } break; default: ptr += MINBPC(enc); break; } } return XML_TOK_PARTIAL; } #endif /* XML_DTD */ static int PREFIX(isPublicId)(const ENCODING *enc, const char *ptr, const char *end, const char **badPtr) { ptr += MINBPC(enc); end -= MINBPC(enc); for (; ptr != end; ptr += MINBPC(enc)) { switch (BYTE_TYPE(enc, ptr)) { case BT_DIGIT: case BT_HEX: case BT_MINUS: case BT_APOS: case BT_LPAR: case BT_RPAR: case BT_PLUS: case BT_COMMA: case BT_SOL: case BT_EQUALS: case BT_QUEST: case BT_CR: case BT_LF: case BT_SEMI: case BT_EXCL: case BT_AST: case BT_PERCNT: case BT_NUM: #ifdef XML_NS case BT_COLON: #endif break; case BT_S: if (CHAR_MATCHES(enc, ptr, ASCII_TAB)) { *badPtr = ptr; return 0; } break; case BT_NAME: case BT_NMSTRT: if (!(BYTE_TO_ASCII(enc, ptr) & ~0x7f)) break; default: switch (BYTE_TO_ASCII(enc, ptr)) { case 0x24: /* $ */ case 0x40: /* @ */ break; default: *badPtr = ptr; return 0; } break; } } return 1; } /* This must only be called for a well-formed start-tag or empty element tag. Returns the number of attributes. Pointers to the first attsMax attributes are stored in atts. */ static int PREFIX(getAtts)(const ENCODING *enc, const char *ptr, int attsMax, ATTRIBUTE *atts) { enum { other, inName, inValue } state = inName; int nAtts = 0; int open = 0; /* defined when state == inValue; initialization just to shut up compilers */ for (ptr += MINBPC(enc);; ptr += MINBPC(enc)) { switch (BYTE_TYPE(enc, ptr)) { #define START_NAME \ if (state == other) { \ if (nAtts < attsMax) { \ atts[nAtts].name = ptr; \ atts[nAtts].normalized = 1; \ } \ state = inName; \ } #define LEAD_CASE(n) \ case BT_LEAD ## n: START_NAME ptr += (n - MINBPC(enc)); break; LEAD_CASE(2) LEAD_CASE(3) LEAD_CASE(4) #undef LEAD_CASE case BT_NONASCII: case BT_NMSTRT: case BT_HEX: START_NAME break; #undef START_NAME case BT_QUOT: if (state != inValue) { if (nAtts < attsMax) atts[nAtts].valuePtr = ptr + MINBPC(enc); state = inValue; open = BT_QUOT; } else if (open == BT_QUOT) { state = other; if (nAtts < attsMax) atts[nAtts].valueEnd = ptr; nAtts++; } break; case BT_APOS: if (state != inValue) { if (nAtts < attsMax) atts[nAtts].valuePtr = ptr + MINBPC(enc); state = inValue; open = BT_APOS; } else if (open == BT_APOS) { state = other; if (nAtts < attsMax) atts[nAtts].valueEnd = ptr; nAtts++; } break; case BT_AMP: if (nAtts < attsMax) atts[nAtts].normalized = 0; break; case BT_S: if (state == inName) state = other; else if (state == inValue && nAtts < attsMax && atts[nAtts].normalized && (ptr == atts[nAtts].valuePtr || BYTE_TO_ASCII(enc, ptr) != ASCII_SPACE || BYTE_TO_ASCII(enc, ptr + MINBPC(enc)) == ASCII_SPACE || BYTE_TYPE(enc, ptr + MINBPC(enc)) == open)) atts[nAtts].normalized = 0; break; case BT_CR: case BT_LF: /* This case ensures that the first attribute name is counted Apart from that we could just change state on the quote. */ if (state == inName) state = other; else if (state == inValue && nAtts < attsMax) atts[nAtts].normalized = 0; break; case BT_GT: case BT_SOL: if (state != inValue) return nAtts; break; default: break; } } /* not reached */ } static int PREFIX(charRefNumber)(const ENCODING *enc, const char *ptr) { int result = 0; /* skip &# */ ptr += 2*MINBPC(enc); if (CHAR_MATCHES(enc, ptr, ASCII_x)) { for (ptr += MINBPC(enc); !CHAR_MATCHES(enc, ptr, ASCII_SEMI); ptr += MINBPC(enc)) { int c = BYTE_TO_ASCII(enc, ptr); switch (c) { case ASCII_0: case ASCII_1: case ASCII_2: case ASCII_3: case ASCII_4: case ASCII_5: case ASCII_6: case ASCII_7: case ASCII_8: case ASCII_9: result <<= 4; result |= (c - ASCII_0); break; case ASCII_A: case ASCII_B: case ASCII_C: case ASCII_D: case ASCII_E: case ASCII_F: result <<= 4; result += 10 + (c - ASCII_A); break; case ASCII_a: case ASCII_b: case ASCII_c: case ASCII_d: case ASCII_e: case ASCII_f: result <<= 4; result += 10 + (c - ASCII_a); break; } if (result >= 0x110000) return -1; } } else { for (; !CHAR_MATCHES(enc, ptr, ASCII_SEMI); ptr += MINBPC(enc)) { int c = BYTE_TO_ASCII(enc, ptr); result *= 10; result += (c - ASCII_0); if (result >= 0x110000) return -1; } } return checkCharRefNumber(result); } static int PREFIX(predefinedEntityName)(const ENCODING *enc, const char *ptr, const char *end) { switch ((end - ptr)/MINBPC(enc)) { case 2: if (CHAR_MATCHES(enc, ptr + MINBPC(enc), ASCII_t)) { switch (BYTE_TO_ASCII(enc, ptr)) { case ASCII_l: return ASCII_LT; case ASCII_g: return ASCII_GT; } } break; case 3: if (CHAR_MATCHES(enc, ptr, ASCII_a)) { ptr += MINBPC(enc); if (CHAR_MATCHES(enc, ptr, ASCII_m)) { ptr += MINBPC(enc); if (CHAR_MATCHES(enc, ptr, ASCII_p)) return ASCII_AMP; } } break; case 4: switch (BYTE_TO_ASCII(enc, ptr)) { case ASCII_q: ptr += MINBPC(enc); if (CHAR_MATCHES(enc, ptr, ASCII_u)) { ptr += MINBPC(enc); if (CHAR_MATCHES(enc, ptr, ASCII_o)) { ptr += MINBPC(enc); if (CHAR_MATCHES(enc, ptr, ASCII_t)) return ASCII_QUOT; } } break; case ASCII_a: ptr += MINBPC(enc); if (CHAR_MATCHES(enc, ptr, ASCII_p)) { ptr += MINBPC(enc); if (CHAR_MATCHES(enc, ptr, ASCII_o)) { ptr += MINBPC(enc); if (CHAR_MATCHES(enc, ptr, ASCII_s)) return ASCII_APOS; } } break; } } return 0; } static int PREFIX(sameName)(const ENCODING *enc, const char *ptr1, const char *ptr2) { for (;;) { switch (BYTE_TYPE(enc, ptr1)) { #define LEAD_CASE(n) \ case BT_LEAD ## n: \ if (*ptr1++ != *ptr2++) \ return 0; LEAD_CASE(4) LEAD_CASE(3) LEAD_CASE(2) #undef LEAD_CASE /* fall through */ if (*ptr1++ != *ptr2++) return 0; break; case BT_NONASCII: case BT_NMSTRT: #ifdef XML_NS case BT_COLON: #endif case BT_HEX: case BT_DIGIT: case BT_NAME: case BT_MINUS: if (*ptr2++ != *ptr1++) return 0; if (MINBPC(enc) > 1) { if (*ptr2++ != *ptr1++) return 0; if (MINBPC(enc) > 2) { if (*ptr2++ != *ptr1++) return 0; if (MINBPC(enc) > 3) { if (*ptr2++ != *ptr1++) return 0; } } } break; default: if (MINBPC(enc) == 1 && *ptr1 == *ptr2) return 1; switch (BYTE_TYPE(enc, ptr2)) { case BT_LEAD2: case BT_LEAD3: case BT_LEAD4: case BT_NONASCII: case BT_NMSTRT: #ifdef XML_NS case BT_COLON: #endif case BT_HEX: case BT_DIGIT: case BT_NAME: case BT_MINUS: return 0; default: return 1; } } } /* not reached */ } static int PREFIX(nameMatchesAscii)(const ENCODING *enc, const char *ptr1, const char *end1, const char *ptr2) { for (; *ptr2; ptr1 += MINBPC(enc), ptr2++) { if (ptr1 == end1) return 0; if (!CHAR_MATCHES(enc, ptr1, *ptr2)) return 0; } return ptr1 == end1; } static int PREFIX(nameLength)(const ENCODING *enc, const char *ptr) { const char *start = ptr; for (;;) { switch (BYTE_TYPE(enc, ptr)) { #define LEAD_CASE(n) \ case BT_LEAD ## n: ptr += n; break; LEAD_CASE(2) LEAD_CASE(3) LEAD_CASE(4) #undef LEAD_CASE case BT_NONASCII: case BT_NMSTRT: #ifdef XML_NS case BT_COLON: #endif case BT_HEX: case BT_DIGIT: case BT_NAME: case BT_MINUS: ptr += MINBPC(enc); break; default: return (int) (ptr - start); } } } static const char *PREFIX(skipS)(const ENCODING *enc, const char *ptr) { for (;;) { switch (BYTE_TYPE(enc, ptr)) { case BT_LF: case BT_CR: case BT_S: ptr += MINBPC(enc); break; default: return ptr; } } } static void PREFIX(updatePosition)(const ENCODING *enc, const char *ptr, const char *end, POSITION *pos) { while (ptr != end) { switch (BYTE_TYPE(enc, ptr)) { #define LEAD_CASE(n) \ case BT_LEAD ## n: \ ptr += n; \ break; LEAD_CASE(2) LEAD_CASE(3) LEAD_CASE(4) #undef LEAD_CASE case BT_LF: pos->columnNumber = (unsigned)-1; pos->lineNumber++; ptr += MINBPC(enc); break; case BT_CR: pos->lineNumber++; ptr += MINBPC(enc); if (ptr != end && BYTE_TYPE(enc, ptr) == BT_LF) ptr += MINBPC(enc); pos->columnNumber = (unsigned)-1; break; default: ptr += MINBPC(enc); break; } pos->columnNumber++; } } #undef DO_LEAD_CASE #undef MULTIBYTE_CASES #undef INVALID_CASES #undef CHECK_NAME_CASE #undef CHECK_NAME_CASES #undef CHECK_NMSTRT_CASE #undef CHECK_NMSTRT_CASES visp-3.0.1/3rdparty/libatidaq-c/xmltok_impl.h000066400000000000000000000033651304511007300211270ustar00rootroot00000000000000/* Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd * * The MIT License * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR * OTHER DEALINGS IN THE SOFTWARE. */ enum { BT_NONXML, BT_MALFORM, BT_LT, BT_AMP, BT_RSQB, BT_LEAD2, BT_LEAD3, BT_LEAD4, BT_TRAIL, BT_CR, BT_LF, BT_GT, BT_QUOT, BT_APOS, BT_EQUALS, BT_QUEST, BT_EXCL, BT_SOL, BT_SEMI, BT_NUM, BT_LSQB, BT_S, BT_NMSTRT, BT_COLON, BT_HEX, BT_DIGIT, BT_NAME, BT_MINUS, BT_OTHER, /* known not to be a name or name start character */ BT_NONASCII, /* might be a name or name start character */ BT_PERCNT, BT_LPAR, BT_RPAR, BT_AST, BT_PLUS, BT_COMMA, BT_VERBAR }; #include visp-3.0.1/3rdparty/libatidaq-c/xmltok_ns.c000066400000000000000000000071741304511007300206030ustar00rootroot00000000000000/* Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd * * The MIT License * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR * OTHER DEALINGS IN THE SOFTWARE. */ const ENCODING *NS(XmlGetUtf8InternalEncoding)(void) { return &ns(internal_utf8_encoding).enc; } const ENCODING *NS(XmlGetUtf16InternalEncoding)(void) { #if XML_BYTE_ORDER == 12 return &ns(internal_little2_encoding).enc; #elif XML_BYTE_ORDER == 21 return &ns(internal_big2_encoding).enc; #else const short n = 1; return *(const char *)&n ? &ns(internal_little2_encoding).enc : &ns(internal_big2_encoding).enc; #endif } static const ENCODING *NS(encodings)[] = { &ns(latin1_encoding).enc, &ns(ascii_encoding).enc, &ns(utf8_encoding).enc, &ns(big2_encoding).enc, &ns(big2_encoding).enc, &ns(little2_encoding).enc, &ns(utf8_encoding).enc /* NO_ENC */ }; static int NS(initScanProlog)(const ENCODING *enc, const char *ptr, const char *end, const char **nextTokPtr) { return initScan(NS(encodings), (const INIT_ENCODING *)enc, XML_PROLOG_STATE, ptr, end, nextTokPtr); } static int NS(initScanContent)(const ENCODING *enc, const char *ptr, const char *end, const char **nextTokPtr) { return initScan(NS(encodings), (const INIT_ENCODING *)enc, XML_CONTENT_STATE, ptr, end, nextTokPtr); } int NS(XmlInitEncoding)(INIT_ENCODING *p, const ENCODING **encPtr, const char *name) { int i = getEncodingIndex(name); if (i == UNKNOWN_ENC) return 0; SET_INIT_ENC_INDEX(p, i); p->initEnc.scanners[XML_PROLOG_STATE] = NS(initScanProlog); p->initEnc.scanners[XML_CONTENT_STATE] = NS(initScanContent); p->initEnc.updatePosition = initUpdatePosition; p->encPtr = encPtr; *encPtr = &(p->initEnc); return 1; } static const ENCODING *NS(findEncoding)(const ENCODING *enc, const char *ptr, const char *end) { #define ENCODING_MAX 128 char buf[ENCODING_MAX]; char *p = buf; int i; XmlUtf8Convert(enc, &ptr, end, &p, p + ENCODING_MAX - 1); if (ptr != end) return 0; *p = 0; if (streqci(buf, KW_UTF_16) && enc->minBytesPerChar == 2) return enc; i = getEncodingIndex(buf); if (i == UNKNOWN_ENC) return 0; return NS(encodings)[i]; } int NS(XmlParseXmlDecl)(int isGeneralTextEntity, const ENCODING *enc, const char *ptr, const char *end, const char **badPtr, const char **versionPtr, const char **encodingName, const ENCODING **encoding, int *standalone) { return doParseXmlDecl(NS(findEncoding), isGeneralTextEntity, enc, ptr, end, badPtr, versionPtr, encodingName, encoding, standalone); } visp-3.0.1/CMakeLists.txt000066400000000000000000001435371304511007300152430ustar00rootroot00000000000000############################################################################# # # This file is part of the ViSP software. # Copyright (C) 2005 - 2017 by Inria. All rights reserved. # # This software is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public License # ("GPL") version 2 as published by the Free Software Foundation. # See the file LICENSE.txt at the root directory of this source # distribution for additional information about the GNU GPL. # # For using ViSP with software that can not be combined with the GNU # GPL, please contact Inria about acquiring a ViSP Professional # Edition License. # # See http://visp.inria.fr for more information. # # This software was developed at: # Inria Rennes - Bretagne Atlantique # Campus Universitaire de Beaulieu # 35042 Rennes Cedex # France # # If you have questions regarding the use of this file, please contact # Inria at visp@inria.fr # # This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE # WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. # # Description: # ViSP overall configuration file. Detect third party libraries (X11, GTK, ...) # # Authors: # Fabien Spindler # ############################################################################# # Detect crosscompiling; need to be before project(VISP) to work if(NOT CMAKE_TOOLCHAIN_FILE) # Modify default install prefix if(WIN32) set(CMAKE_INSTALL_PREFIX "${CMAKE_BINARY_DIR}/install" CACHE PATH "Installation Directory") endif() else() # Crosscompiling set(CMAKE_INSTALL_PREFIX "${CMAKE_BINARY_DIR}/install" CACHE PATH "Installation Directory") endif() if(CMAKE_SYSTEM_NAME MATCHES WindowsPhone OR CMAKE_SYSTEM_NAME MATCHES WindowsStore) set(WINRT TRUE) endif(CMAKE_SYSTEM_NAME MATCHES WindowsPhone OR CMAKE_SYSTEM_NAME MATCHES WindowsStore) if(WINRT) add_definitions(-DWINRT) if(CMAKE_SYSTEM_NAME MATCHES WindowsPhone) set(WINRT_PHONE TRUE) add_definitions(-DWINRT_PHONE) elseif(CMAKE_SYSTEM_NAME MATCHES WindowsStore) set(WINRT_STORE TRUE) add_definitions(-DWINRT_STORE) endif() if(CMAKE_SYSTEM_VERSION MATCHES 10 OR CMAKE_SYSTEM_VERSION MATCHES 10.0) set(WINRT_10 TRUE) add_definitions(-DWINRT_10) elseif(CMAKE_SYSTEM_VERSION MATCHES 8.1) set(WINRT_8_1 TRUE) add_definitions(-DWINRT_8_1) elseif(CMAKE_SYSTEM_VERSION MATCHES 8.0) set(WINRT_8_0 TRUE) add_definitions(-DWINRT_8_0) endif() endif() # By default set release configuration if(NOT CMAKE_BUILD_TYPE) set(CMAKE_BUILD_TYPE "Release" CACHE String "Choose the type of build, options are: None Debug Release RelWithDebInfo MinSizeRel." FORCE) endif() project(VISP C CXX) # Detect if the toolchain is for Aldebaran naoqi if(CMAKE_TOOLCHAIN_FILE AND I_AM_A_ROBOT) include(platforms/naoqi/cmake/extra.cmake) endif() cmake_minimum_required(VERSION 2.8.3) if(POLICY CMP0022) cmake_policy(SET CMP0022 NEW) # Due to sensor ATIDAQ_LIBRARIES endif() list(APPEND CMAKE_MODULE_PATH "${PROJECT_SOURCE_DIR}/cmake") include(cmake/VISPUtils.cmake) vp_clear_vars(VISPModules_TARGETS) #----------------------------------------------------------------------------- # VISP version number. An even minor number corresponds to releases. set(VISP_VERSION_MAJOR "3") set(VISP_VERSION_MINOR "0") set(VISP_VERSION_PATCH "1") set(VISP_VERSION "${VISP_VERSION_MAJOR}.${VISP_VERSION_MINOR}.${VISP_VERSION_PATCH}") # Package revision number set(VISP_REVISION "1") find_file(GNU_INSTALL_DIRS_FROM_CMAKE NAMES GNUInstallDirs.cmake PATHS ${CMAKE_ROOT}/Modules) mark_as_advanced(GNU_INSTALL_DIRS_FROM_CMAKE) if(GNU_INSTALL_DIRS_FROM_CMAKE) include(${CMAKE_ROOT}/Modules/GNUInstallDirs.cmake) else() include(cmake/GNUInstallDirs.cmake) endif() #---------------------------------------------------------------------- # Platform specific #---------------------------------------------------------------------- include(cmake/VISPDetectPlatform.cmake) # Set the path where to install the lib if(WIN32) if(DEFINED VISP_RUNTIME AND DEFINED VISP_ARCH) set(VISP_INSTALL_BINARIES_PREFIX "${VISP_ARCH}/${VISP_RUNTIME}/") else() message(STATUS "Can't detect runtime and/or arch") set(VISP_INSTALL_BINARIES_PREFIX "") endif() else() set(VISP_INSTALL_BINARIES_PREFIX "") endif() # where to install the library and headers if(WIN32) set(VISP_INC_INSTALL_PATH ${CMAKE_INSTALL_INCLUDEDIR}) if(VISP_STATIC) set(VISP_LIB_INSTALL_PATH "${VISP_INSTALL_BINARIES_PREFIX}static${CMAKE_INSTALL_LIBDIR}") else() set(VISP_LIB_INSTALL_PATH "${VISP_INSTALL_BINARIES_PREFIX}${CMAKE_INSTALL_LIBDIR}") endif() set(VISP_BIN_INSTALL_PATH "${VISP_INSTALL_BINARIES_PREFIX}${CMAKE_INSTALL_BINDIR}") set(VISP_3P_LIB_INSTALL_PATH "${VISP_INSTALL_BINARIES_PREFIX}static${CMAKE_INSTALL_LIBDIR}") else() # The location where includes and libraries will be installed # The 2 following commented lines should be used to enable multi-arch support. # Since catkin doesn't support multi-arch we keep these 2 lines commented for the moment. # set(VISP_INC_INSTALL_PATH ${CMAKE_INSTALL_INCLUDEDIR}/${CMAKE_LIBRARY_ARCHITECTURE}) # set(VISP_LIB_INSTALL_PATH ${CMAKE_INSTALL_LIBDIR}/${CMAKE_LIBRARY_ARCHITECTURE}) set(VISP_INC_INSTALL_PATH ${CMAKE_INSTALL_INCLUDEDIR}) set(VISP_LIB_INSTALL_PATH ${CMAKE_INSTALL_LIBDIR}) set(VISP_BIN_INSTALL_PATH ${CMAKE_INSTALL_BINDIR}) set(VISP_3P_LIB_INSTALL_PATH share/ViSP/3rdparty/${VISP_LIB_INSTALL_PATH}) endif() set(VISP_3P_LIBRARY_OUTPUT_PATH "${VISP_BINARY_DIR}/3rdparty/lib") # the include directory we depend on for the build set(VISP_INCLUDE_DIR ${VISP_BINARY_DIR}/${VISP_INC_INSTALL_PATH}) set(VISP_DOC_DIR "${VISP_BINARY_DIR}/doc") # The location where includes and libraries will be build set(LIBRARY_OUTPUT_PATH ${VISP_BINARY_DIR}/${VISP_LIB_INSTALL_PATH}) set(BINARY_OUTPUT_PATH ${VISP_BINARY_DIR}/${VISP_BIN_INSTALL_PATH}) if(WIN32) # Postfix of .lib and .dll set(VISP_DEBUG_POSTFIX "d") set(VISP_DLLVERSION "${VISP_VERSION_MAJOR}${VISP_VERSION_MINOR}${VISP_VERSION_PATCH}") else() set(VISP_DEBUG_POSTFIX "") set(VISP_DLLVERSION "") endif() include_directories(${VISP_INCLUDE_DIR}) #---------------------------------------------------------------------- # SSE optimization #---------------------------------------------------------------------- VP_OPTION(ENABLE_SSE2 "" "" "Enable SSE2 instructions" "" ON IF ((MSVC OR CMAKE_COMPILER_IS_GNUCXX) AND (X86 OR X86_64)) ) VP_OPTION(ENABLE_SSE3 "" "" "Enable SSE3 instructions" "" ON IF ((MSVC OR CMAKE_COMPILER_IS_GNUCXX) AND (X86 OR X86_64)) ) VP_OPTION(ENABLE_SSSE3 "" "" "Enable SSSE3 instructions" "" ON IF ((MSVC OR CMAKE_COMPILER_IS_GNUCXX) AND (X86 OR X86_64)) ) # ---------------------------------------------------------------------------- # Handle always full RPATH # http://www.cmake.org/Wiki/CMake_RPATH_handling # ---------------------------------------------------------------------------- # avoid CMP0042 warning if(APPLE) set(CMAKE_MACOSX_RPATH ON) endif() # use, i.e. don't skip the full RPATH for the build tree set(CMAKE_SKIP_BUILD_RPATH FALSE) # when building, don't use the install RPATH already # (but later on when installing) set(CMAKE_BUILD_WITH_INSTALL_RPATH FALSE) set(CMAKE_INSTALL_RPATH "${CMAKE_INSTALL_PREFIX}/${VISP_LIB_INSTALL_PATH}") # add the automatically determined parts of the RPATH # which point to directories outside the build tree to the install RPATH set(CMAKE_INSTALL_RPATH_USE_LINK_PATH TRUE) # the RPATH to be used when installing, but only if it's not a system directory list(FIND CMAKE_PLATFORM_IMPLICIT_LINK_DIRECTORIES "${CMAKE_INSTALL_PREFIX}/${VISP_LIB_INSTALL_PATH}" isSystemDir) if("${isSystemDir}" STREQUAL "-1") set(CMAKE_INSTALL_RPATH "${CMAKE_INSTALL_PREFIX}/${VISP_LIB_INSTALL_PATH}") endif("${isSystemDir}" STREQUAL "-1") # ---------------------------------------------------------------------------- # Path for additional contrib modules # ---------------------------------------------------------------------------- set(VISP_CONTRIB_MODULES_PATH "" CACHE PATH "Where to look for additional contrib ViSP modules") # Get the OS set(OS ${CMAKE_SYSTEM_NAME}) set(OGRE_HOME $ENV{OGRE_HOME}) if(OGRE_HOME) # replace \ with / especially for windows STRING(REGEX REPLACE "\\\\" "/" OGRE_HOME ${OGRE_HOME}) endif() # add the path to detect Ogre3D if(WIN32) list(APPEND CMAKE_MODULE_PATH "${OGRE_HOME}/CMake") endif(WIN32) if(UNIX) list(APPEND CMAKE_MODULE_PATH "${OGRE_HOME}/cmake") list(APPEND CMAKE_MODULE_PATH "${OGRE_HOME}/CMake") list(APPEND CMAKE_MODULE_PATH "/usr/local/lib/OGRE/cmake") list(APPEND CMAKE_MODULE_PATH "/usr/lib/OGRE/cmake") list(APPEND CMAKE_MODULE_PATH "/usr/local/lib64/OGRE/cmake") list(APPEND CMAKE_MODULE_PATH "/usr/lib64/OGRE/cmake") list(APPEND CMAKE_MODULE_PATH "/usr/share/OGRE/cmake/modules") endif(UNIX) #-------------------------------------------------------------------- # Option management #-------------------------------------------------------------------- # Choose static or shared libraries. VP_OPTION(BUILD_SHARED_LIBS "" "" "Build ViSP shared libraries (.dll/.so) instead of static ones (.lib/.a)" "" NOT APPLE_FRAMEWORK) # Build examples as an option. VP_OPTION(BUILD_EXAMPLES "" "" "Build ViSP examples" "" ON) # Build examples as an option. VP_OPTION(BUILD_TESTS "" "" "Build ViSP tests" "" ON) VP_OPTION(BUILD_COVERAGE "" "" "Enables test coverage" "" OFF IF (BUILD_TESTS AND CMAKE_COMPILER_IS_GNUCXX AND CMAKE_BUILD_TYPE MATCHES "Debug")) # Build demos as an option. VP_OPTION(BUILD_DEMOS "" "" "Build ViSP demos" "" ON) # Build demos as an option. VP_OPTION(BUILD_TUTORIALS "" "" "Build ViSP tutorials" "" ON) # Build deprecated functions as an option. VP_OPTION(BUILD_DEPRECATED_FUNCTIONS "" "" "Build deprecated functionalities" "" ON) # Debug and trace cflags VP_OPTION(ACTIVATE_DEBUG_TRACE "" "" "Enable debug and trace printings" "" ON) VP_OPTION(BUILD_WITH_STATIC_CRT "" "" "Enables use of staticaly linked CRT for staticaly linked ViSP" "" ON IF MSVC) # ---------------------------------------------------------------------------- # Build options # ---------------------------------------------------------------------------- VP_OPTION(ENABLE_SOLUTION_FOLDERS "" "" "Solution folder in Visual Studio or in other IDEs" "" (MSVC_IDE OR CMAKE_GENERATOR MATCHES Xcode)) # Note that it is better to set ENABLE_MOMENTS_COMBINE_MATRICES to OFF VP_OPTION(ENABLE_MOMENTS_COMBINE_MATRICES "" "" "Use linear combination of matrices instead of linear combination of moments to compute interaction matrices." "ENABLE_MOMENTS_COMBINE_MATRICES" OFF) VP_OPTION(ENABLE_TEST_WITHOUT_DISPLAY "" "" "Don't use display feature when testing" "" ON) VP_OPTION(ENABLE_FULL_DOC "" "" "Build doc with internal classes that are by default not part of the doc" "" OFF) if(ENABLE_SOLUTION_FOLDERS) set_property(GLOBAL PROPERTY USE_FOLDERS ON) set_property(GLOBAL PROPERTY PREDEFINED_TARGETS_FOLDER "CMakeTargets") endif() if(ENABLE_TEST_WITHOUT_DISPLAY) set(OPTION_TO_DESACTIVE_DISPLAY "-d") endif() # Check for Inria's robot drivers VP_CHECK_PACKAGE(RAW1394) VP_CHECK_PACKAGE(RT) VP_CHECK_PACKAGE(CALINUX) VP_CHECK_PACKAGE(IRISA) # check for linux/parport.h VP_CHECK_PACKAGE(PARPORT) # OpenGL VP_CHECK_PACKAGE(OpenGL) # for pioneer VP_CHECK_PACKAGE(RT) VP_CHECK_PACKAGE(DL) # for Afma6 calibration data VP_CHECK_PACKAGE(Afma6_data) if(AFMA6_DATA_FOUND) set(VISP_AFMA6_DATA_PATH ${AFMA6_DATA_PATH}) else() set(VISP_AFMA6_DATA_PATH "") endif() # for Viper850 calibration data VP_CHECK_PACKAGE(Viper850_data) if(VIPER850_DATA_FOUND) set(VISP_VIPER850_DATA_PATH ${VIPER850_DATA_PATH}) else() set(VISP_VIPER850_DATA_PATH "") endif() # for Viper650 calibration data VP_CHECK_PACKAGE(Viper650_data) if(VIPER650_DATA_FOUND) set(VISP_VIPER650_DATA_PATH ${VIPER650_DATA_PATH}) else() set(VISP_VIPER650_DATA_PATH "") endif() find_host_program(XRANDR xrandr) VP_OPTION(USE_AFMA4 "" "" "Include Afma4 robot support" "" ON IF (RAW1394_FOUND AND RT_FOUND AND CALINUX_FOUND AND IRISA_FOUND AND NOT WINRT)) VP_OPTION(USE_AFMA6 "" "" "Include Afma6 robot support" "" ON IF (RAW1394_FOUND AND RT_FOUND AND CALINUX_FOUND AND IRISA_FOUND AND NOT WINRT)) VP_OPTION(USE_VIPER650 "" "" "Include Viper s650 robot support" "" ON IF (RAW1394_FOUND AND RT_FOUND AND CALINUX_FOUND AND IRISA_FOUND AND NOT WINRT)) VP_OPTION(USE_VIPER850 "" "" "Include Viper s850 robot support" "" ON IF (RAW1394_FOUND AND RT_FOUND AND CALINUX_FOUND AND IRISA_FOUND AND NOT WINRT)) VP_OPTION(USE_VIRTUOSE Virtuose "" "Include Virtuose SDK support for Haption devices" "" ON IF NOT WINRT) VP_OPTION(USE_DC1394 DC1394 "" "Include dc1394 support" "" ON IF UNIX AND NOT WINRT) VP_OPTION(USE_V4L2 V4L2 "" "Include v4l2 support" "" ON IF UNIX AND NOT WINRT) VP_OPTION(USE_FLYCAPTURE FlyCapture "" "Include FlyCapture SDK support for PointGrey cameras" "" ON IF NOT WINRT) VP_OPTION(USE_COMEDI Comedi "" "Include comedi (linux control and measurement device interface) support" "" ON IF NOT WINRT) VP_OPTION(USE_BICLOPS BICLOPS "" "Include biclops support" "" ON IF NOT WINRT) VP_OPTION(USE_PTU46 PTU46 "" "Include ptu-46 support" "" ON IF UNIX AND NOT WINRT) VP_OPTION(USE_CMU1394 CMU1394 "" "Include cmu1494 support" "" ON IF WIN32 AND NOT WINRT) VP_OPTION(USE_GDI GDI "" "Include gdi support" "" ON IF WIN32 AND NOT WINRT) VP_OPTION(USE_DIRECT3D DIRECT3D "" "Include d3d support" "" ON IF WIN32 AND NOT WINRT) VP_OPTION(USE_DIRECTSHOW DIRECTSHOW "" "Include dshow support" "" ON IF WIN32 AND NOT WINRT) VP_OPTION(USE_OPENMP OpenMP "" "Include openmp support" "" ON) # Since the FindLAPACK.cmake provided with CMake is for Fortran language, # in CMakeModules we have added FindLAPACK_C.cmake for C language VP_OPTION(USE_LAPACK LAPACK_C "" "Include lapack support" "" ON IF NOT WINRT) VP_OPTION(USE_GSL GSL "" "Include gsl support" "" ON IF NOT WINRT) VP_OPTION(USE_COIN3D "Coin3D;MyCoin3D" "" "Include coin3d support" "" ON IF OPENGL_FOUND AND NOT WINRT) VP_OPTION(USE_YARP YARP QUIET "Include yarp support" "YARP_DIR" ON IF NOT WINRT) VP_OPTION(USE_OGRE OGRE QUIET "Include Ogre support" "OGRE_DIR" ON IF NOT WINRT) VP_OPTION(USE_OIS OIS QUIET "Include Ogre/ois support" "OIS_DIR" ON IF USE_OGRE AND NOT WINRT) VP_OPTION(USE_LIBFREENECT LIBFREENECT "" "Include libfreenect support" "" ON IF NOT WINRT) VP_OPTION(USE_LIBUSB_1 LIBUSB_1 "" "Include libusb-1 support" "" ON IF NOT WINRT) VP_OPTION(USE_REALSENSE RealSense "" "Include RealSense SDK support" "" ON IF NOT WINRT) if(USE_REALSENSE) VP_OPTION(USE_CPP11 CPP11 "" "Include c++11 support" "" ON) # if option is OFF, force to ON if(NOT USE_CPP11 AND CPP11_FOUND) unset(USE_REALSENSE) set(USE_REALSENSE OFF CACHE BOOL "Include RealSense SDK support" FORCE) message(WARNING "Realsense 3rd party was detected but turned OFF since USE_CPP11 is OFF. Realsense 3rd party needs cxx11 compiler flags. Thus to enable Realsense usage you have to turn USE_REALSENSE=ON and USE_CPP11=ON.") endif() else() VP_OPTION(USE_CPP11 CPP11 "" "Include c++11 support" "" OFF) endif() VP_OPTION(USE_SOWIN SOWIN "" "Include Coin/SoWin support" "" OFF IF (WIN32 AND USE_COIN3D) AND NOT WINRT) VP_OPTION(USE_SOQT SOQT "" "Include Coin/SoQt support" "" OFF IF USE_COIN3D AND NOT WINRT) VP_OPTION(USE_QT Qt "" "Include Coin/SoQt/Qt support" "" ON IF USE_SOQT AND NOT WINRT) VP_OPTION(USE_SOXT SOXT "" "Include Coin/SoXt support" "" OFF IF USE_COIN3D AND NOT WINRT) VP_OPTION(USE_PTHREAD PTHREAD "" "Include pthread support" "" ON) VP_OPTION(USE_XML2 XML2 "" "Include xml support" "" ON IF NOT WINRT) if(CMAKE_TOOLCHAIN_FILE AND I_AM_A_ROBOT) VP_OPTION(USE_OPENCV "MyOpenCV" QUIET "Include OpenCV support" "OpenCV_DIR;OpenCV_FOUND;OPENCV_FOUND" ON) else() VP_OPTION(USE_OPENCV "OpenCV;MyOpenCV" QUIET "Include OpenCV support" "OpenCV_DIR;OpenCV_FOUND;OPENCV_FOUND" ON) endif() VP_OPTION(USE_ZLIB "ZLIB;MyZLIB" "" "Include zlib support" "" ON IF NOT WINRT) VP_OPTION(USE_X11 X11 "" "Include X11 support" "" ON IF NOT WINRT) # The native FindGTK2.cmake doesn't consider libgobject-2.0 that is # requested by ViSP. That's why we use our FindMyGTK2.cmake VP_OPTION(USE_GTK2 MyGTK2 "" "Include gtk2 support" "" OFF IF NOT WINRT) VP_OPTION(USE_JPEG "JPEG;MyJPEG" "" "Include jpeg support" "" ON) VP_OPTION(USE_PNG "PNG;MyPNG" "" "Include png support" "" ON) VP_OPTION(USE_FFMPEG FFMPEG "" "Include ffmpeg support" "" OFF) # To control Pioneer mobile robots, under UNIX we need Aria, pthread, rt and dl 3rd party libraries VP_OPTION(USE_ARIA ARIA "" "Include aria support" "" ON IF NOT WINRT) #VP_OPTION(USE_RT RT "" "Include rt support" "" ON) #VP_OPTION(USE_DL DL "" "Include dl support" "" ON) # bar codes VP_OPTION(USE_ZBAR ZBAR "" "Include zbar support" "" ON IF NOT WINRT) VP_OPTION(USE_DMTX DMTX "" "Include dmtx support" "" ON IF NOT WINRT) VP_OPTION(USE_PCL PCL QUIET "Include Point Cloud Library support" "" ON IF USE_REALSENSE AND NOT WINRT) VP_OPTION(BUILD_ATIDAQ "" "" "Include atidaq-c support" "" ON IF USE_COMEDI AND NOT WINRT) # Find IsNaN (should be after USE_CPP11) VP_CHECK_PACKAGE(IsNaN) # Find IsInf (should be after USE_CPP11) VP_CHECK_PACKAGE(IsInf) # Find Round (should be after USE_CPP11) VP_CHECK_PACKAGE(Round) # Find Erfc VP_CHECK_PACKAGE(Erfc) # Find Strtof VP_CHECK_PACKAGE(Strtof) #---------------------------------------------------------------------- # For Dart server and tests # We use CDash set through CTestConfig.cmake file # Dashboards are sent to http://cdash.irisa.fr/CDash/index.php?project=ViSP #---------------------------------------------------------------------- if(BUILD_TESTS) enable_testing() mark_as_advanced(DART_ROOT) mark_as_advanced(BUILD_TESTING) endif() #---------------------------------------------------------------------- # Try to find doxygen for documentation generation # Use "make visp_doc" target to generate the documentation #---------------------------------------------------------------------- find_package(Doxygen) if(DOXYGEN_FOUND) set(VISP_HAVE_DOXYGEN "yes") # for header vpConfig.h ## we need latex for doxygen because of the formulas find_package(LATEX) if(NOT LATEX_COMPILER) message(STATUS "latex command LATEX_COMPILER not found but usually required. You will probably get warnings and user interaction on doxy run.") endif() if(NOT MAKEINDEX_COMPILER) message(STATUS "makeindex command MAKEINDEX_COMPILER not found but usually required.") endif() if(NOT DVIPS_CONVERTER) message(STATUS "dvips command DVIPS_CONVERTER not found but usually required.") endif() # set vars used in doxygen config file # - DOXYGEN_STRIP_FROM_INC_PATH corresponding to STRIP_FROM_INC_PATH in the doxy file set(DOXYGEN_STRIP_FROM_INC_PATH "") foreach(m ${VISP_MODULES_BUILD} ${VISP_MODULES_DISABLED_USER} ${VISP_MODULES_DISABLED_AUTO} ${VISP_MODULES_DISABLED_FORCE}) if(m MATCHES "^visp_") set(DOXYGEN_STRIP_FROM_INC_PATH "${DOXYGEN_STRIP_FROM_INC_PATH} \\ \n\t\t\t \"${VISP_MODULE_${m}_LOCATION}/include\"") endif() endforeach() # - DOXYGEN_IMAGE_PATH corresponding to IMAGE_PATH in the doxy file set(DOXYGEN_IMAGE_PATH "\"${VISP_SOURCE_DIR}/doc/image\"") if(VISP_CONTRIB_MODULES_PATH) foreach(contrib ${VISP_CONTRIB_MODULES_PATH}) set(image_path_ "${VISP_CONTRIB_MODULES_PATH}/doc/image") if(EXISTS ${image_path_}) set(DOXYGEN_IMAGE_PATH "${DOXYGEN_IMAGE_PATH} \\ \n\t\t\t \"${image_path_}\"") endif() endforeach() endif() # - DOXYGEN_SHOULD_SKIP_THIS var if (ENABLE_FULL_DOC) set(DOXYGEN_SHOULD_SKIP_THIS "") else() set(DOXYGEN_SHOULD_SKIP_THIS "DOXYGEN_SHOULD_SKIP_THIS") endif() configure_file(${VISP_SOURCE_DIR}/doc/config-doxygen.in ${VISP_DOC_DIR}/config-doxygen @ONLY ) # set vars used in mainpage.doc.in # - VISP_MAINPAGE_EXTENSION set(VISP_MAINPAGE_EXTENSION "") if(VISP_CONTRIB_MODULES_PATH) foreach(contrib ${VISP_CONTRIB_MODULES_PATH}) set(mainpage_ext_file_ "${contrib}/doc/mainpage_extension.doc") if(EXISTS ${mainpage_ext_file_}) file(READ ${mainpage_ext_file_} mainpage_ext_content_) set(VISP_MAINPAGE_EXTENSION "${VISP_MAINPAGE_EXTENSION}\n${mainpage_ext_content_}") endif() endforeach() endif() configure_file(${VISP_SOURCE_DIR}/doc/mainpage.doc.in ${VISP_DOC_DIR}/mainpage.doc @ONLY ) else() set(VISP_HAVE_DOXYGEN "no") # for header vpConfig.h endif() # ---------------------------------------------------------------------------- # Extra ViSP targets: uninstall, etc. # ---------------------------------------------------------------------------- include(cmake/VISPExtraTargets.cmake) # Ogre plugins and resources include(cmake/OgreTools.cmake) if(USE_OGRE) vp_set_ogre_media() elseif(CMAKE_TOOLCHAIN_FILE) vp_set_ogre_advanced_var() endif() # ---------------------------------------------------------------------------- # Check for system libs # ---------------------------------------------------------------------------- include(CheckLibraryExists) if(UNIX) # try to found -lm requested on some platforms to link with X11 find_library(M_LIBRARY NAMES m) mark_as_advanced(M_LIBRARY) if(M_LIBRARY) list(APPEND VISP_LINKER_LIBS ${M_LIBRARY}) endif() # try to found -lsocket -lnsl requested for vpNetwork and vpSickLDMRS find_library(SOCKET_LIBRARY NAMES socket) find_library(NSL_LIBRARY NAMES nsl) mark_as_advanced(SOCKET_LIBRARY NSL_LIBRARY) if (SOCKET_LIBRARY) list(APPEND VISP_LINKER_LIBS ${SOCKET_LIBRARY}) endif() if (NSL_LIBRARY) list(APPEND VISP_LINKER_LIBS ${NSL_LIBRARY}) endif() endif() #---------------------------------------------------------------------- # Add definitions #---------------------------------------------------------------------- # With Visual Studio 2005, Microsoft deprecates the standard C library, for # example fopen() and sprintf(), to non-portable functions fopen_s() and # sprintf_s(). These functions are considered by Microsoft more secure. This is # a worthwhile exercise ! The use of these deprecated functions causes a lot of # warnings. To suppress it, we add the _CRT_SECURE_NO_DEPRECATE preprocessor # definition if(WIN32 AND MSVC) add_definitions("-D_CRT_SECURE_NO_DEPRECATE") endif() #---------------------------------------------------------------------- # Use statically or dynamically linked CRT? # Default: dynamic #---------------------------------------------------------------------- if(MSVC) include(cmake/VISPCRTLinkage.cmake) endif(MSVC) #---------------------------------------------------------------------- # Configure the files that depend on the build or # installation usage. This is the case of: # vpConfig.h #---------------------------------------------------------------------- # case 1: when ViSP is build with make; files are used in #-------------- set(VISP_ROOT_DIR_DATA_CONFIGCMAKE "${VISP_BINARY_DIR}") set(VISP_SCENES_DIR ${VISP_ROOT_DIR_DATA_CONFIGCMAKE}/data/wireframe-simulator) set(VISP_ROBOT_ARMS_DIR ${VISP_ROOT_DIR_DATA_CONFIGCMAKE}/data/robot-simulator) # case 2: when ViSP is build with make install; files are used in #-------------- IF(UNIX) set(VISP_ROOT_DIR_DATA_CONFIGCMAKE "${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_DATAROOTDIR}/visp-${VISP_VERSION}") ELSE() set(VISP_ROOT_DIR_DATA_CONFIGCMAKE "${CMAKE_INSTALL_PREFIX}") ENDIF() list(APPEND VISP_SCENES_DIR ${VISP_ROOT_DIR_DATA_CONFIGCMAKE}/data/wireframe-simulator) list(APPEND VISP_ROBOT_ARMS_DIR ${VISP_ROOT_DIR_DATA_CONFIGCMAKE}/data/robot-simulator) # Only if resources.cfg created by hand, we change the path to resources.cfg in install/vpConfig.h if(VISP_INSTALL_DIR_OGRE_RESOURCES) list(APPEND VISP_HAVE_OGRE_RESOURCES_PATH "${VISP_ROOT_DIR_DATA_CONFIGCMAKE}/data/ogre-simulator") endif() # append to VISP_HAVE_OGRE_PLUGINS_PATH the path of the installed plugins.cfg file # to be able to use ViSP from build tree or install tree if(VISP_INSTALL_DIR_OGRE_RESOURCES) list(APPEND VISP_HAVE_OGRE_PLUGINS_PATH "${CMAKE_INSTALL_PREFIX}/${VISP_LIB_INSTALL_PATH}/visp/data/ogre-simulator") endif() #---------------------------------------------------------------------- # Create and install visp-config.1.gz man page #---------------------------------------------------------------------- if(UNIX) find_host_program(GZIP gzip) if(GZIP) file(MAKE_DIRECTORY ${VISP_BINARY_DIR}/doc/man/man1) add_custom_command( OUTPUT ${VISP_BINARY_DIR}/doc/man/man1/visp-config.1.gz COMMAND ${GZIP} --best -c ${CMAKE_CURRENT_SOURCE_DIR}/doc/man/man1/visp-config.1 > ${VISP_BINARY_DIR}/doc/man/man1/visp-config.1.gz DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/doc/man/man1/visp-config.1 ) add_custom_target(man ALL DEPENDS ${VISP_BINARY_DIR}/doc/man/man1/visp-config.1.gz ) install(FILES ${VISP_BINARY_DIR}/doc/man/man1/visp-config.1.gz DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/man/man1 PERMISSIONS OWNER_READ GROUP_READ WORLD_READ OWNER_WRITE COMPONENT dev ) endif() endif() #---------------------------------------------------------------------- # Add 3rd-party libraries #---------------------------------------------------------------------- include(cmake/VISP3rdParty.cmake) #----------------------------------------------------------------------------- # Add extra compilation flags #----------------------------------------------------------------------------- include(cmake/AddExtraCompilationFlags.cmake) # should be called after FindOpenMP #---------------------------------------------------------------------- # Modules #---------------------------------------------------------------------- include(cmake/VISPModule.cmake) # process subdirectories add_subdirectory(modules) #------------------------------------------------------------------------------- # specific things that need to be updated in vpConfig.h #------------------------------------------------------------------------------- VP_SET(VISP_HAVE_OPENMP TRUE IF USE_OPENMP) VP_SET(VISP_HAVE_OPENCV TRUE IF (BUILD_MODULE_visp_core AND USE_OPENCV)) VP_SET(VISP_HAVE_X11 TRUE IF (BUILD_MODULE_visp_core AND USE_X11)) VP_SET(VISP_HAVE_GTK TRUE IF (BUILD_MODULE_visp_core AND USE_GTK2)) VP_SET(VISP_HAVE_GDI TRUE IF (BUILD_MODULE_visp_core AND USE_GDI)) VP_SET(VISP_HAVE_D3D9 TRUE IF (BUILD_MODULE_visp_core AND USE_DIRECT3D)) VP_SET(VISP_HAVE_JPEG TRUE IF (BUILD_MODULE_visp_core AND USE_JPEG)) VP_SET(VISP_HAVE_PNG TRUE IF (BUILD_MODULE_visp_core AND USE_PNG)) VP_SET(VISP_HAVE_YARP TRUE IF (BUILD_MODULE_visp_core AND USE_YARP)) VP_SET(VISP_HAVE_GSL TRUE IF (BUILD_MODULE_visp_core AND USE_GSL)) VP_SET(VISP_HAVE_LAPACK_C TRUE IF (BUILD_MODULE_visp_core AND USE_LAPACK)) VP_SET(VISP_HAVE_PTHREAD TRUE IF (BUILD_MODULE_visp_core AND USE_PTHREAD)) VP_SET(VISP_HAVE_XML2 TRUE IF (BUILD_MODULE_visp_core AND USE_XML2)) VP_SET(VISP_HAVE_FFMPEG TRUE IF (BUILD_MODULE_visp_core AND USE_FFMPEG)) VP_SET(VISP_HAVE_PCL TRUE IF (BUILD_MODULE_visp_core AND USE_PCL)) VP_SET(VISP_HAVE_OGRE TRUE IF (BUILD_MODULE_visp_ar AND USE_OGRE)) VP_SET(VISP_HAVE_OIS TRUE IF (BUILD_MODULE_visp_ar AND USE_OIS)) VP_SET(VISP_HAVE_COIN3D TRUE IF (BUILD_MODULE_visp_ar AND USE_COIN3D)) VP_SET(VISP_HAVE_SOWIN TRUE IF (BUILD_MODULE_visp_ar AND USE_SOWIN)) VP_SET(VISP_HAVE_SOXT TRUE IF (BUILD_MODULE_visp_ar AND USE_SOXT)) VP_SET(VISP_HAVE_SOQT TRUE IF (BUILD_MODULE_visp_ar AND USE_SOQT)) VP_SET(VISP_HAVE_QT TRUE IF (BUILD_MODULE_visp_ar AND USE_QT)) VP_SET(VISP_HAVE_ZBAR TRUE IF (BUILD_MODULE_visp_detection AND USE_ZBAR)) VP_SET(VISP_HAVE_DMTX TRUE IF (BUILD_MODULE_visp_detection AND USE_DMTX)) VP_SET(VISP_HAVE_AFMA4 TRUE IF (BUILD_MODULE_visp_robot AND USE_AFMA4)) VP_SET(VISP_HAVE_AFMA6 TRUE IF (BUILD_MODULE_visp_robot AND USE_AFMA6)) VP_SET(VISP_HAVE_VIPER650 TRUE IF (BUILD_MODULE_visp_robot AND USE_VIPER650)) VP_SET(VISP_HAVE_VIPER850 TRUE IF (BUILD_MODULE_visp_robot AND USE_VIPER850)) VP_SET(VISP_HAVE_BICLOPS TRUE IF (BUILD_MODULE_visp_robot AND USE_BICLOPS)) VP_SET(VISP_HAVE_PTU46 TRUE IF (BUILD_MODULE_visp_robot AND USE_PTU46)) #VP_SET(VISP_HAVE_PIONEER TRUE IF (BUILD_MODULE_visp_robot AND USE_ARIA)) if(BUILD_MODULE_visp_robot AND USE_ARIA) if(UNIX AND USE_PTHREAD AND RT_FOUND AND DL_FOUND) set(VISP_HAVE_PIONEER TRUE) elseif(NOT UNIX) set(VISP_HAVE_PIONEER TRUE) endif() endif() #VP_SET(VISP_HAVE_VIRTUOSE TRUE IF (BUILD_MODULE_visp_robot AND USE_VIRTUOSE)) if(BUILD_MODULE_visp_robot AND USE_VIRTUOSE) if(UNIX AND USE_PTHREAD AND RT_FOUND AND DL_FOUND) set(VISP_HAVE_VIRTUOSE TRUE) elseif(NOT UNIX) set(VISP_HAVE_VIRTUOSE TRUE) endif() endif() VP_SET(VISP_HAVE_COIN3D TRUE IF (BUILD_MODULE_visp_robot AND USE_COIN3D)) VP_SET(VISP_HAVE_V4L2 TRUE IF (BUILD_MODULE_visp_sensor AND USE_V4L2)) VP_SET(VISP_HAVE_DC1394 TRUE IF (BUILD_MODULE_visp_sensor AND USE_DC1394)) VP_SET(VISP_HAVE_CMU1394 TRUE IF (BUILD_MODULE_visp_sensor AND USE_CMU1394)) VP_SET(VISP_HAVE_DIRECTSHOW TRUE IF (BUILD_MODULE_visp_sensor AND USE_DIRECTSHOW)) VP_SET(VISP_HAVE_LIBFREENECT TRUE IF (BUILD_MODULE_visp_sensor AND USE_LIBFREENECT)) VP_SET(VISP_HAVE_LIBUSB_1 TRUE IF (BUILD_MODULE_visp_sensor AND USE_LIBUSB_1)) VP_SET(VISP_HAVE_REALSENSE TRUE IF (BUILD_MODULE_visp_sensor AND USE_REALSENSE)) VP_SET(VISP_HAVE_FLYCAPTURE TRUE IF (BUILD_MODULE_visp_sensor AND USE_FLYCAPTURE)) VP_SET(VISP_HAVE_COMEDI TRUE IF (BUILD_MODULE_visp_sensor AND USE_COMEDI)) VP_SET(VISP_HAVE_ATIDAQ TRUE IF (BUILD_MODULE_visp_sensor AND BUILD_ATIDAQ)) VP_SET(VISP_BUILD_SHARED_LIBS TRUE IF BUILD_SHARED_LIBS) # for header vpConfig.h VP_SET(VISP_HAVE_DC1394_CAMERA_ENUMERATE TRUE IF (USE_DC1394 AND DC1394_CAMERA_ENUMERATE_FOUND)) # for header vpConfig.h VP_SET(VISP_HAVE_DC1394_FIND_CAMERAS TRUE IF (USE_DC1394 AND DC1394_FIND_CAMERAS_FOUND)) # for header vpConfig.h VP_SET(VISP_HAVE_D3D9 TRUE IF USE_DIRECT3D) # for header vpConfig.h VP_SET(VISP_HAVE_GTK TRUE IF USE_GTK2) # for header vpConfig.h VP_SET(VISP_HAVE_XRANDR TRUE IF XRANDR) # for header vpConfig.h # Check if libfreenect dependencies (ie libusb-1.0 and libpthread) are available if(USE_LIBFREENECT AND USE_LIBUSB_1 AND USE_PTHREAD) if(LIBFREENECT_FOUND AND LIBUSB_1_FOUND AND PTHREAD_FOUND) set(VISP_HAVE_LIBFREENECT_AND_DEPENDENCIES TRUE) # The material is found. Check if libfreenect is an old version include(CheckCXXSourceCompiles) set(CMAKE_REQUIRED_LIBRARIES ${LIBFREENECT_LIBRARIES} ${PTHREAD_LIBRARIES} ${LIBUSB_1_LIBRARIES}) set(CMAKE_REQUIRED_INCLUDES ${LIBFREENECT_INCLUDE_DIRS} ${PTHREAD_INCLUDE_DIRS} ${LIBUSB_1_INCLUDE_DIRS}) CHECK_CXX_SOURCE_COMPILES(" #include class vpMyKinect : public Freenect::FreenectDevice { }; int main() { Freenect::Freenect freenect; } " LIBFREENECT_IS_OLD_VERSION) #MESSAGE("LIBFREENECT_IS_OLD_VERSION: ${LIBFREENECT_IS_OLD_VERSION}") if(LIBFREENECT_IS_OLD_VERSION) set(VISP_HAVE_LIBFREENECT_OLD TRUE) # for header vpConfig.h else() set(VISP_HAVE_LIBFREENECT_OLD FALSE) # for header vpConfig.h endif() endif() endif() # check OpenCV nonfree modules and version if(USE_OPENCV) set(VISP_HAVE_OPENCV_VERSION "(${OpenCV_VERSION_MAJOR}<<16 | ${OpenCV_VERSION_MINOR}<<8 | ${OpenCV_VERSION_PATCH})") # for vpConfig.h if(OpenCV_VERSION) if(OpenCV_VERSION VERSION_LESS "2.4.0") message(STATUS "opencv nonfree module found") set(VISP_HAVE_OPENCV_NONFREE TRUE) # for header vpConfig.h elseif(OPENCV_NONFREE_FOUND) # OpenCV < 3.0.0 message(STATUS "opencv xfeatures2d module found") set(VISP_HAVE_OPENCV_NONFREE TRUE) # for header vpConfig.h elseif(OPENCV_XFEATURES2D_FOUND) # OpenCV >= 3.0.0 set(VISP_HAVE_OPENCV_XFEATURES2D TRUE) # for header vpConfig.h else() message(STATUS "opencv nonfree or xfeature2d module not found") endif() else() message(STATUS "opencv nonfree not found") set(VISP_HAVE_OPENCV_VERSION "(0)") # for vpConfig.h endif() endif() # coin and gui if(USE_SOWIN OR USE_SOXT OR (USE_SOQT AND USE_QT)) set(VISP_HAVE_COIN3D_AND_GUI TRUE) # for header vpConfig.h endif() # PCL and 3rd party advanced vars if(USE_PCL) include(cmake/PCLTools.cmake) endif() # Find isnan macro (C-style) VP_SET(VISP_HAVE_FUNC_ISNAN TRUE IF HAVE_FUNC_ISNAN) # for header vpConfig.h # Find std::isnan function (cmath) VP_SET(VISP_HAVE_FUNC_STD_ISNAN TRUE IF HAVE_FUNC_STD_ISNAN) # for header vpConfig.h # Find _isnan function for MSVC VP_SET(VISP_HAVE_FUNC__ISNAN TRUE IF HAVE_FUNC__ISNAN) # for header vpConfig.h # Find isinf macro (C-style) VP_SET(VISP_HAVE_FUNC_ISINF TRUE IF HAVE_FUNC_ISINF) # for header vpConfig.h # Find std::isinf function (cmath) VP_SET(VISP_HAVE_FUNC_STD_ISINF TRUE IF HAVE_FUNC_STD_ISINF) # for header vpConfig.h # Find _finite function for MSVC VP_SET(VISP_HAVE_FUNC__FINITE TRUE IF HAVE_FUNC__FINITE) # for header vpConfig.h # Find round function (math.h) VP_SET(VISP_HAVE_FUNC_ROUND TRUE IF HAVE_FUNC_ROUND) # for header vpConfig.h # Find std::round function (cmath) VP_SET(VISP_HAVE_FUNC_STD_ROUND TRUE IF HAVE_FUNC_STD_ROUND) # for header vpConfig.h # Find erfc function (math.h) VP_SET(VISP_HAVE_FUNC_ERFC TRUE IF HAVE_FUNC_ERFC) # for header vpConfig.h # Find std::erfc function (cmath) VP_SET(VISP_HAVE_FUNC_STD_ERFC TRUE IF HAVE_FUNC_STD_ERFC) # for header vpConfig.h # Find strtof function (stdlib.h) VP_SET(VISP_HAVE_FUNC_STRTOF TRUE IF HAVE_FUNC_STRTOF) # for header vpConfig.h VP_SET(VISP_BUILD_DEPRECATED_FUNCTIONS TRUE IF BUILD_DEPRECATED_FUNCTIONS) # for header vpConfig.h VP_SET(VISP_MOMENTS_COMBINE_MATRICES TRUE IF ENABLE_MOMENTS_COMBINE_MATRICES) # for header vpConfig.h VP_SET(VISP_USE_MSVC TRUE IF MSVC) # for header vpConfig.h VP_SET(VISP_HAVE_CPP11_COMPATIBILITY TRUE IF USE_CPP11) # for header vpConfig.h VP_SET(VISP_HAVE_BICLOPS_AND_GET_HOMED_STATE_FUNCTION TRUE IF (USE_BICLOPS AND BICLOPS_HAVE_GET_HOMED_STATE_FUNCTION)) # for header vpConfig.h # libraries for Pioneer mobile robots if(USE_ARIA AND UNIX) if(ARIA_FOUND AND USE_PTHREAD AND RT_FOUND AND DL_FOUND) set(VISP_HAVE_PIONEER TRUE) # for header vpConfig.h endif() elseif(USE_ARIA AND NOT UNIX) set(VISP_HAVE_PIONEER TRUE) # for header vpConfig.h endif() # ---------------------------------------------------------------------------- # Finalization: generate configuration-based files # ---------------------------------------------------------------------------- # Generate platform-dependent and configuration-dependent headers include(cmake/VISPGenerateHeaders.cmake) # Configure the file describing how to use ViSP. VISPConfig.cmake # is the main file configuring a CMake package. # . Exports build settings and dependencies for projects using ViSP as a # third party project. # . Create and install files for simple use of find_package(VISP) # by other cmakified "user" projects and libraries depending on ViSP. # (see "Mastering CMake", pp.72) # . To use ViSP in a third party project based on CMake: # find_package(VISP REQUIRED) # include_directories(${VISP_INCLUDE_DIRS}) # target_link_libraries( ${VISP_LIBRARIES}) include(cmake/VISPGenerateConfig.cmake) # Generate Info.plist for the IOS/OSX frameworks if(APPLE_FRAMEWORK) include(cmake/VISPGenerateInfoPlist.cmake) endif() #---------------------------------------------------------------------- # For Dart server and tests # We use CDash set through CTestConfig.cmake file # Dashboards are sent to http://cdash.irisa.fr/CDash/index.php?project=ViSP #---------------------------------------------------------------------- if(BUILD_TESTS) include(CTest) endif() #---------------------------------------------------------------------- # For CPack packaging tool #---------------------------------------------------------------------- option(BUILD_PACKAGE "Configure ViSP packaging" OFF) if(BUILD_PACKAGE) if(UNIX AND NOT APPLE AND NOT WIN32) # =linux option(BUILD_PACKAGE_DEBIAN "Build debian package" ON) option(BUILD_PACKAGE_RPM "Build rpm package" ON) endif() include(cmake/CPackConfig.cmake) endif(BUILD_PACKAGE) #---------------------------------------------------------------------- # Generate the package dependent visp-config shell script for projects which # are not using CMake: # Usage: # visp-config --cflags ... #---------------------------------------------------------------------- include(cmake/VISPGeneratePkgConfigScript.cmake) #---------------------------------------------------------------------- # Propagation in sub dirs to build demo, example, test, tutorial #---------------------------------------------------------------------- set(VISP_DIR ${PROJECT_BINARY_DIR}) mark_as_advanced(VISP_DIR) mark_as_advanced(VISP_INCLUDE_DIRS) if(BUILD_DEMOS) add_subdirectory(demo) vp_add_subdirectories(VISP_CONTRIB_MODULES_PATH demo) endif() if(BUILD_EXAMPLES) add_subdirectory(example) vp_add_subdirectories(VISP_CONTRIB_MODULES_PATH example) endif() if(BUILD_TUTORIALS) add_subdirectory(tutorial) vp_add_subdirectories(VISP_CONTRIB_MODULES_PATH tutorial) endif() # ---------------------------------------------------------------------------- # Update version of 3rd party for which info is missing # ---------------------------------------------------------------------------- if(USE_JPEG) if(NOT JPEG_LIB_VERSION) vp_parse_header("${JPEG_INCLUDE_DIR}/jpeglib.h" JPEG_VERSION_LINES JPEG_LIB_VERSION) endif() if(NOT JPEG_LIB_VERSION) get_filename_component(JPEG_LIB_DIR ${JPEG_LIBRARIES} PATH) string(REPLACE "lib" "include" JPEG_INC_DIR ${JPEG_LIB_DIR}) vp_parse_header("${JPEG_INC_DIR}/jconfig.h" JPEG_VERSION_LINES JPEG_LIB_VERSION) endif() endif() # ---------------------------------------------------------------------------- # Autodetect if we are in a GIT repository # ---------------------------------------------------------------------------- find_host_package(Git QUIET) if(NOT DEFINED VISP_VCSVERSION AND GIT_FOUND) execute_process(COMMAND "${GIT_EXECUTABLE}" describe --tags --always --dirty --match "[0-9].[0-9].[0-9]*" WORKING_DIRECTORY "${VISP_SOURCE_DIR}" OUTPUT_VARIABLE VISP_VCSVERSION RESULT_VARIABLE GIT_RESULT ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE ) if(NOT GIT_RESULT EQUAL 0) set(VISP_VCSVERSION "unknown") endif() elseif(NOT DEFINED VISP_VCSVERSION) # We don't have git: set(VISP_VCSVERSION "unknown") endif() # ---------------------------------------------------------------------------- # Summary: # ---------------------------------------------------------------------------- status("") status("==========================================================") status("General configuration information for ViSP ${VISP_VERSION}") status("") if(VISP_VCSVERSION) status(" Version control:" ${VISP_VCSVERSION}) endif() if(VISP_CONTRIB_MODULES_PATH) set(__dump_extra_header OFF) foreach(p ${VISP_CONTRIB_MODULES_PATH}) if(EXISTS ${p}) if(NOT __dump_extra_header) set(__dump_extra_header ON) status("") status(" Extra modules:") else() status("") endif() set(EXTRA_MODULES_VCSVERSION "unknown") if(GIT_FOUND) execute_process(COMMAND "${GIT_EXECUTABLE}" describe --tags --always --dirty --match "[0-9].[0-9].[0-9]*" WORKING_DIRECTORY "${p}" OUTPUT_VARIABLE EXTRA_MODULES_VCSVERSION RESULT_VARIABLE GIT_RESULT ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE ) if(NOT GIT_RESULT EQUAL 0) set(EXTRA_MODULES_VCSVERSION "unknown") endif() endif() status(" Location (extra):" ${p}) status(" Version control (extra):" ${EXTRA_MODULES_VCSVERSION}) endif() endforeach() unset(__dump_extra_header) endif() # ========================== build platform ========================== status("") status(" Platform:") if(NOT CMAKE_VERSION VERSION_LESS 2.8.11) string(TIMESTAMP TIMESTAMP "" UTC) if(TIMESTAMP) status(" Timestamp:" ${TIMESTAMP}) endif() endif() status(" Host:" ${CMAKE_HOST_SYSTEM_NAME} ${CMAKE_HOST_SYSTEM_VERSION} ${CMAKE_HOST_SYSTEM_PROCESSOR}) if(CMAKE_CROSSCOMPILING) status(" Target:" ${CMAKE_SYSTEM_NAME} ${CMAKE_SYSTEM_VERSION} ${CMAKE_SYSTEM_PROCESSOR}) endif() status(" CMake:" ${CMAKE_VERSION}) status(" CMake generator:" ${CMAKE_GENERATOR}) status(" CMake build tool:" ${CMAKE_BUILD_TOOL}) if(MSVC) status(" MSVC:" ${MSVC_VERSION}) endif() if(CMAKE_GENERATOR MATCHES Xcode) status(" Xcode:" ${XCODE_VERSION}) endif() if(NOT CMAKE_GENERATOR MATCHES "Xcode|Visual Studio") status(" Configuration:" ${CMAKE_BUILD_TYPE}) endif() # ========================== C/C++ options ========================== if(CMAKE_CXX_COMPILER_VERSION) set(VISP_COMPILER_STR "${CMAKE_CXX_COMPILER} ${CMAKE_CXX_COMPILER_ARG1} (ver ${CMAKE_CXX_COMPILER_VERSION})") elseif(CMAKE_COMPILER_IS_CLANGCXX) set(VISP_COMPILER_STR "${CMAKE_CXX_COMPILER} ${CMAKE_CXX_COMPILER_ARG1} (ver ${CMAKE_CLANG_REGEX_VERSION})") elseif(CMAKE_COMPILER_IS_GNUCXX) set(VISP_COMPILER_STR "${CMAKE_CXX_COMPILER} ${CMAKE_CXX_COMPILER_ARG1} (ver ${CMAKE_GCC_REGEX_VERSION})") else() set(VISP_COMPILER_STR "${CMAKE_CXX_COMPILER} ${CMAKE_CXX_COMPILER_ARG1}") endif() string(STRIP "${VISP_COMPILER_STR}" VISP_COMPILER_STR) status("") status(" C/C++:") status(" Built as dynamic libs?:" BUILD_SHARED_LIBS THEN "yes" ELSE "no") status(" C++ Compiler:" ${VISP_COMPILER_STR}) status(" C++ flags (Release):" ${CMAKE_CXX_FLAGS} ${CMAKE_CXX_FLAGS_RELEASE}) status(" C++ flags (Debug):" ${CMAKE_CXX_FLAGS} ${CMAKE_CXX_FLAGS_DEBUG}) status(" C Compiler:" ${CMAKE_C_COMPILER} ${CMAKE_C_COMPILER_ARG1}) status(" C flags (Release):" ${CMAKE_C_FLAGS} ${CMAKE_C_FLAGS_RELEASE}) status(" C flags (Debug):" ${CMAKE_C_FLAGS} ${CMAKE_C_FLAGS_DEBUG}) if(WIN32) status(" Linker flags (Release):" ${CMAKE_EXE_LINKER_FLAGS} ${CMAKE_EXE_LINKER_FLAGS_RELEASE}) status(" Linker flags (Debug):" ${CMAKE_EXE_LINKER_FLAGS} ${CMAKE_EXE_LINKER_FLAGS_DEBUG}) else() status(" Linker flags (Release):" ${CMAKE_SHARED_LINKER_FLAGS} ${CMAKE_SHARED_LINKER_FLAGS_RELEASE}) status(" Linker flags (Debug):" ${CMAKE_SHARED_LINKER_FLAGS} ${CMAKE_SHARED_LINKER_FLAGS_DEBUG}) endif() # ========================== ViSP modules ========================== status("") status(" ViSP modules:") string(REPLACE "visp_" "" VISP_MODULES_BUILD_ST "${VISP_MODULES_BUILD}") string(REPLACE "visp_" "" VISP_MODULES_DISABLED_USER_ST "${VISP_MODULES_DISABLED_USER}") string(REPLACE "visp_" "" VISP_MODULES_DISABLED_FORCE_ST "${VISP_MODULES_DISABLED_FORCE}") set(VISP_MODULES_DISABLED_AUTO_ST "") foreach(m ${VISP_MODULES_DISABLED_AUTO}) set(__mdeps "") foreach(d ${VISP_MODULE_${m}_DEPS}) if(d MATCHES "^visp_" AND NOT USE_${d}) list(APPEND __mdeps ${d}) endif() endforeach() if(__mdeps) list(APPEND VISP_MODULES_DISABLED_AUTO_ST "${m}(deps: ${__mdeps})") else() list(APPEND VISP_MODULES_DISABLED_AUTO_ST "${m}") endif() endforeach() string(REPLACE "visp_" "" VISP_MODULES_DISABLED_AUTO_ST "${VISP_MODULES_DISABLED_AUTO_ST}") status(" To be built:" VISP_MODULES_BUILD THEN ${VISP_MODULES_BUILD_ST} ELSE "-") status(" Disabled:" VISP_MODULES_DISABLED_USER THEN ${VISP_MODULES_DISABLED_USER_ST} ELSE "-") status(" Disabled by dependency:" VISP_MODULES_DISABLED_AUTO THEN ${VISP_MODULES_DISABLED_AUTO_ST} ELSE "-") status(" Unavailable:" VISP_MODULES_DISABLED_FORCE THEN ${VISP_MODULES_DISABLED_FORCE_ST} ELSE "-") # ================== Windows RT features ================== if(WIN32) status("") status(" Windows RT support:" WINRT THEN "yes" ELSE "no") if(WINRT) status(" Building for Microsoft platform: " ${CMAKE_SYSTEM_NAME}) status(" Building for architectures: " ${CMAKE_VS_EFFECTIVE_PLATFORMS}) status(" Building for version: " ${CMAKE_SYSTEM_VERSION}) endif() endif() # ============================ Options =========================== status("") status(" Build options: ") status(" Build deprecated:" BUILD_DEPRECATED_FUNCTIONS THEN "yes" ELSE "no") status(" Build with moment combine:" ENABLE_MOMENTS_COMBINE_MATRICES THEN "yes" ELSE "no") # ===================== Optional 3rd parties ===================== status("") status(" Mathematics: ") status(" Use GSL:" USE_GSL THEN "yes (ver ${GSL_VERSION})" ELSE "no") status(" Use Lapack/blas:" USE_LAPACK THEN "yes (ver ${LAPACK_C_VERSION})" ELSE "no") status("") status(" Simulator: ") status(" Ogre simulator: ") status(" \\- Use Ogre3D:" USE_OGRE THEN "yes" ELSE "no") status(" \\- Use OIS:" USE_OIS THEN "yes" ELSE "no") status(" Coin simulator: ") status(" \\- Use Coin3D:" USE_OGRE THEN "yes" ELSE "no") status(" \\- Use SoWin:" USE_SOWIN THEN "yes" ELSE "no") status(" \\- Use SoXt:" USE_SOXT THEN "yes" ELSE "no") status(" \\- Use SoQt:" USE_SOQT THEN "yes" ELSE "no") status(" \\- Use Qt4:" USE_QT AND DESIRED_QT_VERSION MATCHES 4 THEN "yes" ELSE "no") status(" \\- Use Qt3:" USE_QT AND DESIRED_QT_VERSION MATCHES 3 THEN "yes" ELSE "no") status("") status(" Media I/O: ") status(" Use JPEG:" USE_JPEG THEN "yes (ver ${JPEG_LIB_VERSION})" ELSE "no") status(" Use PNG:" USE_PNG THEN "yes (ver ${PNG_VERSION_STRING})" ELSE "no") status(" \\- Use ZLIB:" USE_ZLIB THEN "yes (ver ${ZLIB_VERSION_STRING})" ELSE "no") status(" Use FFMPEG:" USE_FFMPEG THEN "yes" ELSE "no") status(" Use OpenCV:" USE_OPENCV THEN "yes (ver ${OpenCV_VERSION})" ELSE "no") status("") status(" Real robots: ") status(" Use Afma4:" USE_AFMA4 THEN "yes" ELSE "no") status(" Use Afma6:" USE_AFMA6 THEN "yes" ELSE "no") status(" Use Viper650:" USE_VIPER850 THEN "yes" ELSE "no") status(" Use Viper850:" USE_VIPER850 THEN "yes" ELSE "no") status(" Use aria (Pioneer):" USE_ARIA THEN "yes" ELSE "no") status(" Use PTU46:" USE_PTU46 THEN "yes" ELSE "no") status(" Use Biclops PT:" USE_BICLOPS THEN "yes" ELSE "no") status("") status(" GUI: ") status(" Use X11:" USE_X11 THEN "yes" ELSE "no") status(" Use GTK:" USE_GTK2 THEN "yes (ver ${GTK2_VERSION})" ELSE "no") status(" Use OpenCV:" USE_OPENCV THEN "yes (ver ${OpenCV_VERSION})" ELSE "no") status(" Use GDI:" USE_GDI THEN "yes" ELSE "no") status(" Use Direct3D:" USE_DIRECT3D THEN "yes" ELSE "no") status("") status(" Cameras: ") status(" Use DC1394-2.x:" USE_DC1394 THEN "yes (ver ${DC1394_VERSION})" ELSE "no") status(" Use CMU 1394:" USE_CMU1394 THEN "yes" ELSE "no") status(" Use V4L2:" USE_V4L2 THEN "yes (ver ${V4L2_VERSION})" ELSE "no") status(" Use directshow:" USE_DIRECTSHOW THEN "yes" ELSE "no") status(" Use OpenCV:" USE_OPENCV THEN "yes (ver ${OpenCV_VERSION})" ELSE "no") status(" Use Flycapture:" USE_FLYCAPTURE THEN "yes (ver ${FLYCAPTURE_VERSION})" ELSE "no") status("") status(" RGB-D sensors: ") status(" Use Realsense:" USE_REALSENSE THEN "yes (ver ${REALSENSE_VERSION})" ELSE "no") status(" \\- Use PCL:" USE_PCL THEN "yes (ver ${PCL_VERSION})" ELSE "no") status(" \\- Use VTK:" VTK_FOUND THEN "yes (ver ${VTK_VERSION})" ELSE "no") status(" Use Kinect:" USE_LIBFREENECT AND USE_LIBUSB_1 AND USE_PTHREAD THEN "yes" ELSE "no") status(" \\- Use libfreenect:" USE_LIBFREENECT THEN "yes (ver ${LIBFREENECT_VERSION})" ELSE "no") status(" \\- Use libusb-1:" USE_LIBUSB_1 THEN "yes (ver ${LIBUSB_1_VERSION})" ELSE "no") status(" \\- Use pthread:" USE_PTHREAD THEN "yes" ELSE "no") status("") status(" F/T sensors: ") status(" Use atidaq:" BUILD_ATIDAQ THEN "yes (build)" ELSE "no") status(" Use comedi:" USE_COMEDI THEN "yes (ver ${COMEDI_VERSION})" ELSE "no") status("") status(" Detection: ") status(" Use zbar:" USE_ZBAR THEN "yes (ver ${ZBAR_VERSION})" ELSE "no") status(" Use dmtx:" USE_DMTX THEN "yes (ver ${DMTX_VERSION})" ELSE "no") status("") status(" Misc: ") status(" Use XML2:" USE_XML2 THEN "yes (ver ${XML2_VERSION_STRING})" ELSE "no") status("") status(" Optimization: ") status(" Use OpenMP:" USE_OPENMP THEN "yes" ELSE "no") status(" Use pthread:" USE_PTHREAD THEN "yes" ELSE "no") status(" Use cxx11:" USE_CPP11 THEN "yes" ELSE "no") # ========================== documentation ========================== status("") status(" Documentation: ") status(" Use doxygen:" DOXYGEN_FOUND THEN "yes" ELSE "no") # ========================== samples and tests ========================== status("") status(" Tests and samples:") status(" Tests:" BUILD_TESTS THEN "yes" ELSE "no") status(" Demos:" BUILD_DEMOS THEN "yes" ELSE "no") status(" Examples:" BUILD_EXAMPLES THEN "yes" ELSE "no") status(" Tutorials:" BUILD_TUTORIALS THEN "yes" ELSE "no") # ========================== auxiliary ========================== status("") status(" Install path:" "${CMAKE_INSTALL_PREFIX}") status("") status("==========================================================") vp_finalize_status() visp-3.0.1/CTestConfig.cmake000066400000000000000000000176731304511007300156560ustar00rootroot00000000000000############################################################################# # # This file is part of the ViSP software. # Copyright (C) 2005 - 2017 by Inria. All rights reserved. # # This software is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public License # ("GPL") version 2 as published by the Free Software Foundation. # See the file LICENSE.txt at the root directory of this source # distribution for additional information about the GNU GPL. # # For using ViSP with software that can not be combined with the GNU # GPL, please contact Inria about acquiring a ViSP Professional # Edition License. # # See http://visp.inria.fr for more information. # # This software was developed at: # Inria Rennes - Bretagne Atlantique # Campus Universitaire de Beaulieu # 35042 Rennes Cedex # France # # If you have questions regarding the use of this file, please contact # Inria at visp@inria.fr # # This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE # WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. # # Description: # CDash configuration. # # Authors: # Fabien Spindler # ############################################################################# set(CTEST_PROJECT_NAME "ViSP") set(CTEST_NIGHTLY_START_TIME "00:00:00 GMT") set(CTEST_DROP_METHOD "http") set(CTEST_DROP_SITE "cdash.inria.fr") set(CTEST_DROP_LOCATION "/CDash/submit.php?project=ViSP") set(CTEST_DROP_SITE_CDASH TRUE) #-------------------------------------------------------------------- # BUILNAME variable construction # This variable will be used to set the build name which will appear # on the ViSP dashboard http://cdash.irisa.fr/CDash/ #-------------------------------------------------------------------- # Start with the short system name, e.g. "Linux", "FreeBSD" or "Windows" if(BUILDNAME) set(BUILDNAME "${BUILDNAME}-${CMAKE_SYSTEM_NAME}") else(BUILDNAME) # To suppress the first space if BUILDNAME is not set set(BUILDNAME "${CMAKE_SYSTEM_NAME}") endif(BUILDNAME) # Add i386 or amd64 if(CMAKE_SIZEOF_VOID_P EQUAL 8) set(BUILDNAME "${BUILDNAME}-amd64") else() set(BUILDNAME "${BUILDNAME}-i386") endif() # Add the compiler name, e.g. "g++, msvc7..." if(MSVC70) set(BUILDNAME "${BUILDNAME}-msvc70") elseif(MSVC71) set(BUILDNAME "${BUILDNAME}-msvc71") elseif(MSVC80) set(BUILDNAME "${BUILDNAME}-msvc80") elseif(MSVC90) set(BUILDNAME "${BUILDNAME}-msvc90") elseif(MSVC10) set(BUILDNAME "${BUILDNAME}-msvc10") elseif(MSVC11) set(BUILDNAME "${BUILDNAME}-msvc11") elseif(MSVC12) set(BUILDNAME "${BUILDNAME}-msvc12") elseif(MSVC14) set(BUILDNAME "${BUILDNAME}-msvc14") elseif(MSVC15) set(BUILDNAME "${BUILDNAME}-msvc15") elseif(MSVC) set(BUILDNAME "${BUILDNAME}-msvc") elseif(BORLAND) set(BUILDNAME "${BUILDNAME}-borland") elseif(MINGW) set(BUILDNAME "${BUILDNAME}-mingw") else() # g++ set(BUILDNAME "${BUILDNAME}-${CMAKE_BASE_NAME}") endif() # Find out the version of gcc being used. if(CMAKE_COMPILER_IS_GNUCC) exec_program(${CMAKE_CXX_COMPILER} ARGS -dumpversion OUTPUT_VARIABLE COMPILER_VERSION ) #message("COMPILER_VERSION 1: ${COMPILER_VERSION}") string(REGEX REPLACE ".* ([0-9])\\.([0-9])\\.[0-9].*" "\\1\\2" COMPILER_VERSION ${COMPILER_VERSION}) #message("COMPILER_VERSION 2: ${COMPILER_VERSION}") set(BUILDNAME "${BUILDNAME}${COMPILER_VERSION}") endif(CMAKE_COMPILER_IS_GNUCC) # Add the type of library generation, e.g. "Dynamic or Static" if(BUILD_SHARED_LIBS) set(BUILDNAME "${BUILDNAME}-Dyn") else(BUILD_SHARED_LIBS) set(BUILDNAME "${BUILDNAME}-Sta") endif(BUILD_SHARED_LIBS) # Add the build type, e.g. "Debug, Release..." if(CMAKE_BUILD_TYPE) set(BUILDNAME "${BUILDNAME}-${CMAKE_BUILD_TYPE}") endif(CMAKE_BUILD_TYPE) #---- Robots ---- # Add specific Afma4 robots if(VISP_HAVE_AFMA4) set(BUILDNAME "${BUILDNAME}-Afma4") endif(VISP_HAVE_AFMA4) # Add specific Afma6 robots if(VISP_HAVE_AFMA6) set(BUILDNAME "${BUILDNAME}-Afma6") endif(VISP_HAVE_AFMA6) # Add specific Ptu46 robots if(VISP_HAVE_PTU46) set(BUILDNAME "${BUILDNAME}-Ptu46") endif(VISP_HAVE_PTU46) # Add specific Biclops robots if(VISP_HAVE_BICLOPS) set(BUILDNAME "${BUILDNAME}-Biclops") endif(VISP_HAVE_BICLOPS) # Add specific Pioneer robots if(VISP_HAVE_PIONEER) set(BUILDNAME "${BUILDNAME}-aria") endif() # Add specific Haption Virtuose haptic device if(VISP_HAVE_VIRTUOSE) set(BUILDNAME "${BUILDNAME}-virtuose") endif() #---- Framegrabers/Sensors ---- # Firewire dc1394-2.x if(VISP_HAVE_DC1394) set(BUILDNAME "${BUILDNAME}-dc1394") endif(VISP_HAVE_DC1394) # Video 4 linux 2 (V4L2) if(VISP_HAVE_V4L2) set(BUILDNAME "${BUILDNAME}-v4l2") endif(VISP_HAVE_V4L2) # Directshow if(VISP_HAVE_DIRECTSHOW) set(BUILDNAME "${BUILDNAME}-dshow") endif(VISP_HAVE_DIRECTSHOW) if(VISP_HAVE_CMU1394) set(BUILDNAME "${BUILDNAME}-CMU1394") endif(VISP_HAVE_CMU1394) if(VISP_HAVE_LIBFREENECT) set(BUILDNAME "${BUILDNAME}-freenect") endif() if(VISP_HAVE_REALSENSE) set(BUILDNAME "${BUILDNAME}-rs") endif() if(VISP_HAVE_PCL) set(BUILDNAME "${BUILDNAME}-pcl") endif() if(VISP_HAVE_LIBUSB_1) set(BUILDNAME "${BUILDNAME}-usb") endif() if(VISP_HAVE_FLYCAPTURE) set(BUILDNAME "${BUILDNAME}-flycap") endif() if(VISP_HAVE_COMEDI) set(BUILDNAME "${BUILDNAME}-comedi") endif() if(VISP_HAVE_ATI) set(BUILDNAME "${BUILDNAME}-ati") endif() #---- Video-devices ---- # X11 if(VISP_HAVE_X11) set(BUILDNAME "${BUILDNAME}-X11") endif(VISP_HAVE_X11) # GTK if(VISP_HAVE_GTK) set(BUILDNAME "${BUILDNAME}-gtk") endif(VISP_HAVE_GTK) # GDI (Windows Graphics Device Interface) if(VISP_HAVE_GDI) set(BUILDNAME "${BUILDNAME}-gdi") endif(VISP_HAVE_GDI) # D3D (Direct3D9) if(VISP_HAVE_D3D9) set(BUILDNAME "${BUILDNAME}-Direct3D") endif(VISP_HAVE_D3D9) # OpenCV if(VISP_HAVE_OPENCV) if(OpenCV_VERSION) if(OPENCV_XFEATURES2D_FOUND OR OPENCV_XFEATURES2D_FOUND) set(BUILDNAME "${BUILDNAME}-OpenCV_contrib${OpenCV_VERSION}") else() set(BUILDNAME "${BUILDNAME}-OpenCV${OpenCV_VERSION}") endif() else() set(BUILDNAME "${BUILDNAME}-OpenCV") endif() endif(VISP_HAVE_OPENCV) #---- Mathematics ---- # Lapack (Linear Algebra PACKage) if(VISP_HAVE_LAPACK_C) set(BUILDNAME "${BUILDNAME}-lapack") endif() # GSL (Gnu Scientific Library) if(VISP_HAVE_GSL) set(BUILDNAME "${BUILDNAME}-gsl") endif(VISP_HAVE_GSL) #---- Simulator ---- # Ogre if(VISP_HAVE_OGRE) set(BUILDNAME "${BUILDNAME}-Ogre") endif() if(VISP_HAVE_OIS) set(BUILDNAME "${BUILDNAME}-OIS") endif() # Coin if(VISP_HAVE_COIN3D) set(BUILDNAME "${BUILDNAME}-Coin") endif(VISP_HAVE_COIN3D) # SoQt if(VISP_HAVE_SOQT) set(BUILDNAME "${BUILDNAME}-SoQt") endif(VISP_HAVE_SOQT) # Qt if(VISP_HAVE_QT) set(BUILDNAME "${BUILDNAME}-Qt${DESIRED_QT_VERSION}") endif(VISP_HAVE_QT) # SoWin if(VISP_HAVE_SOWIN) set(BUILDNAME "${BUILDNAME}-SoWin") endif(VISP_HAVE_SOWIN) # SoXt if(VISP_HAVE_SOXT) set(BUILDNAME "${BUILDNAME}-SoXt") endif(VISP_HAVE_SOXT) #---- Images ---- if(VISP_HAVE_FFMPEG) set(BUILDNAME "${BUILDNAME}-ffmpeg") endif(VISP_HAVE_FFMPEG) if(VISP_HAVE_JPEG) set(BUILDNAME "${BUILDNAME}-jpeg") endif(VISP_HAVE_JPEG) if(VISP_HAVE_PNG) set(BUILDNAME "${BUILDNAME}-png") endif(VISP_HAVE_PNG) #if(VISP_HAVE_ZLIB) # set(BUILDNAME "${BUILDNAME}-zlib") #endif() #---- Misc ---- # XML if(VISP_HAVE_XML2) set(BUILDNAME "${BUILDNAME}-xml") endif() # PThread if(VISP_HAVE_PTHREAD) set(BUILDNAME "${BUILDNAME}-pthread") endif() # OpenMP if(VISP_HAVE_OPENMP) set(BUILDNAME "${BUILDNAME}-OpenMP") endif() if(VISP_HAVE_DMTX) set(BUILDNAME "${BUILDNAME}-dmtx") endif() if(VISP_HAVE_ZBAR) set(BUILDNAME "${BUILDNAME}-zbar") endif() #---- Special compiler flags ---- if(ACTIVATE_WARNING_STRICT_OVERFLOW) set(BUILDNAME "${BUILDNAME}-Wov") endif() if(ACTIVATE_WARNING_FLOAT_EQUAL) set(BUILDNAME "${BUILDNAME}-Weq") endif() if(USE_CPP11) set(BUILDNAME "${BUILDNAME}-c11") endif() if(ENABLE_MOMENTS_COMBINE_MATRICES) set(BUILDNAME "${BUILDNAME}-Moment") endif() #---- Suffix contrib ---- if(VISP_CONTRIB_MODULES_PATH) set(BUILDNAME "${BUILDNAME}-contrib") endif() #message("BUILDNAME=${BUILDNAME}") visp-3.0.1/ChangeLog000066400000000000000000001473551304511007300142570ustar00rootroot00000000000000 ViSP Visual Servoing Platform Resume of the change log Copyright (C) 2005 - 2017 by Inria. All rights reserved. https://visp.inria.fr ViSP 3.0.1 (released February 3rd, 2017) - New features . Compatibility with Microsoft Visual C++ 2017 (MSCV 15) . Compatibility with Universal Windows Platform (UWP); Windows Phone and Windows Store 8.x and 10.0 . Add vpMatrix, vpColVector, vpTranslationVector missing member functions to keep compat with ViSP 2.10.0 . New vpFlyCaptureGrabber class to capture images from PointGrey cameras (USB-3, firewire, GigE) . New vpVirtuose class, a wrapper over Haption Virtuose SDK that is provided with their haptic devices . New vpComedi and vpForceTorqueAtiSensor classes to get synchonous data from ATI F/T sensors . New vpRealSense class, a wrapper over RealSense SDK to capture data from SR300, F200, R200 RGB-depth sensors: + Acquisition of the color / depth / infrared streams + the associated point cloud + Possibility to set the stream parameters (resolution, FPS, ...) + Possibility to retrieve stream aligned (e.g. color stream aligned to depth) . New cross platform multi-threading capabilities with vpMutex and vpThread classes . Crosscompiling capabilities tested for Raspberry Pi target . Crosscompiling capabilities tested for Nao, Romeo and Pepper robots . OSX/iOS framework creation with support of OpenCV 3rd party . Introduce SSE2, SSE3 and SSSE3 optimizations . New meta-header visp3/visp.h that allows to include all ViSP headers in one line . New meta-header visp3/visp_.h that allows to include all the headers of a given module in one line . When using cxx11 support (USE_CPP11=ON), the corresponding compiler flag is propagated to the project that use ViSP as 3rd party . In vpServo introduce setCameraDoF() that allows to turn off the usage of some dof . Model-based tracker: + Introduce stereo as well as more generic multi camera tracking capabilities + New classes vpMbEdgeMultiTracker, vpMbKltMultiTracker, and vpMbEdgeKltMultiTracker for the hybrid version . Set vpRGBa images alpha channel default value to 255 . Allow to resize the display in order to display image that are larger than the screen resolution . Introduce new CMake ENABLE_FULL_DOC var: when turned ON allows to build doxygen documentation with all classes including internal ones . Build information available in ViSP-third-party.txt is now more complete, including OS, compiler, flags and 3rd party versions. This information is also embedded in visp_core library and could be obtained using vpIoTools::getBuildInformation() . Improve RANSAC pose estimation computation time (noticeable with large data) . vpKeyPoint class: + Support for little / big endian architecture when writing learning data into binary file + Add possibility to learn keypoints on cylinders + Add support of the new keypoint methods in OpenCV 3.1 and 3.2 + Add possibility to use enum type to select the keypoint . Add possibility to save extra information (time, reprojection error, ...) for the camera calibration process (e.g. in camera_calibration.cpp) . Improve image morphology operations for grayscale images . Add optimized image addition / subtraction for grayscale images . Add possibility to load recursive CAO model with identical filenames . Add possibility to retrieve clipped polygons for the model-based tracker . Improve vpPolygon::isInside() computation time . Add separable filter and switch between correlation / convolution in vpImageFilter . Add possibility to print vpImage class in the terminal . Add basic image resizing (nearest neighbor / bilinear / bicubic interpolation) - Tutorials . New tutorial: How to use multi-threading capabilities . New tutorial: Crosscompilation for Raspberry Pi from Ubuntu host . New tutorial: Installation from prebuilt packages for Arch Linux . New tutorial: Installation from prebuilt packages for ROS . New tutorial: Installation from prebuilt packages for iOS devices . New tutorial: Installation from source for iOS devices . New tutorial: How to create a basic iOS application that uses ViSP . New tutorial: Image processing on iOS . New tutorial: Cross-compilation for NAOqi OS from Ubuntu host . New tutorial: How to create an application that uses ViSP on NAOqi OS . New Tutorial: Markerless model-based tracking with stereo cameras . New Tutorial: How to display an image . New Tutorial: Pose estimation from QRcode . New Tutorial: Installation from source for Universal Windows Platform (UWP) - Bug fixed . [#37] How to build for ios? build failed . [#38] Wrong urls in visp/doc/tutorial-calibration.doc . [#39] Meta header files visp_.h not installed . [#40] vpKeyPoint fails to R/W database on big endian arch . [#42] Fails to build on Fedora 23 with Coin3-devel . [#44] Reshape issue with vpRowVector or vpColVector . [#47] Build issue in vpMath.h around vpMath::sign() . [#48] Fix vpPoseVector::getThetaUVector() to return the adequate vector . [#54] Error in vpHomography::projection() . [#59] Unable to use visp-config or visp-config.bat to build a project without CMake . [#68] Visual C++ 2010 unable to build modules\core\test\math\testMath.cpp . [#69] Unable to build ViSP under Windows without OpenCV 3rdparty . [#75] visp.pc pkgconfig file is corrupted by optimized and debug keywords . [#77] vpAROgre: wrong resources / plugins default path when used from ROS installation . [#82] Problem when comparing two vpImage (operator!=) . [#84] Problem with vpImageMorphology and CONNEXITY_8 and with border pixels . [#90] Fix potential build issue with isnan() and isinf() usage when cxx11 flags are used . [#91] vpMeLine::computeRhoTheta should throw exception . [#92] Is there any interface to resize display window? . [#95] setEllipsoidBadPointsPercentage in vpDot2 not completly being taken into account . [#104] vpMomentAlpha: Results are not repeatable . [#105] vpMomentAlpha: Question about symmetric judgement based on centered moments . [#106] Freeze when more than one GDI display is opened with mingw . [#109] Link errors with undefined reference to TIFF . [#111] vpColor doesn't work in mb-hybrid . [#112] vpPose: Possible ambiguity or misunderstanding in doxygen message . [#114] vpMomentAlpha: wrong abs() function using . [#116] Link errors related to openmp . [#117] vpMomentAlpha: out of range of [-Pi, Pi] in relative mode . [#118] vpKeyPoint: perhaps misleading in document . [#120] Build failed with clang/llvm . [#126] vpPolygon::operator=() does not copy everything. ---------------------------------------------- ViSP 3.0.0 (released December 18th, 2015) - New features . Compatibility with Windows 8.1 and 10 . Compatibility with Microsoft Visual C++ 2015 (MSCV 14) . Compatibility with Odroid XU4 . Source code migrates to GitHub: http://github.com/lagadic/visp . Introduce Travis continuous integration . New website: http://visp.inria.fr . Reorganize source in modules (core, vision, mbt, tt, …) with a library per module named libvisp_. Keep compat with previous releases. . Allow to link contributions to ViSP source code using VISP_CONTRIB_MODULES_PATH CMake var; see http://github.com/lagadic/visp_contrib . Model-based tracker: + New visibility tests based on the scanline rendering algorithm. + Improve Ogre3D visibility tests in order to use it in a probalistic approach via the setNbRayCastingAttemptsForVisibility() and setGoodNbRayCastingAttemptsRatio() functions. + Introduction of cylinder tracking with the model-based trackers using key points. + Improve the setPose() functionnality to use the given pose as a prediction of the key points position while using vpMbKltTracker and vpMbEdgeKltTracker. . Introduce vpArray2D template class that is inherited by all matrices and vectors. . vpKeyPoint class: + Full code compatibility with OpenCV 3.0. + Add support to the new Features introduce in OpenCV 3.0 and contrib module releases. + Add possibility to detect keypoints on an image pyramid with OpenCV 3.0. + Add possibility to change the image type (jpeg, png, ppm, pgm) when saving a learning file. + Add OpenMP support for Affine SIFT. + Add single matching filter (discard pairs of keypoints where multiple query keypoints are matched to the same train keypoints). + Add possibility to match train keypoints to query keypoints (could be useful when we learn only on one image, it allows to avoid to match background keypoints with train keypoints). + Optimize the FLANN matching by learning once the train descriptors instead of doing it at each call of the matching function (noticeable with large train descriptors). + Add possibility to use the FLANN matcher with binary descriptors. + Fix displayMatching function and fix small memory leak in loadLearningData. + Should be possible to read / write learning files in binary mode regardless of the endianness of the host (need to be tested on a real case). + Save learning files in XML mode with the full precision (according to the data type). . and a lot of improvements and fixes - Tutorials . New tutorial: Bridge over OpenCV . New tutorial: Installation from source with Homebrew . New tutorial: Installation from source on Windows 10 with Visual 2015 . Update all the installation tutorials since GitHub migration and modules introduction and make more explicit 3rd party installation . Update tutorial: Markerless 3D model-based tracking - Bug fixed . [18748] Ogre and wireframe resources not found after ViSP installation . [18823] vpMatrix::kernel method returns false result if matrix has less rows than columns . [18939] vpParseArgv::ARGV_CONSTANT segfault . [19312] Model-based tracker unable to initialize the number of cylinder or circle from cao file . [19326] segfault when using vpDisplayX::init(unsigned int, unsigned int, ...) . [19368] Invalid rotation parameters in vpSimulatorViper850::getPosition() . [#3] Issue when comparing two vpRGBa . [#5] Unable to get calibration matrix K when model with distorsion is used . [#6] Issue with vpMath::round() . [#18] Issues with vpColVector::median() + with assignment operator of vpRowVector + with vpRowVector::normalize() function ---------------------------------------------- ViSP 2.10.0 (released February 13th, 2015) - New features . New object detection and localisation capabilities that allow to initialize for instance the model-based tracker (see tutorial). . New bar code detectors that uses libdmtx and libzbar (see tutorial): + vpDetectorQRcode class allows to detect QR codes + vpDetectorDataMatrixCode class allows to detect data matrices . New vpDetectorFace class that allows face detection based on OpenCV Haar cascade classifier capabilities (see tutorial) . New vpConvert class for type conversions from OpenCV to ViSP. . Model-based tracker: + Introduction of 3D circles that project as ellipses. + In *.cao files comments are allowed on lines starting with # character. + New functions getError() and getRobustWeights() useful to compute tracking quality indicators. + Introduction of setLod() for "level of detail" that checks if the size of the feature is large enough to be considered by the tracker. + Based on the rank of the interaction matrix turn off automatically the degrees of freedom that cannot be estimated. Especially useful when considering 3D objets with only cylinders and circles. + and many other improvements and fixes. . Video reader and writer support mpeg4. ffmpeg is no more requested in vpVideoReader and vpVideoWriter. If ffmpeg is not detected or installed we use OpenCV. . New vpXmlParserHomogeneousMatrix class to read/write homogeneous transformations from/to xml files . Auto detection of visp-images-data Debian or Ubuntu package that allows testing without setting VISP_INPUT_IMAGE_PATH . If OpenCV version >= 2.4.8 use only OpenCV C++ api. Classes that use IplImages as input are deprecated. . Compat with RaspberryPi architecture . Compat with OpenCV 3.x . Compat with Yarp 2.3.63 . Compat with CMake 3.x . Compat with MinGW w64 from http://mingw-w64.sourceforge.net/ - Tutorials . New tutorial to show how to install ViSP from Ubuntu official packages. . New tutorial to show how to install ViSP on CentOS. . New tutorial to show how to install ViSP on openSUSE. . New tutorial to show how to install ViSP on Raspberry Pi. . New tutorial to show how to install ViSP on Windows 8.1 with msvc. . New tutorial to show how to install ViSP on Windows 8.1 with mingw. . New keypoints matching tutorial. . New bar code detection tutorial. . New face detection tutorial. . New object detection and localization tutorial . Update KLT tracker tutorial to show how to initialize the tracker online. . Update blob tracker tutorial to show how to use v4l2 live camera. . Update model-based tracking tutorial for advanced usage. - Bug fixed . [17112] Error after second call to track() in vpMbEdgeTracker . [17212] vp1394TwoGrabber: unable to select a camera from its guid . [17457] Cannot apply a secondary task to a 7dof robot . [17550] Build error with ffmpeg libraries . [17620] vpXmlParserCamera::save() doesn't save the camera name and image size . [17644] vpDisplayX doesn't work on RaspberryPi . [17659] ViSP+Ogre3D+boost: libboost_chrono cannot be opened . [17705] Bad endianness support in vpDisplayX . [17766] Compat with cmake 3.0.0: failed due to new CMP0026 policy . [17972] Ogre examples are not working with Fedora 20 . [17983] Unable to build ViSP when an older version was previously installed . [18258] Stack overflow when using vpDot under Windows . [16895] undefined reference to `vpGaussRand::gaussianDraw()' . [18406] Infinite loop in `vpPose::poseRansac()' . [18446] Bad KLT points detection in vpMbKtlTracker and vpMbEdgeKltTracker. . [18451] Infinite loop in vpSimulatorViper850::stopMotion() . [18452] Empty filename check in vpImageIo, vpVideoReader, vpVideoWriter is erroneous . [18459] Error when initializing KLT related trackers but no key point is deteted. . [18471] Bad fov computation in vpCameraParameters. . [18550] Linking error with Homebrew install of OpenCV on MacOS ---------------------------------------------- ViSP 2.9.0 (released February 18th, 2014) - New features . Introduction of a new template tracker using SSD (vpTemplateTrackerSSD classes) or ZNCC (vpTemplateTrackerZNCC classes). These trackers are able to estimate 2D transformations such as translation, SRT (scale, rotation and translation), affine and homography. A video illustrating this tracker capabilities is available on: http://team.inria.fr/lagadic/visp/computer-vision.html . In vpServo introduction of a new controller able to ensure continuous sequencing - Improvements . Add missing const to member functions and arguments passed by reference. . Introduction of a new option BUILD_WITH_STATIC_CRT that allows to set /MT (default) or /MD msvc build option . Compatibility with mingw, msvc11 (2012), msvc12 (2013) and open solaris 11 . Trace and debug can now be enabled/disabled using CMake ACTIVATE_DEBUG_TRACE option . Fix errors detected by Covery Scan static code analyser . Fix warnings detected with Gnu g++ -Weffc++ -Wshadow compiler flags . Improve a lot of classes - New examples . New example that shows how to use the template tracker . A lot of new sample code provided in tutorial folder - New tutorials . Installation from source on Linux Fedora . Image filtering . Template tracking . Homography estimation from points . Keypoint matching . How to boost your visual servo control law . Debug and trace printings - Bug fixed . [16263] libopencv_nonfree for Surf not detected by CMake. . [16307] vpVideoReader::setLastFrameIndex() doesn't work. . [16371] No convergence in SVDcmp . [16465] FTBFS on armhf, ppc, s390: Errors while running CTest . [16696] Build with OpenCV fails with msvc (/MT conflicts with /MD) . [16781] Unable to open .pgm saved with Matlab imwrite . [16823] Problems with camera calibration code . [16889] Link error with CMU 1394 on win x64 arch . [16895] undefined reference to `vpGaussRand::gaussianDraw()' . [16919] Unable to link with OpenCV 2.4.8 under Windows . [16924] MinGW: unable to build ViSP as a shared library . [16928] vpVideoReader is unable to find the number of the first image from a generic sequence of images ---------------------------------------------- ViSP 2.8.0 (released July 24th, 2013) - New features . New camera calibration tool: example/camera_calibration.cpp - Improvements . vpV4l2Grabber and vp1394CMUGrabber does no more require a call to open(I). . In vp1394CMUGrabber new getters/setters for the framerate, shutter, gain. It is now possible to change the settings in the acquisition loop. . An exceptions is throwned when moving-edges are not initialized (vpMeTracker, vpMeLine, vpMeEllipse) . In model-based trackers, improve face visibility test using Ogre ray tracing when faces are concave or not oriented counter clockwise. . Still in model-based trackers, add functionalities to use clipping planes. . ViSP can now be used with pkg-config . New fonctions in vp1394TwoGrabber to turn auto shutter and auto gain on. Also new getter for auto shutter and auto gain min/max values. . Support Visual Studio 2012 (MSVC11) . Introduce C++ visibility support as described here http://gcc.gnu.org/wiki/Visibility . Better support of image formats: *.tiff, *.jpeg, *.bmp, *.pbm, ... - Examples . Introduction of tutorials as minimalist line by line illustrated examples. - Bug fixed . [15404] Segfault in vpMbTracker derived classes around Coin SoDB::init() and SoDB::finish() usage . [15410] Robot wireframe simulator hangs . [15422] Build issues with ffmpeg 1.0.1 third party . [15475] Segfault in cv::Mat(BGR) to vpImage(grey) conversion . [15522] Visibility tests issues in Model-Based Tracker using Ogre3D . [15566] Bad mask orientation when using model-based tracker with cylinders . [15587] visp-config conflicts with multiarch support on Debian . [15623] Possible ViSP-2.7.0 bugs detected by cppcheck . [15644] crash with vpRobotWireFrameSimulator::initScene() . [15679] vpDot and vpDot2 copy operator are incomplete . [15680] Bad pixel to meter conversion in vpFeatureLuminance . [15697] False positive exception in vpDisplay when vpDisplay::close() is used . [15730] ViSP-third-party.txt is installed in a wrong location . [15896] Ogre Boost components miss Boost.Filesystem . [15895] ViSP does not compile on FreeBSD (amd64 / i386) ---------------------------------------------- ViSP 2.7.0 (released February 11th, 2013) - New features - New vpViper650 and vpRobotViper650 classes to interface Inria's new Adept Viper s650 robot. - New robot simulators; vpSimulatorCamera, vpSimulatorPioneer, vpSimulatorPioneerPan - New model-based tracker using KLT points: vpMbKltTracker. - New hybrid model-based tracker using moving edges and KLT points: vpMbEdgeKltTracker - Improvements - Add visp-config.1 man page. - To respect Debian guidelines, remove duplicate ABI version. Library name was set to libvisp.a or libvisp.so.2.7.0 rather than libvisp-2.a or libvisp-2.so.2.7.0 - Fix typos detected by lintian - Add support for multiarch. Multiarch is the ability for a library to be installed concurrently for differents architectures (such as i386 and amd64 for instance). In practice, the changes removes the assumption made that libraries are installed in $INSTALL_PREFIX/lib and binaries in $INSTALL_PREFIX/bin. - In vp1394TwoGrabber that allows to grab images from firewire cameras, cameras are powered off when the grabber is closed. - MinGW is now supported but since MinGW currently doesn't support tls __declspec(thread) with vpDisplayGDI it is possible to open only one display. - To better organise the code, robot simulators inherit from vpRobotSimulator class. Introduction of a new vpRobotWireFrameSimulator class as a base class of robot simulated using the wireframe display capabilities. - VRML loader (based on Coin3D) now reads transform nodes and hierarchical scenes. - If Ogre3D is used, model-based trackers use now RayCasting to improve faces visibility test. - Compatibility with iOS 6 and Fedora 18 - Examples - New model-based tracker examples to show how to use the KLT and hybrid tracker. See in example/tracking mbtEdgeKltTracking.cpp and mbtKltTracking.cpp - Bug fixed - [14646] ViSP doesn't build on Windows with MinGW - [14651] Build error arround vpMatrix::pseudoInverse() with OpenCV 2.1.0 - [14661] Build error when GDI is not detected or turned off - [14818] Build error when only GTK display device is available - [14862] Lagrange pose estimation cannot handle planar objects with points in plane oX=d or oY=d - [14863] vpPose::poseRansac() can fail during Lagrange pose estimation - [14993] Segfault in mbtTracker example when only the cube is tracked - [15049] In vpFeatureSegment, bad interaction matrix associated to alpha angle - [15110] Segfault in ffmpeg video reader - [15291] Under Windows, the end of an image is not displayed ---------------------------------------------- ViSP 2.6.2 (released July 15, 2012) - New features - New vp1394CMUGrabber class that allows firewire frame acquisition under Windows using CMU 1394 Digital Camera 3rd party library. Thanks to Lucas Lopes Lemos and Guillaume Laurent from FEMTO-ST, AS2M departement, Besancon, France for this contribution. - New vpPioneer, vpPioneerPan, vpRobotPioneer classes to control Pioneer mobile robots using Aria 3rd party library. - New vpFeatureSegment class to consider a segment as a visual servoing feature. Normalized and non normalized features are considered. - New vpFeatureMomentArea class to consider moment area as a visual feature. - Introduction of new functionalities in vpIoTools to parse text config files - Introduction of YARP to ViSP image converters in vpImageConvert - New vpClient and vpServer classes for a multiclients TCP network. - New vpPoseFeatures class for pose computation from any visual features. To be able to consider other user defined features the compiler should be compatible with C++ 11 standart. - Improvements - Introduce a new Denavit Hartenberg representation of the Biclops head in vpBiclops. - Compatibility with g++ 4.7 and OpenCV 2.3.1, 2.4.0, 2.4.1 - Remove warning detected with Visual C++ /Wall flag - Use CMake native package finder for zlib, png, jpeg, coin3d, gtk2 and doxygen 3rd party libraries detection. If detection fails, we use our own package finder. - Under Windows, changes done to add "d" suffix to the library name when build in debug (libvisp-2d.lib and libvisp-2d.dll). Install stage copy libvisp-2[d].lib in $CMAKE_INSTALL_PREFIX/lib and libvisp-2[d].dll in $CMAKE_INSTALL_PREFIX/bin. - Use OpenMP to optimize the execution of the moments computation. - Possibility to compute the covariance matrix during pose estimation (vpPose and vpPoseFeatures) and model-based tracking (vpMbTracker). - All initClick() now have a non-blocking equivalent as initFromPoints(), or initFromPose(), etc. - Most of the classes that had a display() method now have the equivalent display in static function (display's externalisation). - Ransac is now improved for either pose computation or point matching. - Examples - New example plot3d.cpp to show how to plot 3D curves - New example movePioneer.cpp to illustrate Pioneer velocity control. - New example sonarPioneerReader.cpp to illustrate Pioneer sonar device usage. - New examples servoPioneerPoint2DDepth.cpp, servoPioneerPoint2DDepthWithoutVpServo.cpp and servoPioneerPanSegment3D.cpp to show how to control the pioneer mobile robot by IBVS. - New example grab1394CMU.cpp to show how to acquire images with the CMU 1394 library. - Bug fixed - [13536] Division by zero in vpMeLine - [13548] ViSP-2.6.1 produces several warnings with g++ 4.4.3, a const is missing in vpMbtDistanceLine.h - [13575] ViSP sporadic segmentation fault in vpMeLine - [13625] trackMeNurbs example produce an assertion failed with MSVC: "list iterator not incrementable" - [13626] testXmlParser produre a Debug assertion failed with MSVC - [13678] Cannot build all the examples if no display capability is available - [13679] GDI not detected on Windows 7 (64 bit) with Visual C++ Express 2010 - [13689] Memory leaks in jpeg reader: vpImageIo::readJPEG() - [13690] Memory leaks in NURBS tracker - [13843] In vpPolygon, isInside() may produce a segfault and getArea() or getCenter() give bad results - [13850] visp-config.bat produces a non compatible msvc 2010 output format - [13955] vpBasicFeature::error() is not virtual - [13963] Under Windows, vpDisplay::getClickUp() doesn't work - [14081] Error in vpThetaUVector when angles are near 180 deg +/- epsilon - [14082] Segmentation fault in model based tracking when tracking only cylinders - [14474] Fix race condition in vpXmlParser. - [14481] testFeatureSegment can lead to an exception. - [14587] Ogre media directory OGRE_MEDIA_DIR not set in Ubuntu 12.04 - [14588] vpConfig.h doesn't match with the install directory ---------------------------------------------- ViSP 2.6.1 (released October 20th, 2011) - New features - Introduction of Lapack support used for the SVD decomposition in vpMatrix - Introduction of vpAROgre that enables augmented reality applications based on Ogre 3D. Some examples are provided in examples/ogre-simulator - Add cylinder's tracking in the model-based tracker. - Reintroduce OpenCV 2.0.0 support lost in ViSP 2.6.0 - Introduction of vpKinect, a wrapper of libfreenect to support the Kinect device - Introduction of vpMoment and vpFeatureMoment classes to be able to consider 2D image moments as visual feature in visual servoing - Improvements - For firewire cameras framegrabbing with vp1394TwoGrabber, it is now possible to select a specific camera with its GUID by using setCamera() - All the specific Xml parser (vpMbtXmlParser, vpXmlParserCamera) inherit now from vpXmlParser - Memory leaks suppression in vpWireFrameSimulator, vpMe, vpXmlParser, vpMbtXmlParser, vpXmlParserCamera, vpMbTracker, vpFeatureLuminance, vpRobotSimulator, vpFFMPEG, vpBSpline - It is now possible to grab images from an usb webcam with the vpV4l2Grabber class that is based on the video 4 linux 2 driver. - When it was possible without braking the backward compatibilty std::list was introduced instead of vpList. Some of the functions that use vpList are now deprecated. - Better detection of image or video file types when used in vpImageIo, vpVideoReader and vpVideoWriter - Build - Set the build type by default to release - Improve the usage of debug versus release third-party libraries - Deprecated - vpAdaptativeGain is deprecated. Use vpAdaptiveGain instead. - vp1394Grabber is deprecated. Use vp1394TwoGrabber instead. - Most of the methods that use vpList are deprecated. Use std::list instead - vpTwistMatrix deprecated in ViSP-1.6.0 was removed. - Examples: - New example grabOpenCV-2.cpp to show how to use the OpenCV cv::VideoCapture class. This example shows how to acquire an image with cv::VideoCapture, how to transform this image in ViSP format and how to display it. - New examples to illustrate the usage of the Ogre simulator through vpAROgre class. - New example to illustrate the usage of the Kinect through vpKinect class. - New examples to illustrate the usage of 2D image moments. - Bug fixed - [11110] On OSX vpDisplayOpenCV does not display images since OpenCV 2.1.0 - [11147] Coin not installed, cannot read VRML files - [11473] vpImageTools::flip() come out error when deal with vpImage with vpRGBa type - [11529] ViSP / OpenCV(2.2.0) incompatibility - [11563] segfault in vpVideoReader - [11617] selecting a subset of features is not taken into account in vpServo - [11916] Build issues with GTK2 on ubuntu 10.10 (fatal error: gdk-pixbuf/gdk-pixbuf.h) - [11924] svdNr fails on some matrices where svdGsl succeeds - [11942] Build issues with GSL on OSX due to 32/64 bits architecture - [11943] Build issues with libjpeg on OSX due to 32/64 bits architecture - [11944] Build issues with libpng on OSX due to 32/64 bits architecture - [11981] vpV4l2Grabber class based on video 4 linux 2 is not able to grab images from an usb webcam - [12329] Bad font problem when opening vpPlot example - [12334] Under windows, link errors when some 3rd party libs are not build in the same build configuration as ViSP - [12499] servoSimu4Points: World point disposition does not match camera - [12591] Seg fault when using setCleanPreviousImage() from vpImageSimulator - [12739] Problem initialising a vpMeEllipse - [13014] Bug in vpCalibration::calibVVSMulti() jacobian - [13015] vpFFMPEG compatibility issue with ffmpeg-0.8 release - [13449] "LIBJPEG_BUILD_TEST - Failed" message in CMake for Visual 2010 - [13467] CreateWindow windows API does not correctly register class. ---------------------------------------------- ViSP 2.6.0 (released September 23rd, 2010) - License: Change the open source license from QPL to GPL v2 - New Features - Introduction of a new wireframe simulator. See vpWireFrameSimulator class. - Introduction of a new model-based tracker that allows to track an object based on its 3D model. See vpMbEdgeTracker class. - New vpForceTwistMatrix class that allows to transfer a force/torque skew from one frame to another. - New vpVelocityTwistMatrix class that allows to transfer a velocity skew from one frame to an other. The vpTwistMatrix class that does the same work previously is from now deprecated. - New vpRobotCycab class to communicate with the Cycab car-like mobile robot at Inria. - New generic vpRobotSimulator class to create robot simulators. - New vpSimulatorViper850 class which simulates the viper850 robot. - New vpSimulatorAfma6 class which simulates the Afma 6dof robot. - New vpPlanarObjectDetector class to detect a planar surface based on the Ferns Classifier. - New vpSickLDMRS class, a UNIX driver to get measures from a Sick LD-MRS laser scanner. - New vpPlot class that was recoded to suppress the XPlotter dependency. This class aims real time drawing of 2D or 3D graphics under Linux, OSX and Windows. - Third party library dependencies - OpenCV 1.1 and 2.0 are no more supported. ViSP requires at least OpenCV 2.1. - libplotter is no longer required. - Itifg8 is no longer supported. - Improvements - Copy constructors were added to better support stl lists and vectors. - In firewire framegrabbing using vp1394TwoGrabber based on libdc1394-2.x, add possibility to change during the execution the shutter, the gain, the brightness, ... (see documentation for more details) . new setIsoTransmissionSpeed(), setAutoShutter() methods - In vpThetaUVector addition of &operator=() method to initialise all the angles to the same value - In vpHomogeneousMatrix addition of . eye() method to set the transformation as identity . extract(vpThetaUVector &) to extract the rotation as a Theta U vector - In vpRobotViper850 add openGripper() and closeGripper() functions to control the Schunk two fingers electric gripper (available only at Inria). - In vpRotationVector and vpTranslationVector introduction of set() method that allows initialization from 3 doubles - Documentation improvements - Deprecated . Some deprecated classes were removed: vpItifg8Grabber, vpEulerVector, vpSubPixel, vpRA . Deprecated functions since ViSP 2.4.4 where also removed - Examples: - New example calibrateTsai.cpp to show how to use the vpCalibration class to estimate the hand to eye transformation. - New examples to illustrate the usage of the new wire-frame simulators - Bug fixed - [9476] Memory leak in vpImageIo::readPNG() functions. - [9505] Problem with the DirectShow grabber : can't be initialised. - [9516] Problem in the getValue methods in the vpImage class. - [9746] The displayPoint method of the vpDisplayOpenCV class doesn't work. - [10472] Bug in the visual features: can't select the good feature. - [10647] Delay in displaying image overlays - [10687] The GDI display is not detected with Visual Studio 2010 - [10696] [CMake] VISP_DIR path conflict - [10697] CMake standard output vars - [10719] Compilation error in vpPlot - [10723] Compilation error in vpFFMPEG.cpp - [10748] PThread and Win32 Conflict - [10928] vpPlane: rayIntersection from 2 points - [10985] In vpPlot, 2D curve plotting starts with point (0,0) and not with the first specified point. ---------------------------------------------- ViSP 2.4.4 (released January 8th, 2010) - Features removed - vpMePath has been removed. ---------------------------------------------- ViSP 2.4.4-rc1 (released December 21th, 2009) - New Features - During CMake configuration, when a third-party library is detected, it is now possible to turn off the default usage of the library. - Warning during the build if deprecated functions are used - For the Irisa's Afma6 robot addition of a new vacuum tool (vpAfma6). - New vpImagePoint class for image point coordinates. - New vpPlot class that enables real time drawing of graphics under Unix. - Ability to use other colors than the predefined ones with the rewriting of the vpColor class and modifications in display functionalities. - New vpKalmanFilter and vpLinearKalmanFilterInstantiation classes with velocity and acceleration state models. - New vpFeatureTranslation: ctc* - New USE_COIN_SIMULATOR option during CMake configuration to enable or disable simulation capabilities based on Coin3D suite. - New vpViper, vpViper850 and vpRobotViper850 classes to provide an interface for Inria's Adept Viper 850 robot. - New vpBSpline and vpNurbs classes to manipulate 2D BSpline and 2D Nurbs (Non Uniform Rational BSpline). - New vpMeNurbs class to track object edges. - New vpFFMPEG class to interface the FFmpeg library. - New vpVideoReader and vpVideoWriter classes to manipulate easily the video files and the image sequences. - Improvements - In firewire framegrabbing using vp1394TwoGrabber based on libdc1394-2.x, bus reset can be switched off in the constructor. There are also improvements in the acquisition using acquire(vpImage &I, ...) by removing the color coding format request and by support of the RAW8 and RAW16 video format. New dequeue() functions were also introduced to make possible to separate the ring buffer dequeuing and enqueuing. This behavior is for example useful when image processing needs to be introduced between the dequeuing and enqueuing stages. It may also useful to synchronise the image acquisition with an other sensor. New setPanControl() function was introduced to set the PAN register 0x884 to control single or multiple image transmission from stereo vision cameras like the PointGrey Bumblebee. - vpDot2: The tracking is restarted in vpDot2::track() if a dot is found but is not valid. - In vpDisplay, new getKeyboardEvent() functionality to handle key events and new getPointerMotionEvent() functionality to handle mouse pointer motion event. - Optimization of the vpMatrix class. - Examples: - New examples in examples/servo-viper850 to show how to use the linear Kalman filter to compensate the tracking error due to the motion of a target. - New examples in examples/servo-viper850 to show how to use the secondary task to avoid joint limits. - New plotting example in example/tools/plot.cpp - In grab1394Two.cpp example, addition of [-r] new option to reset the bus. - New examples to show how to build a 3D visual servoing without using the vpServo and vpFeature classes: servoSimu3D_cMcd_CamVelocityWithoutVpServo.cpp and servoSimu3D_cdMc_CamVelocityWithoutVpServo.cpp - Bug fixed - [7638] Memory leak in all vpFeature... classes was reopened - [7888] vpV4l2Grabber cannot acquire an image from an analog camera on Ubuntu 8.04 Hardy Heron - [7994] vpMeLine : initialization problem for horizontal lines - [8001] Coin and SoQt are not detected during CMake configuration under Fedora 10 - [8032] Link error whith GSL while compiling HelloWorld.cpp on OSX - [8225] Bug in the multiplication of a twist matrix (6x6) by a matrix (6xn) - [8248] Compilation error under Windows MSCV8 if deprecated functions are not build - [8249] Compilation error under Windows MSCV8 when building ViSP as a shared library (DLL) - [8257] Bug in vp1394TwoGrabber::resetBus() - [8259] Segfault in vpDisplayX - [8389] vpKltOpencv : Bug in the copy constructor - [8493] Problem to build ViSP as a dynamic library under windows (Visual C++) - [8495] Segmentation fault during the execution of the example grabDirectShow - [8831] Possible bug when extracting axis/angle from theta/u vector ---------------------------------------------- ViSP 2.4.3 (released April 10th, 2009) - New Features - Add vpFeaturePointPolar corresponding the a 2D image point with polar coordinates visual feature. - Add vpFeatureTranslation for cto (camera to object translation feature) - Add vpDisplay::setWindowPosition() functionality - Bug fixed - [7281] Segfault when displaying a vpCylinder. - [7308] Rotation vector not initialized to zero by the default constructor - [7309] visp-config --cflags produces a bad output - [7342] Bug in vpRobotAfma6::setVelocity(vpRobot::CAMERA_FRAME, v) - [7494] Division by 0 in vpHomography - [7424] Coin3D version 3 not supported under Windows - [7613] vpSimulator::getInternalImage() function yields to an infinite loop. - [7607] vpDisplayGTK bad window positionning - [7638] Memory leak in all vpFeature... classes ---------------------------------------------- ViSP 2.4.3-rc2 (released January 29th, 2009) - Deprecated - Creation of a deprecated section in the online documentation that gives the list of classes or member function that are deprecated - vpOSXcfoxGrabber was removed, since the C+Fox third party library available at http://cfox.sourceforge.net/ was not updated since 2005. - vpIcCompGrabber was removed, since it uses a home made wrapper based on itifg-7.2.1 driver which is not maintained yet - Testing - Use of CDash insteed of Dart2. Dashboards are sent to http://cdash.irisa.fr/CDash/index.php?project=ViSP - Platform compatibility - Compatibility with g++ 4.3.0 coming with fedora 9 - New Features - Add visp-config.bat under Windows to get the list of include dirs, library dirs and libraries ViSP depends on. This may help users to build a Visual Studio project from scratch and where ViSP is used as a third party project - vpFeatureThetaU: Add cRcd feature, with ThetaU corresponding to the rotation the camera has to achieve to move from current frame to the desired one. - vpOpenCVGrabber: New framegrabber based on OpenCV third party library (useful for USB cameras). - vp1394TwoGrabber: Get the timestamp associated to the grabbed image. - vpV4l2Grabber: Get the timestamp associated to the grabbed image. - vpRobotAfma6 and vpAfma6: Modifications to be compatible with the new low level Adept controller provided by Cerebellum Automation. - vpRobotAfma4 and vpAfma4: Modifications to be compatible with the new low level Adept controller provided by Cerebellum Automation. New vpServolens class to control the Servolens lens attached to the camera fixed on the Afma4 end-effector. - Examples: - New examples in example/manual described in ViSP guide under preparation. - example/servo-simu/servoSimu3DCamVelocity2.cpp - Documentation - Creation of a deprecated section. - Classes are now grouped in doxygen modules to help learning ViSP. - Introduction of new sample examples in the online documentation - Bug fixed - [5370] DirectShow and Visual Studio 9 2008 Express - [5371] Warnings on Visual Studio 9 2008 - [5375] Compilation error in calibrate2dGrid.cpp - [5398] display cylinder - [5438] window sizes with Coin - [5496] Compilation error in example/framegrabber/grab1394.cpp - [5508] Bug in vpImageConvert::YUV420ToRGB - [5527] Bug in vpImageTools::changeLUT() - [5539] Unhandle exception with multi vpDisplayGDI / D3D instances - [5596] Multiplying a vpRotationMatrix with a vpColVector ? - [5642] warning in vphomographyvvs.cpp with Visual C++ 2003 .Net - [5993] vpImage BI - [6330] Segfault in vpSimulator with Coin + SoXt - [6336] DLT Homography on 4 points - [6484] Bug in vpCalibration::calibrationTsai for eye-to-hand calibration - [6590] vpDisplayGDI cannot handle numerous displays (windows) - [6619] Problem vpMeLine : compute of delta - [6743] Bug in vpDisplayOpenCV::displayRectangle() - [6744] Bug in vpDisplayOpenCV - [6962] vpMeLine : problem of tracking - [7034] vpMeLine : Bug when a strip is tracked - [7126] problem with vpMatrix::eigenValuesByLU() ---------------------------------------------- ViSP 2.4.2 (released March 27th, 2008) - New classes - vpCalibration : calibration toolkit for intrinsic and extrinsic parameters of perspective camera. - vpXmlParserCamera : Parser xml to read and save camera parameters from vpCameraParameters class. - vpHinkley : Hinkley's cumulative sum test computation. - vpMePath : Tracking of a white curve by using line and parabola tracker. - vpKeyboard : Gets a key from the keyboard without waiting for the enter key. - vpParallelPort : Parallel port management under unix. - vpRingLight : Irisa's ring light controller. - vpKltOpencv : Interface for the KLT (Kanade-Lucas-Tomasi) feature tracker implemented with opencv. - New Features - Bug fix and improvement - vpCameraParameters : support for radial distortion camera model. - vpAfma6 : Add a getCameraParameters functionnality - vpSimulator : either SoWin or SoQt or SoXt is needed to use vpSimulator class. - vpDot: setMaxDotSize(double percentage) replace setNbMaxPoint(double nb) to be less image size dependent. The maximal dot size is set by default to 0.25% (quarter image size). setGrayLevelPrecision(double grayLevelPrecision) has been added for a better management of gray dots detection. - vpDot2: Changes in searchDotsInArea() : The algorithm search now in the bounding boxes of the bad dots. Bug fixed : we could fall in an infinite loop. Split accuracy private variable into grayLevelPrecision and sizePrecision. The gray level min and max are well calculated for white and black dots. Add setEllipsoidShapePrecision() to turn on/off and modify the test related of the geometry of the shape - vpDisplayX : better management of endianness - vpDisplayGTK, vpDisplayGDI, vpDisplayD3D, vpDisplayX : To actually display drawings on the screen, a vpDisplay::flush(I) is needed. Use it with parsimony : it is time consuming. - vpDisplayGTK, vpDisplayGDI, vpDisplayD3D : The behavior of the following methods change to be similar to vpDisplayX: . getClick(..., button) : The button used to click is now an output . getClickUp(..., button) : The button used to click is now an output Moreover, in vpDisplayGDI, vpDisplayD3D middle button is now managed - vpDisplayGTK, vpDisplayGDI, vpDisplayD3D : The usage of display->init(vpImage, int, int); returned a segmentation fault : bug fixed - vpDisplayD3D : we couldn't re-use a display after the call of the function close(vpImage). We had a black image : bug fixed. - vpDisplay : changes in displayRectangle():an option parameter fill has been had to precise if the displayed rectangle is filled or not. - vpColor : Add orange color. - vpServo : To fix bug #3528 you should explicitly call vpServo::kill() in your programs. Otherwise an exception vpServoException::notKilledProperly is launched by vpServo::~vpServo() destructor. - vpMatrix : Change Infinity Norm and Euclidian Norm formula to match with the standard matrix norms definitions. Change determinant formula for 3x3 matrices to match with the standard determinant definition. - vpImageConvert : Add IplImage to vpImage and vpImage to IplImage conversion tool. Add MONO16 to grey (MONO8) conversion tool. - vp1394TwoGrabber : Supports libdc1394-2.0.0-rc7 and libdc1394-2.0.1 MONO16 color coding is supported - Testing and examples: - example/calibration/calibrate2dGrid.cpp was added - example/tracking/trackKltOpencv.cpp was added - example/light/ringLight.cpp was added - example/tools/parallelPort.cpp was added - test/video-device/testClick.cpp was added - test/video-device/testVideoDevice.cpp was added - test/visual-feature/testFeature.cpp was added - test/image/testCreateSubImage.cpp was added - test/camera/testCameraParametersConversion.cpp was added - Documentation improvement - vpRobust::MEstimator() - vpRobotAfma6: example usage of getPosition() was updated - vpDisplayGDI is included in the doxygen documentation ---------------------------------------------- ViSP 2.4.1 (released May 16th, 2007) - New classes - vpRect class for rectangle manipulations, display - vpHistogram,vpHistogramPeak and vpHistogramValey classes to handle gray level image histogram - vpSubPixel for sub-pixel manipulations - vpMouseButton for mouse click identification - New Features - MinGW supported - ViSP as a third party library in an other project. It is now possible to use ViSP as a third party project without installing ViSP by make install. ViSP can now be used directly from the build dir, or from the install dir, or from a package (NSIS, ...) - vpRobotCamera It is now possible to add a sampling time so that the behavior of this simulated camera is quite realistic. This sampling time is set by default to 40 ms. - vpExponentialMap A sampling time was introduced. - Bug fix and improvement - vpImage: getWidth() and getHeight() replace getCols() and getRows() which are now obsolete. - More restrictive types in vpImage, vpDisplay..., and vp...Grabber classes: const are added, unsigned int replace int for pixel manipulations and image or display size. - In vpDisplay classes: . vpMouseButton::vpMouseButtonType was introduced to handle mouse clicks . vpColor::vpColorType was introduced to handle colors to display - Simulator functionality based on Coin usage is now available under windows. It allows the use of vpSimulator class under this platform. - Compatibility with Windows platform. - Reference documentation improvement - cfox and std namespace were removed. To use cout you need to call std::cout, std::endl, std::cin ... ---------------------------------------------- ViSP 2.4.0 (released February 6th, 2007) - New Feature - add new framegrabber interface for itifg8 driver from Coreco Imaging Technology (http://sourceforge.net/projects/itifg) Tested with AM-STD COMP framegrabber board on 2.4 and 2.6 linux kernel (see vpItifg8Grabber). - add new framegrabber interface and test for firewire 1394 cameras using libdc1394-2.x. Need a newer version than libdc1394-2.0.0-rc4. Tested with the svn version of libdc1394-2 and Marlin F033C and F131B cameras (see vp1394TwoGrabber). Format 7 is supported in vp1394TwoGrabber. vp1394Grabber will be obsolete soon. - Bug fix and improvement - tests and examples - Video For Linux Two grabber (see vpV4l2Grabber) - memory leaks suppression - works fully under windows - doxygen documentation ---------------------------------------------- ViSP 2.2.0 (released August 25th, 2006) - Build - To increase the code portability, especially under windows), all the build process is now based on CMake (see http://www.cmake.org). - Supported platforms: Linux, Mac OSX, SunOS: g++ 2.95.3, 2.96, 3.3.x, 3.4.x, 4.1.0) Windows: MSVC7 (2003.NET), MSVC8 (2005) - Suppression of autotools support (configure) - Allows shared library building (.so and .dll) - New Feature - add control for Traclabs biclops pan-tilt head - add control for Directed Perception ptu-46 pan-tilt head - add vpDisplayGTK display under Windows - add vpDirectShowGrabber framegrabber under Windows - add vpDisplayGDI display under windows - Bug fix and improvement - vp1394Grabber settings (format, mode, framerate, shutter, gain) - vpDot (Moment computation) - some fixes in vpDisplayGTK ---------------------------------------------- ViSP 2.1.1 (released January 6th, 2006) - New examples - create an example directory - add vpDotExample.cpp - add vpDot2Example.cpp - add vpPoseExample.cpp - add 2D0.5.VisualServoingSimulation.cpp - New Feature - add this ChangleLog file - add a vpDisplayGTK class with the GTK2+ window system - new member function in vpDisplay (_uv) - add function getInteractionMatrix() in vpGenericFeature - Specification modifications - change the vpDot and vpDot2 specifications - supress demo directory - Bug fix and improvement - add a runtime warning when vpGenericFeature is not correctly used - comment in english in vpDisplayX - suppress a trace in vpPoseVirtualVisualServoing.cpp - directory.mk : add -p option to mkdir - improve XP compatibility - in vp1394Grabber, latency and memory leaks suppression - WWW - add an image sequence to download on the www site cube.tar.gz --------------------------------------- ViSP 2.1.0 (released October, 24th 2005) visp-3.0.1/INSTALL.txt000066400000000000000000000035001304511007300143330ustar00rootroot00000000000000 ViSP Visual Servoing Platform Copyright (C) 2005 - 2017 by Inria. All rights reserved. https://visp.inria.fr INSTALL howto for the ViSP library QUICKINSTALL: > get ViSP source > install CMake (see http://www.cmake.org) > cmake . > make > make install The make install step is needed if you want to use ViSP in your own projects. To do the installation, you don't need to be root. Building ViSP with CMake ------------------------ Prerequsits: (1) Install newest cmake release from http://www.cmake.org (2) checkout/install ViSP source code. (3) configure run cmake to change options and to generate makefiles. example for a build on Linux: cd to source directory of ViSP > cd ViSP To configure and generate makefiles: On Linux: > ccmake . (mind the 'dot') See the bottom line for usage instructions, in particular: - press 'c', then modify options as required and press 'c' again to configure - finally press 'g' to generate Makefiles On Win32: > CMakeSetup.exe The GUI is self-explaining. Note: You can also use > cmake . directly if you prefer command line instead of graphical interface. (4) compile: > make (5) install: > make install Copy headers in ${CMAKE_INSTALL_PREFIX}/include Copy library in ${CMAKE_INSTALL_PREFIX}/lib Copy visp-config shell script in ${CMAKE_INSTALL_PREFIX}/bin (6) uninstall: > make uninstall Dual from install. Remove headers in ${CMAKE_INSTALL_PREFIX}/include Remove library and cmake files in ${CMAKE_INSTALL_PREFIX}/lib Remove visp-config shell script in ${CMAKE_INSTALL_PREFIX}/bin (7) clean: > make clean The "make clean" target will remove files generated by the compiler and linker. (8) documentation > make visp_doc Generate doxygen html documentation in doc/html. See README.txt for further information. visp-3.0.1/LICENSE.txt000066400000000000000000000431331304511007300143150ustar00rootroot00000000000000 GNU GENERAL PUBLIC LICENSE Version 2, June 1991 Copyright (C) 1989, 1991 Free Software Foundation, Inc. 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. Preamble The licenses for most software are designed to take away your freedom to share and change it. By contrast, the GNU General Public License is intended to guarantee your freedom to share and change free software--to make sure the software is free for all its users. This General Public License applies to most of the Free Software Foundation's software and to any other program whose authors commit to using it. (Some other Free Software Foundation software is covered by the GNU Library General Public License instead.) You can apply it to your programs, too. When we speak of free software, we are referring to freedom, not price. Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for this service if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs; and that you know you can do these things. To protect your rights, we need to make restrictions that forbid anyone to deny you these rights or to ask you to surrender the rights. These restrictions translate to certain responsibilities for you if you distribute copies of the software, or if you modify it. For example, if you distribute copies of such a program, whether gratis or for a fee, you must give the recipients all the rights that you have. You must make sure that they, too, receive or can get the source code. And you must show them these terms so they know their rights. We protect your rights with two steps: (1) copyright the software, and (2) offer you this license which gives you legal permission to copy, distribute and/or modify the software. Also, for each author's protection and ours, we want to make certain that everyone understands that there is no warranty for this free software. If the software is modified by someone else and passed on, we want its recipients to know that what they have is not the original, so that any problems introduced by others will not reflect on the original authors' reputations. Finally, any free program is threatened constantly by software patents. We wish to avoid the danger that redistributors of a free program will individually obtain patent licenses, in effect making the program proprietary. To prevent this, we have made it clear that any patent must be licensed for everyone's free use or not licensed at all. The precise terms and conditions for copying, distribution and modification follow. GNU GENERAL PUBLIC LICENSE TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 0. This License applies to any program or other work which contains a notice placed by the copyright holder saying it may be distributed under the terms of this General Public License. The "Program", below, refers to any such program or work, and a "work based on the Program" means either the Program or any derivative work under copyright law: that is to say, a work containing the Program or a portion of it, either verbatim or with modifications and/or translated into another language. (Hereinafter, translation is included without limitation in the term "modification".) Each licensee is addressed as "you". Activities other than copying, distribution and modification are not covered by this License; they are outside its scope. The act of running the Program is not restricted, and the output from the Program is covered only if its contents constitute a work based on the Program (independent of having been made by running the Program). Whether that is true depends on what the Program does. 1. You may copy and distribute verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice and disclaimer of warranty; keep intact all the notices that refer to this License and to the absence of any warranty; and give any other recipients of the Program a copy of this License along with the Program. You may charge a fee for the physical act of transferring a copy, and you may at your option offer warranty protection in exchange for a fee. 2. You may modify your copy or copies of the Program or any portion of it, thus forming a work based on the Program, and copy and distribute such modifications or work under the terms of Section 1 above, provided that you also meet all of these conditions: a) You must cause the modified files to carry prominent notices stating that you changed the files and the date of any change. b) You must cause any work that you distribute or publish, that in whole or in part contains or is derived from the Program or any part thereof, to be licensed as a whole at no charge to all third parties under the terms of this License. c) If the modified program normally reads commands interactively when run, you must cause it, when started running for such interactive use in the most ordinary way, to print or display an announcement including an appropriate copyright notice and a notice that there is no warranty (or else, saying that you provide a warranty) and that users may redistribute the program under these conditions, and telling the user how to view a copy of this License. (Exception: if the Program itself is interactive but does not normally print such an announcement, your work based on the Program is not required to print an announcement.) These requirements apply to the modified work as a whole. If identifiable sections of that work are not derived from the Program, and can be reasonably considered independent and separate works in themselves, then this License, and its terms, do not apply to those sections when you distribute them as separate works. But when you distribute the same sections as part of a whole which is a work based on the Program, the distribution of the whole must be on the terms of this License, whose permissions for other licensees extend to the entire whole, and thus to each and every part regardless of who wrote it. Thus, it is not the intent of this section to claim rights or contest your rights to work written entirely by you; rather, the intent is to exercise the right to control the distribution of derivative or collective works based on the Program. In addition, mere aggregation of another work not based on the Program with the Program (or with a work based on the Program) on a volume of a storage or distribution medium does not bring the other work under the scope of this License. 3. You may copy and distribute the Program (or a work based on it, under Section 2) in object code or executable form under the terms of Sections 1 and 2 above provided that you also do one of the following: a) Accompany it with the complete corresponding machine-readable source code, which must be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or, b) Accompany it with a written offer, valid for at least three years, to give any third party, for a charge no more than your cost of physically performing source distribution, a complete machine-readable copy of the corresponding source code, to be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or, c) Accompany it with the information you received as to the offer to distribute corresponding source code. (This alternative is allowed only for noncommercial distribution and only if you received the program in object code or executable form with such an offer, in accord with Subsection b above.) The source code for a work means the preferred form of the work for making modifications to it. For an executable work, complete source code means all the source code for all modules it contains, plus any associated interface definition files, plus the scripts used to control compilation and installation of the executable. However, as a special exception, the source code distributed need not include anything that is normally distributed (in either source or binary form) with the major components (compiler, kernel, and so on) of the operating system on which the executable runs, unless that component itself accompanies the executable. If distribution of executable or object code is made by offering access to copy from a designated place, then offering equivalent access to copy the source code from the same place counts as distribution of the source code, even though third parties are not compelled to copy the source along with the object code. 4. You may not copy, modify, sublicense, or distribute the Program except as expressly provided under this License. Any attempt otherwise to copy, modify, sublicense or distribute the Program is void, and will automatically terminate your rights under this License. However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance. 5. You are not required to accept this License, since you have not signed it. However, nothing else grants you permission to modify or distribute the Program or its derivative works. These actions are prohibited by law if you do not accept this License. Therefore, by modifying or distributing the Program (or any work based on the Program), you indicate your acceptance of this License to do so, and all its terms and conditions for copying, distributing or modifying the Program or works based on it. 6. Each time you redistribute the Program (or any work based on the Program), the recipient automatically receives a license from the original licensor to copy, distribute or modify the Program subject to these terms and conditions. You may not impose any further restrictions on the recipients' exercise of the rights granted herein. You are not responsible for enforcing compliance by third parties to this License. 7. If, as a consequence of a court judgment or allegation of patent infringement or for any other reason (not limited to patent issues), conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License. If you cannot distribute so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not distribute the Program at all. For example, if a patent license would not permit royalty-free redistribution of the Program by all those who receive copies directly or indirectly through you, then the only way you could satisfy both it and this License would be to refrain entirely from distribution of the Program. If any portion of this section is held invalid or unenforceable under any particular circumstance, the balance of the section is intended to apply and the section as a whole is intended to apply in other circumstances. It is not the purpose of this section to induce you to infringe any patents or other property right claims or to contest validity of any such claims; this section has the sole purpose of protecting the integrity of the free software distribution system, which is implemented by public license practices. Many people have made generous contributions to the wide range of software distributed through that system in reliance on consistent application of that system; it is up to the author/donor to decide if he or she is willing to distribute software through any other system and a licensee cannot impose that choice. This section is intended to make thoroughly clear what is believed to be a consequence of the rest of this License. 8. If the distribution and/or use of the Program is restricted in certain countries either by patents or by copyrighted interfaces, the original copyright holder who places the Program under this License may add an explicit geographical distribution limitation excluding those countries, so that distribution is permitted only in or among countries not thus excluded. In such case, this License incorporates the limitation as if written in the body of this License. 9. The Free Software Foundation may publish revised and/or new versions of the General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. Each version is given a distinguishing version number. If the Program specifies a version number of this License which applies to it and "any later version", you have the option of following the terms and conditions either of that version or of any later version published by the Free Software Foundation. If the Program does not specify a version number of this License, you may choose any version ever published by the Free Software Foundation. 10. If you wish to incorporate parts of the Program into other free programs whose distribution conditions are different, write to the author to ask for permission. For software which is copyrighted by the Free Software Foundation, write to the Free Software Foundation; we sometimes make exceptions for this. Our decision will be guided by the two goals of preserving the free status of all derivatives of our free software and of promoting the sharing and reuse of software generally. NO WARRANTY 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. END OF TERMS AND CONDITIONS How to Apply These Terms to Your New Programs If you develop a new program, and you want it to be of the greatest possible use to the public, the best way to achieve this is to make it free software which everyone can redistribute and change under these terms. To do so, attach the following notices to the program. It is safest to attach them to the start of each source file to most effectively convey the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found. Copyright (C) This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA Also add information on how to contact you by electronic and paper mail. If the program is interactive, make it output a short notice like this when it starts in an interactive mode: Gnomovision version 69, Copyright (C) year name of author Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. This is free software, and you are welcome to redistribute it under certain conditions; type `show c' for details. The hypothetical commands `show w' and `show c' should show the appropriate parts of the General Public License. Of course, the commands you use may be called something other than `show w' and `show c'; they could even be mouse-clicks or menu items--whatever suits your program. You should also get your employer (if you work as a programmer) or your school, if any, to sign a "copyright disclaimer" for the program, if necessary. Here is a sample; alter the names: Yoyodyne, Inc., hereby disclaims all copyright interest in the program `Gnomovision' (which makes passes at compilers) written by James Hacker. , 1 April 1989 Ty Coon, President of Vice This General Public License does not permit incorporating your program into proprietary programs. If your program is a subroutine library, you may consider it more useful to permit linking proprietary applications with the library. If this is what you want to do, use the GNU Library General Public License instead of this License. visp-3.0.1/README.md000066400000000000000000000010201304511007300137360ustar00rootroot00000000000000### ViSP: Open source Visual Servoing Platform [![Build Status](https://travis-ci.org/lagadic/visp.png)](https://travis-ci.org/lagadic/visp) #### Resources - Homepage: http://visp.inria.fr - Wiki: https://github.com/lagadic/visp/wiki - Code documentation: http://visp-doc.inria.fr/doxygen/visp-daily - Q&A forum: http://gforge.inria.fr/forum/?group_id=397 - Issue tracking: https://github.com/lagadic/visp/issues #### Contributing Please read before starting work on a pull request: http://visp.inria.fr/contributing-code/ visp-3.0.1/cmake/000077500000000000000000000000001304511007300135465ustar00rootroot00000000000000visp-3.0.1/cmake/AddExtraCompilationFlags.cmake000066400000000000000000000117641304511007300214310ustar00rootroot00000000000000############################################################################# # # This file is part of the ViSP software. # Copyright (C) 2005 - 2017 by Inria. All rights reserved. # # This software is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public License # ("GPL") version 2 as published by the Free Software Foundation. # See the file LICENSE.txt at the root directory of this source # distribution for additional information about the GNU GPL. # # For using ViSP with software that can not be combined with the GNU # GPL, please contact Inria about acquiring a ViSP Professional # Edition License. # # See http://visp.inria.fr for more information. # # This software was developed at: # Inria Rennes - Bretagne Atlantique # Campus Universitaire de Beaulieu # 35042 Rennes Cedex # France # # If you have questions regarding the use of this file, please contact # Inria at visp@inria.fr # # This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE # WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. # # Description: # ViSP overall configuration file. Add extra compilation flags. # # Authors: # Fabien Spindler # ############################################################################# set(VISP_EXTRA_C_FLAGS "") set(VISP_EXTRA_CXX_FLAGS "") macro(add_extra_compiler_option option) if(CMAKE_BUILD_TYPE) set(CMAKE_TRY_COMPILE_CONFIGURATION ${CMAKE_BUILD_TYPE}) endif() vp_check_flag_support(CXX "${option}" _varname) if(_varname) list(APPEND VISP_EXTRA_CXX_FLAGS ${option}) endif() vp_check_flag_support(C "${option}" _varname) if(_varname) list(APPEND VISP_EXTRA_C_FLAGS ${option}) endif() endmacro() macro(add_extra_compiler_option_enabling option var_enabling flag) if(CMAKE_BUILD_TYPE) set(CMAKE_TRY_COMPILE_CONFIGURATION ${CMAKE_BUILD_TYPE}) endif() vp_check_flag_support(CXX "${option}" _cxx_varname) if(_cxx_varname) set(__msg "Activate ${option} compiler flag") set(${var_enabling} ${flag} CACHE BOOL ${__msg}) endif() if(${${var_enabling}}) list(APPEND VISP_EXTRA_CXX_FLAGS ${option}) else() vp_list_filterout(VISP_EXTRA_CXX_FLAGS ${option}) endif() vp_check_flag_support(C "${option}" _c_varname) if(${${var_enabling}} AND _c_varname) list(APPEND VISP_EXTRA_C_FLAGS ${option}) else() vp_list_filterout(VISP_EXTRA_C_FLAGS ${option}) endif() endmacro() if(CMAKE_COMPILER_IS_GNUCXX OR MINGW OR CMAKE_CXX_COMPILER_ID MATCHES "Clang") #Not only UNIX but also WIN32 for MinGW add_extra_compiler_option_enabling(-Wall ACTIVATE_WARNING_ALL ON) add_extra_compiler_option_enabling(-Wextra ACTIVATE_WARNING_EXTRA ON) add_extra_compiler_option_enabling(-Wstrict-overflow=5 ACTIVATE_WARNING_STRICT_OVERFLOW OFF) add_extra_compiler_option_enabling(-Wfloat-equal ACTIVATE_WARNING_FLOAT_EQUAL OFF) add_extra_compiler_option_enabling(-Wsign-conversion ACTIVATE_WARNING_SIGN_CONVERSION OFF) elseif(MSVC) # Add specific compilation flags for Windows Visual add_extra_compiler_option_enabling(/Wall ACTIVATE_WARNING_ALL OFF) if(MSVC80 OR MSVC90 OR MSVC10 OR MSVC11 OR MSVC14) # To avoid compiler warning (level 4) C4571, compile with /EHa if you still want # your catch(...) blocks to catch structured exceptions. add_extra_compiler_option("/EHa") endif() endif() VP_OPTION(ACTIVATE_WARNING_3PARTY_MUTE "" "" "Add flags to disable warning due to known 3rd parties" "" ON) if(USE_OPENMP) add_extra_compiler_option("${OpenMP_CXX_FLAGS}") endif() if(USE_CPP11) add_extra_compiler_option("${CPP11_CXX_FLAGS}") endif() if(BUILD_COVERAGE) add_extra_compiler_option("-ftest-coverage -fprofile-arcs") endif() if(CMAKE_COMPILER_IS_GNUCXX) add_extra_compiler_option(-fvisibility=hidden) if(ENABLE_SSE2) add_extra_compiler_option(-msse2) elseif(X86 OR X86_64) add_extra_compiler_option(-mno-sse2) endif() if(ENABLE_SSE3) add_extra_compiler_option(-msse3) elseif(X86 OR X86_64) #add_extra_compiler_option(-mno-sse3) endif() if(ENABLE_SSSE3) add_extra_compiler_option(-mssse3) elseif(X86 OR X86_64) add_extra_compiler_option(-mno-ssse3) endif() endif() if(UNIX) if(CMAKE_COMPILER_IS_GNUCXX OR CV_ICC) add_extra_compiler_option(-fPIC) endif() endif() if(DEFINED WINRT_8_1) add_extra_compiler_option(/ZW) # do not use with 8.0 endif() # Add user supplied extra options (optimization, etc...) vp_list_unique(VISP_EXTRA_C_FLAGS) vp_list_unique(VISP_EXTRA_CXX_FLAGS) vp_list_remove_separator(VISP_EXTRA_C_FLAGS) vp_list_remove_separator(VISP_EXTRA_CXX_FLAGS) set(VISP_EXTRA_C_FLAGS "${VISP_EXTRA_C_FLAGS}" CACHE INTERNAL "Extra compiler options for C sources") set(VISP_EXTRA_CXX_FLAGS "${VISP_EXTRA_CXX_FLAGS}" CACHE INTERNAL "Extra compiler options for C++ sources") #combine all "extra" options set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${VISP_EXTRA_C_FLAGS}") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${VISP_EXTRA_CXX_FLAGS}") visp-3.0.1/cmake/CPackConfig.cmake000066400000000000000000000101561304511007300166620ustar00rootroot00000000000000############################################################################# # # This file is part of the ViSP software. # Copyright (C) 2005 - 2017 by Inria. All rights reserved. # # This software is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public License # ("GPL") version 2 as published by the Free Software Foundation. # See the file LICENSE.txt at the root directory of this source # distribution for additional information about the GNU GPL. # # For using ViSP with software that can not be combined with the GNU # GPL, please contact Inria about acquiring a ViSP Professional # Edition License. # # See http://visp.inria.fr for more information. # # This software was developed at: # Inria Rennes - Bretagne Atlantique # Campus Universitaire de Beaulieu # 35042 Rennes Cedex # France # # If you have questions regarding the use of this file, please contact # Inria at visp@inria.fr # # This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE # WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. # # Description: # ViSP packaging configuration file. # # Authors: # Fabien Spindler # ############################################################################# message(STATUS "Configuring CPack") #mark_as_advanced(BUILD_PACKAGE) SET(CPACK_PACKAGE_NAME "libvisp") SET(CPACK_PACKAGE_DESCRIPTION_SUMMARY "Visual tracking and visual servoing library in C++ (development files)") SET(CPACK_PACKAGE_CONTACT "Fabien Spindler ") SET(CPACK_PACKAGE_VENDOR "Inria, French National Institute for Research in Computer Science and Control") SET(CPACK_PACKAGE_DESCRIPTION_FILE "${CMAKE_CURRENT_SOURCE_DIR}/README.txt") SET(CPACK_RESOURCE_FILE_LICENSE "${CMAKE_CURRENT_SOURCE_DIR}/LICENSE.txt") SET(CPACK_PACKAGE_VERSION ${VISP_VERSION}) SET(CPACK_PACKAGE_VERSION_MAJOR ${VISP_VERSION_MAJOR}) SET(CPACK_PACKAGE_VERSION_MINOR ${VISP_VERSION_MINOR}) SET(CPACK_PACKAGE_VERSION_PATCH ${VISP_VERSION_PATCH}) SET(CPACK_COMPONENTS_ALL libraries headers) SET(CPACK_COMPONENT_LIBRARIES_DISPLAY_NAME "Libraries") SET(CPACK_COMPONENT_HEADERS_DISPLAY_NAME "C++ Headers") SET(CPACK_COMPONENT_LIBRARIES_DESCRIPTION "ViSP ${VISP_VERSION} libraries") SET(CPACK_COMPONENT_HEADERS_DESCRIPTION "C/C++ header files for use with ViSP ${VISP_VERSION} libraries") SET(CPACK_COMPONENT_HEADERS_DEPENDS libraries) SET(CPACK_COMPONENT_LIBRARIES_GROUP "Development") SET(CPACK_COMPONENT_HEADERS_GROUP "Development") SET(CPACK_COMPONENT_GROUP_DEVELOPMENT_DESCRIPTION "All of the tools you'll ever need to develop software with ViSP") SET(CPACK_ALL_INSTALL_TYPES Full Developer) SET(CPACK_COMPONENT_LIBRARIES_INSTALL_TYPES Developer Full) SET(CPACK_COMPONENT_HEADERS_INSTALL_TYPES Developer Full) # The following components are regex's to match anywhere (unless anchored) # in absolute path + filename to find files or directories to be excluded # from source tarball. SET(CPACK_SOURCE_IGNORE_FILES "/\\\\.svn/" "/autom4te.cache/" "/build/" "/lib/" "~$" ) SET(CPACK_PACKAGE_INSTALL_DIRECTORY "${PROJECT_NAME} ${VISP_VERSION}") # In ViSP packages we only want to have the libraries and the headers (nor the demo, example, and test) # That's why we turn off the demo, example and test building SET(BUILD_DEMOS OFF CACHE BOOL "Build ViSP demos." FORCE ) SET(BUILD_EXAMPLES OFF CACHE BOOL "Build ViSP examples." FORCE) SET(BUILD_TESTING OFF CACHE BOOL "Build ViSP tests." FORCE) SET(BUILD_TUTORIAL OFF CACHE BOOL "Build ViSP tutorials." FORCE) if(UNIX) set(CMAKE_INSTALL_PREFIX "/usr" CACHE String "Package install prefix" FORCE) elseif(WIN32) set(CMAKE_INSTALL_PREFIX "C:/Program Files/ViSP ${VISP_VERSION}" CACHE String "Package install prefix" FORCE) endif() set(BUILD_SHARED_LIBS ON CACHE BOOL "Build ViSP with shared libraries." FORCE) if(WIN32 AND NOT UNIX) include(${VISP_CMAKE_MODULE_PATH}/CPackConfigNsis.cmake) elseif(APPLE) set(CPACK_GENERATOR "PackageMaker;TBZ2") elseif(UNIX) if(BUILD_PACKAGE_DEBIAN) include(${VISP_CMAKE_MODULE_PATH}/CPackConfigDeb.cmake) elseif(BUILD_PACKAGE_RPM) include(${VISP_CMAKE_MODULE_PATH}/CPackConfigRpm.cmake) endif() endif() INCLUDE(CPack) visp-3.0.1/cmake/CPackConfigDeb.cmake000066400000000000000000000153151304511007300172770ustar00rootroot00000000000000############################################################################# # # This file is part of the ViSP software. # Copyright (C) 2005 - 2017 by Inria. All rights reserved. # # This software is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public License # ("GPL") version 2 as published by the Free Software Foundation. # See the file LICENSE.txt at the root directory of this source # distribution for additional information about the GNU GPL. # # For using ViSP with software that can not be combined with the GNU # GPL, please contact Inria about acquiring a ViSP Professional # Edition License. # # See http://visp.inria.fr for more information. # # This software was developed at: # Inria Rennes - Bretagne Atlantique # Campus Universitaire de Beaulieu # 35042 Rennes Cedex # France # # If you have questions regarding the use of this file, please contact # Inria at visp@inria.fr # # This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE # WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. # # Description: # ViSP packaging configuration file. # # Authors: # Fabien Spindler # ############################################################################# # To install the generated debian package use the gdebi-gtk package # installer on Ubuntu: # gdebi-gtk libvisp-dev-2.6.1-1_i386.deb # $ dpkg --print-architecture FIND_PROGRAM(DPKG_CMD dpkg) MARK_AS_ADVANCED(DPKG_CMD) IF(NOT DPKG_CMD) MESSAGE(STATUS "Can not find dpkg in your path, default to i386.") SET(CPACK_SYSTEM_NAME i386) ELSE() EXECUTE_PROCESS(COMMAND "${DPKG_CMD}" --print-architecture OUTPUT_VARIABLE CPACK_SYSTEM_NAME OUTPUT_STRIP_TRAILING_WHITESPACE ) ENDIF() # $ lsb_release -sr (ex: 12.04) FIND_PROGRAM(LSB_RELEASE_CMD lsb_release) MARK_AS_ADVANCED(LSB_RELEASE_CMD) IF(NOT LSB_RELEASE_CMD) MESSAGE(STATUS "Can not find lsb_release in your path.") SET(DEBIAN_DISTRO_RELEASE "") ELSE() EXECUTE_PROCESS(COMMAND "${LSB_RELEASE_CMD}" -sr OUTPUT_VARIABLE DEBIAN_DISTRO_RELEASE OUTPUT_STRIP_TRAILING_WHITESPACE ) if(DEBIAN_DISTRO_RELEASE) #message("DEBIAN_DISTRO_RELEASE 1: ${DEBIAN_DISTRO_RELEASE}") STRING(REGEX REPLACE "[.]" "" DEBIAN_DISTRO_RELEASE ${DEBIAN_DISTRO_RELEASE}) #message("DEBIAN_DISTRO_RELEASE 2: ${DEBIAN_DISTRO_RELEASE}") endif() ENDIF() list(APPEND CPACK_GENERATOR DEB) SET(CPACK_PACKAGE_VERSION ${VISP_VERSION}-${VISP_REVISION}) SET(CPACK_PACKAGE_NAME "libvisp-dev") set(CPACK_PACKAGE_FILE_NAME "${CPACK_PACKAGE_NAME}_${VISP_VERSION}-${VISP_REVISION}_${CPACK_SYSTEM_NAME}") set(CPACK_DEBIAN_PACKAGE_DEPENDS "cmake (>=2.6)") IF(USE_X11) set(CPACK_DEBIAN_PACKAGE_DEPENDS "${CPACK_DEBIAN_PACKAGE_DEPENDS}, libx11-dev (>=2:1.3.2)") ENDIF() IF(USE_GTK2) set(CPACK_DEBIAN_PACKAGE_DEPENDS "${CPACK_DEBIAN_PACKAGE_DEPENDS}, libgtk2.0-dev (>=2.20.1), libglib2.0-dev (>=2.24.1), libpango1.0-dev (>=1.28.0), libatk1.0-dev (>=1.30.0), libcairo2-dev (>=1.8.10)") ENDIF() IF(USE_LAPACK) set(CPACK_DEBIAN_PACKAGE_DEPENDS "${CPACK_DEBIAN_PACKAGE_DEPENDS}, liblapack-dev(>=3.2)") ENDIF() IF(USE_GSL) set(CPACK_DEBIAN_PACKAGE_DEPENDS "${CPACK_DEBIAN_PACKAGE_DEPENDS}, libgsl0-dev (>=1.13)") ENDIF() IF(USE_V4L2) set(CPACK_DEBIAN_PACKAGE_DEPENDS "${CPACK_DEBIAN_PACKAGE_DEPENDS}, libv4l-dev (>=0.6.4)") ENDIF() IF(USE_DC1394_2) set(CPACK_DEBIAN_PACKAGE_DEPENDS "${CPACK_DEBIAN_PACKAGE_DEPENDS}, libdc1394-22-dev (>=2.1.2)") ENDIF() IF(USE_XML2) set(CPACK_DEBIAN_PACKAGE_DEPENDS "${CPACK_DEBIAN_PACKAGE_DEPENDS}, libxml2-dev (>=2.7.2)") ENDIF() IF(USE_LIBPNG) set(CPACK_DEBIAN_PACKAGE_DEPENDS "${CPACK_DEBIAN_PACKAGE_DEPENDS}, libpng12-dev (>=1.2.42)") ENDIF() IF(USE_LIBJPEG) if(DEBIAN_DISTRO_RELEASE) if(DEBIAN_DISTRO_RELEASE VERSION_LESS "1204") set(CPACK_DEBIAN_PACKAGE_DEPENDS "${CPACK_DEBIAN_PACKAGE_DEPENDS}, libjpeg62-dev (>=6b-15)") else() set(CPACK_DEBIAN_PACKAGE_DEPENDS "${CPACK_DEBIAN_PACKAGE_DEPENDS}, libjpeg-dev (>=6b-15)") endif() else() set(CPACK_DEBIAN_PACKAGE_DEPENDS "${CPACK_DEBIAN_PACKAGE_DEPENDS}, libjpeg-dev (>=6b-15)") endif() ENDIF() IF(USE_FFMPEG) set(CPACK_DEBIAN_PACKAGE_DEPENDS "${CPACK_DEBIAN_PACKAGE_DEPENDS}, libswscale-dev (>=4:0.5.1), libavutil-dev (>=4:0.5.1), libavformat-dev (>=4:0.5.1), libavcodec-dev (>=4:0.5.1), libbz2-dev (>=1.0.5-4), libbz2-1.0 (>=1.0.5-4)") ENDIF() IF(USE_COIN) set(CPACK_DEBIAN_PACKAGE_DEPENDS "${CPACK_DEBIAN_PACKAGE_DEPENDS}, libcoin60-dev (>=3.1.2-1)") ENDIF() IF(USE_SOQT) set(CPACK_DEBIAN_PACKAGE_DEPENDS "${CPACK_DEBIAN_PACKAGE_DEPENDS}, libsoqt4-dev (>=1.4.2~svn20090224-2)") ENDIF() IF(USE_OGRE) set(CPACK_DEBIAN_PACKAGE_DEPENDS "${CPACK_DEBIAN_PACKAGE_DEPENDS}, libogre-dev (>=1.7.3)") # since ogre-samples-media is not available on ubuntu oneiric 11.10 for example, we need an extra test to add this dependency IF(OGRE_MEDIA_DIR) if(DEBIAN_DISTRO_RELEASE) if(DEBIAN_DISTRO_RELEASE VERSION_LESS "1204") set(CPACK_DEBIAN_PACKAGE_DEPENDS "${CPACK_DEBIAN_PACKAGE_DEPENDS}, ogre-samples-media (>=1.7.3)") else() set(CPACK_DEBIAN_PACKAGE_DEPENDS "${CPACK_DEBIAN_PACKAGE_DEPENDS}, ogre-samples (>=1.7.3)") endif() else() set(CPACK_DEBIAN_PACKAGE_DEPENDS "${CPACK_DEBIAN_PACKAGE_DEPENDS}, ogre-samples-media (>=1.7.3)") endif() ENDIF() ENDIF() IF(USE_OIS) set(CPACK_DEBIAN_PACKAGE_DEPENDS "${CPACK_DEBIAN_PACKAGE_DEPENDS}, libois-dev (>=1.3.0)") ENDIF() IF(USE_OPENCV) if(DEBIAN_DISTRO_RELEASE) if(DEBIAN_DISTRO_RELEASE VERSION_LESS "1204") set(CPACK_DEBIAN_PACKAGE_DEPENDS "${CPACK_DEBIAN_PACKAGE_DEPENDS}, libcv-dev (>=2.0), libcvaux-dev (>=2.0), libhighgui-dev (>=2.0)") else() set(CPACK_DEBIAN_PACKAGE_DEPENDS "${CPACK_DEBIAN_PACKAGE_DEPENDS}, libopencv-dev (>=2.3.1)") endif() else() set(CPACK_DEBIAN_PACKAGE_DEPENDS "${CPACK_DEBIAN_PACKAGE_DEPENDS}, libopencv-dev (>=2.3.1)") endif() ENDIF() IF(USE_LIBFREENECT) set(CPACK_DEBIAN_PACKAGE_DEPENDS "${CPACK_DEBIAN_PACKAGE_DEPENDS}, freenect (>=1:0.0.1)") ENDIF() if(USE_LIBUSB_1) set(CPACK_DEBIAN_PACKAGE_DEPENDS "${CPACK_DEBIAN_PACKAGE_DEPENDS}, libusb-1.0-0-dev (>=2:1.0)") endif() set(CPACK_DEBIAN_PACKAGE_DEPENDS "${CPACK_DEBIAN_PACKAGE_DEPENDS}, libc6 (>=2.4)") SET(CPACK_DEBIAN_PACKAGE_DESCRIPTION "Visual Servoing Platform development files ViSP, standing for Visual Servoing Platform, is unique. This software is a complete cross-platform solution that allows prototyping and developing applications in visual tracking and visual servoing. . ViSP can be useful in robotics, computer vision, augmented reality and computer animation. . This package contains development files (headers and shared library symbolic link).") SET(CPACK_DEBIAN_PACKAGE_SECTION "libdevel") SET(CPACK_DEBIAN_PACKAGE_HOMEPAGE "http://www.irisa.fr/lagadic/visp") visp-3.0.1/cmake/CPackConfigNsis.cmake000066400000000000000000000041111304511007300175110ustar00rootroot00000000000000############################################################################# # # This file is part of the ViSP software. # Copyright (C) 2005 - 2017 by Inria. All rights reserved. # # This software is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public License # ("GPL") version 2 as published by the Free Software Foundation. # See the file LICENSE.txt at the root directory of this source # distribution for additional information about the GNU GPL. # # For using ViSP with software that can not be combined with the GNU # GPL, please contact Inria about acquiring a ViSP Professional # Edition License. # # See http://visp.inria.fr for more information. # # This software was developed at: # Inria Rennes - Bretagne Atlantique # Campus Universitaire de Beaulieu # 35042 Rennes Cedex # France # # If you have questions regarding the use of this file, please contact # Inria at visp@inria.fr # # This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE # WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. # # Description: # ViSP packaging configuration file. # # Authors: # Fabien Spindler # ############################################################################# set(BUILD_SHARED_LIBS CACHE FORCE "Build ViSP with shared libraries." ON) # InstallRequiredSystemLibraries: Hack for Visual Studio support Search for # system runtime libraries based on the platform. INCLUDE(InstallRequiredSystemLibraries) set(CPACK_GENERATOR NSIS) set(CPACK_NSIS_CONTACT "visp@inria.fr") SET(CPACK_NSIS_HELP_LINK "http://www.irisa.fr/lagadic/visp/visp.html") set(CPACK_NSIS_URL_INFO_ABOUT "http://www.irisa.fr/lagadic/visp/visp.html") set(CPACK_NSIS_MODIFY_PATH "ON") set(CPACK_NSIS_DISPLAY_NAME "${CPACK_PACKAGE_INSTALL_DIRECTORY} SDK") # set(CPACK_PACKAGE_ICON ${VISP_SOURCE_DIR}/visp.bmp) # set(CPACK_NSIS_MUI_ICON ${VISP_SOURCE_DIR}/logoViSP.ico) # set(CPACK_NSIS_MUI_UNIICON ${VISP_SOURCE_DIR}/logoViSP.ico) SET(CPACK_PACKAGE_FILE_NAME "ViSP-${VISP_VERSION}-win32") SET(CPACK_SOURCE_PACKAGE_FILE_NAME "ViSP-${VISP_VERSION}-win32-src") visp-3.0.1/cmake/CPackConfigRpm.cmake000066400000000000000000000123561304511007300173450ustar00rootroot00000000000000############################################################################# # # This file is part of the ViSP software. # Copyright (C) 2005 - 2017 by Inria. All rights reserved. # # This software is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public License # ("GPL") version 2 as published by the Free Software Foundation. # See the file LICENSE.txt at the root directory of this source # distribution for additional information about the GNU GPL. # # For using ViSP with software that can not be combined with the GNU # GPL, please contact Inria about acquiring a ViSP Professional # Edition License. # # See http://visp.inria.fr for more information. # # This software was developed at: # Inria Rennes - Bretagne Atlantique # Campus Universitaire de Beaulieu # 35042 Rennes Cedex # France # # If you have questions regarding the use of this file, please contact # Inria at visp@inria.fr # # This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE # WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. # # Description: # ViSP packaging configuration file. # # Authors: # Fabien Spindler # ############################################################################# # $ uname -i FIND_PROGRAM(UNAME_CMD uname) MARK_AS_ADVANCED(UNAME_CMD) IF(NOT UNAME_CMD) MESSAGE(STATUS "Can not find uname in your path, default to i386.") SET(CPACK_SYSTEM_NAME i386) ELSE() EXECUTE_PROCESS(COMMAND "${UNAME_CMD}" -m OUTPUT_VARIABLE CPACK_SYSTEM_NAME OUTPUT_STRIP_TRAILING_WHITESPACE ) ENDIF() # create a fedora short name from cat /etc/fedora-release # for example, cat .. return "Fedora release 13 (Goddard)" we build "fc13" FIND_PROGRAM(CAT_CMD cat) MARK_AS_ADVANCED(CAT_CMD) IF(NOT CAT_CMD) MESSAGE(STATUS "Can not find cat in your path, default to empty.") SET(DIST_SHORT_NAME "") ELSE() SET(DIST_SHORT_NAME "") EXECUTE_PROCESS(COMMAND "${CAT_CMD}" /etc/fedora-release OUTPUT_VARIABLE FEDORA_FULL_RELEASE_NAME OUTPUT_STRIP_TRAILING_WHITESPACE ) #message("fedora release found 1: ${FEDORA_FULL_RELEASE_NAME}") IF(FEDORA_FULL_RELEASE_NAME) # replace " " space separator by ";" separator STRING(REGEX REPLACE "[ ]" ";" FEDORA_FULL_RELEASE_NAME ${FEDORA_FULL_RELEASE_NAME}) # message("fedora release found 2: ${FEDORA_FULL_RELEASE_NAME}") LIST(GET FEDORA_FULL_RELEASE_NAME 0 ITEM1) # here ITEM1 should contain "Fedora" # message("item1: ${ITEM1}") STRING(COMPARE EQUAL ${ITEM1} "Fedora" IS_FEDORA) IF(IS_FEDORA) LIST(GET FEDORA_FULL_RELEASE_NAME 2 ITEM3) # here ITEM3 should contain the dist number # message("dist number: ${ITEM3}") IF(ITEM3) SET(DIST_SHORT_NAME "fc${ITEM3}") ENDIF() ENDIF() ENDIF() ENDIF() list(APPEND CPACK_GENERATOR RPM) SET(CPACK_PACKAGE_NAME "libvisp-devel") set(CPACK_PACKAGE_FILE_NAME "${CPACK_PACKAGE_NAME}-${VISP_VERSION}-${VISP_REVISION}.${DIST_SHORT_NAME}.${CPACK_SYSTEM_NAME}") set(CPACK_RPM_PACKAGE_GROUP "Development/Libraries") set(CPACK_RPM_PACKAGE_ARCHITECTURE "${CPACK_SYSTEM_NAME}") set(CPACK_RPM_PACKAGE_LICENSE "GPL") set(CPACK_RPM_PACKAGE_RELEASE ${VISP_REVISION}) set(CPACK_RPM_PACKAGE_DEPENDS "cmake >= 2.6") IF(USE_X11) set(CPACK_RPM_PACKAGE_DEPENDS "${CPACK_RPM_PACKAGE_DEPENDS}, libX11-devel >= 1.3") ENDIF() IF(USE_GTK2) set(CPACK_RPM_PACKAGE_DEPENDS "${CPACK_RPM_PACKAGE_DEPENDS}, gtk2-devel, glib2-devel, pango-devel, atk-devel, cairo-devel") ENDIF() IF(USE_LAPACK) set(CPACK_RPM_PACKAGE_DEPENDS "${CPACK_RPM_PACKAGE_DEPENDS}, lapack-devel >= 3.2") ENDIF() IF(USE_GSL) set(CPACK_RPM_PACKAGE_DEPENDS "${CPACK_RPM_PACKAGE_DEPENDS}, gsl-devel >= 1.13") ENDIF() IF(USE_V4L2) set(CPACK_RPM_PACKAGE_DEPENDS "${CPACK_RPM_PACKAGE_DEPENDS}, libv4l-devel >= 0.6.2") ENDIF() IF(USE_DC1394_2) set(CPACK_RPM_PACKAGE_DEPENDS "${CPACK_RPM_PACKAGE_DEPENDS}, libdc1394-devel >= 2.1.2") ENDIF() IF(USE_XML2) set(CPACK_RPM_PACKAGE_DEPENDS "${CPACK_RPM_PACKAGE_DEPENDS}, libxml2-devel >= 2.7.6") ENDIF() IF(USE_LIBPNG) set(CPACK_RPM_PACKAGE_DEPENDS "${CPACK_RPM_PACKAGE_DEPENDS}, libpng-devel >= 2:1.2.44") ENDIF() IF(USE_LIBJPEG) set(CPACK_RPM_PACKAGE_DEPENDS "${CPACK_RPM_PACKAGE_DEPENDS}, libjpeg-devel >= 6b-46") ENDIF() IF(USE_COIN) set(CPACK_RPM_PACKAGE_DEPENDS "${CPACK_RPM_PACKAGE_DEPENDS}, Coin2-devel >= 2.5.0") ENDIF() IF(USE_SOQT) set(CPACK_RPM_PACKAGE_DEPENDS "${CPACK_RPM_PACKAGE_DEPENDS}, SoQt-devel >= 1.5.0") ENDIF() IF(USE_OPENCV) set(CPACK_RPM_PACKAGE_DEPENDS "${CPACK_RPM_PACKAGE_DEPENDS}, opencv-devel >= 2.0") ENDIF() #message("CPACK_RPM_PACKAGE_DEPENDS ${CPACK_RPM_PACKAGE_DEPENDS}") set(CPACK_RPM_PACKAGE_REQUIRES "${CPACK_RPM_PACKAGE_DEPENDS}") set(CPACK_RPM_PACKAGE_DESCRIPTION "Visual Servoing Platform development files ViSP, standing for Visual Servoing Platform, is unique. This software is a complete cross-platform solution that allows prototyping and developing applications in visual tracking and visual servoing. . ViSP can be useful in robotics, computer vision, augmented reality and computer animation. . This package contains development files (headers and shared library symbolic link).") set(CPACK_RPM_EXCLUDE_FROM_AUTO_FILELIST_ADDITION "/usr/share/man" "/usr/share/man/man1" "/usr/lib64/pkgconfig" "/usr/lib/pkgconfig" "/usr/lib64/cmake" "/usr/lib/cmake") visp-3.0.1/cmake/FindARIA.cmake000066400000000000000000000067721304511007300161010ustar00rootroot00000000000000############################################################################# # # This file is part of the ViSP software. # Copyright (C) 2005 - 2017 by Inria. All rights reserved. # # This software is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public License # ("GPL") version 2 as published by the Free Software Foundation. # See the file LICENSE.txt at the root directory of this source # distribution for additional information about the GNU GPL. # # For using ViSP with software that can not be combined with the GNU # GPL, please contact Inria about acquiring a ViSP Professional # Edition License. # # See http://visp.inria.fr for more information. # # This software was developed at: # Inria Rennes - Bretagne Atlantique # Campus Universitaire de Beaulieu # 35042 Rennes Cedex # France # # If you have questions regarding the use of this file, please contact # Inria at visp@inria.fr # # This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE # WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. # # Description: # Try to find Aria libraries and headers to control Pioneer mobile robots. # Once run this will define: # # ARIA_FOUND # ARIA_INCLUDE_DIRS # ARIA_LIBRARIES # # Authors: # Fabien Spindler # ############################################################################# find_path(ARIA_INCLUDE_DIR Aria.h $ENV{ARIA_HOME}/include /usr/local/Aria/include /usr/Aria/include /usr/include /usr/include/Aria /usr/local/include /usr/local/include/Aria "C:/Program Files/MobileRobots/Aria/include" ) #MESSAGE("DBG ARIA_INCLUDE_DIR=${ARIA_INCLUDE_DIR}") if(UNIX) find_library(ARIA_LIBRARY NAMES Aria PATHS $ENV{ARIA_HOME}/lib /usr/local/Aria/lib /usr/Aria/lib /usr/lib /usr/local/lib ) #MESSAGE("DBG ARIA_LIBRARY=${ARIA_LIBRARY}") else() if(MSVC12) set(ARIA_SUFFIX_NAME VC12) elseif(MSVC11) set(ARIA_SUFFIX_NAME VC11) elseif(MSVC10) set(ARIA_SUFFIX_NAME VC10) elseif(MSVC90) set(ARIA_SUFFIX_NAME VC9) elseif(MSVC80) set(ARIA_SUFFIX_NAME VC8) elseif(MSVC71) set(ARIA_SUFFIX_NAME VC71) else() set(ARIA_SUFFIX_NAME "") endif() set(ARIA_LIB_SEARCH_PATH "") if(CMAKE_CL_64) list(APPEND ARIA_LIB_SEARCH_PATH "C:/Program Files/MobileRobots/Aria/lib64") list(APPEND ARIA_LIB_SEARCH_PATH $ENV{ARIA_HOME}/lib64) else() list(APPEND ARIA_LIB_SEARCH_PATH "C:/Program Files/MobileRobots/Aria/lib") list(APPEND ARIA_LIB_SEARCH_PATH $ENV{ARIA_HOME}/lib) endif() find_library(ARIA_LIBRARY_DEBUG NAMES AriaDebug${ARIA_SUFFIX_NAME} PATHS ${ARIA_LIB_SEARCH_PATH} ) find_library(ARIA_LIBRARY_RELEASE NAMES Aria${ARIA_SUFFIX_NAME} PATHS ${ARIA_LIB_SEARCH_PATH} ) endif() if(UNIX) if(ARIA_LIBRARY AND ARIA_INCLUDE_DIR) set(ARIA_INCLUDE_DIRS ${ARIA_INCLUDE_DIR}) set(ARIA_LIBRARIES ${ARIA_LIBRARY}) set(ARIA_FOUND TRUE) else() set(ARIA_FOUND FALSE) endif() else() set(ARIA_LIBRARIES "") if(ARIA_LIBRARY_RELEASE AND ARIA_INCLUDE_DIR) set(ARIA_INCLUDE_DIRS ${ARIA_INCLUDE_DIR}) list(APPEND ARIA_LIBRARIES optimized ${ARIA_LIBRARY_RELEASE}) set(ARIA_FOUND TRUE) endif() IF(ARIA_LIBRARY_DEBUG AND ARIA_INCLUDE_DIR) set(ARIA_INCLUDE_DIRS ${ARIA_INCLUDE_DIR}) list(APPEND ARIA_LIBRARIES debug ${ARIA_LIBRARY_DEBUG}) set(ARIA_FOUND TRUE) endif() endif() mark_as_advanced( ARIA_INCLUDE_DIR ARIA_LIBRARY ARIA_LIBRARY_DEBUG ARIA_LIBRARY_RELEASE ARIA_LIB_SEARCH_PATH ) visp-3.0.1/cmake/FindAfma6_data.cmake000066400000000000000000000033671304511007300173050ustar00rootroot00000000000000############################################################################# # # This file is part of the ViSP software. # Copyright (C) 2005 - 2017 by Inria. All rights reserved. # # This software is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public License # ("GPL") version 2 as published by the Free Software Foundation. # See the file LICENSE.txt at the root directory of this source # distribution for additional information about the GNU GPL. # # For using ViSP with software that can not be combined with the GNU # GPL, please contact Inria about acquiring a ViSP Professional # Edition License. # # See http://visp.inria.fr for more information. # # This software was developed at: # Inria Rennes - Bretagne Atlantique # Campus Universitaire de Beaulieu # 35042 Rennes Cedex # France # # If you have questions regarding the use of this file, please contact # Inria at visp@inria.fr # # This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE # WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. # # Description: # Try to determine if calibration data (camera intrinsic/extrinsic, FT calib file) # are available for Inria's Viper 650 robot. # # AFMA6_DATA_FOUND # AFMA6_DATA_PATH # # Authors: # Fabien Spindler # ############################################################################# find_path(AFMA6_DATA_PATH NAMES include/const_camera_Afma6.xml PATHS /home/soft/Afma6/Afma6 /home/soft/Afma6/current /udd/fspindle/robot/Afma6/current Z:/robot/Afma6/current ) #message("DBG AFMA6_DATA_PATH=${AFMA6_DATA_PATH}") if(AFMA6_DATA_PATH) set(AFMA6_DATA_FOUND TRUE) else() SET(AFMA6_FATA_FOUND FALSE) endif() mark_as_advanced( AFMA6_DATA_PATH ) visp-3.0.1/cmake/FindBICLOPS.cmake000066400000000000000000000112051304511007300164430ustar00rootroot00000000000000############################################################################# # # This file is part of the ViSP software. # Copyright (C) 2005 - 2017 by Inria. All rights reserved. # # This software is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public License # ("GPL") version 2 as published by the Free Software Foundation. # See the file LICENSE.txt at the root directory of this source # distribution for additional information about the GNU GPL. # # For using ViSP with software that can not be combined with the GNU # GPL, please contact Inria about acquiring a ViSP Professional # Edition License. # # See http://visp.inria.fr for more information. # # This software was developed at: # Inria Rennes - Bretagne Atlantique # Campus Universitaire de Beaulieu # 35042 Rennes Cedex # France # # If you have questions regarding the use of this file, please contact # Inria at visp@inria.fr # # This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE # WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. # # Description: # Try to find libBiclops, libPMD and libUtils for Biclops head. # Once run this will define: # # BICLOPS_FOUND # BICLOPS_INCLUDE_DIRS # BICLOPS_LIBRARIES # # Authors: # Fabien Spindler # ############################################################################# IF(NOT UNIX AND NOT WIN32) # MESSAGE("FindBICLOPS.cmake: macro only for Unix and Windows for the moment.") SET(BICLOPS_FOUND FALSE) ELSE(NOT UNIX AND NOT WIN32) FIND_PATH(BICLOPS_INCLUDE_DIR Biclops.h $ENV{BICLOPS_HOME}/include /usr/include ) #MESSAGE("DBG BICLOPS_INCLUDE_DIR=${BICLOPS_INCLUDE_DIR}") FIND_PATH(PMD_INCLUDE_DIR PMD.h $ENV{BICLOPS_HOME}/include $ENV{BICLOPS_PMD_HOME}/include /usr/include ) FIND_PATH(UTILS_INCLUDE_DIR utility.h $ENV{BICLOPS_HOME}/include $ENV{BICLOPS_UTILS_HOME}/include /usr/include ) FIND_LIBRARY(BICLOPS_LIBRARY NAMES Biclops libBiclops libBiclopsD PATHS $ENV{BICLOPS_HOME}/lib /usr/lib ) FIND_LIBRARY(PMD_LIBRARY NAMES PMD libPMD libPMDD PATHS $ENV{BICLOPS_HOME}/lib $ENV{BICLOPS_PMD_HOME}/lib /usr/lib ) FIND_LIBRARY(UTILS_LIBRARY NAMES Utils libUtils libUtilsD PATHS $ENV{BICLOPS_HOME}/lib $ENV{BICLOPS_UTILS_HOME}/lib /usr/lib ) #MESSAGE("DBG BICLOPS_LIBRARY=${BICLOPS_LIBRARY}") ## -------------------------------- IF(BICLOPS_LIBRARY AND PMD_LIBRARY AND UTILS_LIBRARY) SET(BICLOPS_LIBRARIES ${BICLOPS_LIBRARY} ${PMD_LIBRARY} ${UTILS_LIBRARY}) ELSE(BICLOPS_LIBRARY AND PMD_LIBRARY AND UTILS_LIBRARY) # MESSAGE(SEND_ERROR "Biclops library not found. Set USE_BICLOPS option OFF") ENDIF(BICLOPS_LIBRARY AND PMD_LIBRARY AND UTILS_LIBRARY) IF(NOT BICLOPS_INCLUDE_DIR) # MESSAGE(SEND_ERROR "Biclops include dir not found. Set USE_BICLOPS option OFF") ENDIF(NOT BICLOPS_INCLUDE_DIR) IF(NOT PMD_INCLUDE_DIR) # MESSAGE(SEND_ERROR "PMD include dir not found. Set USE_BICLOPS option OFF") ENDIF(NOT PMD_INCLUDE_DIR) IF(NOT UTILS_INCLUDE_DIR) # MESSAGE(SEND_ERROR "Utils include dir not found. Set USE_BICLOPS option OFF ") ENDIF(NOT UTILS_INCLUDE_DIR) IF(BICLOPS_INCLUDE_DIR AND PMD_INCLUDE_DIR AND UTILS_INCLUDE_DIR) SET(BICLOPS_INCLUDE_DIRS ${BICLOPS_INCLUDE_DIR} ${PMD_INCLUDE_DIR} ${UTILS_INCLUDE_DIR}) ENDIF(BICLOPS_INCLUDE_DIR AND PMD_INCLUDE_DIR AND UTILS_INCLUDE_DIR) IF(BICLOPS_LIBRARIES AND BICLOPS_INCLUDE_DIR AND PMD_INCLUDE_DIR AND UTILS_INCLUDE_DIR) #message("BICLOPS_LIBRARIES: ${BICLOPS_LIBRARIES}") #message("BICLOPS_INCLUDE_DIRS: ${BICLOPS_INCLUDE_DIRS}") # Try to compile a sample code using Biclops library to see if GetHomedState() is available #SET(BICLOPS_HAVE_GET_HOMED_STATE_FUNCTION FALSE) include(CheckCXXSourceCompiles) SET(CMAKE_REQUIRED_LIBRARIES ${BICLOPS_LIBRARIES}) SET(CMAKE_REQUIRED_INCLUDES ${BICLOPS_INCLUDE_DIRS}) CHECK_CXX_SOURCE_COMPILES(" #include int main(){ PMDAxisControl *axis; axis->GetHomedState(); return 0; } " BICLOPS_HAVE_GET_HOMED_STATE_FUNCTION) #MESSAGE("DBG1 BICLOPS_HAVE_GET_HOMED_STATE_FUNCTION ${BICLOPS_HAVE_GET_HOMED_STATE_FUNCTION}") SET(BICLOPS_FOUND TRUE) ELSE(BICLOPS_LIBRARIES AND BICLOPS_INCLUDE_DIR AND PMD_INCLUDE_DIR AND UTILS_INCLUDE_DIR) SET(BICLOPS_FOUND FALSE) ENDIF(BICLOPS_LIBRARIES AND BICLOPS_INCLUDE_DIR AND PMD_INCLUDE_DIR AND UTILS_INCLUDE_DIR) MARK_AS_ADVANCED( BICLOPS_INCLUDE_DIR BICLOPS_LIBRARIES BICLOPS_LIBRARY PMD_INCLUDE_DIR UTILS_INCLUDE_DIR PMD_LIBRARY UTILS_LIBRARY ) ENDIF(NOT UNIX AND NOT WIN32) visp-3.0.1/cmake/FindCALINUX.cmake000066400000000000000000000051351304511007300164600ustar00rootroot00000000000000############################################################################# # # This file is part of the ViSP software. # Copyright (C) 2005 - 2017 by Inria. All rights reserved. # # This software is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public License # ("GPL") version 2 as published by the Free Software Foundation. # See the file LICENSE.txt at the root directory of this source # distribution for additional information about the GNU GPL. # # For using ViSP with software that can not be combined with the GNU # GPL, please contact Inria about acquiring a ViSP Professional # Edition License. # # See http://visp.inria.fr for more information. # # This software was developed at: # Inria Rennes - Bretagne Atlantique # Campus Universitaire de Beaulieu # 35042 Rennes Cedex # France # # If you have questions regarding the use of this file, please contact # Inria at visp@inria.fr # # This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE # WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. # # Description: # Try to find Cerebellum CA linux library material # # CALINUX_FOUND # CALINUX_INCLUDE_DIRS # CALINUX_LIBRARIES # # Authors: # Fabien Spindler # ############################################################################# IF(NOT UNIX) # MESSAGE("FindCALINUX.cmake: only available for Unix.") SET(CALINUX_FOUND FALSE) ELSE(NOT UNIX) FIND_PATH(CALINUX_INCLUDE_DIR calinux.h $ENV{CALINUX_HOME}/include /local/soft/Cerebellum/CALinux/current/include /home/soft/Cerebellum/CALinux/current/include ) #MESSAGE("DBG CALINUX_INCLUDE_DIR=${CALINUX_INCLUDE_DIR}") FIND_LIBRARY(CALINUX_LIBRARY NAMES calinux PATHS $ENV{CALINUX_HOME}/lib /local/soft/Cerebellum/CALinux/current/lib /home/soft/Cerebellum/CALinux/current/lib ) #MESSAGE("DBG CALINUX_LIBRARY=${CALINUX_LIBRARY}") ## -------------------------------- IF(CALINUX_LIBRARY) SET(CALINUX_LIBRARIES ${CALINUX_LIBRARY}) ELSE(CALINUX_LIBRARY) # MESSAGE(SEND_ERROR "Calinux library not found.") ENDIF(CALINUX_LIBRARY) IF(NOT CALINUX_INCLUDE_DIR) # MESSAGE(SEND_ERROR "Calinux include dir not found.") ENDIF(NOT CALINUX_INCLUDE_DIR) IF(CALINUX_LIBRARIES AND CALINUX_INCLUDE_DIR) SET(CALINUX_INCLUDE_DIRS ${CALINUX_INCLUDE_DIR}) SET(CALINUX_FOUND TRUE) ELSE(CALINUX_LIBRARIES AND CALINUX_INCLUDE_DIR) SET(CALINUX_FOUND FALSE) ENDIF(CALINUX_LIBRARIES AND CALINUX_INCLUDE_DIR) MARK_AS_ADVANCED( CALINUX_INCLUDE_DIR CALINUX_LIBRARIES CALINUX_LIBRARY ) ENDIF(NOT UNIX) visp-3.0.1/cmake/FindCMU1394.cmake000066400000000000000000000063041304511007300163210ustar00rootroot00000000000000############################################################################# # # This file is part of the ViSP software. # Copyright (C) 2005 - 2017 by Inria. All rights reserved. # # This software is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public License # ("GPL") version 2 as published by the Free Software Foundation. # See the file LICENSE.txt at the root directory of this source # distribution for additional information about the GNU GPL. # # For using ViSP with software that can not be combined with the GNU # GPL, please contact Inria about acquiring a ViSP Professional # Edition License. # # See http://visp.inria.fr for more information. # # This software was developed at: # Inria Rennes - Bretagne Atlantique # Campus Universitaire de Beaulieu # 35042 Rennes Cedex # France # # If you have questions regarding the use of this file, please contact # Inria at visp@inria.fr # # This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE # WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. # # Description: # Try to find CMU 1394 Digital Camera SDK to acquire images from firewire # cameras on Windows. # Once run this will define: # # CMU1394_FOUND # CMU1394_INCLUDE_DIRS # CMU1394_LIBRARIES # # Authors: # Fabien Spindler # ############################################################################# if(WIN32) FIND_PATH(CMU1394_INCLUDE_DIR 1394Camera.h $ENV{CMU1394_HOME}/include "C:/Program Files (x86)/CMU/1394Camera/include" "C:/Program Files/CMU/1394Camera/include" ) #MESSAGE("DBG CMU1394_INCLUDE_DIR=${CMU1394_INCLUDE_DIR}") if(CMAKE_CL_64) FIND_LIBRARY(CMU1394_LIBRARY_DEBUG NAMES 1394camerad PATHS $ENV{CMU1394_HOME}/lib64/x64 "C:/Program Files (x86)/CMU/1394Camera/lib64/x64" "C:/Program Files/CMU/1394Camera/lib64/x64" ) FIND_LIBRARY(CMU1394_LIBRARY_RELEASE NAMES 1394camera PATHS $ENV{CMU1394_HOME}/lib64/x64 "C:/Program Files (x86)/CMU/1394Camera/lib64/x64" "C:/Program Files/CMU/1394Camera/lib64/x64" ) else() FIND_LIBRARY(CMU1394_LIBRARY_DEBUG NAMES 1394camerad PATHS $ENV{CMU1394_HOME}/lib "C:/Program Files (x86)/CMU/1394Camera/lib" "C:/Program Files/CMU/1394Camera/lib" ) FIND_LIBRARY(CMU1394_LIBRARY_RELEASE NAMES 1394camera PATHS $ENV{CMU1394_HOME}/lib "C:/Program Files (x86)/CMU/1394Camera/lib" "C:/Program Files/CMU/1394Camera/lib" ) endif() #MESSAGE("DBG CMU1394_LIBRARY_DEBUG=${CMU1394_LIBRARY_DEBUG}") #MESSAGE("DBG CMU1394_LIBRARY_RELEASE=${CMU1394_LIBRARY_RELEASE}") set(CMU1394_LIBRARIES "") if(CMU1394_LIBRARY_RELEASE AND CMU1394_INCLUDE_DIR) set(CMU1394_INCLUDE_DIRS ${CMU1394_INCLUDE_DIR}) list(APPEND CMU1394_LIBRARIES optimized ${CMU1394_LIBRARY_RELEASE}) set(CMU1394_FOUND TRUE) endif() if(CMU1394_LIBRARY_DEBUG AND CMU1394_INCLUDE_DIR) set(CMU1394_INCLUDE_DIRS ${CMU1394_INCLUDE_DIR}) list(APPEND CMU1394_LIBRARIES debug ${CMU1394_LIBRARY_DEBUG}) set(CMU1394_FOUND TRUE) ENDIF() MARK_AS_ADVANCED( CMU1394_INCLUDE_DIR CMU1394_LIBRARY CMU1394_LIBRARY_DEBUG CMU1394_LIBRARY_RELEASE ) endif() visp-3.0.1/cmake/FindCPP11.cmake000066400000000000000000000041661304511007300161440ustar00rootroot00000000000000############################################################################# # # This file is part of the ViSP software. # Copyright (C) 2005 - 2017 by Inria. All rights reserved. # # This software is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public License # ("GPL") version 2 as published by the Free Software Foundation. # See the file LICENSE.txt at the root directory of this source # distribution for additional information about the GNU GPL. # # For using ViSP with software that can not be combined with the GNU # GPL, please contact Inria about acquiring a ViSP Professional # Edition License. # # See http://visp.inria.fr for more information. # # This software was developed at: # Inria Rennes - Bretagne Atlantique # Campus Universitaire de Beaulieu # 35042 Rennes Cedex # France # # If you have questions regarding the use of this file, please contact # Inria at visp@inria.fr # # This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE # WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. # # Description: # Try to find C++11 flags. # # CPP11_FOUND - true if C++11 support is detected # CPP11_CXX_FLAGS - flags to add to the CXX compiler for C++11 support # # Authors: # Fabien Spindler include(CheckCXXCompilerFlag) include(FindPackageHandleStandardArgs) set(CPP11_CXX_FLAG_CANDIDATES "-std=c++11" "-std=gnu++11" ) # check CXX c++11 compiler flag foreach(FLAG ${CPP11_CXX_FLAG_CANDIDATES}) set(SAFE_CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS}") set(CMAKE_REQUIRED_FLAGS "${FLAG}") unset(CPP11_FLAG_DETECTED CACHE) message(STATUS "Try C++11 flag = [${FLAG}]") CHECK_CXX_COMPILER_FLAG(${FLAG} CPP11_FLAG_DETECTED) set(CMAKE_REQUIRED_FLAGS "${SAFE_CMAKE_REQUIRED_FLAGS}") if(CPP11_FLAG_DETECTED) set(CPP11_CXX_FLAGS_INTERNAL "${FLAG}") break() endif() endforeach() set(CPP11_CXX_FLAGS "${CPP11_CXX_FLAGS_INTERNAL}" CACHE STRING "C++ compiler flags for C++11 support") # handle the standard arguments for find_package find_package_handle_standard_args(CPP11 DEFAULT_MSG CPP11_CXX_FLAGS ) mark_as_advanced( CPP11_CXX_FLAGS ) visp-3.0.1/cmake/FindComedi.cmake000066400000000000000000000035441304511007300165570ustar00rootroot00000000000000############################################################################# # # This file is part of the ViSP software. # Copyright (C) 2005 - 2017 by Inria. All rights reserved. # # This software is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public License # ("GPL") version 2 as published by the Free Software Foundation. # See the file LICENSE.txt at the root directory of this source # distribution for additional information about the GNU GPL. # # For using ViSP with software that can not be combined with the GNU # GPL, please contact Inria about acquiring a ViSP Professional # Edition License. # # See http://visp.inria.fr for more information. # # This software was developed at: # Inria Rennes - Bretagne Atlantique # Campus Universitaire de Beaulieu # 35042 Rennes Cedex # France # # If you have questions regarding the use of this file, please contact # Inria at visp@inria.fr # # This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE # WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. # # Description: # Try to find comedi library # # COMEDI_FOUND # COMEDI_INCLUDE_DIRS # COMEDI_LIBRARIES # COMEDI_VERSION # # Authors: # Fabien Spindler # ############################################################################# find_path(COMEDI_INCLUDE_DIRS comedilib.h PATHS $ENV{COMEDI_HOME}/include /usr/include /usr/local/include ) find_library(COMEDI_LIBRARIES NAMES comedi PATHS $ENV{COMEDI_HOME}/lib /usr/lib /usr/local/lib ) if(COMEDI_LIBRARIES AND COMEDI_INCLUDE_DIRS) set(COMEDI_FOUND TRUE) get_filename_component(COMEDI_LIB_DIR ${COMEDI_LIBRARIES} PATH) vp_get_version_from_pkg("comedilib" "${COMEDI_LIB_DIR}/pkgconfig" COMEDI_VERSION) else() set(COMEDI_FOUND FALSE) endif() mark_as_advanced( COMEDI_INCLUDE_DIRS COMEDI_LIBRARIES ) visp-3.0.1/cmake/FindDC1394.cmake000066400000000000000000000113711304511007300161630ustar00rootroot00000000000000############################################################################# # # This file is part of the ViSP software. # Copyright (C) 2005 - 2017 by Inria. All rights reserved. # # This software is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public License # ("GPL") version 2 as published by the Free Software Foundation. # See the file LICENSE.txt at the root directory of this source # distribution for additional information about the GNU GPL. # # For using ViSP with software that can not be combined with the GNU # GPL, please contact Inria about acquiring a ViSP Professional # Edition License. # # See http://visp.inria.fr for more information. # # This software was developed at: # Inria Rennes - Bretagne Atlantique # Campus Universitaire de Beaulieu # 35042 Rennes Cedex # France # # If you have questions regarding the use of this file, please contact # Inria at visp@inria.fr # # This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE # WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. # # Description: # Try to find libDC1394 for IEEE1394 camera. First search for libdc1394-2.x # and if not found, search for libdc1394-1.x # Once run this will define: # # DC1394_FOUND # DC1394_INCLUDE_DIRS # DC1394_LIBRARIES # DC1394_VERSION # # The two defines below are only useful to compile with libdc1394-2.x. In # that case DC1394_VERSION=2. Since the libdc1394-2.x API is not stable, we # need to determine if dc1394_find_cameras() or dc1394_enumerate_cameras() # functions are available. dc1394_enumerate_cameras() was introduced after # libdc1394-2.0.0-rc7. DC1394_CAMERA_ENUMERATE_FOUND is TRUE when # dc1394_camera_enumerate() function is found. DC1394_FIND_CAMERAS_FOUND is # TRUE when dc1394_find_cameras() is found. # DC1394_CAMERA_ENUMERATE_FOUND # DC1394_FIND_CAMERAS_FOUND # # Authors: # Fabien Spindler # ############################################################################# if(NOT UNIX) # MESSAGE("FindDC1394.cmake: libdc1394 only available for Unix.") set(DC1394_FOUND FALSE) else(NOT UNIX) # Search for libdc1394-2.x find_path(DC1394_INCLUDE_DIR dc1394/control.h $ENV{DC1394_HOME}/include $ENV{DC1394_DIR}/include /usr/include ) #MESSAGE("DBG DC1394_INCLUDE_DIR=${DC1394_INCLUDE_DIR}") find_library(DC1394_LIBRARY NAMES dc1394 PATHS $ENV{DC1394_HOME}/lib $ENV{DC1394_DIR}/lib /usr/lib ) #MESSAGE("DBG DC1394_LIBRARY=${DC1394_LIBRARY}") if(DC1394_LIBRARY AND DC1394_INCLUDE_DIR) if(CMAKE_CROSSCOMPILING) set(DC1394_LIBRARIES ${DC1394_LIBRARY}) set(DC1394_INCLUDE_DIRS ${DC1394_INCLUDE_DIR}) set(DC1394_CAMERA_ENUMERATE_FOUND TRUE) set(DC1394_FOUND TRUE) else() # Since the libdc1394-2.x API is not stable, try to compile a # sample code to determine if we have to use dc1394_find_cameras() or # dc1394_enumerate_cameras() functions. dc1394_enumerate_cameras() was # introduced after libdc1394-2.0.0-rc7 include(CheckCXXSourceCompiles) set(CMAKE_REQUIRED_LIBRARIES ${DC1394_LIBRARY}) set(CMAKE_REQUIRED_INCLUDES ${DC1394_INCLUDE_DIR}) check_cxx_source_compiles(" #include #include int main(){ dc1394_t * d; dc1394camera_list_t * list; d = dc1394_new (); dc1394_camera_enumerate (d, &list); return 0; } " DC1394_CAMERA_ENUMERATE_FOUND) #MESSAGE("DC1394_CAMERA_ENUMERATE_FOUND: ${DC1394_CAMERA_ENUMERATE_FOUND}") if(NOT DC1394_CAMERA_ENUMERATE_FOUND) # Try to test the compatibility to libdc1394-2.0.0-rc7 check_cxx_source_compiles(" #include #include int main(){ dc1394camera_t **cameras; unsigned int num_cameras; dc1394_find_cameras(&cameras, &num_cameras); return 0; } " DC1394_FIND_CAMERAS_FOUND) #MESSAGE("DC1394_FIND_CAMERAS_FOUND: ${DC1394_FIND_CAMERAS_FOUND}") endif() if(NOT DC1394_CAMERA_ENUMERATE_FOUND AND NOT DC1394_FIND_CAMERAS_FOUND) set(DC1394_FOUND FALSE) message("libdc1394-2.x found but not compatible with ViSP...") else() set(DC1394_FOUND TRUE) endif() set(DC1394_LIBRARIES ${DC1394_LIBRARY}) set(DC1394_INCLUDE_DIRS ${DC1394_INCLUDE_DIR}) endif() get_filename_component(DC1394_LIB_DIR ${DC1394_LIBRARY} PATH) vp_get_version_from_pkg("libdc1394-2" "${DC1394_LIB_DIR}/pkgconfig" DC1394_VERSION) endif() ## -------------------------------- mark_as_advanced( DC1394_LIBRARY DC1394_INCLUDE_DIR DC1394_LIB_DIR DC1394_LIBRARIES DC1394_LIBRARY ) endif(NOT UNIX) visp-3.0.1/cmake/FindDIRECT3D.cmake000066400000000000000000000107351304511007300165200ustar00rootroot00000000000000############################################################################# # # This file is part of the ViSP software. # Copyright (C) 2005 - 2017 by Inria. All rights reserved. # # This software is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public License # ("GPL") version 2 as published by the Free Software Foundation. # See the file LICENSE.txt at the root directory of this source # distribution for additional information about the GNU GPL. # # For using ViSP with software that can not be combined with the GNU # GPL, please contact Inria about acquiring a ViSP Professional # Edition License. # # See http://visp.inria.fr for more information. # # This software was developed at: # Inria Rennes - Bretagne Atlantique # Campus Universitaire de Beaulieu # 35042 Rennes Cedex # France # # If you have questions regarding the use of this file, please contact # Inria at visp@inria.fr # # This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE # WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. # # Description: # Try to find Direct3D on Windows. This code comes originaly # from http://www.cmake.org/Wiki/CMakeUserFindDirectShow . # Once loaded this will define: # # DIRECT3D_FOUND - system has DirectShow # DIRECT3D_INCLUDE_DIRS - include directory for DirectShow # DIRECT3D_LIBRARIES - libraries you need to link to # # Authors: # Bruno Renier # ############################################################################# SET(DIRECT3D_FOUND "NO") # Direct3D is only available on Windows platforms IF(WIN32 AND NOT MINGW) # Find Direct3D Include Directory FIND_PATH(DIRECT3D_INCLUDE_DIR d3dx9.h "$ENV{DXSDK_DIR}/Include" "C:/Program Files/Microsoft DirectX SDK/Include" "C:/DXSDK/Include" NO_DEFAULT_PATH DOC "What is the path where the file d3dx9.h can be found" ) FIND_PATH(DIRECT3D_INCLUDE_DIR d3dx9.h NO_DEFAULT_PATH DOC "What is the path where the file d3dx9.h can be found" ) # if Direct3D include dir found, then find Direct3D libraries IF(DIRECT3D_INCLUDE_DIR) IF(CMAKE_CL_64) FIND_LIBRARY(DIRECT3D_d3d9_LIBRARY d3d9 "$ENV{DXSDK_DIR}/Lib" "$ENV{DXSDK_DIR}/Lib/x64" "C:/Program Files/Microsoft DirectX SDK/Lib/x64" "C:/DXSDK/Include/Lib/x64" NO_DEFAULT_PATH DOC "Where can the Direct3D d3d9 library be found" ) ELSE(CMAKE_CL_64) FIND_LIBRARY(DIRECT3D_d3d9_LIBRARY d3d9 "$ENV{DXSDK_DIR}/Lib" "$ENV{DXSDK_DIR}/Lib/x86" "C:/Program Files/Microsoft DirectX SDK/Lib/x86" "C:/DXSDK/Include/Lib/x86" NO_DEFAULT_PATH DOC "Where can the Direct3D d3d9 library be found" ) ENDIF(CMAKE_CL_64) FIND_LIBRARY(DIRECT3D_d3d9_LIBRARY d3d9 DOC "Where can the Direct3D d3d9 library be found" ) IF(CMAKE_CL_64) FIND_LIBRARY(DIRECT3D_d3dx9_LIBRARY d3dx9 "$ENV{DXSDK_DIR}/Lib/" "$ENV{DXSDK_DIR}/Lib/x64" "C:/Program Files/Microsoft DirectX SDK/Lib/x64" "C:/DXSDK/Include/Lib/x64" NO_DEFAULT_PATH DOC "Where can the Direct3D d3dx9 library be found" ) ELSE(CMAKE_CL_64) FIND_LIBRARY(DIRECT3D_d3dx9_LIBRARY d3dx9 "$ENV{DXSDK_DIR}/Lib/" "$ENV{DXSDK_DIR}/Lib/x86" "C:/Program Files/Microsoft DirectX SDK/Lib/x86" "C:/DXSDK/Include/Lib/x86" NO_DEFAULT_PATH DOC "Where can the Direct3D d3dx9 library be found" ) ENDIF(CMAKE_CL_64) FIND_LIBRARY(DIRECT3D_d3dx9_LIBRARY d3dx9 DOC "Where can the Direct3D d3dx9 library be found" ) # if Direct3D libraries found, then we're ok IF(DIRECT3D_d3d9_LIBRARY) IF(DIRECT3D_d3dx9_LIBRARY) # everything found SET(DIRECT3D_FOUND "YES") ENDIF(DIRECT3D_d3dx9_LIBRARY) ENDIF(DIRECT3D_d3d9_LIBRARY) ENDIF(DIRECT3D_INCLUDE_DIR) MARK_AS_ADVANCED( DIRECT3D_INCLUDE_DIR DIRECT3D_d3d9_LIBRARY DIRECT3D_d3dx9_LIBRARY ) ENDIF(WIN32 AND NOT MINGW) #--------------------------------------------------------------------- IF(DIRECT3D_FOUND) SET(DIRECT3D_INCLUDE_DIRS ${DIRECT3D_INCLUDE_DIR}) SET(DIRECT3D_LIBRARIES "${DIRECT3D_d3d9_LIBRARY}" "${DIRECT3D_d3dx9_LIBRARY}" ) ELSE(DIRECT3D_FOUND) # make FIND_PACKAGE friendly IF(NOT DIRECT3D_FIND_QUIETLY) IF(DIRECT3D_FIND_REQUIRED) MESSAGE(FATAL_ERROR "Direct3D required, please specify it's location.") ENDIF(DIRECT3D_FIND_REQUIRED) ENDIF(NOT DIRECT3D_FIND_QUIETLY) ENDIF(DIRECT3D_FOUND) visp-3.0.1/cmake/FindDIRECTSHOW.cmake000066400000000000000000000261421304511007300170310ustar00rootroot00000000000000############################################################################# # # This file is part of the ViSP software. # Copyright (C) 2005 - 2017 by Inria. All rights reserved. # # This software is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public License # ("GPL") version 2 as published by the Free Software Foundation. # See the file LICENSE.txt at the root directory of this source # distribution for additional information about the GNU GPL. # # For using ViSP with software that can not be combined with the GNU # GPL, please contact Inria about acquiring a ViSP Professional # Edition License. # # See http://visp.inria.fr for more information. # # This software was developed at: # Inria Rennes - Bretagne Atlantique # Campus Universitaire de Beaulieu # 35042 Rennes Cedex # France # # If you have questions regarding the use of this file, please contact # Inria at visp@inria.fr # # This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE # WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. # # Description: # Try to find Direct Show on Windows. This code comes originaly # from http://www.cmake.org/Wiki/CMakeUserFindDirectShow . # Once loaded this will define: # # DIRECTSHOW_FOUND - system has DirectShow # DIRECTSHOW_INCLUDE_DIRS - include directory for DirectShow # DIRECTSHOW_LIBRARIES - libraries you need to link to # # Authors: # Fabien Spindler # ############################################################################# SET(DIRECTSHOW_FOUND "NO") # DirectShow is only available on Windows platforms IF(WIN32 AND NOT MINGW) # find DirectX FIND_PATH(DIRECTX_INCLUDE_PATH ddraw.h "$ENV{DXSDK_DIR}/Include" "C:/Program Files/Microsoft SDKs/Windows/v6.1/Include" "C:/Program Files/Microsoft SDKs/Windows/v6.0/Include" "C:/Program Files/Microsoft SDKs/Windows/v6.0A/Include" "C:/Program Files/Microsoft SDKs/Windows/v7.0A/Include" "C:/DXSDK/include" "C:/Program Files/Microsoft Platform SDK/Include" "C:/Program Files/Microsoft Visual Studio .NET 2003/Vc7/PlatformSDK/Include" NO_DEFAULT_PATH DOC "What is the path where the file ddraw.h can be found" ) FIND_PATH(DIRECTX_INCLUDE_PATH ddraw.h DOC "What is the path where the file ddraw.h can be found" ) # find DirectShow include directory FIND_PATH(DIRECTSHOW_dshow_INCLUDE_PATH dshow.h "$ENV{WINSDK_HOME}/Include" "$ENV{DXSDK_DIR}/Include" "C:/Program Files/Microsoft SDKs/Windows/v6.1/Include" "C:/Program Files/Microsoft SDKs/Windows/v6.0/Include" "C:/Program Files/Microsoft SDKs/Windows/v6.0A/Include" "C:/Program Files/Microsoft SDKs/Windows/v7.0A/Include" "C:/DXSDK/include" "C:/Program Files/Microsoft Platform SDK/Include" "C:/Program Files/Microsoft Visual Studio .NET 2003/Vc7/PlatformSDK/Include" NO_DEFAULT_PATH DOC "What is the path where the file dshow.h can be found" ) FIND_PATH(DIRECTSHOW_dshow_INCLUDE_PATH dshow.h DOC "What is the path where the file dshow.h can be found" ) FIND_PATH(DIRECTSHOW_qedit_INCLUDE_PATH qedit.h "$ENV{WINSDK_HOME}/Include" "$ENV{DXSDK_DIR}/Include" "C:/Program Files/Microsoft SDKs/Windows/v6.1/Include" "C:/Program Files/Microsoft SDKs/Windows/v6.0/Include" "C:/Program Files/Microsoft SDKs/Windows/v6.0A/Include" "C:/Program Files/Microsoft SDKs/Windows/v7.0A/Include" "C:/DXSDK/include" "C:/Program Files/Microsoft Platform SDK/Include" "C:/Program Files/Microsoft Visual Studio .NET 2003/Vc7/PlatformSDK/Include" NO_DEFAULT_PATH DOC "What is the path where the file qedit.h can be found" ) FIND_PATH(DIRECTSHOW_qedit_INCLUDE_PATH qedit.h DOC "What is the path where the file qedit.h can be found" ) FIND_PATH(DIRECTSHOW_atlbase_INCLUDE_PATH atlbase.h DOC "What is the path where the file atlbase.h can be found" ) # Specific path search for Visual Studio .NET 2003 IF(MSVC71) IF(NOT DIRECTSHOW_atlbase_INCLUDE_PATH) FIND_PATH(DIRECTSHOW_atlbase_INCLUDE_PATH atlbase.h "C:/Program Files/Microsoft Visual Studio .NET 2003/Vc7/atlmfc/include" "$ENV{VS71COMNTOOLS}/../../Vc7/atlmfc/include" DOC "What is the path where the file atlbase.h can be found" ) ENDIF(NOT DIRECTSHOW_atlbase_INCLUDE_PATH) ENDIF(MSVC71) # Specific path search for Visual Studio 2005 IF(MSVC80) IF(NOT DIRECTSHOW_atlbase_INCLUDE_PATH) FIND_PATH(DIRECTSHOW_atlbase_INCLUDE_PATH atlbase.h "C:/Program Files/Microsoft Visual Studio 8/VC/atlmfc/include" "$ENV{VS80COMNTOOLS}/../../VC/atlmfc/include" DOC "What is the path where the file atlbase.h can be found" ) ENDIF(NOT DIRECTSHOW_atlbase_INCLUDE_PATH) ENDIF(MSVC80) # Specific path search for Visual Studio 2008 IF(MSVC90) IF(NOT DIRECTSHOW_atlbase_INCLUDE_PATH) FIND_PATH(DIRECTSHOW_atlbase_INCLUDE_PATH atlbase.h "C:/Program Files/Microsoft Visual Studio 9.0/VC/atlmfc/include" "$ENV{VS90COMNTOOLS}/../../VC/atlmfc/include" DOC "What is the path where the file atlbase.h can be found" ) ENDIF(NOT DIRECTSHOW_atlbase_INCLUDE_PATH) ENDIF(MSVC90) # Specific path search for Visual Studio 2008 IF(MSVC10) IF(NOT DIRECTSHOW_atlbase_INCLUDE_PATH) FIND_PATH(DIRECTSHOW_atlbase_INCLUDE_PATH atlbase.h "C:/Program Files/Microsoft Visual Studio 10.0/VC/atlmfc/include" "$ENV{VS100COMNTOOLS}/../../VC/atlmfc/include" DOC "What is the path where the file atlbase.h can be found" ) ENDIF(NOT DIRECTSHOW_atlbase_INCLUDE_PATH) ENDIF(MSVC10) IF(DIRECTX_INCLUDE_PATH AND DIRECTSHOW_dshow_INCLUDE_PATH AND DIRECTSHOW_qedit_INCLUDE_PATH AND DIRECTSHOW_atlbase_INCLUDE_PATH) SET(DIRECTSHOW_INCLUDE_DIRS ${DIRECTX_INCLUDE_PATH} ${DIRECTSHOW_dshow_INCLUDE_PATH} ${DIRECTSHOW_qedit_INCLUDE_PATH} ${DIRECTSHOW_atlbase_INCLUDE_PATH}) ENDIF(DIRECTX_INCLUDE_PATH AND DIRECTSHOW_dshow_INCLUDE_PATH AND DIRECTSHOW_qedit_INCLUDE_PATH AND DIRECTSHOW_atlbase_INCLUDE_PATH) # if DirectShow include dir found, then find DirectShow libraries IF(DIRECTSHOW_INCLUDE_DIRS) IF(CMAKE_CL_64) FIND_LIBRARY(DIRECTSHOW_strmiids_LIBRARY NAMES strmiids PATHS "$ENV{WINSDK_HOME}/Lib/x64" "$ENV{DXSDK_DIR}/Lib/x64" "C:/Program Files/Microsoft SDKs/Windows/v6.1/Lib/x64" "C:/Program Files/Microsoft SDKs/Windows/v6.0/Lib/x64" "C:/Program Files/Microsoft SDKs/Windows/v6.0A/Lib/x64" "C:/Program Files/Microsoft SDKs/Windows/v7.0A/Lib/x64" "C:/DXSDK/lib/x64" "C:/Program Files/Microsoft Visual Studio .NET 2003/Vc7/PlatformSDK/Lib/x64" "C:/Program Files/Microsoft Platform SDK/Lib/x64" NO_DEFAULT_PATH DOC "Where can the DirectShow strmiids library be found" ) ELSE(CMAKE_CL_64) FIND_LIBRARY(DIRECTSHOW_strmiids_LIBRARY NAMES strmiids PATHS "$ENV{WINSDK_HOME}/Lib" "$ENV{WINSDK_HOME}/Lib/x86" "$ENV{DXSDK_DIR}/Lib" "$ENV{DXSDK_DIR}/Lib/x86" "C:/Program Files/Microsoft SDKs/Windows/v6.1/Lib" "C:/Program Files/Microsoft SDKs/Windows/v6.1/Lib/x86" "C:/Program Files/Microsoft SDKs/Windows/v6.0/Lib" "C:/Program Files/Microsoft SDKs/Windows/v6.0A/Lib" "C:/Program Files/Microsoft SDKs/Windows/v6.0/Lib/x86" "C:/Program Files/Microsoft SDKs/Windows/v6.0A/Lib/x86" "C:/Program Files/Microsoft SDKs/Windows/v7.0A/Lib" "C:/DXSDK/lib" "C:/DXSDK/lib/x64" "C:/Program Files/Microsoft Visual Studio .NET 2003/Vc7/PlatformSDK/Lib" "C:/Program Files/Microsoft Platform SDK/Lib" NO_DEFAULT_PATH DOC "Where can the DirectShow strmiids library be found" ) ENDIF(CMAKE_CL_64) FIND_LIBRARY(DIRECTSHOW_strmiids_LIBRARY NAMES strmiids DOC "Where can the DirectShow strmiids library be found" ) IF(CMAKE_CL_64) FIND_LIBRARY(DIRECTSHOW_quartz_LIBRARY NAMES quartz PATHS "$ENV{WINSDK_HOME}/Lib/x64" "$ENV{DXSDK_DIR}/Lib/x64" "C:/DXSDK/lib/x64" "C:/Program Files/Microsoft SDKs/Windows/v6.1/Lib/x64" "C:/Program Files/Microsoft SDKs/Windows/v6.0/Lib/x64" "C:/Program Files/Microsoft SDKs/Windows/v6.0A/Lib/x64" "C:/Program Files/Microsoft Visual Studio .NET 2003/Vc7/PlatformSDK/Lib/x64" "C:/Program Files/Microsoft Platform SDK/Lib/x64" "C:/Program Files/Microsoft SDKs/Windows/v7.0A/Lib/x64" NO_DEFAULT_PATH DOC "Where can the DirectShow quartz library be found" ) ELSE(CMAKE_CL_64) FIND_LIBRARY(DIRECTSHOW_quartz_LIBRARY NAMES quartz PATHS "$ENV{WINSDK_HOME}/Lib/x86" "$ENV{DXSDK_DIR}/Lib/x86" "C:/DXSDK/lib/x86" "C:/Program Files/Microsoft SDKs/Windows/v6.1/Lib/x86" "C:/Program Files/Microsoft SDKs/Windows/v6.0/Lib/x86" "C:/Program Files/Microsoft SDKs/Windows/v6.0A/Lib/x86" "C:/Program Files/Microsoft Visual Studio .NET 2003/Vc7/PlatformSDK/Lib/x86" "C:/Program Files/Microsoft Platform SDK/Lib/x86" "C:/Program Files/Microsoft SDKs/Windows/v7.0A" "$ENV{WINSDK_HOME}/Lib" "$ENV{DXSDK_DIR}/Lib" "C:/DXSDK/lib" "C:/Program Files/Microsoft SDKs/Windows/v6.1/Lib" "C:/Program Files/Microsoft SDKs/Windows/v6.0/Lib" "C:/Program Files/Microsoft SDKs/Windows/v6.0A/Lib" "C:/Program Files/Microsoft Visual Studio .NET 2003/Vc7/PlatformSDK/Lib" "C:/Program Files/Microsoft Platform SDK/Lib" NO_DEFAULT_PATH DOC "Where can the DirectShow quartz library be found" ) ENDIF(CMAKE_CL_64) FIND_LIBRARY(DIRECTSHOW_quartz_LIBRARY NAMES quartz DOC "Where can the DirectShow quartz library be found" ) # if DirectShow libraries found, then we're ok IF(DIRECTSHOW_strmiids_LIBRARY) IF(DIRECTSHOW_quartz_LIBRARY) # everything found SET(DIRECTSHOW_FOUND "YES") ENDIF(DIRECTSHOW_quartz_LIBRARY) ENDIF(DIRECTSHOW_strmiids_LIBRARY) ENDIF(DIRECTSHOW_INCLUDE_DIRS) MARK_AS_ADVANCED( DIRECTSHOW_INCLUDE_DIRS DIRECTSHOW_strmiids_LIBRARY DIRECTSHOW_quartz_LIBRARY DIRECTX_INCLUDE_PATH DIRECTSHOW_dshow_INCLUDE_PATH DIRECTSHOW_qedit_INCLUDE_PATH DIRECTSHOW_atlbase_INCLUDE_PATH ) ENDIF(WIN32 AND NOT MINGW) #--------------------------------------------------------------------- IF(DIRECTSHOW_FOUND) SET(DIRECTSHOW_LIBRARIES ${DIRECTSHOW_strmiids_LIBRARY} ${DIRECTSHOW_quartz_LIBRARY} ) ELSE(DIRECTSHOW_FOUND) # make FIND_PACKAGE friendly IF(NOT DIRECTSHOW_FIND_QUIETLY) IF(DIRECTSHOW_FIND_REQUIRED) MESSAGE(FATAL_ERROR "DirectShow required, please specify it's location.") ENDIF(DIRECTSHOW_FIND_REQUIRED) ENDIF(NOT DIRECTSHOW_FIND_QUIETLY) ENDIF(DIRECTSHOW_FOUND) visp-3.0.1/cmake/FindDL.cmake000066400000000000000000000031231304511007300156470ustar00rootroot00000000000000############################################################################# # # This file is part of the ViSP software. # Copyright (C) 2005 - 2017 by Inria. All rights reserved. # # This software is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public License # ("GPL") version 2 as published by the Free Software Foundation. # See the file LICENSE.txt at the root directory of this source # distribution for additional information about the GNU GPL. # # For using ViSP with software that can not be combined with the GNU # GPL, please contact Inria about acquiring a ViSP Professional # Edition License. # # See http://visp.inria.fr for more information. # # This software was developed at: # Inria Rennes - Bretagne Atlantique # Campus Universitaire de Beaulieu # 35042 Rennes Cedex # France # # If you have questions regarding the use of this file, please contact # Inria at visp@inria.fr # # This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE # WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. # # Description: # Try to find dl library. # Once run this will define: # # DL_FOUND # DL_LIBRARIES # # Authors: # Fabien Spindler # ############################################################################# FIND_LIBRARY(DL_LIBRARY NAMES dl PATHS $ENV{DL_HOME}/lib /usr/lib /usr/local/lib ) #MESSAGE("DBG DL_LIBRARY=${DL_LIBRARY}") IF(DL_LIBRARY) SET(DL_LIBRARIES ${DL_LIBRARY}) SET(DL_FOUND TRUE) ELSE() SET(DL_FOUND FALSE) ENDIF() MARK_AS_ADVANCED( DL_LIBRARY ) visp-3.0.1/cmake/FindDMTX.cmake000066400000000000000000000035111304511007300161250ustar00rootroot00000000000000############################################################################# # # This file is part of the ViSP software. # Copyright (C) 2005 - 2017 by Inria. All rights reserved. # # This software is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public License # ("GPL") version 2 as published by the Free Software Foundation. # See the file LICENSE.txt at the root directory of this source # distribution for additional information about the GNU GPL. # # For using ViSP with software that can not be combined with the GNU # GPL, please contact Inria about acquiring a ViSP Professional # Edition License. # # See http://visp.inria.fr for more information. # # This software was developed at: # Inria Rennes - Bretagne Atlantique # Campus Universitaire de Beaulieu # 35042 Rennes Cedex # France # # If you have questions regarding the use of this file, please contact # Inria at visp@inria.fr # # This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE # WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. # # Description: # Try to find dmtx library. # Once run this will define: # # DMTX_FOUND # DMTX_INCLUDE_DIRS # DMTX_LIBRARIES # DMTX_VERSION # # Authors: # Fabien Spindler # ############################################################################# find_path(DMTX_INCLUDE_DIRS dmtx.h $ENV{DMTX_DIR}/include /usr/include /usr/local/include ) find_library(DMTX_LIBRARIES NAMES dmtx PATHS $ENV{DMTX_DIR}/lib /usr/lib /usr/local/lib ) if(DMTX_INCLUDE_DIRS AND DMTX_LIBRARIES) set(DMTX_FOUND TRUE) get_filename_component(DMTX_LIB_DIR ${DMTX_LIBRARIES} PATH) vp_get_version_from_pkg("libdmtx" "${DMTX_LIB_DIR}/pkgconfig" DMTX_VERSION) else() set(DMTX_FOUND FALSE) endif() mark_as_advanced( DMTX_INCLUDE_DIRS DMTX_LIBRARIES ) visp-3.0.1/cmake/FindErfc.cmake000066400000000000000000000032101304511007300162240ustar00rootroot00000000000000############################################################################# # # This file is part of the ViSP software. # Copyright (C) 2005 - 2017 by Inria. All rights reserved. # # This software is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public License # ("GPL") version 2 as published by the Free Software Foundation. # See the file LICENSE.txt at the root directory of this source # distribution for additional information about the GNU GPL. # # For using ViSP with software that can not be combined with the GNU # GPL, please contact Inria about acquiring a ViSP Professional # Edition License. # # See http://visp.inria.fr for more information. # # This software was developed at: # Inria Rennes - Bretagne Atlantique # Campus Universitaire de Beaulieu # 35042 Rennes Cedex # France # # If you have questions regarding the use of this file, please contact # Inria at visp@inria.fr # # This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE # WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. # # Description: # Try to find erfc function. # # Authors: # Souriya Trinh # ############################################################################# include(CheckCXXSourceCompiles) macro(check_math_expr _expr _var) unset(${_var} CACHE) if(USE_CPP11) set(CMAKE_REQUIRED_FLAGS ${CPP11_CXX_FLAGS}) endif() check_cxx_source_compiles(" #include int main(int argc, char ** argv) { (void)${_expr}; return 0; } " ${_var}) endmacro() check_math_expr("erfc(1.0)" HAVE_FUNC_ERFC) check_math_expr("std::erfc(1.0)" HAVE_FUNC_STD_ERFC) visp-3.0.1/cmake/FindFFMPEG.cmake000066400000000000000000000160511304511007300163200ustar00rootroot00000000000000############################################################################# # # This file is part of the ViSP software. # Copyright (C) 2005 - 2017 by Inria. All rights reserved. # # This software is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public License # ("GPL") version 2 as published by the Free Software Foundation. # See the file LICENSE.txt at the root directory of this source # distribution for additional information about the GNU GPL. # # For using ViSP with software that can not be combined with the GNU # GPL, please contact Inria about acquiring a ViSP Professional # Edition License. # # See http://visp.inria.fr for more information. # # This software was developed at: # Inria Rennes - Bretagne Atlantique # Campus Universitaire de Beaulieu # 35042 Rennes Cedex # France # # If you have questions regarding the use of this file, please contact # Inria at visp@inria.fr # # This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE # WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. # # Description: # Try to find FFMPEG. FFMpeg depend son Zlib. # Once run this will define: # # FFMPEG_FOUND - system has FFMPEG # FFMPEG_INCLUDE_DIRS - the FFMPEG include directory # FFMPEG_LIBRARIES - Link these to use FFMPEG # # Authors: # Fabien Spindler # ############################################################################# # detection of the FFMPEG headers location if(MINGW) find_path(FFMPEG_INCLUDE_DIR_AVCODEC NAMES libavcodec/avcodec.h PATHS "$ENV{MINGW_DIR}/include" C:/mingw/include PATH_SUFFIXES ffmpeg ) find_path(FFMPEG_INCLUDE_DIR_AVFORMAT NAMES libavformat/avformat.h PATHS "$ENV{MINGW_DIR}/include" C:/mingw/include PATH_SUFFIXES ffmpeg ) find_path(FFMPEG_INCLUDE_DIR_AVUTIL NAMES libavutil/avutil.h PATHS "$ENV{MINGW_DIR}/include" C:/mingw/include PATH_SUFFIXES ffmpeg ) find_path(FFMPEG_INCLUDE_DIR_SWSCALE NAMES libswscale/swscale.h PATHS "$ENV{MINGW_DIR}/include" C:/mingw/include PATH_SUFFIXES libswscale ffmpeg ) # Detection of the FFMPEG library on Unix find_library(FFMPEG_AVUTIL_LIBRARY NAMES avutil PATHS "$ENV{MINGW_DIR}/lib64" C:/mingw/lib64 ) find_library(FFMPEG_AVCODEC_LIBRARY NAMES avcodec PATHS "$ENV{MINGW_DIR}/lib64" C:/mingw/lib64 ) find_library(FFMPEG_AVFORMAT_LIBRARY NAMES avformat PATHS "$ENV{MINGW_DIR}/lib64" C:/mingw/lib64 ) find_library(FFMPEG_AVCORE_LIBRARY NAMES avcore PATHS "$ENV{MINGW_DIR}/lib64" C:/mingw/lib64 ) find_library(FFMPEG_SWSCALE_LIBRARY NAMES swscale PATHS "$ENV{MINGW_DIR}/lib64" C:/mingw/lib64 ) else(MINGW) find_path(FFMPEG_INCLUDE_DIR_AVCODEC NAMES libavcodec/avcodec.h PATHS "/usr/include" "/usr/local/include" $ENV{FFMPEG_DIR}/include $ENV{FFMPEG_DIR} PATH_SUFFIXES ffmpeg ) find_path(FFMPEG_INCLUDE_DIR_AVFORMAT NAMES libavformat/avformat.h PATHS "/usr/include" "/usr/local/include" $ENV{FFMPEG_DIR}/include $ENV{FFMPEG_DIR} PATH_SUFFIXES ffmpeg ) find_path(FFMPEG_INCLUDE_DIR_AVUTIL NAMES libavutil/avutil.h PATHS "/usr/include" "/usr/local/include" $ENV{FFMPEG_DIR}/include $ENV{FFMPEG_DIR} PATH_SUFFIXES ffmpeg ) find_path(FFMPEG_INCLUDE_DIR_SWSCALE NAMES libswscale/swscale.h PATHS "/usr/include" "/usr/local/include" $ENV{FFMPEG_DIR}/include $ENV{FFMPEG_DIR} PATH_SUFFIXES libswscale ffmpeg ) # Detection of the FFMPEG library on Unix find_library(FFMPEG_AVUTIL_LIBRARY NAMES avutil PATHS /usr/lib /usr/local/lib /lib $ENV{FFMPEG_DIR}/lib $ENV{FFMPEG_DIR}/Release $ENV{FFMPEG_DIR} ) find_library(FFMPEG_AVCODEC_LIBRARY NAMES avcodec PATHS /usr/lib /usr/local/lib /lib $ENV{FFMPEG_DIR}/lib $ENV{FFMPEG_DIR}/Release $ENV{FFMPEG_DIR} ) find_library(FFMPEG_AVFORMAT_LIBRARY NAMES avformat PATHS /usr/lib /usr/local/lib /lib $ENV{FFMPEG_DIR}/lib $ENV{FFMPEG_DIR}/Release $ENV{FFMPEG_DIR} ) find_library(FFMPEG_AVCORE_LIBRARY NAMES avcore PATHS /usr/lib /usr/local/lib /lib $ENV{FFMPEG_DIR}/lib $ENV{FFMPEG_DIR}/Release $ENV{FFMPEG_DIR} ) find_library(FFMPEG_SWSCALE_LIBRARY NAMES swscale PATHS /usr/lib /usr/local/lib /lib $ENV{FFMPEG_DIR}/lib $ENV{FFMPEG_DIR}/Release $ENV{FFMPEG_DIR} ) endif(MINGW) # FFMpeg depend son Zlib find_package(ZLIB) if(NOT ZLIB_FOUND) find_package(MyZLIB) endif() # FFMpeg depend son BZip2 find_package(BZip2 QUIET) # FFMpeg may depend also on iconv since probably version 1.1.3 where if detected, # iconv usage is enabled by default find_package(ICONV QUIET) #message("ICONV_FOUND: ${ICONV_FOUND}") IF(FFMPEG_INCLUDE_DIR_AVCODEC AND FFMPEG_INCLUDE_DIR_AVFORMAT AND FFMPEG_INCLUDE_DIR_AVUTIL AND FFMPEG_INCLUDE_DIR_SWSCALE AND FFMPEG_SWSCALE_LIBRARY AND FFMPEG_AVFORMAT_LIBRARY AND FFMPEG_AVCODEC_LIBRARY AND FFMPEG_AVUTIL_LIBRARY AND ZLIB_LIBRARIES AND BZIP2_LIBRARIES) SET(FFMPEG_FOUND TRUE) SET(FFMPEG_INCLUDE_DIRS ${FFMPEG_INCLUDE_DIR_AVCODEC} ${FFMPEG_INCLUDE_DIR_AVFORMAT} ${FFMPEG_INCLUDE_DIR_AVUTIL} ${FFMPEG_INCLUDE_DIR_SWSCALE} ) SET(FFMPEG_LIBRARIES ${FFMPEG_SWSCALE_LIBRARY} ${FFMPEG_AVFORMAT_LIBRARY} ${FFMPEG_AVCODEC_LIBRARY} ${FFMPEG_AVUTIL_LIBRARY} ) if(FFMPEG_AVCORE_LIBRARY) LIST(APPEND FFMPEG_LIBRARIES ${FFMPEG_AVCORE_LIBRARY}) endif() list(APPEND FFMPEG_LIBRARIES ${ZLIB_LIBRARIES} ${BZIP2_LIBRARIES}) if(ICONV_FOUND) list(APPEND FFMPEG_LIBRARIES ${ICONV_LIBRARIES}) endif() elseif(MINGW AND FFMPEG_INCLUDE_DIR_AVCODEC AND FFMPEG_INCLUDE_DIR_AVFORMAT AND FFMPEG_INCLUDE_DIR_AVUTIL AND FFMPEG_INCLUDE_DIR_SWSCALE AND FFMPEG_SWSCALE_LIBRARY AND FFMPEG_AVFORMAT_LIBRARY AND FFMPEG_AVCODEC_LIBRARY AND FFMPEG_AVUTIL_LIBRARY AND ZLIB_LIBRARIES) # Bzip2 is nor requested with mingw-w64 SET(FFMPEG_FOUND TRUE) SET(FFMPEG_INCLUDE_DIRS ${FFMPEG_INCLUDE_DIR_AVCODEC} ${FFMPEG_INCLUDE_DIR_AVFORMAT} ${FFMPEG_INCLUDE_DIR_AVUTIL} ${FFMPEG_INCLUDE_DIR_SWSCALE} ) SET(FFMPEG_LIBRARIES ${FFMPEG_SWSCALE_LIBRARY} ${FFMPEG_AVFORMAT_LIBRARY} ${FFMPEG_AVCODEC_LIBRARY} ${FFMPEG_AVUTIL_LIBRARY} ) if(FFMPEG_AVCORE_LIBRARY) LIST(APPEND FFMPEG_LIBRARIES ${FFMPEG_AVCORE_LIBRARY}) endif() list(APPEND FFMPEG_LIBRARIES ${ZLIB_LIBRARIES}) if(ICONV_FOUND) list(APPEND FFMPEG_LIBRARIES ${ICONV_LIBRARIES}) endif() ELSE() SET(FFMPEG_FOUND FALSE) ENDIF () MARK_AS_ADVANCED( BZIP2_DIR FFMPEG_INCLUDE_DIR_AVCODEC FFMPEG_INCLUDE_DIR_AVFORMAT FFMPEG_INCLUDE_DIR_AVUTIL FFMPEG_INCLUDE_DIR_SWSCALE FFMPEG_AVUTIL_LIBRARY FFMPEG_AVFORMAT_LIBRARY FFMPEG_AVCODEC_LIBRARY FFMPEG_SWSCALE_LIBRARY FFMPEG_AVCORE_LIBRARY FFMPEG_INCLUDE_DIRS FFMPEG_LIBRARIES ) visp-3.0.1/cmake/FindFlyCapture.cmake000066400000000000000000000052341304511007300174330ustar00rootroot00000000000000############################################################################# # # This file is part of the ViSP software. # Copyright (C) 2005 - 2017 by Inria. All rights reserved. # # This software is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public License # ("GPL") version 2 as published by the Free Software Foundation. # See the file LICENSE.txt at the root directory of this source # distribution for additional information about the GNU GPL. # # For using ViSP with software that can not be combined with the GNU # GPL, please contact Inria about acquiring a ViSP Professional # Edition License. # # See http://visp.inria.fr for more information. # # This software was developed at: # Inria Rennes - Bretagne Atlantique # Campus Universitaire de Beaulieu # 35042 Rennes Cedex # France # # If you have questions regarding the use of this file, please contact # Inria at visp@inria.fr # # This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE # WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. # # Description: # Try to find Cerebellum Irisa library API to dial with the robot Afma6 # # FLYCAPTURE_FOUND # FLYCAPTURE_INCLUDE_DIRS # FLYCAPTURE_LIBRARIES # FLYCAPTURE_VERSION # # Authors: # Fabien Spindler # ############################################################################# set(FLYCAPTURE_INC_SEARCH_PATH /usr/include/flycapture) set(FLYCAPTURE_LIB_SEARCH_PATH /usr/lib) set(FLYCAPTURE_VERSION "n/a") if(MSVC) if(CMAKE_CL_64) list(APPEND FLYCAPTURE_INC_SEARCH_PATH "C:/Program Files/Point Grey Research/FlyCapture2/include") list(APPEND FLYCAPTURE_LIB_SEARCH_PATH "C:/Program Files/Point Grey Research/FlyCapture2/lib64") else() list(APPEND FLYCAPTURE_INC_SEARCH_PATH "C:/Program Files (x86)/Point Grey Research/FlyCapture2/include") list(APPEND FLYCAPTURE_LIB_SEARCH_PATH "C:/Program Files (x86)/Point Grey Research/FlyCapture2/lib") endif() endif() find_path(FLYCAPTURE_INCLUDE_DIRS FlyCapture2.h PATHS $ENV{FLYCAPTURE_HOME}/include/flycapture ${FLYCAPTURE_INC_SEARCH_PATH} ) find_library(FLYCAPTURE_LIBRARIES NAMES flycapture FlyCapture2 PATHS $ENV{FLYCAPTURE_HOME}/lib ${FLYCAPTURE_LIB_SEARCH_PATH} ) if(FLYCAPTURE_LIBRARIES AND FLYCAPTURE_INCLUDE_DIRS) set(FLYCAPTURE_FOUND TRUE) if(WIN32) vp_parse_header("${FLYCAPTURE_INCLUDE_DIRS}/FC1/PGRFlyCapture.h" FLYCAPTURE_VERSION_LINES PGRFLYCAPTURE_VERSION) set(FLYCAPTURE_VERSION ${PGRFLYCAPTURE_VERSION}) endif() else() set(FLYCAPTURE_FOUND FALSE) endif() mark_as_advanced( FLYCAPTURE_INCLUDE_DIRS FLYCAPTURE_LIBRARIES FLYCAPTURE_INC_SEARCH_PATH FLYCAPTURE_LIB_SEARCH_PATH ) visp-3.0.1/cmake/FindGDI.cmake000066400000000000000000000140601304511007300157550ustar00rootroot00000000000000############################################################################# # # This file is part of the ViSP software. # Copyright (C) 2005 - 2017 by Inria. All rights reserved. # # This software is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public License # ("GPL") version 2 as published by the Free Software Foundation. # See the file LICENSE.txt at the root directory of this source # distribution for additional information about the GNU GPL. # # For using ViSP with software that can not be combined with the GNU # GPL, please contact Inria about acquiring a ViSP Professional # Edition License. # # See http://visp.inria.fr for more information. # # This software was developed at: # Inria Rennes - Bretagne Atlantique # Campus Universitaire de Beaulieu # 35042 Rennes Cedex # France # # If you have questions regarding the use of this file, please contact # Inria at visp@inria.fr # # This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE # WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. # # Description: # Try to find GDI (Graphics Device Interface) on Windows. # Once loaded this will define: # # GDI_FOUND - system has GDI # GDI_LIBRARIES - libraries you need to link to # # Authors: # Fabien Spindler # ############################################################################# SET(GDI_FOUND "NO") # GDI (Graphics Device Interface) is only available on Windows platforms IF(WIN32) IF(MINGW) FIND_LIBRARY(GDI_LIBRARY gdi32 "C:/MinGW/lib" "C:/mingw/mingw/lib" "$ENV{MINGW_DIR}/lib" "$ENV{MINGW_DIR}/mingw/lib" DOC "Where can the GDI (Graphics Device Interface) library be found" NO_DEFAULT_PATH ) ELSE(MINGW) IF(CMAKE_CL_64) # Generic path search FIND_LIBRARY(GDI_LIBRARY gdi32 "$ENV{WINSDK_DIR}/Lib/x64" "$ENV{WINSDK_HOME}/Lib/x64" "$ENV{DXSDK_DIR}/Lib/x64" "C:/Program Files/Microsoft SDKs/Windows/v6.0/Lib/x64" "C:/Program Files/Microsoft SDKs/Windows/v6.0a/Lib/x64" "C:/Program Files/Microsoft SDKs/Windows/v6.1/Lib/x64" "C:/Program Files/Microsoft SDKs/Windows/v7.0A/Lib/x64" "C:/Program Files/Microsoft SDKs/Windows/v7.1/Lib/x64" "C:/Program Files/Microsoft SDKs/Windows/v7.1A/Lib/x64" "C:/Program Files (x86)/Microsoft SDKs/Windows/v7.0A/Lib/x64" "C:/Program Files (x86)/Microsoft SDKs/Windows/v7.1A/Lib/x64" "C:/Program Files (x86)/Windows Kits/8.0/Lib/win8/um/x64" "C:/Program Files (x86)/Windows Kits/8.1/Lib/winv6.3/um/x64" "C:/Program Files/Microsoft Platform SDK/Lib/x64" "C:/DXSDK/Include/Lib/x64" DOC "Where can the GDI (Graphics Device Interface) library be found" ) # Specific path search for Visual Studio .NET 2003 IF(MSVC71) IF(NOT GDI_LIBRARY) FIND_LIBRARY(GDI_LIBRARY gdi32 "C:/Program Files/Microsoft Visual Studio .NET 2003/Vc7/PlatformSDK/Lib" ) ENDIF(NOT GDI_LIBRARY) ENDIF(MSVC71) # Specific path search for Visual Studio 2005 IF(MSVC80) IF(NOT GDI_LIBRARY) FIND_LIBRARY(GDI_LIBRARY gdi32 "C:/Program Files/Microsoft Visual Studio 8/VC/PlatformSDK/Lib/AMD64" ) ENDIF(NOT GDI_LIBRARY) ENDIF(MSVC80) # Specific path search for Visual Studio 2008 IF(MSVC90) IF(NOT GDI_LIBRARY) FIND_LIBRARY(GDI_LIBRARY gdi32 "C:/Program Files/Microsoft Visual Studio 9/VC/PlatformSDK/Lib/AMD64" ) ENDIF(NOT GDI_LIBRARY) ENDIF(MSVC90) ELSE(CMAKE_CL_64) # Generic path search FIND_LIBRARY(GDI_LIBRARY gdi32 "$ENV{WINSDK_DIR}/Lib" "$ENV{WINSDK_HOME}/Lib" "$ENV{DXSDK_DIR}/Lib" "C:/Program Files/Microsoft SDKs/Windows/v6.0a/Lib" "C:/Program Files/Microsoft SDKs/Windows/v6.0/Lib" "C:/Program Files/Microsoft SDKs/Windows/v6.1/Lib" "C:/Program Files/Microsoft SDKs/Windows/v7.0A/Lib" "C:/Program Files (x86)/Microsoft SDKs/Windows/v7.0A/Lib" "C:/Program Files (x86)/Microsoft SDKs/Windows/v7.1/Lib" "C:/Program Files (x86)/Microsoft SDKs/Windows/v7.1A/Lib" "C:/Program Files (x86)/Windows Kits/8.0/Lib/win8/um/x86" "C:/Program Files (x86)/Windows Kits/8.1/Lib/winv6.3/um/x86" "C:/Program Files/Microsoft Platform SDK/Lib" "C:/DXSDK/Include/Lib" DOC "Where can the GDI (Graphics Device Interface) library be found" ) # Specific path search for Visual Studio .NET 2003 IF(MSVC71) IF(NOT GDI_LIBRARY) FIND_LIBRARY(GDI_LIBRARY gdi32 "C:/Program Files/Microsoft Visual Studio .NET 2003/Vc7/PlatformSDK/Lib" ) ENDIF(NOT GDI_LIBRARY) ENDIF(MSVC71) # Specific path search for Visual Studio 2005 IF(MSVC80) IF(NOT GDI_LIBRARY) FIND_LIBRARY(GDI_LIBRARY gdi32 "C:/Program Files/Microsoft Visual Studio 8/VC/PlatformSDK/Lib" ) ENDIF(NOT GDI_LIBRARY) ENDIF(MSVC80) # Specific path search for Visual Studio 2008 IF(MSVC90) IF(NOT GDI_LIBRARY) FIND_LIBRARY(GDI_LIBRARY gdi32 "C:/Program Files/Microsoft Visual Studio 9/VC/PlatformSDK/Lib" ) ENDIF(NOT GDI_LIBRARY) ENDIF(MSVC90) ENDIF(CMAKE_CL_64) ENDIF(MINGW) # if GDI libraries found, then we're ok IF(GDI_LIBRARY) SET(GDI_FOUND "YES") SET(GDI_LIBRARIES ${GDI_LIBRARY}) ENDIF(GDI_LIBRARY) MARK_AS_ADVANCED(GDI_LIBRARY) ENDIF(WIN32) visp-3.0.1/cmake/FindGSL.cmake000066400000000000000000000131711304511007300160010ustar00rootroot00000000000000############################################################################# # # This file is part of the ViSP software. # Copyright (C) 2005 - 2017 by Inria. All rights reserved. # # This software is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public License # ("GPL") version 2 as published by the Free Software Foundation. # See the file LICENSE.txt at the root directory of this source # distribution for additional information about the GNU GPL. # # For using ViSP with software that can not be combined with the GNU # GPL, please contact Inria about acquiring a ViSP Professional # Edition License. # # See http://visp.inria.fr for more information. # # This software was developed at: # Inria Rennes - Bretagne Atlantique # Campus Universitaire de Beaulieu # 35042 Rennes Cedex # France # # If you have questions regarding the use of this file, please contact # Inria at visp@inria.fr # # This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE # WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. # # Description: # Try to find gnu scientific library GSL # (see http://www.gnu.org/software/gsl/) # Once run this will define: # # GSL_FOUND : system has GSL lib # GSL_LIBRARIES : full path to the libraries # GSL_INCLUDE_DIRS : where to find headers # GSL_VERSION : which version # # Authors: # Fabien Spindler # ############################################################################# # it seems that a macro() can't accept a list as input. That's why we have # MY_LIBRARY1 and MY_LIBRARY2 macro(CheckCompilation_gsl2 MY_INCLUDE_DIR MY_LIBRARY1 MY_LIBRARY2 MY_BUILD_SUCCEED2) # The material is found. Check if it works on the requested architecture include(CheckCXXSourceCompiles) #message("Test compilation: ${MY_INCLUDE_DIR} + ${MY_LIBRARY1} + ${MY_LIBRARY2}") set(CMAKE_REQUIRED_LIBRARIES ${MY_LIBRARY1} ${MY_LIBRARY2}) set(CMAKE_REQUIRED_INCLUDES ${MY_INCLUDE_DIR}) check_cxx_source_compiles(" #include // Contrib for GSL library #include #include int main() { gsl_matrix *A2 = gsl_matrix_alloc(6, 6) ; } " BUILD_SUCCEED2) #message("BUILD_SUCCEED: ${BUILD_SUCCEED}") set(${MY_BUILD_SUCCEED2} ${BUILD_SUCCEED2}) endmacro() macro(CheckCompilation_gsl1 MY_INCLUDE_DIR MY_LIBRARY MY_BUILD_SUCCEED) # The material is found. Check if it works on the requested architecture include(CheckCXXSourceCompiles) #message("Test compilation: ${MY_INCLUDE_DIR} + ${MY_LIBRARY}") set(CMAKE_REQUIRED_LIBRARIES ${MY_LIBRARY}) set(CMAKE_REQUIRED_INCLUDES ${MY_INCLUDE_DIR}) check_cxx_source_compiles(" #include // Contrib for GSL library #include #include int main() { gsl_matrix *A1 = gsl_matrix_alloc(6, 6) ; } " BUILD_SUCCEED) #message("BUILD_SUCCEED: ${BUILD_SUCCEED}") set(${MY_BUILD_SUCCEED} ${BUILD_SUCCEED}) endmacro() set(GSL_VERSION "n/a") set(GSL_LIB_SEARCH_PATH "$ENV{GSL_HOME}/lib" "$ENV{GSL_DIR}/lib" /usr/lib /usr/local/lib ) set(GSL_INC_SEARCH_PATH $ENV{GSL_HOME}/include $ENV{GSL_DIR}/include /usr/include /usr/local/include ) find_path(GSL_INCLUDE_DIR gsl/gsl_linalg.h ${GSL_INC_SEARCH_PATH} ) find_library(GSL_gsl_LIBRARY NAMES gsl PATHS ${GSL_LIB_SEARCH_PATH} ) if(WIN32) find_library(GSL_cblas_LIBRARY NAMES cblas PATHS ${GSL_LIB_SEARCH_PATH} ) find_library(GSL_gsl_LIBRARY_DEBUG NAMES gsl_d PATHS ${GSL_LIB_SEARCH_PATH} ) find_library(GSL_cblas_LIBRARY_DEBUG NAMES cblas_d PATHS ${GSL_LIB_SEARCH_PATH} ) if(GSL_INCLUDE_DIR AND GSL_gsl_LIBRARY AND GSL_cblas_LIBRARY AND GSL_gsl_LIBRARY_DEBUG AND GSL_cblas_LIBRARY_DEBUG) set(GSL_LIBRARIES "optimized" ${GSL_cblas_LIBRARY} "optimized" ${GSL_gsl_LIBRARY} "debug" ${GSL_cblas_LIBRARY_DEBUG} "debug" ${GSL_gsl_LIBRARY_DEBUG}) set(GSL_INCLUDE_DIRS ${GSL_INCLUDE_DIR}) set(GSL_FOUND TRUE) else() set(GSL_FOUND FALSE) endif() mark_as_advanced( GSL_gsl_LIBRARY_DEBUG GSL_cblas_LIBRARY_DEBUG ) else() if(GSL_INCLUDE_DIR AND GSL_gsl_LIBRARY) # Check if gsl library is sufficient set(GSL_INCLUDE_DIRS ${GSL_INCLUDE_DIR}) set(GSL_LIBRARIES ${GSL_gsl_LIBRARY}) CheckCompilation_gsl1(${GSL_INCLUDE_DIRS} ${GSL_gsl_LIBRARY} BUILD_SUCCEED1) #message("BUILD_STATUS 1: ${BUILD_SUCCEED1}") if(BUILD_SUCCEED1) set(GSL_FOUND TRUE) get_filename_component(GSL_LIB_DIR ${GSL_gsl_LIBRARY} PATH) vp_get_version_from_pkg("gsl" "${GSL_LIB_DIR}/pkgconfig" GSL_VERSION) else() # Try to add gslcblas library if requested find_library(GSL_cblas_LIBRARY NAMES gslcblas PATHS ${GSL_LIB_SEARCH_PATH} ) if(GSL_cblas_LIBRARY) list(APPEND GSL_LIBRARIES ${GSL_cblas_LIBRARY}) #message("add cblas to GSL_LIBRARIES: ${GSL_LIBRARIES}") CheckCompilation_gsl2(${GSL_INCLUDE_DIRS} ${GSL_gsl_LIBRARY} ${GSL_cblas_LIBRARY} BUILD_SUCCEED2) #message("BUILD_STATUS 2: ${BUILD_SUCCEED2}") if(BUILD_SUCCEED2) set(GSL_FOUND TRUE) get_filename_component(GSL_LIB_DIR ${GSL_gsl_LIBRARY} PATH) vp_get_version_from_pkg("gsl" "${GSL_LIB_DIR}/pkgconfig" GSL_VERSION) else() set(GSL_FOUND FALSE) endif() else() set(GSL_FOUND FALSE) endif() endif() else() set(GSL_FOUND FALSE) endif() endif() mark_as_advanced( GSL_gsl_LIBRARY GSL_cblas_LIBRARY GSL_INCLUDE_DIR ) visp-3.0.1/cmake/FindICONV.cmake000066400000000000000000000042461304511007300162350ustar00rootroot00000000000000############################################################################# # # This file is part of the ViSP software. # Copyright (C) 2005 - 2017 by Inria. All rights reserved. # # This software is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public License # ("GPL") version 2 as published by the Free Software Foundation. # See the file LICENSE.txt at the root directory of this source # distribution for additional information about the GNU GPL. # # For using ViSP with software that can not be combined with the GNU # GPL, please contact Inria about acquiring a ViSP Professional # Edition License. # # See http://visp.inria.fr for more information. # # This software was developed at: # Inria Rennes - Bretagne Atlantique # Campus Universitaire de Beaulieu # 35042 Rennes Cedex # France # # If you have questions regarding the use of this file, please contact # Inria at visp@inria.fr # # This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE # WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. # # Description: # Try to find ICONV library. # Once run this will define: # # ICONV_FOUND # ICONV_INCLUDE_DIRS # ICONV_LIBRARIES # # Authors: # Anthony Saunier # ############################################################################# if(MINGW) find_path(ICONV_INCLUDE_DIR iconv.h "$ENV{MINGW_DIR}/include" C:/mingw/include ) find_library(ICONV_LIBRARY iconv "$ENV{MINGW_DIR}/lib64" C:/mingw/lib64 ) else() find_path(ICONV_INCLUDE_DIR iconv.h $ENV{ICONV_DIR}/include $ENV{ICONV_HOME}/include $ENV{XML2_DIR}/include $ENV{XML2_HOME}/include "c:/libxml2/include" "c:/iconv/include" ) find_library(ICONV_LIBRARY iconv $ENV{ICONV_DIR}/lib $ENV{ICONV_HOME}/lib $ENV{XML2_DIR}/lib $ENV{XML2_HOME}/lib "c:/libxml2/lib" "c:/iconv/lib" ) endif() if(ICONV_LIBRARY) SET(ICONV_LIBRARIES ${ICONV_LIBRARY}) endif() if(ICONV_LIBRARIES AND ICONV_INCLUDE_DIR) SET(ICONV_INCLUDE_DIRS ${ICONV_INCLUDE_DIR}) SET(ICONV_FOUND TRUE) else() SET(ICONV_FOUND FALSE) endif() mark_as_advanced( ICONV_INCLUDE_DIR ICONV_LIBRARIES ICONV_LIBRARY ) visp-3.0.1/cmake/FindIRISA.cmake000066400000000000000000000050271304511007300162240ustar00rootroot00000000000000############################################################################# # # This file is part of the ViSP software. # Copyright (C) 2005 - 2017 by Inria. All rights reserved. # # This software is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public License # ("GPL") version 2 as published by the Free Software Foundation. # See the file LICENSE.txt at the root directory of this source # distribution for additional information about the GNU GPL. # # For using ViSP with software that can not be combined with the GNU # GPL, please contact Inria about acquiring a ViSP Professional # Edition License. # # See http://visp.inria.fr for more information. # # This software was developed at: # Inria Rennes - Bretagne Atlantique # Campus Universitaire de Beaulieu # 35042 Rennes Cedex # France # # If you have questions regarding the use of this file, please contact # Inria at visp@inria.fr # # This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE # WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. # # Description: # Try to find Cerebellum Irisa library API to dial with the robot Afma6 # # IRISA_FOUND # IRISA_INCLUDE_DIRS # IRISA_LIBRARIES # # Authors: # Fabien Spindler # ############################################################################# IF(NOT UNIX) # MESSAGE("FindIRISA.cmake: only available for Unix.") SET(IRISA_FOUND FALSE) ELSE(NOT UNIX) FIND_PATH(IRISA_INCLUDE_DIR irisa_Afma6.h $ENV{IRISA_HOME}/src /local/soft/Cerebellum/Irisa/current/src /home/soft/Cerebellum/Irisa/current/src ) #MESSAGE("DBG IRISA_INCLUDE_DIR=${IRISA_INCLUDE_DIR}") FIND_LIBRARY(IRISA_LIBRARY NAMES irisa PATHS $ENV{IRISA_HOME}/src /local/soft/Cerebellum/Irisa/current/src /home/soft/Cerebellum/Irisa/current/src ) #MESSAGE("DBG IRISA_LIBRARY=${IRISA_LIBRARY}") ## -------------------------------- IF(IRISA_LIBRARY) SET(IRISA_LIBRARIES ${IRISA_LIBRARY}) ELSE(IRISA_LIBRARY) #MESSAGE(SEND_ERROR "Irisa library not found.") ENDIF(IRISA_LIBRARY) IF(NOT IRISA_INCLUDE_DIR) #MESSAGE(SEND_ERROR "Irisa include dir not found.") ENDIF(NOT IRISA_INCLUDE_DIR) IF(IRISA_LIBRARIES AND IRISA_INCLUDE_DIR) SET(IRISA_INCLUDE_DIRS ${IRISA_INCLUDE_DIR}) SET(IRISA_FOUND TRUE) ELSE(IRISA_LIBRARIES AND IRISA_INCLUDE_DIR) SET(IRISA_FOUND FALSE) ENDIF(IRISA_LIBRARIES AND IRISA_INCLUDE_DIR) MARK_AS_ADVANCED( IRISA_INCLUDE_DIR IRISA_LIBRARIES IRISA_LIBRARY ) ENDIF(NOT UNIX) visp-3.0.1/cmake/FindIsInf.cmake000066400000000000000000000042201304511007300163570ustar00rootroot00000000000000############################################################################# # # This file is part of the ViSP software. # Copyright (C) 2005 - 2017 by Inria. All rights reserved. # # This software is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public License # ("GPL") version 2 as published by the Free Software Foundation. # See the file LICENSE.txt at the root directory of this source # distribution for additional information about the GNU GPL. # # For using ViSP with software that can not be combined with the GNU # GPL, please contact Inria about acquiring a ViSP Professional # Edition License. # # See http://visp.inria.fr for more information. # # This software was developed at: # Inria Rennes - Bretagne Atlantique # Campus Universitaire de Beaulieu # 35042 Rennes Cedex # France # # If you have questions regarding the use of this file, please contact # Inria at visp@inria.fr # # This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE # WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. # # Description: # Try to find isnan macro, std::isnan function or _isnan function. # # Authors: # Souriya Trinh # ############################################################################# include(CheckIncludeFile) include(CheckIncludeFiles) include(CheckCXXSourceCompiles) macro(check_math_expr _expr _var) unset(${_var} CACHE) if(USE_CPP11) set(CMAKE_REQUIRED_FLAGS ${CPP11_CXX_FLAGS}) endif() check_cxx_source_compiles(" #include int main(int argc, char ** argv) { (void)${_expr}; return 0; } " ${_var}) endmacro() check_include_files("float.h" HAVE_FLOAT_H) check_math_expr("isinf(1.0)" HAVE_FUNC_ISINF) check_math_expr("std::isinf(1.0)" HAVE_FUNC_STD_ISINF) if(HAVE_FLOAT_H) unset(HAVE_FUNC__FINITE CACHE) if(USE_CPP11) set(CMAKE_REQUIRED_FLAGS ${CPP11_CXX_FLAGS}) endif() # The version that should work with MSVC check_cxx_source_compiles(" #include int main(int argc, char ** argv) { (void)_finite(1.0); return 0; } " HAVE_FUNC__FINITE) else() set(HAVE_FUNC__FINITE FALSE) endif() visp-3.0.1/cmake/FindIsNaN.cmake000066400000000000000000000042141304511007300163220ustar00rootroot00000000000000############################################################################# # # This file is part of the ViSP software. # Copyright (C) 2005 - 2017 by Inria. All rights reserved. # # This software is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public License # ("GPL") version 2 as published by the Free Software Foundation. # See the file LICENSE.txt at the root directory of this source # distribution for additional information about the GNU GPL. # # For using ViSP with software that can not be combined with the GNU # GPL, please contact Inria about acquiring a ViSP Professional # Edition License. # # See http://visp.inria.fr for more information. # # This software was developed at: # Inria Rennes - Bretagne Atlantique # Campus Universitaire de Beaulieu # 35042 Rennes Cedex # France # # If you have questions regarding the use of this file, please contact # Inria at visp@inria.fr # # This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE # WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. # # Description: # Try to find isnan macro, std::isnan function or _isnan function. # # Authors: # Souriya Trinh # ############################################################################# include(CheckIncludeFile) include(CheckIncludeFiles) include(CheckCXXSourceCompiles) macro(check_math_expr _expr _var) unset(${_var} CACHE) if(USE_CPP11) set(CMAKE_REQUIRED_FLAGS ${CPP11_CXX_FLAGS}) endif() check_cxx_source_compiles(" #include int main(int argc, char ** argv) { (void)${_expr}; return 0; } " ${_var}) endmacro() check_include_files("float.h" HAVE_FLOAT_H) check_math_expr("isnan(1.0)" HAVE_FUNC_ISNAN) check_math_expr("std::isnan(1.0)" HAVE_FUNC_STD_ISNAN) if(HAVE_FLOAT_H) unset(HAVE_FUNC__ISNAN CACHE) if(USE_CPP11) set(CMAKE_REQUIRED_FLAGS ${CPP11_CXX_FLAGS}) endif() # The version that should work with MSVC check_cxx_source_compiles(" #include int main(int argc, char ** argv) { (void)_isnan(1.0); return 0; } " HAVE_FUNC__ISNAN) else() set(HAVE_FUNC__ISNAN FALSE) endif() visp-3.0.1/cmake/FindLAPACK_C.cmake000066400000000000000000000104221304511007300165450ustar00rootroot00000000000000############################################################################# # # This file is part of the ViSP software. # Copyright (C) 2005 - 2017 by Inria. All rights reserved. # # This software is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public License # ("GPL") version 2 as published by the Free Software Foundation. # See the file LICENSE.txt at the root directory of this source # distribution for additional information about the GNU GPL. # # For using ViSP with software that can not be combined with the GNU # GPL, please contact Inria about acquiring a ViSP Professional # Edition License. # # See http://visp.inria.fr for more information. # # This software was developed at: # Inria Rennes - Bretagne Atlantique # Campus Universitaire de Beaulieu # 35042 Rennes Cedex # France # # If you have questions regarding the use of this file, please contact # Inria at visp@inria.fr # # This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE # WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. # # Description: # Try to find lapack, the Linear Algebra PACKage. # Since the FindLAPACK.cmake provided with CMake is for Fortran language, # this file is able to detect lapack for C language. # Once run this will define: # # LAPACK_C_FOUND # LAPACK_C_LIBRARIES # LAPACK_C_VERSION # # Authors: # Filip Novotny # Fabien Spindler # ############################################################################# set(LAPACK_C_FOUND FALSE) set(LAPACK_C_LIBRARIES "") set(LAPACK_C_VERSION "n/a") if(WIN32) set(LAPACK_C_LIB_SEARCH_PATH $ENV{LAPACK_C_HOME} $ENV{LAPACK_C_DIR} $ENV{LAPACK_C_HOME}/lib $ENV{LAPACK_C_DIR}/lib $ENV{LAPACK_HOME} $ENV{LAPACK_DIR} $ENV{LAPACK_HOME}/lib $ENV{LAPACK_DIR}/lib ) find_library(LAPACK_C_LIBRARY_LAPACK_C_RELEASE NAMES lapack PATHS ${LAPACK_C_LIB_SEARCH_PATH} ) find_library(LAPACK_C_LIBRARY_BLAS_RELEASE NAMES blas PATHS ${LAPACK_C_LIB_SEARCH_PATH} ) find_library(LAPACK_C_LIBRARY_F2C_RELEASE NAMES libf2c PATHS ${LAPACK_C_LIB_SEARCH_PATH} ) find_library(LAPACK_C_LIBRARY_LAPACK_C_DEBUG NAMES lapackd PATHS ${LAPACK_C_LIB_SEARCH_PATH} ) find_library(LAPACK_C_LIBRARY_BLAS_DEBUG NAMES blasd PATHS ${LAPACK_C_LIB_SEARCH_PATH} ) find_library(LAPACK_C_LIBRARY_F2C_DEBUG NAMES libf2cd PATHS ${LAPACK_C_LIB_SEARCH_PATH} ) if((LAPACK_C_LIBRARY_LAPACK_C_RELEASE AND LAPACK_C_LIBRARY_BLAS_RELEASE AND LAPACK_C_LIBRARY_F2C_RELEASE)) list(APPEND LAPACK_C_LIBRARIES optimized ${LAPACK_C_LIBRARY_LAPACK_C_RELEASE}) list(APPEND LAPACK_C_LIBRARIES optimized ${LAPACK_C_LIBRARY_BLAS_RELEASE}) list(APPEND LAPACK_C_LIBRARIES optimized ${LAPACK_C_LIBRARY_F2C_RELEASE}) set(LAPACK_C_FOUND TRUE) endif() if((LAPACK_C_LIBRARY_LAPACK_C_DEBUG AND LAPACK_C_LIBRARY_BLAS_DEBUG AND LAPACK_C_LIBRARY_F2C_DEBUG)) list(APPEND LAPACK_C_LIBRARIES debug ${LAPACK_C_LIBRARY_LAPACK_C_DEBUG}) list(APPEND LAPACK_C_LIBRARIES debug ${LAPACK_C_LIBRARY_BLAS_DEBUG}) list(APPEND LAPACK_C_LIBRARIES debug ${LAPACK_C_LIBRARY_F2C_DEBUG}) set(LAPACK_C_FOUND TRUE) endif() else(WIN32) set(LAPACK_C_LIB_SEARCH_PATH $ENV{LAPACK_C_HOME} $ENV{LAPACK_C_DIR} $ENV{LAPACK_C_HOME}/lib $ENV{LAPACK_C_DIR}/lib $ENV{LAPACK_HOME} $ENV{LAPACK_DIR} $ENV{LAPACK_HOME}/lib $ENV{LAPACK_DIR}/lib /usr/lib /usr/lib64 /usr/local/lib /usr/local/lib64 ) find_library(LAPACK_C_LIBRARY_LAPACK NAMES lapack PATHS ${LAPACK_C_LIB_SEARCH_PATH} ) find_library(LAPACK_C_LIBRARY_BLAS NAMES blas PATHS ${LAPACK_C_LIB_SEARCH_PATH} ) if((LAPACK_C_LIBRARY_LAPACK AND LAPACK_C_LIBRARY_BLAS)) set(LAPACK_C_LIBRARIES ${LAPACK_C_LIBRARY_LAPACK} ${LAPACK_C_LIBRARY_BLAS}) set(LAPACK_C_FOUND TRUE) get_filename_component(LAPACK_C_LIB_DIR ${LAPACK_C_LIBRARY_LAPACK} PATH) vp_get_version_from_pkg("lapack" "${LAPACK_C_LIB_DIR}/pkgconfig" LAPACK_C_VERSION) endif() endif(WIN32) mark_as_advanced( LAPACK_C_LIBRARIES LAPACK_C_LIBRARY_LAPACK LAPACK_C_LIBRARY_BLAS LAPACK_C_LIBRARY_LAPACK_C_RELEASE LAPACK_C_LIBRARY_BLAS_RELEASE LAPACK_C_LIBRARY_LAPACK_C_DEBUG LAPACK_C_LIBRARY_BLAS_DEBUG LAPACK_C_LIBRARY_F2C_DEBUG LAPACK_C_LIBRARY_F2C_RELEASE ) visp-3.0.1/cmake/FindLIBFREENECT.cmake000066400000000000000000000057471304511007300171100ustar00rootroot00000000000000############################################################################# # # This file is part of the ViSP software. # Copyright (C) 2005 - 2017 by Inria. All rights reserved. # # This software is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public License # ("GPL") version 2 as published by the Free Software Foundation. # See the file LICENSE.txt at the root directory of this source # distribution for additional information about the GNU GPL. # # For using ViSP with software that can not be combined with the GNU # GPL, please contact Inria about acquiring a ViSP Professional # Edition License. # # See http://visp.inria.fr for more information. # # This software was developed at: # Inria Rennes - Bretagne Atlantique # Campus Universitaire de Beaulieu # 35042 Rennes Cedex # France # # If you have questions regarding the use of this file, please contact # Inria at visp@inria.fr # # This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE # WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. # # Description: # Try to find Cerebellum Irisa library API to dial with the robot Afma6 # # LIBFREENECT_FOUND # LIBFREENECT_INCLUDE_DIRS # LIBFREENECT_LIBRARIES # LIBFREENECT_VERSION # # Authors: # Celine Teuliere # Fabien Spindler if(WIN32) find_path(LIBFREENECT_HPP_INCLUDE_DIR libfreenect.hpp $ENV{LIBFREENECT_HOME}/include $ENV{LIBFREENECT_HPP_INCLUDE_DIR} $ENV{LIBFREENECT_H_INCLUDE_DIR} ) find_path(LIBFREENECT_H_INCLUDE_DIR libfreenect.h $ENV{LIBFREENECT_HOME}/include $ENV{LIBFREENECT_HPP_INCLUDE_DIR} $ENV{LIBFREENECT_H_INCLUDE_DIR} ) find_library(LIBFREENECT_LIBRARY freenect $ENV{LIBFREENECT_HOME}/lib $ENV{LIBFREENECT_LIBRARY_DIR} "c:/libfreenect/lib" ) else() find_path(LIBFREENECT_HPP_INCLUDE_DIR libfreenect.hpp $ENV{LIBFREENECT_HOME}/include /usr/include /usr/local/include /usr/include/libfreenect /usr/local/include/libfreenect ) find_path(LIBFREENECT_H_INCLUDE_DIR libfreenect.h $ENV{LIBFREENECT_HOME}/include /usr/include /usr/local/include /usr/include/libfreenect /usr/local/include/libfreenect ) find_library(LIBFREENECT_LIBRARY freenect $ENV{LIBFREENECT_HOME}/lib $ENV{LIBFREENECT_HOME}/build/lib /usr/lib /usr/local/lib ) endif() ## -------------------------------- if(LIBFREENECT_LIBRARY AND LIBFREENECT_HPP_INCLUDE_DIR AND LIBFREENECT_H_INCLUDE_DIR) set(LIBFREENECT_INCLUDE_DIRS ${LIBFREENECT_HPP_INCLUDE_DIR} ${LIBFREENECT_H_INCLUDE_DIR}) set(LIBFREENECT_LIBRARIES ${LIBFREENECT_LIBRARY}) set(LIBFREENECT_FOUND TRUE) get_filename_component(LIBFREENECT_LIB_DIR ${LIBFREENECT_LIBRARY} PATH) vp_get_version_from_pkg("libfreenect" "${LIBFREENECT_LIB_DIR}/pkgconfig" LIBFREENECT_VERSION) else() set(LIBFREENECT_FOUND FALSE) endif() mark_as_advanced( LIBFREENECT_INCLUDE_DIRS LIBFREENECT_HPP_INCLUDE_DIR LIBFREENECT_H_INCLUDE_DIR LIBFREENECT_LIBRARIES LIBFREENECT_LIBRARY ) visp-3.0.1/cmake/FindLIBUSB_1.cmake000066400000000000000000000052741304511007300165610ustar00rootroot00000000000000############################################################################# # # This file is part of the ViSP software. # Copyright (C) 2005 - 2017 by Inria. All rights reserved. # # This software is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public License # ("GPL") version 2 as published by the Free Software Foundation. # See the file LICENSE.txt at the root directory of this source # distribution for additional information about the GNU GPL. # # For using ViSP with software that can not be combined with the GNU # GPL, please contact Inria about acquiring a ViSP Professional # Edition License. # # See http://visp.inria.fr for more information. # # This software was developed at: # Inria Rennes - Bretagne Atlantique # Campus Universitaire de Beaulieu # 35042 Rennes Cedex # France # # If you have questions regarding the use of this file, please contact # Inria at visp@inria.fr # # This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE # WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. # # Description: # Try to find libusb-1.0 library. Headers include dir is not searched. # # LIBUSB_1_FOUND # LIBUSB_1_LIBRARIES # LIBUSB_1_INCLUDE_DIRS # LIBUSB_1_VERSION # # Authors: # Celine Teuliere # Fabien Spindler ############################################################################# if(WIN32) find_library(LIBUSB_1_LIBRARY libusb $ENV{LIBUSB_1_HOME} $ENV{LIBUSB_1_HOME}/lib $ENV{LIBUSB_1_DIR} $ENV{LIBUSB_1_DIR}/lib "c:/libusb/lib" ) else() find_library(LIBUSB_1_LIBRARY usb-1.0 $ENV{LIBUSB_1_HOME}/lib $ENV{LIBUSB_1_HOME}/build/lib $ENV{LIBUSB_1_DIR}/lib $ENV{LIBUSB_1_DIR}/build/lib /lib/ /lib64/ /usr/lib /usr/local/lib ) find_path(LIBUSB_1_INCLUDE_DIR libusb.h $ENV{LIBUSB_1_HOME}/include/libusb-1.0 $ENV{LIBUSB_1_HOME}/build/include/libusb-1.0 $ENV{LIBUSB_1_DIR}/include/libusb-1.0 $ENV{LIBUSB_1_DIR}/build/include/libusb-1.0 /usr/include/libusb-1.0 /usr/local/include/libusb-1.0 ) endif() ## -------------------------------- if(LIBUSB_1_LIBRARY AND LIBUSB_1_INCLUDE_DIR) set(LIBUSB_1_INCLUDE_DIRS ${LIBUSB_1_INCLUDE_DIR}) set(LIBUSB_1_LIBRARIES ${LIBUSB_1_LIBRARY}) set(LIBUSB_1_FOUND TRUE) get_filename_component(LIBUSB_1_LIB_DIR ${LIBUSB_1_LIBRARY} PATH) vp_get_version_from_pkg("libusb" "${LIBUSB_1_LIB_DIR}/pkgconfig" LIBUSB_1_VERSION) if(NOT LIBUSB_1_VERSION) vp_get_version_from_pkg("libusb-1.0" "${LIBUSB_1_LIB_DIR}/pkgconfig" LIBUSB_1_VERSION) endif() else() set(LIBUSB_1_FOUND FALSE) endif() mark_as_advanced( LIBUSB_1_INCLUDE_DIRS LIBUSB_1_INCLUDE_DIR LIBUSB_1_LIBRARIES LIBUSB_1_LIBRARY ) visp-3.0.1/cmake/FindMyCoin3D.cmake000066400000000000000000000146151304511007300167450ustar00rootroot00000000000000############################################################################# # # This file is part of the ViSP software. # Copyright (C) 2005 - 2017 by Inria. All rights reserved. # # This software is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public License # ("GPL") version 2 as published by the Free Software Foundation. # See the file LICENSE.txt at the root directory of this source # distribution for additional information about the GNU GPL. # # For using ViSP with software that can not be combined with the GNU # GPL, please contact Inria about acquiring a ViSP Professional # Edition License. # # See http://visp.inria.fr for more information. # # This software was developed at: # Inria Rennes - Bretagne Atlantique # Campus Universitaire de Beaulieu # 35042 Rennes Cedex # France # # If you have questions regarding the use of this file, please contact # Inria at visp@inria.fr # # This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE # WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. # # Description: # Try to find Coin library. Try first to see if Coin3D-3 is available. If not, # check for Coin3D-2. # Once run this will define: # # COIN3D_FOUND # COIN3D_LIBRARIES # COIN3D_INCLUDE_DIRS # # Authors: # Fabien Spindler # ############################################################################# macro(TRY_COMPILE_WITH_COIN COIN3D_LIB COIN3D_INC) # Try to compile a sample code using Coin release library include(CheckCXXSourceCompiles) set(CMAKE_REQUIRED_LIBRARIES "${COIN3D_LIB}") set(CMAKE_REQUIRED_INCLUDES "${COIN3D_INC}") set(CMAKE_REQUIRED_DEFINITIONS "-DCOIN_DLL") #message("COIN3D_LIB: ${COIN3D_LIB}") #message("COIN3D_INC: ${COIN3D_INC}") check_cxx_source_compiles(" #include int main(){ SoSeparator *scene = new SoSeparator; return 0; } " IS_COMPILER_COMPATIBLE) #message("DBG1 IS_COMPILER_COMPATIBLE ${IS_COMPILER_COMPATIBLE}") endmacro() if(UNIX OR WIN32) find_path(COIN3D_INCLUDE_DIR Inventor/nodes/SoSeparator.h $ENV{COIN_DIR}/include $ENV{COINDIR}/include $ENV{COIN_DIR} $ENV{COINDIR} $ENV{COIN3D_DIR}/include $ENV{COIN3DDIR}/include /usr/include /usr/include/Coin2 /usr/include/Coin3 /Library/Frameworks/Inventor.framework/Headers ) #message("DBG COIN3D_INCLUDE_DIR=${COIN3D_INCLUDE_DIR}") if(WIN32) # Try first to find Coin3D-3 and only if not found Coin3D-2 find_library(COIN3D_LIBRARY_RELEASE NAMES coin3 coin4 #only shared libraries under windows PATHS "$ENV{COINDIR}/lib" "$ENV{COIN_DIR}/lib" "$ENV{COIN3DDIR}/lib" "$ENV{COIN3D_DIR}/lib" ) find_library(COIN3D_LIBRARY_DEBUG NAMES coin3d coin4d #only shared libraries under windows PATHS "$ENV{COINDIR}/lib" "$ENV{COIN_DIR}/lib" "$ENV{COIN3DDIR}/lib" "$ENV{COIN3D_DIR}/lib" ) #MESSAGE("DBG COIN3D_LIBRARY_RELEASE=${COIN3D_LIBRARY_RELEASE}") #MESSAGE("DBG COIN3D_LIBRARY_DEBUG=${COIN3D_LIBRARY_DEBUG}") else(WIN32) find_library(COIN3D_LIBRARY NAMES Coin PATHS "$ENV{COINDIR}/lib" "$ENV{COIN_DIR}/lib" "$ENV{COIN3DDIR}/lib" "$ENV{COIN3D_DIR}/lib" /Library/Frameworks/Inventor.framework/Libraries ) #MESSAGE("DBG COIN3D_LIBRARY=${COIN3D_LIBRARY}") endif(WIN32) mark_as_advanced( COIN3D_INCLUDE_DIR COIN3D_LIBRARY_RELEASE COIN3D_LIBRARY_DEBUG COIN3D_LIBRARY ) ## -------------------------------- if((COIN3D_LIBRARY OR COIN3D_LIBRARY_RELEASE OR COIN3D_LIBRARY_DEBUG) AND COIN3D_INCLUDE_DIR) if(WIN32) if(COIN3D_LIBRARY_RELEASE) TRY_COMPILE_WITH_COIN(${COIN3D_LIBRARY_RELEASE} ${COIN3D_INCLUDE_DIR}) if(NOT IS_COMPILER_COMPATIBLE) set(COIN3D_LIBRARY_RELEASE FALSE) endif() endif() # Try to found COIN3D-2 if(NOT COIN3D_LIBRARY_RELEASE) find_library(COIN3D_LIBRARY_RELEASE NAMES coin2 #only shared libraries under windows PATHS "$ENV{COINDIR}/lib" "$ENV{COIN_DIR}/lib" "$ENV{COIN3DDIR}/lib" "$ENV{COIN3D_DIR}/lib" ) TRY_COMPILE_WITH_COIN(${COIN3D_LIBRARY_RELEASE} ${COIN3D_INCLUDE_DIR}) if(NOT IS_COMPILER_COMPATIBLE) set(COIN3D_LIBRARY_RELEASE FALSE) endif() endif() if(COIN3D_LIBRARY_DEBUG) TRY_COMPILE_WITH_COIN(${COIN3D_LIBRARY_DEBUG} ${COIN3D_INCLUDE_DIR}) if(NOT IS_COMPILER_COMPATIBLE) set(COIN3D_LIBRARY_DEBUG FALSE) endif() endif() # Try to found COIN3D-2 if(NOT COIN3D_LIBRARY_DEBUG) find_library(COIN3D_LIBRARY_DEBUG NAMES coin2d #only shared libraries under windows PATHS "$ENV{COINDIR}/lib" "$ENV{COIN_DIR}/lib" "$ENV{COIN3DDIR}/lib" "$ENV{COIN3D_DIR}/lib" ) TRY_COMPILE_WITH_COIN(${COIN3D_LIBRARY_DEBUG} ${COIN3D_INCLUDE_DIR}) if(NOT IS_COMPILER_COMPATIBLE) set(COIN3D_LIBRARY_DEBUG FALSE) endif() endif() if(NOT COIN3D_LIBRARY_RELEASE AND NOT COIN3D_LIBRARY_DEBUG) set(COIN3D_FOUND FALSE) endif() else(WIN32) TRY_COMPILE_WITH_COIN(${COIN3D_LIBRARY} ${COIN3D_INCLUDE_DIR}) if(IS_COMPILER_COMPATIBLE) set(COIN3D_LIBRARIES ${COIN3D_LIBRARY}) set(COIN3D_FOUND TRUE) mark_as_advanced( COIN3D_LIBRARIES COIN3D_LIBRARY ) else(IS_COMPILER_COMPATIBLE) set(COIN3D_FOUND FALSE) endif() endif(WIN32) set(COIN3D_INCLUDE_DIRS ${COIN3D_INCLUDE_DIR}) set(COIN3D_FOUND TRUE) else((COIN3D_LIBRARY OR COIN3D_LIBRARY_RELEASE OR COIN3D_LIBRARY_DEBUG) AND COIN3D_INCLUDE_DIR) set(COIN3D_FOUND FALSE) #MESSAGE("Coin library not found.") endif((COIN3D_LIBRARY OR COIN3D_LIBRARY_RELEASE OR COIN3D_LIBRARY_DEBUG) AND COIN3D_INCLUDE_DIR) #MESSAGE(STATUS "COIN3D_FOUND : ${COIN3D_FOUND}") if(COIN3D_FOUND) if(COIN3D_LIBRARY_DEBUG AND COIN3D_LIBRARY_RELEASE) set(COIN3D_LIBRARIES optimized ${COIN3D_LIBRARY_RELEASE} debug ${COIN3D_LIBRARY_DEBUG}) else() if(COIN3D_LIBRARY_DEBUG) set(COIN3D_LIBRARIES ${COIN3D_LIBRARY_DEBUG}) endif() if(COIN3D_LIBRARY_RELEASE) set(COIN3D_LIBRARIES ${COIN3D_LIBRARY_RELEASE}) endif() endif() endif() else(UNIX OR WIN32) set(COIN3D_FOUND FALSE) endif(UNIX OR WIN32) visp-3.0.1/cmake/FindMyGTK2.cmake000066400000000000000000000206461304511007300163760ustar00rootroot00000000000000############################################################################# # # This file is part of the ViSP software. # Copyright (C) 2005 - 2017 by Inria. All rights reserved. # # This software is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public License # ("GPL") version 2 as published by the Free Software Foundation. # See the file LICENSE.txt at the root directory of this source # distribution for additional information about the GNU GPL. # # For using ViSP with software that can not be combined with the GNU # GPL, please contact Inria about acquiring a ViSP Professional # Edition License. # # See http://visp.inria.fr for more information. # # This software was developed at: # Inria Rennes - Bretagne Atlantique # Campus Universitaire de Beaulieu # 35042 Rennes Cedex # France # # If you have questions regarding the use of this file, please contact # Inria at visp@inria.fr # # This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE # WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. # # Description: # Try to find GTK (and glib). # Once run this will define: # # GTK2_INCLUDE_DIRS - Directories to include to use GTK # GTK2_LIBRARIES - Files to link against to use GTK # GTK2_FOUND - If false, don't try to use GTK # GTK2_GL_FOUND - If false, don't try to use GTK's GL features # GTK2_VERSION # # Authors: # Fabien Spindler # ############################################################################# IF(UNIX OR WIN32) FIND_PATH( GTK2_gtk_INCLUDE_PATH gtk/gtk.h $ENV{GTK2_DIR}/include/gtk-2.0 $ENV{GTK2_HOME}/include/gtk-2.0 /usr/include/gtk-2.0 /usr/local/include/gtk-2.0 /opt/gnome/include/gtk-2.0 "C:/GTK/include/gtk-2.0" /sw/include/gtk-2.0 ) # Some Linux distributions (e.g. Red Hat) have glibconfig.h # and glib.h in different directories, so we need to look # for both. # - Atanas Georgiev FIND_PATH( GTK2_glibconfig_INCLUDE_PATH glibconfig.h $ENV{GTK2_DIR}/lib/glib-2.0/include $ENV{GTK2_HOME}/lib/glib-2.0/include /usr/lib/glib-2.0/include /usr/lib64/glib-2.0/include /usr/lib/i386-linux-gnu/glib-2.0/include /usr/lib/x86_64-linux-gnu/glib-2.0/include /opt/gnome/lib/glib-2.0/include C:/GTK/lib/glib-2.0/include /sw/lib/glib-2.0/include ) FIND_PATH( GTK2_glib_INCLUDE_PATH glib.h $ENV{GTK2_DIR}/include/glib-2.0 $ENV{GTK2_HOME}/include/glib-2.0 /usr/include/glib-2.0 /opt/gnome/include/glib-2.0 C:/GTK/include/glib-2.0 /sw/include/glib-2.0 ) FIND_PATH( GTK2_pango_INCLUDE_PATH pango/pango.h $ENV{GTK2_DIR}/include/pango-1.0 $ENV{GTK2_HOME}/include/pango-1.0 /usr/include/pango-1.0 /opt/gnome/include/pango-1.0 C:/GTK/include/pango-1.0 /sw/include/pango-1.0 ) FIND_PATH( GTK2_cairo_INCLUDE_PATH cairo.h $ENV{GTK2_DIR}/include/cairo $ENV{GTK2_HOME}/include/cairo /usr/include/cairo /opt/gnome/include/cairo C:/GTK/include/cairo /sw/include/cairo ) FIND_PATH( GTK2_gdkconfig_INCLUDE_PATH gdkconfig.h $ENV{GTK2_DIR}/lib/gtk-2.0/include $ENV{GTK2_HOME}/lib/gtk-2.0/include /usr/lib/gtk-2.0/include /usr/lib64/gtk-2.0/include /opt/gnome/lib/gtk-2.0/include C:/GTK/lib/gtk-2.0/include /sw/lib/gtk-2.0/include /usr/lib/i386-linux-gnu/gtk-2.0/include /usr/lib/x86_64-linux-gnu/gtk-2.0/include ) FIND_PATH( GTK2_gdkpixbuf_INCLUDE_PATH gdk-pixbuf/gdk-pixbuf.h $ENV{GTK2_DIR}/gdk-pixbuf-2.0 $ENV{GTK2_HOME}/gdk-pixbuf-2.0 /usr/include/gdk-pixbuf-2.0 /usr/include/gtk-2.0 C:/GTK/include/gtk-2.0 /sw/include/gtk-2.0 ) #MESSAGE("GTK2_gdkpixbuf_INCLUDE_PATH: ${GTK2_gdkpixbuf_INCLUDE_PATH}") FIND_PATH( GTK2_atk_INCLUDE_PATH atk/atk.h $ENV{GTK2_DIR}/include/atk-1.0 $ENV{GTK2_HOME}/include/atk-1.0 /usr/include/atk-1.0 /opt/gnome/include/atk-1.0 C:/GTK/include/atk-1.0 /sw/include/atk-1.0 ) FIND_LIBRARY( GTK2_gtk_LIBRARY NAMES gtk-x11-2.0 gtk-win32-2.0 PATHS $ENV{GTK2_DIR}/lib PATHS $ENV{GTK2_HOME}/lib /usr/lib /usr/local/lib /usr/openwin/lib /usr/X11R6/lib /opt/gnome/lib C:/GTK/lib /sw/lib ) FIND_LIBRARY( GTK2_gdk_LIBRARY NAMES gdk-x11-2.0 gdk-win32-2.0 PATHS $ENV{GTK2_DIR}/lib PATHS $ENV{GTK2_HOME}/lib /usr/lib /usr/local/lib /usr/openwin/lib /usr/X11R6/lib /opt/gnome/lib C:/GTK/lib /sw/lib ) FIND_LIBRARY( GTK2_gmodule_LIBRARY NAMES gmodule-2.0 PATHS $ENV{GTK2_DIR}/lib PATHS $ENV{GTK2_HOME}/lib /usr/lib /usr/local/lib /usr/openwin/lib /usr/X11R6/lib /opt/gnome/lib C:/GTK/lib /sw/lib ) FIND_LIBRARY( GTK2_glib_LIBRARY NAMES glib-2.0 PATHS $ENV{GTK2_DIR}/lib PATHS $ENV{GTK2_HOME}/lib /usr/lib /usr/local/lib /usr/openwin/lib /usr/X11R6/lib /opt/gnome/lib C:/GTK/lib /sw/lib ) FIND_LIBRARY( GTK2_gthread_LIBRARY NAMES gthread-2.0 PATHS $ENV{GTK2_DIR}/lib PATHS $ENV{GTK2_HOME}/lib /usr/lib /usr/local/lib /usr/openwin/lib /usr/X11R6/lib /opt/gnome/lib C:/GTK/lib /sw/lib ) FIND_LIBRARY( GTK2_gobject_LIBRARY NAMES gobject-2.0 PATHS $ENV{GTK2_DIR}/lib PATHS $ENV{GTK2_HOME}/lib /usr/lib /opt/gnome/lib C:/GTK/lib /sw/lib ) IF(GTK2_gtk_INCLUDE_PATH) IF(GTK2_glib_INCLUDE_PATH) IF(GTK2_glibconfig_INCLUDE_PATH) IF(GTK2_gtk_LIBRARY) IF(GTK2_glib_LIBRARY) IF(GTK2_pango_INCLUDE_PATH) IF(GTK2_gdkconfig_INCLUDE_PATH) IF(GTK2_atk_INCLUDE_PATH) # Assume that if gtk and glib were found, the other # supporting libraries have also been found. SET( GTK2_FOUND "YES" ) SET( GTK2_INCLUDE_DIRS ${GTK2_gtk_INCLUDE_PATH} ${GTK2_glib_INCLUDE_PATH} ${GTK2_glibconfig_INCLUDE_PATH} ${GTK2_pango_INCLUDE_PATH} ${GTK2_atk_INCLUDE_PATH} ${GTK2_gdkconfig_INCLUDE_PATH}) IF(GTK2_cairo_INCLUDE_PATH) LIST(APPEND GTK2_INCLUDE_DIRS ${GTK2_cairo_INCLUDE_PATH} ) ENDIF(GTK2_cairo_INCLUDE_PATH) IF(GTK2_gdkpixbuf_INCLUDE_PATH) LIST(APPEND GTK2_INCLUDE_DIRS ${GTK2_gdkpixbuf_INCLUDE_PATH} ) ENDIF() IF(GTK2_gdkconfig_INCLUDE_PATH) LIST(APPEND GTK2_INCLUDE_DIRS ${GTK2_gdkconfig_INCLUDE_PATH} ) ENDIF(GTK2_gdkconfig_INCLUDE_PATH) SET( GTK2_LIBRARIES ${GTK2_gtk_LIBRARY} ${GTK2_gdk_LIBRARY} ${GTK2_glib_LIBRARY} ${GTK2_gobject_LIBRARY}) get_filename_component(GTK2_LIB_DIR ${GTK2_gtk_LIBRARY} PATH) vp_get_version_from_pkg("gtk+-2.0" "${GTK2_LIB_DIR}/pkgconfig" GTK2_VERSION) IF(GTK2_gmodule_LIBRARY) LIST(APPEND GTK2_LIBRARIES ${GTK2_gmodule_LIBRARY}) ENDIF(GTK2_gmodule_LIBRARY) IF(GTK2_gthread_LIBRARY) LIST(APPEND GTK2_LIBRARIES ${GTK2_gthread_LIBRARY}) ENDIF(GTK2_gthread_LIBRARY) ELSE(GTK2_atk_INCLUDE_PATH) MESSAGE("Can not find atk") ENDIF(GTK2_atk_INCLUDE_PATH) ELSE(GTK2_gdkconfig_INCLUDE_PATH) #MESSAGE("Can not find gdkconfig include") ENDIF(GTK2_gdkconfig_INCLUDE_PATH) ELSE(GTK2_pango_INCLUDE_PATH) #MESSAGE("Can not find pango includes") ENDIF(GTK2_pango_INCLUDE_PATH) ELSE(GTK2_glib_LIBRARY) #MESSAGE("Can not find glib lib") ENDIF(GTK2_glib_LIBRARY) ELSE(GTK2_gtk_LIBRARY) #MESSAGE("Can not find gtk lib") ENDIF(GTK2_gtk_LIBRARY) ELSE(GTK2_glibconfig_INCLUDE_PATH) #MESSAGE("Can not find glibconfig includes") ENDIF(GTK2_glibconfig_INCLUDE_PATH) ELSE(GTK2_glib_INCLUDE_PATH) #MESSAGE("Can not find glib includes") ENDIF(GTK2_glib_INCLUDE_PATH) ELSE(GTK2_gtk_INCLUDE_PATH) #MESSAGE("Can not find gtk includes") ENDIF(GTK2_gtk_INCLUDE_PATH) MARK_AS_ADVANCED( GTK2_gdk_LIBRARY GTK2_glib_INCLUDE_PATH GTK2_glib_LIBRARY GTK2_glibconfig_INCLUDE_PATH GTK2_gmodule_LIBRARY GTK2_gthread_LIBRARY GTK2_gtk_INCLUDE_PATH GTK2_gtk_LIBRARY GTK2_atk_INCLUDE_PATH GTK2_gdkconfig_INCLUDE_PATH GTK2_gobject_LIBRARY GTK2_pango_INCLUDE_PATH GTK2_cairo_INCLUDE_PATH GTK2_gdkpixbuf_INCLUDE_PATH ) ELSE(UNIX OR WIN32) MESSAGE("FindGTK2 is working on UNIX/LINUX and Windows, only!") ENDIF(UNIX OR WIN32) visp-3.0.1/cmake/FindMyJPEG.cmake000066400000000000000000000065161304511007300164140ustar00rootroot00000000000000############################################################################# # # This file is part of the ViSP software. # Copyright (C) 2005 - 2017 by Inria. All rights reserved. # # This software is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public License # ("GPL") version 2 as published by the Free Software Foundation. # See the file LICENSE.txt at the root directory of this source # distribution for additional information about the GNU GPL. # # For using ViSP with software that can not be combined with the GNU # GPL, please contact Inria about acquiring a ViSP Professional # Edition License. # # See http://visp.inria.fr for more information. # # This software was developed at: # Inria Rennes - Bretagne Atlantique # Campus Universitaire de Beaulieu # 35042 Rennes Cedex # France # # If you have questions regarding the use of this file, please contact # Inria at visp@inria.fr # # This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE # WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. # # Description: # Try to find libjpeg library. # Once run this will define: # # JPEG_FOUND # JPEG_INCLUDE_DIRS # JPEG_LIBRARIES # # Authors: # Nicolas Melchior # ############################################################################# # detection of the Libjpeg headers location if(MINGW) find_path(JPEG_INCLUDE_DIR NAMES jpeglib.h PATHS "$ENV{MINGW_DIR}/include" C:/mingw/include ) # Detection of the Libjpeg library on Unix find_library(JPEG_LIBRARY NAMES jpeg libjpeg PATHS "$ENV{MINGW_DIR}/lib" "$ENV{MINGW_DIR}/lib64" C:/mingw/lib64 ) else() find_path(JPEG_INCLUDE_DIR NAMES jpeglib.h PATHS "/usr/include" "/usr/local/include" $ENV{LIBJPEG_DIR}/include $ENV{LIBJPEG_DIR} "C:/Program Files/GnuWin32/include" ) # Detection of the Libjpeg library on Unix find_library(JPEG_LIBRARY NAMES jpeg libjpeg PATHS /usr/lib /usr/local/lib /lib $ENV{LIBJPEG_DIR}/lib $ENV{LIBJPEG_DIR}/Release $ENV{LIBJPEG_DIR} "C:/Program Files/GnuWin32/lib" ) endif() #MESSAGE("JPEG_INCLUDE_DIR=${JPEG_INCLUDE_DIR}") #MESSAGE("JPEG_LIBRARY=${JPEG_LIBRARY}") MARK_AS_ADVANCED( JPEG_LIBRARY JPEG_INCLUDE_DIR ) ## -------------------------------- IF(JPEG_LIBRARY AND JPEG_INCLUDE_DIR) # The material is found. Check if it works on the requested architecture include(CheckCXXSourceCompiles) SET(CMAKE_REQUIRED_LIBRARIES ${JPEG_LIBRARY}) SET(CMAKE_REQUIRED_INCLUDES ${JPEG_INCLUDE_DIR}) CHECK_CXX_SOURCE_COMPILES(" #include #include // Contrib for jpeg image io #include int main() { struct jpeg_decompress_struct cinfo; struct jpeg_error_mgr jerr; cinfo.err = jpeg_std_error(&jerr); } " JPEG_BUILD_TEST) #MESSAGE("JPEG_BUILD_TEST: ${JPEG_BUILD_TEST}") IF(JPEG_BUILD_TEST) SET(JPEG_INCLUDE_DIRS ${JPEG_INCLUDE_DIR}) SET(JPEG_LIBRARIES ${JPEG_LIBRARY}) SET(JPEG_FOUND TRUE) ELSE() SET(JPEG_FOUND FALSE) #MESSAGE("libjpeg library found but not compatible with architecture.") ENDIF() ELSE(JPEG_LIBRARY AND JPEG_INCLUDE_DIR) SET(JPEG_FOUND FALSE) ENDIF(JPEG_LIBRARY AND JPEG_INCLUDE_DIR) visp-3.0.1/cmake/FindMyOpenCV.cmake000066400000000000000000000163041304511007300170150ustar00rootroot00000000000000############################################################################# # # This file is part of the ViSP software. # Copyright (C) 2005 - 2017 by Inria. All rights reserved. # # This software is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public License # ("GPL") version 2 as published by the Free Software Foundation. # See the file LICENSE.txt at the root directory of this source # distribution for additional information about the GNU GPL. # # For using ViSP with software that can not be combined with the GNU # GPL, please contact Inria about acquiring a ViSP Professional # Edition License. # # See http://visp.inria.fr for more information. # # This software was developed at: # Inria Rennes - Bretagne Atlantique # Campus Universitaire de Beaulieu # 35042 Rennes Cedex # France # # If you have questions regarding the use of this file, please contact # Inria at visp@inria.fr # # This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE # WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. # # Description: # Try to find OpenCV framework. # # OpenCV_FOUND # OpenCV_INCLUDE_DIRS (only for naoqi) # OpenCV_LIBRARIES # OpenCV_VERSION_MAJOR # OpenCV_VERSION_MINOR # OpenCV_VERSION_PATCH # OpenCV_VERSION # # Authors: # Fabien Spindler # ############################################################################# # Parse FILENAME in order to find the cxx macro DEFINE # and get its value in VAR. # Useful to get the value of CV_VERSION_MAJOR, CV_VERSION_MINOR, CV_VERSION_REVISION macro(vp_get_opencv_version_from_hpp FILENAME DEFINE VAR) if(EXISTS "${FILENAME}") file(STRINGS ${FILENAME} __matches REGEX "#define ${DEFINE}") vp_create_list_from_string(${__matches} __list) list(LENGTH __list __length) if(__length EQUAL 3) list(REVERSE __list) list(GET __list 0 ${VAR}) else() message("Warning: OpenCV macro ${DEFINE} not found in ${FILENAME}. The following var ${VAR} is set to 0. This may produce build issues.") set(${__var} 0) endif() else() message("Warning: Cannot retrive OpenCV version from non existing file ${FILENAME}. This may produce build issues.") set(${__var} 0) endif() endmacro() macro(find_package_naoqi module) set(${module}_FOUND FALSE) set(${module}_INCLUDE_DIRS "") set(${module}_LIBRARIES "") set(${module}_DEPS "") set(${module}_DEPS_PROCESSED "") _find_package_naoqi_internal(${module}) # remove allready treated deps foreach(__d ${${module}_DEPS_PROCESSED}) list(FIND ${module}_DEPS ${__d} __index) if(NOT __index LESS 0) list(REMOVE_AT ${module}_DEPS ${__index}) endif() endforeach() # hack for ctc-linux??-atom-2.3.1.23 where alsa module required by ffmpeg is not a dependency string(FIND "${TOOLCHAIN_ROOT_DIR}" "-atom-2.3" __apply_hack) if(__apply_hack GREATER 0) list(APPEND ${module}_DEPS ALSA) endif() while(${module}_DEPS) vp_list_pop_front(${module}_DEPS __d) string(TOUPPER "${__d}" __upper_d) _find_package_naoqi_internal(${__upper_d}) if(${__upper_d}_FOUND) if(${__upper_d}_INCLUDE_DIRS) list(APPEND ${module}_INCLUDE_DIRS "${${__upper_d}_INCLUDE_DIRS}") endif() if(${__upper_d}_LIBRARIES) list(APPEND ${module}_LIBRARIES "${${__upper_d}_LIBRARIES}") endif() list(APPEND ${module}_DEPS_PROCESSED ${__upper_d}) if(${__upper_d}_DEPS) vp_list_unique(${__upper_d}_DEPS) # add only deps if not already processed foreach(__new_d ${${__upper_d}_DEPS}) list(FIND ${module}_DEPS_PROCESSED ${__new_d} __index) if(__index LESS 0) list(APPEND ${module}_DEPS ${__new_d}) endif() endforeach() endif() vp_list_unique(${module}_DEPS) endif() endwhile() vp_list_unique(${module}_INCLUDE_DIRS) vp_list_unique(${module}_LIBRARIES) endmacro() macro(_find_package_naoqi_internal module) string(TOLOWER "${module}" __lower_module) file(GLOB __submodule RELATIVE "${TOOLCHAIN_ROOT_DIR}/${__lower_module}/share/cmake" "${TOOLCHAIN_ROOT_DIR}/${__lower_module}/share/cmake/*") foreach(__s ${__submodule}) set(${__s}_DIR "${TOOLCHAIN_ROOT_DIR}/${__lower_module}/share/cmake/${__s}") find_package(${__s}) if(${__s}_FOUND) set(${module}_FOUND TRUE) string(TOUPPER "${__s}" __upper_s) if(${__upper_s}_INCLUDE_DIRS) list(APPEND ${module}_INCLUDE_DIRS ${${__upper_s}_INCLUDE_DIRS}) endif() if(${__upper_s}_LIBRARIES) list(APPEND ${module}_LIBRARIES ${${__upper_s}_LIBRARIES}) endif() if(${__upper_s}_DEPENDS) list(APPEND ${module}_DEPS ${${__upper_s}_DEPENDS}) endif() list(APPEND ${module}_DEPS_PROCESSED ${__upper_s}) endif() unset(${__s}_DIR) endforeach() if(${module}_FOUND) # check if there are not other libs that are not submodule and append file(GLOB __libs "${TOOLCHAIN_ROOT_DIR}/${__lower_module}/lib/lib*.so") foreach(__l ${__libs}) list(FIND ${module}_LIBRARIES ${__l} __index) if(__index LESS 0) list(APPEND ${module}_LIBRARIES ${__l}) endif() endforeach() vp_list_unique(${lower_submodule}_LIBRARIES) endif() endmacro() if(APPLE_FRAMEWORK) find_library(OpenCV_FRAMEWORK opencv2) if(OpenCV_FRAMEWORK) set(OpenCV_FOUND TRUE) set(OpenCV_LIBRARIES ${OpenCV_FRAMEWORK}) file(GLOB_RECURSE opencv_version_file "${OpenCV_FRAMEWORK}/Headers/version.hpp") vp_get_opencv_version_from_hpp(${opencv_version_file} "CV_VERSION_MAJOR" OpenCV_VERSION_MAJOR) vp_get_opencv_version_from_hpp(${opencv_version_file} "CV_VERSION_MINOR" OpenCV_VERSION_MINOR) vp_get_opencv_version_from_hpp(${opencv_version_file} "CV_VERSION_REVISION" OpenCV_VERSION_PATCH) set(OpenCV_VERSION "${OpenCV_VERSION_MAJOR}.${OpenCV_VERSION_MINOR}.${OpenCV_VERSION_PATCH}") else() set(OpenCV_FOUND FALSE) endif() mark_as_advanced(OpenCV_FRAMEWORK) endif() # Detect if the toolchain is for Aldebaran naoqi if(CMAKE_TOOLCHAIN_FILE AND I_AM_A_ROBOT) find_package_naoqi(OpenCV) if(OpenCV_FOUND) file(GLOB_RECURSE opencv_version_file "${TOOLCHAIN_ROOT_DIR}/opencv/include/opencv2/core/version.hpp") # check if old version like 2.4.5 has CV_VERSION_EPOCH vp_get_opencv_version_from_hpp(${opencv_version_file} "CV_VERSION_EPOCH" OpenCV_VERSION_MAJOR) if(OpenCV_VERSION_MAJOR EQUAL 0) vp_get_opencv_version_from_hpp(${opencv_version_file} "CV_VERSION_MAJOR" OpenCV_VERSION_MAJOR) vp_get_opencv_version_from_hpp(${opencv_version_file} "CV_VERSION_MINOR" OpenCV_VERSION_MINOR) vp_get_opencv_version_from_hpp(${opencv_version_file} "CV_VERSION_REVISION" OpenCV_VERSION_PATCH) else() vp_get_opencv_version_from_hpp(${opencv_version_file} "CV_VERSION_MAJOR" OpenCV_VERSION_MINOR) vp_get_opencv_version_from_hpp(${opencv_version_file} "CV_VERSION_MINOR" OpenCV_VERSION_PATCH) endif() set(OpenCV_VERSION "${OpenCV_VERSION_MAJOR}.${OpenCV_VERSION_MINOR}.${OpenCV_VERSION_PATCH}") # check if nonfree module exists foreach(__l ${OpenCV_LIBRARIES}) string(REGEX MATCH "^.*opencv_nonfree" has_nonfree ${__l}) if(has_nonfree) set(OPENCV_NONFREE_FOUND TRUE) break() endif() endforeach() endif() endif() visp-3.0.1/cmake/FindMyPNG.cmake000066400000000000000000000123461304511007300163110ustar00rootroot00000000000000############################################################################# # # This file is part of the ViSP software. # Copyright (C) 2005 - 2017 by Inria. All rights reserved. # # This software is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public License # ("GPL") version 2 as published by the Free Software Foundation. # See the file LICENSE.txt at the root directory of this source # distribution for additional information about the GNU GPL. # # For using ViSP with software that can not be combined with the GNU # GPL, please contact Inria about acquiring a ViSP Professional # Edition License. # # See http://visp.inria.fr for more information. # # This software was developed at: # Inria Rennes - Bretagne Atlantique # Campus Universitaire de Beaulieu # 35042 Rennes Cedex # France # # if you have questions regarding the use of this file, please contact # Inria at visp@inria.fr # # This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE # WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. # # Description: # Try to find libpng library. # To use the libpng library, the zlib library is required. # Once run this will define: # # PNG_FOUND # PNG_INCLUDE_DIR # PNG_LIBRARIES # PNG_VERSION_STRING # # Authors: # Nicolas Melchior # ############################################################################# # detection of the Libpng headers location if(MINGW) find_path(PNG_INCLUDE_DIR NAMES png.h PATHS "C:/mingw/include/libpng14" "$ENV{MINGW_DIR}/include/libpng14" ) else() find_path(PNG_INCLUDE_DIR NAMES png.h PATHS "$ENV{LIBPNG_DIR}/include" "$ENV{LIBPNG_DIR}" "$ENV{LIBPNG_INCLUDE_DIR}" "/usr/include" "/usr/local/include" "C:/Program Files/libpng/include" ) endif() #message("PNG_INCLUDE_DIR=${PNG_INCLUDE_DIR}") if(UNIX) # Detection of the Libpng library on Unix find_library(PNG_LIBRARY NAMES png15 libpng15 libpng14 png12 libpng12 png libpng PATHS "$ENV{LIBPNG_DIR}/lib" "$ENV{LIBPNG_DIR}/Release" "$ENV{LIBPNG_DIR}" "$ENV{LIBPNG_LIBRARY_DIR}" /usr/lib /usr/local/lib /lib "C:/Program Files/libpng/lib" ) elseif(MINGW) # Detection of the Libpng library on mingw find_library(PNG_LIBRARY NAMES png15 libpng15 libpng14 png12 libpng12 png libpng PATHS "C:/mingw/lib64" "$ENV{MINGW_DIR}/lib64" ) #message("PNG_LIBRARY=${PNG_LIBRARY}") else() find_library(PNG_LIBRARY_RELEASE NAMES png15 libpng15 png12 libpng12 png libpng PATHS $ENV{LIBPNG_DIR}/lib $ENV{LIBPNG_DIR}/Release $ENV{LIBPNG_DIR} $ENV{LIBPNG_LIBRARY_RELEASE_DIR} /usr/lib /usr/local/lib /lib "C:/Program Files/libpng/lib" ) find_library(PNG_LIBRARY_DEBUG NAMES png15d libpng15d png12d libpng12d pngd libpngd PATHS $ENV{LIBPNG_DIR}/lib $ENV{LIBPNG_DIR}/Debug $ENV{LIBPNG_DIR} $ENV{LIBPNG_LIBRARY_DEBUG_DIR} /usr/lib /usr/local/lib /lib "C:/Program Files/libpng/lib" ) #message("PNG_LIBRARY_RELEASE=${PNG_LIBRARY_RELEASE}") #message("PNG_LIBRARY_DEBUG=${PNG_LIBRARY_DEBUG}") endif(UNIX) ## -------------------------------- set(PNG_FOUND FALSE) find_package(ZLIB) if(NOT ZLIB_FOUND) find_package(MyZLIB) endif() if(UNIX) if(PNG_LIBRARY AND PNG_INCLUDE_DIR) set(PNG_INCLUDE_DIRS ${PNG_INCLUDE_DIR}) set(PNG_LIBRARIES ${PNG_LIBRARY}) get_filename_component(PNG_LIB_DIR ${PNG_LIBRARY} DIRECTORY) vp_get_version_from_pkg("libpng" "${PNG_LIB_DIR}/pkgconfig" PNG_VERSION_STRING) set(PNG_FOUND TRUE) endif() else(UNIX) set(PNG_LIBRARIES "") if(PNG_LIBRARY_RELEASE AND PNG_INCLUDE_DIR) set(PNG_INCLUDE_DIRS ${PNG_INCLUDE_DIR}) list(APPEND PNG_LIBRARIES optimized ${PNG_LIBRARY_RELEASE}) set(PNG_FOUND TRUE) endif() if(PNG_LIBRARY_DEBUG AND PNG_INCLUDE_DIR) set(PNG_INCLUDE_DIRS ${PNG_INCLUDE_DIR}) list(APPEND PNG_LIBRARIES debug ${PNG_LIBRARY_DEBUG}) set(PNG_FOUND TRUE) endif() endif(UNIX) if(PNG_FOUND) vp_parse_header2(PNG "${PNG_INCLUDE_DIR}/png.h" PNG_LIBPNG_VER_STRING) endif() if(ZLIB_FOUND) if(PNG_FOUND) # The material is found. Check if it works on the requested architecture include(CheckCXXSourceCompiles) #message(PNG_LIBRARIES: ${PNG_LIBRARIES}) #message(ZLIB_LIBRARIES: ${ZLIB_LIBRARIES}) set(CMAKE_REQUIRED_LIBRARIES ${PNG_LIBRARIES} ${ZLIB_LIBRARIES}) set(CMAKE_REQUIRED_INCLUDES ${PNG_INCLUDE_DIRS} ${ZLIB_INCLUDE_DIRS}) CHECK_CXX_SOURCE_COMPILES(" #include // Contrib for png image io int main() { /* create a png read struct */ png_structp png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL); } " PNG_BUILD_TEST) #message("PNG_BUILD_TEST: ${PNG_BUILD_TEST}") if(PNG_BUILD_TEST) set(PNG_FOUND TRUE) else() set(PNG_FOUND FALSE) message("libpng library found but not compatible with architecture.") endif() elseif(PNG_FOUND) message("To use libpng library, you should also install zlib library") endif() endif() mark_as_advanced( PNG_LIBRARY PNG_LIBRARY_DEBUG PNG_LIBRARY_RELEASE PNG_INCLUDE_DIR ) visp-3.0.1/cmake/FindMyZLIB.cmake000066400000000000000000000063411304511007300164230ustar00rootroot00000000000000############################################################################# # # This file is part of the ViSP software. # Copyright (C) 2005 - 2017 by Inria. All rights reserved. # # This software is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public License # ("GPL") version 2 as published by the Free Software Foundation. # See the file LICENSE.txt at the root directory of this source # distribution for additional information about the GNU GPL. # # For using ViSP with software that can not be combined with the GNU # GPL, please contact Inria about acquiring a ViSP Professional # Edition License. # # See http://visp.inria.fr for more information. # # This software was developed at: # Inria Rennes - Bretagne Atlantique # Campus Universitaire de Beaulieu # 35042 Rennes Cedex # France # # If you have questions regarding the use of this file, please contact # Inria at visp@inria.fr # # This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE # WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. # # Description: # Try to find zlib library. # This file should be used only if FindZLIB.cmake provided with CMake # is not able to detect zlib. # The detection can be eased by setting ZLIB_HOME environment variable # especially under windows. # # ZLIB_FOUND # ZLIB_INCLUDE_DIRS # ZLIB_LIBRARIES # # Authors: # Fabien Spindler # ############################################################################# if(MINGW) find_path(ZLIB_INCLUDE_DIR zlib.h "$ENV{MINGW_DIR}/include" C:/mingw/include ) else() find_path(ZLIB_INCLUDE_DIR zlib.h $ENV{ZLIB_DIR}/include $ENV{ZLIB_INCLUDE_DIR} /usr/include /usr/local/include "C:/Program Files/zlib/include" ) endif() if(UNIX) find_library(ZLIB_LIBRARY z zlib $ENV{ZLIB_DIR}/lib $ENV{ZLIB_LIBRARY_DIR} /lib /usr/lib /usr/local/lib "C:/Program Files/zlib/lib" ) elseif(MINGW) find_library(ZLIB_LIBRARY z zlib "$ENV{MINGW_DIR}/lib64" C:/mingw/lib64 ) else() find_library(ZLIB_LIBRARY_RELEASE z zlib $ENV{ZLIB_DIR}/lib $ENV{ZLIB_LIBRARY_RELEASE_DIR} /lib /usr/lib /usr/local/lib "C:/Program Files/zlib/lib" "$ENV{MINGW_DIR}/lib64" C:/mingw/lib64 ) FIND_LIBRARY(ZLIB_LIBRARY_DEBUG zlibd $ENV{ZLIB_DIR}/lib $ENV{ZLIB_LIBRARY_DEBUG_DIR} /lib /usr/lib /usr/local/lib "C:/Program Files/zlib/lib" ) endif() if(UNIX OR MINGW) if(ZLIB_LIBRARY AND ZLIB_INCLUDE_DIR) set(ZLIB_INCLUDE_DIRS ${ZLIB_INCLUDE_DIR}) set(ZLIB_LIBRARIES ${ZLIB_LIBRARY}) set(ZLIB_FOUND TRUE) else() set(ZLIB_FOUND FALSE) endif() else() set(ZLIB_LIBRARIES "") if(ZLIB_LIBRARY_RELEASE AND ZLIB_INCLUDE_DIR) set(ZLIB_INCLUDE_DIRS ${ZLIB_INCLUDE_DIR}) list(APPEND ZLIB_LIBRARIES optimized) list(APPEND ZLIB_LIBRARIES ${ZLIB_LIBRARY_RELEASE}) set(ZLIB_FOUND TRUE) endif() if(ZLIB_LIBRARY_DEBUG AND ZLIB_INCLUDE_DIR) set(ZLIB_INCLUDE_DIRS ${ZLIB_INCLUDE_DIR}) list(APPEND ZLIB_LIBRARIES debug) list(APPEND ZLIB_LIBRARIES ${ZLIB_LIBRARY_DEBUG}) set(ZLIB_FOUND TRUE) endif() endif() mark_as_advanced( ZLIB_INCLUDE_DIR ZLIB_LIBRARY ZLIB_LIBRARY_RELEASE ZLIB_LIBRARY_DEBUG ) visp-3.0.1/cmake/FindOpenCV2.cmake000066400000000000000000000200341304511007300165640ustar00rootroot00000000000000# - Try to find OpenCV library installation # See http://sourceforge.net/projects/opencvlibrary/ # # The following variables are optionally searched for defaults # OpenCV_ROOT_DIR: Base directory of OpenCv tree to use. # OpenCV_FIND_REQUIRED_COMPONENTS : FIND_PACKAGE(OpenCV COMPONENTS ..) # compatible interface. typically CV CXCORE CVAUX HIGHGUI CVCAM .. etc. # # The following are set after configuration is done: # OpenCV_FOUND # OpenCV_INCLUDE_DIRS # OpenCV_LIBS # OpenCV_LIB_DIR # OpenCV_VERSION_MAJOR # OpenCV_VERSION_MINOR # OpenCV_VERSION_PATCH # # deprecated: # OPENCV_* uppercase replaced by case sensitive OpenCV_* # OPENCV_EXE_LINKER_FLAGS # OPENCV_INCLUDE_DIR : replaced by plural *_DIRS # # 2004/05 Jan Woetzel, Friso, Daniel Grest # 2006/01 complete rewrite by Jan Woetzel # 2006/09 2nd rewrite introducing ROOT_DIR and PATH_SUFFIXES # to handle multiple installed versions gracefully by Jan Woetzel # 2009/04 Fabien Spindler, specific detection of cvcam under Windows # # tested with: # -OpenCV 0.97 (beta5a): MSVS 7.1, gcc 3.3, gcc 4.1 # -OpenCV 0.99 (1.0rc1): MSVS 7.1 # -OpenCV 1.0 # -OpenCV 1.1 # # www.mip.informatik.uni-kiel.de/~jw # -------------------------------- MACRO(DBG_MSG _MSG) #MESSAGE(STATUS "${CMAKE_CURRENT_LIST_FILE}(${CMAKE_CURRENT_LIST_LINE}):\n${_MSG}") ENDMACRO(DBG_MSG) # required cv components with header and library if COMPONENTS unspecified IF (NOT OpenCV_FIND_COMPONENTS) # default SET(OpenCV_FIND_REQUIRED_COMPONENTS CV CXCORE CVAUX HIGHGUI ) # IF (WIN32) # LIST(APPEND OpenCV_FIND_REQUIRED_COMPONENTS CVCAM ) # WIN32 only actually # ENDIF(WIN32) ENDIF (NOT OpenCV_FIND_COMPONENTS) # typical root dirs of installations, exactly one of them is used SET (OpenCV_POSSIBLE_ROOT_DIRS "${OpenCV_ROOT_DIR}" "$ENV{OpenCV_ROOT_DIR}" "$ENV{OPENCV_DIR}" # only for backward compatibility deprecated by ROOT_DIR "$ENV{OPENCV_HOME}" # only for backward compatibility "$ENV{ProgramFiles}/OpenCV" /usr/local /usr ) # # select exactly ONE OpenCV base directory/tree # to avoid mixing different version headers and libs # FIND_PATH(OpenCV_ROOT_DIR NAMES cv/include/cv.h # windows include/opencv/cv.h # linux /opt/net include/cv/cv.h include/cv.h PATHS ${OpenCV_POSSIBLE_ROOT_DIRS}) DBG_MSG("OpenCV_ROOT_DIR=${OpenCV_ROOT_DIR}") # header include dir suffixes appended to OpenCV_ROOT_DIR SET(OpenCV_INCDIR_SUFFIXES include include/cv include/opencv cv/include cxcore/include cvaux/include otherlibs/cvcam/include otherlibs/highgui otherlibs/highgui/include otherlibs/_graphics/include ) # library linkdir suffixes appended to OpenCV_ROOT_DIR SET(OpenCV_LIBDIR_SUFFIXES lib OpenCV/lib otherlibs/_graphics/lib ) #DBG_MSG("OpenCV_LIBDIR_SUFFIXES=${OpenCV_LIBDIR_SUFFIXES}") # # find incdir for each lib # FIND_PATH(OpenCV_CV_INCLUDE_DIR NAMES cv.h PATHS ${OpenCV_ROOT_DIR} PATH_SUFFIXES ${OpenCV_INCDIR_SUFFIXES} ) FIND_PATH(OpenCV_CXCORE_INCLUDE_DIR NAMES cxcore.h PATHS ${OpenCV_ROOT_DIR} PATH_SUFFIXES ${OpenCV_INCDIR_SUFFIXES} ) FIND_PATH(OpenCV_CVAUX_INCLUDE_DIR NAMES cvaux.h PATHS ${OpenCV_ROOT_DIR} PATH_SUFFIXES ${OpenCV_INCDIR_SUFFIXES} ) FIND_PATH(OpenCV_HIGHGUI_INCLUDE_DIR NAMES highgui.h PATHS ${OpenCV_ROOT_DIR} PATH_SUFFIXES ${OpenCV_INCDIR_SUFFIXES} ) FIND_PATH(OpenCV_CVCAM_INCLUDE_DIR NAMES cvcam.h PATHS ${OpenCV_ROOT_DIR} PATH_SUFFIXES ${OpenCV_INCDIR_SUFFIXES} ) # # find sbsolute path to all libraries # some are optionally, some may not exist on Linux # FIND_LIBRARY(OpenCV_CV_LIBRARY NAMES cv opencv PATHS ${OpenCV_ROOT_DIR} PATH_SUFFIXES ${OpenCV_LIBDIR_SUFFIXES} ) FIND_LIBRARY(OpenCV_CVAUX_LIBRARY NAMES cvaux PATHS ${OpenCV_ROOT_DIR} PATH_SUFFIXES ${OpenCV_LIBDIR_SUFFIXES} ) FIND_LIBRARY(OpenCV_CVCAM_LIBRARY NAMES cvcam PATHS ${OpenCV_ROOT_DIR} PATH_SUFFIXES ${OpenCV_LIBDIR_SUFFIXES} ) FIND_LIBRARY(OpenCV_CVHAARTRAINING_LIBRARY NAMES cvhaartraining PATHS ${OpenCV_ROOT_DIR} PATH_SUFFIXES ${OpenCV_LIBDIR_SUFFIXES} ) FIND_LIBRARY(OpenCV_CXCORE_LIBRARY NAMES cxcore PATHS ${OpenCV_ROOT_DIR} PATH_SUFFIXES ${OpenCV_LIBDIR_SUFFIXES} ) FIND_LIBRARY(OpenCV_CXTS_LIBRARY NAMES cxts PATHS ${OpenCV_ROOT_DIR} PATH_SUFFIXES ${OpenCV_LIBDIR_SUFFIXES} ) FIND_LIBRARY(OpenCV_HIGHGUI_LIBRARY NAMES highgui PATHS ${OpenCV_ROOT_DIR} PATH_SUFFIXES ${OpenCV_LIBDIR_SUFFIXES} ) FIND_LIBRARY(OpenCV_ML_LIBRARY NAMES ml PATHS ${OpenCV_ROOT_DIR} PATH_SUFFIXES ${OpenCV_LIBDIR_SUFFIXES} ) FIND_LIBRARY(OpenCV_TRS_LIBRARY NAMES trs PATHS ${OpenCV_ROOT_DIR} PATH_SUFFIXES ${OpenCV_LIBDIR_SUFFIXES} ) # # Logic selecting required libs and headers # SET(OpenCV_FOUND ON) DBG_MSG("OpenCV_FIND_REQUIRED_COMPONENTS=${OpenCV_FIND_REQUIRED_COMPONENTS}") FOREACH(NAME ${OpenCV_FIND_REQUIRED_COMPONENTS} ) # only good if header and library both found IF (OpenCV_${NAME}_INCLUDE_DIR AND OpenCV_${NAME}_LIBRARY) LIST(APPEND OpenCV_INCLUDE_DIRS ${OpenCV_${NAME}_INCLUDE_DIR} ) LIST(APPEND OpenCV_LIBS ${OpenCV_${NAME}_LIBRARY} ) #DBG_MSG("appending for NAME=${NAME} ${OpenCV_${NAME}_INCLUDE_DIR} and ${OpenCV_${NAME}_LIBRARY}" ) ELSE (OpenCV_${NAME}_INCLUDE_DIR AND OpenCV_${NAME}_LIBRARY) DBG_MSG("OpenCV component NAME=${NAME} not found! " "\nOpenCV_${NAME}_INCLUDE_DIR=${OpenCV_${NAME}_INCLUDE_DIR} " "\nOpenCV_${NAME}_LIBRARY=${OpenCV_${NAME}_LIBRARY} ") SET(OpenCV_FOUND OFF) ENDIF (OpenCV_${NAME}_INCLUDE_DIR AND OpenCV_${NAME}_LIBRARY) ENDFOREACH(NAME) DBG_MSG("OpenCV_INCLUDE_DIRS=${OpenCV_INCLUDE_DIRS}") DBG_MSG("OpenCV_LIBS=${OpenCV_LIBS}") # get the link directory for rpath to be used with LINK_DIRECTORIES: IF (OpenCV_CV_LIBRARY) GET_FILENAME_COMPONENT(OpenCV_LIB_DIR ${OpenCV_CV_LIBRARY} PATH) ENDIF (OpenCV_CV_LIBRARY) # Now we try to get the OpenCV version if not set previously if(NOT OpenCV_VERSION_MAJOR AND NOT OpenCV_VERSION_MINOR AND NOT OpenCV_VERSION_PATCH) # default init if not found SET(OpenCV_VERSION_MAJOR "1") SET(OpenCV_VERSION_MINOR "0") SET(OpenCV_VERSION_PATCH "0") # Under UNIX try to use "pkg-config --modversion opencv --silence-errors" # to get OpenCV version FIND_PROGRAM(PKG_CONFIG_CMD pkg-config) MARK_AS_ADVANCED(PKG_CONFIG_CMD) #message("PKG_CONFIG_CMD ${PKG_CONFIG_CMD}") IF(NOT PKG_CONFIG_CMD) MESSAGE(STATUS "Can not find pkg-config in your path") ELSE() EXECUTE_PROCESS(COMMAND "${PKG_CONFIG_CMD}" --modversion opencv --silence-errors OUTPUT_VARIABLE PKG_OPENCV_VERSION OUTPUT_STRIP_TRAILING_WHITESPACE ) ENDIF() if(PKG_OPENCV_VERSION) #message("PKG_OPENCV_VERSION ${PKG_OPENCV_VERSION}") string(SUBSTRING ${PKG_OPENCV_VERSION} 0 1 OpenCV_VERSION_MAJOR) string(SUBSTRING ${PKG_OPENCV_VERSION} 2 1 OpenCV_VERSION_MINOR) string(SUBSTRING ${PKG_OPENCV_VERSION} 4 1 OpenCV_VERSION_PATCH) #message("OpenCV_VERSION_MAJOR ${OpenCV_VERSION_MAJOR}") #message("OpenCV_VERSION_MINOR ${OpenCV_VERSION_MINOR}") #message("OpenCV_VERSION_PATCH ${OpenCV_VERSION_PATCH}") endif() endif() MARK_AS_ADVANCED( OpenCV_ROOT_DIR OpenCV_INCLUDE_DIRS OpenCV_CV_INCLUDE_DIR OpenCV_CXCORE_INCLUDE_DIR OpenCV_CVAUX_INCLUDE_DIR OpenCV_CVCAM_INCLUDE_DIR OpenCV_HIGHGUI_INCLUDE_DIR OpenCV_LIBRARIES OpenCV_LIBS OpenCV_CV_LIBRARY OpenCV_CXCORE_LIBRARY OpenCV_CVAUX_LIBRARY OpenCV_CVCAM_LIBRARY OpenCV_CVHAARTRAINING_LIBRARY OpenCV_CXTS_LIBRARY OpenCV_HIGHGUI_LIBRARY OpenCV_ML_LIBRARY OpenCV_TRS_LIBRARY ) # be backward compatible: SET(OPENCV_LIBRARIES ${OpenCV_LIBS} ) SET(OPENCV_INCLUDE_DIR ${OpenCV_INCLUDE_DIRS} ) SET(OPENCV_FOUND ${OpenCV_FOUND}) # display help message IF(NOT OpenCV_FOUND) # make FIND_PACKAGE friendly IF(NOT OpenCV_FIND_QUIETLY) IF(OpenCV_FIND_REQUIRED) MESSAGE(FATAL_ERROR "OpenCV required but some headers or libs not found. Please specify it's location with OpenCV_ROOT_DIR env. variable.") ELSE(OpenCV_FIND_REQUIRED) MESSAGE(STATUS "OpenCV not found.") ENDIF(OpenCV_FIND_REQUIRED) ENDIF(NOT OpenCV_FIND_QUIETLY) ENDIF(NOT OpenCV_FOUND) visp-3.0.1/cmake/FindPARPORT.cmake000066400000000000000000000030641304511007300165030ustar00rootroot00000000000000############################################################################# # # This file is part of the ViSP software. # Copyright (C) 2005 - 2017 by Inria. All rights reserved. # # This software is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public License # ("GPL") version 2 as published by the Free Software Foundation. # See the file LICENSE.txt at the root directory of this source # distribution for additional information about the GNU GPL. # # For using ViSP with software that can not be combined with the GNU # GPL, please contact Inria about acquiring a ViSP Professional # Edition License. # # See http://visp.inria.fr for more information. # # This software was developed at: # Inria Rennes - Bretagne Atlantique # Campus Universitaire de Beaulieu # 35042 Rennes Cedex # France # # If you have questions regarding the use of this file, please contact # Inria at visp@inria.fr # # This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE # WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. # # Description: # Try to find linux/parport.h.h for parallel port usage. # Once run this will define: # # PARPORT_FOUND # PARPORT_INCLUDE_DIRS # # Authors: # Fabien Spindler # ############################################################################# find_path(PARPORT_INCLUDE_DIRS linux/parport.h /usr/include /usr/src/linux/include ) mark_as_advanced( PARPORT_INCLUDE_DIRS ) if(PARPORT_INCLUDE_DIRS) set(PARPORT_FOUND TRUE) else() set(PARPORT_FOUND FALSE) endif() visp-3.0.1/cmake/FindPTHREAD.cmake000066400000000000000000000060161304511007300164430ustar00rootroot00000000000000############################################################################# # # This file is part of the ViSP software. # Copyright (C) 2005 - 2017 by Inria. All rights reserved. # # This software is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public License # ("GPL") version 2 as published by the Free Software Foundation. # See the file LICENSE.txt at the root directory of this source # distribution for additional information about the GNU GPL. # # For using ViSP with software that can not be combined with the GNU # GPL, please contact Inria about acquiring a ViSP Professional # Edition License. # # See http://visp.inria.fr for more information. # # This software was developed at: # Inria Rennes - Bretagne Atlantique # Campus Universitaire de Beaulieu # 35042 Rennes Cedex # France # # If you have questions regarding the use of this file, please contact # Inria at visp@inria.fr # # This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE # WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. # # Description: # Try to find pthread library. # Once run this will define: # # PTHREAD_FOUND # PTHREAD_INCLUDE_DIRS # PTHREAD_LIBRARIES # # Authors: # Fabien Spindler # ############################################################################# if(MINGW) find_path(PTHREAD_INCLUDE_DIR pthread.h "$ENV{MINGW_DIR}/include" "$ENV{MINGW_DIR}/mingw/include" C:/mingw/mingw/include ) # pthreadVSE pthreadGCE pthreadGC pthreadVC1 pthreadVC2 are comming from web find_library(PTHREAD_LIBRARY NAMES pthread pthreadGC2 pthreadVSE pthreadGCE pthreadGC pthreadVC1 pthreadVC2 PATHS "$ENV{MINGW_DIR}/lib" "$ENV{MINGW_DIR}/mingw/lib" C:/mingw/mingw/lib ) else() find_path(PTHREAD_INCLUDE_DIR pthread.h "$ENV{PTHREAD_HOME}/include" "$ENV{PTHREAD_DIR}/include" /usr/include ) # pthreadVSE pthreadGCE pthreadGC pthreadVC1 pthreadVC2 are comming from web find_library(PTHREAD_LIBRARY NAMES pthread pthreadGC2 pthreadVSE pthreadGCE pthreadGC pthreadVC1 pthreadVC2 PATHS "$ENV{PTHREAD_HOME}/lib" "$ENV{PTHREAD_DIR}/lib" /usr/lib /usr/local/lib /lib ) endif() #MESSAGE("DBG PTHREAD_INCLUDE_DIR=${PTHREAD_INCLUDE_DIR}") #MESSAGE(STATUS "DBG PTHREAD_LIBRARY=${PTHREAD_LIBRARY}") ## -------------------------------- IF(PTHREAD_LIBRARY) SET(PTHREAD_LIBRARIES ${PTHREAD_LIBRARY}) ELSE(PTHREAD_LIBRARY) #MESSAGE(SEND_ERROR "pthread library not found.") ENDIF(PTHREAD_LIBRARY) IF(NOT PTHREAD_INCLUDE_DIR) #MESSAGE(SEND_ERROR "pthread include dir not found.") ENDIF(NOT PTHREAD_INCLUDE_DIR) IF(PTHREAD_LIBRARIES AND PTHREAD_INCLUDE_DIR) SET(PTHREAD_INCLUDE_DIRS ${PTHREAD_INCLUDE_DIR}) SET(PTHREAD_FOUND TRUE) ELSE(PTHREAD_LIBRARIES AND PTHREAD_INCLUDE_DIR) SET(PTHREAD_FOUND FALSE) ENDIF(PTHREAD_LIBRARIES AND PTHREAD_INCLUDE_DIR) MARK_AS_ADVANCED( PTHREAD_INCLUDE_DIR PTHREAD_LIBRARY ) #MESSAGE(STATUS "PTHREAD_FOUND : ${PTHREAD_FOUND}") visp-3.0.1/cmake/FindPTU46.cmake000066400000000000000000000073111304511007300161750ustar00rootroot00000000000000############################################################################# # # This file is part of the ViSP software. # Copyright (C) 2005 - 2017 by Inria. All rights reserved. # # This software is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public License # ("GPL") version 2 as published by the Free Software Foundation. # See the file LICENSE.txt at the root directory of this source # distribution for additional information about the GNU GPL. # # For using ViSP with software that can not be combined with the GNU # GPL, please contact Inria about acquiring a ViSP Professional # Edition License. # # See http://visp.inria.fr for more information. # # This software was developed at: # Inria Rennes - Bretagne Atlantique # Campus Universitaire de Beaulieu # 35042 Rennes Cedex # France # # If you have questions regarding the use of this file, please contact # Inria at visp@inria.fr # # This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE # WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. # # Description: # Try to find libraries for Irisa's Ptu-46 pan-tilt head. # Once run this will define: # # PTU46_FOUND # PTU46_INCLUDE_DIRS # PTU46_LIBRARIES # # Authors: # Fabien Spindler # ############################################################################# IF(NOT UNIX) # MESSAGE("FindPTU46.cmake: Ptu-46 only available for Unix.") SET(PTU46_FOUND FALSE) ELSE(NOT UNIX) FIND_PATH(PTU46_INCLUDE_DIR ptu.h $ENV{PTU46_HOME}/include /udd/fspindle/robot/Ptu-Evi/current/include /local/soft/Ptu-Evi/current/include ) #MESSAGE("DBG PTU46_INCLUDE_DIR=${PTU46_INCLUDE_DIR}") FIND_LIBRARY(PTUPTU46_LIBRARY NAMES ptu PATHS $ENV{PTU46_HOME}/lib /udd/fspindle/robot/Ptu-Evi/current/lib /local/soft/Ptu-Evi/current/lib ) FIND_LIBRARY(EVIPTU46_LIBRARY NAMES evi PATHS $ENV{PTU46_HOME}/lib /udd/fspindle/robot/Ptu-Evi/current/lib /local/soft/Ptu-Evi/current/lib ) FIND_LIBRARY(SERIALPTU46_LIBRARY NAMES serial PATHS $ENV{PTU46_HOME}/lib /udd/fspindle/robot/Ptu-Evi/current/lib /local/soft/Ptu-Evi/current/lib ) #MESSAGE("DBG PTU46_LIBRARY=${PTU46_LIBRARY}") ## -------------------------------- IF(PTUPTU46_LIBRARY AND EVIPTU46_LIBRARY AND SERIALPTU46_LIBRARY) # The material is found. Check if it works on the requested architecture include(CheckCXXSourceCompiles) SET(CMAKE_REQUIRED_LIBRARIES ${PTUPTU46_LIBRARY} ${SERIALPTU46_LIBRARY}) SET(CMAKE_REQUIRED_INCLUDES ${PTU46_INCLUDE_DIR}) CHECK_CXX_SOURCE_COMPILES(" #include // Contrib for Ptu-46 robot int main() { Ptu ptu; return 0; } " PTU46_BUILD_TEST) #MESSAGE("PTU46_BUILD_TEST: ${PTU46_BUILD_TEST}") IF(PTU46_BUILD_TEST) SET(PTU46_LIBRARIES ${PTUPTU46_LIBRARY} ${EVIPTU46_LIBRARY} ${SERIALPTU46_LIBRARY}) # ELSE() # MESSAGE("Ptu-46 library found but not compatible with architecture.") ENDIF() ELSE(PTUPTU46_LIBRARY AND EVIPTU46_LIBRARY AND SERIALPTU46_LIBRARY) # MESSAGE(SEND_ERROR "Ptu-46 library not found.") ENDIF(PTUPTU46_LIBRARY AND EVIPTU46_LIBRARY AND SERIALPTU46_LIBRARY) IF(NOT PTU46_INCLUDE_DIR) # MESSAGE(SEND_ERROR "Ptu-46 include dir not found.") ENDIF(NOT PTU46_INCLUDE_DIR) IF(PTU46_LIBRARIES AND PTU46_INCLUDE_DIR) SET(PTU46_INCLUDE_DIRS ${PTU46_INCLUDE_DIR}) SET(PTU46_FOUND TRUE) ELSE(PTU46_LIBRARIES AND PTU46_INCLUDE_DIR) SET(PTU46_FOUND FALSE) ENDIF(PTU46_LIBRARIES AND PTU46_INCLUDE_DIR) MARK_AS_ADVANCED( PTU46_INCLUDE_DIR PTU46_LIBRARIES PTUPTU46_LIBRARY EVIPTU46_LIBRARY SERIALPTU46_LIBRARY ) ENDIF(NOT UNIX) visp-3.0.1/cmake/FindRAW1394.cmake000066400000000000000000000047341304511007300163330ustar00rootroot00000000000000############################################################################# # # This file is part of the ViSP software. # Copyright (C) 2005 - 2017 by Inria. All rights reserved. # # This software is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public License # ("GPL") version 2 as published by the Free Software Foundation. # See the file LICENSE.txt at the root directory of this source # distribution for additional information about the GNU GPL. # # For using ViSP with software that can not be combined with the GNU # GPL, please contact Inria about acquiring a ViSP Professional # Edition License. # # See http://visp.inria.fr for more information. # # This software was developed at: # Inria Rennes - Bretagne Atlantique # Campus Universitaire de Beaulieu # 35042 Rennes Cedex # France # # If you have questions regarding the use of this file, please contact # Inria at visp@inria.fr # # This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE # WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. # # Description: # Try to find libraw1394 for IEEE1394 camera under Linux. # Once run this will define: # # RAW1394_FOUND # RAW1394_INCLUDE_DIRS # RAW1394_LIBRARIES # # Authors: # Fabien Spindler # ############################################################################# IF(NOT UNIX) # MESSAGE("FindRAW1394.cmake: libraw1394 only available for Unix.") SET(RAW1394_FOUND FALSE) ELSE(NOT UNIX) FIND_PATH(RAW1394_INCLUDE_DIR libraw1394/raw1394.h $ENV{RAW1394_HOME}/include /usr/include ) #MESSAGE("DBG RAW1394_INCLUDE_DIR=${RAW1394_INCLUDE_DIR}") FIND_LIBRARY(RAW1394_LIBRARY NAMES raw1394 PATHS $ENV{RAW1394_HOME}/lib /usr/lib ) #MESSAGE("DBG RAW1394_LIBRARY=${RAW1394_LIBRARY}") ## -------------------------------- IF(RAW1394_LIBRARY) SET(RAW1394_LIBRARIES ${RAW1394_LIBRARY}) ELSE(RAW1394_LIBRARY) #MESSAGE("libraw1394 library not found.") ENDIF(RAW1394_LIBRARY) IF(NOT RAW1394_INCLUDE_DIR) #MESSAGE("libraw1394 include dir not found.") ENDIF(NOT RAW1394_INCLUDE_DIR) IF(RAW1394_LIBRARIES AND RAW1394_INCLUDE_DIR) SET(RAW1394_INCLUDE_DIRS ${RAW1394_INCLUDE_DIR}) SET(RAW1394_FOUND TRUE) ELSE(RAW1394_LIBRARIES AND RAW1394_INCLUDE_DIR) SET(RAW1394_FOUND FALSE) ENDIF(RAW1394_LIBRARIES AND RAW1394_INCLUDE_DIR) MARK_AS_ADVANCED( RAW1394_INCLUDE_DIR RAW1394_LIBRARIES RAW1394_LIBRARY ) ENDIF(NOT UNIX) visp-3.0.1/cmake/FindRT.cmake000066400000000000000000000035021304511007300156760ustar00rootroot00000000000000############################################################################# # # This file is part of the ViSP software. # Copyright (C) 2005 - 2017 by Inria. All rights reserved. # # This software is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public License # ("GPL") version 2 as published by the Free Software Foundation. # See the file LICENSE.txt at the root directory of this source # distribution for additional information about the GNU GPL. # # For using ViSP with software that can not be combined with the GNU # GPL, please contact Inria about acquiring a ViSP Professional # Edition License. # # See http://visp.inria.fr for more information. # # This software was developed at: # Inria Rennes - Bretagne Atlantique # Campus Universitaire de Beaulieu # 35042 Rennes Cedex # France # # If you have questions regarding the use of this file, please contact # Inria at visp@inria.fr # # This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE # WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. # # Description: # Try to find RT library material # # RT_FOUND # RT_LIBRARIES # # Authors: # Fabien Spindler # ############################################################################# IF(NOT UNIX) # MESSAGE("FindRT.cmake: only available for Unix.") SET(RT_FOUND FALSE) ELSE(NOT UNIX) FIND_LIBRARY(RT_LIBRARY NAMES rt PATHS $ENV{RT_HOME}/lib /usr/lib /usr/local/lib ) #MESSAGE("DBG RT_LIBRARY=${RT_LIBRARY}") ## -------------------------------- IF(RT_LIBRARY) SET(RT_LIBRARIES ${RT_LIBRARY}) SET(RT_FOUND TRUE) ELSE(RT_LIBRARY) SET(RT_FOUND FALSE) #MESSAGE(SEND_ERROR "rt library not found.") ENDIF(RT_LIBRARY) MARK_AS_ADVANCED( RT_LIBRARIES RT_LIBRARY ) ENDIF(NOT UNIX) visp-3.0.1/cmake/FindRealSense.cmake000066400000000000000000000074551304511007300172450ustar00rootroot00000000000000############################################################################# # # This file is part of the ViSP software. # Copyright (C) 2005 - 2017 by Inria. All rights reserved. # # This software is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public License # ("GPL") version 2 as published by the Free Software Foundation. # See the file LICENSE.txt at the root directory of this source # distribution for additional information about the GNU GPL. # # For using ViSP with software that can not be combined with the GNU # GPL, please contact Inria about acquiring a ViSP Professional # Edition License. # # See http://visp.inria.fr for more information. # # This software was developed at: # Inria Rennes - Bretagne Atlantique # Campus Universitaire de Beaulieu # 35042 Rennes Cedex # France # # If you have questions regarding the use of this file, please contact # Inria at visp@inria.fr # # This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE # WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. # # Description: # Try to find Intel RealSense SDK to work with R200, F200 and SR300 devices. # Once run this will define: # # REALSENSE_FOUND # REALSENSE_INCLUDE_DIRS # REALSENSE_LIBRARIES # REALSENSE_VERSION # # Authors: # Fabien Spindler # ############################################################################# set(REALSENSE_INC_SEARCH_PATH /usr/local/include) set(REALSENSE_LIB_SEARCH_PATH /usr/local/lib) if(MSVC) list(APPEND REALSENSE_INC_SEARCH_PATH "C:/librealsense/include") list(APPEND REALSENSE_INC_SEARCH_PATH $ENV{REALSENSE_HOME}/include) if(CMAKE_CL_64) list(APPEND REALSENSE_LIB_SEARCH_PATH "C:/librealsense/bin/x64") list(APPEND REALSENSE_LIB_SEARCH_PATH $ENV{REALSENSE_HOME}/bin/x64) else() list(APPEND REALSENSE_LIB_SEARCH_PATH "C:/librealsense/bin/Win32") list(APPEND REALSENSE_LIB_SEARCH_PATH $ENV{REALSENSE_HOME}/bin/Win32) endif() else() list(APPEND REALSENSE_INC_SEARCH_PATH /usr/include) list(APPEND REALSENSE_LIB_SEARCH_PATH /usr/lib) list(APPEND REALSENSE_INC_SEARCH_PATH $ENV{REALSENSE_HOME}/include) list(APPEND REALSENSE_LIB_SEARCH_PATH $ENV{REALSENSE_HOME}/lib) endif() find_path(REALSENSE_INCLUDE_DIRS librealsense/rs.hpp PATHS ${REALSENSE_INC_SEARCH_PATH} ) if(MSVC) find_library(REALSENSE_LIBRARIES_OPT NAMES realsense PATHS ${REALSENSE_LIB_SEARCH_PATH} ) find_library(REALSENSE_LIBRARIES_DBG NAMES realsense-d PATHS ${REALSENSE_LIB_SEARCH_PATH} ) if(REALSENSE_LIBRARIES_OPT) set(REALSENSE_LIBRARIES optimized ${REALSENSE_LIBRARIES_OPT}) endif() if(REALSENSE_LIBRARIES_DBG) list(APPEND REALSENSE_LIBRARIES debug ${REALSENSE_LIBRARIES_DBG}) endif() mark_as_advanced(REALSENSE_LIBRARIES_OPT REALSENSE_LIBRARIES_DBG) else() find_library(REALSENSE_LIBRARIES NAMES realsense PATHS ${REALSENSE_LIB_SEARCH_PATH} ) endif() if(REALSENSE_LIBRARIES AND REALSENSE_INCLUDE_DIRS) set(REALSENSE_FOUND TRUE) vp_parse_header("${REALSENSE_INCLUDE_DIRS}/librealsense/rs.h" REALSENSE_VERSION_LINES RS_API_MAJOR_VERSION RS_API_MINOR_VERSION RS_API_PATCH_VERSION) if(RS_API_MAJOR_VERSION) set(REALSENSE_VERSION "${RS_API_MAJOR_VERSION}.${RS_API_MINOR_VERSION}.${RS_API_PATCH_VERSION}") else() # This is an old version vp_parse_header("${REALSENSE_INCLUDE_DIRS}/librealsense/rs.h" REALSENSE_VERSION_LINES RS_API_VERSION) set(REALSENSE_VERSION "${RS_API_VERSION}") message(WARNING "The librealsense 3rd party is detected but this version is too old to build with ViSP. You should install a more recent version.") set(REALSENSE_FOUND FALSE) endif() else() set(REALSENSE_FOUND FALSE) endif() mark_as_advanced( REALSENSE_INCLUDE_DIRS REALSENSE_LIBRARIES REALSENSE_INC_SEARCH_PATH REALSENSE_LIB_SEARCH_PATH ) visp-3.0.1/cmake/FindRound.cmake000066400000000000000000000037421304511007300164460ustar00rootroot00000000000000############################################################################# # # This file is part of the ViSP software. # Copyright (C) 2005 - 2017 by Inria. All rights reserved. # # This software is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public License # ("GPL") version 2 as published by the Free Software Foundation. # See the file LICENSE.txt at the root directory of this source # distribution for additional information about the GNU GPL. # # For using ViSP with software that can not be combined with the GNU # GPL, please contact Inria about acquiring a ViSP Professional # Edition License. # # See http://visp.inria.fr for more information. # # This software was developed at: # Inria Rennes - Bretagne Atlantique # Campus Universitaire de Beaulieu # 35042 Rennes Cedex # France # # If you have questions regarding the use of this file, please contact # Inria at visp@inria.fr # # This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE # WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. # # Description: # Try to find round function. # # Authors: # Souriya Trinh # ############################################################################# include(CheckIncludeFile) include(CheckIncludeFiles) include(CheckCXXSourceCompiles) macro(check_math_expr1 _expr _var) unset(${_var} CACHE) if(USE_CPP11) set(CMAKE_REQUIRED_FLAGS ${CPP11_CXX_FLAGS}) endif() check_cxx_source_compiles(" #include int main(int argc, char ** argv) { (void)${_expr}; return 0; } " ${_var}) endmacro() macro(check_math_expr2 _expr _var) unset(${_var} CACHE) if(USE_CPP11) set(CMAKE_REQUIRED_FLAGS ${CPP11_CXX_FLAGS}) endif() check_cxx_source_compiles(" #include int main(int argc, char ** argv) { (void)${_expr}; return 0; } " ${_var}) endmacro() check_math_expr1("round(5.5)" HAVE_FUNC_ROUND) check_math_expr2("std::round(5.5)" HAVE_FUNC_STD_ROUND) visp-3.0.1/cmake/FindSOQT.cmake000066400000000000000000000064331304511007300161450ustar00rootroot00000000000000############################################################################# # # This file is part of the ViSP software. # Copyright (C) 2005 - 2017 by Inria. All rights reserved. # # This software is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public License # ("GPL") version 2 as published by the Free Software Foundation. # See the file LICENSE.txt at the root directory of this source # distribution for additional information about the GNU GPL. # # For using ViSP with software that can not be combined with the GNU # GPL, please contact Inria about acquiring a ViSP Professional # Edition License. # # See http://visp.inria.fr for more information. # # This software was developed at: # Inria Rennes - Bretagne Atlantique # Campus Universitaire de Beaulieu # 35042 Rennes Cedex # France # # If you have questions regarding the use of this file, please contact # Inria at visp@inria.fr # # This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE # WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. # # Description: # Try to find SoQt library. # Once run this will define: # # SOQT_FOUND # SOQT_INCLUDE_DIRS # SOQT_LIBRARIES # # Authors: # Fabien Spindler # ############################################################################# set(SOQT_FOUND FALSE) # detection of the SoQt headers location find_path(SOQT_INCLUDE_DIR Inventor/Qt/SoQt.h "$ENV{COIN_DIR}/include" "$ENV{SOQT_DIR}/include" "$ENV{COIN_DIR}" "$ENV{SOQT_DIR}" "$ENV{COINDIR}/include" "$ENV{SOQTDIR}/include" /usr/include/Coin2 /usr/include/Coin3 /Library/Frameworks/SoQt.framework/Headers ) #message("DBG SOQT_INCLUDE_DIR=${SOQT_INCLUDE_DIR}") if(WIN32) # Detection of the SoQt library on Windows find_library(SOQT_LIBRARY_RELEASE NAMES soqt1 #only shared libraries under windows PATHS "$ENV{COIN_DIR}/lib" "$ENV{SOQT_DIR}/lib" "$ENV{COINDIR}/lib" "$ENV{SOQTDIR}/lib" ) find_library(SOQT_LIBRARY_DEBUG NAMES soqt1d #only shared libraries under windows PATHS "$ENV{COIN_DIR}/lib" "$ENV{SOQT_DIR}/lib" "$ENV{COINDIR}/lib" "$ENV{SOQTDIR}/lib" ) if(SOQT_INCLUDE_DIR AND SOQT_LIBRARY_RELEASE) set(SOQT_INCLUDE_DIRS ${SOQT_INCLUDE_DIR}) list(APPEND SOQT_LIBRARIES optimized ${SOQT_LIBRARY_RELEASE}) set(SOQT_FOUND TRUE) endif() if(SOQT_INCLUDE_DIR AND SOQT_LIBRARY_DEBUG) set(SOQT_INCLUDE_DIRS ${SOQT_INCLUDE_DIR}) list(APPEND SOQT_LIBRARIES debug ${SOQT_LIBRARY_DEBUG}) set(SOQT_FOUND TRUE) endif() mark_as_advanced( SOQT_LIBRARIES SOQT_LIBRARY_DEBUG SOQT_LIBRARY_RELEASE SOQT_INCLUDE_DIR ) else(WIN32) # Detection of the SoQt library on Unix find_library(SOQT_LIBRARY NAMES SoQt PATHS "$ENV{COIN_DIR}/lib" "$ENV{SOQT_DIR}/lib" "$ENV{COINDIR}/lib" "$ENV{SOQTDIR}/lib" /usr/lib /usr/local/lib /lib /Library/Frameworks/SoQt.framework/Libraries ) if(SOQT_INCLUDE_DIR AND SOQT_LIBRARY) set(SOQT_INCLUDE_DIRS ${SOQT_INCLUDE_DIR}) set(SOQT_LIBRARIES ${SOQT_LIBRARY}) set(SOQT_FOUND TRUE) endif() mark_as_advanced( SOQT_LIBRARIES SOQT_LIBRARY SOQT_INCLUDE_DIR ) #message(STATUS "DBG SOQT_LIBRARY=${SOQT_LIBRARY}") endif(WIN32) #MESSAGE(STATUS "SOQT_FOUND : ${SOQT_FOUND}") visp-3.0.1/cmake/FindSOWIN.cmake000066400000000000000000000046611304511007300162570ustar00rootroot00000000000000############################################################################# # # This file is part of the ViSP software. # Copyright (C) 2005 - 2017 by Inria. All rights reserved. # # This software is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public License # ("GPL") version 2 as published by the Free Software Foundation. # See the file LICENSE.txt at the root directory of this source # distribution for additional information about the GNU GPL. # # For using ViSP with software that can not be combined with the GNU # GPL, please contact Inria about acquiring a ViSP Professional # Edition License. # # See http://visp.inria.fr for more information. # # This software was developed at: # Inria Rennes - Bretagne Atlantique # Campus Universitaire de Beaulieu # 35042 Rennes Cedex # France # # If you have questions regarding the use of this file, please contact # Inria at visp@inria.fr # # This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE # WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. # # Description: # Try to find SoQt library. # Once run this will define: # # SOWIN_FOUND # SOWIN_INCLUDE_DIRS # SOWIN_LIBRARIES # SOWIN_LIBRARY_RELEASE # SOWIN_LIBRARY_DEBUG # # Authors: # Fabien Spindler # Anthony Saunier # ############################################################################# set(SOWIN_FOUND FALSE) if(WIN32) FIND_LIBRARY(SOWIN_LIBRARY_RELEASE NAMES sowin1 #only shared libraries under windows PATHS "$ENV{COINDIR}/lib" "$ENV{COIN_DIR}/lib" "$ENV{SOWIN_DIR}/lib" ) FIND_LIBRARY(SOWIN_LIBRARY_DEBUG NAMES sowin1d #only shared libraries under windows PATHS "$ENV{COINDIR}/lib" "$ENV{COIN_DIR}/lib" "$ENV{SOWIN_DIR}/lib" ) FIND_PATH(SOWIN_INCLUDE_DIR Inventor/Win/SoWin.h "$ENV{COINDIR}/include" "$ENV{COIN_DIR}/include" "$ENV{SOWIN_DIR}/include" ) ## -------------------------------- set(SOWIN_LIBRARIES "") if(SOWIN_LIBRARY_DEBUG) list(APPEND SOWIN_LIBRARIES debug ${SOWIN_LIBRARY_DEBUG}) endif() if(SOWIN_LIBRARY_RELEASE) list(APPEND SOWIN_LIBRARIES optimized ${SOWIN_LIBRARY_RELEASE}) endif() IF(SOWIN_LIBRARIES AND SOWIN_INCLUDE_DIR) set(SOWIN_INCLUDE_DIRS ${SOWIN_INCLUDE_DIR}) set(SOWIN_FOUND TRUE) else() set(SOWIN_FOUND FALSE) endif() endif(WIN32) MARK_AS_ADVANCED( SOWIN_LIBRARY_DEBUG SOWIN_LIBRARY_RELEASE SOWIN_INCLUDE_DIR ) visp-3.0.1/cmake/FindSOXT.cmake000066400000000000000000000036331304511007300161530ustar00rootroot00000000000000############################################################################# # # This file is part of the ViSP software. # Copyright (C) 2005 - 2017 by Inria. All rights reserved. # # This software is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public License # ("GPL") version 2 as published by the Free Software Foundation. # See the file LICENSE.txt at the root directory of this source # distribution for additional information about the GNU GPL. # # For using ViSP with software that can not be combined with the GNU # GPL, please contact Inria about acquiring a ViSP Professional # Edition License. # # See http://visp.inria.fr for more information. # # This software was developed at: # Inria Rennes - Bretagne Atlantique # Campus Universitaire de Beaulieu # 35042 Rennes Cedex # France # # If you have questions regarding the use of this file, please contact # Inria at visp@inria.fr # # This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE # WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. # # Description: # Try to find SoXt library. # Once run this will define: # # SOXT_FOUND # SOXT_LIBRARIES # # Authors: # Fabien Spindler # ############################################################################# IF(UNIX) FIND_LIBRARY(SOXT_LIBRARY NAMES SoXt PATHS /usr/lib /usr/local/lib /lib "$ENV{COIN_DIR}/lib" "$ENV{COINDIR}/lib" ) MARK_AS_ADVANCED( SOXT_LIBRARY ) #MESSAGE(STATUS "DBG SOXT_LIBRARY=${SOXT_LIBRARY}") ## -------------------------------- IF(SOXT_LIBRARY) SET(SOXT_LIBRARIES ${SOXT_LIBRARY}) SET(SOXT_FOUND TRUE) MARK_AS_ADVANCED( SOXT_LIBRARIES ) ELSE(SOXT_LIBRARY) SET(SOXT_FOUND FALSE) #MESSAGE("SoXt library not found.") ENDIF(SOXT_LIBRARY) #MESSAGE(STATUS "SOXT_FOUND : ${SOXT_FOUND}") ELSE(UNIX) SET(SOXT_FOUND FALSE) ENDIF(UNIX) visp-3.0.1/cmake/FindStrtof.cmake000066400000000000000000000027761304511007300166460ustar00rootroot00000000000000############################################################################# # # This file is part of the ViSP software. # Copyright (C) 2005 - 2017 by Inria. All rights reserved. # # This software is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public License # ("GPL") version 2 as published by the Free Software Foundation. # See the file LICENSE.txt at the root directory of this source # distribution for additional information about the GNU GPL. # # For using ViSP with software that can not be combined with the GNU # GPL, please contact Inria about acquiring a ViSP Professional # Edition License. # # See http://visp.inria.fr for more information. # # This software was developed at: # Inria Rennes - Bretagne Atlantique # Campus Universitaire de Beaulieu # 35042 Rennes Cedex # France # # If you have questions regarding the use of this file, please contact # Inria at visp@inria.fr # # This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE # WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. # # Description: # Try to find erfc function. # # Authors: # Souriya Trinh # ############################################################################# include(CheckCXXSourceCompiles) macro(check_expr _expr _var) check_cxx_source_compiles(" #include int main(int argc, char ** argv) { (void)${_expr}; return 0; } " ${_var}) endmacro() check_expr("strtof(\" -0.0000000123junk\", NULL)" HAVE_FUNC_STRTOF) visp-3.0.1/cmake/FindV4L2.cmake000066400000000000000000000056541304511007300160520ustar00rootroot00000000000000############################################################################# # # This file is part of the ViSP software. # Copyright (C) 2005 - 2017 by Inria. All rights reserved. # # This software is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public License # ("GPL") version 2 as published by the Free Software Foundation. # See the file LICENSE.txt at the root directory of this source # distribution for additional information about the GNU GPL. # # For using ViSP with software that can not be combined with the GNU # GPL, please contact Inria about acquiring a ViSP Professional # Edition License. # # See http://visp.inria.fr for more information. # # This software was developed at: # Inria Rennes - Bretagne Atlantique # Campus Universitaire de Beaulieu # 35042 Rennes Cedex # France # # If you have questions regarding the use of this file, please contact # Inria at visp@inria.fr # # This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE # WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. # # Description: # Try to find linux/videodev.h for Video For Linux Two framegrabbing # capabilities. # Once run this will define: # # V4L2_FOUND # V4L2_INCLUDE_DIRS # V4L2_LIBRARIES # V4L2_VERSION # # Authors: # Fabien Spindler # ############################################################################# if(NOT UNIX) # MESSAGE("FindV4L2.cmake: only available for Unix.") set(V4L2_FOUND FALSE) else(NOT UNIX) find_path(V4L2_INCLUDE_VIDEODEV2 linux/videodev2.h $ENV{V4L2_HOME}/include $ENV{V4L2_DIR}/include /usr/include /usr/local/include /usr/src/linux/include ) #MESSAGE("DBG V4L2_INCLUDE_VIDEODEV2=${V4L2_INCLUDE_VIDEODEV2}") find_path(V4L2_INCLUDE_LIBV4L2 libv4l2.h $ENV{V4L2_HOME}/include $ENV{V4L2_DIR}/include /usr/include /usr/local/include ) #MESSAGE("DBG V4L2_INCLUDE_LIBV4L2=${V4L2_INCLUDE_LIBV4L2}") find_library(V4L2_LIBRARY_LIBV4L2 NAMES v4l2 PATHS $ENV{V4L2_HOME}/lib $ENV{V4L2_DIR}/lib /usr/lib /usr/local/lib ) find_library(V4L2_LIBRARY_LIBV4LCONVERT NAMES v4lconvert PATHS $ENV{V4L2_HOME}/lib $ENV{V4L2_DIR}/lib /usr/lib /usr/local/lib ) ## -------------------------------- if(V4L2_INCLUDE_VIDEODEV2 AND V4L2_INCLUDE_LIBV4L2 AND V4L2_LIBRARY_LIBV4L2 AND V4L2_LIBRARY_LIBV4LCONVERT) set(V4L2_INCLUDE_DIRS ${V4L2_INCLUDE_VIDEODEV2} ${V4L2_INCLUDE_LIBV4L2}) set(V4L2_LIBRARIES ${V4L2_LIBRARY_LIBV4L2} ${V4L2_LIBRARY_LIBV4LCONVERT}) set(V4L2_FOUND TRUE) get_filename_component(V4L2_LIB_DIR ${V4L2_LIBRARY_LIBV4L2} PATH) vp_get_version_from_pkg("libv4l2" "${V4L2_LIB_DIR}/pkgconfig" V4L2_VERSION) else() set(V4L2_FOUND FALSE) endif() mark_as_advanced( V4L2_INCLUDE_DIRS V4L2_INCLUDE_VIDEODEV2 V4L2_INCLUDE_LIBV4L2 V4L2_LIBRARY_LIBV4L2 V4L2_LIBRARY_LIBV4LCONVERT ) endif() visp-3.0.1/cmake/FindViper650_data.cmake000066400000000000000000000034441304511007300176670ustar00rootroot00000000000000############################################################################# # # This file is part of the ViSP software. # Copyright (C) 2005 - 2017 by Inria. All rights reserved. # # This software is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public License # ("GPL") version 2 as published by the Free Software Foundation. # See the file LICENSE.txt at the root directory of this source # distribution for additional information about the GNU GPL. # # For using ViSP with software that can not be combined with the GNU # GPL, please contact Inria about acquiring a ViSP Professional # Edition License. # # See http://visp.inria.fr for more information. # # This software was developed at: # Inria Rennes - Bretagne Atlantique # Campus Universitaire de Beaulieu # 35042 Rennes Cedex # France # # If you have questions regarding the use of this file, please contact # Inria at visp@inria.fr # # This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE # WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. # # Description: # Try to determine if calibration data (camera intrinsic/extrinsic, FT calib file) # are available for Inria's Viper 650 robot. # # VIPER650_DATA_FOUND # VIPER650_DATA_PATH # # Authors: # Fabien Spindler # ############################################################################# find_path(VIPER650_DATA_PATH NAMES include/const_camera_Viper650.xml PATHS /home/soft/Viper650/Viper650 /home/soft/Viper650/current /udd/fspindle/robot/Viper650/current Z:/robot/Viper650/current ) #message("DBG VIPER650_DATA_PATH=${VIPER650_DATA_PATH}") if(VIPER650_DATA_PATH) set(VIPER650_DATA_FOUND TRUE) else() SET(VIPER650_FATA_FOUND FALSE) endif() mark_as_advanced( VIPER650_DATA_PATH ) visp-3.0.1/cmake/FindViper850_data.cmake000066400000000000000000000034431304511007300176700ustar00rootroot00000000000000############################################################################# # # This file is part of the ViSP software. # Copyright (C) 2005 - 2017 by Inria. All rights reserved. # # This software is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public License # ("GPL") version 2 as published by the Free Software Foundation. # See the file LICENSE.txt at the root directory of this source # distribution for additional information about the GNU GPL. # # For using ViSP with software that can not be combined with the GNU # GPL, please contact Inria about acquiring a ViSP Professional # Edition License. # # See http://visp.inria.fr for more information. # # This software was developed at: # Inria Rennes - Bretagne Atlantique # Campus Universitaire de Beaulieu # 35042 Rennes Cedex # France # # If you have questions regarding the use of this file, please contact # Inria at visp@inria.fr # # This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE # WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. # # Description: # Try to determine if calibration data (camera intrinsic/extrinsic, FT calib file) # are available for Inria's Viper 850 robot. # # VIPER850_DATA_FOUND # VIPER850_DATA_PATH # # Authors: # Fabien Spindler # ############################################################################# find_path(VIPER850_DATA_PATH NAMES include/const_camera_Viper850.xml PATHS /home/soft/Viper850/Viper850 /home/soft/Viper850/current /udd/fspindle/robot/Viper850/current Z:/robot/Viper850/current ) #message("DBG VIPER850_DATA_PATH=${VIPER850_DATA_PATH}") if(VIPER850_DATA_PATH) set(VIPER850_DATA_FOUND TRUE) else() SET(VIPER850_FATA_FOUND FALSE) endif() mark_as_advanced( VIPER850_DATA_PATH ) visp-3.0.1/cmake/FindVirtuose.cmake000066400000000000000000000104031304511007300171670ustar00rootroot00000000000000############################################################################# # # This file is part of the ViSP software. # Copyright (C) 2005 - 2017 by Inria. All rights reserved. # # This software is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public License # ("GPL") version 2 as published by the Free Software Foundation. # See the file LICENSE.txt at the root directory of this source # distribution for additional information about the GNU GPL. # # For using ViSP with software that can not be combined with the GNU # GPL, please contact Inria about acquiring a ViSP Professional # Edition License. # # See http://visp.inria.fr for more information. # # This software was developed at: # Inria Rennes - Bretagne Atlantique # Campus Universitaire de Beaulieu # 35042 Rennes Cedex # France # # If you have questions regarding the use of this file, please contact # Inria at visp@inria.fr # # This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE # WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. # # Description: # Try to find Virtuose library API to dial with the robot Haption Virtuose # # VIRTUOSE_FOUND # VIRTUOSE_INCLUDE_DIRS # VIRTUOSE_LIBRARIES # # Authors: # Fabien Spindler # ############################################################################# set(VIRTUOSE_API $ENV{VIRTUOSE_HOME}) if(UNIX) list(APPEND VIRTUOSE_API /home/soft/virtuose/Livraison_3_90/VirtuoseAPI_v3_93) list(APPEND VIRTUOSE_API /local/virtuose-6D/Livraison_3_90/VirtuoseAPI_v3_93) set(VIRTUOSE_OS "linux") if(CMAKE_SIZEOF_VOID_P EQUAL 8) list(APPEND VIRTUOSE_ARCH "x64") else() list(APPEND VIRTUOSE_ARCH "x86") endif() elseif(MSVC) list(APPEND VIRTUOSE_API "C:/VirtuoseAPI_v3_93") set(VIRTUOSE_OS win) if(CMAKE_CL_64) list(APPEND VIRTUOSE_ARCH "x64") else() list(APPEND VIRTUOSE_ARCH "Win32") endif() if(MSVC_VERSION EQUAL 1400) set(VIRTUOSE_MSVC_RUNTIME VC2005) elseif(MSVC_VERSION EQUAL 1500) set(VIRTUOSE_MSVC_RUNTIME VC2008) elseif(MSVC_VERSION EQUAL 1600) set(VIRTUOSE_MSVC_RUNTIME VC2010) elseif(MSVC_VERSION EQUAL 1700) set(VIRTUOSE_MSVC_RUNTIME VC2012) elseif(MSVC_VERSION EQUAL 1800) set(VIRTUOSE_MSVC_RUNTIME VC2013) elseif(MSVC_VERSION EQUAL 1900) set(VIRTUOSE_MSVC_RUNTIME VC2015) endif() else() return() endif() set(VIRTUOSE_API_INC "") set(VIRTUOSE_API_LIB "") if(UNIX) foreach(api_ ${VIRTUOSE_API}) list(APPEND VIRTUOSE_API_INC "${api_}") list(APPEND VIRTUOSE_API_LIB "${api_}/${VIRTUOSE_OS}/lib/${VIRTUOSE_ARCH}") endforeach() elseif(MSVC) foreach(api_ ${VIRTUOSE_API}) list(APPEND VIRTUOSE_API_INC "${api_}") list(APPEND VIRTUOSE_API_LIB "${api_}/${VIRTUOSE_OS}/lib/${VIRTUOSE_MSVC_RUNTIME}/${VIRTUOSE_ARCH}") endforeach() endif() find_path(VIRTUOSE_INCLUDE_DIRS VirtuoseAPI.h PATHS ${VIRTUOSE_API_INC} ) if(UNIX) find_library(VIRTUOSE_LIBRARIES NAMES virtuose PATHS ${VIRTUOSE_API_LIB} ) elseif(MSVC) set(VIRTUOSE_API_LIB_DEBUG "") set(VIRTUOSE_API_LIB_RELEASE "") foreach(api_ ${VIRTUOSE_API}) list(APPEND VIRTUOSE_API_LIB_DEBUG "${api_}/${VIRTUOSE_OS}/lib/${VIRTUOSE_MSVC_RUNTIME}/${VIRTUOSE_ARCH}/DebugMD") list(APPEND VIRTUOSE_API_LIB_RELEASE "${api_}/${VIRTUOSE_OS}/lib/${VIRTUOSE_MSVC_RUNTIME}/${VIRTUOSE_ARCH}/ReleaseMD") endforeach() find_library(VIRTUOSE_LIBRARIES_DEBUG NAMES virtuoseDLL PATHS ${VIRTUOSE_API_LIB_DEBUG} ) find_library(VIRTUOSE_LIBRARIES_RELEASE NAMES virtuoseDLL PATHS ${VIRTUOSE_API_LIB_RELEASE} ) if(VIRTUOSE_LIBRARIES_DEBUG AND VIRTUOSE_LIBRARIES_RELEASE) set(VIRTUOSE_LIBRARIES debug ${VIRTUOSE_LIBRARIES_DEBUG} optimized ${VIRTUOSE_LIBRARIES_RELEASE}) elseif(VIRTUOSE_LIBRARIES_DEBUG) set(VIRTUOSE_LIBRARIES ${VIRTUOSE_LIBRARIES_DEBUG}) elseif(VIRTUOSE_LIBRARIES_RELEASE) set(VIRTUOSE_LIBRARIES ${VIRTUOSE_LIBRARIES_RELEASE}) endif() endif() if(VIRTUOSE_LIBRARIES AND VIRTUOSE_INCLUDE_DIRS) set(VIRTUOSE_FOUND TRUE) else() set(VIRTUOSE_FOUND FALSE) endif() mark_as_advanced( VIRTUOSE_INCLUDE_DIRS VIRTUOSE_LIBRARIES VIRTUOSE_LIBRARIES_DEBUG VIRTUOSE_LIBRARIES_RELEASE VIRTUOSE_INC_SEARCH_PATH VIRTUOSE_LIB_SEARCH_PATH ) visp-3.0.1/cmake/FindXML2.cmake000066400000000000000000000056251304511007300161030ustar00rootroot00000000000000############################################################################# # # This file is part of the ViSP software. # Copyright (C) 2005 - 2017 by Inria. All rights reserved. # # This software is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public License # ("GPL") version 2 as published by the Free Software Foundation. # See the file LICENSE.txt at the root directory of this source # distribution for additional information about the GNU GPL. # # For using ViSP with software that can not be combined with the GNU # GPL, please contact Inria about acquiring a ViSP Professional # Edition License. # # See http://visp.inria.fr for more information. # # This software was developed at: # Inria Rennes - Bretagne Atlantique # Campus Universitaire de Beaulieu # 35042 Rennes Cedex # France # # If you have questions regarding the use of this file, please contact # Inria at visp@inria.fr # # This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE # WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. # # Description: # Try to find XML library. # Once run this will define: # # XML2_FOUND # XML2_INCLUDE_DIRS # XML2_LIBRARIES # XML2_VERSION_STRING # # Authors: # Fabien Spindler # ############################################################################# if(WIN32) find_package(ICONV) if(MINGW) find_path(XML2_INCLUDE_DIR libxml/xmlmemory.h "$ENV{MINGW_DIR}/include/libxml2" C:/mingw/include/libxml2 ) find_library(XML2_LIBRARY libxml2 "$ENV{MINGW_DIR}/lib" "$ENV{MINGW_DIR}/lib64" C:/mingw/lib64 ) else() find_path(XML2_INCLUDE_DIR libxml/xmlmemory.h "$ENV{XML2_DIR}/include" "$ENV{XML2_DIR}/include/libxml2" "$ENV{XML2_HOME}/include" "$ENV{XML2_HOME}/include/libxml2" ) find_library(XML2_LIBRARY libxml2 "$ENV{XML2_DIR}/lib" "$ENV{XML2_HOME}/lib" /usr/lib /usr/local/lib "c:/libxml2/lib" ) endif() else(WIN32) find_path(XML2_INCLUDE_DIR libxml/xmlmemory.h "$ENV{XML2_DIR}/include/libxml2" "$ENV{XML2_HOME}/include/libxml2" /usr/include/libxml2 /usr/local/include/libxml2 /usr/local/opt/libxml2/include/libxml2 ) find_library(XML2_LIBRARY xml2 "$ENV{XML2_DIR}/lib" "$ENV{XML2_HOME}/lib" /usr/lib /usr/local/lib /usr/local/opt/libxml2/lib ) endif(WIN32) if(XML2_LIBRARY) set(XML2_LIBRARIES ${XML2_LIBRARY}) endif() if(XML2_LIBRARIES AND XML2_INCLUDE_DIR) set(XML2_INCLUDE_DIRS ${XML2_INCLUDE_DIR}) set(XML2_FOUND TRUE) vp_parse_header2(XML2 "${XML2_INCLUDE_DIR}/libxml/xmlversion.h" LIBXML_DOTTED_VERSION) if(WIN32 AND ICONV_FOUND) list(APPEND XML2_INCLUDE_DIRS ${ICONV_INCLUDE_DIRS}) set(XML2_LIBRARIES ${XML2_LIBRARIES} ${ICONV_LIBRARIES}) endif() else() set(XML2_FOUND FALSE) endif() mark_as_advanced( XML2_INCLUDE_DIR XML2_LIBRARIES XML2_LIBRARY ) visp-3.0.1/cmake/FindZBAR.cmake000066400000000000000000000074021304511007300161120ustar00rootroot00000000000000############################################################################# # # This file is part of the ViSP software. # Copyright (C) 2005 - 2017 by Inria. All rights reserved. # # This software is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public License # ("GPL") version 2 as published by the Free Software Foundation. # See the file LICENSE.txt at the root directory of this source # distribution for additional information about the GNU GPL. # # For using ViSP with software that can not be combined with the GNU # GPL, please contact Inria about acquiring a ViSP Professional # Edition License. # # See http://visp.inria.fr for more information. # # This software was developed at: # Inria Rennes - Bretagne Atlantique # Campus Universitaire de Beaulieu # 35042 Rennes Cedex # France # # If you have questions regarding the use of this file, please contact # Inria at visp@inria.fr # # This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE # WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. # # Description: # Try to find zbar library. # Once run this will define: # # ZBAR_FOUND # ZBAR_INCLUDE_DIRS # ZBAR_LIBRARIES # ZBAR_VERSION # # Authors: # Fabien Spindler # ############################################################################# set(ZBAR_INC_SEARCH_PATH "") set(ZBAR_LIB_SEARCH_PATH "") if(MSVC) list(APPEND ZBAR_INC_SEARCH_PATH $ENV{ZBAR_DIR}/include) list(APPEND ZBAR_INC_SEARCH_PATH "C:/ZBarWin64/include") list(APPEND ZBAR_INC_SEARCH_PATH "C:/zbar/ZBarWin64/include") if(CMAKE_CL_64) list(APPEND ZBAR_LIB_SEARCH_PATH $ENV{ZBAR_DIR}/x64) list(APPEND ZBAR_LIB_SEARCH_PATH "C:/ZBarWin64/x64") list(APPEND ZBAR_LIB_SEARCH_PATH "C:/zbar/ZBarWin64/x64") else() list(APPEND ZBAR_LIB_SEARCH_PATH $ENV{ZBAR_DIR}) list(APPEND ZBAR_LIB_SEARCH_PATH "C:/ZBarWin64") list(APPEND ZBAR_LIB_SEARCH_PATH "C:/zbar/ZBarWin64") endif() else() list(APPEND ZBAR_INC_SEARCH_PATH $ENV{ZBAR_DIR}/include) list(APPEND ZBAR_INC_SEARCH_PATH /usr/include) list(APPEND ZBAR_INC_SEARCH_PATH /usr/local/include) list(APPEND ZBAR_LIB_SEARCH_PATH /usr/lib) list(APPEND ZBAR_LIB_SEARCH_PATH /usr/local/lib) endif() find_path(ZBAR_INCLUDE_DIRS zbar.h PATHS ${ZBAR_INC_SEARCH_PATH} ) if(MSVC) set(ZBAR_LIB_SEARCH_PATH_OPT ${ZBAR_LIB_SEARCH_PATH}) set(ZBAR_LIB_SEARCH_PATH_DBG ${ZBAR_LIB_SEARCH_PATH}) foreach(p ${ZBAR_LIB_SEARCH_PATH}) list(APPEND ZBAR_LIB_SEARCH_PATH_OPT ${p}/Release) list(APPEND ZBAR_LIB_SEARCH_PATH_DBG ${p}/Debug) endforeach() find_library(ZBAR_LIBRARIES_OPT NAMES libzbar64-0 PATHS ${ZBAR_LIB_SEARCH_PATH_OPT} ) find_library(ZBAR_LIBRARIES_DBG NAMES libzbar64-0 PATHS ${ZBAR_LIB_SEARCH_PATH_DBG} ) if(ZBAR_LIBRARIES_OPT) set(ZBAR_LIBRARIES optimized ${ZBAR_LIBRARIES_OPT}) endif() if(ZBAR_LIBRARIES_DBG) list(APPEND ZBAR_LIBRARIES debug ${ZBAR_LIBRARIES_DBG}) endif() mark_as_advanced(ZBAR_LIBRARIES_OPT ZBAR_LIBRARIES_DBG) else() find_library(ZBAR_LIBRARIES NAMES zbar PATHS ${ZBAR_LIB_SEARCH_PATH} ) endif() #message("ZBAR_INCLUDE_DIRS: ${ZBAR_INCLUDE_DIRS}") #message("ZBAR_LIBRARIES: ${ZBAR_LIBRARIES}") if(ZBAR_INCLUDE_DIRS AND ZBAR_LIBRARIES) set(ZBAR_FOUND TRUE) else() set(ZBAR_FOUND FALSE) endif() if(ZBAR_FOUND) if(MSVC) vp_parse_header("${ZBAR_INCLUDE_DIRS}/config.h" ZBAR_VERSION_LINES LIB_VERSION_MAJOR LIB_VERSION_MINOR LIB_VERSION_REVISION) set(ZBAR_VERSION "${LIB_VERSION_MAJOR}.${LIB_VERSION_MINOR}.${LIB_VERSION_REVISION}") else() get_filename_component(ZBAR_LIB_DIR ${ZBAR_LIBRARIES} PATH) vp_get_version_from_pkg("zbar" "${ZBAR_LIB_DIR}/pkgconfig" ZBAR_VERSION) endif() endif() mark_as_advanced( ZBAR_INCLUDE_DIRS ZBAR_LIBRARIES ) visp-3.0.1/cmake/GNUInstallDirs.cmake000066400000000000000000000155571304511007300173670ustar00rootroot00000000000000# - Define GNU standard installation directories # Provides install directory variables as defined for GNU software: # http://www.gnu.org/prep/standards/html_node/Directory-Variables.html # Inclusion of this module defines the following variables: # CMAKE_INSTALL_ - destination for files of a given type # CMAKE_INSTALL_FULL_ - corresponding absolute path # where is one of: # BINDIR - user executables (bin) # SBINDIR - system admin executables (sbin) # LIBEXECDIR - program executables (libexec) # SYSCONFDIR - read-only single-machine data (etc) # SHAREDSTATEDIR - modifiable architecture-independent data (com) # LOCALSTATEDIR - modifiable single-machine data (var) # LIBDIR - object code libraries (lib or lib64) # INCLUDEDIR - C header files (include) # OLDINCLUDEDIR - C header files for non-gcc (/usr/include) # DATAROOTDIR - read-only architecture-independent data root (share) # DATADIR - read-only architecture-independent data (DATAROOTDIR) # INFODIR - info documentation (DATAROOTDIR/info) # LOCALEDIR - locale-dependent data (DATAROOTDIR/locale) # MANDIR - man documentation (DATAROOTDIR/man) # DOCDIR - documentation root (DATAROOTDIR/doc/PROJECT_NAME) # Each CMAKE_INSTALL_ value may be passed to the DESTINATION options of # install() commands for the corresponding file type. If the includer does # not define a value the above-shown default will be used and the value will # appear in the cache for editing by the user. # Each CMAKE_INSTALL_FULL_ value contains an absolute path constructed # from the corresponding destination by prepending (if necessary) the value # of CMAKE_INSTALL_PREFIX. #============================================================================= # Copyright 2011 Nikita Krupen'ko # Copyright 2011 Kitware, Inc. # # Distributed under the OSI-approved BSD License (the "License"); # see accompanying file Copyright.txt for details. # # This software is distributed WITHOUT ANY WARRANTY; without even the # implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. # See the License for more information. #============================================================================= # (To distribute this file outside of CMake, substitute the full # License text for the above reference.) # Installation directories # if(NOT DEFINED CMAKE_INSTALL_BINDIR) set(CMAKE_INSTALL_BINDIR "bin" CACHE PATH "user executables (bin)") endif() if(NOT DEFINED CMAKE_INSTALL_SBINDIR) set(CMAKE_INSTALL_SBINDIR "sbin" CACHE PATH "system admin executables (sbin)") endif() if(NOT DEFINED CMAKE_INSTALL_LIBEXECDIR) set(CMAKE_INSTALL_LIBEXECDIR "libexec" CACHE PATH "program executables (libexec)") endif() if(NOT DEFINED CMAKE_INSTALL_SYSCONFDIR) set(CMAKE_INSTALL_SYSCONFDIR "etc" CACHE PATH "read-only single-machine data (etc)") endif() if(NOT DEFINED CMAKE_INSTALL_SHAREDSTATEDIR) set(CMAKE_INSTALL_SHAREDSTATEDIR "com" CACHE PATH "modifiable architecture-independent data (com)") endif() if(NOT DEFINED CMAKE_INSTALL_LOCALSTATEDIR) set(CMAKE_INSTALL_LOCALSTATEDIR "var" CACHE PATH "modifiable single-machine data (var)") endif() if(NOT DEFINED CMAKE_INSTALL_LIBDIR) set(_LIBDIR_DEFAULT "lib") # Override this default 'lib' with 'lib64' iff: # - we are on Linux system but NOT cross-compiling # - we are NOT on debian # - we are on a 64 bits system # reason is: amd64 ABI: http://www.x86-64.org/documentation/abi.pdf # Note that the future of multi-arch handling may be even # more complicated than that: http://wiki.debian.org/Multiarch if(CMAKE_SYSTEM_NAME MATCHES "Linux" AND NOT CMAKE_CROSSCOMPILING AND NOT EXISTS "/etc/debian_version") if(NOT DEFINED CMAKE_SIZEOF_VOID_P) message(AUTHOR_WARNING "Unable to determine default CMAKE_INSTALL_LIBDIR directory because no target architecture is known. " "Please enable at least one language before including GNUInstallDirs.") else() if("${CMAKE_SIZEOF_VOID_P}" EQUAL "8") set(_LIBDIR_DEFAULT "lib64") endif() endif() endif() set(CMAKE_INSTALL_LIBDIR "${_LIBDIR_DEFAULT}" CACHE PATH "object code libraries (${_LIBDIR_DEFAULT})") endif() if(NOT DEFINED CMAKE_INSTALL_INCLUDEDIR) set(CMAKE_INSTALL_INCLUDEDIR "include" CACHE PATH "C header files (include)") endif() if(NOT DEFINED CMAKE_INSTALL_OLDINCLUDEDIR) set(CMAKE_INSTALL_OLDINCLUDEDIR "/usr/include" CACHE PATH "C header files for non-gcc (/usr/include)") endif() if(NOT DEFINED CMAKE_INSTALL_DATAROOTDIR) set(CMAKE_INSTALL_DATAROOTDIR "share" CACHE PATH "read-only architecture-independent data root (share)") endif() #----------------------------------------------------------------------------- # Values whose defaults are relative to DATAROOTDIR. Store empty values in # the cache and store the defaults in local variables if the cache values are # not set explicitly. This auto-updates the defaults as DATAROOTDIR changes. if(NOT CMAKE_INSTALL_DATADIR) set(CMAKE_INSTALL_DATADIR "" CACHE PATH "read-only architecture-independent data (DATAROOTDIR)") set(CMAKE_INSTALL_DATADIR "${CMAKE_INSTALL_DATAROOTDIR}") endif() if(NOT CMAKE_INSTALL_INFODIR) set(CMAKE_INSTALL_INFODIR "" CACHE PATH "info documentation (DATAROOTDIR/info)") set(CMAKE_INSTALL_INFODIR "${CMAKE_INSTALL_DATAROOTDIR}/info") endif() if(NOT CMAKE_INSTALL_LOCALEDIR) set(CMAKE_INSTALL_LOCALEDIR "" CACHE PATH "locale-dependent data (DATAROOTDIR/locale)") set(CMAKE_INSTALL_LOCALEDIR "${CMAKE_INSTALL_DATAROOTDIR}/locale") endif() if(NOT CMAKE_INSTALL_MANDIR) set(CMAKE_INSTALL_MANDIR "" CACHE PATH "man documentation (DATAROOTDIR/man)") set(CMAKE_INSTALL_MANDIR "${CMAKE_INSTALL_DATAROOTDIR}/man") endif() if(NOT CMAKE_INSTALL_DOCDIR) set(CMAKE_INSTALL_DOCDIR "" CACHE PATH "documentation root (DATAROOTDIR/doc/PROJECT_NAME)") set(CMAKE_INSTALL_DOCDIR "${CMAKE_INSTALL_DATAROOTDIR}/doc/${PROJECT_NAME}") endif() #----------------------------------------------------------------------------- mark_as_advanced( CMAKE_INSTALL_BINDIR CMAKE_INSTALL_SBINDIR CMAKE_INSTALL_LIBEXECDIR CMAKE_INSTALL_SYSCONFDIR CMAKE_INSTALL_SHAREDSTATEDIR CMAKE_INSTALL_LOCALSTATEDIR CMAKE_INSTALL_LIBDIR CMAKE_INSTALL_INCLUDEDIR CMAKE_INSTALL_OLDINCLUDEDIR CMAKE_INSTALL_DATAROOTDIR CMAKE_INSTALL_DATADIR CMAKE_INSTALL_INFODIR CMAKE_INSTALL_LOCALEDIR CMAKE_INSTALL_MANDIR CMAKE_INSTALL_DOCDIR ) # Result directories # foreach(dir BINDIR SBINDIR LIBEXECDIR SYSCONFDIR SHAREDSTATEDIR LOCALSTATEDIR LIBDIR INCLUDEDIR OLDINCLUDEDIR DATAROOTDIR DATADIR INFODIR LOCALEDIR MANDIR DOCDIR ) if(NOT IS_ABSOLUTE ${CMAKE_INSTALL_${dir}}) set(CMAKE_INSTALL_FULL_${dir} "${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_${dir}}") else() set(CMAKE_INSTALL_FULL_${dir} "${CMAKE_INSTALL_${dir}}") endif() endforeach() visp-3.0.1/cmake/OgreTools.cmake000066400000000000000000000371011304511007300164670ustar00rootroot00000000000000############################################################################# # # This file is part of the ViSP software. # Copyright (C) 2005 - 2017 by Inria. All rights reserved. # # This software is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public License # ("GPL") version 2 as published by the Free Software Foundation. # See the file LICENSE.txt at the root directory of this source # distribution for additional information about the GNU GPL. # # For using ViSP with software that can not be combined with the GNU # GPL, please contact Inria about acquiring a ViSP Professional # Edition License. # # See http://visp.inria.fr for more information. # # This software was developed at: # Inria Rennes - Bretagne Atlantique # Campus Universitaire de Beaulieu # 35042 Rennes Cedex # France # # If you have questions regarding the use of this file, please contact # Inria at visp@inria.fr # # This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE # WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. # # Description: # ViSP overall configuration file. Some useful tools for Ogre3D. # # Authors: # Fabien Spindler # ############################################################################# if(WIN32) mark_as_advanced(OGRE_FRAMEWORK_PATH) endif() ######################################################### # Find Ogre plugins # # This is a modified version of the macro provided with Ogre # except that it should be used only in a desperate way when the original # one doesn't detect anything ######################################################### macro(vp_ogre_find_plugin_lib_visp PLUGIN) # On Unix, the plugins might have no prefix if (CMAKE_FIND_LIBRARY_PREFIXES) set(TMP_CMAKE_LIB_PREFIX ${CMAKE_FIND_LIBRARY_PREFIXES}) set(CMAKE_FIND_LIBRARY_PREFIXES ${CMAKE_FIND_LIBRARY_PREFIXES} "") endif() # strip RenderSystem_ or Plugin_ prefix from plugin name string(REPLACE "RenderSystem_" "" PLUGIN_TEMP ${PLUGIN}) string(REPLACE "Plugin_" "" PLUGIN_NAME ${PLUGIN_TEMP}) set(OGRE_PLUGIN_PATH_SUFFIXES PlugIns PlugIns/${PLUGIN_NAME} Plugins Plugins/${PLUGIN_NAME} ${PLUGIN} RenderSystems RenderSystems/${PLUGIN_NAME} ${ARGN}) # find link libraries for plugins set(OGRE_${PLUGIN}_LIBRARY_NAMES "${PLUGIN}${OGRE_LIB_SUFFIX}") get_debug_names(OGRE_${PLUGIN}_LIBRARY_NAMES) find_library(OGRE_${PLUGIN}_LIBRARY_REL NAMES ${OGRE_${PLUGIN}_LIBRARY_NAMES} HINTS ${OGRE_LIBRARY_DIRS} ${OGRE_LIBRARY_DIRS}/OGRE ${OGRE_LIBRARY_DIRS}/OGRE-${OGRE_VERSION_MAJOR}.${OGRE_VERSION_MINOR}.${OGRE_VERSION_PATCH} PATH_SUFFIXES "" OGRE opt release release/opt relwithdebinfo relwithdebinfo/opt minsizerel minsizerel/opt) find_library(OGRE_${PLUGIN}_LIBRARY_DBG NAMES ${OGRE_${PLUGIN}_LIBRARY_NAMES_DBG} HINTS ${OGRE_LIBRARY_DIRS} ${OGRE_LIBRARY_DIRS}/OGRE ${OGRE_LIBRARY_DIRS}/OGRE-${OGRE_VERSION_MAJOR}.${OGRE_VERSION_MINOR}.${OGRE_VERSION_PATCH} PATH_SUFFIXES "" OGRE opt debug debug/opt) make_library_set(OGRE_${PLUGIN}_LIBRARY) if (OGRE_${PLUGIN}_LIBRARY) set(OGRE_${PLUGIN}_FOUND TRUE) endif () mark_as_advanced(OGRE_${PLUGIN}_LIBRARY_REL OGRE_${PLUGIN}_LIBRARY_DBG OGRE_${PLUGIN}_LIBRARY_FWK) endmacro() macro(vp_create_ogre_plugin_config_file) set(VISP_HAVE_OGRE_PLUGINS_PATH "${VISP_BINARY_DIR}/data/ogre-simulator" CACHE INTERNAL "Ogre plugins location") # If OGRE_PLUGIN_DIR_REL and OGRE_PLUGIN_DIR_DBG are not defined we # try to find them manually if(NOT OGRE_PLUGIN_DIR_REL AND NOT OGRE_PLUGIN_DIR_DBG) vp_ogre_find_plugin_lib_visp(RenderSystem_Direct3D9) vp_ogre_find_plugin_lib_visp(RenderSystem_Direct3D10) vp_ogre_find_plugin_lib_visp(RenderSystem_Direct3D11) vp_ogre_find_plugin_lib_visp(RenderSystem_GL) vp_ogre_find_plugin_lib_visp(RenderSystem_GLES) vp_ogre_find_plugin_lib_visp(Plugin_ParticleFX) vp_ogre_find_plugin_lib_visp(Plugin_BSPSceneManager) vp_ogre_find_plugin_lib_visp(Plugin_CgProgramManager) vp_ogre_find_plugin_lib_visp(Plugin_PCZSceneManager) vp_ogre_find_plugin_lib_visp(Plugin_OctreeSceneManager) vp_ogre_find_plugin_lib_visp(Plugin_OctreeZone) if(OGRE_RenderSystem_GL_LIBRARY_REL) get_filename_component(OGRE_PLUGIN_DIR_REL ${OGRE_RenderSystem_GL_LIBRARY_REL} PATH) #message("set manually OGRE_PLUGIN_DIR_REL to ${OGRE_PLUGIN_DIR_REL}") elseif(OGRE_RenderSystem_GL_LIBRARY_DBG) get_filename_component(OGRE_PLUGIN_DIR_DBG ${OGRE_RenderSystem_GL_LIBRARY_DBG} PATH) #message("set manually OGRE_PLUGIN_DIR_DBG to ${OGRE_PLUGIN_DIR_DBG}") endif() endif() if(OGRE_PLUGIN_DIR_REL) list(APPEND PLUGIN_REL ${OGRE_RenderSystem_Direct3D9_LIBRARY_REL}) list(APPEND PLUGIN_REL ${OGRE_RenderSystem_Direct3D10_LIBRARY_REL}) list(APPEND PLUGIN_REL ${OGRE_RenderSystem_Direct3D11_LIBRARY_REL}) list(APPEND PLUGIN_REL ${OGRE_RenderSystem_GL_LIBRARY_REL}) list(APPEND PLUGIN_REL ${OGRE_RenderSystem_GLES_LIBRARY_REL}) list(APPEND PLUGIN_REL ${OGRE_Plugin_ParticleFX_LIBRARY_REL}) list(APPEND PLUGIN_REL ${OGRE_Plugin_BSPSceneManager_LIBRARY_REL}) list(APPEND PLUGIN_REL ${OGRE_Plugin_CgProgramManager_LIBRARY_REL}) list(APPEND PLUGIN_REL ${OGRE_Plugin_PCZSceneManager_LIBRARY_REL}) list(APPEND PLUGIN_REL ${OGRE_Plugin_OctreeSceneManager_LIBRARY_REL}) if(NOT APPLE) # Since the plugin Plugin_Octree causes problems on OSX, we take # it only into account on non Apple platforms list(APPEND PLUGIN_REL ${OGRE_Plugin_OctreeZone_LIBRARY_REL}) endif() set(PLUGINS_CONTENT_REL "# Defines plugins to load\n\n") list(APPEND PLUGINS_CONTENT_REL "# Define plugin folder\n") list(APPEND PLUGINS_CONTENT_REL "PluginFolder=${OGRE_PLUGIN_DIR_REL}/\n\n") list(APPEND PLUGINS_CONTENT_REL "# Define plugins\n") foreach(PLUGIN ${PLUGIN_REL}) if(PLUGIN) get_filename_component(PLUGIN_NAME ${PLUGIN} NAME_WE) list(APPEND PLUGINS_CONTENT_REL " Plugin=${PLUGIN_NAME}\n") endif() endforeach() #MESSAGE("PLUGINS_CONTENT_REL: ${PLUGINS_CONTENT_REL}") file(WRITE "${VISP_HAVE_OGRE_PLUGINS_PATH}/plugins.cfg" ${PLUGINS_CONTENT_REL}) endif() if(OGRE_PLUGIN_DIR_DBG) list(APPEND PLUGIN_DBG ${OGRE_RenderSystem_Direct3D9_LIBRARY_DBG}) list(APPEND PLUGIN_DBG ${OGRE_RenderSystem_Direct3D10_LIBRARY_DBG}) list(APPEND PLUGIN_DBG ${OGRE_RenderSystem_Direct3D11_LIBRARY_DBG}) list(APPEND PLUGIN_DBG ${OGRE_RenderSystem_GL_LIBRARY_DBG}) list(APPEND PLUGIN_DBG ${OGRE_RenderSystem_GLES_LIBRARY_DBG}) list(APPEND PLUGIN_DBG ${OGRE_Plugin_ParticleFX_LIBRARY_DBG}) list(APPEND PLUGIN_DBG ${OGRE_Plugin_BSPSceneManager_LIBRARY_DBG}) list(APPEND PLUGIN_DBG ${OGRE_Plugin_CgProgramManager_LIBRARY_DBG}) list(APPEND PLUGIN_DBG ${OGRE_Plugin_PCZSceneManager_LIBRARY_DBG}) list(APPEND PLUGIN_DBG ${OGRE_Plugin_OctreeSceneManager_LIBRARY_DBG}) if(NOT APPLE) # Since the plugin Plugin_Octree causes problems on OSX, we take # it only into account on non Apple platforms list(APPEND PLUGIN_DBG ${OGRE_Plugin_OctreeZone_LIBRARY_DBG}) endif() set(PLUGINS_CONTENT_DBG "# Defines plugins to load\n\n") list(APPEND PLUGINS_CONTENT_DBG "# Define plugin folder\n") list(APPEND PLUGINS_CONTENT_DBG "PluginFolder=${OGRE_PLUGIN_DIR_DBG}/\n\n") list(APPEND PLUGINS_CONTENT_DBG "# Define plugins\n") foreach(PLUGIN ${PLUGIN_DBG}) if(PLUGIN) get_filename_component(PLUGIN_NAME ${PLUGIN} NAME_WE) list(APPEND PLUGINS_CONTENT_DBG " Plugin=${PLUGIN_NAME}\n") endif() endforeach() #MESSAGE("PLUGINS_CONTENT_DBG: ${PLUGINS_CONTENT_DBG}") file(WRITE "${VISP_HAVE_OGRE_PLUGINS_PATH}/plugins_d.cfg" ${PLUGINS_CONTENT_DBG}) endif() endmacro() function(vp_set_ogre_media) # if OGRE_MEDIA_DIR is empty, try to find the path by searching for plugins.cfg # Introduced since Ubuntu 12.04 if(NOT OGRE_MEDIA_DIR) find_path(OGRE_MEDIA_DIR ../plugins.cfg $ENV{OGRE_MEDIA_DIR} /usr/share/OGRE-1.7.4/media /usr/share/OGRE-1.8.0/media /usr/share/OGRE-1.8.1/media /usr/share/OGRE-1.9.0/media ) endif() # If Ogre media are not available we provide the minimal material to run the examples: # - resources.cfg # - plugins.cfg # - media/materials/... # - media/models/... # # We need to introduce OGRE_MEDIA_NOT_AVAILABLE to memorize when OGRE_MEDIA_DIR is not set. # Because in that case, OGRE_MEDIA_DIR should be set first to VISP_HAVE_OGRE_RESOURCES_PATH # (for the "make all" case) then to VISP_INSTALL_DIR_OGRE_RESOURCES (for the "make install" case) if(NOT OGRE_MEDIA_DIR) set(OGRE_MEDIA_NOT_AVAILABLE "TRUE") endif() # Try to search for an existing plugins.cfg file # Here we cannot use OGRE_PLUGIN_DIR_REL or OGRE_PLUGIN_DIR_DBG where # we may find an existing plugins.cfg file, since under Windows in these # files the PluginFolder is set to a relative path. We need an absolute # path to avoid recopy of the plugins in ViSP. # Under Linux or OSX, we may find plugins.cfg with a PluginFolder set # to an absolute path in OGRE_MEDIA_DIR/.. find_path(ogre_plugings_cfg_exists NAMES plugins.cfg PATHS ${OGRE_MEDIA_DIR}/.. NO_SYSTEM_ENVIRONMENT_PATH ) mark_as_advanced(ogre_plugings_cfg_exists) #message("OGRE_PLUGIN_DIR_REL: ${OGRE_PLUGIN_DIR_REL}") #message("OGRE_PLUGIN_DIR_DBG: ${OGRE_PLUGIN_DIR_DBG}") if(ogre_plugings_cfg_exists) set(VISP_HAVE_OGRE_PLUGINS_PATH "${ogre_plugings_cfg_exists}" CACHE INTERNAL "Ogre plugins location") else(NOT ogre_plugings_cfg_exists) # If no plugins.cfg file is found, we create one with absolute path # case 1: normal case #-------------- vp_create_ogre_plugin_config_file() # case 2: install or packaging case #-------------- # install rule for plugins.cfg: if(UNIX) if(OGRE_PLUGIN_DIR_REL) install(FILES ${VISP_HAVE_OGRE_PLUGINS_PATH}/plugins.cfg DESTINATION ${VISP_LIB_INSTALL_PATH}/visp/data/ogre-simulator PERMISSIONS OWNER_READ GROUP_READ WORLD_READ OWNER_WRITE COMPONENT dev ) endif() if(OGRE_PLUGIN_DIR_DBG) install(FILES ${VISP_HAVE_OGRE_PLUGINS_PATH}/plugins_d.cfg DESTINATION ${VISP_LIB_INSTALL_PATH}/visp/data/ogre-simulator PERMISSIONS OWNER_READ GROUP_READ WORLD_READ OWNER_WRITE COMPONENT dev ) endif() else() if(OGRE_PLUGIN_DIR_REL) install(FILES ${VISP_HAVE_OGRE_PLUGINS_PATH}/plugins.cfg DESTINATION data/ogre-simulator PERMISSIONS OWNER_READ GROUP_READ WORLD_READ OWNER_WRITE COMPONENT dev ) endif() if(OGRE_PLUGIN_DIR_DBG) install(FILES ${VISP_HAVE_OGRE_PLUGINS_PATH}/plugins_d.cfg DESTINATION data/ogre-simulator PERMISSIONS OWNER_READ GROUP_READ WORLD_READ OWNER_WRITE COMPONENT dev ) endif() endif() endif() # Try to search for an existing resources.cfg file find_path(ogre_resources_cfg_exists NAMES resources.cfg PATHS ${OGRE_MEDIA_DIR}/.. NO_SYSTEM_ENVIRONMENT_PATH ) mark_as_advanced(ogre_resources_cfg_exists) # Here we copy all the minimal media files # - media/materials/... # - media/models/... if(OGRE_MEDIA_NOT_AVAILABLE) file(COPY modules/ar/data/ogre-simulator/media DESTINATION ${VISP_BINARY_DIR}/data/ogre-simulator) endif() if(ogre_resources_cfg_exists) set(VISP_HAVE_OGRE_RESOURCES_PATH "${ogre_resources_cfg_exists}" CACHE INTERNAL "Ogre resources location") else() # Here we create a resources.cfg if it was not found # we create a resources.cfg file for vpAROgre.cpp # case 1: normal case # If OGRE_MEDIA_DIR is not found, we set it to VISP_HAVE_OGRE_RESOURCES_PATH in order to use # the minimal requested media to run the examples #-------------- set(VISP_HAVE_OGRE_RESOURCES_PATH "${VISP_BINARY_DIR}/data/ogre-simulator" CACHE INTERNAL "Ogre resources location") if(OGRE_MEDIA_NOT_AVAILABLE) set(OGRE_MEDIA_DIR ${VISP_HAVE_OGRE_RESOURCES_PATH}/media) endif() # Here we add all the subdirs in @OGRE_MEDIA_DIR@/* as resource location. vp_get_relative_subdirs(media_subdirs ${OGRE_MEDIA_DIR}) set(OGRE_RESOURCES_FileSystem "FileSystem=${OGRE_MEDIA_DIR}\n") foreach(m ${media_subdirs}) set(OGRE_RESOURCES_FileSystem "${OGRE_RESOURCES_FileSystem}FileSystem=${OGRE_MEDIA_DIR}/${m}\n") endforeach() configure_file( ${VISP_SOURCE_DIR}/cmake/templates/resources.cfg.in ${VISP_HAVE_OGRE_RESOURCES_PATH}/resources.cfg IMMEDIATE @ONLY ) # case 2: install or packaging case # If OGRE_MEDIA_DIR is not found, we set it to VISP_INSTALL_DIR_OGRE_RESOURCES in order to use # the minimal requested media to run the examples #-------------- if(UNIX) set(VISP_INSTALL_DIR_OGRE_RESOURCES "${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_DATAROOTDIR}/visp-${VISP_VERSION}/data/ogre-simulator") else() set(VISP_INSTALL_DIR_OGRE_RESOURCES "${CMAKE_INSTALL_PREFIX}/data/ogre-simulator") endif() # make the var global set(VISP_INSTALL_DIR_OGRE_RESOURCES ${VISP_INSTALL_DIR_OGRE_RESOURCES} CACHE INTERNAL "Ogre media install dir") if(OGRE_MEDIA_NOT_AVAILABLE) set(OGRE_MEDIA_DIR ${VISP_INSTALL_DIR_OGRE_RESOURCES}/media) endif() # Here we add all the subdirs in @OGRE_MEDIA_DIR@/* as resource location. set(OGRE_RESOURCES_FileSystem "FileSystem=${OGRE_MEDIA_DIR}\n") foreach(m ${media_subdirs}) set(OGRE_RESOURCES_FileSystem "${OGRE_RESOURCES_FileSystem}FileSystem=${OGRE_MEDIA_DIR}/${m}\n") endforeach() # install rule for resources.cfg and Ogre media if they are not available: if(UNIX) configure_file( ${VISP_SOURCE_DIR}/cmake/templates/resources.cfg.in ${VISP_BINARY_DIR}/unix-install/resources.cfg IMMEDIATE @ONLY ) install(FILES ${VISP_BINARY_DIR}/unix-install/resources.cfg DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/visp-${VISP_VERSION}/data/ogre-simulator PERMISSIONS OWNER_READ GROUP_READ WORLD_READ OWNER_WRITE COMPONENT dev ) if(OGRE_MEDIA_NOT_AVAILABLE) install(DIRECTORY ${VISP_BINARY_DIR}/data/ogre-simulator/media DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/visp-${VISP_VERSION}/data/ogre-simulator FILE_PERMISSIONS OWNER_READ GROUP_READ WORLD_READ OWNER_WRITE COMPONENT dev ) endif() else() configure_file( ${VISP_SOURCE_DIR}/cmake/templates/resources.cfg.in ${VISP_BINARY_DIR}/win-install/resources.cfg IMMEDIATE @ONLY ) install(FILES ${VISP_BINARY_DIR}/win-install/resources.cfg DESTINATION data/ogre-simulator PERMISSIONS OWNER_READ GROUP_READ WORLD_READ OWNER_WRITE COMPONENT dev ) if(OGRE_MEDIA_NOT_AVAILABLE) install(DIRECTORY ${VISP_BINARY_DIR}/data/ogre-simulator/media DESTINATION data/ogre-simulator FILE_PERMISSIONS OWNER_READ GROUP_READ WORLD_READ OWNER_WRITE COMPONENT dev ) endif() endif() endif() endfunction() macro(vp_set_ogre_advanced_var) set(ogre_components_ Paging Terrain Plugin_BSPSceneManager Plugin_CgProgramManager Plugin_OctreeSceneManager Plugin_OctreeZone Plugin_PCZSceneManager Plugin_ParticleFX RenderSystem_Direct3D11 RenderSystem_Direct3D9 RenderSystem_GLES2 RenderSystem_GLES RenderSystem_GL) foreach(component_ ${ogre_components_}) mark_as_advanced(OGRE_${component_}_INCLUDE_DIR) mark_as_advanced(OGRE_${component_}_LIBRARY_DBG) mark_as_advanced(OGRE_${component_}_LIBRARY_REL) mark_as_advanced(OGRE_${component_}_LIBRARY_FWK) endforeach() endmacro() visp-3.0.1/cmake/PCLTools.cmake000066400000000000000000000041531304511007300162120ustar00rootroot00000000000000############################################################################# # # This file is part of the ViSP software. # Copyright (C) 2005 - 2017 by Inria. All rights reserved. # # This software is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public License # ("GPL") version 2 as published by the Free Software Foundation. # See the file LICENSE.txt at the root directory of this source # distribution for additional information about the GNU GPL. # # For using ViSP with software that can not be combined with the GNU # GPL, please contact Inria about acquiring a ViSP Professional # Edition License. # # See http://visp.inria.fr for more information. # # This software was developed at: # Inria Rennes - Bretagne Atlantique # Campus Universitaire de Beaulieu # 35042 Rennes Cedex # France # # If you have questions regarding the use of this file, please contact # Inria at visp@inria.fr # # This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE # WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. # # Description: # ViSP configuration file. # # Authors: # Fabien Spindler # ############################################################################# if(USE_PCL) if(PCL_FOUND) mark_as_advanced(PCL_DIR) mark_as_advanced(PCL_APPS_LIBRARY) mark_as_advanced(PCL_APPS_LIBRARY_DEBUG) foreach(component ${PCL_TO_FIND_COMPONENTS}) string(TOUPPER "${component}" COMPONENT) if(PCL_${COMPONENT}_INCLUDE_DIR) mark_as_advanced(PCL_${COMPONENT}_INCLUDE_DIR) endif() endforeach() endif() if(EIGEN_FOUND) mark_as_advanced(EIGEN_INCLUDE_DIRS) endif() if(FLANN_FOUND) mark_as_advanced(FLANN_INCLUDE_DIRS) mark_as_advanced(FLANN_LIBRARY) mark_as_advanced(FLANN_LIBRARY_DEBUG) endif() if(QHULL_FOUND) mark_as_advanced(QHULL_INCLUDE_DIRS) mark_as_advanced(QHULL_LIBRARY) mark_as_advanced(QHULL_LIBRARY_DEBUG) endif() mark_as_advanced(OPENNI2_INCLUDE_DIRS) mark_as_advanced(OPENNI2_LIBRARY) mark_as_advanced(OPENNI_INCLUDE_DIRS) mark_as_advanced(OPENNI_LIBRARY) endif()visp-3.0.1/cmake/VISP3rdParty.cmake000066400000000000000000000006771304511007300167740ustar00rootroot00000000000000#---------------------------------------------------------------------- # Add 3rd-party libraries build as static libs #---------------------------------------------------------------------- if(BUILD_ATIDAQ) set(ATIDAQ_LIBRARY atidaq_c) add_subdirectory("${VISP_SOURCE_DIR}/3rdparty/libatidaq-c") set(ATIDAQ_INCLUDE_DIRS "${${ATIDAQ_LIBRARY}_SOURCE_DIR}" "${${ATIDAQ_LIBRARY}_BINARY_DIR}") set(ATIDAQ_LIBRARIES ${ATIDAQ_LIBRARY}) endif() visp-3.0.1/cmake/VISPCRTLinkage.cmake000066400000000000000000000105021304511007300171730ustar00rootroot00000000000000if(NOT MSVC) message(FATAL_ERROR "CRT options are available only for MSVC") endif() if(WINRT) if(CMAKE_SYSTEM_VERSION MATCHES 10) add_definitions(/DWINVER=_WIN32_WINNT_WIN10 /DNTDDI_VERSION=NTDDI_WIN10 /D_WIN32_WINNT=_WIN32_WINNT_WIN10) elseif(CMAKE_SYSTEM_VERSION MATCHES 8.1) add_definitions(/DWINVER=_WIN32_WINNT_WINBLUE /DNTDDI_VERSION=NTDDI_WINBLUE /D_WIN32_WINNT=_WIN32_WINNT_WINBLUE) else() add_definitions(/DWINVER=_WIN32_WINNT_WIN8 /DNTDDI_VERSION=NTDDI_WIN8 /D_WIN32_WINNT=_WIN32_WINNT_WIN8) endif() endif() # Removing LNK4075 warnings for debug WinRT builds # "LNK4075: ignoring '/INCREMENTAL' due to '/OPT:ICF' specification" # "LNK4075: ignoring '/INCREMENTAL' due to '/OPT:REF' specification" if(MSVC AND WINRT) # Optional verification checks since we don't know existing contents of variables below string(REPLACE "/OPT:ICF " "/OPT:NOICF " CMAKE_EXE_LINKER_FLAGS_DEBUG "${CMAKE_EXE_LINKER_FLAGS_DEBUG}") string(REPLACE "/OPT:REF " "/OPT:NOREF " CMAKE_EXE_LINKER_FLAGS_DEBUG "${CMAKE_EXE_LINKER_FLAGS_DEBUG}") string(REPLACE "/INCREMENTAL:YES " "/INCREMENTAL:NO " CMAKE_EXE_LINKER_FLAGS_DEBUG "${CMAKE_EXE_LINKER_FLAGS_DEBUG}") string(REPLACE "/INCREMENTAL " "/INCREMENTAL:NO " CMAKE_EXE_LINKER_FLAGS_DEBUG "${CMAKE_EXE_LINKER_FLAGS_DEBUG}") string(REPLACE "/OPT:ICF " "/OPT:NOICF " CMAKE_MODULE_LINKER_FLAGS_DEBUG "${CMAKE_MODULE_LINKER_FLAGS_DEBUG}") string(REPLACE "/OPT:REF " "/OPT:NORE F" CMAKE_MODULE_LINKER_FLAGS_DEBUG "${CMAKE_MODULE_LINKER_FLAGS_DEBUG}") string(REPLACE "/INCREMENTAL:YES " "/INCREMENTAL:NO " CMAKE_MODULE_LINKER_FLAGS_DEBUG "${CMAKE_MODULE_LINKER_FLAGS_DEBUG}") string(REPLACE "/INCREMENTAL " "/INCREMENTAL:NO " CMAKE_MODULE_LINKER_FLAGS_DEBUG "${CMAKE_MODULE_LINKER_FLAGS_DEBUG}") string(REPLACE "/OPT:ICF " "/OPT:NOICF " CMAKE_SHARED_LINKER_FLAGS_DEBUG "${CMAKE_SHARED_LINKER_FLAGS_DEBUG}") string(REPLACE "/OPT:REF " "/OPT:NOREF " CMAKE_SHARED_LINKER_FLAGS_DEBUG "${CMAKE_SHARED_LINKER_FLAGS_DEBUG}") string(REPLACE "/INCREMENTAL:YES " "/INCREMENTAL:NO " CMAKE_SHARED_LINKER_FLAGS_DEBUG "${CMAKE_SHARED_LINKER_FLAGS_DEBUG}") string(REPLACE "/INCREMENTAL " "/INCREMENTAL:NO " CMAKE_SHARED_LINKER_FLAGS_DEBUG "${CMAKE_SHARED_LINKER_FLAGS_DEBUG}") # Mandatory set(CMAKE_MODULE_LINKER_FLAGS_DEBUG "${CMAKE_MODULE_LINKER_FLAGS_DEBUG} /INCREMENTAL:NO /OPT:NOREF /OPT:NOICF") set(CMAKE_EXE_LINKER_FLAGS_DEBUG "${CMAKE_EXE_LINKER_FLAGS_DEBUG} /INCREMENTAL:NO /OPT:NOREF /OPT:NOICF") set(CMAKE_SHARED_LINKER_FLAGS_DEBUG "${CMAKE_SHARED_LINKER_FLAGS_DEBUG} /INCREMENTAL:NO /OPT:NOREF /OPT:NOICF") endif() if(NOT BUILD_SHARED_LIBS AND BUILD_WITH_STATIC_CRT) foreach(flag_var CMAKE_C_FLAGS CMAKE_C_FLAGS_DEBUG CMAKE_C_FLAGS_RELEASE CMAKE_C_FLAGS_MINSIZEREL CMAKE_C_FLAGS_RELWITHDEBINFO CMAKE_CXX_FLAGS CMAKE_CXX_FLAGS_DEBUG CMAKE_CXX_FLAGS_RELEASE CMAKE_CXX_FLAGS_MINSIZEREL CMAKE_CXX_FLAGS_RELWITHDEBINFO) if(${flag_var} MATCHES "/MD") string(REGEX REPLACE "/MD" "/MT" ${flag_var} "${${flag_var}}") endif() if(${flag_var} MATCHES "/MDd") string(REGEX REPLACE "/MDd" "/MTd" ${flag_var} "${${flag_var}}") endif() endforeach(flag_var) set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /NODEFAULTLIB:atlthunk.lib /NODEFAULTLIB:msvcrt.lib /NODEFAULTLIB:msvcrtd.lib") set(CMAKE_EXE_LINKER_FLAGS_DEBUG "${CMAKE_EXE_LINKER_FLAGS_DEBUG} /NODEFAULTLIB:libcmt.lib") set(CMAKE_EXE_LINKER_FLAGS_RELEASE "${CMAKE_EXE_LINKER_FLAGS_RELEASE} /NODEFAULTLIB:libcmtd.lib") else() foreach(flag_var CMAKE_C_FLAGS CMAKE_C_FLAGS_DEBUG CMAKE_C_FLAGS_RELEASE CMAKE_C_FLAGS_MINSIZEREL CMAKE_C_FLAGS_RELWITHDEBINFO CMAKE_CXX_FLAGS CMAKE_CXX_FLAGS_DEBUG CMAKE_CXX_FLAGS_RELEASE CMAKE_CXX_FLAGS_MINSIZEREL CMAKE_CXX_FLAGS_RELWITHDEBINFO) if(${flag_var} MATCHES "/MT") string(REGEX REPLACE "/MT" "/MD" ${flag_var} "${${flag_var}}") endif() if(${flag_var} MATCHES "/MTd") string(REGEX REPLACE "/MTd" "/MDd" ${flag_var} "${${flag_var}}") endif() endforeach(flag_var) endif() if(NOT ${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION} LESS 2.8 AND NOT ${CMAKE_MINOR_VERSION}.${CMAKE_PATCH_VERSION} LESS 8.6) include(ProcessorCount) ProcessorCount(N) if(NOT N EQUAL 0) SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /MP${N} ") SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /MP${N} ") endif() endif() visp-3.0.1/cmake/VISPConfig.cmake000066400000000000000000000127211304511007300164620ustar00rootroot00000000000000############################################################################# # # This file is part of the ViSP software. # Copyright (C) 2005 - 2017 by Inria. All rights reserved. # # This software is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public License # ("GPL") version 2 as published by the Free Software Foundation. # See the file LICENSE.txt at the root directory of this source # distribution for additional information about the GNU GPL. # # For using ViSP with software that can not be combined with the GNU # GPL, please contact Inria about acquiring a ViSP Professional # Edition License. # # See http://visp.inria.fr for more information. # # This software was developed at: # Inria Rennes - Bretagne Atlantique # Campus Universitaire de Beaulieu # 35042 Rennes Cedex # France # # If you have questions regarding the use of this file, please contact # Inria at visp@inria.fr # # This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE # WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. # # Description: # CMake package config file for ViSP. # # ** File generated automatically, do not modify ** # # This file will define the following CMake variables: # - VISP_INCLUDE_DIRS : ViSP and third-party include directories # - VISP_LIBRARIES : ViSP library to link against. Third-party libraries are # linked automatically thanks to cmake export file VISPTargets.cmake # - VISP_VERSION_STRING : Full ViSP version that is build. Example: "2.10.0" # - VISP_VERSION_MAJOR : Major version part of VISP_VERSION. Example: "2" # - VISP_VERSION_MINOR : Minor version part of VISP_VERSION. Example: "10" # - VISP_VERSION_PATCH : Patch version part of VISP_VERSION. Example: "0" # # Advanced variables: # - VISP_SHARED : Use ViSP as shared library # - VISP_CONFIG_PATH : Path to this VISPConfig.cmake # - VISP_FIND_QUIETLY : If set to TRUE turn off messages during configuration # - VISP_USE_FILE : File to include to use ViSP without specific cmake code # # Windows specific variables: # - VISP_STATIC : If set to TRUE uses ViSP static library (.lib) rather then dynamic (.dll) # # Typical usage in user project: # # find_package(VISP) # include_directories(${VISP_INCLUDE_DIRS}) # target_link_libraries(MY_TARGET_NAME ${VISP_LIBRARIES}) # # It is also possible to build your project using VISP_USE_FILE. # # find_package(VISP) # if(VISP_FOUND) # include(${VISP_USE_FILE}) # endif() # # Authors: # Fabien Spindler # ############################################################################# # similar code exist in VISPDetectPlatform.cmake if(MSVC) if(CMAKE_CL_64) set(VISP_ARCH x64) else() set(VISP_ARCH x86) endif() if(MSVC_VERSION EQUAL 1400) set(VISP_RUNTIME vc8) elseif(MSVC_VERSION EQUAL 1500) set(VISP_RUNTIME vc9) elseif(MSVC_VERSION EQUAL 1600) set(VISP_RUNTIME vc10) elseif(MSVC_VERSION EQUAL 1700) set(VISP_RUNTIME vc11) elseif(MSVC_VERSION EQUAL 1800) set(VISP_RUNTIME vc12) elseif(MSVC_VERSION EQUAL 1900) set(VISP_RUNTIME vc14) elseif(MSVC_VERSION EQUAL 1910) set(VISP_RUNTIME vc15) endif() elseif(MINGW) set(VISP_RUNTIME mingw) execute_process(COMMAND ${CMAKE_CXX_COMPILER} -dumpmachine OUTPUT_VARIABLE VISP_GCC_TARGET_MACHINE OUTPUT_STRIP_TRAILING_WHITESPACE) if(VISP_GCC_TARGET_MACHINE MATCHES "64") set(MINGW64 1) set(VISP_ARCH x64) else() set(VISP_ARCH x86) endif() endif() if(CMAKE_VERSION VERSION_GREATER 2.6.2) unset(VISP_CONFIG_PATH CACHE) endif() if(NOT VISP_FIND_QUIETLY) message(STATUS "ViSP ARCH: ${VISP_ARCH}") message(STATUS "ViSP RUNTIME: ${VISP_RUNTIME}") endif() get_filename_component(VISP_CONFIG_PATH "${CMAKE_CURRENT_LIST_FILE}" PATH CACHE) if(VISP_RUNTIME AND VISP_ARCH) if(NOT DEFINED VISP_STATIC AND EXISTS "${VISP_CONFIG_PATH}/${VISP_ARCH}/${VISP_RUNTIME}/lib/VISPConfig.cmake") set(VISP_LIB_PATH "${VISP_CONFIG_PATH}/${VISP_ARCH}/${VISP_RUNTIME}/lib") elseif(NOT DEFINED VISP_STATIC AND EXISTS "${VISP_CONFIG_PATH}/${VISP_ARCH}/${VISP_RUNTIME}/staticlib/VISPConfig.cmake") set(VISP_LIB_PATH "${VISP_CONFIG_PATH}/${VISP_ARCH}/${VISP_RUNTIME}/staticlib") elseif(VISP_STATIC AND EXISTS "${VISP_CONFIG_PATH}/${VISP_ARCH}/${VISP_RUNTIME}/staticlib/VISPConfig.cmake") set(VISP_LIB_PATH "${VISP_CONFIG_PATH}/${VISP_ARCH}/${VISP_RUNTIME}/staticlib") elseif(VISP_STATIC EXISTS "${VISP_CONFIG_PATH}/${VISP_ARCH}/${VISP_RUNTIME}/lib/VISPConfig.cmake") set(VISP_LIB_PATH "${VISP_CONFIG_PATH}/${VISP_ARCH}/${VISP_RUNTIME}/lib") endif() endif() if(VISP_LIB_PATH AND EXISTS "${VISP_LIB_PATH}/VISPConfig.cmake") include("${VISP_LIB_PATH}/VISPConfig.cmake") set(VISP_FOUND TRUE CACHE BOOL "" FORCE) if(NOT VISP_FIND_QUIETLY) message(STATUS "Found VISP ${VISP_VERSION} in ${VISP_LIB_PATH}") if(NOT VISP_LIB_PATH MATCHES "/staticlib") get_filename_component(_VISP_LIB_PATH "${VISP_LIB_PATH}/../bin" ABSOLUTE) file(TO_NATIVE_PATH "${_VISP_LIB_PATH}" _VISP_LIB_PATH) message(STATUS "You might need to add ${_VISP_LIB_PATH} to your PATH to be able to run your applications.") endif() endif() else() if(NOT VISP_FIND_QUIETLY) message(WARNING "Found ViSP for Windows but it has no binaries compatible with your configuration. You should manually point CMake variable VISP_DIR to your build of ViSP library." ) endif() set(VISP_FOUND FALSE CACHE BOOL "" FORCE) endif() visp-3.0.1/cmake/VISPDetectPlatform.cmake000066400000000000000000000073001304511007300201670ustar00rootroot00000000000000############################################################################# # # This file is part of the ViSP software. # Copyright (C) 2005 - 2017 by Inria. All rights reserved. # # This software is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public License # ("GPL") version 2 as published by the Free Software Foundation. # See the file LICENSE.txt at the root directory of this source # distribution for additional information about the GNU GPL. # # For using ViSP with software that can not be combined with the GNU # GPL, please contact Inria about acquiring a ViSP Professional # Edition License. # # See http://visp.inria.fr for more information. # # This software was developed at: # Inria Rennes - Bretagne Atlantique # Campus Universitaire de Beaulieu # 35042 Rennes Cedex # France # # If you have questions regarding the use of this file, please contact # Inria at visp@inria.fr # # This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE # WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. # # Authors: # Fabien Spindler # ############################################################################# if(CMAKE_CL_64) set(MSVC64 1) endif() if(CMAKE_CXX_COMPILER_ID STREQUAL "Clang") set(CMAKE_COMPILER_IS_GNUCXX 1) set(CMAKE_COMPILER_IS_CLANGCXX 1) endif() if(CMAKE_C_COMPILER_ID STREQUAL "Clang") set(CMAKE_COMPILER_IS_GNUCC 1) set(CMAKE_COMPILER_IS_CLANGCC 1) endif() if(CMAKE_COMPILER_IS_GNUCXX) if(WIN32) execute_process(COMMAND ${CMAKE_CXX_COMPILER} -dumpmachine OUTPUT_VARIABLE VISP_GCC_TARGET_MACHINE OUTPUT_STRIP_TRAILING_WHITESPACE) if(VISP_GCC_TARGET_MACHINE MATCHES "amd64|x86_64|AMD64") set(MINGW64 1) endif() endif() endif() if(MSVC64 OR MINGW64) set(X86_64 1) elseif(MINGW OR (MSVC AND NOT CMAKE_CROSSCOMPILING)) set(X86 1) elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "amd64.*|x86_64.*|AMD64.*") set(X86_64 1) elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "i686.*|i386.*|x86.*|amd64.*|AMD64.*") set(X86 1) elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "^(arm.*|ARM.*)") set(ARM 1) elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "^(aarch64.*|AARCH64.*)") set(AARCH64 1) endif() # Workaround for 32-bit operating systems on 64-bit x86_64 processor if(X86_64 AND CMAKE_SIZEOF_VOID_P EQUAL 4 AND NOT FORCE_X86_64) message(STATUS "sizeof(void) = 4 on x86 / x86_64 processor. Assume 32-bit compilation mode (X86=1)") unset(X86_64) set(X86 1) endif() # ---------------------------------------------------------------------------- # Similar code exist in VISPConfig.cmake # ---------------------------------------------------------------------------- if(NOT DEFINED VISP_STATIC) # look for global setting if(NOT DEFINED BUILD_SHARED_LIBS OR BUILD_SHARED_LIBS) set(VISP_STATIC OFF) else() set(VISP_STATIC ON) endif() endif() if(MSVC) if(CMAKE_CL_64) set(VISP_ARCH x64) else() set(VISP_ARCH x86) endif() if(MSVC_VERSION EQUAL 1400) set(VISP_RUNTIME vc8) elseif(MSVC_VERSION EQUAL 1500) set(VISP_RUNTIME vc9) elseif(MSVC_VERSION EQUAL 1600) set(VISP_RUNTIME vc10) elseif(MSVC_VERSION EQUAL 1700) set(VISP_RUNTIME vc11) elseif(MSVC_VERSION EQUAL 1800) set(VISP_RUNTIME vc12) elseif(MSVC_VERSION EQUAL 1900) set(VISP_RUNTIME vc14) elseif(MSVC_VERSION EQUAL 1910) set(VISP_RUNTIME vc15) endif() elseif(MINGW) set(VISP_RUNTIME mingw) execute_process(COMMAND ${CMAKE_CXX_COMPILER} -dumpmachine OUTPUT_VARIABLE VISP_GCC_TARGET_MACHINE OUTPUT_STRIP_TRAILING_WHITESPACE) if(VISP_GCC_TARGET_MACHINE MATCHES "64") set(MINGW64 1) set(VISP_ARCH x64) else() set(VISP_ARCH x86) endif() endif() visp-3.0.1/cmake/VISPExtraTargets.cmake000066400000000000000000000127001304511007300176670ustar00rootroot00000000000000############################################################################# # # This file is part of the ViSP software. # Copyright (C) 2005 - 2017 by Inria. All rights reserved. # # This software is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public License # ("GPL") version 2 as published by the Free Software Foundation. # See the file LICENSE.txt at the root directory of this source # distribution for additional information about the GNU GPL. # # For using ViSP with software that can not be combined with the GNU # GPL, please contact Inria about acquiring a ViSP Professional # Edition License. # # See http://visp.inria.fr for more information. # # This software was developed at: # Inria Rennes - Bretagne Atlantique # Campus Universitaire de Beaulieu # 35042 Rennes Cedex # France # # If you have questions regarding the use of this file, please contact # Inria at visp@inria.fr # # This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE # WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. # # Authors: # Fabien Spindler # ############################################################################# # ---------------------------------------------------------------------------- # Uninstall target, for "make uninstall" # ---------------------------------------------------------------------------- configure_file( cmake/templates/cmake_uninstall.cmake.in "${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake" IMMEDIATE @ONLY) add_custom_target(uninstall "${CMAKE_COMMAND}" -P "${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake") if(ENABLE_SOLUTION_FOLDERS) set_target_properties(uninstall PROPERTIES FOLDER "CMakeTargets") endif() # ---------------------------------------------------------------------------- # Doxygen documentation target, for "make visp_doc" and "make html-doc" (to keep compat with previous versions) # ---------------------------------------------------------------------------- if(DOXYGEN_FOUND) add_custom_target(html-doc ${DOXYGEN_EXECUTABLE} ${VISP_DOC_DIR}/config-doxygen) # for compat with previous versions add_custom_target(visp_doc ${DOXYGEN_EXECUTABLE} ${VISP_DOC_DIR}/config-doxygen) if(ENABLE_SOLUTION_FOLDERS) set_target_properties(visp_doc PROPERTIES FOLDER "extra") set_target_properties(html-doc PROPERTIES FOLDER "extra") endif() endif() # ---------------------------------------------------------------------------- # Tests target, for make visp_tests # ---------------------------------------------------------------------------- if(BUILD_TESTS) add_custom_target(visp_tests) if(ENABLE_SOLUTION_FOLDERS) set_target_properties(visp_tests PROPERTIES FOLDER "extra") endif() endif() # ---------------------------------------------------------------------------- # Tests target, for make visp_examples # ---------------------------------------------------------------------------- if(BUILD_EXAMPLES) add_custom_target(visp_examples) if(ENABLE_SOLUTION_FOLDERS) set_target_properties(visp_examples PROPERTIES FOLDER "extra") endif() endif() # ---------------------------------------------------------------------------- # Tests target, for make visp_demos # ---------------------------------------------------------------------------- if(BUILD_DEMOS) add_custom_target(visp_demos) if(ENABLE_SOLUTION_FOLDERS) set_target_properties(visp_demos PROPERTIES FOLDER "extra") endif() endif() # ---------------------------------------------------------------------------- # Tests target, for make visp_tutorials # ---------------------------------------------------------------------------- if(BUILD_TUTORIALS) add_custom_target(visp_tutorials) if(ENABLE_SOLUTION_FOLDERS) set_target_properties(visp_tutorials PROPERTIES FOLDER "extra") endif() endif() # ---------------------------------------------------------------------------- # Target building all ViSP modules # ---------------------------------------------------------------------------- add_custom_target(visp_modules) if(ENABLE_SOLUTION_FOLDERS) set_target_properties(visp_modules PROPERTIES FOLDER "extra") endif() # ---------------------------------------------------------------------------- # Coverage # ---------------------------------------------------------------------------- if(BUILD_TESTS AND BUILD_COVERAGE) # needed for coverage find_program(GCOVR_COMMAND gcovr) find_program(LCOV_COMMAND lcov) find_program(GENHTML_COMMAND genhtml) if(GCOVR_COMMAND AND LCOV_COMMAND AND GENHTML_COMMAND) add_custom_target(visp_coverage # Cleanup lcov COMMAND ${LCOV_COMMAND} --zerocounters --directory . # Build COMMAND ${CMAKE_COMMAND} --build ${CMAKE_BINARY_DIR} --target all # Run tests COMMAND ${CMAKE_COMMAND} --build ${CMAKE_BINARY_DIR} --target test # Capturing lcov counters and generating report COMMAND ${LCOV_COMMAND} --directory . --capture --output-file visp-coverage.info COMMAND ${LCOV_COMMAND} --remove visp-coverage.info '/usr/*' --output-file visp-coverage.cleaned COMMAND ${GENHTML_COMMAND} -o coverage visp-coverage.cleaned --demangle-cpp --num-spaces 2 --sort --title "ViSP coverage test" --function-coverage --legend COMMAND ${CMAKE_COMMAND} -E remove visp-coverage.info visp-coverage.cleaned COMMAND ${GCOVR_COMMAND} --xml --root=${CMAKE_SOURCE_DIR} -o coverage.xml WORKING_DIRECTORY ${CMAKE_BINARY_DIR} COMMENT "Run code coverage" ) endif() endif() visp-3.0.1/cmake/VISPGenerateConfig.cmake000066400000000000000000000155301304511007300201360ustar00rootroot00000000000000############################################################################# # # This file is part of the ViSP software. # Copyright (C) 2005 - 2017 by Inria. All rights reserved. # # This software is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public License # ("GPL") version 2 as published by the Free Software Foundation. # See the file LICENSE.txt at the root directory of this source # distribution for additional information about the GNU GPL. # # For using ViSP with software that can not be combined with the GNU # GPL, please contact Inria about acquiring a ViSP Professional # Edition License. # # See http://visp.inria.fr for more information. # # This software was developed at: # Inria Rennes - Bretagne Atlantique # Campus Universitaire de Beaulieu # 35042 Rennes Cedex # France # # If you have questions regarding the use of this file, please contact # Inria at visp@inria.fr # # This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE # WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. # # Description: # This file generates the ViSPConfig.cmake file: # Part 1/3: ${BIN_DIR}/VISPConfig.cmake -> For use *without* "make install" # Part 2/3: ${BIN_DIR}/unix-install/VISPConfig.cmake -> For use with "make install" # Part 3/3: ${BIN_DIR}/win-install/VISPConfig.cmake -> For use within binary installers/packages # # Authors: # Fabien Spindler # ############################################################################# # Macro that returns the relative path to go from a child folder to the parent folder # input: path_to_child # output: path_to_parent, the relative path to go from path_to_child to parent # example: if input =lib/x86_64-linux-gnu, then output=../.. macro(get_path_to_parent path_to_child path_to_parent) set(${path_to_parent} "") set(input_ "${path_to_child}") while(input_) if(input_) set(${path_to_parent} "${${path_to_parent}}../") endif() get_filename_component(input_ "${input_}" PATH) endwhile(input_) endmacro() # Here we determine the relative path from ./${VISP_LIB_INSTALL_PATH} to its parent folder # if VISP_LIB_INSTALL_PATH=lib, then VISP_INSTALL_LIBDIR_TO_PARENT=../ # if VISP_LIB_INSTALL_PATH=lib/x86_64-linux-gnu, then VISP_INSTALL_LIBDIR_TO_PARENT=../.. get_path_to_parent(${VISP_LIB_INSTALL_PATH} VISP_INSTALL_LIBDIR_TO_PARENT) #build list of modules available for the ViSP user set(VISP_LIB_COMPONENTS "") foreach(m ${VISP_MODULES_PUBLIC}) list(INSERT VISP_LIB_COMPONENTS 0 ${${m}_MODULE_DEPS_OPT} ${m}) endforeach() vp_list_unique(VISP_LIB_COMPONENTS) #message("VISP_LIB_COMPONENTS: ${VISP_LIB_COMPONENTS}") set(VISP_MODULES_CONFIGCMAKE ${VISP_LIB_COMPONENTS}) vp_list_filterout(VISP_LIB_COMPONENTS "^visp_") if(VISP_LIB_COMPONENTS) list(REMOVE_ITEM VISP_MODULES_CONFIGCMAKE ${VISP_LIB_COMPONENTS}) endif() # ------------------------------------------------------------------------------------------- # Part 1/3: ${BIN_DIR}/VISPConfig.cmake -> For use *without* "make install" # ------------------------------------------------------------------------------------------- # Export the library export(TARGETS ${VISPModules_TARGETS} FILE "${PROJECT_BINARY_DIR}/VISPModules.cmake") ## Update include dirs set(VISP_INCLUDE_DIRS_CONFIGCMAKE "${VISP_INCLUDE_DIR}") foreach(m ${VISP_MODULES_BUILD}) if(EXISTS "${VISP_MODULE_${m}_LOCATION}/include") list(APPEND VISP_INCLUDE_DIRS_CONFIGCMAKE "${VISP_MODULE_${m}_LOCATION}/include") endif() list(APPEND VISP_INCLUDE_DIRS_CONFIGCMAKE ${VISP_MODULE_${m}_INC_DEPS}) endforeach() vp_list_unique(VISP_INCLUDE_DIRS_CONFIGCMAKE) configure_file( cmake/templates/VISPConfig.cmake.in ${VISP_BINARY_DIR}/VISPConfig.cmake IMMEDIATE @ONLY ) configure_file( cmake/templates/VISPConfigVersion.cmake.in ${VISP_BINARY_DIR}/VISPConfigVersion.cmake IMMEDIATE @ONLY ) configure_file( cmake/VISPUse.cmake.in ${VISP_BINARY_DIR}/VISPUse.cmake IMMEDIATE @ONLY ) # -------------------------------------------------------------------------------------------- # Part 2/3: ${BIN_DIR}/unix-install/VISPConfig.cmake -> For use *with* "make install" # ------------------------------------------------------------------------------------------- if(UNIX) set(VISP_INCLUDE_DIRS_CONFIGCMAKE "\${VISP_INSTALL_PATH}/${VISP_INC_INSTALL_PATH}") foreach(m ${VISP_MODULES_BUILD}) list(APPEND VISP_INCLUDE_DIRS_CONFIGCMAKE ${VISP_MODULE_${m}_INC_DEPS}) endforeach() vp_list_unique(VISP_INCLUDE_DIRS_CONFIGCMAKE) configure_file( cmake/templates/VISPConfig.cmake.in ${VISP_BINARY_DIR}/unix-install/VISPConfig.cmake IMMEDIATE @ONLY ) configure_file( cmake/templates/VISPConfigVersion.cmake.in ${VISP_BINARY_DIR}/unix-install/VISPConfigVersion.cmake IMMEDIATE @ONLY ) configure_file( cmake/VISPUse.cmake.in ${VISP_BINARY_DIR}/unix-install/VISPUse.cmake IMMEDIATE @ONLY ) install(FILES ${VISP_BINARY_DIR}/unix-install/VISPConfig.cmake ${VISP_BINARY_DIR}/unix-install/VISPConfigVersion.cmake ${VISP_BINARY_DIR}/unix-install/VISPUse.cmake DESTINATION "${VISP_LIB_INSTALL_PATH}/cmake/visp" PERMISSIONS OWNER_READ GROUP_READ WORLD_READ OWNER_WRITE COMPONENT dev ) # Install the export set for use with the install-tree install(EXPORT VISPModules FILE VISPModules.cmake DESTINATION "${VISP_LIB_INSTALL_PATH}/cmake/visp" COMPONENT dev ) endif() # -------------------------------------------------------------------------------------------- # Part 3/3: ${BIN_DIR}/win-install/VISPConfig.cmake -> For use within binary installers/packages # -------------------------------------------------------------------------------------------- if(WIN32) set(VISP_INCLUDE_DIRS_CONFIGCMAKE "\${VISP_CONFIG_PATH}/${VISP_INC_INSTALL_PATH}") foreach(m ${VISP_MODULES_BUILD}) list(APPEND VISP_INCLUDE_DIRS_CONFIGCMAKE ${VISP_MODULE_${m}_INC_DEPS}) endforeach() vp_list_unique(VISP_INCLUDE_DIRS_CONFIGCMAKE) configure_file( cmake/templates/VISPConfig.cmake.in ${VISP_BINARY_DIR}/win-install/VISPConfig.cmake IMMEDIATE @ONLY ) configure_file( cmake/templates/VISPConfigVersion.cmake.in ${VISP_BINARY_DIR}/win-install/VISPConfigVersion.cmake IMMEDIATE @ONLY ) configure_file( cmake/VISPUse.cmake.in ${VISP_BINARY_DIR}/win-install/VISPUse.cmake IMMEDIATE @ONLY ) install(FILES "${CMAKE_BINARY_DIR}/win-install/ViSPConfig.cmake" "${CMAKE_BINARY_DIR}/win-install/ViSPUse.cmake" DESTINATION "${VISP_LIB_INSTALL_PATH}" COMPONENT dev) install(EXPORT VISPModules DESTINATION "${VISP_LIB_INSTALL_PATH}" FILE VISPModules.cmake COMPONENT dev) install(FILES "cmake/VISPConfig.cmake" "${VISP_BINARY_DIR}/win-install/VISPConfigVersion.cmake" DESTINATION "${CMAKE_INSTALL_PREFIX}" PERMISSIONS OWNER_READ GROUP_READ WORLD_READ OWNER_WRITE COMPONENT dev ) endif() visp-3.0.1/cmake/VISPGenerateHeaders.cmake000066400000000000000000000112271304511007300203030ustar00rootroot00000000000000############################################################################# # # This file is part of the ViSP software. # Copyright (C) 2005 - 2017 by Inria. All rights reserved. # # This software is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public License # ("GPL") version 2 as published by the Free Software Foundation. # See the file LICENSE.txt at the root directory of this source # distribution for additional information about the GNU GPL. # # For using ViSP with software that can not be combined with the GNU # GPL, please contact Inria about acquiring a ViSP Professional # Edition License. # # See http://visp.inria.fr for more information. # # This software was developed at: # Inria Rennes - Bretagne Atlantique # Campus Universitaire de Beaulieu # 35042 Rennes Cedex # France # # If you have questions regarding the use of this file, please contact # Inria at visp@inria.fr # # This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE # WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. # # Authors: # Fabien Spindler # ############################################################################# # platform-specific config file configure_file("${VISP_SOURCE_DIR}/cmake/templates/vpConfig.h.in" "${VISP_INCLUDE_DIR}/visp3/core/vpConfig.h") install(FILES "${VISP_INCLUDE_DIR}/visp3/core/vpConfig.h" DESTINATION ${VISP_INC_INSTALL_PATH}/visp3/core COMPONENT dev ) # ---------------------------------------------------------------------------- # visp_modules.h that contains all the build modules defines # ---------------------------------------------------------------------------- set(VISP_MODULE_DEFINITIONS_CONFIGMAKE "#ifndef __visp_modules_h__\n#define __visp_modules_h__\n\n") set(VISP_MOD_LIST ${VISP_MODULES_PUBLIC}) vp_list_sort(VISP_MOD_LIST) foreach(m ${VISP_MOD_LIST}) if(m MATCHES "^visp_") string(REGEX REPLACE "^visp_" "" m "${m}") endif() string(TOUPPER "${m}" m) set(VISP_MODULE_DEFINITIONS_CONFIGMAKE "${VISP_MODULE_DEFINITIONS_CONFIGMAKE}#define VISP_HAVE_MODULE_${m}\n") endforeach() set(VISP_MODULE_DEFINITIONS_CONFIGMAKE "${VISP_MODULE_DEFINITIONS_CONFIGMAKE}\n#endif\n") configure_file("${VISP_SOURCE_DIR}/cmake/templates/visp_modules.h.in" "${VISP_INCLUDE_DIR}/visp3/visp_modules.h") install(FILES "${VISP_INCLUDE_DIR}/visp3/visp_modules.h" DESTINATION ${VISP_INC_INSTALL_PATH}/visp3 COMPONENT dev ) # ---------------------------------------------------------------------------- # visp.h that includes all build modules headers # Note: for other meta headers visp3/visp_.h see vp_create_global_module_header() macro # ---------------------------------------------------------------------------- set(VISP_ALL_HEADERS_CONFIGMAKE "#ifndef __visp_h__\n#define __visp_h__\n\n") set(VISP_ALL_HEADERS_CONFIGMAKE "${VISP_ALL_HEADERS_CONFIGMAKE}// File that defines which modules where included during ViSP build\n") set(VISP_ALL_HEADERS_CONFIGMAKE "${VISP_ALL_HEADERS_CONFIGMAKE}// It contains the defines of the correct VISP_HAVE_MODULE_ values\n") set(VISP_ALL_HEADERS_CONFIGMAKE "${VISP_ALL_HEADERS_CONFIGMAKE}#include \n\n") set(VISP_ALL_HEADERS_CONFIGMAKE "${VISP_ALL_HEADERS_CONFIGMAKE}// Then the list of defines is checked to include the correct headers\n") set(VISP_MOD_LIST ${VISP_MODULES_BUILD} ${VISP_MODULES_DISABLED_USER} ${VISP_MODULES_DISABLED_AUTO} ${VISP_MODULES_DISABLED_FORCE}) vp_list_sort(VISP_MOD_LIST) foreach(m ${VISP_MOD_LIST}) if(m MATCHES "^visp_") string(REGEX REPLACE "^visp_" "" m "${m}") endif() string(TOUPPER "${m}" M) if(m MATCHES "core") set(VISP_ALL_HEADERS_CONFIGMAKE "${VISP_ALL_HEADERS_CONFIGMAKE}// Core library is always included; without no ViSP functionality available\n") set(VISP_ALL_HEADERS_CONFIGMAKE "${VISP_ALL_HEADERS_CONFIGMAKE}#include \n\n") else() set(VISP_ALL_HEADERS_CONFIGMAKE "${VISP_ALL_HEADERS_CONFIGMAKE}#ifdef VISP_HAVE_MODULE_${M}\n# include \n#endif\n\n") endif() endforeach() set(VISP_ALL_HEADERS_CONFIGMAKE "${VISP_ALL_HEADERS_CONFIGMAKE}#endif\n") configure_file("${VISP_SOURCE_DIR}/cmake/templates/visp.h.in" "${VISP_INCLUDE_DIR}/visp3/visp.h") install(FILES "${VISP_INCLUDE_DIR}/visp3/visp.h" DESTINATION ${VISP_INC_INSTALL_PATH}/visp3 COMPONENT dev ) # ---------------------------------------------------------------------------- # install old headers to keep compat with dev based on ViSP 2.x releases # ---------------------------------------------------------------------------- file(GLOB old_hdrs "${VISP_INCLUDE_DIR}/visp/*.h") install(FILES ${old_hdrs} DESTINATION ${VISP_INC_INSTALL_PATH}/visp COMPONENT dev ) visp-3.0.1/cmake/VISPGenerateInfoPlist.cmake000066400000000000000000000005311304511007300206330ustar00rootroot00000000000000set(VISP_APPLE_BUNDLE_NAME "ViSP") set(VISP_APPLE_BUNDLE_ID "org.visp") if(IOS) configure_file("${VISP_SOURCE_DIR}/platforms/ios/Info.plist.in" "${CMAKE_BINARY_DIR}/ios/Info.plist") elseif(APPLE) configure_file("${VISP_SOURCE_DIR}/platforms/osx/Info.plist.in" "${CMAKE_BINARY_DIR}/osx/Info.plist") endif() visp-3.0.1/cmake/VISPGeneratePkgConfigScript.cmake000066400000000000000000000362301304511007300217650ustar00rootroot00000000000000############################################################################# # # This file is part of the ViSP software. # Copyright (C) 2005 - 2017 by Inria. All rights reserved. # # This software is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public License # ("GPL") version 2 as published by the Free Software Foundation. # See the file LICENSE.txt at the root directory of this source # distribution for additional information about the GNU GPL. # # For using ViSP with software that can not be combined with the GNU # GPL, please contact Inria about acquiring a ViSP Professional # Edition License. # # See http://visp.inria.fr for more information. # # This software was developed at: # Inria Rennes - Bretagne Atlantique # Campus Universitaire de Beaulieu # 35042 Rennes Cedex # France # # If you have questions regarding the use of this file, please contact # Inria at visp@inria.fr # # This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE # WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. # # Description: # This file generates the ViSP library config shell scripts: # - visp-config in /bin from visp-config.in # - visp-config in /install from visp-config.install.in # When make install, this file is copied in /bin # - visp.pc in /install from visp.pc.in # When make install, this file is copied in /lib/pkgconfig # # Authors: # Fabien Spindler # ############################################################################# if(MINGW) # not implemented yet return() endif() if(UNIX) ####################################################################### # # for Unix platforms: Linux, OSX # ####################################################################### set(FILE_VISP_CONFIG_SCRIPT_IN "cmake/templates/visp-config.in") set(FILE_VISP_CONFIG_SCRIPT "${BINARY_OUTPUT_PATH}/visp-config") set(FILE_VISP_CONFIG_SCRIPT_INSTALL_IN "cmake/templates/visp-config.install.in") set(FILE_VISP_CONFIG_SCRIPT_INSTALL "${VISP_BINARY_DIR}/unix-install/visp-config") set(FILE_VISP_CONFIG_PC_INSTALL_IN "cmake/templates/visp.pc.in") set(FILE_VISP_CONFIG_PC_INSTALL "${VISP_BINARY_DIR}/unix-install/visp.pc") #--------------------------------------------------------------------- # Updates VISP_CONFIG_SCRIPT_PREFIX #---------------------------------------------------------------------- set(VISP_CONFIG_SCRIPT_PREFIX "${CMAKE_INSTALL_PREFIX}") #--------------------------------------------------------------------- # Updates vars needed to update VISP_CONFIG_CFLAGS_SCRIPT # 1/ For usage with the build tree (where location of the //include should be added) # VISP_CONFIG_CFLAGS_SCRIPT = VISP_CONFIG_CFLAGS + VISP_CONFIG_CFLAGS_DEPS + VISP_CONFIG_CFLAGS_SRC_TREE # 2/ For usage with the install tree # VISP_CONFIG_CFLAGS_SCRIPT = VISP_CONFIG_CFLAGS + VISP_CONFIG_CFLAGS_DEPS #---------------------------------------------------------------------- if(BUILD_TEST_COVERAGE) # Add build options for test coverage. Currently coverage is only supported # on gcc compiler # Because using -fprofile-arcs with shared lib can cause problems like: # hidden symbol `__bb_init_func', we add this option only for static # library build list(APPEND VISP_CONFIG_CFLAGS "-ftest-coverage") list(APPEND VISP_CONFIG_CFLAGS "-fprofile-arcs") endif() # Propagate cxx11 compiler option if enabled during ViSP build if(VISP_HAVE_CPP11_COMPATIBILITY) list(APPEND VISP_CONFIG_CFLAGS ${CPP11_CXX_FLAGS}) endif() # Propagate openmp compiler option if enabled during ViSP build if(VISP_HAVE_OPENMP) list(APPEND VISP_CONFIG_CFLAGS ${OpenMP_CXX_FLAGS}) endif() # include ViSP own include dir set(VISP_CONFIG_CFLAGS_SRC_TREE "-I$PREFIX/${VISP_INC_INSTALL_PATH}") foreach(m ${VISP_MODULES_BUILD}) if(EXISTS "${VISP_MODULE_${m}_LOCATION}/include") list(APPEND VISP_CONFIG_CFLAGS_SRC_TREE "-I${VISP_MODULE_${m}_LOCATION}/include") endif() endforeach() foreach(m ${VISP_MODULES_BUILD}) foreach(inc ${VISP_MODULE_${m}_INC_DEPS}) list(APPEND VISP_CONFIG_CFLAGS_DEPS "-I${inc}") endforeach() endforeach() #--------------------------------------------------------------------- # Updates vars needed to update VISP_CONFIG_LIBS_SCRIPT #---------------------------------------------------------------------- # prepend with ViSP own modules first set(VISP_CONFIG_LIBS_SCRIPT "") foreach(m ${VISP_MODULES_BUILD}) # need to be improved if(POLICY CMP0026) cmake_policy(PUSH) cmake_policy(SET CMP0026 OLD) get_target_property(m_libpath ${m} LOCATION_Release) cmake_policy(POP) else() get_target_property(m_libpath ${m} LOCATION_Release) endif() get_filename_component(m_libname "${m_libpath}" NAME) list(APPEND VISP_CONFIG_LIBS_SCRIPT "$PREFIX/${VISP_LIB_INSTALL_PATH}/${m_libname}") endforeach() # append deps foreach(m ${VISP_MODULES_BUILD}) list(APPEND VISP_CONFIG_LIBS_SCRIPT ${VISP_MODULE_${m}_LINK_DEPS}) endforeach() vp_list_unique(VISP_CONFIG_LIBS_SCRIPT) vp_list_filterout(VISP_CONFIG_LIBS_SCRIPT "debug") vp_list_filterout(VISP_CONFIG_LIBS_SCRIPT "optimized") # message("VISP_CONFIG_LIBS_SCRIPT: ${VISP_CONFIG_LIBS_SCRIPT}") # Format the string to suppress CMake separators ";" vp_list_remove_separator(VISP_CONFIG_LIBS_SCRIPT) set(VISP_ECHO_NO_NEWLINE_CHARACTER "") set(VISP_ECHO_NO_NEWLINE_OPTION "") if(APPLE) set(VISP_ECHO_NO_NEWLINE_CHARACTER "\\c") else() set(VISP_ECHO_NO_NEWLINE_OPTION "-n") endif() #--------------------------------------------------------------------- # Configure to create /bin/visp-config shell script # Updates VISP_CONFIG_CFLAGS_SCRIPT before #---------------------------------------------------------------------- set(VISP_CONFIG_CFLAGS_SCRIPT ${VISP_CONFIG_CFLAGS}) list(APPEND VISP_CONFIG_CFLAGS_SCRIPT ${VISP_CONFIG_CFLAGS_SRC_TREE}) list(APPEND VISP_CONFIG_CFLAGS_SCRIPT ${VISP_CONFIG_CFLAGS_DEPS}) vp_list_unique(VISP_CONFIG_CFLAGS_SCRIPT) # Format the string to suppress CMake separators ";" vp_list_remove_separator(VISP_CONFIG_CFLAGS_SCRIPT) configure_file(${FILE_VISP_CONFIG_SCRIPT_IN} ${FILE_VISP_CONFIG_SCRIPT}) #--------------------------------------------------------------------- # Configure to create /unix-install/visp-config shell script # that will call visp.pc #---------------------------------------------------------------------- configure_file(${FILE_VISP_CONFIG_SCRIPT_INSTALL_IN} ${FILE_VISP_CONFIG_SCRIPT_INSTALL}) #--------------------------------------------------------------------- # Updates the /install/visp.pc pkg-config file # Updates VISP_CONFIG_CFLAGS_PC (for libvisp.pc used by pkg-config) # Updates VISP_CONFIG_LIBS_PC (for libvisp.pc used by pkg-config) #---------------------------------------------------------------------- set(exec_prefix "\${prefix}") set(includedir "\${prefix}/${VISP_INC_INSTALL_PATH}") set(libdir "\${prefix}/${VISP_LIB_INSTALL_PATH}") # prepend with ViSP own include dir set(VISP_CONFIG_CFLAGS_PC "-I\${includedir}") list(APPEND VISP_CONFIG_CFLAGS_PC ${VISP_CONFIG_CFLAGS}) list(APPEND VISP_CONFIG_CFLAGS_PC ${VISP_CONFIG_CFLAGS_DEPS}) vp_list_unique(VISP_CONFIG_CFLAGS_PC) # Format the string to suppress CMake separators ";" vp_list_remove_separator(VISP_CONFIG_CFLAGS_PC) # prepend with ViSP own modules first set(VISP_CONFIG_LIBS_PC "") foreach(m ${VISP_MODULES_BUILD}) # need to be improved if(POLICY CMP0026) cmake_policy(PUSH) cmake_policy(SET CMP0026 OLD) get_target_property(m_libpath ${m} LOCATION_Release) cmake_policy(POP) else() get_target_property(m_libpath ${m} LOCATION_Release) endif() get_filename_component(m_libname "${m_libpath}" NAME) list(APPEND VISP_CONFIG_LIBS_PC "\${libdir}/${m_libname}") endforeach() # append deps foreach(m ${VISP_MODULES_BUILD}) list(APPEND VISP_CONFIG_LIBS_PC ${VISP_MODULE_${m}_LINK_DEPS}) endforeach() vp_list_filterout(VISP_CONFIG_LIBS_PC "optimized") vp_list_filterout(VISP_CONFIG_LIBS_PC "debug") vp_list_remove_separator(VISP_CONFIG_LIBS_PC) # message("VISP_CONFIG_LIBS_PC: ${VISP_CONFIG_LIBS_PC}") configure_file(${FILE_VISP_CONFIG_PC_INSTALL_IN} ${FILE_VISP_CONFIG_PC_INSTALL}) else() ####################################################################### # # for windows platforms # ####################################################################### set(FILE_VISP_CONFIG_SCRIPT_IN "cmake/templates/visp-config.bat.in") set(FILE_VISP_CONFIG_SCRIPT "${BINARY_OUTPUT_PATH}/visp-config.bat") set(FILE_VISP_CONFIG_SCRIPT_INSTALL_IN "cmake/templates/visp-config.bat.in") set(FILE_VISP_CONFIG_SCRIPT_INSTALL "${VISP_BINARY_DIR}/win-install/visp-config-${VISP_ARCH}-${VISP_RUNTIME}.bat") #--------------------------------------------------------------------- # Updates VISP_CONFIG_SCRIPT_PREFIX #---------------------------------------------------------------------- set(VISP_CONFIG_SCRIPT_PREFIX "${CMAKE_INSTALL_PREFIX}") #--------------------------------------------------------------------- # Updates VISP_CONFIG_SCRIPT_DEF #---------------------------------------------------------------------- set(VISP_CONFIG_SCRIPT_DEFS "") set(VISP_OPENMP_SUPPORT "no") if(VISP_HAVE_OPENMP) set(VISP_CONFIG_SCRIPT_DEFS "${OpenMP_CXX_FLAGS}") set(VISP_OPENMP_SUPPORT "yes") endif() if(VISP_HAVE_CPP11_COMPATIBILITY) set(VISP_CONFIG_SCRIPT_DEFS "${CPP11_CXX_FLAGS}, ${VISP_CONFIG_SCRIPT_DEFS}") endif() #--------------------------------------------------------------------- # Updates VISP_CONFIG_SCRIPT_INC # 1/ For usage with the build tree (where location of the //include should be added) # VISP_CONFIG_SCRIPT_INC = VISP_CONFIG_SCRIPT_INC_BUILD + VISP_CONFIG_SCRIPT_INC_DEPS # 2/ For usage with the install tree # VISP_CONFIG_SCRIPT_INC = VISP_CONFIG_SCRIPT_INC_BUILD + VISP_CONFIG_SCRIPT_INC_SRC_TREE + VISP_CONFIG_SCRIPT_INC_DEPS #---------------------------------------------------------------------- set(VISP_CONFIG_SCRIPT_INC_BUILD "%PREFIX%/${VISP_INC_INSTALL_PATH}") set(VISP_CONFIG_SCRIPT_INC_SRC_TREE "") foreach(m ${VISP_MODULES_BUILD}) if(EXISTS "${VISP_MODULE_${m}_LOCATION}/include") list(APPEND VISP_CONFIG_SCRIPT_INC_SRC_TREE "${VISP_MODULE_${m}_LOCATION}/include") endif() endforeach() set(VISP_CONFIG_SCRIPT_INC_DEPS "") foreach(m ${VISP_MODULES_BUILD}) foreach(inc ${VISP_MODULE_${m}_INC_DEPS}) list(APPEND VISP_CONFIG_SCRIPT_INC_DEPS "${inc}") endforeach() endforeach() #--------------------------------------------------------------------- # Updates VISP_CONFIG_SCRIPT_LIBDIR # 1/ For usage with the build tree # 2/ For usage with the install tree # # and updates VISP_CONFIG_SCRIPT_LIBS_${config} #---------------------------------------------------------------------- # prepend with ViSP own modules first set(TMP_SCRIPT_LIBS_DBG "") set(TMP_SCRIPT_LIBS_OPT "") foreach(m ${VISP_MODULES_BUILD}) # need to be improved if(POLICY CMP0026) cmake_policy(PUSH) cmake_policy(SET CMP0026 OLD) get_target_property(m_libpath ${m} LOCATION_Release) cmake_policy(POP) else() get_target_property(m_libpath ${m} LOCATION_Release) endif() get_filename_component(m_libname "${m_libpath}" NAME_WE) list(APPEND TMP_SCRIPT_LIBS_DBG "${m_libname}${VISP_DEBUG_POSTFIX}.lib") list(APPEND TMP_SCRIPT_LIBS_OPT "${m_libname}.lib") endforeach() # append deps set(TMP_SCRIPT_LIBS_DEPS "") foreach(m ${VISP_MODULES_BUILD}) list(APPEND TMP_SCRIPT_LIBS_DEPS ${VISP_MODULE_${m}_LINK_DEPS}) endforeach() vp_list_unique(TMP_SCRIPT_LIBS_DEPS) set(TMP_IS_DBG FALSE) set(TMP_IS_OPT FALSE) foreach(lib ${TMP_SCRIPT_LIBS_DEPS}) if("${lib}" MATCHES "[d][e][b][u][g]") set(TMP_IS_DBG TRUE) elseif("${lib}" MATCHES "[o][p][t][i][m][i][z][e][d]") set(TMP_IS_OPT TRUE) else() # Get the library name get_filename_component(libname ${lib} NAME) if("${libname}" MATCHES ".+[.][l][i][b]" OR "${libname}" MATCHES ".+[.][L][i][b]") #MESSAGE("${libname} matches .lib or .Lib") else() # We need to add .lib suffix #MESSAGE("For ${libname} we add .lib suffix") set(libname "${libname}.lib") endif() # Get the library path get_filename_component(libpath ${lib} PATH) list(APPEND VISP_CONFIG_SCRIPT_LIBDIR_ "${libpath}") if(TMP_IS_DBG) set(TMP_IS_DBG FALSE) list(APPEND TMP_SCRIPT_LIBS_DBG ${libname}) elseif(TMP_IS_OPT) set(TMP_IS_OPT FALSE) list(APPEND TMP_SCRIPT_LIBS_OPT ${libname}) else() list(APPEND TMP_SCRIPT_LIBS_DBG ${libname}) list(APPEND TMP_SCRIPT_LIBS_OPT ${libname}) endif() endif() endforeach(lib) vp_list_unique(TMP_SCRIPT_LIBS_DBG) vp_list_unique(TMP_SCRIPT_LIBS_OPT) # Format the string set(VISP_CONFIG_SCRIPT_LIBS_DEBUG "${TMP_SCRIPT_LIBS_DBG}") set(VISP_CONFIG_SCRIPT_LIBS_OPTIMIZED "${TMP_SCRIPT_LIBS_OPT}") # Format the string string(REGEX REPLACE "lib/Release" "lib/$(ConfigurationName)" VISP_CONFIG_SCRIPT_LIBDIR_ "${VISP_CONFIG_SCRIPT_LIBDIR_}") string(REGEX REPLACE "lib/Debug" "lib/$(ConfigurationName)" VISP_CONFIG_SCRIPT_LIBDIR_ "${VISP_CONFIG_SCRIPT_LIBDIR_}") # 1/ For usage with the build tree set(VISP_CONFIG_SCRIPT_INC "${VISP_CONFIG_SCRIPT_INC_BUILD}") list(APPEND VISP_CONFIG_SCRIPT_INC ${VISP_CONFIG_SCRIPT_INC_SRC_TREE}) list(APPEND VISP_CONFIG_SCRIPT_INC ${VISP_CONFIG_SCRIPT_INC_DEPS}) vp_list_unique(VISP_CONFIG_SCRIPT_INC) set(VISP_CONFIG_SCRIPT_LIBDIR "%PREFIX%/lib") list(APPEND VISP_CONFIG_SCRIPT_LIBDIR "%PREFIX%/lib/$(ConfigurationName)") list(APPEND VISP_CONFIG_SCRIPT_LIBDIR ${VISP_CONFIG_SCRIPT_LIBDIR_}) list(REMOVE_DUPLICATES VISP_CONFIG_SCRIPT_LIBDIR) configure_file(${FILE_VISP_CONFIG_SCRIPT_IN} ${FILE_VISP_CONFIG_SCRIPT}) # 2/ For usage with the install tree set(VISP_CONFIG_SCRIPT_INC "${VISP_CONFIG_SCRIPT_INC_BUILD}") list(APPEND VISP_CONFIG_SCRIPT_INC ${VISP_CONFIG_SCRIPT_INC_DEPS}) vp_list_unique(VISP_CONFIG_SCRIPT_INC) set(VISP_CONFIG_SCRIPT_LIBDIR "%PREFIX%/${VISP_ARCH}/${VISP_RUNTIME}/lib") list(APPEND VISP_CONFIG_SCRIPT_LIBDIR ${VISP_CONFIG_SCRIPT_LIBDIR_}) list(REMOVE_DUPLICATES VISP_CONFIG_SCRIPT_LIBDIR) configure_file(${FILE_VISP_CONFIG_SCRIPT_INSTALL_IN} ${FILE_VISP_CONFIG_SCRIPT_INSTALL}) endif() #---------------------------------------------------------------------- # customize install target #---------------------------------------------------------------------- # install rule for visp-config shell script install(FILES ${FILE_VISP_CONFIG_SCRIPT_INSTALL} DESTINATION ${VISP_BIN_INSTALL_PATH} PERMISSIONS OWNER_READ GROUP_READ WORLD_READ OWNER_EXECUTE GROUP_EXECUTE WORLD_EXECUTE OWNER_WRITE COMPONENT dev ) # install rule for visp.pc pkg-config file if(UNIX) install(FILES ${FILE_VISP_CONFIG_PC_INSTALL} DESTINATION ${VISP_LIB_INSTALL_PATH}/pkgconfig PERMISSIONS OWNER_READ GROUP_READ WORLD_READ OWNER_WRITE COMPONENT dev ) else() # not implemented yet endif() visp-3.0.1/cmake/VISPModule.cmake000066400000000000000000001236151304511007300165070ustar00rootroot00000000000000############################################################################# # # This file is part of the ViSP software. # Copyright (C) 2005 - 2017 by Inria. All rights reserved. # # This software is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public License # ("GPL") version 2 as published by the Free Software Foundation. # See the file LICENSE.txt at the root directory of this source # distribution for additional information about the GNU GPL. # # For using ViSP with software that can not be combined with the GNU # GPL, please contact Inria about acquiring a ViSP Professional # Edition License. # # See http://visp.inria.fr for more information. # # This software was developed at: # Inria Rennes - Bretagne Atlantique # Campus Universitaire de Beaulieu # 35042 Rennes Cedex # France # # If you have questions regarding the use of this file, please contact # Inria at visp@inria.fr # # This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE # WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. # # Authors: # Fabien Spindler # ############################################################################# # Local variables (set for each module): # # name - short name in lower case i.e. core # the_module - full name in lower case i.e. visp_core # Global variables: # # VISP_MODULE_${the_module}_LOCATION # VISP_MODULE_${the_module}_BINARY_DIR # VISP_MODULE_${the_module}_DESCRIPTION # VISP_MODULE_${the_module}_CLASS - PUBLIC|INTERNAL|BINDINGS # VISP_MODULE_${the_module}_HEADERS # VISP_MODULE_${the_module}_SOURCES # VISP_MODULE_${the_module}_DEPS - final flattened set of module dependencies # VISP_MODULE_${the_module}_DEPS_TO_LINK - differs from above for world build only # VISP_MODULE_${the_module}_DEPS_EXT - non-module dependencies # VISP_MODULE_${the_module}_REQ_DEPS # VISP_MODULE_${the_module}_OPT_DEPS # VISP_MODULE_${the_module}_PRIVATE_REQ_DEPS - private module deps that are not exposed in interface # VISP_MODULE_${the_module}_PRIVATE_OPT_DEPS - private module deps that are not exposed in interface # VISP_MODULE_${the_module}_CHILDREN - list of submodules for compound modules (cmake >= 2.8.8) # HAVE_${the_module} - for fast check of module availability # To control the setup of the module you could also set: # the_description - text to be used as current module description # VISP_MODULE_TYPE - STATIC|SHARED - set to force override global settings for current module # BUILD_${the_module}_INIT - ON|OFF (default ON) - initial value for BUILD_${the_module} # VISP_MODULE_CHILDREN - list of submodules # The verbose template for ViSP module: # # vp_add_module(modname ) # vp_glob_module_sources(() # or glob them manually and vp_set_module_sources(...) # vp_module_include_directories() # vp_create_module() # # If module have no "extra" then you can define it in one line: # # vp_define_module(modname ) # clean flags for modules enabled on previous cmake run # this is necessary to correctly handle modules removal foreach(mod ${VISP_MODULES_BUILD} ${VISP_MODULES_DISABLED_USER} ${VISP_MODULES_DISABLED_AUTO} ${VISP_MODULES_DISABLED_FORCE}) if(HAVE_${mod}) unset(HAVE_${mod} CACHE) endif() unset(VISP_MODULE_${mod}_DEPS CACHE) unset(VISP_MODULE_${mod}_DEPS_EXT CACHE) unset(VISP_MODULE_${mod}_REQ_DEPS CACHE) unset(VISP_MODULE_${mod}_OPT_DEPS CACHE) unset(VISP_MODULE_${mod}_PRIVATE_REQ_DEPS CACHE) unset(VISP_MODULE_${mod}_PRIVATE_OPT_DEPS CACHE) unset(VISP_MODULE_${mod}_LINK_DEPS CACHE) unset(VISP_MODULE_${mod}_INC_DEPS CACHE) endforeach() # clean modules info which needs to be recalculated set(VISP_MODULES_PUBLIC "" CACHE INTERNAL "List of ViSP modules marked for export") set(VISP_MODULES_BUILD "" CACHE INTERNAL "List of ViSP modules included into the build") set(VISP_MODULES_DISABLED_USER "" CACHE INTERNAL "List of ViSP modules explicitly disabled by user") set(VISP_MODULES_DISABLED_AUTO "" CACHE INTERNAL "List of ViSP modules implicitly disabled due to dependencies") set(VISP_MODULES_DISABLED_FORCE "" CACHE INTERNAL "List of ViSP modules which can not be build in current configuration") # adds dependencies to ViSP module # Usage: # add_dependencies(visp_ [REQUIRED] [] [OPTIONAL ]) # Notes: # * - can include full names of modules or full pathes to shared/static libraries or cmake targets macro(vp_add_dependencies full_modname) vp_debug_message("vp_add_dependencies(" ${full_modname} ${ARGN} ")") #we don't clean the dependencies here to allow this macro several times for every module foreach(d "REQUIRED" ${ARGN}) if(d STREQUAL "REQUIRED") set(__depsvar VISP_MODULE_${full_modname}_REQ_DEPS) elseif(d STREQUAL "OPTIONAL") set(__depsvar VISP_MODULE_${full_modname}_OPT_DEPS) elseif(d STREQUAL "PRIVATE_REQUIRED") set(__depsvar VISP_MODULE_${full_modname}_PRIVATE_REQ_DEPS) elseif(d STREQUAL "PRIVATE_OPTIONAL") set(__depsvar VISP_MODULE_${full_modname}_PRIVATE_OPT_DEPS) else() list(APPEND ${__depsvar} "${d}") endif() endforeach() unset(__depsvar) vp_list_unique(VISP_MODULE_${full_modname}_REQ_DEPS) vp_list_unique(VISP_MODULE_${full_modname}_OPT_DEPS) vp_list_unique(VISP_MODULE_${full_modname}_PRIVATE_REQ_DEPS) vp_list_unique(VISP_MODULE_${full_modname}_PRIVATE_OPT_DEPS) set(VISP_MODULE_${full_modname}_REQ_DEPS ${VISP_MODULE_${full_modname}_REQ_DEPS} CACHE INTERNAL "Required dependencies of ${full_modname} module") set(VISP_MODULE_${full_modname}_OPT_DEPS ${VISP_MODULE_${full_modname}_OPT_DEPS} CACHE INTERNAL "Optional dependencies of ${full_modname} module") set(VISP_MODULE_${full_modname}_PRIVATE_REQ_DEPS ${VISP_MODULE_${full_modname}_PRIVATE_REQ_DEPS} CACHE INTERNAL "Required private dependencies of ${full_modname} module") set(VISP_MODULE_${full_modname}_PRIVATE_OPT_DEPS ${VISP_MODULE_${full_modname}_PRIVATE_OPT_DEPS} CACHE INTERNAL "Optional private dependencies of ${full_modname} module") endmacro() # declare new ViSP module in current folder # Usage: # vp_add_module( [INTERNAL|BINDINGS] [REQUIRED] [] # [OPTIONAL ] # [PRIVATE_OPTIONAL|PRIVATE_REQUIRED] []) # Example: # vp_add_module(mymodule INTERNAL visp_core OPTIONAL visp_ar) macro(vp_add_module _name) vp_debug_message("vp_add_module(" ${_name} ${ARGN} ")") string(TOLOWER "${_name}" name) set(the_module visp_${name}) #message("Found module: ${the_module}") # the first pass - collect modules info, the second pass - create targets if(VISP_INITIAL_PASS) #guard agains redefinition if(";${VISP_MODULES_BUILD};${VISP_MODULES_DISABLED_USER};" MATCHES ";${the_module};") message(FATAL_ERROR "Redefinition of the ${the_module} module. at: ${CMAKE_CURRENT_SOURCE_DIR} previously defined at: ${VISP_MODULE_${the_module}_LOCATION} ") endif() if(NOT DEFINED the_description) set(the_description "The ViSP ${name} module") endif() if(NOT DEFINED BUILD_${the_module}_INIT) set(BUILD_${the_module}_INIT ON) endif() # create option to enable/disable this module option(BUILD_MODULE_${the_module} "Include ${the_module} module into ViSP build" ${BUILD_${the_module}_INIT}) # remember the module details set(VISP_MODULE_${the_module}_DESCRIPTION "${the_description}" CACHE INTERNAL "Brief description of ${the_module} module") set(VISP_MODULE_${the_module}_LOCATION "${CMAKE_CURRENT_SOURCE_DIR}" CACHE INTERNAL "Location of ${the_module} module sources") set(VISP_MODULE_${the_module}_LINK_DEPS "" CACHE INTERNAL "") set(VISP_MODULE_${the_module}_INC_DEPS "" CACHE INTERNAL "") # parse list of dependencies if("${ARGV1}" STREQUAL "INTERNAL" OR "${ARGV1}" STREQUAL "BINDINGS") set(VISP_MODULE_${the_module}_CLASS "${ARGV1}" CACHE INTERNAL "The category of the module") set(__vp_argn__ ${ARGN}) list(REMOVE_AT __vp_argn__ 0) vp_add_dependencies(${the_module} ${__vp_argn__}) unset(__vp_argn__) else() set(VISP_MODULE_${the_module}_CLASS "PUBLIC" CACHE INTERNAL "The category of the module") vp_add_dependencies(${the_module} ${ARGN}) if(BUILD_MODULE_${the_module}) set(VISP_MODULES_PUBLIC ${VISP_MODULES_PUBLIC} "${the_module}" CACHE INTERNAL "List of ViSP modules marked for export") endif() endif() if(BUILD_MODULE_${the_module}) set(VISP_MODULES_BUILD ${VISP_MODULES_BUILD} "${the_module}" CACHE INTERNAL "List of ViSP modules included into the build") else() set(VISP_MODULES_DISABLED_USER ${VISP_MODULES_DISABLED_USER} "${the_module}" CACHE INTERNAL "List of ViSP modules explicitly disabled by user") endif() # add submodules if any set(VISP_MODULE_${the_module}_CHILDREN "${VISP_MODULE_CHILDREN}" CACHE INTERNAL "List of ${the_module} submodules") # stop processing of current file return() else() set(VISP_MODULE_${the_module}_BINARY_DIR "${CMAKE_CURRENT_BINARY_DIR}" CACHE INTERNAL "") if(NOT BUILD_MODULE_${the_module}) return() # extra protection from redefinition endif() endif() endmacro() # remove visp_ prefix from name macro(vp_short_module_name name) if(${name} MATCHES "^visp_") string(REGEX REPLACE "^visp_" "" ${name} "${${name}}") endif() endmacro() # collect modules from specified directories # NB: must be called only once! macro(vp_glob_modules) if(DEFINED VISP_INITIAL_PASS) message(FATAL_ERROR "ViSP has already loaded its modules. Calling vp_glob_modules second time is not allowed.") endif() set(__directories_observed "") # collect modules set(VISP_INITIAL_PASS ON) set(VISP_PROCESSING_EXTRA_MODULES 0) foreach(__path ${ARGN}) if("${__path}" STREQUAL "EXTRA") set(VISP_PROCESSING_EXTRA_MODULES 1) else() get_filename_component(__path "${__path}" ABSOLUTE) list(FIND __directories_observed "${__path}" __pathIdx) if(__pathIdx GREATER -1) message(FATAL_ERROR "The directory ${__path} is observed for ViSP modules second time.") endif() list(APPEND __directories_observed "${__path}") file(GLOB __vpmodules RELATIVE "${__path}" "${__path}/*") vp_list_remove_item(__vpmodules ".git") if(VISP_PROCESSING_EXTRA_MODULES) # Remove tutorial, example, demo from potential contrib module list # They will be processed in visp/CMakeLists.txt vp_list_remove_item(__vpmodules "tutorial") vp_list_remove_item(__vpmodules "example") vp_list_remove_item(__vpmodules "demo") vp_list_remove_item(__vpmodules "doc") endif() # TODO: Improve the following if to put a macro instead of manually copying the code # Here we have 3 internal loops. The depth of the loop (3) could be a var set(__count 0) if(__vpmodules) list(SORT __vpmodules) foreach(mod ${__vpmodules}) get_filename_component(__modpath "${__path}/${mod}" ABSOLUTE) if(EXISTS "${__modpath}/CMakeLists.txt") list(FIND __directories_observed "${__modpath}" __pathIdx) if(__pathIdx GREATER -1) message(FATAL_ERROR "The module from ${__modpath} is already loaded.") endif() list(APPEND __directories_observed "${__modpath}") add_subdirectory("${__modpath}" "${CMAKE_CURRENT_BINARY_DIR}/${mod}/.${mod}") if (DEFINED VISP_MODULE_visp_${mod}_LOCATION) math(EXPR __count "${__count} + 1") endif() else() # modules in visp/tracker get_filename_component(__subpath "${__path}/${mod}" ABSOLUTE) file(GLOB __vpsubmodules RELATIVE "${__subpath}" "${__subpath}/*") if(__vpsubmodules) list(SORT __vpsubmodules) foreach(submod ${__vpsubmodules}) get_filename_component(__submodpath "${__subpath}/${submod}" ABSOLUTE) if(EXISTS "${__submodpath}/CMakeLists.txt") list(FIND __directories_observed "${__submodpath}" __pathIdx) if(__pathIdx GREATER -1) message(FATAL_ERROR "The module from ${__submodpath} is already loaded.") endif() list(APPEND __directories_observed "${__submodpath}") add_subdirectory("${__submodpath}" "${CMAKE_CURRENT_BINARY_DIR}/${submod}/.${submod}") if (DEFINED VISP_MODULE_visp_${submod}_LOCATION) math(EXPR __count "${__count} + 1") endif() else() # modules in ustk/image_processing get_filename_component(__subsubpath "${__subpath}/${submod}" ABSOLUTE) file(GLOB __vpsubsubmodules RELATIVE "${__subsubpath}" "${__subsubpath}/*") if(__vpsubsubmodules) list(SORT __vpsubsubmodules) foreach(subsubmod ${__vpsubsubmodules}) get_filename_component(__subsubmodpath "${__subsubpath}/${subsubmod}" ABSOLUTE) if(EXISTS "${__subsubmodpath}/CMakeLists.txt") list(FIND __directories_observed "${__subsubmodpath}" __pathIdx) if(__pathIdx GREATER -1) message(FATAL_ERROR "The module from ${__subsubmodpath} is already loaded.") endif() list(APPEND __directories_observed "${__subsubmodpath}") add_subdirectory("${__subsubmodpath}" "${CMAKE_CURRENT_BINARY_DIR}/${subsubmod}/.${subsubmod}") if (DEFINED VISP_MODULE_visp_${subsubmod}_LOCATION) math(EXPR __count "${__count} + 1") endif() else() # modules in ustk/image_processing/tracking get_filename_component(__subsubsubpath "${__subsubpath}/${subsubmod}" ABSOLUTE) file(GLOB __vpsubsubsubmodules RELATIVE "${__subsubsubpath}" "${__subsubsubpath}/*") if(__vpsubsubsubmodules) list(SORT __vpsubsubsubmodules) foreach(subsubsubmod ${__vpsubsubsubmodules}) get_filename_component(__subsubsubmodpath "${__subsubsubpath}/${subsubsubmod}" ABSOLUTE) if(EXISTS "${__subsubsubmodpath}/CMakeLists.txt") list(FIND __directories_observed "${__subsubsubmodpath}" __pathIdx) if(__pathIdx GREATER -1) message(FATAL_ERROR "The module from ${__subsubsubmodpath} is already loaded.") endif() list(APPEND __directories_observed "${__subsubsubmodpath}") add_subdirectory("${__subsubsubmodpath}" "${CMAKE_CURRENT_BINARY_DIR}/${subsubsubmod}/.${subsubsubmod}") if (DEFINED VISP_MODULE_visp_$subsubsubmod_LOCATION) math(EXPR __count "${__count} + 1") endif() endif() endforeach() endif() endif() endforeach() endif() endif() endforeach() endif() endif() endforeach() endif() endif() if (VISP_PROCESSING_EXTRA_MODULES AND ${__count} LESS 1) message(SEND_ERROR "No contrib modules found in folder: ${__path}\nPlease provide path to 'visp_contrib/modules' folder.") endif() endforeach() vp_clear_vars(__vpmodules __directories_observed __path __modpath __pathIdx __vpsubmodules __subpath __submodpath) # resolve dependencies __vp_resolve_dependencies() # create modules set(VISP_INITIAL_PASS OFF PARENT_SCOPE) set(VISP_INITIAL_PASS OFF) foreach(m ${VISP_MODULES_BUILD}) if(m MATCHES "^visp_") string(REGEX REPLACE "^visp_" "" __shortname "${m}") add_subdirectory("${VISP_MODULE_${m}_LOCATION}" "${CMAKE_CURRENT_BINARY_DIR}/${__shortname}") else() message(WARNING "Check module name: ${m}") add_subdirectory("${VISP_MODULE_${m}_LOCATION}" "${CMAKE_CURRENT_BINARY_DIR}/${m}") endif() endforeach() unset(__shortname) endmacro() # disables ViSP module with missing dependencies function(__vp_module_turn_off the_module) list(REMOVE_ITEM VISP_MODULES_DISABLED_AUTO "${the_module}") list(APPEND VISP_MODULES_DISABLED_AUTO "${the_module}") list(REMOVE_ITEM VISP_MODULES_BUILD "${the_module}") list(REMOVE_ITEM VISP_MODULES_PUBLIC "${the_module}") set(HAVE_${the_module} OFF CACHE INTERNAL "Module ${the_module} can not be built in current configuration") set(VISP_MODULES_DISABLED_AUTO "${VISP_MODULES_DISABLED_AUTO}" CACHE INTERNAL "") set(VISP_MODULES_BUILD "${VISP_MODULES_BUILD}" CACHE INTERNAL "") set(VISP_MODULES_PUBLIC "${VISP_MODULES_PUBLIC}" CACHE INTERNAL "") endfunction() # sort modules by dependencies function(__vp_sort_modules_by_deps __lst) vp_list_sort(${__lst}) set(input ${${__lst}}) set(result "") while(input) list(LENGTH input length_before) foreach (m ${input}) # check if module is in the result already if (NOT ";${result};" MATCHES ";${m};") # scan through module dependencies... set(unresolved_deps_found FALSE) foreach (d ${VISP_MODULE_${m}_CHILDREN} ${VISP_MODULE_${m}_DEPS}) # ... which are not already in the result and are enabled if ((NOT ";${result};" MATCHES ";${d};") AND HAVE_${d}) set(unresolved_deps_found TRUE) break() endif() endforeach() # chek if all dependencies for this module has been resolved if (NOT unresolved_deps_found) list(APPEND result ${m}) list(REMOVE_ITEM input ${m}) endif() endif() endforeach() list(LENGTH input length_after) # check for infinite loop or unresolved dependencies if (NOT length_after LESS length_before) message(WARNING "Unresolved dependencies or loop in dependency graph (${length_after})\n" "Processed ${__lst}: ${${__lst}}\n" "Good modules: ${result}\n" "Bad modules: ${input}" ) list(APPEND result ${input}) break() endif() endwhile() set(${__lst} "${result}" PARENT_SCOPE) endfunction() # resolve dependensies function(__vp_resolve_dependencies) foreach(m ${VISP_MODULES_DISABLED_USER}) set(HAVE_${m} OFF CACHE INTERNAL "Module ${m} will not be built in current configuration") endforeach() foreach(m ${VISP_MODULES_BUILD}) set(HAVE_${m} ON CACHE INTERNAL "Module ${m} will be built in current configuration") endforeach() # disable MODULES with unresolved dependencies set(has_changes ON) while(has_changes) set(has_changes OFF) foreach(m ${VISP_MODULES_BUILD}) set(__deps ${VISP_MODULE_${m}_REQ_DEPS} ${VISP_MODULE_${m}_PRIVATE_REQ_DEPS}) while(__deps) vp_list_pop_front(__deps d) string(TOLOWER "${d}" upper_d) if(NOT (HAVE_${d} OR HAVE_${upper_d} OR TARGET ${d} OR EXISTS ${d})) if(d MATCHES "^visp_") # TODO Remove this condition in the future and use HAVE_ variables only message(STATUS "Module ${m} disabled because ${d} dependency can't be resolved!") __vp_module_turn_off(${m}) set(has_changes ON) break() else() message(STATUS "Assume that non-module dependency is available: ${d} (for module ${m})") endif() endif() endwhile() endforeach() endwhile() # message(STATUS "List of active modules: ${VISP_MODULES_BUILD}") foreach(m ${VISP_MODULES_BUILD}) set(deps_${m} ${VISP_MODULE_${m}_REQ_DEPS}) foreach(d ${VISP_MODULE_${m}_OPT_DEPS}) if(NOT (";${deps_${m}};" MATCHES ";${d};")) if(HAVE_${d} OR TARGET ${d}) list(APPEND deps_${m} ${d}) endif() endif() endforeach() # message(STATUS "Initial deps of ${m} (w/o private deps): ${deps_${m}}") endforeach() # propagate dependencies set(has_changes ON) while(has_changes) set(has_changes OFF) foreach(m2 ${VISP_MODULES_BUILD}) # transfer deps of m2 to m foreach(m ${VISP_MODULES_BUILD}) if((NOT m STREQUAL m2) AND ";${deps_${m}};" MATCHES ";${m2};") foreach(d ${deps_${m2}}) if(NOT (";${deps_${m}};" MATCHES ";${d};")) # message(STATUS " Transfer dependency ${d} from ${m2} to ${m}") list(APPEND deps_${m} ${d}) set(has_changes ON) endif() endforeach() endif() endforeach() endforeach() endwhile() # process private deps #foreach(m ${VISP_MODULES_BUILD}) # foreach(d ${VISP_MODULE_${m}_PRIVATE_REQ_DEPS}) # if(NOT (";${deps_${m}};" MATCHES ";${d};")) # list(APPEND deps_${m} ${d}) # endif() # endforeach() # foreach(d ${VISP_MODULE_${m}_PRIVATE_OPT_DEPS}) # if(NOT (";${deps_${m}};" MATCHES ";${d};")) # if(HAVE_${d} OR TARGET ${d}) # list(APPEND deps_${m} ${d}) # endif() # endif() # endforeach() #endforeach() vp_list_sort(VISP_MODULES_BUILD) foreach(m ${VISP_MODULES_BUILD}) #message(STATUS "FULL deps of ${m}: ${deps_${m}}") set(VISP_MODULE_${m}_DEPS ${deps_${m}}) set(VISP_MODULE_${m}_DEPS_EXT ${deps_${m}}) vp_list_filterout(VISP_MODULE_${m}_DEPS_EXT "^visp_[^ ]+$") if(VISP_MODULE_${m}_DEPS_EXT AND VISP_MODULE_${m}_DEPS) list(REMOVE_ITEM VISP_MODULE_${m}_DEPS ${VISP_MODULE_${m}_DEPS_EXT}) endif() endforeach() # reorder dependencies foreach(m ${VISP_MODULES_BUILD}) __vp_sort_modules_by_deps(VISP_MODULE_${m}_DEPS) vp_list_sort(VISP_MODULE_${m}_DEPS_EXT) set(LINK_DEPS ${VISP_MODULE_${m}_DEPS}) set(VISP_MODULE_${m}_DEPS ${VISP_MODULE_${m}_DEPS} CACHE INTERNAL "Flattened dependencies of ${m} module") set(VISP_MODULE_${m}_DEPS_EXT ${VISP_MODULE_${m}_DEPS_EXT} CACHE INTERNAL "Extra dependencies of ${m} module") set(VISP_MODULE_${m}_DEPS_TO_LINK ${LINK_DEPS} CACHE INTERNAL "Flattened dependencies of ${m} module (for linker)") # message(STATUS " module deps of ${m}: ${VISP_MODULE_${m}_DEPS}") # message(STATUS " module link deps of ${m}: ${VISP_MODULE_${m}_DEPS_TO_LINK}") # message(STATUS " extra deps of ${m}: ${VISP_MODULE_${m}_DEPS_EXT}") # message(STATUS "") endforeach() __vp_sort_modules_by_deps(VISP_MODULES_BUILD) set(VISP_MODULES_PUBLIC ${VISP_MODULES_PUBLIC} CACHE INTERNAL "List of ViSP modules marked for export") set(VISP_MODULES_BUILD ${VISP_MODULES_BUILD} CACHE INTERNAL "List of ViSP modules included into the build") set(VISP_MODULES_DISABLED_AUTO ${VISP_MODULES_DISABLED_AUTO} CACHE INTERNAL "List of ViSP modules implicitly disabled due to dependencies") endfunction() # setup include paths for the list of passed modules macro(vp_target_include_modules target) foreach(d ${ARGN}) if(d MATCHES "^visp_" AND HAVE_${d}) if (EXISTS "${VISP_MODULE_${d}_LOCATION}/include") vp_target_include_directories(${target} "${VISP_MODULE_${d}_LOCATION}/include") # Work arround to be able to build the modules without INTERFACE_INCLUDE_DIRECTORIES # that was only introduces since CMake 2.8.12 if (CMAKE_VERSION VERSION_LESS 2.8.12) vp_target_include_directories(${target} "${VISP_MODULE_${d}_INC_DEPS}") endif() endif() elseif(EXISTS "${d}") # FS keep external deps inc set(VISP_MODULE_${the_module}_INC_DEPS "${VISP_MODULE_${the_module}_INC_DEPS};${d}" CACHE INTERNAL "") vp_target_include_directories(${target} "${d}") endif() endforeach() vp_list_unique(VISP_MODULE_${the_module}_INC_DEPS) endmacro() # setup include path for ViSP headers for specified module # vp_module_include_directories() macro(vp_module_include_directories) vp_target_include_directories(${the_module} "${VISP_MODULE_${the_module}_LOCATION}/include" "${VISP_MODULE_${the_module}_LOCATION}/src" "${CMAKE_CURRENT_BINARY_DIR}" # for precompiled headers ) vp_target_include_modules(${the_module} ${VISP_MODULE_${the_module}_DEPS} ${ARGN}) endmacro() # sets header and source files for the current module # NB: all files specified as headers will be installed # Usage: # vp_set_module_sources([HEADERS] [SOURCES] ) macro(vp_set_module_sources) vp_debug_message("vp_set_module_sources(" ${ARGN} ")") set(VISP_MODULE_${the_module}_HEADERS "") set(VISP_MODULE_${the_module}_SOURCES "") foreach(f "HEADERS" ${ARGN}) if(f STREQUAL "HEADERS" OR f STREQUAL "SOURCES") set(__filesvar "VISP_MODULE_${the_module}_${f}") else() list(APPEND ${__filesvar} "${f}") endif() endforeach() # use full paths for module to be independent from the module location vp_convert_to_full_paths(VISP_MODULE_${the_module}_HEADERS) if(${the_module} MATCHES visp_core) list(APPEND VISP_MODULE_${the_module}_HEADERS "${VISP_INCLUDE_DIR}/visp3/core/vpConfig.h") list(APPEND VISP_MODULE_${the_module}_HEADERS "${VISP_INCLUDE_DIR}/visp3/visp_modules.h") endif() set(VISP_MODULE_${the_module}_HEADERS ${VISP_MODULE_${the_module}_HEADERS} CACHE INTERNAL "List of header files for ${the_module}") set(VISP_MODULE_${the_module}_SOURCES ${VISP_MODULE_${the_module}_SOURCES} CACHE INTERNAL "List of source files for ${the_module}") endmacro() # finds and sets headers and sources for the standard ViSP module # Usage: # vp_glob_module_sources() macro(vp_glob_module_sources) vp_debug_message("vp_glob_module_sources(" ${ARGN} ")") set(_argn ${ARGN}) file(GLOB_RECURSE lib_srcs "${CMAKE_CURRENT_LIST_DIR}/src/*.cpp" ) file(GLOB_RECURSE lib_int_hdrs "${CMAKE_CURRENT_LIST_DIR}/src/*.hpp" "${CMAKE_CURRENT_LIST_DIR}/src/*.h" ) file(GLOB lib_hdrs "${CMAKE_CURRENT_LIST_DIR}/include/visp3/*.h" "${CMAKE_CURRENT_LIST_DIR}/include/visp3/${name}/*.h" ) vp_source_group("Src" DIRBASE "${CMAKE_CURRENT_LIST_DIR}/src" FILES ${lib_srcs} ${lib_int_hdrs}) vp_source_group("Include" DIRBASE "${CMAKE_CURRENT_LIST_DIR}/include" FILES ${lib_hdrs}) vp_set_module_sources(${_argn} HEADERS ${lib_hdrs} SOURCES ${lib_srcs} ${lib_int_hdrs}) endmacro() # finds and copy data from a source to a destination # Usage: # vp_glob_module_data( ) macro(vp_glob_module_copy_data src dst) set(__data "") file(GLOB_RECURSE __data "${CMAKE_CURRENT_LIST_DIR}/${src}" ) foreach(__d ${__data}) file(COPY ${__d} DESTINATION "${VISP_BINARY_DIR}/${dst}" FILE_PERMISSIONS OWNER_READ GROUP_READ WORLD_READ OWNER_WRITE ) # install if(UNIX) set(__install_dst "${CMAKE_INSTALL_DATAROOTDIR}/visp-${VISP_VERSION}/${dst}") else() set(__install_dst "${dst}") endif() install(FILES ${__d} DESTINATION "${__install_dst}" PERMISSIONS OWNER_READ GROUP_READ WORLD_READ OWNER_WRITE ) endforeach() endmacro() # creates old headers for compat with previous releases in include/visp # Usage: # vp_create_compat_headers() macro(vp_create_compat_headers) vp_debug_message("vp_create_compat_headers(" ${ARGN} ")") set(VISP_HEADER_CONTENT_CONFIGMAKE "") foreach(h ${ARGN}) get_filename_component(__h_name_we ${h} NAME_WE) get_filename_component(__h_name ${h} NAME) set(VISP_HEADER_CONTENT_CONFIGMAKE "#ifndef __${__h_name_we}_h_\n#define __${__h_name_we}_h_\n\n#include \n\n#endif\n") set(__compat_header_dst "${VISP_INCLUDE_DIR}/visp/${__h_name_we}.h") configure_file("${VISP_SOURCE_DIR}/cmake/templates/vpHeader.h.in" ${__compat_header_dst}) endforeach() unset(__h_name_we) unset(__h_name) unset(__compat_header_dst) endmacro() # creates headers for modules include/visp3//vp.h # Usage: # vp_create_global_module_header() macro(vp_create_global_module_header module) vp_debug_message("vp_create_global_module_header(" ${module} ")") set(__name ${module}) vp_short_module_name(__name) set(__module_header_dst "${VISP_INCLUDE_DIR}/visp3/${module}.h") set(VISP_HEADER_CONTENT_CONFIGMAKE "#ifndef __${module}_h_\n#define __${module}_h_\n") # when core, include also vpConfig.h if(__name MATCHES "core") set(VISP_HEADER_CONTENT_CONFIGMAKE "${VISP_HEADER_CONTENT_CONFIGMAKE}\n#include ") endif() # include the modules we depend on if(VISP_MODULE_${module}_REQ_DEPS) foreach(dep ${VISP_MODULE_${module}_REQ_DEPS}) vp_short_module_name(dep) set(VISP_HEADER_CONTENT_CONFIGMAKE "${VISP_HEADER_CONTENT_CONFIGMAKE}\n#include ") endforeach() endif() foreach(h ${VISP_MODULE_${module}_HEADERS}) string(REGEX REPLACE "^.*/include/visp3" "visp3" h "${h}") set(VISP_HEADER_CONTENT_CONFIGMAKE "${VISP_HEADER_CONTENT_CONFIGMAKE}\n#include <${h}>") endforeach() set(VISP_HEADER_CONTENT_CONFIGMAKE "${VISP_HEADER_CONTENT_CONFIGMAKE}\n\n#endif\n") configure_file("${VISP_SOURCE_DIR}/cmake/templates/vpHeader.h.in" ${__module_header_dst}) install(FILES ${__module_header_dst} DESTINATION ${VISP_INC_INSTALL_PATH}/visp3 COMPONENT dev ) unset(__h_name_we) unset(__h_name) unset(__module_header_dst) endmacro() # creates ViSP module in current folder # creates new target, configures standard dependencies, compilers flags, install rules # Usage: # vp_create_module( LINK_PRIVATE ) # vp_create_module() macro(vp_create_module) vp_debug_message("vp_create_module(" ${ARGN} ")") set(VISP_MODULE_${the_module}_LINK_DEPS "${VISP_MODULE_${the_module}_LINK_DEPS};${ARGN}" CACHE INTERNAL "") _vp_create_module() set(the_module_target ${the_module}) endmacro() macro(_vp_create_module) vp_create_compat_headers(${VISP_MODULE_${the_module}_HEADERS}) vp_create_global_module_header(${the_module}) vp_add_library(${the_module} ${VISP_MODULE_TYPE} ${VISP_MODULE_${the_module}_HEADERS} ${VISP_MODULE_${the_module}_SOURCES}) vp_target_link_libraries(${the_module} LINK_PUBLIC ${VISP_MODULE_${the_module}_DEPS_TO_LINK} ${VISP_MODULE_${the_module}_DEPS_EXT} ${VISP_MODULE_${the_module}_LINK_DEPS} ${VISP_LINKER_LIBS} LINK_PRIVATE ${VISP_MODULE_${the_module}_PRIVATE_REQ_DEPS} ${VISP_MODULE_${the_module}_PRIVATE_OPT_DEPS}) add_dependencies(visp_modules ${the_module}) if(ENABLE_SOLUTION_FOLDERS) set_target_properties(${the_module} PROPERTIES FOLDER "modules") endif() set_target_properties(${the_module} PROPERTIES OUTPUT_NAME "${the_module}${VISP_DLLVERSION}" DEBUG_POSTFIX "${VISP_DEBUG_POSTFIX}" ARCHIVE_OUTPUT_DIRECTORY ${LIBRARY_OUTPUT_PATH} LIBRARY_OUTPUT_DIRECTORY ${LIBRARY_OUTPUT_PATH} RUNTIME_OUTPUT_DIRECTORY ${BINARY_OUTPUT_PATH} ) set_property(TARGET ${the_module} APPEND PROPERTY INTERFACE_INCLUDE_DIRECTORIES ${VISP_MODULE_${the_module}_INC_DEPS} ) # For dynamic link numbering convenions if(NOT ANDROID) # Android SDK build scripts can include only .so files into final .apk # As result we should not set version properties for Android set_target_properties(${the_module} PROPERTIES VERSION ${VISP_VERSION} SOVERSION ${VISP_VERSION_MAJOR}.${VISP_VERSION_MINOR} ) endif() if((NOT DEFINED VISP_MODULE_TYPE AND BUILD_SHARED_LIBS) OR (DEFINED VISP_MODULE_TYPE AND VISP_MODULE_TYPE STREQUAL SHARED)) set_target_properties(${the_module} PROPERTIES COMPILE_DEFINITIONS visp_EXPORTS) set_target_properties(${the_module} PROPERTIES DEFINE_SYMBOL visp_EXPORTS) endif() if(MSVC) if(CMAKE_CROSSCOMPILING) set_target_properties(${the_module} PROPERTIES LINK_FLAGS "/NODEFAULTLIB:secchk") endif() set_target_properties(${the_module} PROPERTIES LINK_FLAGS "/NODEFAULTLIB:libc /DEBUG") endif() vp_install_target(${the_module} EXPORT VISPModules OPTIONAL RUNTIME DESTINATION ${VISP_BIN_INSTALL_PATH} COMPONENT libs LIBRARY DESTINATION ${VISP_LIB_INSTALL_PATH} COMPONENT libs ARCHIVE DESTINATION ${VISP_LIB_INSTALL_PATH} COMPONENT dev ) foreach(m ${VISP_MODULE_${the_module}_CHILDREN} ${the_module}) # only "public" headers need to be installed if(VISP_MODULE_${m}_HEADERS AND ";${VISP_MODULES_PUBLIC};" MATCHES ";${m};") foreach(hdr ${VISP_MODULE_${m}_HEADERS}) string(REGEX REPLACE "^.*visp3/" "visp3/" hdr2 "${hdr}") if(NOT hdr2 MATCHES "visp3/${m}/private.*" AND hdr2 MATCHES "^(visp3/?.*)/[^/]+.h(..)?$" ) install(FILES ${hdr} OPTIONAL DESTINATION "${VISP_INC_INSTALL_PATH}/${CMAKE_MATCH_1}" COMPONENT dev) endif() endforeach() endif() endforeach() endmacro() # short command for adding simple ViSP module # see vp_add_module for argument details # Usage: # vp_define_module(module_name [INTERNAL] [REQUIRED] [] [OPTIONAL ]) macro(vp_define_module module_name) vp_debug_message("vp_define_module(" ${module_name} ${ARGN} ")") set(_argn ${ARGN}) vp_add_module(${module_name} ${_argn}) vp_glob_module_sources() vp_module_include_directories() vp_create_module() endmacro() # ensures that all passed modules are available # sets VP_DEPENDENCIES_FOUND variable to TRUE/FALSE macro(vp_check_dependencies) set(VP_DEPENDENCIES_FOUND TRUE) foreach(d ${ARGN}) if(d MATCHES "^visp_[^ ]+$" AND NOT HAVE_${d}) set(VP_DEPENDENCIES_FOUND FALSE) break() endif() endforeach() endmacro() # auxiliary macro to parse arguments of vp_add_tests commands macro(__vp_parse_test_sources tests_type) set(VISP_${tests_type}_${the_module}_SOURCES "") set(VISP_${tests_type}_${the_module}_SOURCES_EXCLUDE "") set(VISP_${tests_type}_${the_module}_DEPS "") set(VISP_${tests_type}_${the_module}_CTEST_EXCLUDE_FOLDER "") set(VISP_${tests_type}_${the_module}_CTEST_EXCLUDE_FILE "") set(__file_group_name "") set(__file_group_sources "") foreach(arg "DEPENDS_ON" ${ARGN} "FILES") if(arg STREQUAL "FILES") set(__currentvar "__file_group_sources") if(__file_group_name AND __file_group_sources) source_group("${__file_group_name}" FILES ${__file_group_sources}) list(APPEND VISP_${tests_type}_${the_module}_SOURCES ${__file_group_sources}) endif() set(__file_group_name "") set(__file_group_sources "") elseif(arg STREQUAL "DEPENDS_ON") set(__currentvar "VISP_${tests_type}_${the_module}_DEPS") elseif(" ${__currentvar}" STREQUAL " __file_group_sources" AND NOT __file_group_name) # spaces to avoid CMP0054 set(__file_group_name "${arg}") elseif(arg STREQUAL "CTEST_EXCLUDE_PATH") set(__currentvar "VISP_${tests_type}_${the_module}_CTEST_EXCLUDE_FOLDER") elseif(arg STREQUAL "CTEST_EXCLUDE_FILE") set(__currentvar "VISP_${tests_type}_${the_module}_CTEST_EXCLUDE_FILE") elseif(arg STREQUAL "SOURCES_EXCLUDE") set(__currentvar "VISP_${tests_type}_${the_module}_SOURCES_EXCLUDE") else() list(APPEND ${__currentvar} "${arg}") endif() endforeach() unset(__file_group_name) unset(__file_group_sources) unset(__currentvar) endmacro() # this is a command for adding ViSP tests to the module # vp_add_tests([FILES ] # [FILES_EXCLUDE ] # [DEPENDS_ON] # [CTEST_EXCLUDE_PATH] ) # [CTEST_EXCLUDE_FILE] ) macro(vp_add_tests) vp_debug_message("vp_add_tests(" ${ARGN} ")") set(test_path "${CMAKE_CURRENT_LIST_DIR}/test") if(BUILD_TESTS AND EXISTS "${test_path}") __vp_parse_test_sources(TEST ${ARGN}) set(__exclude_ctest "") foreach(__folder ${VISP_TEST_${the_module}_CTEST_EXCLUDE_FOLDER} ) file(GLOB_RECURSE __files "${CMAKE_CURRENT_LIST_DIR}/test/${__folder}/*.cpp") list(APPEND __exclude_ctest ${__files}) endforeach() foreach(__file ${VISP_TEST_${the_module}_CTEST_EXCLUDE_FILE} ) if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/test/${__file}") list(APPEND __exclude_ctest "${CMAKE_CURRENT_LIST_DIR}/test/${__file}") endif() endforeach() set(__exclude_sources "") foreach(__source ${VISP_TEST_${the_module}_SOURCES_EXCLUDE} ) file(GLOB __files "${CMAKE_CURRENT_LIST_DIR}/test/${__source}") list(APPEND __exclude_sources ${__files}) endforeach() set(test_deps ${the_module} ${VISP_MODULE_${the_module}_DEPS}) foreach(d ${VISP_TEST_${the_module}_DEPS}) list(APPEND test_deps ${d}) list(APPEND test_deps ${VISP_MODULE_${d}_DEPS}) # Work arround to be able to build the modules without INTERFACE_INCLUDE_DIRECTORIES # that was only introduces since CMake 2.8.12 if(CMAKE_VERSION VERSION_LESS 2.8.12) list(APPEND test_deps "${VISP_MODULE_${__m}_INC_DEPS}") endif() endforeach() vp_check_dependencies(${test_deps}) if(VP_DEPENDENCIES_FOUND) if(NOT VISP_TEST_${the_module}_SOURCES) file(GLOB_RECURSE test_srcs "${test_path}/*.cpp") vp_source_group("Src" DIRBASE "${test_path}" FILES ${test_srcs}) set(VISP_TEST_${the_module}_SOURCES ${test_srcs}) endif() foreach(t ${VISP_TEST_${the_module}_SOURCES}) # check if source is not in exclude list list(FIND __exclude_sources ${t} __to_exclude_from_sources) if(${__to_exclude_from_sources} EQUAL -1) # Compute the name of the binary to create get_filename_component(the_target ${t} NAME_WE) # From source compile the binary and add link rules vp_add_executable(${the_target} ${t}) vp_target_include_modules(${the_target} ${test_deps}) vp_target_link_libraries(${the_target} ${test_deps} ${VISP_MODULE_${the_module}_DEPS} ${VISP_LINKER_LIBS}) # ctest only if not in the exclude list list(FIND __exclude_ctest ${t} __to_exclude_from_ctest) if(${__to_exclude_from_ctest} EQUAL -1) add_test(${the_target} ${the_target} -c ${OPTION_TO_DESACTIVE_DISPLAY}) endif() # TODO FS add visp_test_${name} target to group all the tests add_dependencies(visp_tests ${the_target}) if(ENABLE_SOLUTION_FOLDERS) set_target_properties(${the_target} PROPERTIES FOLDER "tests") endif() endif() endforeach() else(VP_DEPENDENCIES_FOUND) # TODO: warn about unsatisfied dependencies endif(VP_DEPENDENCIES_FOUND) endif() endmacro() # setup include paths for the list of passed modules macro(vp_include_modules) foreach(d ${ARGN}) if(d MATCHES "^visp_" AND HAVE_${d}) if (EXISTS "${VISP_MODULE_${d}_LOCATION}/include") vp_include_directories("${VISP_MODULE_${d}_LOCATION}/include") endif() elseif(EXISTS "${d}") vp_include_directories("${d}") endif() endforeach() endmacro() # same as previous but with dependencies macro(vp_include_modules_recurse) vp_include_modules(${ARGN}) foreach(d ${ARGN}) if(d MATCHES "^visp_" AND HAVE_${d} AND DEFINED VISP_MODULE_${d}_DEPS) foreach (sub ${VISP_MODULE_${d}_DEPS}) vp_include_modules(${sub}) endforeach() endif() endforeach() endmacro() # This is a command to configure files as include headers of the corresponding module. # vp_add_config_file() # # If the input config filename is suffixed by .in or .cmake the suffix is removed # in the configured file. # # Example: # vp_add_config_file(cmake/template/vpConfigModule.h.in) # creates include/visp3/module_name/vpConfigModule.h macro(vp_add_config_file) foreach(d ${ARGN}) # Removes first "/" if it exists string(FIND ${d} "/" FIRST_SEPARATOR_POS) if(${FIRST_SEPARATOR_POS} EQUAL 0) string(SUBSTRING ${d} 1 -1 d) endif() # Find start of file name string(FIND ${d} "/" LAST_SEPARATOR_POS REVERSE) if(${LAST_SEPARATOR_POS} EQUAL -1) set(START 0) else() math(EXPR START "${LAST_SEPARATOR_POS}+1") endif() # Save entire path set(FILENAME_CONFIG ${d}) # Find file name string(FIND ${d} "." EXTENSION_POS REVERSE) if(${EXTENSION_POS} EQUAL -1) string(SUBSTRING ${d} ${START} -1 FILENAME_CONFIG_SHORT) else() string(SUBSTRING ${d} ${EXTENSION_POS} -1 EXT_CONFIG_FILE) if(EXT_CONFIG_FILE MATCHES ".cmake" OR EXT_CONFIG_FILE MATCHES ".in") math(EXPR LENGTH "${EXTENSION_POS} - ${START}") string(SUBSTRING ${d} ${START} ${LENGTH} FILENAME_CONFIG_SHORT) else() string(SUBSTRING ${d} ${START} -1 FILENAME_CONFIG_SHORT) endif() endif() set(MODULE_NAME ${the_module}) if(MODULE_NAME MATCHES "^visp_") string(REGEX REPLACE "^visp_" "" MODULE_NAME "${MODULE_NAME}") endif() configure_file("${VISP_MODULE_${the_module}_LOCATION}/${FILENAME_CONFIG}" "${VISP_INCLUDE_DIR}/visp3/${MODULE_NAME}/${FILENAME_CONFIG_SHORT}") vp_create_compat_headers("${VISP_INCLUDE_DIR}/visp3/${MODULE_NAME}/${FILENAME_CONFIG_SHORT}") install(FILES "${VISP_INCLUDE_DIR}/visp3/${MODULE_NAME}/${FILENAME_CONFIG_SHORT}" DESTINATION ${VISP_INC_INSTALL_PATH}/visp3/${MODULE_NAME} COMPONENT dev ) endforeach() endmacro() # This is a command to add a list of paths associated to the corresponding module # to the CMAKE_MODULE_PATH global var to find specific cmake material # vp_add_cmake_module_path() # Example: # vp_add_cmake_module_path(cmake) # Appends the cmake full path to CMAKE_MODULE_PATH var. macro(vp_add_cmake_module_path) foreach(d ${ARGN}) # Removes first "/" if it exists string(FIND ${d} "/" FIRST_SEPARATOR_POS) if(${FIRST_SEPARATOR_POS} EQUAL 0) string(SUBSTRING ${d} 1 -1 d) endif() if(EXISTS "${VISP_MODULE_${the_module}_LOCATION}/${d}") list(APPEND CMAKE_MODULE_PATH "${VISP_MODULE_${the_module}_LOCATION}/${d}") endif() endforeach() endmacro() visp-3.0.1/cmake/VISPUse.cmake.in000066400000000000000000000027631304511007300164230ustar00rootroot00000000000000############################################################################# # # This file is part of the ViSP software. # Copyright (C) 2005 - 2017 by Inria. All rights reserved. # # This software is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public License # ("GPL") version 2 as published by the Free Software Foundation. # See the file LICENSE.txt at the root directory of this source # distribution for additional information about the GNU GPL. # # For using ViSP with software that can not be combined with the GNU # GPL, please contact Inria about acquiring a ViSP Professional # Edition License. # # See http://visp.inria.fr for more information. # # This software was developed at: # Inria Rennes - Bretagne Atlantique # Campus Universitaire de Beaulieu # 35042 Rennes Cedex # France # # If you have questions regarding the use of this file, please contact # Inria at visp@inria.fr # # This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE # WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. # # Description: # cmake PackageConfig file. # # Authors: # Fabien Spindler # ############################################################################# # Tell the compiler where to find ViSP's header files # and the third party headers we depend on include_directories(${VISP_INCLUDE_DIRS}) # Tell the compiler where to find ViSP's libraries # and the third party libraries we depend on link_libraries(${VISP_LIBRARIES}) visp-3.0.1/cmake/VISPUtils.cmake000066400000000000000000000651611304511007300163630ustar00rootroot00000000000000############################################################################# # # This file is part of the ViSP software. # Copyright (C) 2005 - 2017 by Inria. All rights reserved. # # This software is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public License # ("GPL") version 2 as published by the Free Software Foundation. # See the file LICENSE.txt at the root directory of this source # distribution for additional information about the GNU GPL. # # For using ViSP with software that can not be combined with the GNU # GPL, please contact Inria about acquiring a ViSP Professional # Edition License. # # See http://visp.inria.fr for more information. # # This software was developed at: # Inria Rennes - Bretagne Atlantique # Campus Universitaire de Beaulieu # 35042 Rennes Cedex # France # # If you have questions regarding the use of this file, please contact # Inria at visp@inria.fr # # This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE # WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. # # Authors: # Fabien Spindler # ############################################################################# if(NOT COMMAND find_host_program) # macro to find programs on the host OS macro( find_host_program ) set( CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER ) set( CMAKE_FIND_ROOT_PATH_MODE_LIBRARY NEVER ) set( CMAKE_FIND_ROOT_PATH_MODE_INCLUDE NEVER ) find_program( ${ARGN} ) set( CMAKE_FIND_ROOT_PATH_MODE_PROGRAM ONLY ) set( CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY ) set( CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY ) mark_as_advanced(${ARGV0}) endmacro() endif() if(NOT COMMAND find_host_package) macro(find_host_package) find_package(${ARGN}) endmacro() endif() # adds include directories in such way that directories from the ViSP source tree go first function(vp_include_directories) vp_debug_message("vp_include_directories( ${ARGN} )") set(__add_before "") foreach(dir ${ARGN}) get_filename_component(__abs_dir "${dir}" ABSOLUTE) if("${__abs_dir}" MATCHES "^${VISP_SOURCE_DIR}" OR "${__abs_dir}" MATCHES "^${VISP_BINARY_DIR}") list(APPEND __add_before "${dir}") else() include_directories(AFTER SYSTEM "${dir}") endif() endforeach() include_directories(BEFORE ${__add_before}) endfunction() # adds include directories in such way that directories from the ViSP source tree go first function(vp_target_include_directories target) set(__params "") foreach(dir ${ARGN}) get_filename_component(__abs_dir "${dir}" ABSOLUTE) string(REPLACE "+" "\\+" __VISP_BINARY_DIR_filtered ${VISP_BINARY_DIR}) # if("${__abs_dir}" MATCHES "^${VISP_SOURCE_DIR}" OR "${__abs_dir}" MATCHES "^${VISP_BINARY_DIR}") if("${__abs_dir}" MATCHES "^${VISP_SOURCE_DIR}" OR "${__abs_dir}" MATCHES "^${__VISP_BINARY_DIR_filtered}") list(APPEND __params "${__abs_dir}") else() list(APPEND __params "${dir}") endif() endforeach() if(__params) if(CMAKE_VERSION VERSION_LESS 2.8.11) include_directories(${__params}) else() if(TARGET ${target}) target_include_directories(${target} PRIVATE ${__params}) else() set(__new_inc "${VP_TARGET_INCLUDE_DIRS_${target}};${__params}") set(VP_TARGET_INCLUDE_DIRS_${target} "${__new_inc}" CACHE INTERNAL "") endif() endif() endif() endfunction() # clears all passed variables macro(vp_clear_vars) foreach(_var ${ARGN}) unset(${_var} CACHE) endforeach() endmacro() # print message macro(vp_debug_message) #string(REPLACE ";" " " __msg "${ARGN}") #message(STATUS "${__msg}") endmacro() # remove all matching elements from the list macro(vp_list_filterout lst regex) foreach(item ${${lst}}) if(item MATCHES "${regex}") list(REMOVE_ITEM ${lst} "${item}") endif() endforeach() endmacro() # stable & safe duplicates removal macro macro(vp_list_unique __lst) if(${__lst}) list(REMOVE_DUPLICATES ${__lst}) endif() endmacro() # list empty elements removal macro macro(vp_list_remove_empty __lst) if(${__lst}) list(REMOVE_ITEM ${__lst} "") endif() endmacro() # list elements removal macro macro(vp_list_remove_item __lst __item) if(${__lst}) list(REMOVE_ITEM ${__lst} ${__item}) endif() endmacro() # macro that creates a list from a string. Spaces or tab are considered as list separator # In other words split a string into list elements macro(vp_create_list_from_string STR LST) if(NOT ${STR} STREQUAL "") set(__lst ${STR}) string(REPLACE " " ";" __lst ${__lst}) vp_list_remove_empty(${__lst}) set(${LST} ${__lst}) endif() endmacro() # safe list sorting macro macro(vp_list_sort __lst) if(${__lst}) list(SORT ${__lst}) endif() endmacro() # gets and removes the first element from list macro(vp_list_pop_front LST VAR) if(${LST}) list(GET ${LST} 0 ${VAR}) list(REMOVE_AT ${LST} 0) else() set(${VAR} "") endif() endmacro() # remove cmake ; list separator macro(vp_list_remove_separator __lst) if(${__lst}) set(__lst_reformated "") foreach(element ${${__lst}}) set(__lst_reformated "${__lst_reformated} ${element}") endforeach() set(${__lst} ${__lst_reformated}) endif() endmacro() # Provides an option that the user can optionally select. # Can accept condition to control when option is available for user. # Usage: # vp_option( # # # "help string describing the option" # "advanced list of vars separated by ;" # [IF ]) # # Example: # VP_OPTION(USE_VTK "VTK" "QUIET" "Include vtk support" "" ON) # VP_OPTION(USE_VTK "VTK;COMPONENTS;vtkCommonCore;vtkFiltersSources" "" "Include vtk support" "" ON) macro(VP_OPTION variable package quiet description advanced value) set(__option TRUE) set(__value ${value}) set(__condition "") set(__varname "__value") set(__components "") set(__eltIsComponent FALSE) set(__package "") # without components foreach(p ${package}) if(${p} MATCHES "COMPONENTS") set(__eltIsComponent TRUE) elseif(__eltIsComponent) list(APPEND __components ${p}) else() list(APPEND __package ${p}) endif() endforeach() # get the first package considered as the main package from a list: ie "Zlib;MyZlib" set(__first_package "") foreach(p ${__package}) if(${p} MATCHES "^My") string(REGEX REPLACE "^My" "" p "${p}") endif() set(__first_package ${p}) break() endforeach() if(NOT ${__first_package} STREQUAL "") string(TOLOWER "${__first_package}" __package_lower) string(TOUPPER "${__first_package}" __package_upper) # useful for Qt -> QT_FOUND # make var _DIR advanced mark_as_advanced(${__first_package}_DIR) endif() foreach(arg ${ARGN}) if(arg STREQUAL "IF" OR arg STREQUAL "if") set(__varname "__condition") else() list(APPEND ${__varname} ${arg}) endif() endforeach() unset(__varname) if(__condition STREQUAL "") set(__condition 2 GREATER 1) endif() if(${__condition}) if(NOT ${__first_package} STREQUAL "") foreach(p ${__package}) if("${quiet}" STREQUAL "") if(__components) find_package(${p} COMPONENTS ${__components}) else() find_package(${p}) endif() else() if(__components) find_package(${p} ${quiet} COMPONENTS ${__components}) else() find_package(${p} ${quiet}) endif() endif() if(${__package_upper}_FOUND OR ${__first_package}_FOUND) set(__option TRUE) break() else() set(__option FALSE) endif() endforeach() endif() if(${__option}) if(__value MATCHES ";") if(${__value}) option(${variable} "${description}" ON) else() option(${variable} "${description}" OFF) endif() elseif(DEFINED ${__value}) if(${__value}) option(${variable} "${description}" ON) else() option(${variable} "${description}" OFF) endif() else() option(${variable} "${description}" ${__value}) endif() else() unset(${variable} CACHE) endif() unset(__condition) unset(__value) else() set(${variable} OFF) endif() foreach(a ${advanced}) mark_as_advanced(${a}) endforeach() if(${variable} AND NOT ${__first_package} STREQUAL "") # set VISP_HAVE_=TRUE and VISP_HAVE__FOUND="yes" message(STATUS "${__package_lower} found") endif() unset(__option) unset(__alias_have) endmacro() # Provides a macro to set a var. # Can accept condition to set var. # Usage: # vp_set( # [IF ]) macro(VP_SET variable value) set(__value ${value}) set(__condition "") set(__varname "__value") foreach(arg ${ARGN}) if(arg STREQUAL "IF" OR arg STREQUAL "if") set(__varname "__condition") else() list(APPEND ${__varname} ${arg}) endif() endforeach() unset(__varname) if(__condition STREQUAL "") set(__condition 2 GREATER 1) endif() if(${__condition}) if(__value MATCHES ";") if(${__value}) set(${variable} TRUE) else() set(${variable} FALSE) endif() elseif(DEFINED ${__value}) if(${__value}) set(${variable} TRUE) else() set(${variable} FALSE) endif() else() set(${variable} ${__value}) endif() endif() unset(__condition) unset(__value) endmacro() # short command to setup source group function(vp_source_group group) cmake_parse_arguments(SG "" "DIRBASE" "GLOB;GLOB_RECURSE;FILES" ${ARGN}) set(files "") if(SG_FILES) list(APPEND files ${SG_FILES}) endif() if(SG_GLOB) file(GLOB srcs ${SG_GLOB}) list(APPEND files ${srcs}) endif() if(SG_GLOB_RECURSE) file(GLOB_RECURSE srcs ${SG_GLOB_RECURSE}) list(APPEND files ${srcs}) endif() if(SG_DIRBASE) foreach(f ${files}) file(RELATIVE_PATH fpart "${SG_DIRBASE}" "${f}") if(fpart MATCHES "^\\.\\.") message(AUTHOR_WARNING "Can't detect subpath for vp_source_group command: Group=${group} FILE=${f} DIRBASE=${SG_DIRBASE}") set(fpart "") else() get_filename_component(fpart "${fpart}" PATH) if(fpart) set(fpart "/${fpart}") # add '/' string(REPLACE "/" "\\" fpart "${fpart}") endif() endif() source_group("${group}${fpart}" FILES ${f}) endforeach() else() source_group(${group} FILES ${files}) endif() endfunction() # convert list of paths to full paths macro(vp_convert_to_full_paths VAR) if(${VAR}) set(__tmp "") foreach(path ${${VAR}}) get_filename_component(${VAR} "${path}" ABSOLUTE) list(APPEND __tmp "${${VAR}}") endforeach() set(${VAR} ${__tmp}) unset(__tmp) endif() endmacro() # add install command function(vp_install_target) install(TARGETS ${ARGN}) set(isPackage 0) unset(__package) unset(__target) foreach(e ${ARGN}) if(NOT DEFINED __target) set(__target "${e}") endif() if(isPackage EQUAL 1) set(__package "${e}") break() endif() if(e STREQUAL "EXPORT") set(isPackage 1) endif() endforeach() if(DEFINED __package) list(APPEND ${__package}_TARGETS ${__target}) set(${__package}_TARGETS "${${__package}_TARGETS}" CACHE INTERNAL "List of ${__package} targets") endif() if(INSTALL_CREATE_DISTRIB) if(MSVC AND NOT BUILD_SHARED_LIBS) set(__target "${ARGV0}") set(isArchive 0) set(isDst 0) unset(__dst) foreach(e ${ARGN}) if(isDst EQUAL 1) set(__dst "${e}") break() endif() if(isArchive EQUAL 1 AND e STREQUAL "DESTINATION") set(isDst 1) endif() if(e STREQUAL "ARCHIVE") set(isArchive 1) else() set(isArchive 0) endif() endforeach() # message(STATUS "Process ${__target} dst=${__dst}...") if(DEFINED __dst) if(CMAKE_VERSION VERSION_LESS 2.8.12) get_target_property(fname ${__target} LOCATION_DEBUG) if(fname MATCHES "\\.lib$") string(REGEX REPLACE "\\.lib$" ".pdb" fname "${fname}") install(FILES ${fname} DESTINATION ${__dst} CONFIGURATIONS Debug) endif() get_target_property(fname ${__target} LOCATION_RELEASE) if(fname MATCHES "\\.lib$") string(REGEX REPLACE "\\.lib$" ".pdb" fname "${fname}") install(FILES ${fname} DESTINATION ${__dst} CONFIGURATIONS Release) endif() else() # CMake 2.8.12 brokes PDB support in STATIC libraries for MSVS endif() endif() endif() endif() endfunction() function(vp_target_link_libraries target) set(LINK_DEPS ${ARGN}) target_link_libraries(${target} ${LINK_DEPS}) endfunction() function(_vp_append_target_includes target) if(DEFINED VP_TARGET_INCLUDE_DIRS_${target}) target_include_directories(${target} PRIVATE ${VP_TARGET_INCLUDE_DIRS_${target}}) unset(VP_TARGET_INCLUDE_DIRS_${target} CACHE) endif() endfunction() function(vp_add_executable target) add_executable(${target} ${ARGN}) _vp_append_target_includes(${target}) endfunction() function(vp_add_library target) add_library(${target} ${ARGN}) _vp_append_target_includes(${target}) endfunction() # Macros that checks if package have been installed. # After it set vars: # _FOUND # _INCLUDE_DIRS # _LIBRARIES # VISP_HAVE_ macro(VP_CHECK_PACKAGE package) set(ALIAS ${package}) string(TOUPPER "${ALIAS}" ALIAS_UPPER) # useful for OpenGL set(ALIAS_FOUND ${ALIAS}_FOUND) set(ALIAS_UPPER_FOUND ${ALIAS_UPPER}_FOUND) set(ALIAS_INCLUDE_DIRS ${ALIAS}_INCLUDE_DIRS) set(ALIAS_LIBRARIES ${ALIAS}_LIBRARIES) set(ALIAS_VISP_HAVE VISP_HAVE_${ALIAS}) set(ALIAS_UPPER_VISP_HAVE VISP_HAVE_${ALIAS_UPPER}) find_package(${ALIAS}) if(${ALIAS_FOUND} OR ${ALIAS_UPPER_FOUND}) set(${ALIAS_VISP_HAVE} 1) set(${ALIAS_UPPER_VISP_HAVE} 1) endif() endmacro() # Macro the get the list of subdirs from the path # var: returned variable name # path: path from witch relative subdirs are macro(vp_get_relative_subdirs var path) set(ALIAS ${var}) file(GLOB_RECURSE rel_path_lst_ RELATIVE ${path} ${path}/*) set(${ALIAS} "") foreach(f ${rel_path_lst_}) get_filename_component(d ${f} PATH) list(APPEND ${ALIAS} ${d}) endforeach() list(REMOVE_DUPLICATES ${ALIAS}) endmacro() set(VP_COMPILER_FAIL_REGEX "command line option .* is valid for .* but not for C\\+\\+" # GNU "command line option .* is valid for .* but not for C" # GNU "unrecognized .*option" # GNU "unknown .*option" # Clang "ignoring unknown option" # MSVC "warning D9002" # MSVC, any lang "option .*not supported" # Intel "[Uu]nknown option" # HP "[Ww]arning: [Oo]ption" # SunPro "command option .* is not recognized" # XL "not supported in this configuration; ignored" # AIX "File with unknown suffix passed to linker" # PGI "WARNING: unknown flag:" # Open64 ) # test if a compiler flag is supported macro(vp_check_compiler_flag LANG FLAG RESULT) if(NOT DEFINED ${RESULT}) if("_${LANG}_" MATCHES "_CXX_") set(_fname "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/src.cxx") #if("${CMAKE_CXX_FLAGS} ${FLAG} " MATCHES "-Werror " OR "${CMAKE_CXX_FLAGS} ${FLAG} " MATCHES "-Werror=unknown-pragmas ") file(WRITE "${_fname}" "int main() { return 0; }\n") #else() # file(WRITE "${_fname}" "#pragma\nint main() { return 0; }\n") #endif() elseif("_${LANG}_" MATCHES "_C_") set(_fname "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/src.c") #if("${CMAKE_C_FLAGS} ${FLAG} " MATCHES "-Werror " OR "${CMAKE_C_FLAGS} ${FLAG} " MATCHES "-Werror=unknown-pragmas ") file(WRITE "${_fname}" "int main(void) { return 0; }\n") #else() # file(WRITE "${_fname}" "#pragma\nint main(void) { return 0; }\n") #endif() elseif("_${LANG}_" MATCHES "_OBJCXX_") set(_fname "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/src.mm") #if("${CMAKE_CXX_FLAGS} ${FLAG} " MATCHES "-Werror " OR "${CMAKE_CXX_FLAGS} ${FLAG} " MATCHES "-Werror=unknown-pragmas ") file(WRITE "${_fname}" "int main() { return 0; }\n") #else() # file(WRITE "${_fname}" "#pragma\nint main() { return 0; }\n") #endif() else() unset(_fname) endif() if(_fname) message(STATUS "Performing Test ${RESULT}") try_compile(${RESULT} "${CMAKE_BINARY_DIR}" "${_fname}" COMPILE_DEFINITIONS "${FLAG}" OUTPUT_VARIABLE OUTPUT) foreach(_regex ${VP_COMPILER_FAIL_REGEX}) if("${OUTPUT}" MATCHES "${_regex}") set(${RESULT} 0) break() endif() endforeach() if(${RESULT}) set(${RESULT} 1 CACHE INTERNAL "Test ${RESULT}") message(STATUS "Performing Test ${RESULT} - Success") else() message(STATUS "Performing Test ${RESULT} - Failed") set(${RESULT} "" CACHE INTERNAL "Test ${RESULT}") file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log "Compilation failed:\n" " source file: '${_fname}'\n" " check option: '${FLAG}'\n" "===== BUILD LOG =====\n" "${OUTPUT}\n" "===== END =====\n\n") endif() else() set(${RESULT} 0) endif() endif() endmacro() # check if a compiler flag is supported macro(vp_check_flag_support lang flag varname) if("_${lang}_" MATCHES "_CXX_") set(_lang CXX) elseif("_${lang}_" MATCHES "_C_") set(_lang C) else() set(_lang ${lang}) endif() string(TOUPPER "${flag}" ${varname}) string(REGEX REPLACE "^(/|-)" "HAVE_${_lang}_" ${varname} "${${varname}}") string(REGEX REPLACE " -|-|=| |\\." "_" ${varname} "${${varname}}") vp_check_compiler_flag("${_lang}" "${ARGN} ${flag}" ${${varname}}) endmacro() # turns off warnings macro(vp_warnings_disable) set(_flag_vars "") set(_msvc_warnings "") set(_gxx_warnings "") foreach(arg ${ARGN}) if(arg MATCHES "^CMAKE_") list(APPEND _flag_vars ${arg}) elseif(arg MATCHES "^/wd") list(APPEND _msvc_warnings ${arg}) elseif(arg MATCHES "^-W") list(APPEND _gxx_warnings ${arg}) endif() endforeach() if(MSVC AND _msvc_warnings AND _flag_vars) foreach(var ${_flag_vars}) foreach(warning ${_msvc_warnings}) set(${var} "${${var}} ${warning}") endforeach() endforeach() elseif((CMAKE_COMPILER_IS_GNUCXX OR (${CMAKE_CXX_COMPILER_ID} STREQUAL "Clang")) AND _gxx_warnings AND _flag_vars) foreach(var ${_flag_vars}) foreach(warning ${_gxx_warnings}) if(NOT warning MATCHES "^-Wno-") string(REPLACE "${warning}" "" ${var} "${${var}}") string(REPLACE "-W" "-Wno-" warning "${warning}") endif() vp_check_flag_support(${var} "${warning}" _varname) if(${_varname}) set(${var} "${${var}} ${warning}") endif() endforeach() endforeach() endif() unset(_flag_vars) unset(_msvc_warnings) unset(_gxx_warnings) endmacro() macro(vp_set_source_file_compile_flag file) if(ACTIVATE_WARNING_3PARTY_MUTE) set(__cxxflags "") foreach(cxxflag ${ARGN}) vp_check_flag_support(CXX ${cxxflag} __support_flag) if(${__support_flag}) set(__cxxflags "${__cxxflags} ${cxxflag}") endif() endforeach() if(NOT ${__cxxflags} STREQUAL "") if(EXISTS ${CMAKE_CURRENT_LIST_DIR}/${file}) set_source_files_properties(${CMAKE_CURRENT_LIST_DIR}/${file} PROPERTIES COMPILE_FLAGS ${__cxxflags}) elseif(EXISTS ${file}) # for files that are in the build tree (like those produced by qt moc set_source_files_properties(${CMAKE_CURRENT_LIST_DIR}/${file} PROPERTIES COMPILE_FLAGS ${__cxxflags}) endif() endif() endif() endmacro() macro(vp_add_subdirectories lst subdir) if(${lst}) foreach(__path ${${lst}}) if(EXISTS ${__path}/${subdir}) file(GLOB __subdirs RELATIVE "${__path}/${subdir}" "${__path}/${subdir}/*") foreach(__s ${__subdirs}) if(EXISTS "${__path}/${subdir}/${__s}/CMakeLists.txt") add_subdirectory("${__path}/${subdir}/${__s}" "${CMAKE_BINARY_DIR}/${subdir}/${__s}") endif() endforeach() endif() endforeach() endif() endmacro() set(VISP_BUILD_INFO_FILE "${CMAKE_BINARY_DIR}/visp-build-info.tmp") set(VISP_TXT_INFO_FILE "${CMAKE_BINARY_DIR}/ViSP-third-party.txt") file(REMOVE "${VISP_BUILD_INFO_FILE}") file(REMOVE "${VISP_TXT_INFO_FILE}") function(vp_output_status msg) message(STATUS "${msg}") string(REPLACE "\\" "\\\\" msg "${msg}") string(REPLACE "\"" "\\\"" msg "${msg}") string(REPLACE "\\\\" "\\" msg_txt "${msg}") file(APPEND "${VISP_BUILD_INFO_FILE}" "\"${msg}\\n\"\n") file(APPEND "${VISP_TXT_INFO_FILE}" "${msg_txt}\n") endfunction() macro(vp_finalize_status) if(DEFINED VISP_MODULE_visp_core_BINARY_DIR) execute_process(COMMAND ${CMAKE_COMMAND} -E copy_if_different "${VISP_BUILD_INFO_FILE}" "${VISP_MODULE_visp_core_BINARY_DIR}/version_string.inc" OUTPUT_QUIET) endif() endmacro() # Status report function. # Automatically align right column and selects text based on condition. # Usage: # status() # status( [ ...]) # status( THEN ELSE ) function(status text) set(status_cond) set(status_then) set(status_else) set(status_current_name "cond") foreach(arg ${ARGN}) if(arg STREQUAL "THEN") set(status_current_name "then") elseif(arg STREQUAL "ELSE") set(status_current_name "else") else() list(APPEND status_${status_current_name} ${arg}) endif() endforeach() if(DEFINED status_cond) set(status_placeholder_length 32) string(RANDOM LENGTH ${status_placeholder_length} ALPHABET " " status_placeholder) string(LENGTH "${text}" status_text_length) if(status_text_length LESS status_placeholder_length) string(SUBSTRING "${text}${status_placeholder}" 0 ${status_placeholder_length} status_text) elseif(DEFINED status_then OR DEFINED status_else) vp_output_status("${text}") set(status_text "${status_placeholder}") else() set(status_text "${text}") endif() if(DEFINED status_then OR DEFINED status_else) if(${status_cond}) string(REPLACE ";" " " status_then "${status_then}") string(REGEX REPLACE "^[ \t]+" "" status_then "${status_then}") vp_output_status("${status_text} ${status_then}") else() string(REPLACE ";" " " status_else "${status_else}") string(REGEX REPLACE "^[ \t]+" "" status_else "${status_else}") vp_output_status("${status_text} ${status_else}") endif() else() string(REPLACE ";" " " status_cond "${status_cond}") string(REGEX REPLACE "^[ \t]+" "" status_cond "${status_cond}") vp_output_status("${status_text} ${status_cond}") endif() else() vp_output_status("${text}") endif() endfunction() # read set of version defines from the header file macro(vp_parse_header FILENAME FILE_VAR) set(vars_regex "") set(__parnet_scope OFF) set(__add_cache OFF) foreach(name ${ARGN}) if(${name} STREQUAL "PARENT_SCOPE") set(__parnet_scope ON) elseif(${name} STREQUAL "CACHE") set(__add_cache ON) elseif(vars_regex) set(vars_regex "${vars_regex}|${name}") else() set(vars_regex "${name}") endif() endforeach() if(EXISTS "${FILENAME}") file(STRINGS "${FILENAME}" ${FILE_VAR} REGEX "#define[ \t]+(${vars_regex})[ \t]+[0-9]+" ) else() unset(${FILE_VAR}) endif() foreach(name ${ARGN}) if(NOT ${name} STREQUAL "PARENT_SCOPE" AND NOT ${name} STREQUAL "CACHE") if(${FILE_VAR}) if(${FILE_VAR} MATCHES ".+[ \t]${name}[ \t]+([0-9]+).*") string(REGEX REPLACE ".+[ \t]${name}[ \t]+([0-9]+).*" "\\1" ${name} "${${FILE_VAR}}") else() set(${name} "") endif() if(__add_cache) set(${name} ${${name}} CACHE INTERNAL "${name} parsed from ${FILENAME}" FORCE) elseif(__parnet_scope) set(${name} "${${name}}" PARENT_SCOPE) endif() else() unset(${name} CACHE) endif() endif() endforeach() endmacro() # read single version define from the header file macro(vp_parse_header2 LIBNAME HDR_PATH VARNAME) vp_clear_vars(${LIBNAME}_VERSION_MAJOR ${LIBNAME}_VERSION_MAJOR ${LIBNAME}_VERSION_MINOR ${LIBNAME}_VERSION_PATCH ${LIBNAME}_VERSION_TWEAK ${LIBNAME}_VERSION_STRING) set(${LIBNAME}_H "") if(EXISTS "${HDR_PATH}") file(STRINGS "${HDR_PATH}" ${LIBNAME}_H REGEX "^#define[ \t]+${VARNAME}[ \t]+\"[^\"]*\".*$" LIMIT_COUNT 1) endif() if(${LIBNAME}_H) string(REGEX REPLACE "^.*[ \t]${VARNAME}[ \t]+\"([0-9]+).*$" "\\1" ${LIBNAME}_VERSION_MAJOR "${${LIBNAME}_H}") string(REGEX REPLACE "^.*[ \t]${VARNAME}[ \t]+\"[0-9]+\\.([0-9]+).*$" "\\1" ${LIBNAME}_VERSION_MINOR "${${LIBNAME}_H}") string(REGEX REPLACE "^.*[ \t]${VARNAME}[ \t]+\"[0-9]+\\.[0-9]+\\.([0-9]+).*$" "\\1" ${LIBNAME}_VERSION_PATCH "${${LIBNAME}_H}") set(${LIBNAME}_VERSION_MAJOR ${${LIBNAME}_VERSION_MAJOR} ${ARGN}) set(${LIBNAME}_VERSION_MINOR ${${LIBNAME}_VERSION_MINOR} ${ARGN}) set(${LIBNAME}_VERSION_PATCH ${${LIBNAME}_VERSION_PATCH} ${ARGN}) set(${LIBNAME}_VERSION_STRING "${${LIBNAME}_VERSION_MAJOR}.${${LIBNAME}_VERSION_MINOR}.${${LIBNAME}_VERSION_PATCH}") # append a TWEAK version if it exists: set(${LIBNAME}_VERSION_TWEAK "") if("${${LIBNAME}_H}" MATCHES "^.*[ \t]${VARNAME}[ \t]+\"[0-9]+\\.[0-9]+\\.[0-9]+\\.([0-9]+).*$") set(${LIBNAME}_VERSION_TWEAK "${CMAKE_MATCH_1}" ${ARGN}) endif() if(${LIBNAME}_VERSION_TWEAK) set(${LIBNAME}_VERSION_STRING "${${LIBNAME}_VERSION_STRING}.${${LIBNAME}_VERSION_TWEAK}" ${ARGN}) else() set(${LIBNAME}_VERSION_STRING "${${LIBNAME}_VERSION_STRING}" ${ARGN}) endif() endif() endmacro() # read single version info from the pkg file macro(vp_get_version_from_pkg LIBNAME PKG_PATH OUTPUT_VAR) if(EXISTS "${PKG_PATH}/${LIBNAME}.pc") file(STRINGS "${PKG_PATH}/${LIBNAME}.pc" line_to_parse REGEX "^Version:[ \t]+[0-9.]*.*$" LIMIT_COUNT 1) string(REGEX REPLACE ".*Version: ([^ ]+).*" "\\1" ${OUTPUT_VAR} "${line_to_parse}" ) endif() endmacro() visp-3.0.1/cmake/templates/000077500000000000000000000000001304511007300155445ustar00rootroot00000000000000visp-3.0.1/cmake/templates/VISPConfig.cmake.in000066400000000000000000000431311304511007300210640ustar00rootroot00000000000000############################################################################# # # This file is part of the ViSP software. # Copyright (C) 2005 - 2017 by Inria. All rights reserved. # # This software is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public License # ("GPL") version 2 as published by the Free Software Foundation. # See the file LICENSE.txt at the root directory of this source # distribution for additional information about the GNU GPL. # # For using ViSP with software that can not be combined with the GNU # GPL, please contact Inria about acquiring a ViSP Professional # Edition License. # # See http://visp.inria.fr for more information. # # This software was developed at: # Inria Rennes - Bretagne Atlantique # Campus Universitaire de Beaulieu # 35042 Rennes Cedex # France # # If you have questions regarding the use of this file, please contact # Inria at visp@inria.fr # # This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE # WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. # # Description: # CMake package config file for ViSP. # # ** File generated automatically, do not modify ** # # This file will define the following CMake variables: # - VISP_LIBS : The list of all imported targets for VISP modules. # - VISP_INCLUDE_DIRS : ViSP and third-party include directories # - VISP_LIBRARIES : ViSP library to link against. Third-party libraries are # linked automatically thanks to cmake export file VISPModules.cmake # - VISP_VERSION_STRING : Full ViSP version that is build, "@VISP_VERSION@" # - VISP_VERSION_MAJOR : Major version part of VISP_VERSION: "@VISP_VERSION_MAJOR@" # - VISP_VERSION_MINOR : Minor version part of VISP_VERSION: "@VISP_VERSION_MINOR@" # - VISP_VERSION_PATCH : Patch version part of VISP_VERSION: "@VISP_VERSION_PATCH@" # # Advanced variables: # - VISP_SHARED : Use ViSP as shared library # - VISP_CONFIG_PATH : Path to this VISPConfig.cmake # - VISP_USE_FILE : File to include to use ViSP without specific cmake code # - VISP_LIB_COMPONENTS: Present VISP modules list # # Typical usage in user project: # # find_package(VISP REQUIRED) # include_directories(${VISP_INCLUDE_DIRS}) # target_link_libraries(MY_TARGET_NAME ${VISP_LIBRARIES}) # # It is also possible to build your project using VISP_USE_FILE. # # find_package(VISP) # if(VISP_FOUND) # include(${VISP_USE_FILE}) # endif() # # Or you can search for specific OpenCV modules: # # find_package(VISP REQUIRED core videoio) # # If the module is found then VISP__FOUND is set to TRUE. # # Authors: # Fabien Spindler # ############################################################################# #if(VISP_FOUND) # return() #endif() #set(VISP_FOUND TRUE) # Set the version numbers set(VISP_VERSION_STRING "@VISP_VERSION@") set(VISP_VERSION_MAJOR "@VISP_VERSION_MAJOR@") set(VISP_VERSION_MINOR "@VISP_VERSION_MINOR@") set(VISP_VERSION_PATCH "@VISP_VERSION_PATCH@") set(VISP_LIB_COMPONENTS @VISP_MODULES_CONFIGCMAKE@) # Form list of modules (components) to find if(NOT VISP_FIND_COMPONENTS) set(VISP_FIND_COMPONENTS ${VISP_LIB_COMPONENTS}) endif() # expand short module names and see if requested components exist set(VISP_FIND_COMPONENTS_ "") foreach(__vpcomponent ${VISP_FIND_COMPONENTS}) if(NOT __vpcomponent MATCHES "^visp_") set(__vpcomponent visp_${__vpcomponent}) endif() list(FIND VISP_LIB_COMPONENTS ${__vpcomponent} __vpcomponentIdx) if(__vpcomponentIdx LESS 0) #requested component is not found... if(VISP_FIND_REQUIRED) message(FATAL_ERROR "${__vpcomponent} is required but was not found") elseif(NOT VISP_FIND_QUIETLY) message(WARNING "${__vpcomponent} is required but was not found") endif() #indicate that module is NOT found string(TOUPPER "${__vpcomponent}" __vpcomponentUP) set(${__vpcomponentUP}_FOUND "${__vpcomponentUP}_FOUND-NOTFOUND") else() list(APPEND VISP_FIND_COMPONENTS_ ${__vpcomponent}) # Not using list(APPEND) here, because VISP_LIBS may not exist yet. # Also not clearing VISP_LIBS anywhere, so that multiple calls # to find_package(VISP) with different component lists add up. set(VISP_LIBS ${VISP_LIBS} "${__vpcomponent}") #indicate that module is found string(TOUPPER "${__vpcomponent}" __vpcomponentUP) set(${__vpcomponentUP}_FOUND 1) endif() endforeach() set(VISP_FIND_COMPONENTS ${VISP_FIND_COMPONENTS_}) #message("VISP_FIND_COMPONENTS: ${VISP_FIND_COMPONENTS}") # Resolve dependencies foreach(__opttype OPT DBG) set(VISP_LIBS_${__opttype} "${VISP_LIBS}") endforeach() # Some additional settings are required if ViSP is built as static libs set(VISP_SHARED @BUILD_SHARED_LIBS@) # Extract the directory where *this* file has been installed (determined at cmake run-time) set(VISP_CONFIG_PATH ${VISP_DIR} CACHE PATH "ViSPConfig.cmake path location" FORCE) mark_as_advanced(VISP_CONFIG_PATH) if(NOT WIN32) # Since this file is installed in ./${VISP_INSTALL_LIBDIR}/cmake/visp # the first "../../" are here to go to ${VISP_INSTALL_LIBDIR}, and then # VISP_INSTALL_LIBDIR_TO_PARENT goes to the parent dir "." set(VISP_INSTALL_PATH "${VISP_CONFIG_PATH}/../../@VISP_INSTALL_LIBDIR_TO_PARENT@") # Get the absolute path with no ../.. relative marks, to eliminate implicit linker warnings if(${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION} VERSION_LESS 2.8) get_filename_component(VISP_INSTALL_PATH "${VISP_INSTALL_PATH}" ABSOLUTE) else() get_filename_component(VISP_INSTALL_PATH "${VISP_INSTALL_PATH}" REALPATH) endif() endif() # Tells the user project where to find ViSP headers set(VISP_INCLUDE_DIRS "@VISP_INCLUDE_DIRS_CONFIGCMAKE@") # Tells the user project ViSP library name set(VISP_LIBRARIES ${VISP_LIBS}) # need to be improved if(POLICY CMP0024) # Fix to prevent multiple includes if(NOT TARGET visp_core) cmake_policy(PUSH) cmake_policy(SET CMP0024 OLD) # Our library dependencies (contains definitions for IMPORTED targets) include("${CMAKE_CURRENT_LIST_DIR}/VISPModules.cmake") cmake_policy(POP) endif() else() # Fix for cmake 2.8.7 to prevent multiple includes if(NOT TARGET visp_core) # Our library dependencies (contains definitions for IMPORTED targets) include("${CMAKE_CURRENT_LIST_DIR}/VISPModules.cmake") endif() endif() # where to find the USE file to be used by user project set(VISP_USE_FILE "${CMAKE_CURRENT_LIST_DIR}/VISPUse.cmake") if(BUILD_TEST_COVERAGE) # Add build options for test coverage. Currently coverage is only supported # on gcc compiler # Because using -fprofile-arcs with shared lib can cause problems like: # hidden symbol `__bb_init_func', we add this option only for static # library build set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -ftest-coverage -fprofile-arcs") endif() #---------------------------------------------------------------------- # Remember VISP' third party libs configuration: #---------------------------------------------------------------------- set(VISP_HAVE_X11 "@VISP_HAVE_X11@") set(VISP_HAVE_PTHREAD "@VISP_HAVE_PTHREAD@") set(VISP_HAVE_GTK "@VISP_HAVE_GTK@") set(VISP_HAVE_GDI "@VISP_HAVE_GDI@") set(VISP_HAVE_D3D9 "@VISP_HAVE_D3D9@") set(VISP_HAVE_DISPLAY "@VISP_HAVE_DISPLAY@") set(VISP_HAVE_GSL "@VISP_HAVE_GSL@") set(VISP_HAVE_LAPACK_C "@VISP_HAVE_LAPACK_C@") set(VISP_HAVE_LIBFREENECT "@VISP_HAVE_LIBFREENECT@") set(VISP_HAVE_LIBFREENECT_AND_DEPENDENCIES "@VISP_HAVE_LIBFREENECT_AND_DEPENDENCIES@") set(VISP_HAVE_LIBFREENECT_OLD "@VISP_HAVE_LIBFREENECT_OLD@") set(VISP_HAVE_LIBUSB_1 "@VISP_HAVE_LIBUSB_1@") set(VISP_HAVE_REALSENSE "@VISP_HAVE_REALSENSE@") set(VISP_HAVE_OPENCV "@VISP_HAVE_OPENCV@") set(VISP_HAVE_OPENCV_NONFREE "@VISP_HAVE_OPENCV_NONFREE@") set(VISP_HAVE_OPENCV_VERSION "@VISP_HAVE_OPENCV_VERSION@") set(VISP_HAVE_OGRE "@VISP_HAVE_OGRE@") set(VISP_HAVE_OPENGL "@VISP_HAVE_OPENGL@") set(VISP_HAVE_OIS "@VISP_HAVE_OIS@") set(VISP_HAVE_COIN3D_AND_GUI "@VISP_HAVE_COIN3D_AND_GUI@") set(VISP_HAVE_COIN3D "@VISP_HAVE_COIN3D@") set(VISP_HAVE_QT "@VISP_HAVE_QT@") set(VISP_HAVE_SOQT "@VISP_HAVE_SOQT@") set(VISP_HAVE_SOWIN "@VISP_HAVE_SOWIN@") set(VISP_HAVE_SOXT "@VISP_HAVE_SOXT@") set(VISP_HAVE_DC1394 "@VISP_HAVE_DC1394@") set(VISP_HAVE_CMU1394 "@VISP_HAVE_CMU1394@") set(VISP_HAVE_V4L2 "@VISP_HAVE_V4L2@") set(VISP_HAVE_DIRECTSHOW "@VISP_HAVE_DIRECTSHOW@") set(VISP_HAVE_FLYCAPTURE "@VISP_HAVE_FLYCAPTURE@") set(VISP_HAVE_COMEDI "@VISP_HAVE_COMEDI@") set(VISP_HAVE_AFMA4 "@VISP_HAVE_AFMA4@") set(VISP_HAVE_AFMA6 "@VISP_HAVE_AFMA6@") set(VISP_HAVE_BICLOPS "@VISP_HAVE_BICLOPS@") set(VISP_HAVE_PTU46 "@VISP_HAVE_PTU46@") set(VISP_HAVE_VIPER650 "@VISP_HAVE_VIPER650@") set(VISP_HAVE_VIPER850 "@VISP_HAVE_VIPER850@") set(VISP_HAVE_PIONEER "@VISP_HAVE_PIONEER@") set(VISP_HAVE_VIRTUOSE "@VISP_HAVE_VIRTUOSE@") set(VISP_HAVE_PARPORT "@VISP_HAVE_PARPORT@") set(VISP_HAVE_XML2 "@VISP_HAVE_XML2@") set(VISP_HAVE_JPEG "@VISP_HAVE_JPEG@") set(VISP_HAVE_PNG "@VISP_HAVE_PNG@") set(VISP_HAVE_FFMPEG "@VISP_HAVE_FFMPEG@") set(VISP_HAVE_YARP "@VISP_HAVE_YARP@") set(VISP_HAVE_PCL "@VISP_HAVE_PCL@") set(VISP_HAVE_OPENMP "@VISP_HAVE_OPENMP@") set(VISP_HAVE_CPP11_COMPATIBILITY "@VISP_HAVE_CPP11_COMPATIBILITY@") set(VISP_COMPILER_FAIL_REGEX "command line option .* is valid for .* but not for C\\+\\+" # GNU "command line option .* is valid for .* but not for C" # GNU "unrecognized .*option" # GNU "unknown .*option" # Clang "ignoring unknown option" # MSVC "warning D9002" # MSVC, any lang "option .*not supported" # Intel "[Uu]nknown option" # HP "[Ww]arning: [Oo]ption" # SunPro "command option .* is not recognized" # XL "not supported in this configuration; ignored" # AIX "File with unknown suffix passed to linker" # PGI "WARNING: unknown flag:" # Open64 ) #---------------------------------------------------------------------- # Propagate cxx11 compiler option if enabled during ViSP build #---------------------------------------------------------------------- if(VISP_HAVE_CPP11_COMPATIBILITY) set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} @CPP11_CXX_FLAGS@") endif() #---------------------------------------------------------------------- # Propagate openmp compiler option if enabled during ViSP build #---------------------------------------------------------------------- if(VISP_HAVE_OPENMP) set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} @OpenMP_CXX_FLAGS@") endif() #---------------------------------------------------------------------- # Some useful macro to be able to build the tutorials along side ViSP #---------------------------------------------------------------------- # Create a target from the *.cpp file, link against ViSP libraries and add a dependency to ViSP library # tu ensure that the library is build before this target. macro(visp_add_target file_cpp) get_filename_component(target ${file_cpp} NAME_WE) include_directories(${VISP_INCLUDE_DIRS}) add_executable(${target} ${file_cpp}) target_link_libraries(${target} ${VISP_LIBRARIES}) endmacro() # Create a dependency to the target extracted from the *.cpp file and put the target in the solution dependency folder. macro(visp_add_dependency file_cpp dependency) get_filename_component(target ${file_cpp} NAME_WE) if(TARGET visp_${dependency}) add_dependencies(visp_${dependency} ${target}) if(ENABLE_SOLUTION_FOLDERS) set_target_properties(${target} PROPERTIES FOLDER "${dependency}") endif() endif() endmacro() # Copy the data files to the same location than the target associated to the cpp files # Since CMake 3.0.0 policy CMP0026 was introduced to disallow location property on target. # If CMake 3.0.0 is used, we use $ to get the target location if (CMAKE_VERSION VERSION_GREATER 2.8.12) macro(visp_copy_data file_cpp file_data) get_filename_component(target ${file_cpp} NAME_WE) #get_target_property(target_location ${target} LOCATION) get_filename_component(target_location "${target_location}" PATH) add_custom_command( TARGET ${target} POST_BUILD #COMMAND ${CMAKE_COMMAND} -E copy "${file_data}" "${target_location}" COMMAND ${CMAKE_COMMAND} -E copy "${file_data}" "$" ) endmacro() else() macro(visp_copy_data file_cpp file_data) get_filename_component(target ${file_cpp} NAME_WE) get_target_property(target_location ${target} LOCATION) get_filename_component(target_location "${target_location}" PATH) add_custom_command( TARGET ${target} POST_BUILD COMMAND ${CMAKE_COMMAND} -E copy "${file_data}" "${target_location}" ) endmacro() endif() # Check dependencies for examples macro(visp_check_dependencies) set(VP_DEPENDENCIES_FOUND TRUE) foreach(d ${ARGN}) if(NOT TARGET ${d}) #message(WARNING "ViSP: Can't resolve dependency: ${d}") set(VP_DEPENDENCIES_FOUND FALSE) break() endif() endforeach() endmacro() # add subdirectory if dependencies are found # visp_add_subdirectory( REQUIRED_DEPS ) macro(visp_add_subdirectory subdir) set(__deps "") foreach(arg ${ARGN}) if(arg STREQUAL "REQUIRED_DEPS") set(__varname "__deps") else() list(APPEND ${__varname} ${arg}) endif() endforeach() unset(__varname) if(__deps STREQUAL "") set(VP_DEPENDENCIES_FOUND TRUE) else() visp_check_dependencies(${__deps}) endif() if(VP_DEPENDENCIES_FOUND) add_subdirectory(${subdir}) endif() endmacro() # add specific compile flag useful to turn warning coming from 3rdparty macro(visp_set_source_file_compile_flag file) # if(DEFINED ACTIVATE_WARNING_3PARTY_MUTE) # if(ACTIVATE_WARNING_3PARTY_MUTE) set(__cxxflags "") foreach(cxxflag ${ARGN}) visp_check_flag_support(CXX ${cxxflag} __support_flag) if(${__support_flag}) set(__cxxflags "${__cxxflags} ${cxxflag}") endif() endforeach() if(NOT ${__cxxflags} STREQUAL "") if(EXISTS ${CMAKE_CURRENT_LIST_DIR}/${file}) set_source_files_properties(${CMAKE_CURRENT_LIST_DIR}/${file} PROPERTIES COMPILE_FLAGS ${__cxxflags}) elseif(EXISTS ${file}) # for files that are in the build tree (like those produced by qt moc set_source_files_properties(${CMAKE_CURRENT_LIST_DIR}/${file} PROPERTIES COMPILE_FLAGS ${__cxxflags}) endif() endif() # endif() # endif() endmacro() # check if a compiler flag is supported macro(visp_check_flag_support lang flag varname) if("_${lang}_" MATCHES "_CXX_") set(_lang CXX) elseif("_${lang}_" MATCHES "_C_") set(_lang C) else() set(_lang ${lang}) endif() string(TOUPPER "${flag}" ${varname}) string(REGEX REPLACE "^(/|-)" "HAVE_${_lang}_" ${varname} "${${varname}}") string(REGEX REPLACE " -|-|=| |\\." "_" ${varname} "${${varname}}") visp_check_compiler_flag("${_lang}" "${ARGN} ${flag}" ${${varname}}) endmacro() # test if a compiler flag is supported macro(visp_check_compiler_flag LANG FLAG RESULT) if(NOT DEFINED ${RESULT}) if("_${LANG}_" MATCHES "_CXX_") set(_fname "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/src.cxx") #if("${CMAKE_CXX_FLAGS} ${FLAG} " MATCHES "-Werror " OR "${CMAKE_CXX_FLAGS} ${FLAG} " MATCHES "-Werror=unknown-pragmas ") file(WRITE "${_fname}" "int main() { return 0; }\n") #else() # file(WRITE "${_fname}" "#pragma\nint main() { return 0; }\n") #endif() elseif("_${LANG}_" MATCHES "_C_") set(_fname "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/src.c") #if("${CMAKE_C_FLAGS} ${FLAG} " MATCHES "-Werror " OR "${CMAKE_C_FLAGS} ${FLAG} " MATCHES "-Werror=unknown-pragmas ") file(WRITE "${_fname}" "int main(void) { return 0; }\n") #else() # file(WRITE "${_fname}" "#pragma\nint main(void) { return 0; }\n") #endif() elseif("_${LANG}_" MATCHES "_OBJCXX_") set(_fname "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/src.mm") #if("${CMAKE_CXX_FLAGS} ${FLAG} " MATCHES "-Werror " OR "${CMAKE_CXX_FLAGS} ${FLAG} " MATCHES "-Werror=unknown-pragmas ") file(WRITE "${_fname}" "int main() { return 0; }\n") #else() # file(WRITE "${_fname}" "#pragma\nint main() { return 0; }\n") #endif() else() unset(_fname) endif() if(_fname) message(STATUS "Performing Test ${RESULT}") try_compile(${RESULT} "${CMAKE_BINARY_DIR}" "${_fname}" COMPILE_DEFINITIONS "${FLAG}" OUTPUT_VARIABLE OUTPUT) foreach(_regex ${VISP_COMPILER_FAIL_REGEX}) if("${OUTPUT}" MATCHES "${_regex}") set(${RESULT} 0) break() endif() endforeach() if(${RESULT}) set(${RESULT} 1 CACHE INTERNAL "Test ${RESULT}") message(STATUS "Performing Test ${RESULT} - Success") else() message(STATUS "Performing Test ${RESULT} - Failed") set(${RESULT} "" CACHE INTERNAL "Test ${RESULT}") file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log "Compilation failed:\n" " source file: '${_fname}'\n" " check option: '${FLAG}'\n" "===== BUILD LOG =====\n" "${OUTPUT}\n" "===== END =====\n\n") endif() else() set(${RESULT} 0) endif() endif() endmacro() visp-3.0.1/cmake/templates/VISPConfigVersion.cmake.in000066400000000000000000000024451304511007300224350ustar00rootroot00000000000000# This is a basic version file for the Config-mode of find_package(). # It is used by write_basic_package_version_file() as input file for configure_file() # to create a version-file which can be installed along a config.cmake file. # # The created file sets PACKAGE_VERSION_EXACT if the current version string and # the requested version string are exactly the same and it sets # PACKAGE_VERSION_COMPATIBLE if the current version is >= requested version. # The variable VISP_VERSION must be set before calling configure_file(). set(PACKAGE_VERSION @VISP_VERSION@) # There is a bug in CMake (at least in 2.7.0) whereby calling "find_package(FOO)" within # "find_package(FOO)" results in the version being checked in the # second version no matter if it was set. To get around this, check # "PACKAGE_FIND_VERSION" and if empty set return variables to TRUE to # make CMake happy. Not the best solution, but it does the trick. if(NOT PACKAGE_FIND_VERSION) set(PACKAGE_VERSION_COMPATIBLE TRUE) set(PACKAGE_VERSION_EXACT TRUE) return() endif() if("${PACKAGE_VERSION}" VERSION_LESS "${PACKAGE_FIND_VERSION}" ) set(PACKAGE_VERSION_COMPATIBLE FALSE) else() set(PACKAGE_VERSION_COMPATIBLE TRUE) if( "${PACKAGE_FIND_VERSION}" STREQUAL "${PACKAGE_VERSION}") set(PACKAGE_VERSION_EXACT TRUE) endif() endif() visp-3.0.1/cmake/templates/cmake_uninstall.cmake.in000066400000000000000000000044131304511007300223260ustar00rootroot00000000000000############################################################################# # # This file is part of the ViSP software. # Copyright (C) 2005 - 2017 by Inria. All rights reserved. # # This software is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public License # ("GPL") version 2 as published by the Free Software Foundation. # See the file LICENSE.txt at the root directory of this source # distribution for additional information about the GNU GPL. # # For using ViSP with software that can not be combined with the GNU # GPL, please contact Inria about acquiring a ViSP Professional # Edition License. # # See http://visp.inria.fr for more information. # # This software was developed at: # Inria Rennes - Bretagne Atlantique # Campus Universitaire de Beaulieu # 35042 Rennes Cedex # France # # If you have questions regarding the use of this file, please contact # Inria at visp@inria.fr # # This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE # WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. # # Description: # Comes from http://www.cmake.org/Wiki/CMake_FAQ to create an uninstall target # # Authors: # Fabien Spindler # ############################################################################# IF(NOT EXISTS "@CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt") #MESSAGE("Cannot find install manifest: \"@CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt\"") MESSAGE("There is no files to uninstall") ELSE(NOT EXISTS "@CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt") FILE(READ "@CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt" files) STRING(REGEX REPLACE "\n" ";" files "${files}") FOREACH(file ${files}) MESSAGE(STATUS "Uninstalling \"${file}\"") IF(EXISTS "${file}") EXEC_PROGRAM( "@CMAKE_COMMAND@" ARGS "-E remove \"${file}\"" OUTPUT_VARIABLE rm_out RETURN_VALUE rm_retval ) IF("${rm_retval}" STREQUAL 0) ELSE("${rm_retval}" STREQUAL 0) MESSAGE(FATAL_ERROR "Problem when removing \"${file}\"") ENDIF("${rm_retval}" STREQUAL 0) ELSE(EXISTS "${file}") MESSAGE(STATUS "File \"${file}\" does not exist.") ENDIF(EXISTS "${file}") ENDFOREACH(file) ENDIF(NOT EXISTS "@CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt") visp-3.0.1/cmake/templates/resources.cfg.in000066400000000000000000000003161304511007300206440ustar00rootroot00000000000000# Resources required by the sample browser and most samples. [Essential] #Zip=@OGRE_MEDIA_DIR@/packs/SdkTrays.zip # Resource locations to be added to the default path [General] @OGRE_RESOURCES_FileSystem@ visp-3.0.1/cmake/templates/visp-config.bat.in000077500000000000000000000070541304511007300210760ustar00rootroot00000000000000@rem ############################################################################# @rem # @rem # This file is part of the ViSP software. @rem # Copyright (C) 2005 - 2017 by Inria. All rights reserved. @rem # @rem # This software is free software; you can redistribute it and/or @rem # modify it under the terms of the GNU General Public License @rem # ("GPL") version 2 as published by the Free Software Foundation. @rem # See the file LICENSE.txt at the root directory of this source @rem # distribution for additional information about the GNU GPL. @rem # @rem # For using ViSP with software that can not be combined with the GNU @rem # GPL, please contact Inria about acquiring a ViSP Professional @rem # Edition License. @rem # @rem # See http://visp.inria.fr for more information. @rem # @rem # This software was developed at: @rem # Inria Rennes - Bretagne Atlantique @rem # Campus Universitaire de Beaulieu @rem # 35042 Rennes Cedex @rem # France @rem # @rem # If you have questions regarding the use of this file, please contact @rem # Inria at visp@inria.fr @rem # @rem # This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE @rem # WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. @rem # @rem # Description: @rem # visp-config.bat script for Windows. @rem # Auto-generated from visp-config.bat.in by cmake. @rem # @rem # Authors: @rem # Fabien Spindler @rem # @rem ############################################################################# @echo off @rem Get the dirname @rem for /F %%x in ('CHDIR') do set PREFIX=%%x\.. set CURPATH=%CD /d %%~dp0% @rem echo CURPATH: %CURPATH% set PREFIX=%CURPATH%\.. set VERSION=${VISP_VERSION} set DEFS=${VISP_CONFIG_SCRIPT_DEFS} set INCLUDE="${VISP_CONFIG_SCRIPT_INC}" set OPENMP_SUPPORT=${VISP_OPENMP_SUPPORT} set LIBDIR="${VISP_CONFIG_SCRIPT_LIBDIR}" set LIBS_DEBUG=${VISP_CONFIG_SCRIPT_LIBS_DEBUG} set LIBS_OPTIMIZED=${VISP_CONFIG_SCRIPT_LIBS_OPTIMIZED} @rem Test if an argument is provided if "%1" == "" goto USAGE @rem Parse the argument list for %%a in (%*) do ( @rem echo Read arg %%a if "%%a" == "--help" ( goto USAGE ) if "%%a" == "--prefix" ( echo %PREFIX% goto END ) if "%%a" == "--def" ( echo %DEFS% goto END ) if "%%a" == "--include" ( echo %INCLUDE% goto END ) if "%%a" == "--openmp" ( echo %OPENMP_SUPPORT% goto END ) if "%%a" == "--libpath" ( echo %LIBDIR% goto END ) if "%%a" == "--libs-debug" ( echo %LIBS_DEBUG% goto END ) if "%%a" == "--libs-optimized" ( echo %LIBS_OPTIMIZED% goto END ) if "%%a" == "--version" ( echo ViSP %VERSION% Visual Servoing Platform echo. echo Copyright 2005 - 2017 Inria. All rights reserved. goto END ) if "%%a" == "--dumpversion" ( echo %VERSION% goto END ) ) :USAGE echo ViSP %VERSION% (Visual Servoing Platform) echo Copyright (C) 2005 - 2017 Inria. All rights reserved. echo. echo Usage: %0 [--prefix] [--def] [--include] [--openmp] [--libpath] echo [--libs-debug] [--libs-optimized] [--version] [--dumpversion] [--help] echo. echo --prefix Show ViSP installation prefix. echo --def Print pre-processor definitions. echo --include Print include directories. echo --openmp Indicates if OpenMP support has to be turned on/off. echo --libpath Print library directories. echo --libs-debug Print library dependencies for debug configuration. echo --libs-optimized Print library dependencies for optimized configuration. echo --dumpversion Output ViSP version information. echo --help Display this help and exit. echo. goto END :End visp-3.0.1/cmake/templates/visp-config.in000077500000000000000000000053441304511007300203310ustar00rootroot00000000000000#!/bin/sh ############################################################################# # # This file is part of the ViSP software. # Copyright (C) 2005 - 2017 by Inria. All rights reserved. # # This software is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public License # ("GPL") version 2 as published by the Free Software Foundation. # See the file LICENSE.txt at the root directory of this source # distribution for additional information about the GNU GPL. # # For using ViSP with software that can not be combined with the GNU # GPL, please contact Inria about acquiring a ViSP Professional # Edition License. # # See http://visp.inria.fr for more information. # # This software was developed at: # Inria Rennes - Bretagne Atlantique # Campus Universitaire de Beaulieu # 35042 Rennes Cedex # France # # If you have questions regarding the use of this file, please contact # Inria at visp@inria.fr # # This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE # WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. # # Description: # visp-config shell script. # Auto-generated from visp-config.in by cmake. # # Authors: # Fabien Spindler # ############################################################################# relpath=`dirname $0` relpath=`(cd $relpath/..; pwd)` PREFIX=$relpath CFLAGS="${VISP_CONFIG_CFLAGS_SCRIPT}" LIBS="${VISP_CONFIG_LIBS_SCRIPT}" VERSION="${VISP_VERSION}" NO_NEWLINE_CHARACTER="${VISP_ECHO_NO_NEWLINE_CHARACTER}" NO_NEWLINE_OPTION="${VISP_ECHO_NO_NEWLINE_OPTION}" usage() { cat <= 1200 #pragma warning( disable: 4100 4127 4251 4275 4351 4514 4668 4710 4820 ) #if _MSC_VER >= 1400 // 1400 = MSVC 8 2005 #pragma warning( disable: 4548 ) #endif #if _MSC_VER > 1500 // 1500 = MSVC 9 2008 #pragma warning( disable: 4986 ) #endif #ifdef WINRT #pragma warning(disable:4447) #endif // 4100 : undocumented ("unreferenced formal parameter") // 4127 : conditional expression is constant // 4251 : 'identifier' : class 'type' needs to have dll-interface to be used by clients of class 'type2', ie. disable warnings related to inline functions // 4275 : non – DLL-interface classkey 'identifier' used as base for DLL-interface classkey 'identifier' // 4351 : new behavior: elements of array will be default initialized // 4447 : Disable warning 'main' signature found without threading model // 4514 : 'function' : unreferenced inline function has been removed // 4548 : expression before comma has no effect // 4668 : 'symbol' is not defined as a preprocessor macro, replacing with '0' for 'directives' // 4710 : 'function' : function not inlined // 4820 : 'bytes' bytes padding added after construct 'member_name' // 4986 : undocumented #ifndef NOMINMAX #define NOMINMAX #endif #endif #if defined _MSC_VER && (_MSC_VER == 1500) // Visual Studio 9 2008 specific stuff // Fix running 64-bit OpenMP Debug Builds compiled with Visual Studio 2008 SP1 // See discussion on https://gforge.inria.fr/forum/message.php?msg_id=149273&group_id=397 // and the proposed fix: http://www.johanseland.com/2010/08/running-64-bit-openmp-debug-builds.html # define _BIND_TO_CURRENT_OPENMP_VERSION 1 #endif #if defined(__MINGW__) || defined(__MINGW32__) || defined(__MINGW64__) // Work arround to fix build issues that may occur with Mingw: // error: 'DBL_EPSILON' was not declared in this scope // error: 'FLT_EPSILON' was not declared in this scope # include # ifndef DBL_EPSILON # define DBL_EPSILON __DBL_EPSILON__ # endif # ifndef FLT_EPSILON # define FLT_EPSILON __FLT_EPSILON__ # endif #endif #include // ViSP major version. #define VISP_VERSION_MAJOR ${VISP_VERSION_MAJOR} // ViSP minor version. #define VISP_VERSION_MINOR ${VISP_VERSION_MINOR} // ViSP patch version. #define VISP_VERSION_PATCH ${VISP_VERSION_PATCH} // ViSP version with dots "${VISP_VERSION_MAJOR}.${VISP_VERSION_MINOR}.${VISP_VERSION_PATCH}". #cmakedefine VISP_VERSION ${VISP_VERSION} // ViSP version as an integer #define VP_VERSION_INT(a, b, c) (a<<16 | b<<8 | c) #define VISP_VERSION_INT VP_VERSION_INT(VISP_VERSION_MAJOR, \ VISP_VERSION_MINOR, \ VISP_VERSION_PATCH) // ViSP library is either compiled static or shared // Used to set declspec(import, export) in headers if required under Windows #cmakedefine VISP_BUILD_SHARED_LIBS // Defined if deprecated functionalities are requested to build #cmakedefine VISP_BUILD_DEPRECATED_FUNCTIONS // Defined if MSVC is the compiler #cmakedefine VISP_USE_MSVC // Defined if X11 library available. #cmakedefine VISP_HAVE_X11 // Defined if XML2 library available. #cmakedefine VISP_HAVE_XML2 // Defined if pthread library available. #cmakedefine VISP_HAVE_PTHREAD // Defined if YARP available. #cmakedefine VISP_HAVE_YARP // Defined if OpenCV available. #cmakedefine VISP_HAVE_OPENCV // Defined if OpenCV nonfree module available. Only with OpenCV < 3.0.0 #cmakedefine VISP_HAVE_OPENCV_NONFREE // Defined if OpenCV xfeatures2d module available. Only since OpenCV >= 3.0.0 #cmakedefine VISP_HAVE_OPENCV_XFEATURES2D // OpenCV version in hexadecimal (for example 2.1.0 gives 0x020100). #ifdef VISP_HAVE_OPENCV # define VISP_HAVE_OPENCV_VERSION ${VISP_HAVE_OPENCV_VERSION} #endif // Defined if GTK2 library available #cmakedefine VISP_HAVE_GTK // Defined if GDI (Graphics Device Interface) library available #cmakedefine VISP_HAVE_GDI // Defined if Direct3D9 library available #cmakedefine VISP_HAVE_D3D9 // Defined if one of the display device is available #if defined(VISP_HAVE_X11) || defined(VISP_HAVE_GDI) || defined(VISP_HAVE_OPENCV) || defined(VISP_HAVE_D3D9) || defined(VISP_HAVE_GTK) # define VISP_HAVE_DISPLAY #endif // Defined if GSL library available (-lgsl -lgslcblas). #cmakedefine VISP_HAVE_GSL // Defined if lapack/blas libraries are available (-lblas -llapack). #cmakedefine VISP_HAVE_LAPACK_C // Defined the path to the basic scenes used by the simulator #cmakedefine VISP_SCENES_DIR "${VISP_SCENES_DIR}" // Defined the path to the robot's arms 3D model used by the robot simulators #cmakedefine VISP_ROBOT_ARMS_DIR "${VISP_ROBOT_ARMS_DIR}" // Defined if Ogre3d is available. #cmakedefine VISP_HAVE_OGRE // Defined if Ogre3d plugins.cfg is available. #cmakedefine VISP_HAVE_OGRE_PLUGINS_PATH "${VISP_HAVE_OGRE_PLUGINS_PATH}" // Defined if Ogre3d resources.cfg is available. #cmakedefine VISP_HAVE_OGRE_RESOURCES_PATH "${VISP_HAVE_OGRE_RESOURCES_PATH}" // Defined if OIS (Object Oriented Input System) library available. #cmakedefine VISP_HAVE_OIS // Defined if Coin3D and one of the GUI (SoXt, SoWin, SoQt + Qt) // libraries are available. #cmakedefine VISP_HAVE_COIN3D_AND_GUI // provided for compat with previous releases #ifdef VISP_HAVE_COIN3D_AND_GUI # define VISP_HAVE_COIN_AND_GUI #endif // Defined if Coin3D library available. #cmakedefine VISP_HAVE_COIN3D // provided for compat with previous releases #ifdef VISP_HAVE_COIN3D # define VISP_HAVE_COIN #endif // Defined if OpenGL library available. #cmakedefine VISP_HAVE_OPENGL // Defined if Qt library available (either Qt-3 or Qt-4). #cmakedefine VISP_HAVE_QT // Defined if SoQt library available. #cmakedefine VISP_HAVE_SOQT // Defined if SoWin library available. #cmakedefine VISP_HAVE_SOWIN // Defined if SoXt library available. #cmakedefine VISP_HAVE_SOXT // Defined if libjpeg library available. #cmakedefine VISP_HAVE_JPEG #ifdef VISP_HAVE_JPEG # define VISP_HAVE_LIBJPEG #endif // Defined if libpng library available. #cmakedefine VISP_HAVE_PNG #ifdef VISP_HAVE_PNG # define VISP_HAVE_LIBPNG #endif // Defined if libfreenect, libusb-1.0 and libpthread libraries available. #cmakedefine VISP_HAVE_LIBFREENECT_AND_DEPENDENCIES // Defined if libfreenect library available. #cmakedefine VISP_HAVE_LIBFREENECT // Defined if libfreenect library in an old version package for // ubuntu 10.04 lucid is available. // This is a workaround useful to initialise vpKinect depending on the // libfreenect version //#ifdef VISP_HAVE_LIBFREENECT_OLD // Freenect::Freenect freenect; // vpKinect & kinect = freenect.createDevice(0); //#else // Freenect::Freenect freenect; // vpKinect & kinect = freenect.createDevice(0); //#endif #cmakedefine VISP_HAVE_LIBFREENECT_OLD // Defined if libusb-1.0 library available. #cmakedefine VISP_HAVE_LIBUSB_1 // Defined if RealSense library available. #cmakedefine VISP_HAVE_REALSENSE // Defined if ffmpeg library available. #cmakedefine VISP_HAVE_FFMPEG // Defined if raw1394 and dc1394-2.x libraries available. #cmakedefine VISP_HAVE_DC1394 #if defined(VISP_BUILD_DEPRECATED_FUNCTIONS) && defined(VISP_HAVE_DC1394) # define VISP_HAVE_DC1394_2 #endif // Defined if dc1394_camera_enumerate() is available in dc1394-2.x. // dc1394_camera_enumerate() was introduced after libdc1394-2.0.0-rc7. #cmakedefine VISP_HAVE_DC1394_CAMERA_ENUMERATE #if defined(VISP_BUILD_DEPRECATED_FUNCTIONS) && defined(VISP_HAVE_DC1394_CAMERA_ENUMERATE) # define VISP_HAVE_DC1394_2_CAMERA_ENUMERATE #endif // Defined if dc1394_find_cameras() is available in dc1394-2.x // dc1394_find_cameras() is still present until libdc1394-2.0.0-rc7. // This function was suppress and replace by dc1394_camera_enumerate() // in more recent releases. #cmakedefine VISP_HAVE_DC1394_FIND_CAMERAS #if defined(VISP_BUILD_DEPRECATED_FUNCTIONS) && defined(VISP_HAVE_DC1394_FIND_CAMERAS) # define VISP_HAVE_DC1394_2_FIND_CAMERAS #endif // Defined if CMU 1394 Digital Camera SDK available. #cmakedefine VISP_HAVE_CMU1394 // Defined if Video For Linux Two available. #cmakedefine VISP_HAVE_V4L2 // Defined if DirectShow library is available (only under Windows). #cmakedefine VISP_HAVE_DIRECTSHOW // Defined if PointGrey FlyCapture SDK available. #cmakedefine VISP_HAVE_FLYCAPTURE // Defined if Comedi (linux control and measurement cdevice interface) available. #cmakedefine VISP_HAVE_COMEDI // Defined if ATIDAQ-C is build and available. #cmakedefine VISP_HAVE_ATIDAQ // Defined if Irisa's Afma4 robot available. #cmakedefine VISP_HAVE_AFMA4 // Defined if Irisa's Afma6 robot available. #cmakedefine VISP_HAVE_AFMA6 // Defined if Irisa's Afma6 data files (camera intrinsic/extrinsic parameters) are available #cmakedefine VISP_HAVE_AFMA6_DATA #define VISP_AFMA6_DATA_PATH "${VISP_AFMA6_DATA_PATH}" // Defined if Biclops pan-tilt head available. #cmakedefine VISP_HAVE_BICLOPS #cmakedefine VISP_HAVE_BICLOPS_AND_GET_HOMED_STATE_FUNCTION // Defined if Irisa's Ptu-46 pan-tilt head available. #cmakedefine VISP_HAVE_PTU46 // Defined if Irisa's Viper S650 robot available. #cmakedefine VISP_HAVE_VIPER650 // Defined if Inria's Viper650 data files (camera intrinsic/extrinsic parameters) are available #cmakedefine VISP_HAVE_VIPER650_DATA #define VISP_VIPER650_DATA_PATH "${VISP_VIPER650_DATA_PATH}" // Defined if Irisa's Viper S850 robot available. #cmakedefine VISP_HAVE_VIPER850 // Defined if Inria's Viper850 data files (camera intrinsic/extrinsic parameters) are available #cmakedefine VISP_HAVE_VIPER850_DATA #define VISP_VIPER850_DATA_PATH "${VISP_VIPER850_DATA_PATH}" // Defined if the Aria library and (pthread, rt, dl libraries under Unix) is found. // These libraries are used to control Pioneer mobile robots. #cmakedefine VISP_HAVE_PIONEER // Defined if Haption Virtuose SDK available. #cmakedefine VISP_HAVE_VIRTUOSE // Defined if linux/parport.h is available for parallel port usage. #cmakedefine VISP_HAVE_PARPORT // Defined if libzbar is available for bar code detection #cmakedefine VISP_HAVE_ZBAR // Defined if Point Cloud Library is available #cmakedefine VISP_HAVE_PCL // Defined if libdmtx is available for bar code detection #cmakedefine VISP_HAVE_DMTX // Defined if Doxygen documentation tool is found #cmakedefine VISP_HAVE_DOXYGEN // Defined if we want to compute interaction matrices by combining // other interaction matrices #cmakedefine VISP_MOMENTS_COMBINE_MATRICES //Defined if we want to use openmp #cmakedefine VISP_HAVE_OPENMP //Defined if we want to use c++ 11 #cmakedefine VISP_HAVE_CPP11_COMPATIBILITY // Defined if isnan macro is available #cmakedefine VISP_HAVE_FUNC_ISNAN // Defined if std::isnan function is available #cmakedefine VISP_HAVE_FUNC_STD_ISNAN // Defined if _isnan (Microsoft version) is available #cmakedefine VISP_HAVE_FUNC__ISNAN // Defined if isinf macro is available #cmakedefine VISP_HAVE_FUNC_ISINF // Defined if std::isinf function is available #cmakedefine VISP_HAVE_FUNC_STD_ISINF // Defined if _finite (Microsoft version) function is available #cmakedefine VISP_HAVE_FUNC__FINITE // Defined if round function is available #cmakedefine VISP_HAVE_FUNC_ROUND // Defined if std::round function is available #cmakedefine VISP_HAVE_FUNC_STD_ROUND // Defined if erfc function is available #cmakedefine VISP_HAVE_FUNC_ERFC // Defined if std::erfc function is available #cmakedefine VISP_HAVE_FUNC_STD_ERFC // Defined if strtof function is available #cmakedefine VISP_HAVE_FUNC_STRTOF // Defined if xrandr program available #cmakedefine VISP_HAVE_XRANDR // Handle portable symbol export. // Defining manually which symbol should be exported is required // under Windows whether MinGW or MSVC is used. // // The headers then have to be able to work in two different modes: // - dllexport when one is building the library, // - dllimport for clients using the library. // // On Linux, set the visibility accordingly. If C++ symbol visibility // is handled by the compiler, see: http://gcc.gnu.org/wiki/Visibility # if defined(_WIN32) || defined(__CYGWIN__) // On Microsoft Windows, use dllimport and dllexport to tag symbols. # define VISP_DLLIMPORT __declspec(dllimport) # define VISP_DLLEXPORT __declspec(dllexport) # define VISP_DLLLOCAL # else // On Linux, for GCC >= 4, tag symbols using GCC extension. # if __GNUC__ >= 4 # define VISP_DLLIMPORT __attribute__ ((visibility("default"))) # define VISP_DLLEXPORT __attribute__ ((visibility("default"))) # define VISP_DLLLOCAL __attribute__ ((visibility("hidden"))) # else // Otherwise (GCC < 4 or another compiler is used), export everything. # define VISP_DLLIMPORT # define VISP_DLLEXPORT # define VISP_DLLLOCAL # endif // __GNUC__ >= 4 # endif // defined(_WIN32) || defined(__CYGWIN__) // Under Windows, for shared libraries (DLL) we need to define export on // compilation or import on use (like a third party project). // We exploit here the fact that cmake auto set xxx_EXPORTS (with S) on // compilation. #if defined(VISP_BUILD_SHARED_LIBS) // Depending on whether one is building or using the // library define VISP_EXPORT to import or export. # ifdef visp_EXPORTS # define VISP_EXPORT VISP_DLLEXPORT # else # define VISP_EXPORT VISP_DLLIMPORT # endif # define VISP_LOCAL VISP_DLLLOCAL #else // If one is using the library statically, get rid of // extra information. # define VISP_EXPORT # define VISP_LOCAL #endif // Add the material to produce a warning when deprecated functions are used #ifndef vp_deprecated # if !defined(_WIN32) && (defined(__unix__) || defined(__unix) || (defined(__APPLE__) && defined(__MACH__))) // UNIX # define vp_deprecated __attribute__((deprecated)) # else # define vp_deprecated __declspec(deprecated) # endif #endif #endif visp-3.0.1/cmake/templates/vpHeader.h.in000066400000000000000000000001451304511007300200600ustar00rootroot00000000000000/* * ** File generated automatically, do not modify ** * */ @VISP_HEADER_CONTENT_CONFIGMAKE@ visp-3.0.1/demo/000077500000000000000000000000001304511007300134125ustar00rootroot00000000000000visp-3.0.1/demo/CMakeLists.txt000066400000000000000000000045361304511007300161620ustar00rootroot00000000000000############################################################################# # # This file is part of the ViSP software. # Copyright (C) 2005 - 2017 by Inria. All rights reserved. # # This software is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public License # ("GPL") version 2 as published by the Free Software Foundation. # See the file LICENSE.txt at the root directory of this source # distribution for additional information about the GNU GPL. # # For using ViSP with software that can not be combined with the GNU # GPL, please contact Inria about acquiring a ViSP Professional # Edition License. # # See http://visp.inria.fr for more information. # # This software was developed at: # Inria Rennes - Bretagne Atlantique # Campus Universitaire de Beaulieu # 35042 Rennes Cedex # France # # If you have questions regarding the use of this file, please contact # Inria at visp@inria.fr # # This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE # WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. # # Description: # ViSP overall configuration file. # # Authors: # Nicolas Melchior # ############################################################################# project(ViSP-demo) cmake_minimum_required(VERSION 2.6) find_package(VISP) if(MSVC) if(NOT VISP_SHARED) foreach(flag_var CMAKE_C_FLAGS CMAKE_C_FLAGS_DEBUG CMAKE_C_FLAGS_RELEASE CMAKE_C_FLAGS_MINSIZEREL CMAKE_C_FLAGS_RELWITHDEBINFO CMAKE_CXX_FLAGS CMAKE_CXX_FLAGS_DEBUG CMAKE_CXX_FLAGS_RELEASE CMAKE_CXX_FLAGS_MINSIZEREL CMAKE_CXX_FLAGS_RELWITHDEBINFO) if(${flag_var} MATCHES "/MD") string(REGEX REPLACE "/MD" "/MT" ${flag_var} "${${flag_var}}") endif() if(${flag_var} MATCHES "/MDd") string(REGEX REPLACE "/MDd" "/MTd" ${flag_var} "${${flag_var}}") endif() endforeach(flag_var) set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /NODEFAULTLIB:atlthunk.lib /NODEFAULTLIB:msvcrt.lib /NODEFAULTLIB:msvcrtd.lib") set(CMAKE_EXE_LINKER_FLAGS_DEBUG "${CMAKE_EXE_LINKER_FLAGS_DEBUG} /NODEFAULTLIB:libcmt.lib") set(CMAKE_EXE_LINKER_FLAGS_RELEASE "${CMAKE_EXE_LINKER_FLAGS_RELEASE} /NODEFAULTLIB:libcmtd.lib") endif() endif() visp_add_subdirectory(wireframe-simulator REQUIRED_DEPS visp_core visp_robot visp_vs visp_io visp_gui) visp-3.0.1/demo/wireframe-simulator/000077500000000000000000000000001304511007300174105ustar00rootroot00000000000000visp-3.0.1/demo/wireframe-simulator/CMakeLists.txt000066400000000000000000000042761304511007300221610ustar00rootroot00000000000000############################################################################# # # This file is part of the ViSP software. # Copyright (C) 2005 - 2017 by Inria. All rights reserved. # # This software is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public License # ("GPL") version 2 as published by the Free Software Foundation. # See the file LICENSE.txt at the root directory of this source # distribution for additional information about the GNU GPL. # # For using ViSP with software that can not be combined with the GNU # GPL, please contact Inria about acquiring a ViSP Professional # Edition License. # # See http://visp.inria.fr for more information. # # This software was developed at: # Inria Rennes - Bretagne Atlantique # Campus Universitaire de Beaulieu # 35042 Rennes Cedex # France # # If you have questions regarding the use of this file, please contact # Inria at visp@inria.fr # # This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE # WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. # # Description: # ViSP overall configuration file. # # Authors: # Fabien Spindler # ############################################################################# project(demo-wireframe-simulator) cmake_minimum_required(VERSION 2.8) find_package(VISP REQUIRED visp_core visp_robot visp_vs visp_io visp_gui) # SOURCE variable corresponds to the list of all the sources to build binaries. # The generate binary comes by removing the .cpp extension to # the source name. # # If you want to add/remove a source, modify here set(demo_cpp servoSimu4Points.cpp servoSimuCylinder.cpp servoSimuSphere.cpp ) foreach(cpp ${demo_cpp}) visp_add_target(${cpp}) if(COMMAND visp_add_dependency) visp_add_dependency(${cpp} "demos") endif() endforeach() # Add test # To run some of these tests don't forget to set VISP_INPUT_IMAGE_PATH # environment variable to the ViSP test sequences location. # To get these sequence download ViSP-images.tar.gz from # http://www.irisa.fr/lagadic/visp/visp.html add_test(servoSimu4Points servoSimu4Points -d) add_test(servoSimuCylinder servoSimuCylinder -d) add_test(servoSimuSphere servoSimuSphere -d) visp-3.0.1/demo/wireframe-simulator/servoSimu4Points.cpp000066400000000000000000000332711304511007300233770ustar00rootroot00000000000000/**************************************************************************** * * This file is part of the ViSP software. * Copyright (C) 2005 - 2017 by Inria. All rights reserved. * * This software is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License * ("GPL") version 2 as published by the Free Software Foundation. * See the file LICENSE.txt at the root directory of this source * distribution for additional information about the GNU GPL. * * For using ViSP with software that can not be combined with the GNU * GPL, please contact Inria about acquiring a ViSP Professional * Edition License. * * See http://visp.inria.fr for more information. * * This software was developed at: * Inria Rennes - Bretagne Atlantique * Campus Universitaire de Beaulieu * 35042 Rennes Cedex * France * * If you have questions regarding the use of this file, please contact * Inria at visp@inria.fr * * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. * * Description: * Demonstration of the wireframe simulator with a simple visual servoing * * Authors: * Nicolas Melchior * *****************************************************************************/ /*! \example servoSimu4Points.cpp Demonstration of the wireframe simulator with a simple visual servoing. */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #define GETOPTARGS "dh" #ifdef VISP_HAVE_DISPLAY void usage(const char *name, std::string ipath, const char *badparam); bool getOptions(int argc, const char **argv, std::string &ipath, bool &display); /*! Print the program options. \param name : Program name. \param ipath : Input image path. \param badparam : Bad parameter name. */ void usage(const char *name, std::string ipath, const char *badparam) { fprintf(stdout, "\n\ Demonstration of the wireframe simulator with a simple visual servoing.\n\ \n\ The visual servoing consists in bringing the camera at a desired \n\ position from the object.\n\ \n\ The visual features used to compute the pose of the camera and \n\ thus the control law are four points.\n\ \n\ This demonstration explains also how to move the object around a world\n\ reference frame. Here, the movement is a rotation around the x and y axis\n\ at a given distance from the world frame. In fact the object trajectory\n\ is on a sphere whose center is the origin of the world frame.\n\ \n\ SYNOPSIS\n\ %s [-d] [-h]\n", name); fprintf(stdout, "\n\ OPTIONS: Default\n\ -i %s\n\ Set mire.pgm image input path.\n\ From this path read \"ViSP-images/mire/mire.pgm\" video.\n\ Setting the VISP_INPUT_IMAGE_PATH environment variable \n\ produces the same behaviour than using this option.\n\ \n\ -d \n\ Turn off the display.\n\ \n\ -h\n\ Print the help.\n", ipath.c_str()); if (badparam) fprintf(stdout, "\nERROR: Bad parameter [%s]\n", badparam); } /*! Set the program options. \param argc : Command line number of parameters. \param argv : Array of command line parameters. \param ipath : Input image path. \param display : Display activation. \return false if the program has to be stopped, true otherwise. */ bool getOptions(int argc, const char **argv, std::string &ipath, bool &display) { const char *optarg_; int c; while ((c = vpParseArgv::parse(argc, argv, GETOPTARGS, &optarg_)) > 1) { switch (c) { case 'i': ipath = optarg_; break; case 'd': display = false; break; case 'h': usage(argv[0],ipath, NULL); return false; break; default: usage(argv[0],ipath, optarg_); return false; break; } } if ((c == 1) || (c == -1)) { // standalone param or error usage(argv[0], ipath, NULL); std::cerr << "ERROR: " << std::endl; std::cerr << " Bad argument " << optarg_ << std::endl << std::endl; return false; } return true; } int main(int argc, const char ** argv) { try { bool opt_display = true; std::string opt_ipath; std::string env_ipath; std::string ipath ; std::string filename; // Read the command line options if (getOptions(argc, argv, opt_ipath, opt_display) == false) { exit (-1); } vpImage Iint(480,640,255); vpImage Iext1(480,640,255); vpImage Iext2(480,640,255); #if defined VISP_HAVE_X11 vpDisplayX display[3]; #elif defined VISP_HAVE_OPENCV vpDisplayOpenCV display[3]; #elif defined VISP_HAVE_GDI vpDisplayGDI display[3]; #elif defined VISP_HAVE_D3D9 vpDisplayD3D display[3]; #elif defined VISP_HAVE_GTK vpDisplayGTK display[3]; #endif if (opt_display) { // Display size is automatically defined by the image (I) size display[0].init(Iint, 100, 100,"The internal view") ; display[1].init(Iext1, 100, 100,"The first external view") ; display[2].init(Iext2, 100, 100,"The second external view") ; vpDisplay::setWindowPosition (Iint, 0, 0); vpDisplay::setWindowPosition (Iext1, 700, 0); vpDisplay::setWindowPosition (Iext2, 0, 550); vpDisplay::display(Iint); vpDisplay::flush(Iint); vpDisplay::display(Iext1); vpDisplay::flush(Iext1); vpDisplay::display(Iext2); vpDisplay::flush(Iext2); } vpServo task; vpSimulatorCamera robot ; float sampling_time = 0.040f; // Sampling period in second robot.setSamplingTime(sampling_time); // Since the task gain lambda is very high, we need to increase default max velocities robot.setMaxTranslationVelocity(10); robot.setMaxRotationVelocity(vpMath::rad(180)); // Set initial position of the object in the camera frame vpHomogeneousMatrix cMo(0,0.1,2.0,vpMath::rad(35),vpMath::rad(25),0); // Set desired position of the object in the camera frame vpHomogeneousMatrix cdMo(0.0,0.0,1.0,vpMath::rad(0),vpMath::rad(0),vpMath::rad(0)); // Set initial position of the object in the world frame vpHomogeneousMatrix wMo(0.0,0.0,0.2,0,0,0); // Position of the camera in the world frame vpHomogeneousMatrix wMc; wMc = wMo * cMo.inverse(); //The four point used as visual features vpPoint point[4] ; point[0].setWorldCoordinates(-0.1,-0.1,0) ; point[3].setWorldCoordinates(-0.1,0.1,0) ; point[2].setWorldCoordinates(0.1,0.1,0) ; point[1].setWorldCoordinates(0.1,-0.1,0) ; // Projection of the points for (int i = 0 ; i < 4 ; i++) point[i].track(cMo); //Set the current visual feature vpFeaturePoint p[4]; for (int i = 0 ; i < 4 ; i++) vpFeatureBuilder::create(p[i], point[i]); // Projection of the points for (int i = 0 ; i < 4 ; i++) point[i].track(cdMo); vpFeaturePoint pd[4]; for (int i = 0 ; i < 4 ; i++) vpFeatureBuilder::create(pd[i], point[i]); task.setServo(vpServo::EYEINHAND_L_cVe_eJe); task.setInteractionMatrixType(vpServo::DESIRED); vpHomogeneousMatrix cMe; // Identity vpVelocityTwistMatrix cVe(cMe); task.set_cVe(cVe); vpMatrix eJe; robot.get_eJe(eJe); task.set_eJe(eJe); for (int i = 0 ; i < 4 ; i++) task.addFeature(p[i],pd[i]) ; task.setLambda(10); std::list list; vpImageSimulator imsim; vpColVector X[4]; for (int i = 0; i < 4; i++) X[i].resize(3); X[0][0] = -0.2; X[0][1] = -0.2; X[0][2] = 0; X[1][0] = 0.2; X[1][1] = -0.2; X[1][2] = 0; X[2][0] = 0.2; X[2][1] = 0.2; X[2][2] = 0; X[3][0] = -0.2; X[3][1] = 0.2; X[3][2] = 0; // Get the visp-images-data package path or VISP_INPUT_IMAGE_PATH environment variable value env_ipath = vpIoTools::getViSPImagesDataPath(); if (! env_ipath.empty()) ipath = env_ipath; if (!opt_ipath.empty()) ipath = opt_ipath; filename = vpIoTools::createFilePath(ipath, "ViSP-images/mire/mire.pgm"); imsim.init(filename.c_str(), X); list.push_back(imsim); vpWireFrameSimulator sim; // Set the scene sim.initScene(vpWireFrameSimulator::PLATE, vpWireFrameSimulator::D_STANDARD,list); // Initialize simulator frames sim.set_fMo( wMo ); // Position of the object in the world reference frame sim.setCameraPositionRelObj(cMo) ; // initial position of the camera sim.setDesiredCameraPosition(cdMo); // desired position of the camera // Set the External camera position vpHomogeneousMatrix camMf(vpHomogeneousMatrix(0.0,0,3.5,vpMath::rad(0),vpMath::rad(30),0)); sim.setExternalCameraPosition(camMf); //Computes the position of a camera which is fixed in the object frame vpHomogeneousMatrix camoMf(0,0.0,1.5,0,vpMath::rad(140),0); camoMf = camoMf*(sim.get_fMo().inverse()); //Set the parameters of the cameras (internal and external) vpCameraParameters camera(1000,1000,320,240); sim.setInternalCameraParameters(camera); sim.setExternalCameraParameters(camera); int stop = 10; if (opt_display) { stop = 2500; //Get the internal and external views sim.getInternalImage(Iint); sim.getExternalImage(Iext1); sim.getExternalImage(Iext2, camoMf); //Display the object frame (current and desired position) vpDisplay::displayFrame(Iint,cMo,camera,0.2,vpColor::none); vpDisplay::displayFrame(Iint,cdMo,camera,0.2,vpColor::none); //Display the object frame the world reference frame and the camera frame vpDisplay::displayFrame(Iext1,camMf*sim.get_fMo()*cMo.inverse(),camera,0.2,vpColor::none); vpDisplay::displayFrame(Iext1,camMf*sim.get_fMo(),camera,0.2,vpColor::none); vpDisplay::displayFrame(Iext1,camMf,camera,0.2,vpColor::none); //Display the world reference frame and the object frame vpDisplay::displayFrame(Iext2,camoMf,camera,0.2,vpColor::none); vpDisplay::displayFrame(Iext2,camoMf*sim.get_fMo(),camera,0.05,vpColor::none); vpDisplay::flush(Iint); vpDisplay::flush(Iext1); vpDisplay::flush(Iext2); std::cout << "Click on a display" << std::endl; while (!vpDisplay::getClick(Iint,false) && !vpDisplay::getClick(Iext1,false) && !vpDisplay::getClick(Iext2,false)){}; } robot.setPosition( wMc ); //Print the task task.print() ; int iter = 0; vpColVector v ; while(iter++ < stop) { if (opt_display) { vpDisplay::display(Iint) ; vpDisplay::display(Iext1) ; vpDisplay::display(Iext2) ; } double t = vpTime::measureTimeMs(); robot.get_eJe(eJe) ; task.set_eJe(eJe) ; wMc = robot.getPosition() ; cMo = wMc.inverse() * wMo; for (int i = 0 ; i < 4 ; i++) { point[i].track(cMo) ; vpFeatureBuilder::create(p[i],point[i]) ; } v = task.computeControlLaw() ; robot.setVelocity(vpRobot::CAMERA_FRAME, v) ; //Compute the movement of the object around the world reference frame. vpHomogeneousMatrix a(0, 0, 0.2, 0, 0, 0); vpHomogeneousMatrix b(0, 0, 0, vpMath::rad(1.5*iter), 0, 0); vpHomogeneousMatrix c(0, 0, 0, 0, vpMath::rad(2.5*iter), 0); // Move the object in the world frame wMo = b*c*a; sim.set_fMo( wMo ); //Move the object in the simulator sim.setCameraPositionRelObj(cMo); //Compute the position of the external view which is fixed in the object frame camoMf.buildFrom(0,0.0,1.5,0,vpMath::rad(150),0); camoMf = camoMf*(sim.get_fMo().inverse()); if (opt_display) { //Get the internal and external views sim.getInternalImage(Iint); sim.getExternalImage(Iext1); sim.getExternalImage(Iext2,camoMf); //Display the object frame (current and desired position) vpDisplay::displayFrame(Iint,cMo,camera,0.2,vpColor::none); vpDisplay::displayFrame(Iint,cdMo,camera,0.2,vpColor::none); //Display the camera frame, the object frame the world reference frame vpDisplay::displayFrame(Iext1,sim.getExternalCameraPosition()*sim.get_fMo()*cMo.inverse(),camera,0.2,vpColor::none); vpDisplay::displayFrame(Iext1,sim.getExternalCameraPosition()*sim.get_fMo(),camera,0.2,vpColor::none); vpDisplay::displayFrame(Iext1,sim.getExternalCameraPosition(),camera,0.2,vpColor::none); //Display the world reference frame and the object frame vpDisplay::displayFrame(Iext2,camoMf,camera,0.2,vpColor::none); vpDisplay::displayFrame(Iext2,camoMf*sim.get_fMo(),camera,0.05,vpColor::none); vpDisplay::flush(Iint); vpDisplay::flush(Iext1); vpDisplay::flush(Iext2); } vpTime::wait(t, sampling_time * 1000); // Wait 40 ms std::cout << "|| s - s* || = " << ( task.getError() ).sumSquare() < #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #define GETOPTARGS "dh" #ifdef VISP_HAVE_DISPLAY void usage(const char *name, const char *badparam); bool getOptions(int argc, const char **argv, bool &display); /*! Print the program options. \param name : Program name. \param badparam : Bad parameter name. */ void usage(const char *name, const char *badparam) { fprintf(stdout, "\n\ Demonstration of the wireframe simulator with a simple visual servoing.\n\ \n\ The visual servoing consists in bringing the camera at a desired position\n\ from the object.\n\ \n\ The visual features used to compute the pose of the camera and \n\ thus the control law are two lines. These features are computed thanks \n\ to the equation of a cylinder.\n\ \n\ This demonstration explains also how to move the object around a world \n\ reference frame. Here, the movment is a rotation around the x and y axis \n\ at a given distance from the world frame. In fact the object trajectory \n\ is on a sphere whose center is the origin of the world frame.\n\ \n\ SYNOPSIS\n\ %s [-d] [-h]\n", name); fprintf(stdout, "\n\ OPTIONS: \n\ -d \n\ Turn off the display.\n\ \n\ -h\n\ Print the help.\n"); if (badparam) fprintf(stdout, "\nERROR: Bad parameter [%s]\n", badparam); } /*! Set the program options. \param argc : Command line number of parameters. \param argv : Array of command line parameters. \param display : Display activation. \return false if the program has to be stopped, true otherwise. */ bool getOptions(int argc, const char **argv, bool &display) { const char *optarg_; int c; while ((c = vpParseArgv::parse(argc, argv, GETOPTARGS, &optarg_)) > 1) { switch (c) { case 'd': display = false; break; case 'h': usage(argv[0], NULL); return false; break; default: usage(argv[0], optarg_); return false; break; } } if ((c == 1) || (c == -1)) { // standalone param or error usage(argv[0], NULL); std::cerr << "ERROR: " << std::endl; std::cerr << " Bad argument " << optarg_ << std::endl << std::endl; return false; } return true; } int main(int argc, const char ** argv) { try { bool opt_display = true; // Read the command line options if (getOptions(argc, argv, opt_display) == false) { exit (-1); } vpImage Iint(480,640,255); vpImage Iext(480,640,255); #if defined VISP_HAVE_X11 vpDisplayX display[2]; #elif defined VISP_HAVE_OPENCV vpDisplayOpenCV display[2]; #elif defined VISP_HAVE_GDI vpDisplayGDI display[2]; #elif defined VISP_HAVE_D3D9 vpDisplayD3D display[2]; #elif defined VISP_HAVE_GTK vpDisplayGTK display[2]; #endif if (opt_display) { // Display size is automatically defined by the image (I) size display[0].init(Iint, 100, 100,"The internal view") ; display[1].init(Iext, 100, 100,"The first external view") ; vpDisplay::setWindowPosition (Iint, 0, 0); vpDisplay::setWindowPosition (Iext, 700, 0); vpDisplay::display(Iint); vpDisplay::flush(Iint); vpDisplay::display(Iext); vpDisplay::flush(Iext); } vpServo task; vpSimulatorCamera robot ; float sampling_time = 0.040f; // Sampling period in second robot.setSamplingTime(sampling_time); // Set initial position of the object in the camera frame vpHomogeneousMatrix cMo(0,0.1,0.3,vpMath::rad(35),vpMath::rad(25),vpMath::rad(75)); // Set desired position of the object in the camera frame vpHomogeneousMatrix cdMo(0.0,0.0,0.5,vpMath::rad(90),vpMath::rad(0),vpMath::rad(0)); // Set initial position of the object in the world frame vpHomogeneousMatrix wMo(0.0,0.0,0,0,0,0); // Position of the camera in the world frame vpHomogeneousMatrix wMc; wMc = wMo * cMo.inverse(); // Create a cylinder vpCylinder cylinder(0,0,1,0,0,0,0.1); // Projection of the cylinder cylinder.track(cMo); //Set the current visual feature vpFeatureLine l[2]; vpFeatureBuilder::create(l[0], cylinder, vpCylinder::line1); vpFeatureBuilder::create(l[1], cylinder, vpCylinder::line2); // Projection of the cylinder cylinder.track(cdMo); vpFeatureLine ld[2]; vpFeatureBuilder::create(ld[0], cylinder, vpCylinder::line1); vpFeatureBuilder::create(ld[1], cylinder, vpCylinder::line2); task.setServo(vpServo::EYEINHAND_L_cVe_eJe); task.setInteractionMatrixType(vpServo::DESIRED); vpHomogeneousMatrix cMe; vpVelocityTwistMatrix cVe(cMe); task.set_cVe(cVe); vpMatrix eJe; robot.get_eJe(eJe); task.set_eJe(eJe); for (int i = 0 ; i < 2 ; i++) task.addFeature(l[i],ld[i]) ; task.setLambda(1); vpWireFrameSimulator sim; // Set the scene sim.initScene(vpWireFrameSimulator::CYLINDER, vpWireFrameSimulator::D_STANDARD); // Initialize simulator frames sim.set_fMo( wMo ); // Position of the object in the world reference frame sim.setCameraPositionRelObj(cMo) ; // initial position of the camera sim.setDesiredCameraPosition(cdMo); // desired position of the camera // Set the External camera position vpHomogeneousMatrix camMf(vpHomogeneousMatrix(0.0,0,3.5,vpMath::rad(0),vpMath::rad(30),0)); sim.setExternalCameraPosition(camMf); // Set the parameters of the cameras (internal and external) vpCameraParameters camera(1000,1000,320,240); sim.setInternalCameraParameters(camera); sim.setExternalCameraParameters(camera); int stop = 10; if (opt_display) { stop = 2500; //Get the internal and external views sim.getInternalImage(Iint); sim.getExternalImage(Iext); //Display the object frame (current and desired position) vpDisplay::displayFrame(Iint,cMo,camera,0.2,vpColor::none); vpDisplay::displayFrame(Iint,cdMo,camera,0.2,vpColor::none); //Display the object frame the world reference frame and the camera frame vpDisplay::displayFrame(Iext,camMf*sim.get_fMo()*cMo.inverse(),camera,0.2,vpColor::none); vpDisplay::displayFrame(Iext,camMf*sim.get_fMo(),camera,0.2,vpColor::none); vpDisplay::displayFrame(Iext,camMf,camera,0.2,vpColor::none); vpDisplay::flush(Iint); vpDisplay::flush(Iext); std::cout << "Click on a display" << std::endl; while (!vpDisplay::getClick(Iint,false) && !vpDisplay::getClick(Iext,false)){}; } robot.setPosition( wMc ); //Print the task task.print(); int iter = 0; vpColVector v ; //Set the secondary task parameters vpColVector e1(6) ; e1 = 0 ; vpColVector e2(6) ; e2 = 0 ; vpColVector proj_e1 ; vpColVector proj_e2 ; iter = 0; double rapport = 0; double vitesse = 0.3; int tempo = 600; while(iter++ < stop) { if (opt_display) { vpDisplay::display(Iint) ; vpDisplay::display(Iext) ; } double t = vpTime::measureTimeMs(); robot.get_eJe(eJe) ; task.set_eJe(eJe) ; wMc = robot.getPosition(); cMo = wMc.inverse() * wMo; cylinder.track(cMo) ; vpFeatureBuilder::create(l[0], cylinder, vpCylinder::line1); vpFeatureBuilder::create(l[1], cylinder, vpCylinder::line2); v = task.computeControlLaw() ; //Compute the velocity with the secondary task if ( iter%tempo < 200 && iter%tempo >= 0) { e2 = 0; e1[0] = -fabs(vitesse) ; proj_e1 = task.secondaryTask(e1); rapport = -vitesse/proj_e1[0]; proj_e1 *= rapport ; v += proj_e1 ; } if ( iter%tempo < 300 && iter%tempo >= 200) { e1 = 0; e2[1] = -fabs(vitesse) ; proj_e2 = task.secondaryTask(e2); rapport = -vitesse/proj_e2[1]; proj_e2 *= rapport ; v += proj_e2 ; } if ( iter%tempo < 500 && iter%tempo >= 300) { e2 = 0; e1[0] = -fabs(vitesse) ; proj_e1 = task.secondaryTask(e1); rapport = vitesse/proj_e1[0]; proj_e1 *= rapport ; v += proj_e1 ; } if ( iter%tempo < 600 && iter%tempo >= 500) { e1 = 0; e2[1] = -fabs(vitesse) ; proj_e2 = task.secondaryTask(e2); rapport = vitesse/proj_e2[1]; proj_e2 *= rapport ; v += proj_e2 ; } robot.setVelocity(vpRobot::CAMERA_FRAME, v) ; // Update the simulator frames sim.set_fMo( wMo ); // This line is not really requested since the object doesn't move sim.setCameraPositionRelObj( cMo ); if (opt_display) { //Get the internal and external views sim.getInternalImage(Iint); sim.getExternalImage(Iext); //Display the object frame (current and desired position) vpDisplay::displayFrame(Iint,cMo,camera,0.2,vpColor::none); vpDisplay::displayFrame(Iint,cdMo,camera,0.2,vpColor::none); //Display the object frame the world reference frame and the camera frame vpDisplay::displayFrame(Iext,sim.getExternalCameraPosition()*sim.get_fMo()*cMo.inverse(),camera,0.2,vpColor::none); vpDisplay::displayFrame(Iext,sim.getExternalCameraPosition()*sim.get_fMo(),camera,0.2,vpColor::none); vpDisplay::displayFrame(Iext,sim.getExternalCameraPosition(),camera,0.2,vpColor::none);; vpDisplay::flush(Iint); vpDisplay::flush(Iext); } vpTime::wait(t, sampling_time * 1000); // Wait 40 ms std::cout << "|| s - s* || = " << (task.getError() ).sumSquare() < #include // std::fabs #include // numeric_limits #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #define GETOPTARGS "dh" #ifdef VISP_HAVE_DISPLAY void usage(const char *name, const char *badparam); bool getOptions(int argc, const char **argv, bool &display); void computeVisualFeatures(const vpSphere &sphere, vpGenericFeature &s); void computeInteractionMatrix(const vpGenericFeature &s,const vpSphere &sphere, vpMatrix &L); /*! Print the program options. \param name : Program name. \param badparam : Bad parameter name. */ void usage(const char *name, const char *badparam) { fprintf(stdout, "\n\ Demonstration of the wireframe simulator with a simple visual servoing.\n\ \n\ The visual servoing consists in bringing the camera at a desired position from the object.\n\ \n\ The visual features used to compute the pose of the camera and thus the control law are special moments computed with the sphere's parameters.\n\ \n\ SYNOPSIS\n\ %s [-d] [-h]\n", name); fprintf(stdout, "\n\ OPTIONS: Default\n\ -d \n\ Turn off the display.\n\ \n\ -h\n\ Print the help.\n"); if (badparam) fprintf(stdout, "\nERROR: Bad parameter [%s]\n", badparam); } /*! Set the program options. \param argc : Command line number of parameters. \param argv : Array of command line parameters. \param display : Display activation. \return false if the program has to be stopped, true otherwise. */ bool getOptions(int argc, const char **argv, bool &display) { const char *optarg_; int c; while ((c = vpParseArgv::parse(argc, argv, GETOPTARGS, &optarg_)) > 1) { switch (c) { case 'd': display = false; break; case 'h': usage(argv[0], NULL); return false; break; default: usage(argv[0], optarg_); return false; break; } } if ((c == 1) || (c == -1)) { // standalone param or error usage(argv[0], NULL); std::cerr << "ERROR: " << std::endl; std::cerr << " Bad argument " << optarg_ << std::endl << std::endl; return false; } return true; } /* Computes the virtual visual features corresponding to the sphere and stores it in the generic feature. The visual feature vector is computed thanks to the following formula : s = {sx, sy, sz} sx = gx*h2/(sqrt(h2+1) sx = gy*h2/(sqrt(h2+1) sz = sqrt(h2+1) with gx and gy the center of gravity of the ellipse, with h2 = (gx²+gy²)/(4*n20*gy²+4*n02*gx²-8n11gxgy) with n20,n02,n11 the second order moments of the sphere */ void computeVisualFeatures(const vpSphere &sphere, vpGenericFeature &s) { double gx = sphere.get_x(); double gy = sphere.get_y(); double m02 = sphere.get_mu02(); double m20 = sphere.get_mu20(); double m11 = sphere.get_mu11(); double h2; //if (gx != 0 || gy != 0) if (std::fabs(gx) > std::numeric_limits::epsilon() || std::fabs(gy) > std::numeric_limits::epsilon()) h2 = (vpMath::sqr(gx)+vpMath::sqr(gy))/(4*m20*vpMath::sqr(gy)+4*m02*vpMath::sqr(gx)-8*m11*gx*gy); else h2 = 1/(4*m20); double sx = gx*h2/(sqrt(h2+1)); double sy = gy*h2/(sqrt(h2+1)); double sz = sqrt(h2+1); //(h2-(vpMath::sqr(sx)+vpMath::sqr(sy)-1))/(2*sqrt(h2)); s.set_s(sx,sy,sz); } /* Computes the interaction matrix such as L = [-1/R*I3 [s]x] with R the radius of the sphere with I3 the 3x3 identity matrix with [s]x the skew matrix related to s */ void computeInteractionMatrix(const vpGenericFeature &s,const vpSphere &sphere, vpMatrix &L) { L = 0; L[0][0] = -1/sphere.getR(); L[1][1] = -1/sphere.getR(); L[2][2] = -1/sphere.getR(); double s0,s1,s2; s.get_s(s0,s1,s2); vpTranslationVector c(s0,s1,s2); vpMatrix sk; sk = c.skew(); for(unsigned int i = 0; i < 3; i++) for(unsigned int j = 0; j < 3; j++) L[i][j+3] = sk[i][j]; } int main(int argc, const char ** argv) { try { bool opt_display = true; // Read the command line options if (getOptions(argc, argv, opt_display) == false) { exit (-1); } vpImage Iint(480,640,255); vpImage Iext1(480,640,255); vpImage Iext2(480,640,255); #if defined VISP_HAVE_X11 vpDisplayX display[3]; #elif defined VISP_HAVE_OPENCV vpDisplayOpenCV display[3]; #elif defined VISP_HAVE_GDI vpDisplayGDI display[3]; #elif defined VISP_HAVE_D3D9 vpDisplayD3D display[3]; #elif defined VISP_HAVE_GTK vpDisplayGTK display[3]; #endif if (opt_display) { // Display size is automatically defined by the image (I) size display[0].init(Iint, 100, 100,"The internal view") ; display[1].init(Iext1, 100, 100,"The first external view") ; display[2].init(Iext2, 100, 100,"The second external view") ; vpDisplay::setWindowPosition (Iint, 0, 0); vpDisplay::setWindowPosition (Iext1, 700, 0); vpDisplay::setWindowPosition (Iext2, 0, 550); vpDisplay::display(Iint); vpDisplay::flush(Iint); vpDisplay::display(Iext1); vpDisplay::flush(Iext1); vpDisplay::display(Iext2); vpDisplay::flush(Iext2); } vpServo task; vpSimulatorCamera robot ; float sampling_time = 0.040f; // Sampling period in second robot.setSamplingTime(sampling_time); // Since the task gain lambda is very high, we need to increase default max velocities robot.setMaxTranslationVelocity(10); robot.setMaxRotationVelocity(vpMath::rad(180)); // Set initial position of the object in the camera frame vpHomogeneousMatrix cMo(0,0.1,2.0,vpMath::rad(35),vpMath::rad(25),0); // Set desired position of the object in the camera frame vpHomogeneousMatrix cdMo(0.0,0.0,0.8,vpMath::rad(0),vpMath::rad(0),vpMath::rad(0)); // Set initial position of the object in the world frame vpHomogeneousMatrix wMo(0.0,0.0,0,0,0,0); // Position of the camera in the world frame vpHomogeneousMatrix wMc; wMc = wMo * cMo.inverse(); robot.setPosition( wMc ); //The sphere vpSphere sphere(0,0,0,0.15); // Projection of the sphere sphere.track(cMo); //Set the current visual feature vpGenericFeature s(3); computeVisualFeatures(sphere, s); // Projection of the points sphere.track(cdMo); vpGenericFeature sd(3); computeVisualFeatures(sphere, sd); vpMatrix L(3,6); computeInteractionMatrix(sd,sphere,L); sd.setInteractionMatrix(L); task.setServo(vpServo::EYEINHAND_L_cVe_eJe); task.setInteractionMatrixType(vpServo::DESIRED); vpHomogeneousMatrix cMe; vpVelocityTwistMatrix cVe(cMe); task.set_cVe(cVe); vpMatrix eJe; robot.get_eJe(eJe); task.set_eJe(eJe); task.addFeature(s,sd) ; task.setLambda(7); vpWireFrameSimulator sim; // Set the scene sim.initScene(vpWireFrameSimulator::SPHERE, vpWireFrameSimulator::D_STANDARD); // Initialize simulator frames sim.set_fMo( wMo ); // Position of the object in the world reference frame sim.setCameraPositionRelObj(cMo) ; // initial position of the camera sim.setDesiredCameraPosition(cdMo); // desired position of the camera // Set the External camera position vpHomogeneousMatrix camMf(0.0,0,3.5,vpMath::rad(0),vpMath::rad(30),0); sim.setExternalCameraPosition(camMf); // Computes the position of a camera which is fixed in the object frame vpHomogeneousMatrix camoMf(0,0.0,2.5,0,vpMath::rad(140),0); camoMf = camoMf*(sim.get_fMo().inverse()); // Set the parameters of the cameras (internal and external) vpCameraParameters camera(1000,1000,320,240); sim.setInternalCameraParameters(camera); sim.setExternalCameraParameters(camera); int stop = 10; if (opt_display) { stop = 1000; //Get the internal and external views sim.getInternalImage(Iint); sim.getExternalImage(Iext1); sim.getExternalImage(Iext2,camoMf); //Display the object frame (current and desired position) vpDisplay::displayFrame(Iint,cMo,camera,0.2,vpColor::none); vpDisplay::displayFrame(Iint,cdMo,camera,0.2,vpColor::none); //Display the object frame the world reference frame and the camera frame vpDisplay::displayFrame(Iext1,camMf*sim.get_fMo()*cMo.inverse(),camera,0.2,vpColor::none); vpDisplay::displayFrame(Iext1,camMf*sim.get_fMo(),camera,0.2,vpColor::none); vpDisplay::displayFrame(Iext1,camMf,camera,0.2,vpColor::none); //Display the world reference frame and the object frame vpDisplay::displayFrame(Iext2,camoMf,camera,0.2,vpColor::none); vpDisplay::displayFrame(Iext2,camoMf*sim.get_fMo(),camera,0.05,vpColor::none); vpDisplay::flush(Iint); vpDisplay::flush(Iext1); vpDisplay::flush(Iext2); std::cout << "Click on a display" << std::endl; while (!vpDisplay::getClick(Iint,false) && !vpDisplay::getClick(Iext1,false) && !vpDisplay::getClick(Iext2,false)){}; } //Print the task task.print() ; int iter = 0; vpColVector v ; while(iter++ < stop) { if (opt_display) { vpDisplay::display(Iint) ; vpDisplay::display(Iext1) ; vpDisplay::display(Iext2) ; } double t = vpTime::measureTimeMs(); robot.get_eJe(eJe) ; task.set_eJe(eJe) ; wMc = robot.getPosition() ; cMo = wMc.inverse() * wMo; sphere.track(cMo); //Set the current visual feature computeVisualFeatures(sphere, s); v = task.computeControlLaw() ; robot.setVelocity(vpRobot::CAMERA_FRAME, v); sim.setCameraPositionRelObj(cMo); //Compute the position of the external view which is fixed in the object frame camoMf.buildFrom(0,0.0,2.5,0,vpMath::rad(150),0); camoMf = camoMf*(sim.get_fMo().inverse()); if (opt_display) { //Get the internal and external views sim.getInternalImage(Iint); sim.getExternalImage(Iext1); sim.getExternalImage(Iext2,camoMf); //Display the object frame (current and desired position) vpDisplay::displayFrame(Iint,cMo,camera,0.2,vpColor::none); vpDisplay::displayFrame(Iint,cdMo,camera,0.2,vpColor::none); //Display the camera frame, the object frame the world reference frame vpDisplay::displayFrame(Iext1,sim.getExternalCameraPosition()*sim.get_fMo()*cMo.inverse(),camera,0.2,vpColor::none); vpDisplay::displayFrame(Iext1,sim.getExternalCameraPosition()*sim.get_fMo(),camera,0.2,vpColor::none); vpDisplay::displayFrame(Iext1,sim.getExternalCameraPosition(),camera,0.2,vpColor::none); //Display the world reference frame and the object frame vpDisplay::displayFrame(Iext2,camoMf,camera,0.2,vpColor::none); vpDisplay::displayFrame(Iext2,camoMf*sim.get_fMo(),camera,0.05,vpColor::none); vpDisplay::flush(Iint); vpDisplay::flush(Iext1); vpDisplay::flush(Iext2); } vpTime::wait(t, sampling_time * 1000); // Wait 40 ms std::cout << "|| s - s* || = " << ( task.getError() ).sumSquare() <