]> Creatis software - clitk.git/blob - cmake/FindROOT.cmake
Add clitkImage2DicomSeries tool to write a Dicom Series from an image without a corre...
[clitk.git] / cmake / FindROOT.cmake
1 # - Find ROOT instalation
2 # This module tries to find the ROOT installation on your system.
3 # It tries to find the root-config script which gives you all the needed information.
4 # If the system variable ROOTSYS is set this is straight forward.
5 # If not the module uses the pathes given in ROOT_CONFIG_SEARCHPATH.
6 # If you need an other path you should add this path to this varaible.
7 # The root-config script is then used to detect basically everything else.
8 # This module defines a number of key variables and macros.
9
10
11 message(STATUS "Looking for Root...")
12
13 set(ROOT_DEFINITIONS "")
14
15 set(ROOT_INSTALLED_VERSION_TOO_OLD FALSE)
16
17 set(ROOT_CONFIG_EXECUTABLE ROOT_CONFIG_EXECUTABLE-NOTFOUND)
18
19 find_program(ROOT_CONFIG_EXECUTABLE NAMES root-config PATHS)
20
21 if(${ROOT_CONFIG_EXECUTABLE} MATCHES "ROOT_CONFIG_EXECUTABLE-NOTFOUND")
22   message( FATAL_ERROR "ROOT not installed in the searchpath and ROOTSYS is not set. Please
23  set ROOTSYS or add the path to your ROOT installation in the Macro FindROOT.cmake in the
24  subdirectory cmake/modules.")
25 else(${ROOT_CONFIG_EXECUTABLE} MATCHES "ROOT_CONFIG_EXECUTABLE-NOTFOUND")
26                 message(STATUS "root-config found")
27   string(REGEX REPLACE "(^.*)/bin/root-config" "\\1" test ${ROOT_CONFIG_EXECUTABLE})
28   set( ENV{ROOTSYS} ${test})
29   set( ROOTSYS ${test})
30 endif(${ROOT_CONFIG_EXECUTABLE} MATCHES "ROOT_CONFIG_EXECUTABLE-NOTFOUND")
31
32
33 if(ROOT_CONFIG_EXECUTABLE)
34
35   set(ROOT_FOUND FALSE)
36
37   exec_program(${ROOT_CONFIG_EXECUTABLE} ARGS "--version" OUTPUT_VARIABLE ROOTVERSION)
38
39   message(STATUS "Looking for Root... - found $ENV{ROOTSYS}/bin/root")
40   message(STATUS "Looking for Root... - version ${ROOTVERSION} ")
41
42   # we need at least version 5.00/00
43   if(NOT ROOT_MIN_VERSION)
44     set(ROOT_MIN_VERSION "5.00/00")
45   endif(NOT ROOT_MIN_VERSION)
46
47   # now parse the parts of the user given version string into variables
48   string(REGEX REPLACE "^([0-9]+)\\.[0-9][0-9]+\\/[0-9][0-9]+" "\\1" req_root_major_vers "${ROOT_MIN_VERSION}")
49   string(REGEX REPLACE "^[0-9]+\\.([0-9][0-9])+\\/[0-9][0-9]+.*" "\\1" req_root_minor_vers "${ROOT_MIN_VERSION}")
50   string(REGEX REPLACE "^[0-9]+\\.[0-9][0-9]+\\/([0-9][0-9]+)" "\\1" req_root_patch_vers "${ROOT_MIN_VERSION}")
51
52   # and now the version string given by qmake
53   string(REGEX REPLACE "^([0-9]+)\\.[0-9][0-9]+\\/[0-9][0-9]+.*" "\\1" found_root_major_vers "${ROOTVERSION}")
54   string(REGEX REPLACE "^[0-9]+\\.([0-9][0-9])+\\/[0-9][0-9]+.*" "\\1" found_root_minor_vers "${ROOTVERSION}")
55   string(REGEX REPLACE "^[0-9]+\\.[0-9][0-9]+\\/([0-9][0-9]+).*" "\\1" found_root_patch_vers "${ROOTVERSION}")
56
57   if(found_root_major_vers LESS 5)
58     message( FATAL_ERROR "Invalid ROOT version \"${ROOTERSION}\", at least major version 4 is required, e.g. \"5.00/00\"")
59   endif(found_root_major_vers LESS 5)
60
61   # compute an overall version number which can be compared at once
62   math(EXPR req_vers "${req_root_major_vers}*10000 + ${req_root_minor_vers}*100 + ${req_root_patch_vers}")
63   math(EXPR found_vers "${found_root_major_vers}*10000 + ${found_root_minor_vers}*100 + ${found_root_patch_vers}")
64
65   if(found_vers LESS req_vers)
66     set(ROOT_FOUND FALSE)
67     set(ROOT_INSTALLED_VERSION_TOO_OLD TRUE)
68   else(found_vers LESS req_vers)
69     set(ROOT_FOUND TRUE)
70   endif(found_vers LESS req_vers)
71
72 endif(ROOT_CONFIG_EXECUTABLE)
73
74 #message("root found = "${ROOT_FOUND})
75
76 if(ROOT_FOUND)
77
78   # ask root-config for the library dir
79   # Set ROOT_LIBRARY_DIR
80
81   exec_program( ${ROOT_CONFIG_EXECUTABLE}
82     ARGS "--libdir"
83     OUTPUT_VARIABLE ROOT_LIBRARY_DIR_TMP )
84
85   if(EXISTS "${ROOT_LIBRARY_DIR_TMP}")
86     set(ROOT_LIBRARY_DIR ${ROOT_LIBRARY_DIR_TMP} )
87   else(EXISTS "${ROOT_LIBRARY_DIR_TMP}")
88     message("Warning: ROOT_CONFIG_EXECUTABLE reported ${ROOT_LIBRARY_DIR_TMP} as library path,")
89     message("Warning: but ${ROOT_LIBRARY_DIR_TMP} does NOT exist, ROOT must NOT be installed correctly.")
90   endif(EXISTS "${ROOT_LIBRARY_DIR_TMP}")
91
92   # ask root-config for the binary dir
93   exec_program(${ROOT_CONFIG_EXECUTABLE}
94     ARGS "--bindir"
95     OUTPUT_VARIABLE root_bins )
96   set(ROOT_BINARY_DIR ${root_bins})
97
98   # ask root-config for the include dir
99   exec_program( ${ROOT_CONFIG_EXECUTABLE}
100     ARGS "--incdir"
101     OUTPUT_VARIABLE root_headers )
102   set(ROOT_INCLUDE_DIR ${root_headers})
103       # CACHE INTERNAL "")
104
105   # ask root-config for the library varaibles
106   exec_program( ${ROOT_CONFIG_EXECUTABLE}
107 #    ARGS "--noldflags --noauxlibs --libs"
108     ARGS "--glibs"
109     OUTPUT_VARIABLE root_flags )
110
111 #  string(REGEX MATCHALL "([^ ])+"  root_libs_all ${root_flags})
112 #  string(REGEX MATCHALL "-L([^ ])+"  root_library ${root_flags})
113 #  REMOVE_FROM_LIST(root_flags "${root_libs_all}" "${root_library}")
114
115   set(ROOT_LIBRARIES ${root_flags})
116
117   # Make variables changeble to the advanced user
118   mark_as_advanced( ROOT_LIBRARY_DIR ROOT_INCLUDE_DIR ROOT_DEFINITIONS)
119
120   # Set ROOT_INCLUDES
121   set( ROOT_INCLUDES ${ROOT_INCLUDE_DIR})
122
123   set(LD_LIBRARY_PATH ${LD_LIBRARY_PATH} ${ROOT_LIBRARY_DIR})
124
125   #######################################
126   #
127   #       Check the executables of ROOT
128   #          ( rootcint )
129   #
130   #######################################
131
132   find_program(ROOT_CINT_EXECUTABLE
133     NAMES rootcint
134     PATHS ${ROOT_BINARY_DIR}
135     NO_DEFAULT_PATH
136     )
137
138 endif(ROOT_FOUND)
139
140
141 #message("icici")
142
143   ###########################################
144   #
145   #       Macros for building ROOT dictionary
146   #
147   ###########################################
148
149 macro(ROOT_GENERATE_DICTIONARY_OLD )
150
151    set(INFILES "")
152
153    foreach (_current_FILE ${ARGN})
154
155      if(${_current_FILE} MATCHES "^.*\\.h$")
156        if(${_current_FILE} MATCHES "^.*Link.*$")
157          set(LINKDEF_FILE ${_current_FILE})
158        else(${_current_FILE} MATCHES "^.*Link.*$")
159          set(INFILES ${INFILES} ${_current_FILE})
160        endif(${_current_FILE} MATCHES "^.*Link.*$")
161      else(${_current_FILE} MATCHES "^.*\\.h$")
162        if(${_current_FILE} MATCHES "^.*\\.cxx$")
163          set(OUTFILE ${_current_FILE})
164        else(${_current_FILE} MATCHES "^.*\\.cxx$")
165          set(INCLUDE_DIRS ${INCLUDE_DIRS} -I${_current_FILE})
166        endif(${_current_FILE} MATCHES "^.*\\.cxx$")
167      endif(${_current_FILE} MATCHES "^.*\\.h$")
168
169    endforeach (_current_FILE ${ARGN})
170
171 #  message("INFILES: ${INFILES}")
172 #  message("OutFILE: ${OUTFILE}")
173 #  message("LINKDEF_FILE: ${LINKDEF_FILE}")
174 #  message("INCLUDE_DIRS: ${INCLUDE_DIRS}")
175
176    string(REGEX REPLACE "(^.*).cxx" "\\1.h" bla "${OUTFILE}")
177 #   message("BLA: ${bla}")
178    set(OUTFILES ${OUTFILE} ${bla})
179
180    add_custom_command(OUTPUT ${OUTFILES}
181       COMMAND ${ROOT_CINT_EXECUTABLE}
182       ARGS -f ${OUTFILE} -c -DHAVE_CONFIG_H ${INCLUDE_DIRS} ${INFILES} ${LINKDEF_FILE} DEPENDS ${INFILES})
183
184 #   message("ROOT_CINT_EXECUTABLE has created the dictionary ${OUTFILE}")
185
186 endmacro(ROOT_GENERATE_DICTIONARY_OLD)
187
188   ###########################################
189   #
190   #       Macros for building ROOT dictionary
191   #
192   ###########################################
193
194 macro(ROOT_GENERATE_DICTIONARY INFILES LINKDEF_FILE OUTFILE INCLUDE_DIRS_IN)
195
196   set(INCLUDE_DIRS)
197
198   foreach (_current_FILE ${INCLUDE_DIRS_IN})
199     set(INCLUDE_DIRS ${INCLUDE_DIRS} -I${_current_FILE})
200   endforeach (_current_FILE ${INCLUDE_DIRS_IN})
201
202
203 #  message("INFILES: ${INFILES}")
204 #  message("OutFILE: ${OUTFILE}")
205 #  message("LINKDEF_FILE: ${LINKDEF_FILE}")
206 #  message("INCLUDE_DIRS: ${INCLUDE_DIRS}")
207
208   string(REGEX REPLACE "^(.*)\\.(.*)$" "\\1.h" bla "${OUTFILE}")
209 #  message("BLA: ${bla}")
210   set(OUTFILES ${OUTFILE} ${bla})
211
212   add_custom_command(OUTPUT ${OUTFILES}
213      COMMAND ${ROOT_CINT_EXECUTABLE}
214      ARGS -f ${OUTFILE} -c -DHAVE_CONFIG_H ${INCLUDE_DIRS} ${INFILES} ${LINKDEF_FILE} DEPENDS ${INFILES})
215
216 endmacro(ROOT_GENERATE_DICTIONARY)
217
218 #message("la")