libfishcamp-1.2+20220607003151/0000755000175100017510000000000014247516170014444 5ustar debiandebianlibfishcamp-1.2+20220607003151/99-fishcamp.rules0000644000175100017510000000024414174600256017547 0ustar debiandebianSUBSYSTEMS=="usb", ATTRS{idVendor}=="1887", ATTRS{idProduct}=="0002", MODE="0666" SUBSYSTEMS=="usb", ATTRS{idVendor}=="1887", ATTRS{idProduct}=="0003", MODE="0666" libfishcamp-1.2+20220607003151/cmake_modules/0000755000175100017510000000000014247236061017252 5ustar debiandebianlibfishcamp-1.2+20220607003151/cmake_modules/FindGPSD.cmake0000644000175100017510000000103614174600255021611 0ustar debiandebian# - Find GPSD # Find the native GPSD includes and library FIND_PATH(GPSD_INCLUDE_DIR libgpsmm.h gps.h) SET(GPSD_NAMES ${GPSD_NAMES} gps) FIND_LIBRARY(GPSD_LIBRARY NAMES ${GPSD_NAMES} ) # handle the QUIETLY and REQUIRED arguments and set JPEG_FOUND to TRUE if # all listed variables are TRUE INCLUDE(FindPackageHandleStandardArgs) FIND_PACKAGE_HANDLE_STANDARD_ARGS(GPSD DEFAULT_MSG GPSD_LIBRARY GPSD_INCLUDE_DIR) IF(GPSD_FOUND) SET(GPSD_LIBRARIES ${GPSD_LIBRARY}) message(STATUS "Found libgps: ${GPSD_LIBRARIES}") ENDIF(GPSD_FOUND) libfishcamp-1.2+20220607003151/cmake_modules/FindFTDI1.cmake0000644000175100017510000000267214174600255021672 0ustar debiandebian# - Try to find FTDI1 # Once done this will define # # FTDI1_FOUND - system has FTDI # FTDI1_INCLUDE_DIR - the FTDI include directory # FTDI1_LIBRARIES - Link these to use FTDI # # N.B. You must include the file as following: # #include # # Redistribution and use is allowed according to the terms of the BSD license. # For details see the accompanying COPYING-CMAKE-SCRIPTS file. if (FTDI1_INCLUDE_DIR AND FTDI1_LIBRARIES) # in cache already set(FTDI1_FOUND TRUE) message(STATUS "Found libftdi1: ${FTDI1_LIBRARIES}") else (FTDI1_INCLUDE_DIR AND FTDI1_LIBRARIES) find_path(FTDI1_INCLUDE_DIR ftdi.h PATH_SUFFIXES libftdi1 ${_obIncDir} ${GNUWIN32_DIR}/include /usr/local/include ) find_library(FTDI1_LIBRARIES NAMES ftdi1 PATHS ${_obLinkDir} ${GNUWIN32_DIR}/lib /usr/local/lib ) if(FTDI1_INCLUDE_DIR AND FTDI1_LIBRARIES) set(FTDI1_FOUND TRUE) else (FTDI1_INCLUDE_DIR AND FTDI1_LIBRARIES) set(FTDI1_FOUND FALSE) endif(FTDI1_INCLUDE_DIR AND FTDI1_LIBRARIES) if (FTDI1_FOUND) if (NOT FTDI1_FIND_QUIETLY) message(STATUS "Found FTDI1: ${FTDI1_LIBRARIES}") endif (NOT FTDI1_FIND_QUIETLY) else (FTDI1_FOUND) if (FTDI1_FIND_REQUIRED) message(FATAL_ERROR "FTDI not found. Please install libftdi1-dev") endif (FTDI1_FIND_REQUIRED) endif (FTDI1_FOUND) mark_as_advanced(FTDI1_INCLUDE_DIR FTDI1_LIBRARIES) endif (FTDI1_INCLUDE_DIR AND FTDI1_LIBRARIES) libfishcamp-1.2+20220607003151/cmake_modules/FindOpenAL.cmake0000644000175100017510000000660414174600255022200 0ustar debiandebian# Locate OpenAL # This module defines # OPENAL_LIBRARY # OPENAL_FOUND, if false, do not try to link to OpenAL # OPENAL_INCLUDE_DIR, where to find the headers # # $OPENALDIR is an environment variable that would # correspond to the ./configure --prefix=$OPENALDIR # used in building OpenAL. # # Created by Eric Wing. This was influenced by the FindSDL.cmake module. # This makes the presumption that you are include al.h like # #include "al.h" # and not # #include # The reason for this is that the latter is not entirely portable. # Windows/Creative Labs does not by default put their headers in AL/ and # OS X uses the convention . # # For Windows, Creative Labs seems to have added a registry key for their # OpenAL 1.1 installer. I have added that key to the list of search paths, # however, the key looks like it could be a little fragile depending on # if they decide to change the 1.00.0000 number for bug fix releases. # Also, they seem to have laid down groundwork for multiple library platforms # which puts the library in an extra subdirectory. Currently there is only # Win32 and I have hardcoded that here. This may need to be adjusted as # platforms are introduced. # The OpenAL 1.0 installer doesn't seem to have a useful key I can use. # I do not know if the Nvidia OpenAL SDK has a registry key. # # For OS X, remember that OpenAL was added by Apple in 10.4 (Tiger). # To support the framework, I originally wrote special framework detection # code in this module which I have now removed with CMake's introduction # of native support for frameworks. # In addition, OpenAL is open source, and it is possible to compile on Panther. # Furthermore, due to bugs in the initial OpenAL release, and the # transition to OpenAL 1.1, it is common to need to override the built-in # framework. # Per my request, CMake should search for frameworks first in # the following order: # ~/Library/Frameworks/OpenAL.framework/Headers # /Library/Frameworks/OpenAL.framework/Headers # /System/Library/Frameworks/OpenAL.framework/Headers # # On OS X, this will prefer the Framework version (if found) over others. # People will have to manually change the cache values of # OPENAL_LIBRARY to override this selection or set the CMake environment # CMAKE_INCLUDE_PATH to modify the search paths. FIND_PATH(OPENAL_INCLUDE_DIR al.h PATHS $ENV{OPENALDIR} NO_DEFAULT_PATH PATH_SUFFIXES include/AL include/OpenAL include ) FIND_PATH(OPENAL_INCLUDE_DIR al.h PATHS ~/Library/Frameworks /Library/Frameworks /usr/local /usr /sw # Fink /opt/local # DarwinPorts /opt/csw # Blastwave /opt [HKEY_LOCAL_MACHINE\\SOFTWARE\\Creative\ Labs\\OpenAL\ 1.1\ Software\ Development\ Kit\\1.00.0000;InstallDir] PATH_SUFFIXES include/AL include/OpenAL include ) FIND_LIBRARY(OPENAL_LIBRARY NAMES OpenAL al openal OpenAL32 PATHS $ENV{OPENALDIR} NO_DEFAULT_PATH PATH_SUFFIXES lib64 lib libs64 libs libs/Win32 libs/Win64 ) FIND_LIBRARY(OPENAL_LIBRARY NAMES OpenAL al openal OpenAL32 PATHS ~/Library/Frameworks /Library/Frameworks /usr/local /usr /sw /opt/local /opt/csw /opt [HKEY_LOCAL_MACHINE\\SOFTWARE\\Creative\ Labs\\OpenAL\ 1.1\ Software\ Development\ Kit\\1.00.0000;InstallDir] PATH_SUFFIXES lib64 lib libs64 libs libs/Win32 libs/Win64 ) SET(OPENAL_FOUND "NO") IF(OPENAL_LIBRARY AND OPENAL_INCLUDE_DIR) SET(OPENAL_FOUND "YES") ENDIF(OPENAL_LIBRARY AND OPENAL_INCLUDE_DIR) libfishcamp-1.2+20220607003151/cmake_modules/FindFFTW3.cmake0000644000175100017510000000257314174600255021714 0ustar debiandebian# - Try to find FFTW3 # Once done this will define # # FFTW3_FOUND - system has FFTW3 # FFTW3_INCLUDE_DIR - the FFTW3 include directory # FFTW3_LIBRARIES - Link these to use FFTW3 # FFTW3_VERSION_STRING - Human readable version number of fftw3 # FFTW3_VERSION_MAJOR - Major version number of fftw3 # FFTW3_VERSION_MINOR - Minor version number of fftw3 # Copyright (c) 2017, Ilia Platone, # Based on FindLibfacile by Carsten Niehaus, # # Redistribution and use is allowed according to the terms of the BSD license. # For details see the accompanying COPYING-CMAKE-SCRIPTS file. if (FFTW3_LIBRARIES) # in cache already set(FFTW3_FOUND TRUE) message(STATUS "Found FFTW3: ${FFTW3_LIBRARIES}") else (FFTW3_LIBRARIES) find_library(FFTW3_LIBRARIES NAMES fftw3 PATHS ${_obLinkDir} ${GNUWIN32_DIR}/lib /usr/local/lib ) if(FFTW3_LIBRARIES) set(FFTW3_FOUND TRUE) else (FFTW3_LIBRARIES) set(FFTW3_FOUND FALSE) endif(FFTW3_LIBRARIES) if (FFTW3_FOUND) if (NOT FFTW3_FIND_QUIETLY) message(STATUS "Found FFTW3: ${FFTW3_LIBRARIES}") endif (NOT FFTW3_FIND_QUIETLY) else (FFTW3_FOUND) if (FFTW3_FIND_REQUIRED) message(FATAL_ERROR "FFTW3 not found. Please install libfftw3-dev") endif (FFTW3_FIND_REQUIRED) endif (FFTW3_FOUND) mark_as_advanced(FFTW3_LIBRARIES) endif (FFTW3_LIBRARIES) libfishcamp-1.2+20220607003151/cmake_modules/FindMALLINCAM.cmake0000644000175100017510000000301314174600255022346 0ustar debiandebian# - Try to find MALLINCAM Camera Library # Once done this will define # # MALLINCAM_FOUND - system has Levenhuk # MALLINCAM_INCLUDE_DIR - the Levenhuk include directory # MALLINCAM_LIBRARIES - Link these to use Levenhuk # Redistribution and use is allowed according to the terms of the BSD license. # For details see the accompanying COPYING-CMAKE-SCRIPTS file. if (MALLINCAM_INCLUDE_DIR AND MALLINCAM_LIBRARIES) # in cache already set(MALLINCAM_FOUND TRUE) message(STATUS "Found libnncam: ${MALLINCAM_LIBRARIES}") else (MALLINCAM_INCLUDE_DIR AND MALLINCAM_LIBRARIES) find_path(MALLINCAM_INCLUDE_DIR mallincam.h PATH_SUFFIXES libmallincam ${_obIncDir} ${GNUWIN32_DIR}/include ) find_library(MALLINCAM_LIBRARIES NAMES mallincam PATHS ${_obLinkDir} ${GNUWIN32_DIR}/lib ) if(MALLINCAM_INCLUDE_DIR AND MALLINCAM_LIBRARIES) set(MALLINCAM_FOUND TRUE) else (MALLINCAM_INCLUDE_DIR AND MALLINCAM_LIBRARIES) set(MALLINCAM_FOUND FALSE) endif(MALLINCAM_INCLUDE_DIR AND MALLINCAM_LIBRARIES) if (MALLINCAM_FOUND) if (NOT MALLINCAM_FIND_QUIETLY) message(STATUS "Found MALLINCAM: ${MALLINCAM_LIBRARIES}") endif (NOT MALLINCAM_FIND_QUIETLY) else (MALLINCAM_FOUND) if (MALLINCAM_FIND_REQUIRED) message(FATAL_ERROR "MALLINCAM not found. Please install MALLINCAM Library http://www.indilib.org") endif (MALLINCAM_FIND_REQUIRED) endif (MALLINCAM_FOUND) mark_as_advanced(MALLINCAM_INCLUDE_DIR MALLINCAM_LIBRARIES) endif (MALLINCAM_INCLUDE_DIR AND MALLINCAM_LIBRARIES) libfishcamp-1.2+20220607003151/cmake_modules/FindNova.cmake0000644000175100017510000000304614174600255021762 0ustar debiandebian# - Try to find NOVA # Once done this will define # # NOVA_FOUND - system has NOVA # NOVA_INCLUDE_DIR - the NOVA include directory # NOVA_LIBRARIES - Link these to use NOVA # Copyright (c) 2006, Jasem Mutlaq # Based on FindLibfacile by Carsten Niehaus, # # Redistribution and use is allowed according to the terms of the BSD license. # For details see the accompanying COPYING-CMAKE-SCRIPTS file. if (NOVA_INCLUDE_DIR AND NOVA_LIBRARIES) # in cache already set(NOVA_FOUND TRUE) message(STATUS "Found libnova: ${NOVA_LIBRARIES}") else (NOVA_INCLUDE_DIR AND NOVA_LIBRARIES) find_path(NOVA_INCLUDE_DIR libnova.h PATH_SUFFIXES libnova ${_obIncDir} ${GNUWIN32_DIR}/include ) find_library(NOVA_LIBRARIES NAMES nova libnova libnovad PATHS ${_obLinkDir} ${GNUWIN32_DIR}/lib ) set(CMAKE_REQUIRED_INCLUDES ${NOVA_INCLUDE_DIR}) set(CMAKE_REQUIRED_LIBRARIES ${NOVA_LIBRARIES}) if(NOVA_INCLUDE_DIR AND NOVA_LIBRARIES) set(NOVA_FOUND TRUE) else (NOVA_INCLUDE_DIR AND NOVA_LIBRARIES) set(NOVA_FOUND FALSE) endif(NOVA_INCLUDE_DIR AND NOVA_LIBRARIES) if (NOVA_FOUND) if (NOT Nova_FIND_QUIETLY) message(STATUS "Found NOVA: ${NOVA_LIBRARIES}") endif (NOT Nova_FIND_QUIETLY) else (NOVA_FOUND) if (Nova_FIND_REQUIRED) message(FATAL_ERROR "libnova not found. Please install libnova development package.") endif (Nova_FIND_REQUIRED) endif (NOVA_FOUND) mark_as_advanced(NOVA_INCLUDE_DIR NOVA_LIBRARIES) endif (NOVA_INCLUDE_DIR AND NOVA_LIBRARIES) libfishcamp-1.2+20220607003151/cmake_modules/FindVorbis.cmake0000644000175100017510000000204414174600255022320 0ustar debiandebian# - Find vorbis # Find the native vorbis includes and libraries # # VORBIS_INCLUDE_DIR - where to find vorbis.h, etc. # VORBIS_LIBRARIES - List of libraries when using vorbis(file). # VORBIS_FOUND - True if vorbis found. if(VORBIS_INCLUDE_DIR) # Already in cache, be silent set(VORBIS_FIND_QUIETLY TRUE) endif(VORBIS_INCLUDE_DIR) find_path(VORBIS_INCLUDE_DIR vorbis/vorbisfile.h) find_library(OGG_LIBRARY NAMES ogg) find_library(VORBIS_LIBRARY NAMES vorbis) find_library(VORBISFILE_LIBRARY NAMES vorbisfile) # Handle the QUIETLY and REQUIRED arguments and set VORBIS_FOUND to TRUE if # all listed variables are TRUE. include(FindPackageHandleStandardArgs) find_package_handle_standard_args(VORBIS DEFAULT_MSG VORBIS_INCLUDE_DIR OGG_LIBRARY VORBIS_LIBRARY VORBIS_LIBRARY) if(VORBIS_FOUND) set(VORBIS_LIBRARIES ${VORBISFILE_LIBRARY} ${VORBIS_LIBRARY} ${OGG_LIBRARY}) else(VORBIS_FOUND) set(VORBIS_LIBRARIES) endif(VORBIS_FOUND) mark_as_advanced(VORBIS_INCLUDE_DIR) mark_as_advanced(OGG_LIBRARY VORBIS_LIBRARY VORBISFILE_LIBRARY) libfishcamp-1.2+20220607003151/cmake_modules/FindJPEG.cmake0000644000175100017510000000166314174600255021607 0ustar debiandebian# - Find JPEG # Find the native JPEG includes and library # This module defines # JPEG_INCLUDE_DIR, where to find jpeglib.h, etc. # JPEG_LIBRARIES, the libraries needed to use JPEG. # JPEG_FOUND, If false, do not try to use JPEG. # also defined, but not for general use are # JPEG_LIBRARY, where to find the JPEG library. FIND_PATH(JPEG_INCLUDE_DIR jpeglib.h) SET(JPEG_NAMES ${JPEG_NAMES} jpeg) FIND_LIBRARY(JPEG_LIBRARY NAMES ${JPEG_NAMES} ) # handle the QUIETLY and REQUIRED arguments and set JPEG_FOUND to TRUE if # all listed variables are TRUE INCLUDE(FindPackageHandleStandardArgs) FIND_PACKAGE_HANDLE_STANDARD_ARGS(JPEG DEFAULT_MSG JPEG_LIBRARY JPEG_INCLUDE_DIR) IF(JPEG_FOUND) SET(JPEG_LIBRARIES ${JPEG_LIBRARY}) ENDIF(JPEG_FOUND) # Deprecated declarations. SET (NATIVE_JPEG_INCLUDE_PATH ${JPEG_INCLUDE_DIR} ) GET_FILENAME_COMPONENT (NATIVE_JPEG_LIB_PATH ${JPEG_LIBRARY} PATH) MARK_AS_ADVANCED(JPEG_LIBRARY JPEG_INCLUDE_DIR ) libfishcamp-1.2+20220607003151/cmake_modules/FindCFITSIO.cmake0000644000175100017510000000434614174600255022163 0ustar debiandebian# - Try to find CFITSIO # Once done this will define # # CFITSIO_FOUND - system has CFITSIO # CFITSIO_INCLUDE_DIR - the CFITSIO include directory # CFITSIO_LIBRARIES - Link these to use CFITSIO # CFITSIO_VERSION_STRING - Human readable version number of cfitsio # CFITSIO_VERSION_MAJOR - Major version number of cfitsio # CFITSIO_VERSION_MINOR - Minor version number of cfitsio # Copyright (c) 2006, Jasem Mutlaq # Based on FindLibfacile by Carsten Niehaus, # # Redistribution and use is allowed according to the terms of the BSD license. # For details see the accompanying COPYING-CMAKE-SCRIPTS file. if (CFITSIO_INCLUDE_DIR AND CFITSIO_LIBRARIES) # in cache already set(CFITSIO_FOUND TRUE) message(STATUS "Found CFITSIO: ${CFITSIO_LIBRARIES}") else (CFITSIO_INCLUDE_DIR AND CFITSIO_LIBRARIES) # JM: Packages from different distributions have different suffixes find_path(CFITSIO_INCLUDE_DIR fitsio.h PATH_SUFFIXES libcfitsio3 libcfitsio0 cfitsio ${_obIncDir} ${GNUWIN32_DIR}/include ) find_library(CFITSIO_LIBRARIES NAMES cfitsio PATHS ${_obLinkDir} ${GNUWIN32_DIR}/lib ) if(CFITSIO_INCLUDE_DIR AND CFITSIO_LIBRARIES) set(CFITSIO_FOUND TRUE) else (CFITSIO_INCLUDE_DIR AND CFITSIO_LIBRARIES) set(CFITSIO_FOUND FALSE) endif(CFITSIO_INCLUDE_DIR AND CFITSIO_LIBRARIES) if (CFITSIO_FOUND) # Find the version of the cfitsio header file(STRINGS ${CFITSIO_INCLUDE_DIR}/fitsio.h CFITSIO_VERSION_STRING LIMIT_COUNT 1 REGEX "CFITSIO_VERSION") STRING(REGEX REPLACE "[^0-9.]" "" CFITSIO_VERSION_STRING ${CFITSIO_VERSION_STRING}) STRING(REGEX REPLACE "^([0-9]+)[.]([0-9]+)" "\\1" CFITSIO_VERSION_MAJOR ${CFITSIO_VERSION_STRING}) STRING(REGEX REPLACE "^([0-9]+)[.]([0-9]+)" "\\2" CFITSIO_VERSION_MINOR ${CFITSIO_VERSION_STRING}) if (NOT CFITSIO_FIND_QUIETLY) message(STATUS "Found CFITSIO ${CFITSIO_VERSION_STRING}: ${CFITSIO_LIBRARIES}") endif (NOT CFITSIO_FIND_QUIETLY) else (CFITSIO_FOUND) if (CFITSIO_FIND_REQUIRED) message(STATUS "CFITSIO not found.") endif (CFITSIO_FIND_REQUIRED) endif (CFITSIO_FOUND) mark_as_advanced(CFITSIO_INCLUDE_DIR CFITSIO_LIBRARIES) endif (CFITSIO_INCLUDE_DIR AND CFITSIO_LIBRARIES) libfishcamp-1.2+20220607003151/cmake_modules/FindUSB1.cmake0000644000175100017510000000562314174600255021574 0ustar debiandebian# - Try to find libusb-1.0 # Once done this will define # # USB1_FOUND - system has libusb-1.0 # USB1_INCLUDE_DIRS - the libusb-1.0 include directories # USB1_LIBRARIES - Link these to use libusb-1.0 # USB1_DEFINITIONS - Compiler switches required for using libusb-1.0 # # USB1_HAS_LIBUSB_ERROR_NAME - defined when libusb-1.0 has libusb_error_name() #============================================================================= # Copyright (c) 2017 Pino Toscano # # Redistribution and use in source and binary forms, with or without # modification, are permitted provided that the following conditions # are met: # # 1. Redistributions of source code must retain the copyright # notice, this list of conditions and the following disclaimer. # 2. Redistributions in binary form must reproduce the copyright # notice, this list of conditions and the following disclaimer in the # documentation and/or other materials provided with the distribution. # 3. The name of the author may not be used to endorse or promote products # derived from this software without specific prior written permission. # # THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR # IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES # OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. # IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, # INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT # NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF # THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #============================================================================= find_package(PkgConfig) pkg_check_modules(PC_LIBUSB1 QUIET libusb-1.0) find_path(USB1_INCLUDE_DIR NAMES libusb.h HINTS ${PC_LIBUSB1_INCLUDE_DIRS} PATH_SUFFIXES libusb-1.0 ) find_library(USB1_LIBRARY NAMES ${PC_LIBUSB1_LIBRARIES} usb-1.0 HINTS ${PC_LIBUSB1_LIBRARY_DIRS} ) set(USB1_INCLUDE_DIRS ${USB1_INCLUDE_DIR}) set(USB1_LIBRARIES ${USB1_LIBRARY}) include(FindPackageHandleStandardArgs) find_package_handle_standard_args(USB1 FOUND_VAR USB1_FOUND REQUIRED_VARS USB1_LIBRARY USB1_INCLUDE_DIR VERSION_VAR PC_LIBUSB1_VERSION ) mark_as_advanced(USB1_INCLUDE_DIRS USB1_LIBRARIES) if(USB1_FOUND) include(CheckCXXSourceCompiles) include(CMakePushCheckState) cmake_push_check_state(RESET) set(CMAKE_REQUIRED_INCLUDES ${USB1_INCLUDE_DIRS}) set(CMAKE_REQUIRED_LIBRARIES ${USB1_LIBRARIES}) check_cxx_source_compiles("#include int main() { libusb_error_name(0); return 0; }" USB1_HAS_LIBUSB_ERROR_NAME) cmake_pop_check_state() endif() libfishcamp-1.2+20220607003151/cmake_modules/FindGMock.cmake0000644000175100017510000001162314174600255022057 0ustar debiandebian#.rst: # FindGMock # --------- # # Locate the Google C++ Mocking Framework. # # Defines the following variables: # # :: # # GMOCK_FOUND - Found the Google Mocking framework # GMOCK_INCLUDE_DIRS - Include directories # # # # Also defines the library variables below as normal variables. These # contain debug/optimized keywords when a debugging library is found. # # :: # # GMOCK_LIBRARIES - libgmock # # # # Accepts the following variables as input: # # :: # # GMOCK_ROOT - (as a CMake or environment variable) # The root directory of the gmock install prefix # # # # :: # # GMOCK_MSVC_SEARCH - If compiling with MSVC, this variable can be set to # "MD" or "MT" to enable searching a GMock build tree # (defaults: "MD") # # # # Example Usage: # # :: # # find_package(GMock REQUIRED) # include_directories(${GMOCK_INCLUDE_DIRS}) # # # # :: # # add_executable(foo foo.cc) # target_link_libraries(foo ${GMOCK_LIBRARIES}) # # # # :: # # add_test(AllMocksInFoo foo) # # # # # # If you would like each Google test to show up in CMock as a test you # may use the following macro. NOTE: It will slow down your tests by # running an executable for each test and test fixture. You will also # have to rerun CMake after adding or removing tests or test fixtures. # # GMOCK_ADD_MOCKS(executable extra_args ARGN) # # :: # # executable = The path to the test executable # extra_args = Pass a list of extra arguments to be passed to # executable enclosed in quotes (or "" for none) # ARGN = A list of source files to search for tests & test # fixtures. # # # # :: # # Example: # set(FooMockArgs --foo 1 --bar 2) # add_executable(FooMock FooUnitMock.cc) # GMOCK_ADD_MOCKS(FooMock "${FooMockArgs}" FooUnitMock.cc) #============================================================================= # Copyright 2009 Kitware, Inc. # Copyright 2009 Philip Lowman # Copyright 2009 Daniel Blezek # # 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.) # # Thanks to Daniel Blezek for the GMOCK_ADD_MOCKS code function(GMOCK_ADD_MOCKS executable extra_args) if(NOT ARGN) message(FATAL_ERROR "Missing ARGN: Read the documentation for GMOCK_ADD_MOCKS") endif() foreach(source ${ARGN}) file(READ "${source}" contents) string(REGEX MATCHALL "MOCK_?F?\\(([A-Za-z_0-9 ,]+)\\)" found_tests ${contents}) foreach(hit ${found_tests}) string(REGEX REPLACE ".*\\( *([A-Za-z_0-9]+), *([A-Za-z_0-9]+) *\\).*" "\\1.\\2" test_name ${hit}) add_test(${test_name} ${executable} --gmock_filter=${test_name} ${extra_args}) endforeach() endforeach() endfunction() function(_gmock_append_debugs _endvar _library) if(${_library} AND ${_library}_DEBUG) set(_output optimized ${${_library}} debug ${${_library}_DEBUG}) else() set(_output ${${_library}}) endif() set(${_endvar} ${_output} PARENT_SCOPE) endfunction() function(_gmock_find_library _name) find_library(${_name} NAMES ${ARGN} HINTS ENV GMOCK_ROOT ${GMOCK_ROOT} PATH_SUFFIXES ${_gmock_libpath_suffixes} ) mark_as_advanced(${_name}) endfunction() # if(NOT DEFINED GMOCK_MSVC_SEARCH) set(GMOCK_MSVC_SEARCH MD) endif() set(_gmock_libpath_suffixes lib) if(MSVC) if(GMOCK_MSVC_SEARCH STREQUAL "MD") list(APPEND _gmock_libpath_suffixes msvc/gmock-md/Debug msvc/gmock-md/Release) elseif(GMOCK_MSVC_SEARCH STREQUAL "MT") list(APPEND _gmock_libpath_suffixes msvc/gmock/Debug msvc/gmock/Release) endif() endif() find_path(GMOCK_INCLUDE_DIR gmock/gmock.h HINTS $ENV{GMOCK_ROOT}/include ${GMOCK_ROOT}/include ) mark_as_advanced(GMOCK_INCLUDE_DIR) if(MSVC AND GMOCK_MSVC_SEARCH STREQUAL "MD") # The provided /MD project files for Google Mock add -md suffixes to the # library names. _gmock_find_library(GMOCK_LIBRARY gmock-md gmock) _gmock_find_library(GMOCK_LIBRARY_DEBUG gmock-mdd gmockd) else() _gmock_find_library(GMOCK_LIBRARY gmock) _gmock_find_library(GMOCK_LIBRARY_DEBUG gmockd) endif() FIND_PACKAGE_HANDLE_STANDARD_ARGS(GMock DEFAULT_MSG GMOCK_LIBRARY GMOCK_INCLUDE_DIR) if(GMOCK_FOUND) set(GMOCK_INCLUDE_DIRS ${GMOCK_INCLUDE_DIR}) _gmock_append_debugs(GMOCK_LIBRARIES GMOCK_LIBRARY) endif() libfishcamp-1.2+20220607003151/cmake_modules/FindPackageMessage.cmake0000644000175100017510000000375514174600255023726 0ustar debiandebian#.rst: # FindPackageMessage # ------------------ # # # # FIND_PACKAGE_MESSAGE( "message for user" "find result details") # # This macro is intended to be used in FindXXX.cmake modules files. It # will print a message once for each unique find result. This is useful # for telling the user where a package was found. The first argument # specifies the name (XXX) of the package. The second argument # specifies the message to display. The third argument lists details # about the find result so that if they change the message will be # displayed again. The macro also obeys the QUIET argument to the # find_package command. # # Example: # # :: # # if(X11_FOUND) # FIND_PACKAGE_MESSAGE(X11 "Found X11: ${X11_X11_LIB}" # "[${X11_X11_LIB}][${X11_INCLUDE_DIR}]") # else() # ... # endif() #============================================================================= # Copyright 2008-2009 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.) function(FIND_PACKAGE_MESSAGE pkg msg details) # Avoid printing a message repeatedly for the same find result. if(NOT ${pkg}_FIND_QUIETLY) string(REPLACE "\n" "" details "${details}") set(DETAILS_VAR FIND_PACKAGE_MESSAGE_DETAILS_${pkg}) if(NOT "${details}" STREQUAL "${${DETAILS_VAR}}") # The message has not yet been printed. message(STATUS "${msg}") # Save the find details in the cache to avoid printing the same # message again. set("${DETAILS_VAR}" "${details}" CACHE INTERNAL "Details about finding ${pkg}") endif() endif() endfunction() libfishcamp-1.2+20220607003151/cmake_modules/FindFTDI.cmake0000644000175100017510000000267114174600255021610 0ustar debiandebian# - Try to find FTDI # This finds libFTDI that is compatible with old libusb v 0.1 # For newer libusb > 1.0, use FindFTDI1.cmake # Once done this will define # # FTDI_FOUND - system has FTDI # FTDI_INCLUDE_DIR - the FTDI include directory # FTDI_LIBRARIES - Link these to use FTDI # Redistribution and use is allowed according to the terms of the BSD license. # For details see the accompanying COPYING-CMAKE-SCRIPTS file. if (FTDI_INCLUDE_DIR AND FTDI_LIBRARIES) # in cache already set(FTDI_FOUND TRUE) message(STATUS "Found libftdi: ${FTDI_LIBRARIES}") else (FTDI_INCLUDE_DIR AND FTDI_LIBRARIES) find_path(FTDI_INCLUDE_DIR ftdi.h PATH_SUFFIXES libftdi1 ${_obIncDir} ${GNUWIN32_DIR}/include /usr/local/include ) find_library(FTDI_LIBRARIES NAMES ftdi ftdi1 PATHS ${_obLinkDir} ${GNUWIN32_DIR}/lib /usr/local/lib ) if(FTDI_INCLUDE_DIR AND FTDI_LIBRARIES) set(FTDI_FOUND TRUE) else (FTDI_INCLUDE_DIR AND FTDI_LIBRARIES) set(FTDI_FOUND FALSE) endif(FTDI_INCLUDE_DIR AND FTDI_LIBRARIES) if (FTDI_FOUND) if (NOT FTDI_FIND_QUIETLY) message(STATUS "Found FTDI: ${FTDI_LIBRARIES}") endif (NOT FTDI_FIND_QUIETLY) else (FTDI_FOUND) if (FTDI_FIND_REQUIRED) message(FATAL_ERROR "FTDI not found. Please install libftdi-dev") endif (FTDI_FIND_REQUIRED) endif (FTDI_FOUND) mark_as_advanced(FTDI_INCLUDE_DIR FTDI_LIBRARIES) endif (FTDI_INCLUDE_DIR AND FTDI_LIBRARIES) libfishcamp-1.2+20220607003151/cmake_modules/FindMODBUS.cmake0000644000175100017510000000320114174600255022041 0ustar debiandebian# - Try to find libmodbus # Once done this will define # # MODBUS_FOUND - system has MODBUS # MODBUS_INCLUDE_DIR - the MODBUS include directory # MODBUS_LIBRARIES - Link these to use MODBUS # Copyright (c) 2006, Jasem Mutlaq # Based on FindLibfacile by Carsten Niehaus, # # Redistribution and use is allowed according to the terms of the BSD license. # For details see the accompanying COPYING-CMAKE-SCRIPTS file. if (MODBUS_INCLUDE_DIR AND MODBUS_LIBRARIES) # in cache already set(MODBUS_FOUND TRUE) message(STATUS "Found libmodbus: ${MODBUS_LIBRARIES}") else (MODBUS_INCLUDE_DIR AND MODBUS_LIBRARIES) find_path(MODBUS_INCLUDE_DIR modbus.h PATH_SUFFIXES modbus ${_obIncDir} ${GNUWIN32_DIR}/include ) find_library(MODBUS_LIBRARIES NAMES modbus PATHS ${_obLinkDir} ${GNUWIN32_DIR}/lib ) set(CMAKE_REQUIRED_INCLUDES ${MODBUS_INCLUDE_DIR}) set(CMAKE_REQUIRED_LIBRARIES ${MODBUS_LIBRARIES}) if(MODBUS_INCLUDE_DIR AND MODBUS_LIBRARIES) set(MODBUS_FOUND TRUE) else (MODBUS_INCLUDE_DIR AND MODBUS_LIBRARIES) set(MODBUS_FOUND FALSE) endif(MODBUS_INCLUDE_DIR AND MODBUS_LIBRARIES) if (MODBUS_FOUND) if (NOT MODBUS_FIND_QUIETLY) message(STATUS "Found libmodbus: ${MODBUS_LIBRARIES}") endif (NOT MODBUS_FIND_QUIETLY) else (MODBUS_FOUND) if (MODBUS_FIND_REQUIRED) message(FATAL_ERROR "libmodbus not found. Please install libmodbus-devel. https://launchpad.net/libmodbus/") endif (MODBUS_FIND_REQUIRED) endif (MODBUS_FOUND) mark_as_advanced(MODBUS_INCLUDE_DIR MODBUS_LIBRARIES) endif (MODBUS_INCLUDE_DIR AND MODBUS_LIBRARIES) libfishcamp-1.2+20220607003151/cmake_modules/FindSTARSHOOTG.cmake0000644000175100017510000000307014174600255022551 0ustar debiandebian# - Try to find Starshoot Camera Library # Once done this will define # # STARSHOOTG_FOUND - system has Starshoot # STARSHOOTG_INCLUDE_DIR - the Starshoot include directory # STARSHOOTG_LIBRARIES - Link these to use Starshoot # Redistribution and use is allowed according to the terms of the BSD license. # For details see the accompanying COPYING-CMAKE-SCRIPTS file. if (STARSHOOTG_INCLUDE_DIR AND STARSHOOTG_LIBRARIES) # in cache already set(STARSHOOTG_FOUND TRUE) message(STATUS "Found libstarshootg: ${STARSHOOTG_LIBRARIES}") else (STARSHOOTG_INCLUDE_DIR AND STARSHOOTG_LIBRARIES) find_path(STARSHOOTG_INCLUDE_DIR starshootg.h PATH_SUFFIXES libstarshootg ${_obIncDir} ${GNUWIN32_DIR}/include ) find_library(STARSHOOTG_LIBRARIES NAMES starshootg PATHS ${_obLinkDir} ${GNUWIN32_DIR}/lib ) if(STARSHOOTG_INCLUDE_DIR AND STARSHOOTG_LIBRARIES) set(STARSHOOTG_FOUND TRUE) else (STARSHOOTG_INCLUDE_DIR AND STARSHOOTG_LIBRARIES) set(STARSHOOTG_FOUND FALSE) endif(STARSHOOTG_INCLUDE_DIR AND STARSHOOTG_LIBRARIES) if (STARSHOOTG_FOUND) if (NOT STARSHOOTG_FIND_QUIETLY) message(STATUS "Found StarshootG: ${STARSHOOTG_LIBRARIES}") endif (NOT STARSHOOTG_FIND_QUIETLY) else (STARSHOOTG_FOUND) if (STARSHOOTG_FIND_REQUIRED) message(FATAL_ERROR "StarshootG not found. Please install StarshootG Library http://www.indilib.org") endif (STARSHOOTG_FIND_REQUIRED) endif (STARSHOOTG_FOUND) mark_as_advanced(STARSHOOTG_INCLUDE_DIR STARSHOOTG_LIBRARIES) endif (STARSHOOTG_INCLUDE_DIR AND STARSHOOTG_LIBRARIES) libfishcamp-1.2+20220607003151/cmake_modules/InstallImported.cmake0000644000175100017510000000661114174600255023371 0ustar debiandebian function (install_imported) cmake_parse_arguments (ARG "" "DESTINATION" "TARGETS" ${ARGN}) if (NOT DEFINED ARG_DESTINATION) message (FATAL_ERROR "DESTINATION not defined") endif () foreach (target ${ARG_TARGETS}) get_target_property (location ${target} LOCATION) get_target_property (version ${target} VERSION) get_target_property (soversion ${target} SOVERSION) get_target_property (output_name ${target} OUTPUT_NAME) get_target_property (suffix ${target} SUFFIX) get_target_property (type ${target} TYPE) if (NOT ${type} STREQUAL "SHARED_LIBRARY") message (FATAL_ERROR "install_imported: ${type} not supported") endif () if (${location} STREQUAL "${target}-NOTFOUND") return () endif () if (NOT ${version} STREQUAL "version-NOTFOUND") set (version ".${version}") else () set (version "") endif () if (NOT ${soversion} STREQUAL "soversion-NOTFOUND") set (soversion ".${soversion}") else () set (soversion "") endif () if (${output_name} STREQUAL "output_name-NOTFOUND") set (output_name ${target}) endif () set (name_noversion "${CMAKE_SHARED_LIBRARY_PREFIX}${output_name}${CMAKE_SHARED_LIBRARY_SUFFIX}") if (APPLE) set (name_version "${CMAKE_SHARED_LIBRARY_PREFIX}${output_name}${version}${CMAKE_SHARED_LIBRARY_SUFFIX}") set (name_soversion "${CMAKE_SHARED_LIBRARY_PREFIX}${output_name}${soversion}${CMAKE_SHARED_LIBRARY_SUFFIX}") else () set (name_version "${CMAKE_SHARED_LIBRARY_PREFIX}${output_name}${CMAKE_SHARED_LIBRARY_SUFFIX}${version}") set (name_soversion "${CMAKE_SHARED_LIBRARY_PREFIX}${output_name}${CMAKE_SHARED_LIBRARY_SUFFIX}${soversion}") endif () if (NOT IS_ABSOLUTE ${location}) set (location ${CMAKE_CURRENT_SOURCE_DIR}/${location}) endif () if (NOT ${name_noversion} STREQUAL ${name_soversion}) add_custom_command ( OUTPUT ${name_noversion} COMMAND ${CMAKE_COMMAND} -E create_symlink ${name_soversion} ${name_noversion} WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR} MAIN_DEPENDENCY ${name_soversion} ) install (FILES ${CMAKE_CURRENT_BINARY_DIR}/${name_noversion} DESTINATION ${ARG_DESTINATION}) endif () if (NOT ${name_soversion} STREQUAL ${name_version}) add_custom_command ( OUTPUT ${name_soversion} COMMAND ${CMAKE_COMMAND} -E create_symlink ${name_version} ${name_soversion} WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR} MAIN_DEPENDENCY ${name_version} ) install (FILES ${CMAKE_CURRENT_BINARY_DIR}/${name_soversion} DESTINATION ${ARG_DESTINATION}) endif () add_custom_command ( OUTPUT ${name_version} COMMAND ${CMAKE_COMMAND} -E copy "${location}" "${CMAKE_CURRENT_BINARY_DIR}/${name_version}" MAIN_DEPENDENCY ${location} ) install (FILES ${CMAKE_CURRENT_BINARY_DIR}/${name_version} DESTINATION ${ARG_DESTINATION}) add_custom_target( imported_${output_name} ALL DEPENDS ${name_version} ${name_noversion} ${name_soversion} ) endforeach () endfunction () libfishcamp-1.2+20220607003151/cmake_modules/FindAHPXC.cmake0000644000175100017510000000273214174600255021723 0ustar debiandebian# - Try to find AHPXC Universal Library # Once done this will define # # AHPXC_FOUND - system has AHPXC # AHPXC_INCLUDE_DIR - the AHPXC include directory # AHPXC_LIBRARIES - Link these to use AHPXC # Redistribution and use is allowed according to the terms of the BSD license. # For details see the accompanying COPYING-CMAKE-SCRIPTS file. if (AHPXC_INCLUDE_DIR AND AHPXC_LIBRARIES) # in cache already set(AHPXC_FOUND TRUE) message(STATUS "Found libahp_xc: ${AHPXC_LIBRARIES}") else (AHPXC_INCLUDE_DIR AND AHPXC_LIBRARIES) find_path(AHPXC_INCLUDE_DIR ahp_xc.h PATH_SUFFIXES ahp ${_obIncDir} ${GNUWIN32_DIR}/include ) find_library(AHPXC_LIBRARIES NAMES ahp_xc PATHS ${_obLinkDir} ${GNUWIN32_DIR}/lib ) if(AHPXC_INCLUDE_DIR AND AHPXC_LIBRARIES) set(AHPXC_FOUND TRUE) else (AHPXC_INCLUDE_DIR AND AHPXC_LIBRARIES) set(AHPXC_FOUND FALSE) endif(AHPXC_INCLUDE_DIR AND AHPXC_LIBRARIES) if (AHPXC_FOUND) if (NOT AHPXC_FIND_QUIETLY) message(STATUS "Found AHP XC: ${AHPXC_LIBRARIES}") endif (NOT AHPXC_FIND_QUIETLY) else (AHPXC_FOUND) if (AHPXC_FIND_REQUIRED) message(FATAL_ERROR "AHP XC not found. Please install libahp_xc http://www.indilib.org") endif (AHPXC_FIND_REQUIRED) endif (AHPXC_FOUND) mark_as_advanced(AHPXC_INCLUDE_DIR AHPXC_LIBRARIES) endif (AHPXC_INCLUDE_DIR AND AHPXC_LIBRARIES) libfishcamp-1.2+20220607003151/cmake_modules/FindFLI.cmake0000644000175100017510000000264514174600255021475 0ustar debiandebian# - Try to find Finger Lakes Instruments Library # Once done this will define # # FLI_FOUND - system has FLI # FLI_INCLUDE_DIR - the FLI include directory # FLI_LIBRARIES - Link these to use FLI # Copyright (c) 2008, Jasem Mutlaq # Based on FindLibfacile by Carsten Niehaus, # # Redistribution and use is allowed according to the terms of the BSD license. # For details see the accompanying COPYING-CMAKE-SCRIPTS file. if (FLI_INCLUDE_DIR AND FLI_LIBRARIES) # in cache already set(FLI_FOUND TRUE) message(STATUS "Found libfli: ${FLI_LIBRARIES}") else (FLI_INCLUDE_DIR AND FLI_LIBRARIES) find_path(FLI_INCLUDE_DIR libfli.h PATH_SUFFIXES fli ${_obIncDir} ${GNUWIN32_DIR}/include ) find_library(FLI_LIBRARIES NAMES fli PATHS ${_obLinkDir} ${GNUWIN32_DIR}/lib ) if(FLI_INCLUDE_DIR AND FLI_LIBRARIES) set(FLI_FOUND TRUE) else (FLI_INCLUDE_DIR AND FLI_LIBRARIES) set(FLI_FOUND FALSE) endif(FLI_INCLUDE_DIR AND FLI_LIBRARIES) if (FLI_FOUND) if (NOT FLI_FIND_QUIETLY) message(STATUS "Found FLI: ${FLI_LIBRARIES}") endif (NOT FLI_FIND_QUIETLY) else (FLI_FOUND) if (FLI_FIND_REQUIRED) message(FATAL_ERROR "FLI not found. Please install libfli-dev. http://www.indilib.org") endif (FLI_FIND_REQUIRED) endif (FLI_FOUND) mark_as_advanced(FLI_INCLUDE_DIR FLI_LIBRARIES) endif (FLI_INCLUDE_DIR AND FLI_LIBRARIES) libfishcamp-1.2+20220607003151/cmake_modules/FindASI.cmake0000644000175100017510000000356514174600255021501 0ustar debiandebian# - Try to find ASI Library # Once done this will define # # ASI_FOUND - system has ASI # ASI_INCLUDE_DIR - the ASI include directory # ASI_LIBRARIES - Link these to use ASI # Redistribution and use is allowed according to the terms of the BSD license. # For details see the accompanying COPYING-CMAKE-SCRIPTS file. if (ASI_INCLUDE_DIR AND ASI_LIBRARIES) # in cache already set(ASI_FOUND TRUE) message(STATUS "Found libasi: ${ASI_LIBRARIES}") else (ASI_INCLUDE_DIR AND ASI_LIBRARIES) find_path(ASI_INCLUDE_DIR ASICamera2.h PATH_SUFFIXES libasi ${_obIncDir} ${GNUWIN32_DIR}/include ) find_library(ASICAM_LIBRARIES NAMES ASICamera2 PATHS ${_obLinkDir} ${GNUWIN32_DIR}/lib ) find_library(ASIEFW_LIBRARIES NAMES EFWFilter PATHS ${_obLinkDir} ${GNUWIN32_DIR}/lib ) find_library(ASIST4_LIBRARIES NAMES USB2ST4Conv PATHS ${_obLinkDir} ${GNUWIN32_DIR}/lib ) find_library(ASIEAF_LIBRARIES NAMES EAFFocuser PATHS ${_obLinkDir} ${GNUWIN32_DIR}/lib ) if (ASICAM_LIBRARIES AND ASIEFW_LIBRARIES AND ASIST4_LIBRARIES AND ASIEAF_LIBRARIES) set(ASI_LIBRARIES ${ASICAM_LIBRARIES} ${ASIEFW_LIBRARIES} ${ASIST4_LIBRARIES} ${ASIEAF_LIBRARIES}) endif (ASICAM_LIBRARIES AND ASIEFW_LIBRARIES AND ASIST4_LIBRARIES AND ASIEAF_LIBRARIES) if(ASI_INCLUDE_DIR AND ASI_LIBRARIES) set(ASI_FOUND TRUE) else (ASI_INCLUDE_DIR AND ASI_LIBRARIES) set(ASI_FOUND FALSE) endif(ASI_INCLUDE_DIR AND ASI_LIBRARIES) if (ASI_FOUND) if (NOT ASI_FIND_QUIETLY) message(STATUS "Found ASI: ${ASI_LIBRARIES}") endif (NOT ASI_FIND_QUIETLY) else (ASI_FOUND) if (ASI_FIND_REQUIRED) message(FATAL_ERROR "ASI not found. Please install libasi http://www.indilib.org") endif (ASI_FIND_REQUIRED) endif (ASI_FOUND) mark_as_advanced(ASI_INCLUDE_DIR ASI_LIBRARIES) endif (ASI_INCLUDE_DIR AND ASI_LIBRARIES) libfishcamp-1.2+20220607003151/cmake_modules/FindINDI.cmake0000644000175100017510000003457414174600255021614 0ustar debiandebian# Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # http://www.apache.org/licenses/LICENSE-2.0 # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # # This module can find INDI Library # # Requirements: # - CMake >= 2.8.3 (for new version of find_package_handle_standard_args) # # The following variables will be defined for your use: # - INDI_FOUND : were all of your specified components found (include dependencies)? # - INDI_WEBSOCKET : was INDI compiled with websocket support? # - INDI_INCLUDE_DIR : INDI include directory # - INDI_DATA_DIR : INDI include directory # - INDI_LIBRARIES : INDI libraries # - INDI_DRIVER_LIBRARIES : Same as above maintained for backward compatibility # - INDI_VERSION : complete version of INDI (x.y.z) # - INDI_MAJOR_VERSION : major version of INDI # - INDI_MINOR_VERSION : minor version of INDI # - INDI_RELEASE_VERSION : release version of INDI # - INDI__FOUND : were found? (FALSE for non specified component if it is not a dependency) # # For windows or non standard installation, define INDI_ROOT variable to point to the root installation of INDI. Two ways: # - run cmake with -DINDI_ROOT= # - define an environment variable with the same name before running cmake # With cmake-gui, before pressing "Configure": # 1) Press "Add Entry" button # 2) Add a new entry defined as: # - Name: INDI_ROOT # - Type: choose PATH in the selection list # - Press "..." button and select the root installation of INDI # # Example Usage: # # 1. Copy this file in the root of your project source directory # 2. Then, tell CMake to search this non-standard module in your project directory by adding to your CMakeLists.txt: # set(CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}) # 3. Finally call find_package() once, here are some examples to pick from # # Require INDI 1.4 or later # find_package(INDI 1.4 REQUIRED) # # if(INDI_FOUND) # include_directories(${INDI_INCLUDE_DIR}) # add_executable(myapp myapp.cpp) # target_link_libraries(myapp ${INDI_LIBRARIES}) # endif(INDI_FOUND) # # # Using Components: # # You can search for specific components. Currently, the following components are available # * driver: to build INDI hardware drivers. # * align: to build drivers that use INDI Alignment Subsystem. # * client: to build pure C++ INDI clients. # * clientqt5: to build Qt5-based INDI clients. # * lx200: To build LX200-based 3rd party drivers (you must link with driver above as well). # # By default, if you do not specify any components, driver and align components are searched. # # Example: # # To use INDI Qt5 Client library only in your application: # # find_package(INDI COMPONENTS clientqt5 REQUIRED) # # if(INDI_FOUND) # include_directories(${INDI_INCLUDE_DIR}) # add_executable(myapp myapp.cpp) # target_link_libraries(myapp ${INDI_LIBRARIES}) # endif(INDI_FOUND) # # To use INDI driver + lx200 component in your application: # # find_package(INDI COMPONENTS driver lx200 REQUIRED) # # if(INDI_FOUND) # include_directories(${INDI_INCLUDE_DIR}) # add_executable(myapp myapp.cpp) # target_link_libraries(myapp ${INDI_LIBRARIES}) # endif(INDI_FOUND) # # Notice we still use ${INDI_LIBRARIES} which now should contain both driver & lx200 libraries. #============================================================================================== # Copyright (c) 2011-2013, julp # Copyright (c) 2017-2019 Jasem Mutlaq # # Distributed under the OSI-approved BSD License # # This software is distributed WITHOUT ANY WARRANTY; without even the # implied warranty of MERCHANTABILITY or FITNESS FOR A PARTINDILAR PURPOSE. #============================================================================= find_package(PkgConfig QUIET) ########## Private ########## if(NOT DEFINED INDI_PUBLIC_VAR_NS) set(INDI_PUBLIC_VAR_NS "INDI") # Prefix for all INDI relative public variables endif(NOT DEFINED INDI_PUBLIC_VAR_NS) if(NOT DEFINED INDI_PRIVATE_VAR_NS) set(INDI_PRIVATE_VAR_NS "_${INDI_PUBLIC_VAR_NS}") # Prefix for all INDI relative internal variables endif(NOT DEFINED INDI_PRIVATE_VAR_NS) if(NOT DEFINED PC_INDI_PRIVATE_VAR_NS) set(PC_INDI_PRIVATE_VAR_NS "_PC${INDI_PRIVATE_VAR_NS}") # Prefix for all pkg-config relative internal variables endif(NOT DEFINED PC_INDI_PRIVATE_VAR_NS) function(indidebug _VARNAME) if(${INDI_PUBLIC_VAR_NS}_DEBUG) if(DEFINED ${INDI_PUBLIC_VAR_NS}_${_VARNAME}) message("${INDI_PUBLIC_VAR_NS}_${_VARNAME} = ${${INDI_PUBLIC_VAR_NS}_${_VARNAME}}") else(DEFINED ${INDI_PUBLIC_VAR_NS}_${_VARNAME}) message("${INDI_PUBLIC_VAR_NS}_${_VARNAME} = ") endif(DEFINED ${INDI_PUBLIC_VAR_NS}_${_VARNAME}) endif(${INDI_PUBLIC_VAR_NS}_DEBUG) endfunction(indidebug) set(${INDI_PRIVATE_VAR_NS}_ROOT "") if(DEFINED ENV{INDI_ROOT}) set(${INDI_PRIVATE_VAR_NS}_ROOT "$ENV{INDI_ROOT}") endif(DEFINED ENV{INDI_ROOT}) if (DEFINED INDI_ROOT) set(${INDI_PRIVATE_VAR_NS}_ROOT "${INDI_ROOT}") endif(DEFINED INDI_ROOT) set(${INDI_PRIVATE_VAR_NS}_BIN_SUFFIXES ) set(${INDI_PRIVATE_VAR_NS}_LIB_SUFFIXES ) if(CMAKE_SIZEOF_VOID_P EQUAL 8) list(APPEND ${INDI_PRIVATE_VAR_NS}_BIN_SUFFIXES "bin64") list(APPEND ${INDI_PRIVATE_VAR_NS}_LIB_SUFFIXES "lib64") endif(CMAKE_SIZEOF_VOID_P EQUAL 8) list(APPEND ${INDI_PRIVATE_VAR_NS}_BIN_SUFFIXES "bin") list(APPEND ${INDI_PRIVATE_VAR_NS}_LIB_SUFFIXES "lib") set(${INDI_PRIVATE_VAR_NS}_COMPONENTS ) # ... macro(INDI_declare_component _NAME) list(APPEND ${INDI_PRIVATE_VAR_NS}_COMPONENTS ${_NAME}) set("${INDI_PRIVATE_VAR_NS}_COMPONENTS_${_NAME}" ${ARGN}) endmacro(INDI_declare_component) INDI_declare_component(driver indidriver) INDI_declare_component(align indiAlignmentDriver) INDI_declare_component(client indiclient) INDI_declare_component(clientqt5 indiclientqt5) INDI_declare_component(lx200 indilx200) ########## Public ########## set(${INDI_PUBLIC_VAR_NS}_FOUND TRUE) set(${INDI_PUBLIC_VAR_NS}_LIBRARIES ) set(${INDI_PUBLIC_VAR_NS}_INCLUDE_DIR ) foreach(${INDI_PRIVATE_VAR_NS}_COMPONENT ${${INDI_PRIVATE_VAR_NS}_COMPONENTS}) string(TOUPPER "${${INDI_PRIVATE_VAR_NS}_COMPONENT}" ${INDI_PRIVATE_VAR_NS}_UPPER_COMPONENT) set("${INDI_PUBLIC_VAR_NS}_${${INDI_PRIVATE_VAR_NS}_UPPER_COMPONENT}_FOUND" FALSE) # may be done in the INDI_declare_component macro endforeach(${INDI_PRIVATE_VAR_NS}_COMPONENT) # Check components if(NOT ${INDI_PUBLIC_VAR_NS}_FIND_COMPONENTS) # driver and posix client by default set(${INDI_PUBLIC_VAR_NS}_FIND_COMPONENTS driver align) else(NOT ${INDI_PUBLIC_VAR_NS}_FIND_COMPONENTS) #list(APPEND ${INDI_PUBLIC_VAR_NS}_FIND_COMPONENTS uc) list(REMOVE_DUPLICATES ${INDI_PUBLIC_VAR_NS}_FIND_COMPONENTS) foreach(${INDI_PRIVATE_VAR_NS}_COMPONENT ${${INDI_PUBLIC_VAR_NS}_FIND_COMPONENTS}) if(NOT DEFINED ${INDI_PRIVATE_VAR_NS}_COMPONENTS_${${INDI_PRIVATE_VAR_NS}_COMPONENT}) message(FATAL_ERROR "Unknown INDI component: ${${INDI_PRIVATE_VAR_NS}_COMPONENT}") endif(NOT DEFINED ${INDI_PRIVATE_VAR_NS}_COMPONENTS_${${INDI_PRIVATE_VAR_NS}_COMPONENT}) endforeach(${INDI_PRIVATE_VAR_NS}_COMPONENT) endif(NOT ${INDI_PUBLIC_VAR_NS}_FIND_COMPONENTS) # Includes find_path( ${INDI_PUBLIC_VAR_NS}_INCLUDE_DIR indidevapi.h PATH_SUFFIXES libindi include/libindi ${PC_INDI_INCLUDE_DIR} ${_obIncDir} ${GNUWIN32_DIR}/include HINTS ${${INDI_PRIVATE_VAR_NS}_ROOT} DOC "Include directory for INDI" ) find_path( WEBSOCKET_HEADER indiwsserver.h PATH_SUFFIXES libindi ${PC_INDI_INCLUDE_DIR} ${_obIncDir} ${GNUWIN32_DIR}/include ) if (WEBSOCKET_HEADER) SET(INDI_WEBSOCKET TRUE) else() SET(INDI_WEBSOCKET FALSE) endif() find_path(${INDI_PUBLIC_VAR_NS}_DATA_DIR drivers.xml PATH_SUFFIXES share/indi DOC "Data directory for INDI" ) if(${INDI_PUBLIC_VAR_NS}_INCLUDE_DIR) if(EXISTS "${${INDI_PUBLIC_VAR_NS}_INCLUDE_DIR}/indiversion.h") # INDI >= 1.4 file(READ "${${INDI_PUBLIC_VAR_NS}_INCLUDE_DIR}/indiversion.h" ${INDI_PRIVATE_VAR_NS}_VERSION_HEADER_CONTENTS) else() message(FATAL_ERROR "INDI version header not found") endif() if(${INDI_PRIVATE_VAR_NS}_VERSION_HEADER_CONTENTS MATCHES ".*INDI_VERSION ([0-9]+).([0-9]+).([0-9]+)") set(${INDI_PUBLIC_VAR_NS}_MAJOR_VERSION "${CMAKE_MATCH_1}") set(${INDI_PUBLIC_VAR_NS}_MINOR_VERSION "${CMAKE_MATCH_2}") set(${INDI_PUBLIC_VAR_NS}_RELEASE_VERSION "${CMAKE_MATCH_3}") else() message(FATAL_ERROR "failed to detect INDI version") endif() set(${INDI_PUBLIC_VAR_NS}_VERSION "${${INDI_PUBLIC_VAR_NS}_MAJOR_VERSION}.${${INDI_PUBLIC_VAR_NS}_MINOR_VERSION}.${${INDI_PUBLIC_VAR_NS}_RELEASE_VERSION}") # Check libraries foreach(${INDI_PRIVATE_VAR_NS}_COMPONENT ${${INDI_PUBLIC_VAR_NS}_FIND_COMPONENTS}) set(${INDI_PRIVATE_VAR_NS}_POSSIBLE_RELEASE_NAMES ) set(${INDI_PRIVATE_VAR_NS}_POSSIBLE_DEBUG_NAMES ) foreach(${INDI_PRIVATE_VAR_NS}_BASE_NAME ${${INDI_PRIVATE_VAR_NS}_COMPONENTS_${${INDI_PRIVATE_VAR_NS}_COMPONENT}}) list(APPEND ${INDI_PRIVATE_VAR_NS}_POSSIBLE_RELEASE_NAMES "${${INDI_PRIVATE_VAR_NS}_BASE_NAME}") list(APPEND ${INDI_PRIVATE_VAR_NS}_POSSIBLE_DEBUG_NAMES "${${INDI_PRIVATE_VAR_NS}_BASE_NAME}d") list(APPEND ${INDI_PRIVATE_VAR_NS}_POSSIBLE_RELEASE_NAMES "${${INDI_PRIVATE_VAR_NS}_BASE_NAME}${INDI_MAJOR_VERSION}${INDI_MINOR_VERSION}") list(APPEND ${INDI_PRIVATE_VAR_NS}_POSSIBLE_DEBUG_NAMES "${${INDI_PRIVATE_VAR_NS}_BASE_NAME}${INDI_MAJOR_VERSION}${INDI_MINOR_VERSION}d") endforeach(${INDI_PRIVATE_VAR_NS}_BASE_NAME) find_library( ${INDI_PRIVATE_VAR_NS}_LIB_RELEASE_${${INDI_PRIVATE_VAR_NS}_COMPONENT} NAMES ${${INDI_PRIVATE_VAR_NS}_POSSIBLE_RELEASE_NAMES} HINTS ${${INDI_PRIVATE_VAR_NS}_ROOT} PATH_SUFFIXES ${_INDI_LIB_SUFFIXES} DOC "Release libraries for INDI" ) find_library( ${INDI_PRIVATE_VAR_NS}_LIB_DEBUG_${${INDI_PRIVATE_VAR_NS}_COMPONENT} NAMES ${${INDI_PRIVATE_VAR_NS}_POSSIBLE_DEBUG_NAMES} HINTS ${${INDI_PRIVATE_VAR_NS}_ROOT} PATH_SUFFIXES ${_INDI_LIB_SUFFIXES} DOC "Debug libraries for INDI" ) string(TOUPPER "${${INDI_PRIVATE_VAR_NS}_COMPONENT}" ${INDI_PRIVATE_VAR_NS}_UPPER_COMPONENT) if(NOT ${INDI_PRIVATE_VAR_NS}_LIB_RELEASE_${${INDI_PRIVATE_VAR_NS}_COMPONENT} AND NOT ${INDI_PRIVATE_VAR_NS}_LIB_DEBUG_${${INDI_PRIVATE_VAR_NS}_COMPONENT}) # both not found set("${INDI_PUBLIC_VAR_NS}_${${INDI_PRIVATE_VAR_NS}_UPPER_COMPONENT}_FOUND" FALSE) set("${INDI_PUBLIC_VAR_NS}_FOUND" FALSE) else(NOT ${INDI_PRIVATE_VAR_NS}_LIB_RELEASE_${${INDI_PRIVATE_VAR_NS}_COMPONENT} AND NOT ${INDI_PRIVATE_VAR_NS}_LIB_DEBUG_${${INDI_PRIVATE_VAR_NS}_COMPONENT}) # one or both found set("${INDI_PUBLIC_VAR_NS}_${${INDI_PRIVATE_VAR_NS}_UPPER_COMPONENT}_FOUND" TRUE) if(NOT ${INDI_PRIVATE_VAR_NS}_LIB_RELEASE_${${INDI_PRIVATE_VAR_NS}_COMPONENT}) # release not found => we are in debug set(${INDI_PRIVATE_VAR_NS}_LIB_${${INDI_PRIVATE_VAR_NS}_COMPONENT} "${${INDI_PRIVATE_VAR_NS}_LIB_DEBUG_${${INDI_PRIVATE_VAR_NS}_COMPONENT}}") elseif(NOT ${INDI_PRIVATE_VAR_NS}_LIB_DEBUG_${${INDI_PRIVATE_VAR_NS}_COMPONENT}) # debug not found => we are in release set(${INDI_PRIVATE_VAR_NS}_LIB_${${INDI_PRIVATE_VAR_NS}_COMPONENT} "${${INDI_PRIVATE_VAR_NS}_LIB_RELEASE_${${INDI_PRIVATE_VAR_NS}_COMPONENT}}") else() # both found set( ${INDI_PRIVATE_VAR_NS}_LIB_${${INDI_PRIVATE_VAR_NS}_COMPONENT} optimized ${${INDI_PRIVATE_VAR_NS}_LIB_RELEASE_${${INDI_PRIVATE_VAR_NS}_COMPONENT}} debug ${${INDI_PRIVATE_VAR_NS}_LIB_DEBUG_${${INDI_PRIVATE_VAR_NS}_COMPONENT}} ) endif() list(APPEND ${INDI_PUBLIC_VAR_NS}_LIBRARIES ${${INDI_PRIVATE_VAR_NS}_LIB_${${INDI_PRIVATE_VAR_NS}_COMPONENT}}) endif(NOT ${INDI_PRIVATE_VAR_NS}_LIB_RELEASE_${${INDI_PRIVATE_VAR_NS}_COMPONENT} AND NOT ${INDI_PRIVATE_VAR_NS}_LIB_DEBUG_${${INDI_PRIVATE_VAR_NS}_COMPONENT}) endforeach(${INDI_PRIVATE_VAR_NS}_COMPONENT) # Check find_package arguments include(FindPackageHandleStandardArgs) if(${INDI_PUBLIC_VAR_NS}_FIND_REQUIRED AND NOT ${INDI_PUBLIC_VAR_NS}_FIND_QUIETLY) find_package_handle_standard_args( ${INDI_PUBLIC_VAR_NS} REQUIRED_VARS ${INDI_PUBLIC_VAR_NS}_LIBRARIES ${INDI_PUBLIC_VAR_NS}_INCLUDE_DIR VERSION_VAR ${INDI_PUBLIC_VAR_NS}_VERSION ) else(${INDI_PUBLIC_VAR_NS}_FIND_REQUIRED AND NOT ${INDI_PUBLIC_VAR_NS}_FIND_QUIETLY) find_package_handle_standard_args(${INDI_PUBLIC_VAR_NS} "INDI not found" ${INDI_PUBLIC_VAR_NS}_LIBRARIES ${INDI_PUBLIC_VAR_NS}_INCLUDE_DIR) endif(${INDI_PUBLIC_VAR_NS}_FIND_REQUIRED AND NOT ${INDI_PUBLIC_VAR_NS}_FIND_QUIETLY) else(${INDI_PUBLIC_VAR_NS}_INCLUDE_DIR) set("${INDI_PUBLIC_VAR_NS}_FOUND" FALSE) if(${INDI_PUBLIC_VAR_NS}_FIND_REQUIRED AND NOT ${INDI_PUBLIC_VAR_NS}_FIND_QUIETLY) message(FATAL_ERROR "Could not find INDI include directory") endif(${INDI_PUBLIC_VAR_NS}_FIND_REQUIRED AND NOT ${INDI_PUBLIC_VAR_NS}_FIND_QUIETLY) endif(${INDI_PUBLIC_VAR_NS}_INCLUDE_DIR) mark_as_advanced( ${INDI_PUBLIC_VAR_NS}_INCLUDE_DIR ${INDI_PUBLIC_VAR_NS}_LIBRARIES INDI_WEBSOCKET ) # IN (args) indidebug("FIND_COMPONENTS") indidebug("FIND_REQUIRED") indidebug("FIND_QUIETLY") indidebug("FIND_VERSION") # OUT # Found indidebug("FOUND") indidebug("SERVER_FOUND") indidebug("DRIVERS_FOUND") indidebug("CLIENT_FOUND") indidebug("QT5CLIENT_FOUND") indidebug("LX200_FOUND") # Linking indidebug("INCLUDE_DIR") indidebug("DATA_DIR") indidebug("LIBRARIES") # Backward compatibility set(${INDI_PUBLIC_VAR_NS}_DRIVER_LIBRARIES ${${INDI_PUBLIC_VAR_NS}_LIBRARIES}) indidebug("DRIVER_LIBRARIES") # Version indidebug("MAJOR_VERSION") indidebug("MINOR_VERSION") indidebug("RELEASE_VERSION") indidebug("VERSION") libfishcamp-1.2+20220607003151/cmake_modules/CMakeCommon.cmake0000644000175100017510000001366714174600255022421 0ustar debiandebian include(CheckCCompilerFlag) #IF (NOT ${CMAKE_CXX_COMPILER_ID} STREQUAL "MSVC") #SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -std=gnu99") #SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11") #ENDIF () # C++14 Support if (NOT ANDROID) set(CMAKE_CXX_STANDARD 14) set(CMAKE_CXX_STANDARD_REQUIRED ON) endif(NOT ANDROID) # Position Independent Code set(CMAKE_POSITION_INDEPENDENT_CODE ON) # Ccache support IF (ANDROID OR UNIX OR APPLE) FIND_PROGRAM(CCACHE_FOUND ccache) SET(CCACHE_SUPPORT OFF CACHE BOOL "Enable ccache support") IF ((CCACHE_FOUND OR ANDROID) AND CCACHE_SUPPORT MATCHES ON) SET_PROPERTY(GLOBAL PROPERTY RULE_LAUNCH_COMPILE ccache) SET_PROPERTY(GLOBAL PROPERTY RULE_LAUNCH_LINK ccache) ENDIF () ENDIF () # Add security (hardening flags) IF (UNIX OR APPLE OR ANDROID) # Older compilers are predefining _FORTIFY_SOURCE, so defining it causes a # warning, which is then considered an error. Second issue is that for # these compilers, _FORTIFY_SOURCE must be used while optimizing, else # causes a warning, which also results in an error. And finally, CMake is # not using optimization when testing for libraries, hence breaking the build. CHECK_C_COMPILER_FLAG("-Werror -D_FORTIFY_SOURCE=2" COMPATIBLE_FORTIFY_SOURCE) IF (${COMPATIBLE_FORTIFY_SOURCE}) SET(SEC_COMP_FLAGS "-D_FORTIFY_SOURCE=2") ENDIF () SET(SEC_COMP_FLAGS "${SEC_COMP_FLAGS} -fstack-protector-all -fPIE") # Make sure to add optimization flag. Some systems require this for _FORTIFY_SOURCE. IF (NOT CMAKE_BUILD_TYPE MATCHES "MinSizeRel" AND NOT CMAKE_BUILD_TYPE MATCHES "Release" AND NOT CMAKE_BUILD_TYPE MATCHES "Debug") SET(SEC_COMP_FLAGS "${SEC_COMP_FLAGS} -O1") ENDIF () IF (NOT ANDROID AND NOT "${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang" AND NOT APPLE AND NOT CYGWIN) SET(SEC_COMP_FLAGS "${SEC_COMP_FLAGS} -Wa,--noexecstack") ENDIF () SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${SEC_COMP_FLAGS}") SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${SEC_COMP_FLAGS}") SET(SEC_LINK_FLAGS "") IF (NOT APPLE AND NOT CYGWIN) SET(SEC_LINK_FLAGS "${SEC_LINK_FLAGS} -Wl,-z,nodump -Wl,-z,noexecstack -Wl,-z,relro -Wl,-z,now") ENDIF () IF (NOT ANDROID AND NOT APPLE) SET(SEC_LINK_FLAGS "${SEC_LINK_FLAGS} -pie") ENDIF () SET(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${SEC_LINK_FLAGS}") SET(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} ${SEC_LINK_FLAGS}") ENDIF () # Warning, debug and linker flags SET(FIX_WARNINGS OFF CACHE BOOL "Enable strict compilation mode to turn compiler warnings to errors") IF (UNIX OR APPLE) SET(COMP_FLAGS "") SET(LINKER_FLAGS "") # Verbose warnings and turns all to errors SET(COMP_FLAGS "${COMP_FLAGS} -Wall -Wextra") IF (FIX_WARNINGS) SET(COMP_FLAGS "${COMP_FLAGS} -Werror") ENDIF () # Omit problematic warnings IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU") SET(COMP_FLAGS "${COMP_FLAGS} -Wno-unused-but-set-variable") ENDIF () IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU" AND CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 6.9.9) SET(COMP_FLAGS "${COMP_FLAGS} -Wno-format-truncation") ENDIF () IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "AppleClang") SET(COMP_FLAGS "${COMP_FLAGS} -Wno-nonnull -Wno-deprecated-declarations") ENDIF () # Minimal debug info with Clang IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang") SET(COMP_FLAGS "${COMP_FLAGS} -gline-tables-only") ELSE () SET(COMP_FLAGS "${COMP_FLAGS} -g") ENDIF () # Note: The following flags are problematic on older systems with gcc 4.8 IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang" OR ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU" AND CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 4.9.9)) IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang" OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "AppleClang") SET(COMP_FLAGS "${COMP_FLAGS} -Wno-unused-command-line-argument") ENDIF () FIND_PROGRAM(LDGOLD_FOUND ld.gold) SET(LDGOLD_SUPPORT OFF CACHE BOOL "Enable ld.gold support") # Optional ld.gold is 2x faster than normal ld IF (LDGOLD_FOUND AND LDGOLD_SUPPORT MATCHES ON AND NOT APPLE AND NOT CMAKE_SYSTEM_PROCESSOR MATCHES arm) SET(LINKER_FLAGS "${LINKER_FLAGS} -fuse-ld=gold") # Use Identical Code Folding SET(COMP_FLAGS "${COMP_FLAGS} -ffunction-sections") SET(LINKER_FLAGS "${LINKER_FLAGS} -Wl,--icf=safe") # Compress the debug sections # Note: Before valgrind 3.12.0, patch should be applied for valgrind (https://bugs.kde.org/show_bug.cgi?id=303877) IF (NOT APPLE AND NOT ANDROID AND NOT CMAKE_SYSTEM_PROCESSOR MATCHES arm AND NOT CMAKE_CXX_CLANG_TIDY) SET(COMP_FLAGS "${COMP_FLAGS} -Wa,--compress-debug-sections") SET(LINKER_FLAGS "${LINKER_FLAGS} -Wl,--compress-debug-sections=zlib") ENDIF () ENDIF () ENDIF () # Apply the flags SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${COMP_FLAGS}") SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${COMP_FLAGS}") SET(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${LINKER_FLAGS}") SET(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} ${LINKER_FLAGS}") ENDIF () # Sanitizer support SET(CLANG_SANITIZERS OFF CACHE BOOL "Clang's sanitizer support") IF (CLANG_SANITIZERS AND ((UNIX AND "${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang") OR (APPLE AND "${CMAKE_CXX_COMPILER_ID}" STREQUAL "AppleClang"))) SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fsanitize=address,undefined -fno-omit-frame-pointer") SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fsanitize=address,undefined -fno-omit-frame-pointer") SET(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -fsanitize=address,undefined -fno-omit-frame-pointer") SET(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -fsanitize=address,undefined -fno-omit-frame-pointer") ENDIF () # Unity Build support include(UnityBuild) libfishcamp-1.2+20220607003151/cmake_modules/FindINOVASDK.cmake0000644000175100017510000000275314174600255022301 0ustar debiandebian# - Try to find INOVASDK Universal Library # Once done this will define # # INOVASDK_FOUND - system has INOVASDK # INOVASDK_INCLUDE_DIR - the INOVASDK include directory # INOVASDK_LIBRARIES - Link these to use INOVASDK # Redistribution and use is allowed according to the terms of the BSD license. # For details see the accompanying COPYING-CMAKE-SCRIPTS file. if (INOVASDK_INCLUDE_DIR AND INOVASDK_LIBRARIES) # in cache already set(INOVASDK_FOUND TRUE) message(STATUS "Found libinovasdk: ${INOVASDK_LIBRARIES}") else (INOVASDK_INCLUDE_DIR AND INOVASDK_LIBRARIES) find_path(INOVASDK_INCLUDE_DIR inovasdk.h PATH_SUFFIXES inovasdk ${_obIncDir} ${GNUWIN32_DIR}/include ) find_library(INOVASDK_LIBRARIES NAMES inovasdk PATHS ${_obLinkDir} ${GNUWIN32_DIR}/lib ) if(INOVASDK_INCLUDE_DIR AND INOVASDK_LIBRARIES) set(INOVASDK_FOUND TRUE) else (INOVASDK_INCLUDE_DIR AND INOVASDK_LIBRARIES) set(INOVASDK_FOUND FALSE) endif(INOVASDK_INCLUDE_DIR AND INOVASDK_LIBRARIES) if (INOVASDK_FOUND) if (NOT INOVASDK_FIND_QUIETLY) message(STATUS "Found INOVASDK: ${INOVASDK_LIBRARIES}") endif (NOT INOVASDK_FIND_QUIETLY) else (INOVASDK_FOUND) if (INOVASDK_FIND_REQUIRED) message(FATAL_ERROR "INOVASDK not found. Please install INOVASDK Library http://www.indilib.org") endif (INOVASDK_FIND_REQUIRED) endif (INOVASDK_FOUND) mark_as_advanced(INOVASDK_INCLUDE_DIR INOVASDK_LIBRARIES) endif (INOVASDK_INCLUDE_DIR AND INOVASDK_LIBRARIES) libfishcamp-1.2+20220607003151/cmake_modules/FindQHY.cmake0000644000175100017510000000242614174600255021521 0ustar debiandebian# - Try to find QHY Library # Once done this will define # # QHY_FOUND - system has QHY # QHY_INCLUDE_DIR - the QHY include directory # QHY_LIBRARIES - Link these to use QHY # Redistribution and use is allowed according to the terms of the BSD license. # For details see the accompanying COPYING-CMAKE-SCRIPTS file. if (QHY_INCLUDE_DIR AND QHY_LIBRARIES) # in cache already set(QHY_FOUND TRUE) message(STATUS "Found libqhyccd: ${QHY_LIBRARIES}") else (QHY_INCLUDE_DIR AND QHY_LIBRARIES) find_path(QHY_INCLUDE_DIR qhyccd.h PATH_SUFFIXES libqhy ${_obIncDir} ${GNUWIN32_DIR}/include ) find_library(QHY_LIBRARIES NAMES qhyccd PATHS ${_obLinkDir} ${GNUWIN32_DIR}/lib ) if(QHY_INCLUDE_DIR AND QHY_LIBRARIES) set(QHY_FOUND TRUE) else (QHY_INCLUDE_DIR AND QHY_LIBRARIES) set(QHY_FOUND FALSE) endif(QHY_INCLUDE_DIR AND QHY_LIBRARIES) if (QHY_FOUND) if (NOT QHY_FIND_QUIETLY) message(STATUS "Found QHY: ${QHY_LIBRARIES}") endif (NOT QHY_FIND_QUIETLY) else (QHY_FOUND) if (QHY_FIND_REQUIRED) message(FATAL_ERROR "QHY not found. Please install libqhy http://www.indilib.org") endif (QHY_FIND_REQUIRED) endif (QHY_FOUND) mark_as_advanced(QHY_INCLUDE_DIR QHY_LIBRARIES) endif (QHY_INCLUDE_DIR AND QHY_LIBRARIES) libfishcamp-1.2+20220607003151/cmake_modules/FindPENTAX.cmake0000644000175100017510000000553014174600255022056 0ustar debiandebian# - Try to find PENTAX Universal Libraries # Once done this will define # # PENTAX_FOUND - system has PENTAX # PENTAX_INCLUDE_DIR - the PENTAX include directory # PENTAX_LIBRARIES - Link these to use PENTAX # Redistribution and use is allowed according to the terms of the BSD license. # For details see the accompanying COPYING-CMAKE-SCRIPTS file. if (PENTAX_INCLUDE_DIR AND PENTAX_LIBRARIES) # in cache already set(PENTAX_FOUND TRUE) message(STATUS "Found PENTAX libraries: ${PENTAX_LIBRARIES}") else (PENTAX_INCLUDE_DIR AND PENTAX_LIBRARIES) find_path(PKTRIGGERCORD_INCLUDE_DIR libpktriggercord.h PATH_SUFFIXES libpktriggercord ${_obIncDir} ${GNUWIN32_DIR}/include ) find_library(PKTRIGGERCORD_LIBRARIES NAMES pktriggercord PATHS ${_obLinkDir} ${GNUWIN32_DIR}/lib PATH_SUFFIXES indipentax ) #if not armv8, then look for ricoh library; otherwise only use pktriggercord library if(NOT (${CMAKE_SYSTEM_PROCESSOR} MATCHES "^aarch64")) find_path(RICOH_INCLUDE_DIR ricoh_camera_sdk.hpp PATH_SUFFIXES libpentax libricohcamerasdk ${_obIncDir} ${GNUWIN32_DIR}/include ) find_library(RICOH_LIBRARIES NAMES RicohCameraSDKCpp PATHS ${_obLinkDir} ${GNUWIN32_DIR}/lib ) find_library(RICOHMTP_LIBRARIES NAMES libmtpricoh.so.9.3.0 PATHS ${_obLinkDir} ${GNUWIN32_DIR}/lib ) if (RICOH_INCLUDE_DIR AND PKTRIGGERCORD_INCLUDE_DIR) set(PENTAX_INCLUDE_DIR ${RICOH_INCLUDE_DIR} ${PKTRIGGERCORD_INCLUDE_DIR}) endif (RICOH_INCLUDE_DIR AND PKTRIGGERCORD_INCLUDE_DIR) if (RICOH_LIBRARIES AND RICOHMTP_LIBRARIES AND PKTRIGGERCORD_LIBRARIES) set(PENTAX_LIBRARIES ${RICOH_LIBRARIES} ${RICOHMTP_LIBRARIES} ${PKTRIGGERCORD_LIBRARIES}) endif (RICOH_LIBRARIES AND RICOHMTP_LIBRARIES AND PKTRIGGERCORD_LIBRARIES) else() if (PKTRIGGERCORD_INCLUDE_DIR) set(PENTAX_INCLUDE_DIR ${PKTRIGGERCORD_INCLUDE_DIR}) endif (PKTRIGGERCORD_INCLUDE_DIR) if (PKTRIGGERCORD_LIBRARIES) set(PENTAX_LIBRARIES ${PKTRIGGERCORD_LIBRARIES}) endif (PKTRIGGERCORD_LIBRARIES) endif() if(PENTAX_INCLUDE_DIR AND PENTAX_LIBRARIES) set(PENTAX_FOUND TRUE) else (PENTAX_INCLUDE_DIR AND PENTAX_LIBRARIES) set(PENTAX_FOUND FALSE) endif(PENTAX_INCLUDE_DIR AND PENTAX_LIBRARIES) if (PENTAX_FOUND) if (NOT PENTAX_FIND_QUIETLY) message(STATUS "Found PENTAX libraries: ${PENTAX_LIBRARIES}") endif (NOT PENTAX_FIND_QUIETLY) else (PENTAX_FOUND) if (PENTAX_FIND_REQUIRED) message(FATAL_ERROR "One or both of libricohcamersdk and libpktriggercord are not found. Please install them. See http://www.indilib.org.") endif (PENTAX_FIND_REQUIRED) endif (PENTAX_FOUND) mark_as_advanced(PENTAX_INCLUDE_DIR PENTAX_LIBRARIES) endif (PENTAX_INCLUDE_DIR AND PENTAX_LIBRARIES) libfishcamp-1.2+20220607003151/cmake_modules/FindGLIB2.cmake0000644000175100017510000001327114174600255021657 0ustar debiandebian# - Try to find GLib2 # Once done this will define # # GLIB2_FOUND - system has GLib2 # GLIB2_INCLUDE_DIRS - the GLib2 include directory # GLIB2_LIBRARIES - Link these to use GLib2 # # HAVE_GLIB_GREGEX_H glib has gregex.h header and # supports g_regex_match_simple # # Copyright (c) 2006 Andreas Schneider # Copyright (c) 2006 Philippe Bernery # Copyright (c) 2007 Daniel Gollub # Copyright (c) 2007 Alban Browaeys # Copyright (c) 2008 Michael Bell # Copyright (c) 2008 Bjoern Ricks # # Redistribution and use is allowed according to the terms of the New # BSD license. # For details see the accompanying COPYING-CMAKE-SCRIPTS file. # IF (GLIB2_LIBRARIES AND GLIB2_INCLUDE_DIRS ) # in cache already SET(GLIB2_FOUND TRUE) ELSE (GLIB2_LIBRARIES AND GLIB2_INCLUDE_DIRS ) INCLUDE(FindPkgConfig) ## Glib IF ( GLIB2_FIND_REQUIRED ) SET( _pkgconfig_REQUIRED "REQUIRED" ) ELSE ( GLIB2_FIND_REQUIRED ) SET( _pkgconfig_REQUIRED "" ) ENDIF ( GLIB2_FIND_REQUIRED ) IF ( GLIB2_MIN_VERSION ) PKG_SEARCH_MODULE( GLIB2 ${_pkgconfig_REQUIRED} glib-2.0>=${GLIB2_MIN_VERSION} ) ELSE ( GLIB2_MIN_VERSION ) PKG_SEARCH_MODULE( GLIB2 ${_pkgconfig_REQUIRED} glib-2.0 ) ENDIF ( GLIB2_MIN_VERSION ) IF ( PKG_CONFIG_FOUND ) IF ( GLIB2_FOUND ) SET ( GLIB2_CORE_FOUND TRUE ) ELSE ( GLIB2_FOUND ) SET ( GLIB2_CORE_FOUND FALSE ) ENDIF ( GLIB2_FOUND ) ENDIF ( PKG_CONFIG_FOUND ) # Look for glib2 include dir and libraries w/o pkgconfig IF ( NOT GLIB2_FOUND AND NOT PKG_CONFIG_FOUND ) FIND_PATH( _glibconfig_include_DIR NAMES glibconfig.h PATHS /opt/gnome/lib64 /opt/gnome/lib /opt/lib/ /opt/local/lib /sw/lib/ /usr/lib64 /usr/lib /usr/local/include ${CMAKE_LIBRARY_PATH} PATH_SUFFIXES glib-2.0/include ) FIND_PATH( _glib2_include_DIR NAMES glib.h PATHS /opt/gnome/include /opt/local/include /sw/include /usr/include /usr/local/include PATH_SUFFIXES glib-2.0 ) #MESSAGE(STATUS "Glib headers: ${_glib2_include_DIR}") FIND_LIBRARY( _glib2_link_DIR NAMES glib-2.0 glib PATHS /opt/gnome/lib /opt/local/lib /sw/lib /usr/lib /usr/local/lib ) IF ( _glib2_include_DIR AND _glib2_link_DIR ) SET ( _glib2_FOUND TRUE ) ENDIF ( _glib2_include_DIR AND _glib2_link_DIR ) IF ( _glib2_FOUND ) SET ( GLIB2_INCLUDE_DIRS ${_glib2_include_DIR} ${_glibconfig_include_DIR} ) SET ( GLIB2_LIBRARIES ${_glib2_link_DIR} ) SET ( GLIB2_CORE_FOUND TRUE ) ELSE ( _glib2_FOUND ) SET ( GLIB2_CORE_FOUND FALSE ) ENDIF ( _glib2_FOUND ) # Handle dependencies # libintl IF ( NOT LIBINTL_FOUND ) FIND_PATH(LIBINTL_INCLUDE_DIR NAMES libintl.h PATHS /opt/gnome/include /opt/local/include /sw/include /usr/include /usr/local/include ) FIND_LIBRARY(LIBINTL_LIBRARY NAMES intl PATHS /opt/gnome/lib /opt/local/lib /sw/lib /usr/local/lib /usr/lib ) IF (LIBINTL_LIBRARY AND LIBINTL_INCLUDE_DIR) SET (LIBINTL_FOUND TRUE) ENDIF (LIBINTL_LIBRARY AND LIBINTL_INCLUDE_DIR) ENDIF ( NOT LIBINTL_FOUND ) # libiconv IF ( NOT LIBICONV_FOUND ) FIND_PATH(LIBICONV_INCLUDE_DIR NAMES iconv.h PATHS /opt/gnome/include /opt/local/include /opt/local/include /sw/include /sw/include /usr/local/include /usr/include PATH_SUFFIXES glib-2.0 ) FIND_LIBRARY(LIBICONV_LIBRARY NAMES iconv PATHS /opt/gnome/lib /opt/local/lib /sw/lib /usr/lib /usr/local/lib ) IF (LIBICONV_LIBRARY AND LIBICONV_INCLUDE_DIR) SET (LIBICONV_FOUND TRUE) ENDIF (LIBICONV_LIBRARY AND LIBICONV_INCLUDE_DIR) ENDIF ( NOT LIBICONV_FOUND ) IF (LIBINTL_FOUND) SET (GLIB2_LIBRARIES ${GLIB2_LIBRARIES} ${LIBINTL_LIBRARY}) SET (GLIB2_INCLUDE_DIRS ${GLIB2_INCLUDE_DIRS} ${LIBINTL_INCLUDE_DIR}) ENDIF (LIBINTL_FOUND) IF (LIBICONV_FOUND) SET (GLIB2_LIBRARIES ${GLIB2_LIBRARIES} ${LIBICONV_LIBRARY}) SET (GLIB2_INCLUDE_DIRS ${GLIB2_INCLUDE_DIRS} ${LIBICONV_INCLUDE_DIR}) ENDIF (LIBICONV_FOUND) ENDIF ( NOT GLIB2_FOUND AND NOT PKG_CONFIG_FOUND ) ## IF (GLIB2_CORE_FOUND AND GLIB2_INCLUDE_DIRS AND GLIB2_LIBRARIES) SET (GLIB2_FOUND TRUE) ENDIF (GLIB2_CORE_FOUND AND GLIB2_INCLUDE_DIRS AND GLIB2_LIBRARIES) IF (GLIB2_FOUND) IF (NOT GLIB2_FIND_QUIETLY) MESSAGE (STATUS "Found GLib2: ${GLIB2_LIBRARIES} ${GLIB2_INCLUDE_DIRS}") ENDIF (NOT GLIB2_FIND_QUIETLY) ELSE (GLIB2_FOUND) IF (GLIB2_FIND_REQUIRED) MESSAGE (SEND_ERROR "Could not find GLib2") ENDIF (GLIB2_FIND_REQUIRED) ENDIF (GLIB2_FOUND) # show the GLIB2_INCLUDE_DIRS and GLIB2_LIBRARIES variables only in the advanced view MARK_AS_ADVANCED(GLIB2_INCLUDE_DIRS GLIB2_LIBRARIES) MARK_AS_ADVANCED(LIBICONV_INCLUDE_DIR LIBICONV_LIBRARY) MARK_AS_ADVANCED(LIBINTL_INCLUDE_DIR LIBINTL_LIBRARY) ENDIF (GLIB2_LIBRARIES AND GLIB2_INCLUDE_DIRS) IF ( GLIB2_FOUND ) # Check if system has a newer version of glib # which supports g_regex_match_simple INCLUDE( CheckIncludeFiles ) SET( CMAKE_REQUIRED_INCLUDES ${GLIB2_INCLUDE_DIRS} ) CHECK_INCLUDE_FILES ( glib/gregex.h HAVE_GLIB_GREGEX_H ) # Reset CMAKE_REQUIRED_INCLUDES SET( CMAKE_REQUIRED_INCLUDES "" ) ENDIF( GLIB2_FOUND ) libfishcamp-1.2+20220607003151/cmake_modules/FindATIK.cmake0000644000175100017510000000254014174600255021605 0ustar debiandebian# - Try to find Atik Camera Library # Once done this will define # # ATIK_FOUND - system has ATIK # ATIK_INCLUDE_DIR - the ATIK include directory # ATIK_LIBRARIES - Link these to use ATIK # Redistribution and use is allowed according to the terms of the BSD license. # For details see the accompanying COPYING-CMAKE-SCRIPTS file. if (ATIK_INCLUDE_DIR AND ATIK_LIBRARIES) # in cache already set(ATIK_FOUND TRUE) message(STATUS "Found libatik: ${ATIK_LIBRARIES}") else (ATIK_INCLUDE_DIR AND ATIK_LIBRARIES) find_path(ATIK_INCLUDE_DIR AtikCameras.h PATH_SUFFIXES libatik ${_obIncDir} ${GNUWIN32_DIR}/include ) find_library(ATIK_LIBRARIES NAMES atikcameras PATHS ${_obLinkDir} ${GNUWIN32_DIR}/lib ) if(ATIK_INCLUDE_DIR AND ATIK_LIBRARIES) set(ATIK_FOUND TRUE) else (ATIK_INCLUDE_DIR AND ATIK_LIBRARIES) set(ATIK_FOUND FALSE) endif(ATIK_INCLUDE_DIR AND ATIK_LIBRARIES) if (ATIK_FOUND) if (NOT ATIK_FIND_QUIETLY) message(STATUS "Found Atik Library: ${ATIK_LIBRARIES}") endif (NOT ATIK_FIND_QUIETLY) else (ATIK_FOUND) if (ATIK_FIND_REQUIRED) message(FATAL_ERROR "Atik Library not found. Please install Atik Library http://www.indilib.org") endif (ATIK_FIND_REQUIRED) endif (ATIK_FOUND) mark_as_advanced(ATIK_INCLUDE_DIR ATIK_LIBRARIES) endif (ATIK_INCLUDE_DIR AND ATIK_LIBRARIES) libfishcamp-1.2+20220607003151/cmake_modules/FindALUT.cmake0000644000175100017510000000504214174600255021622 0ustar debiandebian# - Locate ALUT # This module defines # ALUT_LIBRARY # ALUT_FOUND, if false, do not try to link to OpenAL # ALUT_INCLUDE_DIR, where to find the headers # # $OPENALDIR is an environment variable that would # correspond to the ./configure --prefix=$OPENALDIR # used in building OpenAL. # # Created by Bryan Donlan, based on the FindOpenAL.cmake module by Eric Wang. FIND_PATH(ALUT_INCLUDE_DIR alut.h $ENV{OPENALDIR}/include ~/Library/Frameworks/OpenAL.framework/Headers /Library/Frameworks/OpenAL.framework/Headers /System/Library/Frameworks/OpenAL.framework/Headers # Tiger /usr/local/include/AL /usr/local/include/OpenAL /usr/local/include /usr/include/AL /usr/include/OpenAL /usr/include /sw/include/AL # Fink /sw/include/OpenAL /sw/include /opt/local/include/AL # DarwinPorts /opt/local/include/OpenAL /opt/local/include /opt/csw/include/AL # Blastwave /opt/csw/include/OpenAL /opt/csw/include /opt/include/AL /opt/include/OpenAL /opt/include ) # I'm not sure if I should do a special casing for Apple. It is # unlikely that other Unix systems will find the framework path. # But if they do ([Next|Open|GNU]Step?), # do they want the -framework option also? IF(${ALUT_INCLUDE_DIR} MATCHES ".framework") STRING(REGEX REPLACE "(.*)/.*\\.framework/.*" "\\1" ALUT_FRAMEWORK_PATH_TMP ${ALUT_INCLUDE_DIR}) IF("${ALUT_FRAMEWORK_PATH_TMP}" STREQUAL "/Library/Frameworks" OR "${ALUT_FRAMEWORK_PATH_TMP}" STREQUAL "/System/Library/Frameworks" ) # String is in default search path, don't need to use -F SET (ALUT_LIBRARY "-framework OpenAL" CACHE STRING "OpenAL framework for OSX") ELSE("${ALUT_FRAMEWORK_PATH_TMP}" STREQUAL "/Library/Frameworks" OR "${ALUT_FRAMEWORK_PATH_TMP}" STREQUAL "/System/Library/Frameworks" ) # String is not /Library/Frameworks, need to use -F SET(ALUT_LIBRARY "-F${ALUT_FRAMEWORK_PATH_TMP} -framework OpenAL" CACHE STRING "OpenAL framework for OSX") ENDIF("${ALUT_FRAMEWORK_PATH_TMP}" STREQUAL "/Library/Frameworks" OR "${ALUT_FRAMEWORK_PATH_TMP}" STREQUAL "/System/Library/Frameworks" ) # Clear the temp variable so nobody can see it SET(ALUT_FRAMEWORK_PATH_TMP "" CACHE INTERNAL "") ELSE(${ALUT_INCLUDE_DIR} MATCHES ".framework") FIND_LIBRARY(ALUT_LIBRARY NAMES alut PATHS $ENV{OPENALDIR}/lib $ENV{OPENALDIR}/libs /usr/local/lib /usr/lib /sw/lib /opt/local/lib /opt/csw/lib /opt/lib ) ENDIF(${ALUT_INCLUDE_DIR} MATCHES ".framework") SET(ALUT_FOUND "NO") IF(ALUT_LIBRARY) SET(ALUT_FOUND "YES") ENDIF(ALUT_LIBRARY) libfishcamp-1.2+20220607003151/cmake_modules/FindD2XX.cmake0000644000175100017510000000262014174600255021601 0ustar debiandebian# - Try to find D2XX # Once done this will define # # D2XX_FOUND - system has FTDI # D2XX_INCLUDE_DIR - the FTDI include directory # D2XX_LIBRARIES - Link these to use FTDI # # N.B. You must include the file as following: # #include # # Redistribution and use is allowed according to the terms of the BSD license. # For details see the accompanying COPYING-CMAKE-SCRIPTS file. if (D2XX_INCLUDE_DIR AND D2XX_LIBRARIES) # in cache already set(D2XX_FOUND TRUE) message(STATUS "Found libfd2xx: ${D2XX_LIBRARIES}") else (D2XX_INCLUDE_DIR AND D2XX_LIBRARIES) find_path(D2XX_INCLUDE_DIR ftd2xx.h #PATH_SUFFIXES libD2XX ${_obIncDir} ${GNUWIN32_DIR}/include /usr/local/include ) find_library(D2XX_LIBRARIES NAMES ftd2xx PATHS ${_obLinkDir} ${GNUWIN32_DIR}/lib /usr/local/lib ) if(D2XX_INCLUDE_DIR AND D2XX_LIBRARIES) set(D2XX_FOUND TRUE) else (D2XX_INCLUDE_DIR AND D2XX_LIBRARIES) set(D2XX_FOUND FALSE) endif(D2XX_INCLUDE_DIR AND D2XX_LIBRARIES) if (D2XX_FOUND) if (NOT D2XX_FIND_QUIETLY) message(STATUS "Found D2XX: ${D2XX_LIBRARIES}") endif (NOT D2XX_FIND_QUIETLY) else (D2XX_FOUND) if (D2XX_FIND_REQUIRED) message(FATAL_ERROR "D2XX not found. Please install libd2xx") endif (D2XX_FIND_REQUIRED) endif (D2XX_FOUND) mark_as_advanced(D2XX_INCLUDE_DIR D2XX_LIBRARIES) endif (D2XX_INCLUDE_DIR AND D2XX_LIBRARIES) libfishcamp-1.2+20220607003151/cmake_modules/FindARAVIS.cmake0000644000175100017510000000272314174600255022045 0ustar debiandebian# - Find the native sqlite3 includes and library # # This module defines # ARV_INCLUDE_DIR, where to find libgphoto2 header files # ARV_LIBRARIES, the libraries to link against to use libgphoto2 # ARV_FOUND, If false, do not try to use libgphoto2. # ARV_VERSION_STRING, e.g. 2.4.14 # ARV_VERSION_MAJOR, e.g. 2 # ARV_VERSION_MINOR, e.g. 4 # ARV_VERSION_PATCH, e.g. 14 # # also defined, but not for general use are # ARV_LIBRARY, where to find the sqlite3 library. #============================================================================= # Copyright 2010 henrik andersson #============================================================================= SET(ARV_FIND_REQUIRED ${Arv_FIND_REQUIRED}) find_path(ARV_INCLUDE_DIR aravis-0.8/arv.h) mark_as_advanced(ARV_INCLUDE_DIR) set(ARV_NAMES ${ARV_NAMES} aravis-0.8) find_library(ARV_LIBRARY NAMES ${ARV_NAMES} ) mark_as_advanced(ARV_LIBRARY) set(ARV_VERSION_MAJOR "0") set(ARV_VERSION_MINOR "8") set(ARV_VERSION_STRING "${ARV_VERSION_MAJOR}.${ARV_VERSION_MINOR}") # handle the QUIETLY and REQUIRED arguments and set ARV_FOUND to TRUE if # all listed variables are TRUE include(FindPackageHandleStandardArgs) find_package_handle_standard_args(ARV DEFAULT_MSG ARV_LIBRARY ARV_INCLUDE_DIR) IF(ARV_FOUND) #SET(Arv_LIBRARIES ${ARV_LIBRARY}) SET(Arv_LIBRARIES "aravis-0.8") SET(Arv_INCLUDE_DIRS "${ARV_INCLUDE_DIR}/aravis-0.8") MESSAGE (STATUS "Found aravis: ${Arv_LIBRARIES} ${Arv_INCLUDE_DIRS}") ENDIF(ARV_FOUND) libfishcamp-1.2+20220607003151/cmake_modules/FindFISHCAMP.cmake0000644000175100017510000000322514174600255022250 0ustar debiandebian# - Try to find FISHCAMP CCD # Once done this will define # # FISHCAMP_FOUND - system has FISHCAMP # FISHCAMP_LIBRARIES - Link these to use FISHCAMP # FISHCAMP_INCLUDE_DIR - Fishcamp include directory # Copyright (c) 2006, Jasem Mutlaq # Based on FindLibfacile by Carsten Niehaus, # # Redistribution and use is allowed according to the terms of the BSD license. # For details see the accompanying COPYING-CMAKE-SCRIPTS file. if (FISHCAMP_LIBRARIES AND FISHCAMP_INCLUDE_DIR) # in cache already set(FISHCAMP_FOUND TRUE) message(STATUS "Found FISHCAMP: ${FISHCAMP_LIBRARIES}") else (FISHCAMP_LIBRARIES AND FISHCAMP_INCLUDE_DIR) find_library(FISHCAMP_LIBRARIES NAMES fishcamp PATHS ${_obLinkDir} ${GNUWIN32_DIR}/lib ) find_path(FISHCAMP_INCLUDE_DIR fishcamp.h PATH_SUFFIXES libfishcamp ${_obIncDir} ${GNUWIN32_DIR}/include ) set(CMAKE_REQUIRED_LIBRARIES ${FISHCAMP_LIBRARIES}) if(FISHCAMP_LIBRARIES AND FISHCAMP_INCLUDE_DIR) set(FISHCAMP_FOUND TRUE) else (FISHCAMP_LIBRARIES AND FISHCAMP_INCLUDE_DIR) set(FISHCAMP_FOUND FALSE) endif(FISHCAMP_LIBRARIES AND FISHCAMP_INCLUDE_DIR) if (FISHCAMP_FOUND) if (NOT FISHCAMP_FIND_QUIETLY) message(STATUS "Found FISHCAMP: ${FISHCAMP_LIBRARIES}") endif (NOT FISHCAMP_FIND_QUIETLY) else (FISHCAMP_FOUND) if (FISHCAMP_FIND_REQUIRED) message(FATAL_ERROR "FISHCAMP not found. Please install FISHCAMP library. http://www.indilib.org") endif (FISHCAMP_FIND_REQUIRED) endif (FISHCAMP_FOUND) mark_as_advanced(FISHCAMP_LIBRARIES FISHCAMP_INCLUDE_DIR) endif (FISHCAMP_LIBRARIES AND FISHCAMP_INCLUDE_DIR) libfishcamp-1.2+20220607003151/cmake_modules/FindDC1394.cmake0000644000175100017510000000264314174600255021670 0ustar debiandebian# - Try to find dc1394 library (version 2) and include files # Once done this will define # # DC1394_FOUND - system has DC1394 # DC1394_INCLUDE_DIR - the DC1394 include directory # DC1394_LIBRARIES - Link these to use DC1394 # Redistribution and use is allowed according to the terms of the BSD license. # For details see the accompanying COPYING-CMAKE-SCRIPTS file. if (DC1394_INCLUDE_DIR AND DC1394_LIBRARIES) # in cache already set(DC1394_FOUND TRUE) message(STATUS "Found libdc1394: ${DC1394_LIBRARIES}") else (DC1394_INCLUDE_DIR AND DC1394_LIBRARIES) find_path(DC1394_INCLUDE_DIR control.h PATH_SUFFIXES dc1394 ${_obIncDir} ${GNUWIN32_DIR}/include ) find_library(DC1394_LIBRARIES NAMES dc1394 PATHS ${_obLinkDir} ${GNUWIN32_DIR}/lib ) if(DC1394_INCLUDE_DIR AND DC1394_LIBRARIES) set(DC1394_FOUND TRUE) else (DC1394_INCLUDE_DIR AND DC1394_LIBRARIES) set(DC1394_FOUND FALSE) endif(DC1394_INCLUDE_DIR AND DC1394_LIBRARIES) if (DC1394_FOUND) if (NOT DC1394_FIND_QUIETLY) message(STATUS "Found DC1394: ${DC1394_LIBRARIES}") endif (NOT DC1394_FIND_QUIETLY) else (DC1394_FOUND) if (DC1394_FIND_REQUIRED) message(FATAL_ERROR "DC1394 not found. Please install libdc1394 development package.") endif (DC1394_FIND_REQUIRED) endif (DC1394_FOUND) mark_as_advanced(DC1394_INCLUDE_DIR DC1394_LIBRARIES) endif (DC1394_INCLUDE_DIR AND DC1394_LIBRARIES) libfishcamp-1.2+20220607003151/cmake_modules/FindTIFFXX.cmake0000644000175100017510000000176314174600255022073 0ustar debiandebian# - Try to find TIFFXX Library # Once done this will define # # TIFXX_LIBRARY - Link these to use TIFFXX # Redistribution and use is allowed according to the terms of the BSD license. # For details see the accompanying COPYING-CMAKE-SCRIPTS file. if (TIFFXX_LIBRARY) # in cache already set(TIFFXX_FOUND TRUE) message(STATUS "Found libtiffxx: ${TIFFXX_LIBRARY}") else (TIFFXX_LIBRARY) find_library(TIFFXX_LIBRARY NAMES tiffxx PATHS ${_obLinkDir} ${GNUWIN32_DIR}/lib ) if(TIFFXX_LIBRARY) set(TIFFXX_FOUND TRUE) else (TIFFXX_LIBRARY) set(TIFFXX_FOUND FALSE) endif(TIFFXX_LIBRARY) if (TIFFXX_FOUND) if (NOT TIFFXX_FIND_QUIETLY) message(STATUS "Found tiffxx: ${TIFFXX_LIBRARY}") endif (NOT TIFFXX_FIND_QUIETLY) else (TIFFXX_FOUND) if (TIFFXX_FIND_REQUIRED) message(FATAL_ERROR "tiffxx is not found. Please install it first.") endif (TIFFXX_FIND_REQUIRED) endif (TIFFXX_FOUND) mark_as_advanced(TIFFXX_LIBRARY) endif (TIFFXX_LIBRARY) libfishcamp-1.2+20220607003151/cmake_modules/FindGSL.cmake0000644000175100017510000002224114174600255021502 0ustar debiandebian#.rst: # FindGSL # -------- # # Find the native GSL includes and libraries. # # The GNU Scientific Library (GSL) is a numerical library for C and C++ # programmers. It is free software under the GNU General Public # License. # # Imported Targets # ^^^^^^^^^^^^^^^^ # # If GSL is found, this module defines the following :prop_tgt:`IMPORTED` # targets:: # # GSL::gsl - The main GSL library. # GSL::gslcblas - The CBLAS support library used by GSL. # # Result Variables # ^^^^^^^^^^^^^^^^ # # This module will set the following variables in your project:: # # GSL_FOUND - True if GSL found on the local system # GSL_INCLUDE_DIRS - Location of GSL header files. # GSL_LIBRARIES - The GSL libraries. # GSL_VERSION - The version of the discovered GSL install. # # Hints # ^^^^^ # # Set ``GSL_ROOT_DIR`` to a directory that contains a GSL installation. # # This script expects to find libraries at ``$GSL_ROOT_DIR/lib`` and the GSL # headers at ``$GSL_ROOT_DIR/include/gsl``. The library directory may # optionally provide Release and Debug folders. For Unix-like systems, this # script will use ``$GSL_ROOT_DIR/bin/gsl-config`` (if found) to aid in the # discovery GSL. # # Cache Variables # ^^^^^^^^^^^^^^^ # # This module may set the following variables depending on platform and type # of GSL installation discovered. These variables may optionally be set to # help this module find the correct files:: # # GSL_CLBAS_LIBRARY - Location of the GSL CBLAS library. # GSL_CBLAS_LIBRARY_DEBUG - Location of the debug GSL CBLAS library (if any). # GSL_CONFIG_EXECUTABLE - Location of the ``gsl-config`` script (if any). # GSL_LIBRARY - Location of the GSL library. # GSL_LIBRARY_DEBUG - Location of the debug GSL library (if any). # #============================================================================= # Copyright 2014 Kelly Thompson # # 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.) # Include these modules to handle the QUIETLY and REQUIRED arguments. include(${CMAKE_CURRENT_LIST_DIR}/FindPackageHandleStandardArgs.cmake) #============================================================================= # If the user has provided ``GSL_ROOT_DIR``, use it! Choose items found # at this location over system locations. if( EXISTS "$ENV{GSL_ROOT_DIR}" ) file( TO_CMAKE_PATH "$ENV{GSL_ROOT_DIR}" GSL_ROOT_DIR ) set( GSL_ROOT_DIR "${GSL_ROOT_DIR}" CACHE PATH "Prefix for GSL installation." ) endif() if( NOT EXISTS "${GSL_ROOT_DIR}" ) set( GSL_USE_PKGCONFIG ON ) endif() #============================================================================= # As a first try, use the PkgConfig module. This will work on many # *NIX systems. See :module:`findpkgconfig` # This will return ``GSL_INCLUDEDIR`` and ``GSL_LIBDIR`` used below. if( GSL_USE_PKGCONFIG ) find_package(PkgConfig) pkg_check_modules( GSL QUIET gsl ) if( EXISTS "${GSL_INCLUDEDIR}" ) get_filename_component( GSL_ROOT_DIR "${GSL_INCLUDEDIR}" DIRECTORY CACHE) endif() endif() #============================================================================= # Set GSL_INCLUDE_DIRS and GSL_LIBRARIES. If we skipped the PkgConfig step, try # to find the libraries at $GSL_ROOT_DIR (if provided) or in standard system # locations. These find_library and find_path calls will prefer custom # locations over standard locations (HINTS). If the requested file is not found # at the HINTS location, standard system locations will be still be searched # (/usr/lib64 (Redhat), lib/i386-linux-gnu (Debian)). find_path( GSL_INCLUDE_DIR NAMES gsl/gsl_sf.h HINTS ${GSL_ROOT_DIR}/include ${GSL_INCLUDEDIR} ) find_library( GSL_LIBRARY NAMES gsl HINTS ${GSL_ROOT_DIR}/lib ${GSL_LIBDIR} PATH_SUFFIXES Release Debug ) find_library( GSL_CBLAS_LIBRARY NAMES gslcblas cblas HINTS ${GSL_ROOT_DIR}/lib ${GSL_LIBDIR} PATH_SUFFIXES Release Debug ) # Do we also have debug versions? find_library( GSL_LIBRARY_DEBUG NAMES gsl HINTS ${GSL_ROOT_DIR}/lib ${GSL_LIBDIR} PATH_SUFFIXES Debug ) find_library( GSL_CBLAS_LIBRARY_DEBUG NAMES gslcblas cblas HINTS ${GSL_ROOT_DIR}/lib ${GSL_LIBDIR} PATH_SUFFIXES Debug ) set( GSL_INCLUDE_DIRS ${GSL_INCLUDE_DIR} ) set( GSL_LIBRARIES ${GSL_LIBRARY} ${GSL_CBLAS_LIBRARY} ) # If we didn't use PkgConfig, try to find the version via gsl-config or by # reading gsl_version.h. if( NOT GSL_VERSION ) # 1. If gsl-config exists, query for the version. find_program( GSL_CONFIG_EXECUTABLE NAMES gsl-config HINTS "${GSL_ROOT_DIR}/bin" ) if( EXISTS "${GSL_CONFIG_EXECUTABLE}" ) execute_process( COMMAND "${GSL_CONFIG_EXECUTABLE}" --version OUTPUT_VARIABLE GSL_VERSION OUTPUT_STRIP_TRAILING_WHITESPACE ) endif() # 2. If gsl-config is not available, try looking in gsl/gsl_version.h if( NOT GSL_VERSION AND EXISTS "${GSL_INCLUDE_DIRS}/gsl/gsl_version.h" ) file( STRINGS "${GSL_INCLUDE_DIRS}/gsl/gsl_version.h" gsl_version_h_contents REGEX "define GSL_VERSION" ) string( REGEX REPLACE ".*([0-9].[0-9][0-9]).*" "\\1" GSL_VERSION ${gsl_version_h_contents} ) endif() # might also try scraping the directory name for a regex match "gsl-X.X" endif() #============================================================================= # handle the QUIETLY and REQUIRED arguments and set GSL_FOUND to TRUE if all # listed variables are TRUE find_package_handle_standard_args( GSL FOUND_VAR GSL_FOUND REQUIRED_VARS GSL_INCLUDE_DIR GSL_LIBRARY GSL_CBLAS_LIBRARY VERSION_VAR GSL_VERSION ) mark_as_advanced( GSL_ROOT_DIR GSL_VERSION GSL_LIBRARY GSL_INCLUDE_DIR GSL_CBLAS_LIBRARY GSL_LIBRARY_DEBUG GSL_CBLAS_LIBRARY_DEBUG GSL_USE_PKGCONFIG GSL_CONFIG ) #============================================================================= # Register imported libraries: # 1. If we can find a Windows .dll file (or if we can find both Debug and # Release libraries), we will set appropriate target properties for these. # 2. However, for most systems, we will only register the import location and # include directory. # Look for dlls, or Release and Debug libraries. if(WIN32) string( REPLACE ".lib" ".dll" GSL_LIBRARY_DLL "${GSL_LIBRARY}" ) string( REPLACE ".lib" ".dll" GSL_CBLAS_LIBRARY_DLL "${GSL_CBLAS_LIBRARY}" ) string( REPLACE ".lib" ".dll" GSL_LIBRARY_DEBUG_DLL "${GSL_LIBRARY_DEBUG}" ) string( REPLACE ".lib" ".dll" GSL_CBLAS_LIBRARY_DEBUG_DLL "${GSL_CBLAS_LIBRARY_DEBUG}" ) endif() if( GSL_FOUND AND NOT TARGET GSL::gsl ) if( EXISTS "${GSL_LIBRARY_DLL}" AND EXISTS "${GSL_CBLAS_LIBRARY_DLL}") # Windows systems with dll libraries. add_library( GSL::gsl SHARED IMPORTED ) add_library( GSL::gslcblas SHARED IMPORTED ) # Windows with dlls, but only Release libraries. set_target_properties( GSL::gslcblas PROPERTIES IMPORTED_LOCATION_RELEASE "${GSL_CBLAS_LIBRARY_DLL}" IMPORTED_IMPLIB "${GSL_CBLAS_LIBRARY}" INTERFACE_INCLUDE_DIRECTORIES "${GSL_INCLUDE_DIRS}" IMPORTED_CONFIGURATIONS Release IMPORTED_LINK_INTERFACE_LANGUAGES "C" ) set_target_properties( GSL::gsl PROPERTIES IMPORTED_LOCATION_RELEASE "${GSL_LIBRARY_DLL}" IMPORTED_IMPLIB "${GSL_LIBRARY}" INTERFACE_INCLUDE_DIRECTORIES "${GSL_INCLUDE_DIRS}" IMPORTED_CONFIGURATIONS Release IMPORTED_LINK_INTERFACE_LANGUAGES "C" INTERFACE_LINK_LIBRARIES GSL::gslcblas ) # If we have both Debug and Release libraries if( EXISTS "${GSL_LIBRARY_DEBUG_DLL}" AND EXISTS "${GSL_CBLAS_LIBRARY_DEBUG_DLL}") set_property( TARGET GSL::gslcblas APPEND PROPERTY IMPORTED_CONFIGURATIONS Debug ) set_target_properties( GSL::gslcblas PROPERTIES IMPORTED_LOCATION_DEBUG "${GSL_CBLAS_LIBRARY_DEBUG_DLL}" IMPORTED_IMPLIB_DEBUG "${GSL_CBLAS_LIBRARY_DEBUG}" ) set_property( TARGET GSL::gsl APPEND PROPERTY IMPORTED_CONFIGURATIONS Debug ) set_target_properties( GSL::gsl PROPERTIES IMPORTED_LOCATION_DEBUG "${GSL_LIBRARY_DEBUG_DLL}" IMPORTED_IMPLIB_DEBUG "${GSL_LIBRARY_DEBUG}" ) endif() else() # For all other environments (ones without dll libraries), create # the imported library targets. add_library( GSL::gsl UNKNOWN IMPORTED ) add_library( GSL::gslcblas UNKNOWN IMPORTED ) set_target_properties( GSL::gslcblas PROPERTIES IMPORTED_LOCATION "${GSL_CBLAS_LIBRARY}" INTERFACE_INCLUDE_DIRECTORIES "${GSL_INCLUDE_DIRS}" IMPORTED_LINK_INTERFACE_LANGUAGES "C" ) set_target_properties( GSL::gsl PROPERTIES IMPORTED_LOCATION "${GSL_LIBRARY}" INTERFACE_INCLUDE_DIRECTORIES "${GSL_INCLUDE_DIRS}" IMPORTED_LINK_INTERFACE_LANGUAGES "C" INTERFACE_LINK_LIBRARIES GSL::gslcblas ) endif() endif() libfishcamp-1.2+20220607003151/cmake_modules/FindMICAM.cmake0000644000175100017510000000256714174600255021714 0ustar debiandebian# - Try to find Moravian Instruments Camera Library # Once done this will define # # MICAM_FOUND - system has MI # MICAM_INCLUDE_DIR - the MI include directory # MICAM_LIBRARIES - Link these to use MI # Redistribution and use is allowed according to the terms of the BSD license. # For details see the accompanying COPYING-CMAKE-SCRIPTS file. if (MICAM_INCLUDE_DIR AND MICAM_LIBRARIES) # in cache already set(MICAM_FOUND TRUE) message(STATUS "Found libmicam: ${MICAM_LIBRARIES}") else (MICAM_INCLUDE_DIR AND MICAM_LIBRARIES) find_path(MICAM_INCLUDE_DIR gxccd.h PATH_SUFFIXES libmicam ${_obIncDir} ${GNUWIN32_DIR}/include ) find_library(MICAM_LIBRARIES NAMES gxccd PATHS ${_obLinkDir} ${GNUWIN32_DIR}/lib ) if(MICAM_INCLUDE_DIR AND MICAM_LIBRARIES) set(MICAM_FOUND TRUE) else (MICAM_INCLUDE_DIR AND MICAM_LIBRARIES) set(MICAM_FOUND FALSE) endif(MICAM_INCLUDE_DIR AND MICAM_LIBRARIES) if (MICAM_FOUND) if (NOT MICAM_FIND_QUIETLY) message(STATUS "Found MI Library: ${MICAM_LIBRARIES}") endif (NOT MICAM_FIND_QUIETLY) else (MICAM_FOUND) if (MICAM_FIND_REQUIRED) message(FATAL_ERROR "MI Library not found. Please install MI Library http://www.indilib.org") endif (MICAM_FIND_REQUIRED) endif (MICAM_FOUND) mark_as_advanced(MICAM_INCLUDE_DIR MICAM_LIBRARIES) endif (MICAM_INCLUDE_DIR AND MICAM_LIBRARIES) libfishcamp-1.2+20220607003151/cmake_modules/FindPackageHandleStandardArgs.cmake0000644000175100017510000003565714174600255026041 0ustar debiandebian#[=======================================================================[.rst: FindPackageHandleStandardArgs ----------------------------- This module provides a function intended to be used in :ref:`Find Modules` implementing :command:`find_package()` calls. It handles the ``REQUIRED``, ``QUIET`` and version-related arguments of ``find_package``. It also sets the ``_FOUND`` variable. The package is considered found if all variables listed contain valid results, e.g. valid filepaths. .. command:: find_package_handle_standard_args There are two signatures:: find_package_handle_standard_args( (DEFAULT_MSG|) ... ) find_package_handle_standard_args( [FOUND_VAR ] [REQUIRED_VARS ...] [VERSION_VAR ] [HANDLE_COMPONENTS] [CONFIG_MODE] [FAIL_MESSAGE ] ) The ``_FOUND`` variable will be set to ``TRUE`` if all the variables ``...`` are valid and any optional constraints are satisfied, and ``FALSE`` otherwise. A success or failure message may be displayed based on the results and on whether the ``REQUIRED`` and/or ``QUIET`` option was given to the :command:`find_package` call. The options are: ``(DEFAULT_MSG|)`` In the simple signature this specifies the failure message. Use ``DEFAULT_MSG`` to ask for a default message to be computed (recommended). Not valid in the full signature. ``FOUND_VAR `` Obsolete. Specifies either ``_FOUND`` or ``_FOUND`` as the result variable. This exists only for compatibility with older versions of CMake and is now ignored. Result variables of both names are always set for compatibility. ``REQUIRED_VARS ...`` Specify the variables which are required for this package. These may be named in the generated failure message asking the user to set the missing variable values. Therefore these should typically be cache entries such as ``FOO_LIBRARY`` and not output variables like ``FOO_LIBRARIES``. ``VERSION_VAR `` Specify the name of a variable that holds the version of the package that has been found. This version will be checked against the (potentially) specified required version given to the :command:`find_package` call, including its ``EXACT`` option. The default messages include information about the required version and the version which has been actually found, both if the version is ok or not. ``HANDLE_COMPONENTS`` Enable handling of package components. In this case, the command will report which components have been found and which are missing, and the ``_FOUND`` variable will be set to ``FALSE`` if any of the required components (i.e. not the ones listed after the ``OPTIONAL_COMPONENTS`` option of :command:`find_package`) are missing. ``CONFIG_MODE`` Specify that the calling find module is a wrapper around a call to ``find_package( NO_MODULE)``. This implies a ``VERSION_VAR`` value of ``_VERSION``. The command will automatically check whether the package configuration file was found. ``FAIL_MESSAGE `` Specify a custom failure message instead of using the default generated message. Not recommended. Example for the simple signature: .. code-block:: cmake find_package_handle_standard_args(LibXml2 DEFAULT_MSG LIBXML2_LIBRARY LIBXML2_INCLUDE_DIR) The ``LibXml2`` package is considered to be found if both ``LIBXML2_LIBRARY`` and ``LIBXML2_INCLUDE_DIR`` are valid. Then also ``LibXml2_FOUND`` is set to ``TRUE``. If it is not found and ``REQUIRED`` was used, it fails with a :command:`message(FATAL_ERROR)`, independent whether ``QUIET`` was used or not. If it is found, success will be reported, including the content of the first ````. On repeated CMake runs, the same message will not be printed again. Example for the full signature: .. code-block:: cmake find_package_handle_standard_args(LibArchive REQUIRED_VARS LibArchive_LIBRARY LibArchive_INCLUDE_DIR VERSION_VAR LibArchive_VERSION) In this case, the ``LibArchive`` package is considered to be found if both ``LibArchive_LIBRARY`` and ``LibArchive_INCLUDE_DIR`` are valid. Also the version of ``LibArchive`` will be checked by using the version contained in ``LibArchive_VERSION``. Since no ``FAIL_MESSAGE`` is given, the default messages will be printed. Another example for the full signature: .. code-block:: cmake find_package(Automoc4 QUIET NO_MODULE HINTS /opt/automoc4) find_package_handle_standard_args(Automoc4 CONFIG_MODE) In this case, a ``FindAutmoc4.cmake`` module wraps a call to ``find_package(Automoc4 NO_MODULE)`` and adds an additional search directory for ``automoc4``. Then the call to ``find_package_handle_standard_args`` produces a proper success/failure message. #]=======================================================================] #============================================================================= # Copyright 2007-2009 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.) include(${CMAKE_CURRENT_LIST_DIR}/FindPackageMessage.cmake) include(${CMAKE_CURRENT_LIST_DIR}/CMakeParseArguments.cmake) # internal helper macro macro(_FPHSA_FAILURE_MESSAGE _msg) if (${_NAME}_FIND_REQUIRED) message(FATAL_ERROR "${_msg}") else () if (NOT ${_NAME}_FIND_QUIETLY) message(STATUS "${_msg}") endif () endif () endmacro() # internal helper macro to generate the failure message when used in CONFIG_MODE: macro(_FPHSA_HANDLE_FAILURE_CONFIG_MODE) # _CONFIG is set, but FOUND is false, this means that some other of the REQUIRED_VARS was not found: if(${_NAME}_CONFIG) _FPHSA_FAILURE_MESSAGE("${FPHSA_FAIL_MESSAGE}: missing: ${MISSING_VARS} (found ${${_NAME}_CONFIG} ${VERSION_MSG})") else() # If _CONSIDERED_CONFIGS is set, the config-file has been found, but no suitable version. # List them all in the error message: if(${_NAME}_CONSIDERED_CONFIGS) set(configsText "") list(LENGTH ${_NAME}_CONSIDERED_CONFIGS configsCount) math(EXPR configsCount "${configsCount} - 1") foreach(currentConfigIndex RANGE ${configsCount}) list(GET ${_NAME}_CONSIDERED_CONFIGS ${currentConfigIndex} filename) list(GET ${_NAME}_CONSIDERED_VERSIONS ${currentConfigIndex} version) set(configsText "${configsText} ${filename} (version ${version})\n") endforeach() if (${_NAME}_NOT_FOUND_MESSAGE) set(configsText "${configsText} Reason given by package: ${${_NAME}_NOT_FOUND_MESSAGE}\n") endif() _FPHSA_FAILURE_MESSAGE("${FPHSA_FAIL_MESSAGE} ${VERSION_MSG}, checked the following files:\n${configsText}") else() # Simple case: No Config-file was found at all: _FPHSA_FAILURE_MESSAGE("${FPHSA_FAIL_MESSAGE}: found neither ${_NAME}Config.cmake nor ${_NAME_LOWER}-config.cmake ${VERSION_MSG}") endif() endif() endmacro() function(FIND_PACKAGE_HANDLE_STANDARD_ARGS _NAME _FIRST_ARG) # set up the arguments for CMAKE_PARSE_ARGUMENTS and check whether we are in # new extended or in the "old" mode: set(options CONFIG_MODE HANDLE_COMPONENTS) set(oneValueArgs FAIL_MESSAGE VERSION_VAR FOUND_VAR) set(multiValueArgs REQUIRED_VARS) set(_KEYWORDS_FOR_EXTENDED_MODE ${options} ${oneValueArgs} ${multiValueArgs} ) list(FIND _KEYWORDS_FOR_EXTENDED_MODE "${_FIRST_ARG}" INDEX) if(${INDEX} EQUAL -1) set(FPHSA_FAIL_MESSAGE ${_FIRST_ARG}) set(FPHSA_REQUIRED_VARS ${ARGN}) set(FPHSA_VERSION_VAR) else() CMAKE_PARSE_ARGUMENTS(FPHSA "${options}" "${oneValueArgs}" "${multiValueArgs}" ${_FIRST_ARG} ${ARGN}) if(FPHSA_UNPARSED_ARGUMENTS) message(FATAL_ERROR "Unknown keywords given to FIND_PACKAGE_HANDLE_STANDARD_ARGS(): \"${FPHSA_UNPARSED_ARGUMENTS}\"") endif() if(NOT FPHSA_FAIL_MESSAGE) set(FPHSA_FAIL_MESSAGE "DEFAULT_MSG") endif() endif() # now that we collected all arguments, process them if("x${FPHSA_FAIL_MESSAGE}" STREQUAL "xDEFAULT_MSG") set(FPHSA_FAIL_MESSAGE "Could NOT find ${_NAME}") endif() # In config-mode, we rely on the variable _CONFIG, which is set by find_package() # when it successfully found the config-file, including version checking: if(FPHSA_CONFIG_MODE) list(INSERT FPHSA_REQUIRED_VARS 0 ${_NAME}_CONFIG) list(REMOVE_DUPLICATES FPHSA_REQUIRED_VARS) set(FPHSA_VERSION_VAR ${_NAME}_VERSION) endif() if(NOT FPHSA_REQUIRED_VARS) message(FATAL_ERROR "No REQUIRED_VARS specified for FIND_PACKAGE_HANDLE_STANDARD_ARGS()") endif() list(GET FPHSA_REQUIRED_VARS 0 _FIRST_REQUIRED_VAR) string(TOUPPER ${_NAME} _NAME_UPPER) string(TOLOWER ${_NAME} _NAME_LOWER) if(FPHSA_FOUND_VAR) if(FPHSA_FOUND_VAR MATCHES "^${_NAME}_FOUND$" OR FPHSA_FOUND_VAR MATCHES "^${_NAME_UPPER}_FOUND$") set(_FOUND_VAR ${FPHSA_FOUND_VAR}) else() message(FATAL_ERROR "The argument for FOUND_VAR is \"${FPHSA_FOUND_VAR}\", but only \"${_NAME}_FOUND\" and \"${_NAME_UPPER}_FOUND\" are valid names.") endif() else() set(_FOUND_VAR ${_NAME_UPPER}_FOUND) endif() # collect all variables which were not found, so they can be printed, so the # user knows better what went wrong (#6375) set(MISSING_VARS "") set(DETAILS "") # check if all passed variables are valid set(FPHSA_FOUND_${_NAME} TRUE) foreach(_CURRENT_VAR ${FPHSA_REQUIRED_VARS}) if(NOT ${_CURRENT_VAR}) set(FPHSA_FOUND_${_NAME} FALSE) set(MISSING_VARS "${MISSING_VARS} ${_CURRENT_VAR}") else() set(DETAILS "${DETAILS}[${${_CURRENT_VAR}}]") endif() endforeach() if(FPHSA_FOUND_${_NAME}) set(${_NAME}_FOUND TRUE) set(${_NAME_UPPER}_FOUND TRUE) else() set(${_NAME}_FOUND FALSE) set(${_NAME_UPPER}_FOUND FALSE) endif() # component handling unset(FOUND_COMPONENTS_MSG) unset(MISSING_COMPONENTS_MSG) if(FPHSA_HANDLE_COMPONENTS) foreach(comp ${${_NAME}_FIND_COMPONENTS}) if(${_NAME}_${comp}_FOUND) if(NOT DEFINED FOUND_COMPONENTS_MSG) set(FOUND_COMPONENTS_MSG "found components: ") endif() set(FOUND_COMPONENTS_MSG "${FOUND_COMPONENTS_MSG} ${comp}") else() if(NOT DEFINED MISSING_COMPONENTS_MSG) set(MISSING_COMPONENTS_MSG "missing components: ") endif() set(MISSING_COMPONENTS_MSG "${MISSING_COMPONENTS_MSG} ${comp}") if(${_NAME}_FIND_REQUIRED_${comp}) set(${_NAME}_FOUND FALSE) set(MISSING_VARS "${MISSING_VARS} ${comp}") endif() endif() endforeach() set(COMPONENT_MSG "${FOUND_COMPONENTS_MSG} ${MISSING_COMPONENTS_MSG}") set(DETAILS "${DETAILS}[c${COMPONENT_MSG}]") endif() # version handling: set(VERSION_MSG "") set(VERSION_OK TRUE) set(VERSION ${${FPHSA_VERSION_VAR}}) # check with DEFINED here as the requested or found version may be "0" if (DEFINED ${_NAME}_FIND_VERSION) if(DEFINED ${FPHSA_VERSION_VAR}) if(${_NAME}_FIND_VERSION_EXACT) # exact version required # count the dots in the version string string(REGEX REPLACE "[^.]" "" _VERSION_DOTS "${VERSION}") # add one dot because there is one dot more than there are components string(LENGTH "${_VERSION_DOTS}." _VERSION_DOTS) if (_VERSION_DOTS GREATER ${_NAME}_FIND_VERSION_COUNT) # Because of the C++ implementation of find_package() ${_NAME}_FIND_VERSION_COUNT # is at most 4 here. Therefore a simple lookup table is used. if (${_NAME}_FIND_VERSION_COUNT EQUAL 1) set(_VERSION_REGEX "[^.]*") elseif (${_NAME}_FIND_VERSION_COUNT EQUAL 2) set(_VERSION_REGEX "[^.]*\\.[^.]*") elseif (${_NAME}_FIND_VERSION_COUNT EQUAL 3) set(_VERSION_REGEX "[^.]*\\.[^.]*\\.[^.]*") else () set(_VERSION_REGEX "[^.]*\\.[^.]*\\.[^.]*\\.[^.]*") endif () string(REGEX REPLACE "^(${_VERSION_REGEX})\\..*" "\\1" _VERSION_HEAD "${VERSION}") unset(_VERSION_REGEX) if (NOT ${_NAME}_FIND_VERSION VERSION_EQUAL _VERSION_HEAD) set(VERSION_MSG "Found unsuitable version \"${VERSION}\", but required is exact version \"${${_NAME}_FIND_VERSION}\"") set(VERSION_OK FALSE) else () set(VERSION_MSG "(found suitable exact version \"${VERSION}\")") endif () unset(_VERSION_HEAD) else () if (NOT ${_NAME}_FIND_VERSION VERSION_EQUAL VERSION) set(VERSION_MSG "Found unsuitable version \"${VERSION}\", but required is exact version \"${${_NAME}_FIND_VERSION}\"") set(VERSION_OK FALSE) else () set(VERSION_MSG "(found suitable exact version \"${VERSION}\")") endif () endif () unset(_VERSION_DOTS) else() # minimum version specified: if (${_NAME}_FIND_VERSION VERSION_GREATER VERSION) set(VERSION_MSG "Found unsuitable version \"${VERSION}\", but required is at least \"${${_NAME}_FIND_VERSION}\"") set(VERSION_OK FALSE) else () set(VERSION_MSG "(found suitable version \"${VERSION}\", minimum required is \"${${_NAME}_FIND_VERSION}\")") endif () endif() else() # if the package was not found, but a version was given, add that to the output: if(${_NAME}_FIND_VERSION_EXACT) set(VERSION_MSG "(Required is exact version \"${${_NAME}_FIND_VERSION}\")") else() set(VERSION_MSG "(Required is at least version \"${${_NAME}_FIND_VERSION}\")") endif() endif() else () if(VERSION) set(VERSION_MSG "(found version \"${VERSION}\")") endif() endif () if(VERSION_OK) set(DETAILS "${DETAILS}[v${VERSION}(${${_NAME}_FIND_VERSION})]") else() set(${_NAME}_FOUND FALSE) endif() # print the result: if (${_NAME}_FOUND) FIND_PACKAGE_MESSAGE(${_NAME} "Found ${_NAME}: ${${_FIRST_REQUIRED_VAR}} ${VERSION_MSG} ${COMPONENT_MSG}" "${DETAILS}") else () if(FPHSA_CONFIG_MODE) _FPHSA_HANDLE_FAILURE_CONFIG_MODE() else() if(NOT VERSION_OK) _FPHSA_FAILURE_MESSAGE("${FPHSA_FAIL_MESSAGE}: ${VERSION_MSG} (found ${${_FIRST_REQUIRED_VAR}})") else() _FPHSA_FAILURE_MESSAGE("${FPHSA_FAIL_MESSAGE} (missing: ${MISSING_VARS}) ${VERSION_MSG}") endif() endif() endif () set(${_NAME}_FOUND ${${_NAME}_FOUND} PARENT_SCOPE) set(${_NAME_UPPER}_FOUND ${${_NAME}_FOUND} PARENT_SCOPE) endfunction() libfishcamp-1.2+20220607003151/cmake_modules/FindOggTheora.cmake0000644000175100017510000000247214174600255022740 0ustar debiandebian# # Find the native Ogg/Theora includes and libraries # # This module defines # OGGTHEORA_INCLUDE_DIR, where to find ogg/ogg.h and theora/theora.h # OGGTHEORA_LIBRARIES, the libraries to link against to use Ogg/Theora. # OGGTHEORA_FOUND, If false, do not try to use Ogg/Theora. FIND_PATH(OGGTHEORA_ogg_INCLUDE_DIR ogg/ogg.h) FIND_PATH(OGGTHEORA_theora_INCLUDE_DIR theora/theora.h) FIND_LIBRARY(OGGTHEORA_ogg_LIBRARY ogg) FIND_LIBRARY(OGGTHEORA_theoraenc_LIBRARY theoraenc) FIND_LIBRARY(OGGTHEORA_theoradec_LIBRARY theoradec) SET(OGGTHEORA_INCLUDE_DIRS ${OGGTHEORA_ogg_INCLUDE_DIR} ${OGGTHEORA_theora_INCLUDE_DIR} ) #HACK multiple directories SET(OGGTHEORA_INCLUDE_DIR ${OGGTHEORA_INCLUDE_DIRS}) SET(OGGTHEORA_LIBRARIES ${OGGTHEORA_theoraenc_LIBRARY} ${OGGTHEORA_theoradec_LIBRARY} ${OGGTHEORA_ogg_LIBRARY} ) #HACK multiple libraries SET(OGGTHEORA_LIBRARY ${OGGTHEORA_LIBRARIES}) INCLUDE(FindPackageHandleStandardArgs) FIND_PACKAGE_HANDLE_STANDARD_ARGS(OGGTHEORA "Could NOT find the ogg and theora libraries" OGGTHEORA_ogg_LIBRARY OGGTHEORA_theoraenc_LIBRARY OGGTHEORA_theoradec_LIBRARY OGGTHEORA_ogg_INCLUDE_DIR OGGTHEORA_theora_INCLUDE_DIR ) MARK_AS_ADVANCED(OGGTHEORA_ogg_INCLUDE_DIR OGGTHEORA_theora_INCLUDE_DIR OGGTHEORA_ogg_LIBRARY OGGTHEORA_theoraenc_LIBRARY OGGTHEORA_theoradec_LIBRARY ) libfishcamp-1.2+20220607003151/cmake_modules/FindMEADE.cmake0000644000175100017510000000247714174600255021701 0ustar debiandebian# - Try to find Meade DSI Library. # Once done this will define # # MEADEDSI_FOUND - system has Meade DSI # MEADEDSI_LIBRARIES - Link these to use Meade DSI # Copyright (c) 2006, Jasem Mutlaq # Based on FindLibfacile by Carsten Niehaus, # # Redistribution and use is allowed according to the terms of the BSD license. # For details see the accompanying COPYING-CMAKE-SCRIPTS file. if (MEADEDSI_LIBRARIES) # in cache already set(MEADEDSI_FOUND TRUE) message(STATUS "Found MEADEDSI: ${MEADEDSI_LIBRARIES}") else (MEADEDSI_LIBRARIES) find_library(MEADEDSI_LIBRARIES NAMES dsi PATHS ${_obLinkDir} ${GNUWIN32_DIR}/lib ) set(CMAKE_REQUIRED_LIBRARIES ${MEADEDSI_LIBRARIES}) if(MEADEDSI_LIBRARIES) set(MEADEDSI_FOUND TRUE) else (MEADEDSI_LIBRARIES) set(MEADEDSI_FOUND FALSE) endif(MEADEDSI_LIBRARIES) if (MEADEDSI_FOUND) if (NOT MEADEDSI_FIND_QUIETLY) message(STATUS "Found Meade DSI: ${MEADEDSI_LIBRARIES}") endif (NOT MEADEDSI_FIND_QUIETLY) else (MEADEDSI_FOUND) if (MEADEDSI_FIND_REQUIRED) message(FATAL_ERROR "Meade DSI not found. Please install Meade DSI library. http://linuxdsi.sourceforge.net") endif (MEADEDSI_FIND_REQUIRED) endif (MEADEDSI_FOUND) mark_as_advanced(MEADEDSI_LIBRARIES) endif (MEADEDSI_LIBRARIES) libfishcamp-1.2+20220607003151/cmake_modules/FindTOUPCAM.cmake0000644000175100017510000000267614174600255022177 0ustar debiandebian# - Try to find Toupcam Camera Library # Once done this will define # # TOUPCAM_FOUND - system has Toupcam # TOUPCAM_INCLUDE_DIR - the Toupcam include directory # TOUPCAM_LIBRARIES - Link these to use Toupcam # Redistribution and use is allowed according to the terms of the BSD license. # For details see the accompanying COPYING-CMAKE-SCRIPTS file. if (TOUPCAM_INCLUDE_DIR AND TOUPCAM_LIBRARIES) # in cache already set(TOUPCAM_FOUND TRUE) message(STATUS "Found libsbig: ${TOUPCAM_LIBRARIES}") else (TOUPCAM_INCLUDE_DIR AND TOUPCAM_LIBRARIES) find_path(TOUPCAM_INCLUDE_DIR toupcam.h PATH_SUFFIXES libtoupcam ${_obIncDir} ${GNUWIN32_DIR}/include ) find_library(TOUPCAM_LIBRARIES NAMES toupcam PATHS ${_obLinkDir} ${GNUWIN32_DIR}/lib ) if(TOUPCAM_INCLUDE_DIR AND TOUPCAM_LIBRARIES) set(TOUPCAM_FOUND TRUE) else (TOUPCAM_INCLUDE_DIR AND TOUPCAM_LIBRARIES) set(TOUPCAM_FOUND FALSE) endif(TOUPCAM_INCLUDE_DIR AND TOUPCAM_LIBRARIES) if (TOUPCAM_FOUND) if (NOT TOUPCAM_FIND_QUIETLY) message(STATUS "Found Toupcam: ${TOUPCAM_LIBRARIES}") endif (NOT TOUPCAM_FIND_QUIETLY) else (TOUPCAM_FOUND) if (TOUPCAM_FIND_REQUIRED) message(FATAL_ERROR "Toupcam not found. Please install Toupcam Library http://www.indilib.org") endif (TOUPCAM_FIND_REQUIRED) endif (TOUPCAM_FOUND) mark_as_advanced(TOUPCAM_INCLUDE_DIR TOUPCAM_LIBRARIES) endif (TOUPCAM_INCLUDE_DIR AND TOUPCAM_LIBRARIES) libfishcamp-1.2+20220607003151/cmake_modules/FindSV305.cmake0000644000175100017510000000264614174600255021644 0ustar debiandebian# - Try to find SV305 Library # Once done this will define # # SV305_FOUND - system has QHY # SV305_INCLUDE_DIR - the QHY include directory # SV305_LIBRARIES - Link these to use QHY # Redistribution and use is allowed according to the terms of the BSD license. # For details see the accompanying COPYING-CMAKE-SCRIPTS file. if (SV305_INCLUDE_DIR AND SV305_LIBRARIES) # in cache already set(SV305_FOUND TRUE) message(STATUS "Found libsv305: ${SV305_LIBRARIES}") else (SV305_INCLUDE_DIR AND SV305_LIBRARIES) # find headers find_path(SV305_INCLUDE_DIR NAMES SVBCameraSDK.h PATH_SUFFIXES libsv305 ${_obIncDir} ${GNUWIN32_DIR}/include ) # find libraries find_library(SV305_LIBRARIES NAMES SVBCameraSDK PATHS ${_obLinkDir} ${GNUWIN32_DIR}/lib ) if(SV305_INCLUDE_DIR AND SV305_LIBRARIES) set(SV305_FOUND TRUE) else (SV305_INCLUDE_DIR AND SV305_LIBRARIES) set(SV305_FOUND FALSE) endif(SV305_INCLUDE_DIR AND SV305_LIBRARIES) if (SV305_FOUND) if (NOT SV305_FIND_QUIETLY) message(STATUS "Found SV305 libraries : ${SV305_LIBRARIES}") endif (NOT SV305_FIND_QUIETLY) else (SV305_FOUND) if (SV305_FIND_REQUIRED) message(FATAL_ERROR "SV305 libraries not found. Please install libsv305 http://www.indilib.org") endif (SV305_FIND_REQUIRED) endif (SV305_FOUND) mark_as_advanced(SV305_INCLUDE_DIR SV305_LIBRARIES) endif (SV305_INCLUDE_DIR AND SV305_LIBRARIES) libfishcamp-1.2+20220607003151/cmake_modules/FindQSI.cmake0000644000175100017510000000245514174600255021516 0ustar debiandebian# - Try to find Quantum Scientific Imaging Library # Once done this will define # # QSI_FOUND - system has QSI # QSI_INCLUDE_DIR - the QSI include directory # QSI_LIBRARIES - Link these to use QSI # Redistribution and use is allowed according to the terms of the BSD license. # For details see the accompanying COPYING-CMAKE-SCRIPTS file. if (QSI_INCLUDE_DIR AND QSI_LIBRARIES) # in cache already set(QSI_FOUND TRUE) message(STATUS "Found libqsiapi: ${QSI_LIBRARIES}") else (QSI_INCLUDE_DIR AND QSI_LIBRARIES) find_path(QSI_INCLUDE_DIR qsiapi.h PATH_SUFFIXES qsiapi ${_obIncDir} ${GNUWIN32_DIR}/include ) find_library(QSI_LIBRARIES NAMES qsiapi PATHS ${_obLinkDir} ${GNUWIN32_DIR}/lib ) if(QSI_INCLUDE_DIR AND QSI_LIBRARIES) set(QSI_FOUND TRUE) else (QSI_INCLUDE_DIR AND QSI_LIBRARIES) set(QSI_FOUND FALSE) endif(QSI_INCLUDE_DIR AND QSI_LIBRARIES) if (QSI_FOUND) if (NOT QSI_FIND_QUIETLY) message(STATUS "Found QSI: ${QSI_LIBRARIES}") endif (NOT QSI_FIND_QUIETLY) else (QSI_FOUND) if (QSI_FIND_REQUIRED) message(FATAL_ERROR "QSI not found. Please install libqsi http://www.indilib.org") endif (QSI_FIND_REQUIRED) endif (QSI_FOUND) mark_as_advanced(QSI_INCLUDE_DIR QSI_LIBRARIES) endif (QSI_INCLUDE_DIR AND QSI_LIBRARIES) libfishcamp-1.2+20220607003151/cmake_modules/UnityBuild.cmake0000644000175100017510000001627714174600255022360 0ustar debiandebian# # Copyright (c) 2009-2012 Christoph Heindl # Copyright (c) 2015 Csaba Kertész (csaba.kertesz@gmail.com) # All rights reserved. # # Redistribution and use in source and binary forms, with or without # modification, are permitted provided that the following conditions are met: # # * Redistributions of source code must retain the above copyright # notice, this list of conditions and the following disclaimer. # * Redistributions in binary form must reproduce the above copyright # notice, this list of conditions and the following disclaimer in the # documentation and/or other materials provided with the distribution. # * Neither the name of the nor the # names of its contributors may be used to endorse or promote products # derived from this software without specific prior written permission. # # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND # ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED # WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE # DISCLAIMED. IN NO EVENT SHALL BE LIABLE FOR ANY # DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES # (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; # LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND # ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS # SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. # MACRO (COMMIT_UNITY_FILE UNITY_FILE FILE_CONTENT) SET(DIRTY FALSE) # Check if the build file exists SET(OLD_FILE_CONTENT "") IF (NOT EXISTS ${${UNITY_FILE}} AND NOT EXISTS ${CMAKE_CURRENT_BINARY_DIR}/${${UNITY_FILE}}) SET(DIRTY TRUE) ELSE () # Check the file content FILE(STRINGS ${${UNITY_FILE}} OLD_FILE_CONTENT) STRING(REPLACE ";" "" OLD_FILE_CONTENT "${OLD_FILE_CONTENT}") STRING(REPLACE "\n" "" NEW_CONTENT "${${FILE_CONTENT}}") STRING(COMPARE EQUAL "${OLD_FILE_CONTENT}" "${NEW_CONTENT}" EQUAL_CHECK) IF (NOT EQUAL_CHECK EQUAL 1) SET(DIRTY TRUE) ENDIF () ENDIF () IF (DIRTY MATCHES TRUE) MESSAGE(STATUS "Write Unity Build file: " ${${UNITY_FILE}}) FILE(WRITE ${${UNITY_FILE}} "${${FILE_CONTENT}}") ENDIF () # Create a dummy copy of the unity file to trigger CMake reconfigure if it is deleted. SET(UNITY_FILE_PATH "") SET(UNITY_FILE_NAME "") GET_FILENAME_COMPONENT(UNITY_FILE_PATH ${${UNITY_FILE}} PATH) GET_FILENAME_COMPONENT(UNITY_FILE_NAME ${${UNITY_FILE}} NAME) CONFIGURE_FILE(${${UNITY_FILE}} ${UNITY_FILE_PATH}/CMakeFiles/${UNITY_FILE_NAME}.dummy) ENDMACRO () MACRO (ENABLE_UNITY_BUILD TARGET_NAME SOURCE_VARIABLE_NAME UNIT_SIZE EXTENSION) # Limit is zero based conversion of unit_size MATH(EXPR LIMIT ${UNIT_SIZE}-1) SET(FILES ${SOURCE_VARIABLE_NAME}) # Effectivly ignore the source files from the build, but keep track them for changes. SET_SOURCE_FILES_PROPERTIES(${${FILES}} PROPERTIES HEADER_FILE_ONLY true) # Counts the number of source files up to the threshold SET(COUNTER ${LIMIT}) # Have one or more unity build files SET(FILE_NUMBER 0) SET(BUILD_FILE "") SET(BUILD_FILE_CONTENT "") SET(UNITY_BUILD_FILES "") SET(_DEPS "") FOREACH (SOURCE_FILE ${${FILES}}) IF (COUNTER EQUAL LIMIT) SET(_DEPS "") # Write the actual Unity Build file IF (NOT ${BUILD_FILE} STREQUAL "" AND NOT ${BUILD_FILE_CONTENT} STREQUAL "") COMMIT_UNITY_FILE(BUILD_FILE BUILD_FILE_CONTENT) ENDIF () SET(UNITY_BUILD_FILES ${UNITY_BUILD_FILES} ${BUILD_FILE}) # Set the variables for the current Unity Build file SET(BUILD_FILE ${CMAKE_CURRENT_BINARY_DIR}/unitybuild_${FILE_NUMBER}_${TARGET_NAME}.${EXTENSION}) SET(BUILD_FILE_CONTENT "// Unity Build file generated by CMake\n") MATH(EXPR FILE_NUMBER ${FILE_NUMBER}+1) SET(COUNTER 0) ENDIF () # Add source path to the file name if it is not there yet. SET(FINAL_SOURCE_FILE "") SET(SOURCE_PATH "") GET_FILENAME_COMPONENT(SOURCE_PATH ${SOURCE_FILE} PATH) IF (SOURCE_PATH STREQUAL "" OR NOT EXISTS ${SOURCE_FILE}) SET(FINAL_SOURCE_FILE ${CMAKE_CURRENT_SOURCE_DIR}/${SOURCE_FILE}) ELSE () SET(FINAL_SOURCE_FILE ${SOURCE_FILE}) ENDIF () # Treat only the existing files or moc_*.cpp files STRING(FIND ${SOURCE_FILE} "moc_" MOC_POS) IF (EXISTS ${FINAL_SOURCE_FILE} OR MOC_POS GREATER -1) # Add md5 hash of the source file (except moc files) to the build file content IF (MOC_POS LESS 0) SET(MD5_HASH "") FILE(MD5 ${FINAL_SOURCE_FILE} MD5_HASH) SET(BUILD_FILE_CONTENT "${BUILD_FILE_CONTENT}// md5: ${MD5_HASH}\n") ENDIF () # Add the source file to the build file content IF (MOC_POS GREATER -1) SET(BUILD_FILE_CONTENT "${BUILD_FILE_CONTENT}#include <${SOURCE_FILE}>\n") ELSE () SET(BUILD_FILE_CONTENT "${BUILD_FILE_CONTENT}#include <${FINAL_SOURCE_FILE}>\n") ENDIF () # Add the source dependencies to the Unity Build file GET_SOURCE_FILE_PROPERTY(_FILE_DEPS ${SOURCE_FILE} OBJECT_DEPENDS) IF (_FILE_DEPS) SET(_DEPS ${_DEPS} ${_FILE_DEPS}) SET_SOURCE_FILES_PROPERTIES(${BUILD_FILE} PROPERTIES OBJECT_DEPENDS "${_DEPS}") ENDIF() # Keep counting up to the threshold. Increment counter. MATH(EXPR COUNTER ${COUNTER}+1) ENDIF () ENDFOREACH () # Write out the last Unity Build file IF (NOT ${BUILD_FILE} STREQUAL "" AND NOT ${BUILD_FILE_CONTENT} STREQUAL "") COMMIT_UNITY_FILE(BUILD_FILE BUILD_FILE_CONTENT) ENDIF () SET(UNITY_BUILD_FILES ${UNITY_BUILD_FILES} ${BUILD_FILE}) SET(${SOURCE_VARIABLE_NAME} ${${SOURCE_VARIABLE_NAME}} ${UNITY_BUILD_FILES}) ENDMACRO () MACRO (UNITY_GENERATE_MOC TARGET_NAME SOURCES HEADERS) SET(NEW_SOURCES "") FOREACH (HEADER_FILE ${${HEADERS}}) IF (NOT EXISTS ${HEADER_FILE}) MESSAGE(FATAL_ERROR "Header file does not exist (mocing): ${HEADER_FILE}") ENDIF () FILE(READ ${HEADER_FILE} FILE_CONTENT) STRING(FIND "${FILE_CONTENT}" "Q_OBJECT" QOBJECT_POS) STRING(FIND "${FILE_CONTENT}" "Q_SLOTS" QSLOTS_POS) STRING(FIND "${FILE_CONTENT}" "Q_SIGNALS" QSIGNALS_POS) STRING(FIND "${FILE_CONTENT}" "QObject" OBJECT_POS) STRING(FIND "${FILE_CONTENT}" "slots" SLOTS_POS) STRING(FIND "${FILE_CONTENT}" "signals" SIGNALS_POS) IF (QOBJECT_POS GREATER 0 OR OBJECT_POS GREATER 0 OR QSLOTS_POS GREATER 0 OR Q_SIGNALS GREATER 0 OR SLOTS_POS GREATER 0 OR SIGNALS GREATER 0) # Generate the moc filename GET_FILENAME_COMPONENT(HEADER_BASENAME ${HEADER_FILE} NAME_WE) SET(MOC_FILENAME "moc_${HEADER_BASENAME}.cpp") SET(NEW_SOURCES ${NEW_SOURCES} ; "${CMAKE_CURRENT_BINARY_DIR}/${MOC_FILENAME}") ADD_CUSTOM_COMMAND(OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/${MOC_FILENAME}" DEPENDS ${HEADER_FILE} COMMAND ${QT_MOC_EXECUTABLE} ${HEADER_FILE} -o "${CMAKE_CURRENT_BINARY_DIR}/${MOC_FILENAME}") ENDIF () ENDFOREACH () IF (NEW_SOURCES) SET_SOURCE_FILES_PROPERTIES(${NEW_SOURCES} PROPERTIES GENERATED TRUE) SET(${SOURCES} ${${SOURCES}} ; ${NEW_SOURCES}) ENDIF () ENDMACRO () libfishcamp-1.2+20220607003151/cmake_modules/FindLibRaw.cmake0000644000175100017510000000562514174600255022244 0ustar debiandebian# - Find LibRaw # Find the LibRaw library # This module defines # LibRaw_VERSION_STRING, the version string of LibRaw # LibRaw_INCLUDE_DIR, where to find libraw.h # LibRaw_LIBRARIES, the libraries needed to use LibRaw (non-thread-safe) # LibRaw_r_LIBRARIES, the libraries needed to use LibRaw (thread-safe) # LibRaw_DEFINITIONS, the definitions needed to use LibRaw (non-thread-safe) # LibRaw_r_DEFINITIONS, the definitions needed to use LibRaw (thread-safe) # # Copyright (c) 2013, Pino Toscano # Copyright (c) 2013, Gilles Caulier # # Redistribution and use is allowed according to the terms of the BSD license. # For details see the accompanying COPYING-CMAKE-SCRIPTS file. FIND_PACKAGE(PkgConfig) IF(PKG_CONFIG_FOUND) PKG_CHECK_MODULES(PC_LIBRAW libraw) SET(LibRaw_DEFINITIONS ${PC_LIBRAW_CFLAGS_OTHER}) PKG_CHECK_MODULES(PC_LIBRAW_R libraw_r) SET(LibRaw_r_DEFINITIONS ${PC_LIBRAW_R_CFLAGS_OTHER}) ENDIF() FIND_PATH(LibRaw_INCLUDE_DIR libraw.h HINTS ${PC_LIBRAW_INCLUDEDIR} ${PC_LibRaw_INCLUDE_DIRS} PATH_SUFFIXES libraw ) FIND_LIBRARY(LibRaw_LIBRARIES NAMES raw HINTS ${PC_LIBRAW_LIBDIR} ${PC_LIBRAW_LIBRARY_DIRS} ) FIND_LIBRARY(LibRaw_r_LIBRARIES NAMES raw_r HINTS ${PC_LIBRAW_R_LIBDIR} ${PC_LIBRAW_R_LIBRARY_DIRS} ) IF(LibRaw_INCLUDE_DIR) FILE(READ ${LibRaw_INCLUDE_DIR}/libraw_version.h _libraw_version_content) STRING(REGEX MATCH "#define LIBRAW_MAJOR_VERSION[ \t]*([0-9]*)\n" _version_major_match ${_libraw_version_content}) SET(_libraw_version_major "${CMAKE_MATCH_1}") STRING(REGEX MATCH "#define LIBRAW_MINOR_VERSION[ \t]*([0-9]*)\n" _version_minor_match ${_libraw_version_content}) SET(_libraw_version_minor "${CMAKE_MATCH_1}") STRING(REGEX MATCH "#define LIBRAW_PATCH_VERSION[ \t]*([0-9]*)\n" _version_patch_match ${_libraw_version_content}) SET(_libraw_version_patch "${CMAKE_MATCH_1}") IF(_version_major_match AND _version_minor_match AND _version_patch_match) SET(LibRaw_VERSION_STRING "${_libraw_version_major}.${_libraw_version_minor}.${_libraw_version_patch}") ELSE() IF(NOT LibRaw_FIND_QUIETLY) MESSAGE(STATUS "Failed to get version information from ${LibRaw_INCLUDE_DIR}/libraw_version.h") ENDIF() ENDIF() ENDIF() INCLUDE(FindPackageHandleStandardArgs) FIND_PACKAGE_HANDLE_STANDARD_ARGS(LibRaw REQUIRED_VARS LibRaw_LIBRARIES LibRaw_INCLUDE_DIR VERSION_VAR LibRaw_VERSION_STRING ) MARK_AS_ADVANCED(LibRaw_VERSION_STRING LibRaw_INCLUDE_DIR LibRaw_LIBRARIES LibRaw_r_LIBRARIES LibRaw_DEFINITIONS LibRaw_r_DEFINITIONS ) libfishcamp-1.2+20220607003151/cmake_modules/FindALTAIRCAM.cmake0000644000175100017510000000301014174600255022343 0ustar debiandebian# - Try to find Altair Camera Library # Once done this will define # # ALTAIRCAM_FOUND - system has Altair # ALTAIRCAM_INCLUDE_DIR - the Altair include directory # ALTAIRCAM_LIBRARIES - Link these to use Altair # Redistribution and use is allowed according to the terms of the BSD license. # For details see the accompanying COPYING-CMAKE-SCRIPTS file. if (ALTAIRCAM_INCLUDE_DIR AND ALTAIRCAM_LIBRARIES) # in cache already set(ALTAIRCAM_FOUND TRUE) message(STATUS "Found libaltaircam: ${ALTAIRCAM_LIBRARIES}") else (ALTAIRCAM_INCLUDE_DIR AND ALTAIRCAM_LIBRARIES) find_path(ALTAIRCAM_INCLUDE_DIR altaircam.h PATH_SUFFIXES libaltaircam ${_obIncDir} ${GNUWIN32_DIR}/include ) find_library(ALTAIRCAM_LIBRARIES NAMES altaircam PATHS ${_obLinkDir} ${GNUWIN32_DIR}/lib ) if(ALTAIRCAM_INCLUDE_DIR AND ALTAIRCAM_LIBRARIES) set(ALTAIRCAM_FOUND TRUE) else (ALTAIRCAM_INCLUDE_DIR AND ALTAIRCAM_LIBRARIES) set(ALTAIRCAM_FOUND FALSE) endif(ALTAIRCAM_INCLUDE_DIR AND ALTAIRCAM_LIBRARIES) if (ALTAIRCAM_FOUND) if (NOT ALTAIRCAM_FIND_QUIETLY) message(STATUS "Found Altaircam: ${ALTAIRCAM_LIBRARIES}") endif (NOT ALTAIRCAM_FIND_QUIETLY) else (ALTAIRCAM_FOUND) if (ALTAIRCAM_FIND_REQUIRED) message(FATAL_ERROR "Altaircam not found. Please install Altaircam Library http://www.indilib.org") endif (ALTAIRCAM_FIND_REQUIRED) endif (ALTAIRCAM_FOUND) mark_as_advanced(ALTAIRCAM_INCLUDE_DIR ALTAIRCAM_LIBRARIES) endif (ALTAIRCAM_INCLUDE_DIR AND ALTAIRCAM_LIBRARIES) libfishcamp-1.2+20220607003151/cmake_modules/FindSBIG.cmake0000644000175100017510000000251214174600255021600 0ustar debiandebian# - Try to find SBIG Universal Library # Once done this will define # # SBIG_FOUND - system has SBIG # SBIG_INCLUDE_DIR - the SBIG include directory # SBIG_LIBRARIES - Link these to use SBIG # Redistribution and use is allowed according to the terms of the BSD license. # For details see the accompanying COPYING-CMAKE-SCRIPTS file. if (SBIG_INCLUDE_DIR AND SBIG_LIBRARIES) # in cache already set(SBIG_FOUND TRUE) message(STATUS "Found libsbig: ${SBIG_LIBRARIES}") else (SBIG_INCLUDE_DIR AND SBIG_LIBRARIES) find_path(SBIG_INCLUDE_DIR sbigudrv.h PATH_SUFFIXES libsbig ${_obIncDir} ${GNUWIN32_DIR}/include ) find_library(SBIG_LIBRARIES NAMES sbig PATHS ${_obLinkDir} ${GNUWIN32_DIR}/lib ) if(SBIG_INCLUDE_DIR AND SBIG_LIBRARIES) set(SBIG_FOUND TRUE) else (SBIG_INCLUDE_DIR AND SBIG_LIBRARIES) set(SBIG_FOUND FALSE) endif(SBIG_INCLUDE_DIR AND SBIG_LIBRARIES) if (SBIG_FOUND) if (NOT SBIG_FIND_QUIETLY) message(STATUS "Found SBIG: ${SBIG_LIBRARIES}") endif (NOT SBIG_FIND_QUIETLY) else (SBIG_FOUND) if (SBIG_FIND_REQUIRED) message(FATAL_ERROR "SBIG not found. Please install SBIG Library http://www.indilib.org") endif (SBIG_FIND_REQUIRED) endif (SBIG_FOUND) mark_as_advanced(SBIG_INCLUDE_DIR SBIG_LIBRARIES) endif (SBIG_INCLUDE_DIR AND SBIG_LIBRARIES) libfishcamp-1.2+20220607003151/cmake_modules/CMakeParseArguments.cmake0000644000175100017510000000164214174600255024117 0ustar debiandebian#.rst: # CMakeParseArguments # ------------------- # # This module once implemented the :command:`cmake_parse_arguments` command # that is now implemented natively by CMake. It is now an empty placeholder # for compatibility with projects that include it to get the command from # CMake 3.4 and lower. #============================================================================= # Copyright 2010 Alexander Neundorf # # 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.) libfishcamp-1.2+20220607003151/cmake_modules/FindGPHOTO2.cmake0000644000175100017510000000562614174600255022147 0ustar debiandebian# - Find the native sqlite3 includes and library # # This module defines # GPHOTO2_INCLUDE_DIR, where to find libgphoto2 header files # GPHOTO2_LIBRARIES, the libraries to link against to use libgphoto2 # GPHOTO2_FOUND, If false, do not try to use libgphoto2. # GPHOTO2_VERSION_STRING, e.g. 2.4.14 # GPHOTO2_VERSION_MAJOR, e.g. 2 # GPHOTO2_VERSION_MINOR, e.g. 4 # GPHOTO2_VERSION_PATCH, e.g. 14 # # also defined, but not for general use are # GPHOTO2_LIBRARY, where to find the sqlite3 library. #============================================================================= # Copyright 2010 henrik andersson #============================================================================= SET(GPHOTO2_FIND_REQUIRED ${Gphoto2_FIND_REQUIRED}) find_path(GPHOTO2_INCLUDE_DIR gphoto2/gphoto2.h) mark_as_advanced(GPHOTO2_INCLUDE_DIR) set(GPHOTO2_NAMES ${GPHOTO2_NAMES} gphoto2 libgphoto2) set(GPHOTO2_PORT_NAMES ${GPHOTO2_PORT_NAMES} gphoto2_port libgphoto2_port) find_library(GPHOTO2_LIBRARY NAMES ${GPHOTO2_NAMES} ) find_library(GPHOTO2_PORT_LIBRARY NAMES ${GPHOTO2_PORT_NAMES} ) mark_as_advanced(GPHOTO2_LIBRARY) mark_as_advanced(GPHOTO2_PORT_LIBRARY) # Detect libgphoto2 version FIND_PROGRAM(GPHOTO2CONFIG_EXECUTABLE NAMES gphoto2-config) IF(GPHOTO2CONFIG_EXECUTABLE) EXEC_PROGRAM(${GPHOTO2CONFIG_EXECUTABLE} ARGS --version RETURN_VALUE _return_VALUE OUTPUT_VARIABLE GPHOTO2_VERSION) string(REGEX REPLACE "^.*libgphoto2 ([0-9]+).*$" "\\1" GPHOTO2_VERSION_MAJOR "${GPHOTO2_VERSION}") string(REGEX REPLACE "^.*libgphoto2 [0-9]+\\.([0-9]+).*$" "\\1" GPHOTO2_VERSION_MINOR "${GPHOTO2_VERSION}") string(REGEX REPLACE "^.*libgphoto2 [0-9]+\\.[0-9]+\\.([0-9]+).*$" "\\1" GPHOTO2_VERSION_PATCH "${GPHOTO2_VERSION}") set(GPHOTO2_VERSION_STRING "${GPHOTO2_VERSION_MAJOR}.${GPHOTO2_VERSION_MINOR}.${GPHOTO2_VERSION_PATCH}") ENDIF(GPHOTO2CONFIG_EXECUTABLE) # handle the QUIETLY and REQUIRED arguments and set GPHOTO2_FOUND to TRUE if # all listed variables are TRUE include(FindPackageHandleStandardArgs) find_package_handle_standard_args(GPHOTO2 DEFAULT_MSG GPHOTO2_LIBRARY GPHOTO2_INCLUDE_DIR) IF(GPHOTO2_FOUND) SET(Gphoto2_LIBRARIES ${GPHOTO2_LIBRARY} ${GPHOTO2_PORT_LIBRARY}) SET(Gphoto2_INCLUDE_DIRS ${GPHOTO2_INCLUDE_DIR}) # libgphoto2 dynamically loads and unloads usb library # without calling any cleanup functions (since they are absent from libusb-0.1). # This leaves usb event handling threads running with invalid callback and return addresses, # which causes a crash after any usb event is generated, at least in Mac OS X. # libusb1 backend does correctly call exit function, but ATM it crashes anyway. # Workaround is to link against libusb so that it wouldn't get unloaded. IF(APPLE) find_library(USB_LIBRARY NAMES usb-1.0 libusb-1.0) mark_as_advanced(USB_LIBRARY) IF(USB_LIBRARY) SET(Gphoto2_LIBRARIES ${Gphoto2_LIBRARIES} ${USB_LIBRARY}) ENDIF(USB_LIBRARY) ENDIF(APPLE) ENDIF(GPHOTO2_FOUND) libfishcamp-1.2+20220607003151/cmake_modules/FindMMAL.cmake0000644000175100017510000000303214174600255021600 0ustar debiandebian# Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # http://www.apache.org/licenses/LICENSE-2.0 # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # # This module can find the MMAL camera libraries. # cmake_minimum_required(VERSION 3.0.0) set (MMAL_LIBS mmal_core mmal_util mmal_vc_client) set (EGL_LIBS brcmGLESv2 brcmEGL) foreach(lib ${MMAL_LIBS} ${EGL_LIBS} vcos bcm_host m dl) find_library(${lib}_LIBRARY NAMES ${lib} HINTS ${MMAL_DIR}/lib /opt/vc/lib ) if (DEFINED ${lib}_LIBRARY) set(MMAL_LIBRARIES ${MMAL_LIBRARIES} ${${lib}_LIBRARY}) else() message(FATAL_ERROR "Failed to find ${${lib}_LIBRARY} library") endif() endforeach(lib) find_path(BCM_INCLUDE_DIR NAMES bcm_host.h HINTS "/opt/vc/include" ) find_path(MMAL_BASE_INCLUDE_DIR NAMES mmal.h HINTS "/opt/vc/include/interface/mmal" ) find_path(MMAL_UTIL_INCLUDE_DIR NAMES mmal_util.h HINTS "/opt/vc/include/interface/mmal/util" ) if (MMAL_BASE_INCLUDE_DIR AND BCM_INCLUDE_DIR AND MMAL_UTIL_INCLUDE_DIR) set(MMAL_INCLUDE_DIR ${MMAL_BASE_INCLUDE_DIR} ${BCM_INCLUDE_DIR} ${MMAL_UTIL_INCLUDE_DIR}) set(MMAL_FOUND TRUE) endif() libfishcamp-1.2+20220607003151/cmake_modules/FindAIOUSB.cmake0000644000175100017510000000371314174600255022042 0ustar debiandebian# - Try to find libaiousb # Once done this will define # # AIOUSB_FOUND - system has AIOUSB # AIOUSB_INCLUDE_DIR - the AIOUSB include directory # AIOUSB_LIBRARIES - Link these to use AIOUSB (C) # AIOUSB_CPP_LIBRARIES - Link these to use AIOUSB (C++) # Copyright (c) 2006, Jasem Mutlaq # Based on FindLibfacile by Carsten Niehaus, # # Redistribution and use is allowed according to the terms of the BSD license. # For details see the accompanying COPYING-CMAKE-SCRIPTS file. if (AIOUSB_INCLUDE_DIR AND AIOUSB_LIBRARIES AND AIOUSB_CPP_LIBRARIES) # in cache already set(AIOUSB_FOUND TRUE) message(STATUS "Found libaiusb: ${AIOUSB_LIBRARIES}") message(STATUS "Found libaiusbcpp: ${AIOUSB_CPP_LIBRARIES}") else (AIOUSB_INCLUDE_DIR AND AIOUSB_LIBRARIES AND AIOUSB_CPP_LIBRARIES) find_path(AIOUSB_INCLUDE_DIR aiousb.h ${_obIncDir} ${GNUWIN32_DIR}/include ) find_library(AIOUSB_LIBRARIES NAMES aiousb PATHS ${_obLinkDir} ${GNUWIN32_DIR}/lib ) find_library(AIOUSB_CPP_LIBRARIES NAMES aiousbcpp PATHS ${_obLinkDir} ${GNUWIN32_DIR}/lib ) if(AIOUSB_INCLUDE_DIR AND AIOUSB_LIBRARIES AND AIOUSB_CPP_LIBRARIES) set(AIOUSB_FOUND TRUE) else (AIOUSB_INCLUDE_DIR AND AIOUSB_LIBRARIES AND AIOUSB_CPP_LIBRARIES) set(AIOUSB_FOUND FALSE) endif(AIOUSB_INCLUDE_DIR AND AIOUSB_LIBRARIES AND AIOUSB_CPP_LIBRARIES) if (AIOUSB_FOUND) if (NOT AIOUSB_FIND_QUIETLY) message(STATUS "Found libaiousb: ${AIOUSB_LIBRARIES}") message(STATUS "Found libaiusbcpp: ${AIOUSB_CPP_LIBRARIES}") endif (NOT AIOUSB_FIND_QUIETLY) else (AIOUSB_FOUND) if (AIOUSB_FIND_REQUIRED) message(FATAL_ERROR "libaiousb not found. Please install libaiousb. https://www.accesio.com") endif (AIOUSB_FIND_REQUIRED) endif (AIOUSB_FOUND) mark_as_advanced(AIOUSB_INCLUDE_DIR AIOUSB_LIBRARIES AIOUSB_CPP_LIBRARIES) endif (AIOUSB_INCLUDE_DIR AND AIOUSB_LIBRARIES AND AIOUSB_CPP_LIBRARIES) libfishcamp-1.2+20220607003151/cmake_modules/FindAPOGEE.cmake0000644000175100017510000000311514174600255022014 0ustar debiandebian# - Try to find Apogee Instruments Library # Once done this will define # # APOGEE_FOUND - system has APOGEE # APOGEE_INCLUDE_DIR - the APOGEE include directory # APOGEE_LIBRARY - Link these to use APOGEE # Copyright (c) 2008, Jasem Mutlaq # Based on FindLibfacile by Carsten Niehaus, # # Redistribution and use is allowed according to the terms of the BSD license. # For details see the accompanying COPYING-CMAKE-SCRIPTS file. if (APOGEE_INCLUDE_DIR AND APOGEE_LIBRARY) # in cache already set(APOGEE_FOUND TRUE) message(STATUS "Found libapogee: ${APOGEE_LIBRARY}") else (APOGEE_INCLUDE_DIR AND APOGEE_LIBRARY) find_path(APOGEE_INCLUDE_DIR ApogeeCam.h PATH_SUFFIXES libapogee ${_obIncDir} ${GNUWIN32_DIR}/include ) # Find Apogee Library find_library(APOGEE_LIBRARY NAMES apogee PATHS ${_obLinkDir} ${GNUWIN32_DIR}/lib ) if(APOGEE_INCLUDE_DIR AND APOGEE_LIBRARY) set(APOGEE_FOUND TRUE) else (APOGEE_INCLUDE_DIR AND APOGEE_LIBRARY) set(APOGEE_FOUND FALSE) endif(APOGEE_INCLUDE_DIR AND APOGEE_LIBRARY) if (APOGEE_FOUND) if (NOT APOGEE_FIND_QUIETLY) message(STATUS "Found APOGEE: ${APOGEE_LIBRARY}") endif (NOT APOGEE_FIND_QUIETLY) else (APOGEE_FOUND) if (APOGEE_FIND_REQUIRED) message(FATAL_ERROR "libapogee not found. Cannot compile Apogee CCD Driver. Please install libapogee and try again. http://www.indilib.org") endif (APOGEE_FIND_REQUIRED) endif (APOGEE_FOUND) mark_as_advanced(APOGEE_INCLUDE_DIR APOGEE_LIBRARY) endif (APOGEE_INCLUDE_DIR AND APOGEE_LIBRARY) libfishcamp-1.2+20220607003151/cmake_modules/FindFFmpeg.cmake0000644000175100017510000001615414243553447022236 0ustar debiandebian# - Try to find ffmpeg libraries (libavcodec, libavdevice, libavformat, libavutil, and libswscale) # Once done this will define # # FFMPEG_FOUND - system has ffmpeg or libav # FFMPEG_INCLUDE_DIR - the ffmpeg include directory # FFMPEG_LIBRARIES - Link these to use ffmpeg # FFMPEG_LIBAVCODEC # FFMPEG_LIBAVDEVICE # FFMPEG_LIBAVFORMAT # FFMPEG_LIBAVUTIL # FFMPEG_LIBSWSCALE # # Copyright (c) 2008 Andreas Schneider # Modified for other libraries by Lasse Kärkkäinen # Modified for Hedgewars by Stepik777 # Modified for INDILIB by rlancaste # # Redistribution and use is allowed according to the terms of the New # BSD license. # macro(_FFMPEG_PACKAGE_check_version) if(EXISTS "${PACKAGE_INCLUDE_DIR}/version.h") file(READ "${PACKAGE_INCLUDE_DIR}/version.h" _FFMPEG_PACKAGE_version_header) string(REGEX MATCH "#define ${PACKAGE_NAME}_VERSION_MAJOR[ \t]+([0-9]+)" _VERSION_MAJOR_match "${_FFMPEG_PACKAGE_version_header}") set(FFMPEG_PACKAGE_VERSION_MAJOR "${CMAKE_MATCH_1}") string(REGEX MATCH "#define ${PACKAGE_NAME}_VERSION_MINOR[ \t]+([0-9]+)" _VERSION_MINOR_match "${_FFMPEG_PACKAGE_version_header}") set(FFMPEG_PACKAGE_VERSION_MINOR "${CMAKE_MATCH_1}") string(REGEX MATCH "#define ${PACKAGE_NAME}_VERSION_MICRO[ \t]+([0-9]+)" _VERSION_MICRO_match "${_FFMPEG_PACKAGE_version_header}") set(FFMPEG_PACKAGE_VERSION_MICRO "${CMAKE_MATCH_1}") set(FFMPEG_PACKAGE_VERSION ${FFMPEG_PACKAGE_VERSION_MAJOR}.${FFMPEG_PACKAGE_VERSION_MINOR}.${FFMPEG_PACKAGE_VERSION_MICRO}) if(${FFMPEG_PACKAGE_VERSION} VERSION_LESS ${FFMPEG_PACKAGE_FIND_VERSION}) set(FFMPEG_PACKAGE_VERSION_OK FALSE) else(${FFMPEG_PACKAGE_VERSION} VERSION_LESS ${FFMPEG_PACKAGE_FIND_VERSION}) set(FFMPEG_PACKAGE_VERSION_OK TRUE) endif(${FFMPEG_PACKAGE_VERSION} VERSION_LESS ${FFMPEG_PACKAGE_FIND_VERSION}) if(NOT FFMPEG_PACKAGE_VERSION_OK) message(STATUS "${PACKAGE_NAME} version ${FFMPEG_PACKAGE_VERSION} found in ${PACKAGE_INCLUDE_DIR}, " "but at least version ${FFMPEG_PACKAGE_FIND_VERSION} is required") else(NOT FFMPEG_PACKAGE_VERSION_OK) mark_as_advanced(FFMPEG_PACKAGE_VERSION_MAJOR FFMPEG_PACKAGE_VERSION_MINOR FFMPEG_PACKAGE_VERSION_MICRO) endif(NOT FFMPEG_PACKAGE_VERSION_OK) else(EXISTS "${PACKAGE_INCLUDE_DIR}/version.h") set(FFMPEG_PACKAGE_VERSION_OK FALSE) message(STATUS "${PACKAGE_NAME}'s version.h file was not found in the include directory: ${PACKAGE_INCLUDE_DIR}, please install this program.") endif(EXISTS "${PACKAGE_INCLUDE_DIR}/version.h") endmacro(_FFMPEG_PACKAGE_check_version) # required ffmpeg library versions, Requiring at least FFMPEG 3.2.11, Hypatia set(_avcodec_ver ">=57.64.101") set(_avdevice_ver ">=57.1.100") set(_avformat_ver ">=57.56.100") set(_avutil_ver ">=55.34.100") set(_swscale_ver ">=4.2.100") if (FFMPEG_LIBRARIES AND FFMPEG_INCLUDE_DIR) # in cache already set(FFMPEG_FOUND TRUE) else (FFMPEG_LIBRARIES AND FFMPEG_INCLUDE_DIR) # use pkg-config to get the directories and then use these values # in the FIND_PATH() and FIND_LIBRARY() calls find_path(FFMPEG_INCLUDE_DIR NAMES libavcodec/avcodec.h PATHS ${FFMPEG_INCLUDE_DIRS} ${CMAKE_INSTALL_PREFIX}/include /usr/include /usr/local/include /opt/local/include /sw/include PATH_SUFFIXES ffmpeg libav ) find_package(PkgConfig) if (PKG_CONFIG_FOUND) pkg_check_modules(AVCODEC libavcodec${_avcodec_ver}) pkg_check_modules(AVDEVICE libavdevice${_avdevice_ver}) pkg_check_modules(AVFORMAT libavformat${_avformat_ver}) pkg_check_modules(AVUTIL libavutil${_avutil_ver}) pkg_check_modules(SWSCALE libswscale${_swscale_ver}) endif (PKG_CONFIG_FOUND) if (NOT PKG_CONFIG_FOUND OR NOT FFMPEG_LIBAVCODEC OR NOT FFMPEG_LIBAVDEVICE OR NOT FFMPEG_LIBAVFORMAT OR NOT FFMPEG_LIBAVUTIL OR NOT FFMPEG_LIBSWSCALE) # LIBAVCODEC set(PACKAGE_NAME "LIBAVCODEC") set(PACKAGE_INCLUDE_DIR "${FFMPEG_INCLUDE_DIR}/libavcodec") set(FFMPEG_PACKAGE_FIND_VERSION _avcodec_ver) _FFMPEG_PACKAGE_check_version() if(FFMPEG_PACKAGE_VERSION_OK) set(AVCODEC_VERSION FFMPEG_PACKAGE_VERSION) endif(FFMPEG_PACKAGE_VERSION_OK) # LIBAVDEVICE set(PACKAGE_NAME "LIBAVDEVICE") set(PACKAGE_INCLUDE_DIR "${FFMPEG_INCLUDE_DIR}/libavdevice") set(FFMPEG_PACKAGE_FIND_VERSION _avdevice_ver) _FFMPEG_PACKAGE_check_version() if(FFMPEG_PACKAGE_VERSION_OK) set(AVDEVICE_VERSION FFMPEG_PACKAGE_VERSION) endif(FFMPEG_PACKAGE_VERSION_OK) # LIBAVFORMAT set(PACKAGE_NAME "LIBAVFORMAT") set(PACKAGE_INCLUDE_DIR "${FFMPEG_INCLUDE_DIR}/libavformat") set(FFMPEG_PACKAGE_FIND_VERSION _avformat_ver) _FFMPEG_PACKAGE_check_version() if(FFMPEG_PACKAGE_VERSION_OK) set(AVFORMAT_VERSION FFMPEG_PACKAGE_VERSION) endif(FFMPEG_PACKAGE_VERSION_OK) # LIBAVUTIL set(PACKAGE_NAME "LIBAVUTIL") set(PACKAGE_INCLUDE_DIR "${FFMPEG_INCLUDE_DIR}/libavutil") set(FFMPEG_PACKAGE_FIND_VERSION _avutil_ver) _FFMPEG_PACKAGE_check_version() if(FFMPEG_PACKAGE_VERSION_OK) set(AVUTIL_VERSION FFMPEG_PACKAGE_VERSION) endif(FFMPEG_PACKAGE_VERSION_OK) # LIBSWSCALE set(PACKAGE_NAME "LIBSWSCALE") set(PACKAGE_INCLUDE_DIR "${FFMPEG_INCLUDE_DIR}/libswscale") set(FFMPEG_PACKAGE_FIND_VERSION _swscale_ver) _FFMPEG_PACKAGE_check_version() if(FFMPEG_PACKAGE_VERSION_OK) set(SWSCALE_VERSION FFMPEG_PACKAGE_VERSION) endif(FFMPEG_PACKAGE_VERSION_OK) endif () find_library(FFMPEG_LIBAVCODEC NAMES avcodec libavcodec PATHS ${AVCODEC_LIBRARY_DIRS} ${CMAKE_INSTALL_PREFIX}/lib /usr/lib /usr/local/lib /opt/local/lib /sw/lib ) find_library(FFMPEG_LIBAVDEVICE NAMES avdevice libavdevice PATHS ${AVDEVICE_LIBRARY_DIRS} ${CMAKE_INSTALL_PREFIX}/lib /usr/lib /usr/local/lib /opt/local/lib /sw/lib ) find_library(FFMPEG_LIBAVFORMAT NAMES avformat libavformat PATHS ${AVFORMAT_LIBRARY_DIRS} ${CMAKE_INSTALL_PREFIX}/lib /usr/lib /usr/local/lib /opt/local/lib /sw/lib ) find_library(FFMPEG_LIBAVUTIL NAMES avutil libavutil PATHS ${AVUTIL_LIBRARY_DIRS} ${CMAKE_INSTALL_PREFIX}/lib /usr/lib /usr/local/lib /opt/local/lib /sw/lib ) find_library(FFMPEG_LIBSWSCALE NAMES swscale libswscale PATHS ${SWSCALE_LIBRARY_DIRS} ${CMAKE_INSTALL_PREFIX}/lib /usr/lib /usr/local/lib /opt/local/lib /sw/lib ) #Only set FFMPEG to found if all the libraries are found in the right versions. if(AVCODEC_VERSION AND AVDEVICE_VERSION AND AVFORMAT_VERSION AND AVUTIL_VERSION AND SWSCALE_VERSION AND FFMPEG_LIBAVCODEC AND FFMPEG_LIBAVDEVICE AND FFMPEG_LIBAVFORMAT AND FFMPEG_LIBAVUTIL AND FFMPEG_LIBSWSCALE) set(FFMPEG_FOUND TRUE) endif() if (FFMPEG_FOUND) set(FFMPEG_LIBRARIES ${FFMPEG_LIBAVCODEC} ${FFMPEG_LIBAVDEVICE} ${FFMPEG_LIBAVFORMAT} ${FFMPEG_LIBAVUTIL} ${FFMPEG_LIBSWSCALE} ) endif (FFMPEG_FOUND) if (FFMPEG_FOUND) if (NOT FFMPEG_FIND_QUIETLY) message(STATUS "Found FFMPEG: ${FFMPEG_LIBRARIES}, ${FFMPEG_INCLUDE_DIR}") endif (NOT FFMPEG_FIND_QUIETLY) else (FFMPEG_FOUND) message(STATUS "Could not find up to date FFMPEG for INDI Webcam. Up to date versions of these packages are required: libavcodec, libavdevice, libavformat, libavutil, and libswscale") if (FFMPEG_FIND_REQUIRED) message(FATAL_ERROR "Error: FFMPEG is required by this package!") endif (FFMPEG_FIND_REQUIRED) endif (FFMPEG_FOUND) endif (FFMPEG_LIBRARIES AND FFMPEG_INCLUDE_DIR) libfishcamp-1.2+20220607003151/cmake_modules/FindIconv.cmake0000644000175100017510000000426114174600255022135 0ustar debiandebian# # Copyright (C) 2010 Michael Bell # 2015-2016 MariaDB Corporation AB # # Redistribution and use is allowed according to the terms of the New # BSD license. # For details see the COPYING-CMAKE-SCRIPTS file. # # ICONV_EXTERNAL - Iconv is an external library (not libc) # ICONV_FOUND - system has Iconv # ICONV_INCLUDE_DIR - the Iconv include directory # ICONV_LIBRARIES - Link these to use Iconv # ICONV_SECOND_ARGUMENT_IS_CONST - the second argument for iconv() is const # ICONV_VERSION - Iconv version string if (ICONV_INCLUDE_DIR AND ICONV_LIBRARIES) # Already in cache, be silent set(ICONV_FIND_QUIETLY TRUE) endif (ICONV_INCLUDE_DIR AND ICONV_LIBRARIES) find_path(ICONV_INCLUDE_DIR iconv.h) IF(CMAKE_SYSTEM_NAME MATCHES "SunOS") # There is some libiconv.so in /usr/local that must # be avoided, iconv routines are in libc ELSEIF(APPLE) find_library(ICONV_LIBRARIES NAMES iconv libiconv PATHS /usr/lib/ NO_CMAKE_SYSTEM_PATH) SET(ICONV_EXTERNAL TRUE) ELSE() find_library(ICONV_LIBRARIES NAMES iconv libiconv libiconv-2) IF(ICONV_LIBRARIES) SET(ICONV_EXTERNAL TRUE) ENDIF() ENDIF() if (ICONV_INCLUDE_DIR AND ICONV_LIBRARIES) set (ICONV_FOUND TRUE) endif (ICONV_INCLUDE_DIR AND ICONV_LIBRARIES) set(CMAKE_REQUIRED_INCLUDES ${ICONV_INCLUDE_DIR}) IF(ICONV_EXTERNAL) set(CMAKE_REQUIRED_LIBRARIES ${ICONV_LIBRARIES}) ENDIF() if (ICONV_FOUND) include(CheckCSourceCompiles) CHECK_C_SOURCE_COMPILES(" #include int main(){ iconv_t conv = 0; const char* in = 0; size_t ilen = 0; char* out = 0; size_t olen = 0; iconv(conv, &in, &ilen, &out, &olen); return 0; } " ICONV_SECOND_ARGUMENT_IS_CONST ) endif (ICONV_FOUND) set (CMAKE_REQUIRED_INCLUDES) set (CMAKE_REQUIRED_LIBRARIES) if (ICONV_FOUND) if (NOT ICONV_FIND_QUIETLY) message (STATUS "Found Iconv: ${ICONV_LIBRARIES}") endif (NOT ICONV_FIND_QUIETLY) else (ICONV_FOUND) if (Iconv_FIND_REQUIRED) message (FATAL_ERROR "Could not find Iconv") endif (Iconv_FIND_REQUIRED) endif (ICONV_FOUND) MARK_AS_ADVANCED( ICONV_INCLUDE_DIR ICONV_LIBRARIES ICONV_EXTERNAL ICONV_SECOND_ARGUMENT_IS_CONST ) libfishcamp-1.2+20220607003151/cmake_modules/FindLIMESUITE.cmake0000644000175100017510000000301214174600255022410 0ustar debiandebian# - Try to find LIMESUITE # Once done this will define # # LIMESUITE_FOUND - system has LIMESUITE # LIMESUITE_INCLUDE_DIR - the LIMESUITE include directory # LIMESUITE_LIBRARIES - Link these to use LIMESUITE # LIMESUITE_VERSION_STRING - Human readable version number of rtlsdr # LIMESUITE_VERSION_MAJOR - Major version number of rtlsdr # LIMESUITE_VERSION_MINOR - Minor version number of rtlsdr # Copyright (c) 2017, Ilia Platone, # Based on FindLibfacile by Carsten Niehaus, # # Redistribution and use is allowed according to the terms of the BSD license. # For details see the accompanying COPYING-CMAKE-SCRIPTS file. if (LIMESUITE_LIBRARIES) # in cache already set(LIMESUITE_FOUND TRUE) message(STATUS "Found LIMESUITE: ${LIMESUITE_LIBRARIES}") else (LIMESUITE_LIBRARIES) find_library(LIMESUITE_LIBRARIES NAMES LimeSuite PATHS ${_obLinkDir} ${GNUWIN32_DIR}/lib /usr/local/lib ) if(LIMESUITE_LIBRARIES) set(LIMESUITE_FOUND TRUE) else (LIMESUITE_LIBRARIES) set(LIMESUITE_FOUND FALSE) endif(LIMESUITE_LIBRARIES) if (LIMESUITE_FOUND) if (NOT LIMESUITE_FIND_QUIETLY) message(STATUS "Found LIMESUITE: ${LIMESUITE_LIBRARIES}") endif (NOT LIMESUITE_FIND_QUIETLY) else (LIMESUITE_FOUND) if (LIMESUITE_FIND_REQUIRED) message(FATAL_ERROR "LIMESUITE not found. Please install libLimeSuite-dev") endif (LIMESUITE_FIND_REQUIRED) endif (LIMESUITE_FOUND) mark_as_advanced(LIMESUITE_LIBRARIES) endif (LIMESUITE_LIBRARIES) libfishcamp-1.2+20220607003151/cmake_modules/FindOMEGONPROCAM.cmake0000644000175100017510000000323314247236061022744 0ustar debiandebian# - Try to find Omegon Pro Cam Camera Library # Once done this will define # # OMEGONPROCAM_FOUND - system has Omegon Pro Cam # OMEGONPROCAM_INCLUDE_DIR - the Omegon Pro Cam include directory # OMEGONPROCAM_LIBRARIES - Link these to use Omegon Pro Cam # Redistribution and use is allowed according to the terms of the BSD license. # For details see the accompanying COPYING-CMAKE-SCRIPTS file. if (OMEGONPROCAM_INCLUDE_DIR AND OMEGONPROCAM_LIBRARIES) # in cache already set(OMEGONPROCAM_FOUND TRUE) message(STATUS "Found libomegonprocam: ${OMEGONPROCAM_LIBRARIES}") else (OMEGONPROCAM_INCLUDE_DIR AND OMEGONPROCAM_LIBRARIES) find_path(OMEGONPROCAM_INCLUDE_DIR omegonprocam.h PATH_SUFFIXES libomegonprocam ${_obIncDir} ${GNUWIN32_DIR}/include ) find_library(OMEGONPROCAM_LIBRARIES NAMES omegonprocam PATHS ${_obLinkDir} ${GNUWIN32_DIR}/lib ) if(OMEGONPROCAM_INCLUDE_DIR AND OMEGONPROCAM_LIBRARIES) set(OMEGONPROCAM_FOUND TRUE) else (OMEGONPROCAM_INCLUDE_DIR AND OMEGONPROCAM_LIBRARIES) set(OMEGONPROCAM_FOUND FALSE) endif(OMEGONPROCAM_INCLUDE_DIR AND OMEGONPROCAM_LIBRARIES) if (OMEGONPROCAM_FOUND) if (NOT OMEGONPROCAM_FIND_QUIETLY) message(STATUS "Found OmegonProCam: ${OMEGONPROCAM_LIBRARIES}") endif (NOT OMEGONPROCAM_FIND_QUIETLY) else (OMEGONPROCAM_FOUND) if (OMEGONPROCAM_FIND_REQUIRED) message(FATAL_ERROR "OmegonProCam not found. Please install OmegonProCam Library http://www.indilib.org") endif (OMEGONPROCAM_FIND_REQUIRED) endif (OMEGONPROCAM_FOUND) mark_as_advanced(OMEGONPROCAM_INCLUDE_DIR OMEGONPROCAM_LIBRARIES) endif (OMEGONPROCAM_INCLUDE_DIR AND OMEGONPROCAM_LIBRARIES) libfishcamp-1.2+20220607003151/cmake_modules/FindPLAYERONE.cmake0000644000175100017510000000322114174600255022410 0ustar debiandebian# - Try to find PlayerOne Library # Once done this will define # # PLAYERONE_FOUND - system has PLAYERONE # PLAYERONE_INCLUDE_DIR - the PLAYERONE include directory # PLAYERONE_LIBRARIES - Link these to use ASI # Redistribution and use is allowed according to the terms of the BSD license. # For details see the accompanying COPYING-CMAKE-SCRIPTS file. if (PLAYERONE_INCLUDE_DIR AND PLAYERONE_LIBRARIES) # in cache already set(PLAYERONE_FOUND TRUE) message(STATUS "Found libplayerone: ${PLAYERONE_LIBRARIES}") else (PLAYERONE_INCLUDE_DIR AND PLAYERONE_LIBRARIES) find_path(PLAYERONE_INCLUDE_DIR PlayerOneCamera.h PATH_SUFFIXES libplayerone ${_obIncDir} ${GNUWIN32_DIR}/include ) find_library(PLAYERONECAM_LIBRARIES NAMES PlayerOneCamera PATHS ${_obLinkDir} ${GNUWIN32_DIR}/lib ) if (PLAYERONECAM_LIBRARIES) set(PLAYERONE_LIBRARIES ${PLAYERONECAM_LIBRARIES}) endif (PLAYERONECAM_LIBRARIES) if(PLAYERONE_INCLUDE_DIR AND PLAYERONE_LIBRARIES) set(PLAYERONE_FOUND TRUE) else (PLAYERONE_INCLUDE_DIR AND PLAYERONE_LIBRARIES) set(PLAYERONE_FOUND FALSE) endif(PLAYERONE_INCLUDE_DIR AND PLAYERONE_LIBRARIES) if (PLAYERONE_FOUND) if (NOT PLAYERONE_FIND_QUIETLY) message(STATUS "Found PLAYERONE: ${PLAYERONE_LIBRARIES}") endif (NOT PLAYERONE_FIND_QUIETLY) else (PLAYERONE_FOUND) if (PLAYERONE_FIND_REQUIRED) message(FATAL_ERROR "PLAYERONE not found. Please install libPlayerOneCamera.2 http://www.indilib.org") endif (PLAYERONE_FIND_REQUIRED) endif (PLAYERONE_FOUND) mark_as_advanced(PLAYERONE_INCLUDE_DIR PLAYERONE_LIBRARIES) endif (PLAYERONE_INCLUDE_DIR AND PLAYERONE_LIBRARIES) libfishcamp-1.2+20220607003151/cmake_modules/FindNNCAM.cmake0000644000175100017510000000256314174600255021716 0ustar debiandebian# - Try to find NNCAM Camera Library # Once done this will define # # NNCAM_FOUND - system has Levenhuk # NNCAM_INCLUDE_DIR - the Levenhuk include directory # NNCAM_LIBRARIES - Link these to use Levenhuk # Redistribution and use is allowed according to the terms of the BSD license. # For details see the accompanying COPYING-CMAKE-SCRIPTS file. if (NNCAM_INCLUDE_DIR AND NNCAM_LIBRARIES) # in cache already set(NNCAM_FOUND TRUE) message(STATUS "Found libnncam: ${NNCAM_LIBRARIES}") else (NNCAM_INCLUDE_DIR AND NNCAM_LIBRARIES) find_path(NNCAM_INCLUDE_DIR nncam.h PATH_SUFFIXES libnncam ${_obIncDir} ${GNUWIN32_DIR}/include ) find_library(NNCAM_LIBRARIES NAMES nncam PATHS ${_obLinkDir} ${GNUWIN32_DIR}/lib ) if(NNCAM_INCLUDE_DIR AND NNCAM_LIBRARIES) set(NNCAM_FOUND TRUE) else (NNCAM_INCLUDE_DIR AND NNCAM_LIBRARIES) set(NNCAM_FOUND FALSE) endif(NNCAM_INCLUDE_DIR AND NNCAM_LIBRARIES) if (NNCAM_FOUND) if (NOT NNCAM_FIND_QUIETLY) message(STATUS "Found NNCAM: ${NNCAM_LIBRARIES}") endif (NOT NNCAM_FIND_QUIETLY) else (NNCAM_FOUND) if (NNCAM_FIND_REQUIRED) message(FATAL_ERROR "NNCAM not found. Please install NNCAM Library http://www.indilib.org") endif (NNCAM_FIND_REQUIRED) endif (NNCAM_FOUND) mark_as_advanced(NNCAM_INCLUDE_DIR NNCAM_LIBRARIES) endif (NNCAM_INCLUDE_DIR AND NNCAM_LIBRARIES) libfishcamp-1.2+20220607003151/cmake_modules/FindRT.cmake0000644000175100017510000000152514174600255021404 0ustar debiandebian# FindRT.cmake - Try to find the RT library # Once done this will define # # RT_FOUND - System has rt # RT_INCLUDE_DIR - The rt include directory # RT_LIBRARIES - The libraries needed to use rt # RT_DEFINITIONS - Compiler switches required for using rt # # Also creates an import target called RT::RT find_path (RT_INCLUDE_DIR NAMES time.h PATHS /usr /usr/local /opt PATH_SUFFIXES ) find_library(RT_LIBRARIES NAMES rt PATHS /usr /usr/local /opt ) include(FindPackageHandleStandardArgs) FIND_PACKAGE_HANDLE_STANDARD_ARGS(rt DEFAULT_MSG RT_LIBRARIES RT_INCLUDE_DIR) mark_as_advanced(RT_INCLUDE_DIR RT_LIBRARIES) if (NOT TARGET RT::RT) add_library(RT::RT INTERFACE IMPORTED) set_target_properties(RT::RT PROPERTIES INTERFACE_INCLUDE_DIRECTORIES ${RT_INCLUDE_DIR} INTERFACE_LINK_LIBRARIES ${RT_LIBRARIES} ) endif()libfishcamp-1.2+20220607003151/fishcamp.h0000644000175100017510000003755414174600256016423 0ustar debiandebian/* Copyright (c) 2001-2013 Fishcamp Engineering (support@fishcamp.com) All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. Modified by: Jasem Mutlaq (2013) THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ====================================================================== */ #ifndef FISHCAMP_H #define FISHCAMP_H #include #include #include #include #include #include #include "fishcamp_common.h" // list of USB command codes typedef enum { fcNOP, fcRST, fcGETINFO, fcSETREG, fcGETREG, fcSETINTTIME, fcSTARTEXP, fcABORTEXP, fcGETSTATE, fcSETFGTP, fcRDSCANLINE, fcGETIMAGESTATS, fcSETROI, fcSETBIN, fcSETRELAY, fcCLRRELAY, fcPULSERELAY, fcSETLED, fcSETTEMP, fcGETTEMP, fcGETRAWFRAME, fcTURNOFFTEC, fcSETREADMODE, fcSETGAIN, fcSETOFFSET, fcSETGUIDEINTTIME, fcSTARTGUIDEEXP, fcABORTGUIDEEXP, fcGETGUIDESTATE, fcGETPEDESTAL, fcSETREG32, fcGETREG32, fcSETPROPERTY, fcGETPROPERTY } fc_cmd; // progress codes for the fcUsb_FindCameras routine typedef enum { fcFindCam_notYetStarted, fcFindCam_looking4supported, // @"Looking for supported cameras" fcFindCam_initializingUSB, // @"Initializing camera USB controller" fcFindCam_initializingIP, // @"Initializing camera Image Processor" fcFindCam_finished // @"Done looking for supported cameras" } fcFindCamState; // structure used to hold the return information from the fcGETINFO command typedef struct { UInt16 boardVersion; UInt16 boardRevision; UInt16 fpgaVersion; UInt16 fpgaRevision; UInt16 width; UInt16 height; UInt16 pixelWidth; UInt16 pixelHeight; UInt8 camSerialStr[32]; // 'C' string format UInt8 camNameStr[32]; // 'C' string format } fc_camInfo; // list of relays typedef enum { fcRELAYNORTH, fcRELAYSOUTH, fcRELAYWEST, fcRELAYEAST } fc_relay; // list of data formats typedef enum { fc_8b_data, fc_10b_data, fc_12b_data, fc_14b_data, fc_16b_data } fc_dataFormat; // list of data transfer modes typedef enum { fc_classicDataXfr, fc_DMAwFBDataXfr, fc_DMASensor2USBDataXfr } fc_dataXfrModes; // list of image filters typedef enum { fc_filter_none, fc_filter_3x3, fc_filter_5x5, fc_filter_hotPixel } fc_imageFilter; // properties that we have defined so far. First camera that // supports properties is the StarfishPRO 4M with the KAI-04022 chip typedef enum { fcPROP_NUMSAMPLES, fcPROP_PATTERNENABLE, fcPROP_PIXCAPTURE, fcPROP_SHUTTERMODE, fcPROP_MOVESHUTTERFLAG, fcPROP_COLNORM, // not available to the end user fcPROP_SERVOOPENPOS, // not available to the end user fcPROP_SERVOCLOSEDPOS // not available to the end user } fc_property; void Starfish_LogFmt(const char *fmt, ...); void Starfish_Log(const char *logString); #ifdef __cplusplus extern "C" { // only need to export C interface if used by C++ source code #endif // This is the framework initialization routine and needs to be called once upon application startup void fcUsb_init(void); // Call this routine to enable / disable entries in the log file // By default, logging is turned on. The log file will be created // in C:\Program Files\fishcamp\starfish_log.txt // // loggingState = true to turn logging on // void fcUsb_setLogging(bool loggingState); // Call this routine to enable simulation mode void fcUsb_setSimulation(bool simState); // This is the framework close routine and needs to be called just before application termination void fcUsb_close(void); // the prefered way of finding and opening a communications link to any of our supported cameras // This routine will call fcUsb_OpenCameraDriver and fcUsb_CloseCameraDriver routines to do its job // // will return the actual number of cameras found. // // be carefull, this routine can take a long time (> 5 secs) to execute // // routine will return the number of supported cameras discovered. // //int fcUsb_FindCameras(struct libusb_context *ctx); int fcUsb_FindCameras(void); // call this routine to know how what state the fcUsb_FindCameras routine is currently executing // will return a result of fcFindCamState type // int fcUsb_GetFindCamsState(void); // call this routine to know how long it will take for the fcUsb_FindCameras routine to complete. // float fcUsb_GetFindCamsPercentComplete(void); // call this routine before making any other calls to this camera // This routine will assign the designated camera to your application // valid camNum is 1 -> fcUsb_GetNumCameras() // int fcUsb_OpenCamera(int camNum); // call this routine after you are finished making calls to this camera // This routine will free the designated camera for other applications to use // valid camNum is 1 -> fcUsb_GetNumCameras() // int fcUsb_CloseCamera(int camNum); // call this routine to know how many of our supported cameras are available for use. // int fcUsb_GetNumCameras(void); // call this routine to see if we have any of our supported cameras attached. // will return TRUE if we have at least one supported camera. // bool fcUsb_haveCamera(void); // return the numeric serial number of the camera specified. // valid camNum is 1 -> fcUsb_GetNumCameras() // int fcUsb_GetCameraSerialNum(int camNum); // return the numeric vendorID of the camera specified. // valid camNum is 1 -> fcUsb_GetNumCameras() // int fcUsb_GetCameraVendorID(int camNum); // return the numeric productID of the camera specified. // valid camNum is 1 -> fcUsb_GetNumCameras() // int fcUsb_GetCameraProductID(int camNum); int fcUsb_cmd_nop(int camNum); // send the rst command to the starfish camera // int fcUsb_cmd_rst(int camNum); // send the fcGETINFO command to the starfish camera // read the return information // int fcUsb_cmd_getinfo(int camNum, fc_camInfo *camInfo); // // call to set a low level register in the camera // // for Starfish camera: // - call to set a low level register in the micron image sensor // - enter with the micron address register, and register data value // refer to the micron image sensor documentation for details // on available registers and bit definitions // // for IBIS1300 // - call to set the serial configuration word on the camera // - enter with regAddress = 0, dataValue // // valid camNum is 1 -> fcUsb_GetNumCameras() // int fcUsb_cmd_setRegister(int camNum, UInt16 regAddress, UInt16 dataValue); // // call to get a low level register from the micron image sensor // valid camNum is 1 -> fcUsb_GetNumCameras() // refer to the micron image sensor documentation for details // on available registers and bit definitions // // not a valid call for the IBIS1300 camera // UInt16 fcUsb_cmd_getRegister(int camNum, UInt16 regAddress); // call to set the integration time register. // valid camNum is 1 -> fcUsb_GetNumCameras() // 'theTime' specifies the number of milliseconds desired for the integration. // only 22 LSB significant giving a range of 0.001 -> 4194 seconds // the starfish only has a range of 0.001 -> 300 seconds // // This command is valid for both the Starfish and IBIS1300 cameras. // When sent to the IBIS1300 camera, it defines the integration time of // the main imager portion of the sensor. // int fcUsb_cmd_setIntegrationTime(int camNum, UInt32 theTime); // command to set the integration time period of the guider portion of // the IBIS1300 image sensor. This command is not recognized by the Starfish camera // int fcUsb_cmd_setGuiderIntegrationTime(int camNum, UInt32 theTime); // send the 'start exposure' command to the camera // // when sent to the IBIS1300 camera, the command start and exposure // with the main imager section of the chip. // // valid camNum is 1 -> fcUsb_GetNumCameras() // int fcUsb_cmd_startExposure(int camNum); // send the 'start exposure' command to the guider portion of the // IBIS1300 image sensor. This command is not recognized by the Starfish camera // int fcUsb_cmd_startGuiderExposure(int camNum); // send the 'abort exposure' command to the camera // int fcUsb_cmd_abortExposure(int camNum); // send the 'abort Guider exposure' command to the camera // This command is not recognized by the Starfish camera // // valid camNum is 1 -> fcUsb_GetNumCameras() // int fcUsb_cmd_abortGuiderExposure(int camNum); // send a command to get the current camera state // UInt16 fcUsb_cmd_getState(int camNum); // send a command to get the current camera state of the guider sensor // This command is not recognized by the Starfish camera // // valid camNum is 1 -> fcUsb_GetNumCameras() // return values are: // 0 - idle // 1 - integrating // 2 - processing image // UInt16 fcUsb_cmd_getGuiderState(int camNum); // turn on/off the frame grabber's test pattern generator // 0 = off, 1 = on // int fcUsb_cmd_setFrameGrabberTestPattern(int camNum, UInt16 state); // here to read a specific scan line from the camera's frame grabber buffer // int fcUsb_cmd_rdScanLine(int camNum, UInt16 lineNum, UInt16 Xmin, UInt16 Xmax, UInt16 *lineBuffer); // here to specify a new ROI to the sensor // X = 0 -> 2047 // Y = 0 -> 1535 // // This command is not supported by the IBIS1300 camera // int fcUsb_cmd_setRoi(int camNum, UInt16 left, UInt16 top, UInt16 right, UInt16 bottom); // set the binning mode of the camera. Valid binModes are 1, 2, 3 // valid camNum is 1 -> fcUsb_GetNumCameras() // This command is not supported by the current starfish camera // int fcUsb_cmd_setBin(int camNum, UInt16 binMode); // turn on one of the relays on the camera. whichRelay is one of enum fc_relay // int fcUsb_cmd_setRelay(int camNum, int whichRelay); // turn off one of the relays on the camera. whichRelay is one of enum fc_relay // int fcUsb_cmd_clearRelay(int camNum, int whichRelay); // generate a pulse on one of the relays on the camera. whichRelay is one of enum fc_relay. // pulse width parameters are in mS. you can specify the hi and lo period of the pulse. // if 'repeats' is true then the pulse will loop. // call this routine with 'onMs' = 0 to abort any pulse operation in progress // int fcUsb_cmd_pulseRelay(int camNum, int whichRelay, int onMs, int offMs, bool repeats); // Tell the camera what temperature setpoint to use for the TEC controller // this will also turn on cooling to the camera. // // Specify the temperature with a signed integer that is 100x the actual // temperature required. This allows us to represent a temperature with // 2 decimal places of accuracy while still passing an integer value. // int fcUsb_cmd_setTemperature(int camNum, SInt16 theTemp); // Get the temperature of the image sensor. // // Will return a signed integer that is 100x the actual sensor temperature. // This allows us to represent a temperature with 2 decimal places of // accuracy while still passing an integer value. // SInt16 fcUsb_cmd_getTemperature(int camNum); // will return a number from 0 -> 100; To be interpreted as a percent. // UInt16 fcUsb_cmd_getTECPowerLevel(int camNum); // will return TRUE if the TEC power cable is plugged into the camera // bool fcUsb_cmd_getTECInPowerOK(int camNum); // command camera to turn off the TEC cooler // int fcUsb_cmd_turnOffCooler(int camNum); // here to read an entire frame in RAW format // int fcUsb_cmd_getRawFrame(int camNum, UInt16 numRows, UInt16 numCols, UInt16 *frameBuffer); // only the 'fc_classicDataXfr' data transfer mode is supported on the PC platform. // here to define some image readout modes of the camera. The state of these bits will be // used during the call to fcUsb_cmd_startExposure. When an exposure is started and subsequent // image readout is begun, the camera will assume an implied fcUsb_cmd_getRawFrame command // when the 'DataXfrReadMode' is a '1' or '2' and begin uploading pixel data to the host as the image // is being read from the sensor. // // DataFormat can be one of 8, 10, 12, 14, 16 // 8 - packed into a single byte // others - packed into a 16 bit word // int fcUsb_cmd_setReadMode(int camNum, int DataXfrReadMode, int DataFormat); // set some register defaults for the starfish camera void fcUsb_setStarfishDefaultRegs(int camNum); // here to set the analog gain on the camera. // // theGain - the gain number desired. // // Valid gains are between 0 and 15. For the IBIS camera this corresponds to 1.28 to 17.53 as per the sensor data sheet // int fcUsb_cmd_setCameraGain(int camNum, UInt16 theGain); // here to set the analog offset on the camera. // // theOffset - the offset number desired. // // Valid offsets are between 0 and 15. // int fcUsb_cmd_setCameraOffset(int camNum, UInt16 theOffset); // here to set the filter type used for image processing // The specified filter will be performed on any images // transferred from the camera. // // 'theImageFilter' is one of fc_imageFilter // void fcUsb_cmd_setImageFilter(int camNum, int theImageFilter); // call to get the black level pedestal of the image sensor. This is usefull if you wish // to subtract out the pedestal from the image returned from the camera. // // the return value will be scalled according to the currently set fc_dataFormat. See the // fcUsb_cmd_setReadMode routine for information on the pixel format // UInt16 fcUsb_cmd_getBlackPedestal(int camNum); // call this routine to set a camera property. Various cameras support different properties // the following properties are defined: // // 1) fcPROP_NUMSAMPLES - enter with 'propertyValue' set to the number desired. Valid // numbers are binary numbers starting with 4 (4, 8, 16, 32, 64, 128) // // 2) fcPROP_PATTERNENABLE - enter with 'propertyValue' set to '1' to enable the frame grabber // pattern generator. '0' to get true sensor data // // 3) fcPROP_PIXCAPTURE - enter with 'propertyValue' set to '0' for normal CDS pixel sampling, // '1' for pixel level only and '2' for reset level only. // // 4) fcPROP_SHUTTERMODE - enter with 'propertyValue' set to '0' for AUTOMATIC shutter, // '1' for MANUAL shutter. // // 5) fcPROP_SHUTTERPRIORITY - enter with 'propertyValue' set to '0' for MECHANICAL shutter priority, // '1' for ELECTRONIC shutter priority // // 6) fcPROP_MOVESHUTTERFLAG = enter with 'propertyValue' set to '0' to CLOSE the mechanical shutter, // '1' to OPEN the mechanical shutter // // 7) fcPROP_COLNORM - enter with 'propertyValue' set to '0' for no column level normalization // '1' for column level normalization. // // 8) fcPROP_SERVOOPENPOS - enter with 'propertyValue' set to servo pulse period used for the OPEN position // // 9) fcPROP_SERVOCLOSEDPOS - enter with 'propertyValue' set to servo pulse period used for the CLOSED position // // void fcUsb_cmd_setCameraProperty(int camNum, int propertyType, int propertyValue); #ifdef __cplusplus } #endif #endif // FISHCAMP_H libfishcamp-1.2+20220607003151/fishcamp_common.h0000644000175100017510000001650214174600256017761 0ustar debiandebian/* Copyright (c) 2001-2013 Fishcamp Engineering (support@fishcamp.com) All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ====================================================================== */ #ifndef FISHCAMP_COMMON #define FISHCAMP_COMMON #include typedef unsigned char UInt8; typedef signed char SInt8; typedef unsigned short UInt16; typedef signed short SInt16; typedef unsigned long UInt32; typedef signed long SInt32; // USB ID codes follow #define fishcamp_USB_VendorID 0x1887 // defines for prototype starfish guide camera #define starfish_mono_proto_raw_deviceID 0x0001 #define starfish_mono_proto_final_deviceID 0x0000 // defines for prototype starfish guide camera w/ DMA logic #define starfish_mono_proto2_raw_deviceID 0x0004 #define starfish_mono_proto2_final_deviceID 0x0005 // defines for REV2 (production) starfish guide camera #define starfish_mono_rev2_raw_deviceID 0x0002 #define starfish_mono_rev2_final_deviceID 0x0003 // defines for IBIS Imager camera #define starfish_ibis13_raw_deviceID 0x0006 #define starfish_ibis13_final_deviceID 0x0007 // defines for Starfish PRO 4M Imager camera #define starfish_pro4m_raw_deviceID 0x0008 #define starfish_pro4m_final_deviceID 0x0009 #define kNumCamsSupported 8 #define FC_STARFISH_BULK_OUT_ENDPOINT 0x02 #define FC_STARFISH_BULK_IN_ENDPOINT 0x86 //structure used for command only messages that don't have any parameters typedef struct { UInt16 header; UInt16 command; UInt16 length; UInt16 cksum; } fc_no_param; // structure used when calling the low level set register command typedef struct{ UInt16 header; UInt16 command; UInt16 length; UInt16 registerAddress; UInt16 dataValue; UInt16 cksum; } fc_setReg_param; // structure used when calling the low level get register command typedef struct{ UInt16 header; UInt16 command; UInt16 length; UInt16 registerAddress; UInt16 cksum; } fc_getReg_param; // structure used to hold the return information from the fcGETREG command typedef struct{ UInt16 header; UInt16 command; UInt16 dataValue; } fc_regInfo; // structure used when calling the fcSETINTTIME command typedef struct{ UInt16 header; UInt16 command; UInt16 length; UInt16 timeHi; UInt16 timeLo; UInt16 cksum; } fc_setIntTime_param; // structure used when calling the fcSETFGTP command typedef struct{ UInt16 header; UInt16 command; UInt16 length; UInt16 state; UInt16 cksum; } fc_setFgTp_param; // structure used when calling the fcRDSCANLINE command typedef struct{ UInt16 header; UInt16 command; UInt16 length; UInt16 LineNum; UInt16 padZero; UInt16 Xmin; UInt16 Xmax; UInt16 cksum; } fc_rdScanLine_param; // structure used to hold the return information from the fcRDSCANLINE command typedef struct{ UInt16 header; UInt16 command; UInt16 LineNum; UInt16 padZero; UInt16 Xmin; UInt16 Xmax; UInt16 lineBuffer[2048]; } fc_scanLineInfo; // structure used when calling the fcSETROI command typedef struct{ UInt16 header; UInt16 command; UInt16 length; UInt16 left; UInt16 top; UInt16 right; UInt16 bottom; UInt16 cksum; } fc_setRoi_param; // structure used when calling the fcSETBIN command typedef struct{ UInt16 header; UInt16 command; UInt16 length; UInt16 binMode; UInt16 cksum; } fc_setBin_param; // structure used when calling the fcSETRELAY command typedef struct{ UInt16 header; UInt16 command; UInt16 length; UInt16 relayNum; UInt16 cksum; } fc_setClrRelay_param; // structure used when calling the fcPULSERELAY command typedef struct{ UInt16 header; UInt16 command; UInt16 length; UInt16 relayNum; UInt16 highPulseWidth; UInt16 lowPulseWidth; UInt16 repeats; UInt16 cksum; } fc_pulseRelay_param; // structure used to hold the return information from the fcGETTEMP command typedef struct{ UInt16 header; UInt16 command; SInt16 tempValue; UInt16 TECPwrValue; UInt16 TECInPwrOK; } fc_tempInfo; // structure used when calling the fcSETTEMP command typedef struct{ UInt16 header; UInt16 command; UInt16 length; SInt16 theTemp; UInt16 cksum; } fc_setTemp_param; // structure used when calling the fcSETREADMODE command typedef struct{ UInt16 header; UInt16 command; UInt16 length; SInt16 ReadBlack; UInt16 DataXfrReadMode; UInt16 DataFormat; SInt16 AutoOffsetCorrection; UInt16 cksum; } fc_setReadMode_param; // structure used to store information about any cameras that were detected by the application typedef struct { UInt16 camVendor; // FC vendor ID UInt16 camRawProduct; // RAW, uninitialized camera ID UInt16 camFinalProduct; // initialized camera ID UInt16 camRelease; // camera serial number // CCyUSBDevice **camUsbIntfc; // handle to this camera struct libusb_device_handle *dev; // handle to this camera } fc_Camera_Information; // structure used when calling the fcSETGAIN command typedef struct{ UInt16 header; UInt16 command; UInt16 length; UInt16 theGain; UInt16 cksum; } fc_setGain_param; // structure used when calling the fcSETOFFSET command typedef struct{ UInt16 header; UInt16 command; UInt16 length; UInt16 theOffset; UInt16 cksum; } fc_setOffset_param; // structure used to hold the return information from the fcGETPEDESTAL command typedef struct{ UInt16 header; UInt16 command; UInt16 dataValue; } fc_blackPedestal; // structure used for the fcSETPROPERTY command typedef struct{ UInt16 header; UInt16 command; UInt16 length; UInt16 propertyType; UInt16 propertyValue; UInt16 cksum; } fc_setProperty_param; #define MAX_INTEL_HEX_RECORD_LENGTH 16 typedef struct _INTEL_HEX_RECORD { UInt32 Length; UInt32 Address; UInt32 Type; UInt8 Data[MAX_INTEL_HEX_RECORD_LENGTH]; } INTEL_HEX_RECORD, *PINTEL_HEX_RECORD; #define k8051_USBCS 0xE600 #endif // FISHCAMP_COMMON libfishcamp-1.2+20220607003151/CMakeLists.txt0000644000175100017510000000332714243553450017207 0ustar debiandebiancmake_minimum_required(VERSION 3.0) PROJECT(libfishcamp C CXX) #*********************************************************** LIST(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake_modules/") LIST(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/../cmake_modules/") include(GNUInstallDirs) find_package(INDI REQUIRED) include_directories( ${INDI_INCLUDE_DIR}) IF(APPLE) set(FIRMWARE_INSTALL_DIR "/usr/local/lib/indi/DriverSupport/fishcamp") ##This one is needed for homebrew include_directories( "/usr/local/include") ## This one is needed for Craft include_directories("${CMAKE_INSTALL_PREFIX}/include") ELSE(APPLE) set(FIRMWARE_INSTALL_DIR "/lib/firmware" CACHE STRING "libfishcamp firmware installation dir") set(UDEVRULES_INSTALL_DIR "/lib/udev/rules.d" CACHE STRING "Base directory for udev rules") ENDIF(APPLE) #*********************************************************** find_package(USB1 REQUIRED) ADD_DEFINITIONS(-Wno-multichar) set(LIBFISHCAMP_VERSION "1.1") set(LIBFISHCAMP_SOVERSION "1") set(fishcamp_LIB_SRCS fishcamp.c) SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wno-error") SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-error") #build a shared library ADD_LIBRARY(fishcamp SHARED ${fishcamp_LIB_SRCS}) set_target_properties(fishcamp PROPERTIES VERSION ${LIBFISHCAMP_VERSION} SOVERSION ${LIBFISHCAMP_SOVERSION}) target_link_libraries(fishcamp ${USB1_LIBRARIES}) INSTALL(FILES fishcamp.h fishcamp_common.h DESTINATION include/libfishcamp) INSTALL(TARGETS fishcamp LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}) install( FILES gdr_usb.hex Guider_mono_rev16_intel.srec DESTINATION ${FIRMWARE_INSTALL_DIR}) IF(NOT APPLE) install(FILES 99-fishcamp.rules DESTINATION ${UDEVRULES_INSTALL_DIR}) ENDIF(NOT APPLE) libfishcamp-1.2+20220607003151/Guider_mono_rev16_intel.srec0000644000175100017510000037635614174600256022031 0ustar debiandebian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libfishcamp-1.2+20220607003151/gdr_usb.hex0000644000175100017510000001606414174600256016604 0ustar debiandebian:0A090F0000010202030304040505C1 :10031900E4F513F512F511F510C203C200C202C2C9 :10032900011204C37E077F008E238F24752B077566 :100339002C1275210775221C752907752A3C752D04 :1003490007752E5CEE54E0700302045D75140075A8 :1003590015808E168F17C374AA9FFF74079ECF242A :1003690002CF3400FEE48F0F8E0EF50DF50CF50B60 :10037900F50AF509F508AF0FAE0EAD0DAC0CAB0BD8 :10038900AA0AA909A808C31206EF5026E515250BE4 :10039900F582E514350AF58374CDF0E50B2401F5F2 :1003A9000BE4350AF50AE43509F509E43508F508D9 :1003B90080C4E4F50BF50AF509F508AF0FAE0EADEB :1003C9000DAC0CAB0BAA0AA909A808C31206EF5079 :1003D90031AE0AAF0BE5172FF582E5163EF583E03E :1003E900FDE5152FF582E5143EF583EDF0EF2401C7 :1003F900F50BE43EF50AE43509F509E43508F50895 :1004090080B985142385152474002480FF7407346A :10041900FFFEC3E52C9FF52CE52B9EF52BC3E526A6 :100429009FF526E5259EF525C3E5289FF528E527AF :100439009EF527C3E5229FF522E5219EF521C3E517 :100449002A9FF52AE5299EF529C3E52E9FF52EE574 :100459002D9EF52DD2E843D82090E668E04409F0B6 :1004690090E65CE0443DF0D2AF90E680E020E10503 :10047900D2041207E390E680E054F7F0538EF8C2F5 :1004890003300105120080C2013003291205FD5015 :1004990024C20312086A20001690E682E030E704BD :1004A900E020E1EF90E682E030E604E020E0E412AB :0A04B900081212093112092D80C744 :1000800090E6B9E0700302015B14700302020424DD :10009000FE700302029924FB7003020155147003E1 :1000A00002014F147003020143147003020149243A :1000B000056003020305120933400302031190E6B1 :1000C000BBE024FE602C14604724FD6016146031F0 :1000D00024067065E52390E6B3F0E52490E6B4F0DD :1000E000020311E52B90E6B3F0E52C90E6B4F002A4 :1000F0000311E52590E6B3F0E52690E6B4F002039F :1001000011E52790E6B3F0E52890E6B4F00203117C :1001100090E6BAE0FF12083EAA06A9077B01EA4969 :10012000600DEE90E6B3F0EF90E6B4F002031190AC :10013000E6A0E04401F002031190E6A0E04401F0E3 :100140000203111208FD0203111209210203111208 :1001500009190203111208EB0203111209354003B9 :1001600002031190E6B8E0247F602B14603C240267 :1001700060030201FAA200E433FF25E0FFA202E4DB :10018000334F90E740F0E4A3F090E68AF090E68BDE :100190007402F0020311E490E740F0A3F090E68AC5 :1001A000F090E68B7402F002031190E6BCE0547EFE :1001B000FF7E00E0D3948040067C007D0180047CBB :1001C000007D00EC4EFEED4F240FF58274093EF5E4 :1001D00083E493FF3395E0FEEF24A1FFEE34E68F36 :1001E00082F583E0540190E740F0E4A3F090E68AC2 :1001F000F090E68B7402F002031190E6A0E0440157 :10020000F0020311120937400302031190E6B8E02F :1002100024FE601D2402600302031190E6BAE0B4DC :100220000105C20002031190E6A0E04401F00203C0 :100230001190E6BAE0705990E6BCE0547EFF7E0073 :10024000E0D3948040067C007D0180047C007D002A :10025000EC4EFEED4F240FF58274093EF583E493D6 :10026000FF3395E0FEEF24A1FFEE34E68F82F583A5 :10027000E054FEF090E6BCE05480FF131313541FCB :10028000FFE0540F2F90E683F0E04420F0020311CA :1002900090E6A0E04401F08078120939507390E6AE :1002A000B8E024FE60202402706790E6BAE0B40152 :1002B00004D200805C90E6BAE06402605490E6A04C :1002C000E04401F0804B90E6BCE0547EFF7E00E00D :1002D000D3948040067C007D0180047C007D00EC8E :1002E0004EFEED4F240FF58274093EF583E493FF33 :1002F0003395E0FEEF24A1FFEE34E68F82F583E034 :100300004401F0800C12093B500790E6A0E0440144 :08031000F090E6A0E04480F04B :0103180022C2 :0300330002092996 :0409290053D8EF327E :1007000012010002000000408718030000000102EF :1007100000010A060002000000400100090220005A :10072000010100A0FA0904000002FF000000070513 :1007300002020002000705860200020009022000F2 :10074000010100A0FA0904000002FF0000000705F3 :10075000020240000007058602400000040309046D :100760002A036600690073006800630061006D0081 :100770007000200065006E00670069006E00650073 :100780006500720069006E0067002003530074006A :100790006100720066006900730068002000430079 :0C07A00061006D00650072006100000047 :1008120090E682E030E004E020E60B90E682E030F1 :10082200E119E030E71590E680E04401F07F147EA4 :0C083200001205AB90E680E054FEF022BE :10086A0090E682E044C0F090E681F0438701000000 :04087A000000002258 :1007E30030040990E680E0440AF0800790E680E058 :1007F3004408F07FDC7E051205AB90E65D74FFF0E4 :0F08030090E65FF05391EF90E680E054F7F0221B :02083E00A90708 :10084000AE2DAF2E8F828E83A3E064037017AD01AF :1008500019ED7001228F828E83E07C002FFDEC3E2B :09086000FEAF0580DF7E007F0081 :01086900226C :1005AB008E188F1990E600E054187012E51924018B :1005BB00FFE43518C313F518EF13F519801590E602 :1005CB0000E05418FFBF100BE51925E0F519E518ED :1005DB0033F518E5191519AE18700215184E60058C :0605EB0012087E80EE22E2 :10087E007400F58690FDA57C05A3E582458370F98D :01088E002247 :03004300020600B2 :03005300020600A2 :1006000002088F000208D5000208BF000208A700F8 :100610000206B8000207AC000205FF0002093D0017 :1006200002093E0002093F000209400002094100A0 :100630000209420002094300020944000209450080 :100640000209460002093D0002094700020948006C :100650000209490002094A0002094B0002094C0044 :1006600002094D0002093D0002093D0002093D005A :1006700002094E0002094F00020950000209510010 :1006800002095200020953000209540002095500F0 :1006900002095600020957000209580002095900D0 :1006A00002095A0002095B0002095C0002095D00B0 :0806B00002095E0002095F006F :1004C30090E600E054E74410F0000000E4F5B27F4A :1004D300207E031205AB00000090E6047480F00058 :1004E30000007402F00000007404F00000007406C1 :1004F300F00000007408F0000000E4F00000009039 :10050300E6017403F000000090E60274E8F00000D6 :100513000090E6037446F000000090E609743FF093 :1005230000000090E61074A0F000000090E611F0C7 :1005330000000090E61274A2F000000090E613742D :1005430020F000000090E61474EAF000000090E64A :10055300157460F000000090E6187411F0000000BC :1005630090E61A740DF000000000000090E691740C :1005730080F0000000F000000090E6247402F00018 :100583000000E490E625F000000090E6707483F02C :10059300000000E4F51BF51C43AF01D200F58075A4 :0805A300B2087F01FE0205AB66 :04092D00E4F5B22219 :0205FD00D32207 :02093100D322CF :02093300D322CD :0809190090E6BAE0F51DD322BF :1008EB0090E740E51DF0E490E68AF090E68B04F08B :0208FB00D32206 :0809210090E6BAE0F51AD322BA :1008FD0090E740E51AF0E490E68AF090E68B04F07C :02090D00D322F3 :02093500D322CB :02093700D322C9 :02093900D322C7 :02093B00D322C5 :10088F00C0E0C083C082D2015391EF90E65D740146 :08089F00F0D082D083D0E032DA :1008BF00C0E0C083C0825391EF90E65D7404F0D026 :0608CF0082D083D0E0326C :1008D500C0E0C083C0825391EF90E65D7402F0D012 :0608E50082D083D0E03256 :1006B800C0E0C083C08290E680E030E70E85212547 :1006C800852226852927852A28800C852925852A9B :1006D800268521278522285391EF90E65D7410F036 :0706E800D082D083D0E03284 :1008A700C0E0C083C082D2035391EF90E65D740825 :0808B700F0D082D083D0E032C2 :1007AC00C0E0C083C08290E680E030E70E85212552 :1007BC00852226852927852A28800C852925852AA6 :1007CC00268521278522285391EF90E65D7420F031 :0707DC00D082D083D0E0328F :0105FF0032C9 :01093D003287 :01093E003286 :01093F003285 :010940003284 :010941003283 :010942003282 :010943003281 :010944003280 :01094500327F :01094600327E :01094700327D :01094800327C :01094900327B :01094A00327A :01094B003279 :01094C003278 :01094D003277 :01094E003276 :01094F003275 :010950003274 :010951003273 :010952003272 :010953003271 :010954003270 :01095500326F :01095600326E :01095700326D :01095800326C :01095900326B :01095A00326A :01095B003269 :01095C003268 :01095D003267 :01095E003266 :01095F003265 :030000000205F105 :0C05F100787FE4F6D8FD75812E02031916 :1006EF00EB9FF5F0EA9E42F0E99D42F0E89C45F061 :0106FF0022D8 :00000001FF libfishcamp-1.2+20220607003151/libfishcamp.spec0000644000175100017510000000445014243553450017602 0ustar debiandebian%define __cmake_in_source_build %{_vpath_builddir} Name: libfishcamp Version:1.9.6.git Release: %(date -u +%%Y%%m%%d%%H%%M%%S)%{?dist} Summary: Instrument Neutral Distributed Interface 3rd party drivers License: LGPLv2 # See COPYRIGHT file for a description of the licenses and files covered URL: https://indilib.org Source0: https://github.com/indilib/indi-3rdparty/archive/master.tar.gz %global debug_package %{nil} %define __find_requires %{nil} BuildRequires: cmake BuildRequires: libfli-devel BuildRequires: libnova-devel BuildRequires: qt5-qtbase-devel BuildRequires: systemd BuildRequires: gphoto2-devel BuildRequires: LibRaw-devel BuildRequires: indi-libs BuildRequires: indi-devel BuildRequires: libtiff-devel BuildRequires: cfitsio-devel BuildRequires: zlib-devel BuildRequires: gsl-devel BuildRequires: libcurl-devel BuildRequires: libjpeg-turbo-devel BuildRequires: fftw-devel BuildRequires: libftdi-devel BuildRequires: gpsd-devel BuildRequires: libdc1394-devel BuildRequires: boost-devel BuildRequires: boost-regex BuildRequires: gmock BuildRequires: pkgconfig(fftw3) BuildRequires: pkgconfig(cfitsio) BuildRequires: pkgconfig(libcurl) BuildRequires: pkgconfig(gsl) BuildRequires: pkgconfig(libjpeg) BuildRequires: pkgconfig(libusb-1.0) BuildRequires: pkgconfig(zlib) %description INDI is a distributed control protocol designed to operate astronomical instrumentation. INDI is small, flexible, easy to parse, and scalable. It supports common DCS functions such as remote control, data acquisition, monitoring, and a lot more. This is a 3rd party driver. %prep -v %autosetup -v -p1 -n indi-3rdparty-master %build # This package tries to mix and match PIE and PIC which is wrong and will # trigger link errors when LTO is enabled. # Disable LTO %define _lto_cflags %{nil} cd libfishcamp %cmake . make VERBOSE=1 %{?_smp_mflags} -j4 %install cd libfishcamp find %buildroot -type f \( -name '*.so' -o -name '*.so.*' \) -exec chmod 755 {} + make DESTDIR=%{buildroot} install %files %{_libdir}/* %{_includedir}/libfishcamp /lib/firmware/Guider_mono_rev16_intel.srec /lib/firmware/gdr_usb.hex /lib/udev/rules.d/99-fishcamp.rules %changelog * Sun Jul 19 2020 Jim Howard 1.8.7.git-1 - update to build from git for copr, credit to Sergio Pascual and Christian Dersch for prior work on spec files libfishcamp-1.2+20220607003151/COPYING.LIB0000644000175100017510000000252314174600256016104 0ustar debiandebianCopyright (c) 2001-2013 Fishcamp Engineering (support@fishcamp.com) All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. libfishcamp-1.2+20220607003151/fishcamp.c0000644000175100017510000037747714174600256016431 0ustar debiandebian/* Copyright (c) 2001-2013 Fishcamp Engineering (support@fishcamp.com) All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. Modified by: Jasem Mutlaq (2013) THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ====================================================================== */ #include "fishcamp.h" #include "indimacros.h" #include #include #include #include #include #include #include #include #define MAXRBUF 512 // globals struct libusb_context *gCtx; fc_Camera_Information gCamerasFound[kNumCamsSupported]; bool gFWInitialized; // set when the fcUsb_init is executed the first time. char gBuffer[513]; UInt16 gRelease; // set in the 'RawDeviceAdded' routine. Is actually used // by fishcamp as a camera serial number int gNumCamerasDiscovered; // total cameras found on the USB interface bool gReadBlack[kNumCamsSupported]; // set if the host wishes to read the black pixels int gDataXfrReadMode[kNumCamsSupported]; // the type of data transfers we will be using when taking picts int gDataFormat[kNumCamsSupported]; // the desired camera data format fcFindCamState gFindCamState; // the progress state codes that the fcUsb_FindCameras routine reports float gFindCamPercentComplete; // 0.0 -> 100.0 progress as a percent of total time. UInt32 gCurrentIntegrationTime[kNumCamsSupported]; UInt32 gCurrentGuiderIntegrationTime[kNumCamsSupported]; // currently set exposure time for the guider part of the camera // add an internal frame buffer to handle time when we do black level line compensation. // we use the internal frame buffer which is bigger than what the user asked for in order to // be able to handle the extra black columns. We then strip it out of the uploaded image // so the user never sees them UInt16 *gFrameBuffer; UInt16 gRoi_left[kNumCamsSupported]; // this is the requested size from the user UInt16 gRoi_top[kNumCamsSupported]; UInt16 gRoi_right[kNumCamsSupported]; UInt16 gRoi_bottom[kNumCamsSupported]; // for IBIS 1300 image sensor we look at the average of the first row of black pixels to perform the column normalization // this is where we store the average. It is computed every time the gain setting on the image sensor is made. SInt32 gBlackOffsets[1280]; // for the Starfish PRO camera, we will calculate the column and row offsets from information in the overscan pixels // we will use the vertical overscan to calculate the column offsets and the horizontal overscan to calculate the // row offsets. The final number in this vector will be the number that needs to be added to the given row/col // to normalize the image. Thus the reason of using SInt32. SInt32 gProBlackColOffsets[4096]; // offsets. one for each column SInt32 gProBlackRowOffsets[4096]; // offsets. one for each row bool gProWantColNormalization; // true if we want column normalization //CCyUSBDevice* gUSBDevice; bool gDoLogging; // set to TRUE to enable logging to the log file bool gDoSimulation; // set to TRUE to enable simulation int gCameraImageFilter[kNumCamsSupported]; // type of image filter for post processing on this camera UInt16 gBlackPedestal[kNumCamsSupported]; //Location for Drivers char driverSupportPath[MAXRBUF]; // send data via the designated camera's bulk out endpoint // valid camNum is 1 -> fcUsb_GetNumCameras() // int SendUSB(int camNum, unsigned char *data, int length) { int retVal, transferred; struct libusb_device_handle *dev; retVal = -1; dev = gCamerasFound[camNum - 1].dev; if (dev != NULL) retVal = libusb_bulk_transfer(dev, FC_STARFISH_BULK_OUT_ENDPOINT, data, length, &transferred, 10000); else { Starfish_LogFmt("Error on Sending Libusb Bulk Transfer: no camera handle\n"); return 0; } if (retVal == 0) { Starfish_LogFmt("Sent - %d bytes\n", transferred); return transferred; } else { Starfish_LogFmt("Error on Sending Libusb Bulk Transfer: %s\n", libusb_error_name(retVal)); return 0; } } // receive data via the designated camera's bulk in endpoint // valid camNum is 1 -> fcUsb_GetNumCameras() // int RcvUSB(int camNum, unsigned char *data, int maxBytes) { int retVal, transferred; struct libusb_device_handle *dev; retVal = -1; dev = gCamerasFound[camNum - 1].dev; if (dev != NULL) retVal = libusb_bulk_transfer(dev, FC_STARFISH_BULK_IN_ENDPOINT, data, maxBytes, &transferred, 10000); else { Starfish_LogFmt("Error on Receiving Libusb Bulk Transfer: no camera handle\n"); return 0; } if (retVal == 0) { Starfish_LogFmt("RcvUSB - %d bytes\n", transferred); return transferred; } else { Starfish_LogFmt("Error on Receiving Libusb Bulk Transfer: %s\n", libusb_error_name(retVal)); return 0; } } // routine to check to see if we have a starfish log file on disk // return TRUE if one exists // bool haveStarfishLogFile() { FILE *theLogFile; bool retValue; // assume the file isn't there retValue = false; // Open for read (will fail if file does not exist) char filename[MAXRBUF]; snprintf(filename, MAXRBUF, "%s/.indi/starfish_log.txt", getenv("HOME")); if ((theLogFile = fopen(filename, "r")) == NULL) { // no such file // printf("haveStarfishLogFile = FALSE\n"); retValue = false; } else { // the file was there // printf("haveStarfishLogFile = TRUE\n"); fclose(theLogFile); retValue = true; } return retValue; } // routine to create the starfish log file on disk. // will first check to see if the file already exists. // will simply return if the file is there already // otherwise it will create it. // void creatStarfishLogFile() { FILE *theLogFile; if (!haveStarfishLogFile()) { char filename[MAXRBUF]; snprintf(filename, MAXRBUF, "%s/.indi/starfish_log.txt", getenv("HOME")); if (!(theLogFile = fopen(filename, "w"))) { fprintf(stderr, "Error opening Starfish log file (%s) : %s\n", filename, strerror(errno)); return; } fclose(theLogFile); } } // routine that is called everytime we make a log file entry. // we don't want the log file to get too big, so we check its size // and resize it if it was getting too big. Simple routine // here is that it checks the size of the file and if too // big, it simply clears it out starting at zero again. // void check4tooLongLogFile() { FILE *theLogFile; long length; //int result; if (haveStarfishLogFile()) { // Open for write char filename[MAXRBUF]; snprintf(filename, MAXRBUF, "%s/.indi/starfish_log.txt", getenv("HOME")); theLogFile = fopen(filename, "a+"); fseek(theLogFile, 0, SEEK_END); length = ftell(theLogFile); fclose(theLogFile); if (length > 8000000) { // file too big, need to reset it and start over // printf("Re-creating (smaller) Starfish Log File.\n"); theLogFile = fopen(filename, "w"); // "w" will re-create the file fclose(theLogFile); } } } void fc_timestamp(FILE *out) { time_t t; struct timeval tv; char timestamp[40]; gettimeofday(&tv, NULL); *(unsigned long *)&t = tv.tv_sec; strftime(timestamp, sizeof timestamp, "%e %b %G %T", localtime(&t)); fprintf(out, "%s.%02ld ", timestamp, (long)(tv.tv_usec / 10000)); } // // routine to add a log entry to the Starfish log file // // The log file is by default placed in \etc\fishcamp\starfish_log.txt // // This routine will first check to see if the log file exists and create it if it doesn't // // Then the routine will append the passed logString to the end of the file. // void Starfish_LogFmt(const char *fmt, ...) { FILE *theLogFile; if (!gDoLogging) // only do if logging has been enabled return; // check to see if we have the starfish log file yet // if not create one if (!haveStarfishLogFile()) creatStarfishLogFile(); // simple way of assuring the log file doesn't get too big check4tooLongLogFile(); char filename[MAXRBUF]; snprintf(filename, MAXRBUF, "%s/.indi/starfish_log.txt", getenv("HOME")); if ((theLogFile = fopen(filename, "a+")) != NULL) { va_list ap; va_start(ap, fmt); // get operating system-style date and time. fc_timestamp(theLogFile); //sprintf( buffer, "- %s", logString ); //numWritten = fputs( buffer, theLogFile ); fputs("- ", theLogFile); vfprintf(theLogFile, fmt, ap); fclose(theLogFile); va_end(ap); } // else // printf( "Problem opening the file\n" ); } void Starfish_Log(const char *logString) { Starfish_LogFmt("%s", logString); } // utility routine to see if we have already discovered that a certain // camera was connected to this computer. Will return TRUE if so. // // enter with: // - FC vendor ID // - RAW camera product ID or -1 if not valid // - Final camera product ID or -1 if not valid // - camera serial number // // the routine will use the desired camera product ID specified. pass in a -1 if not valid. // bool sawThisCameraAlready(UInt16 vendor, UInt16 rawProduct, UInt16 finalProduct, UInt16 release) { int i; bool retValue; retValue = false; for (i = 0; i < kNumCamsSupported; i++) { if (gCamerasFound[i].camVendor == vendor) { if ((rawProduct == 0xffff) || (gCamerasFound[i].camRawProduct == rawProduct)) { if ((finalProduct == 0xffff) || (gCamerasFound[i].camFinalProduct == finalProduct)) { if (gCamerasFound[i].camRelease == release) { retValue = true; } } } } } return retValue; } // utility routine to return the index of the camera in the local 'gCamerasFound' array // will return 0 -> (kNumCamsSupported - 1) if we have the camera in our data base // will return -1 if we don't. // // enter with: // - FC vendor ID // - RAW camera product ID or -1 if not valid // - Final camera product ID or -1 if not valid // - camera serial number // // the routine will use the desired camera product ID specified. pass in a -1 if not valid. // int getCameraDBIndex(UInt16 vendor, UInt16 rawProduct, UInt16 finalProduct, UInt16 release) { int i; int retValue; retValue = -1; for (i = 0; i < kNumCamsSupported; i++) { if (gCamerasFound[i].camVendor == vendor) { if ((rawProduct == 0xffff) || (gCamerasFound[i].camRawProduct == rawProduct)) { if ((finalProduct == 0xffff) || (gCamerasFound[i].camFinalProduct == finalProduct)) { if (gCamerasFound[i].camRelease == release) { retValue = i; } } } } } return retValue; } // utility routine to return the DB index of the next available slot in the local 'gCamerasFound' array // will return 0 -> (kNumCamsSupported - 1) if we have room in our data base // will return -1 if we don't. // // int getNextFreeDBIndex(void) { int i; int retValue; retValue = -1; for (i = 0; i < kNumCamsSupported; i++) { if (gCamerasFound[i].camVendor == 0) { retValue = i; break; } } return retValue; } // utility debug routine used to print out the camera data base // void printOutDiscoveredCamerasDB(void) { int i; for (i = 0; i < kNumCamsSupported; i++) { Starfish_LogFmt("Camera DB for discovered camera # - %d\n", i); Starfish_LogFmt(" gCamerasFound[%d].camVendor - %04x\n", i, gCamerasFound[i].camVendor); Starfish_LogFmt(" gCamerasFound[%d].camRawProduct - %04x\n", i, gCamerasFound[i].camRawProduct); Starfish_LogFmt(" gCamerasFound[%d].camFinalProduct - %04x\n", i, gCamerasFound[i].camFinalProduct); Starfish_LogFmt(" gCamerasFound[%d].camRelease - %04x\n", i, gCamerasFound[i].camRelease); } } void AnchorWrite(struct libusb_device_handle *dev_handle, UInt16 anchorAddress, UInt16 count, UInt8 writeBuffer[]) { int retval; retval = libusb_control_transfer(dev_handle, /*dev_handle*/ LIBUSB_REQUEST_TYPE_VENDOR, //REQ_VENDOR, /*request type*/ 0xa0, /*request*/ anchorAddress, /*value*/ 0, /*index*/ writeBuffer, /*(unsigned char *)data*/ count, /*length*/ 5000 /*timeout*/ ); if (retval < 0) Starfish_Log("Error in control transfer.\n"); } FILE *openFile(UInt16 vendor, UInt16 product) { INDI_UNUSED(vendor); char name[MAXRBUF]; char name2[MAXRBUF]; snprintf(name, MAXRBUF, "%s/gdr_usb.hex", driverSupportPath); snprintf(name2, MAXRBUF, "%s/pro_usb.hex", driverSupportPath); //char path[256]; FILE *hexFile; Starfish_Log("openFile routine\n"); if (product == 0x0008) { Starfish_LogFmt("File to open is \"%s\"\n", name2); hexFile = fopen(name2, "r"); } else { Starfish_LogFmt("File to open is \"%s\"\n", name); hexFile = fopen(name, "r"); } return (hexFile); } /* Description of Intel hex records. Position Description 1 Record Marker: The first character of the line is always a colon (ASCII 0x3A) to identify the line as an Intel HEX file 2 - 3 Record Length: This field contains the number of data bytes in the register represented as a 2-digit hexidecimal number. This is the total number of data bytes, not including the checksum byte nor the first 9 characters of the line. 4 - 7 Address: This field contains the address where the data should be loaded into the chip. This is a value from 0 to 65,535 represented as a 4-digit hexidecimal value. 8 - 9 Record Type: This field indicates the type of record for this line. The possible values are: 00=Register contains normal data. 01=End of File. 02=Extended address. 10 - ? Data Bytes: The following bytes are the actual data that will be burned into the EPROM. The data is represented as 2-digit hexidecimal values. Last 2 characters Checksum: The last two characters of the line are a checksum for the line. The checksum value is calculated by taking the twos complement of the sum of all the preceeding data bytes, excluding the checksum byte itself and the colon at the beginning of the line. */ int hexRead(INTEL_HEX_RECORD *record, FILE *hexFile, UInt16 vendor, UInt16 product) { // Read the next hex record from the file into the structure INDI_UNUSED(vendor); // **** Need to impliment checksum checking **** if (gDoSimulation) return 0; char c; UInt16 i; UInt16 newChecksum; int n, c1, check, len; c = getc(hexFile); if (c != ':') { Starfish_LogFmt("Line does not start with colon (%d)\n", c); return (-1); } n = fscanf(hexFile, "%2lX%4lX%2lX", &record->Length, &record->Address, &record->Type); if (n != 3) { Starfish_LogFmt("Could not read line preamble %d\n", c); return (-1); } len = record->Length; if (len > MAX_INTEL_HEX_RECORD_LENGTH) { Starfish_LogFmt("length is more than can fit %d, %d\n", len, MAX_INTEL_HEX_RECORD_LENGTH); return (-1); } for (i = 0; i < len; i++) { n = fscanf(hexFile, "%2X", &c1); if (n != 1) { if (i != record->Length) { Starfish_LogFmt("Line finished at wrong time %d, %ld\n", i, record->Length); return (-1); } } record->Data[i] = c1; } n = fscanf(hexFile, "%2X\n", &check); if (n != 1) { Starfish_LogFmt("Check not found\n"); return (-1); } // final operation. stuff the serial number of the RAW camera into the firmware file of the final camera // printf(" record->Length = %ld\n", record->Length); // printf(" record->Address = %ld\n", record->Address); // printf(" record->Type = %ld\n", record->Type); if ((record->Length == 16) && (record->Address == 0x0700) && (record->Type == 00)) { Starfish_Log("setting configured productID\n"); record->Data[10] = (product & 0xFF) | 0x01; // even# was RAW device, odd will be CONFIGURED device record->Data[11] = (product >> 8) & 0xFF; Starfish_Log("setting serial number\n"); record->Data[12] = gRelease & 0xFF; record->Data[13] = (gRelease >> 8) & 0xFF; // compute new checksum newChecksum = 0x10 + 0x07; for (i = 0; i < len; i++) { newChecksum = newChecksum + record->Data[i]; } newChecksum = ~newChecksum; newChecksum = newChecksum + 1; newChecksum = newChecksum & 0xff; // printf(" old check = %ld\n", check); check = newChecksum; // printf(" new check = %ld\n", check); } return (0); } // routine used to load the USB chip's firmware. // called from RawDeviceAdded, // int DownloadToAnchorDevice(struct libusb_device_handle *dev, UInt16 vendor, UInt16 product) { UInt8 writeVal; int kr; FILE *hexFile; INTEL_HEX_RECORD anchorCode; Starfish_Log("DownloadToAnchorDevice routine\n"); if (gDoSimulation) return 0; hexFile = openFile(vendor, product); if (hexFile == NULL) { Starfish_Log("DownloadToAnchorDevice could not open file.\n"); return -1; } // Assert reset writeVal = 1; AnchorWrite(dev, k8051_USBCS, 1, &writeVal); // Download code while (1) { kr = hexRead(&anchorCode, hexFile, vendor, product); if (anchorCode.Type != 0) break; if (kr == 0) AnchorWrite(dev, anchorCode.Address, anchorCode.Length, anchorCode.Data); } // De-assert reset writeVal = 0; AnchorWrite(dev, k8051_USBCS, 1, &writeVal); return 0; } // Routine to search the 'fishcamp' directory for the latest version of the // MicroBlaze SREC file. The following file name format is assumed // "\etc\fishcamp\Guider_mono_revXX_intel.srec"; // // where revXX is an incrementing rev number. // // will return the rev number of the latest file found or -1 if no file found // int GetLatestSrecFileRevNumber(void) { int returnNumber; //int tempInt; bool done; //char fileName[200]; FILE *srecFile; Starfish_Log("GetLatestSrecFileRevNumber\n"); returnNumber = 16; // rev 16 is the latest version released done = false; while (!done) { // generate the next file name to look for char fileName[MAXRBUF]; snprintf(fileName, MAXRBUF, "%s/Guider_mono_rev%02d_intel.srec", driverSupportPath, returnNumber); Starfish_LogFmt(" Looking for file - \"%s\"\n", fileName); // try to open the file srecFile = fopen(fileName, "r"); if (srecFile == NULL) { // file didn't exist so we must be done looking Starfish_Log(" Done looking\n"); done = true; } else { // file was there so keep looking Starfish_Log(" Found SREC file\n"); fclose(srecFile); returnNumber++; } } returnNumber--; if (returnNumber == 15) { Starfish_Log(" Could not find an SREC file\n"); returnNumber = -1; } else { char fileName[MAXRBUF]; snprintf(fileName, MAXRBUF, "%s/Guider_mono_rev%02d_intel.srec", driverSupportPath, returnNumber); Starfish_LogFmt(" Most recent SREC file is - \"%s\"\n", fileName); } return (returnNumber); } // routine to open the file containing the program to be executed by // the camera's microBlaze processor. File is S-records // FILE *openSrecFile(UInt16 vendor, UInt16 rawProduct) { INDI_UNUSED(vendor); char name[MAXRBUF]; char name1[MAXRBUF]; char name2[MAXRBUF]; snprintf(name, MAXRBUF, "%s/Guider_mono_rev16_intel.srec", driverSupportPath); snprintf(name1, MAXRBUF, "%s/ibis_rev1_intel.srec", driverSupportPath); // ibis 1300 snprintf(name2, MAXRBUF, "%s/StarfishPRO4M_rev1_intel.srec", driverSupportPath); // StarfishPRO4M int fileRevNumber; //char fileName[200]; FILE *srecFile; Starfish_Log("openSrecFile routine\n"); if (rawProduct == starfish_ibis13_raw_deviceID) { Starfish_LogFmt("File to open is \"%s\"\n", name1); srecFile = fopen(name1, "r"); } else { if (rawProduct == starfish_pro4m_raw_deviceID) { Starfish_LogFmt("File to open is \"%s\"\n", name2); srecFile = fopen(name2, "r"); } else { // look for the most recent SREC file fileRevNumber = GetLatestSrecFileRevNumber(); if (fileRevNumber != -1) { char fileName[MAXRBUF]; snprintf(fileName, MAXRBUF, "%s/Guider_mono_rev16_intel.srec", driverSupportPath); Starfish_LogFmt("File to open is \"%s\"\n", fileName); srecFile = fopen(fileName, "r"); } else { srecFile = NULL; Starfish_Log(" Could not open the file\n"); } } } return (srecFile); } char *srecRead(UInt8 *record, FILE *srecFile) { // Read the next srecord from the file into the buffer int maxLineSize; maxLineSize = 100; return (fgets((char *)record, maxLineSize, srecFile)); } // will download the application program to the MicroBlaze processor in the camera. // At boot-up, the camera is looking for srecords. After the download the processor // will jump execution to the downloaded program. // // // valid camNum is 1 -> fcUsb_GetNumCameras() // void DownloadtToMicroBlaze(int camNum) { FILE *mySrecFile; char *lineReadResult; bool done; static char srecBuffer[513]; int /*index,*/ retVal, msgSize, transferred; UInt16 vendor, rawProduct, finalProduct, release; struct libusb_device_handle *USBdev; Starfish_Log("DownloadtToMicroBlaze routine\n"); if (gDoSimulation) return; vendor = gCamerasFound[camNum - 1].camVendor; rawProduct = gCamerasFound[camNum - 1].camRawProduct; finalProduct = gCamerasFound[camNum - 1].camFinalProduct; release = gCamerasFound[camNum - 1].camRelease; USBdev = gCamerasFound[camNum - 1].dev; mySrecFile = openSrecFile(vendor, rawProduct); if (mySrecFile != NULL) { Starfish_LogFmt("SrecFile Opened and writing\n"); done = false; while (!done) { lineReadResult = srecRead((UInt8 *)&srecBuffer[0], mySrecFile); if (lineReadResult == 0) done = true; else { msgSize = strlen(srecBuffer); retVal = libusb_bulk_transfer(USBdev, FC_STARFISH_BULK_OUT_ENDPOINT, (unsigned char *)&srecBuffer[0], msgSize, &transferred, 10000); if (retVal != 0) { Starfish_LogFmt("Error on Libusb Bulk Transfer: %s\n", libusb_error_name(retVal)); } else { //For some reason, without this it fails to send all the lines to the camera. usleep(100); } } } Starfish_LogFmt("Closing Srecfile\n"); fclose(mySrecFile); } else { Starfish_LogFmt("Error opening SrecFile!\n"); } } // Notification. Here when we discover that the guider camera is first plugged in. // // - reads, VendorID, ProductID, and ReleaseID // - calls 'DownloadToAnchorDevice' to load the USB chip's firmware // //void RawDeviceAdded(void) //{ // UInt16 vendor; // UInt16 product; // UInt16 release; // int index; // int kr; // char buffer[200]; // // // // Starfish_Log("RawDeviceAdded routine\n"); // // // vendor = gUSBDevice->VendorID; // product = gUSBDevice->ProductID; // release = gUSBDevice->BcdDevice; // // Starfish_LogFmt(" vendor = %08x\n", vendor); // Starfish_Log( buffer ); // Starfish_LogFmt(" product = %08x\n", product); // Starfish_Log( buffer ); // Starfish_LogFmt(" release = %08x\n", release); // Starfish_Log( buffer ); // // // put the new RAW camera in our data base // if (!sawThisCameraAlready (vendor, product, 0xffff, release)) // { // index = getNextFreeDBIndex(); // // gCamerasFound[index].camVendor = vendor; // gCamerasFound[index].camRawProduct = product; // gCamerasFound[index].camFinalProduct = 0; // gCamerasFound[index].camRelease = release; //// gCamerasFound[index].camUsbIntfc = 0; // // Starfish_LogFmt("RawDeviceAdded - added RAW camera to DB index at index = %d\n", index); // Starfish_Log( buffer ); // } // // // the ReleaseNumber is used by fishcamp as a camera serial number. Store it away // gRelease = release; // // ConfigureAnchorDevice(); // // kr = DownloadToAnchorDevice(vendor, product); // if (0 != kr) // { // Starfish_LogFmt("unable to download to device: %08x\n", kr); // Starfish_Log( buffer ); // } // //} //Notfication. here when we discover our newly programmed guider device // - calls 'FindInterfaces' // - calls 'DownloadtToMicroBlaze' to load final camera software // //void NewDeviceAdded(void) //{ // int kr; // int kr2; // SInt32 score; // UInt16 vendor; // UInt16 product; // UInt16 release; // int index; // char buffer[200]; // // // // // Starfish_Log("NewDeviceAdded routine\n"); // // vendor = gUSBDevice->VendorID; // product = gUSBDevice->ProductID; // release = gUSBDevice->BcdDevice; // // Starfish_LogFmt(" vendor = %08x\n", vendor); // Starfish_Log( buffer ); // Starfish_LogFmt(" product = %08x\n", product); // Starfish_Log( buffer ); // Starfish_LogFmt(" release = %08x\n", release); // Starfish_Log( buffer ); // // // put the new initialized camera in our data base // // at this point only the RAW version of the camera will be in the data base, if at all. It // // won't be in it at all if we re-started the application after previously been running // // and the camera is already initialized from before. // // by convention, the RAW productID will be an even number, the initialized version will be odd. // // we use this knowledge to look for any previous entries of the RAW version of this camera. // if (!sawThisCameraAlready (vendor, product & 0xfffe, 0xffff, release)) // { // // here if we haven't seen this camera in its RAW state // // // check to see if it was already addded in its initialized state. add it if not. // if (getCameraDBIndex (vendor, 0xffff, product, release) == -1) // { // index = getNextFreeDBIndex(); // // gCamerasFound[index].camVendor = vendor; // gCamerasFound[index].camRawProduct = 0; // gCamerasFound[index].camFinalProduct = product; // gCamerasFound[index].camRelease = release; //// gCamerasFound[index].camUsbIntfc = 0; // // Starfish_LogFmt("NewDeviceAdded - added FINAL camera to DB at index = %d\n", index); // Starfish_Log( buffer ); // } // else // Starfish_Log("NewDeviceAdded - FINAL camera already in DB\n"); // } // else // { // index = getCameraDBIndex (vendor, product & 0xfffe, 0xffff, release); // // gCamerasFound[index].camVendor = vendor; // // don't touch the following field. we already saw this camera added as a RAW device //// gCamerasFound[index].camRawProduct = 0; // gCamerasFound[index].camFinalProduct = product; // gCamerasFound[index].camRelease = release; //// gCamerasFound[index].camUsbIntfc = 0; // // Starfish_LogFmt("NewDeviceAdded - updating RAW camera at DB index = %d\n", index); // Starfish_Log( buffer ); // } // // // // // the ReleaseNumber is used by fishcamp as a camera serial number. Store it away // gRelease = release; // // ConfigureAnchorDevice(); // // FindInterfaces(); // // // one last thing.... // // need to load the MicroBlaze executable program before doing any camera stuff. // // if (gCamerasFound[index].camRawProduct != 0) // if the camera was discovered in the RAW state. we will know this cause it will be non-zero // { // Starfish_Log("Calling - DownloadtToMicroBlaze \n"); // DownloadtToMicroBlaze(gCamerasFound[index].camVendor, gCamerasFound[index].camRawProduct, gCamerasFound[index].camFinalProduct, gCamerasFound[index].camRelease); // } // else // { // Starfish_Log("didn't need to call - DownloadtToMicroBlaze \n"); // } // //// printOutDiscoveredCamerasDB(); //} // given a pointer to a command parameter struct, this routine will // calculate the correct cksum field UInt16 fcUsb_GetUsbCmdCksum(UInt16 *cmdParams) { UInt16 theCksum; UInt16 *ptr16; UInt16 theLength; int i; ptr16 = cmdParams; theCksum = *ptr16++; // start with the header theCksum += *ptr16++; // add in the command field theLength = *ptr16++; theCksum += theLength; for (i = 0; i < (theLength - 8); i += 2) { theCksum += *ptr16++; } return theCksum; } // helper routine for fcImage_doFullFrameRowLevelNormalization. // will calculate the average level of the pixels in the // black cols of the image sensor // float fcImage_calcFullFrameAllColAvg(UInt16 *frameBufferPtr, int imageWidth, int imageHeight) { float floatPixel; float retValue; int row, col; //bool evenRow; UInt16 *inputPtr; UInt16 aPixel; retValue = 0.0; // we will average all of the pixels in cols 0 -> 14 for (row = 0; row < imageHeight; row++) { inputPtr = frameBufferPtr; inputPtr = inputPtr + (row * imageWidth); for (col = 0; col < 14; col++) { // get the next pixel aPixel = *inputPtr++; floatPixel = (float)aPixel; retValue += floatPixel; } } //divide by the number of pixels in the black col retValue = retValue / (14.0 * (float)imageHeight); return retValue; } // helper routine for fcImage_doFullFrameRowLevelNormalization. // will calculate the average level of the pixels in the // defined ROW's black columns float fcImage_calcFullFrameRowAvgForRow(UInt16 *frameBufferPtr, int imageWidth, int imageHeight, int theRow) { INDI_UNUSED(imageHeight); float floatPixel; float retValue; int /*row,*/ col; //bool evenRow; UInt16 *inputPtr; UInt16 aPixel; UInt16 lowPixel; UInt16 hiPixel; retValue = 0.0; lowPixel = 0xffff; hiPixel = 0; // we will average all of the pixels in cols 0 -> 14 inputPtr = frameBufferPtr; inputPtr = inputPtr + (theRow * imageWidth); for (col = 0; col < 14; col++) { // get the next pixel aPixel = *inputPtr++; // find lowest and highest pixel if (lowPixel > aPixel) lowPixel = aPixel; if (hiPixel < aPixel) hiPixel = aPixel; floatPixel = (float)aPixel; retValue += floatPixel; } // throw out lowest and highest // floatPixel = (float) lowPixel; // retValue -= floatPixel; // floatPixel = (float) hiPixel; // retValue -= floatPixel; //divide by the number of pixels in the black col retValue = retValue / 14.0; // retValue = retValue / 12.0; return retValue; } // routine to perform line level normalization on the RAW camera image // Used to get rid of the camera's read noise associated with ROWs // enter with pointer to 16 bit image // void fcImage_doFullFrameRowLevelNormalization(UInt16 *frameBufferPtr, int imageWidth, int imageHeight) { //float reference; int row, col; UInt16 *inputPtr; UInt16 aPixel; float rowAvg = 0; float thisRowAvg; //float minRowAvg; //float colAvg; float frameAvg; float rowOffset; //float colOffset; float floatPixel; if (gDoSimulation) { srand(time(NULL)); int i = 0, j = 0; for (i = 0; i < imageHeight; i++) for (j = 0; j < imageWidth; j++) frameBufferPtr[i * imageWidth + j] = rand() % 65535; return; } // make sure we are dealing with 16 bit pixels // printf("fcImage_doFullFrameRowLevelNormalization\n"); // calculate the average of all the black pixels frameAvg = fcImage_calcFullFrameAllColAvg(frameBufferPtr, imageWidth, imageHeight); for (row = 0; row < imageHeight; row++) { if (row > 0) rowAvg = fcImage_calcFullFrameRowAvgForRow(frameBufferPtr, imageWidth, imageHeight, (row - 1)); // rowAvg = [self calcFullFrameRowMedianForRow: (row - 1)]; thisRowAvg = fcImage_calcFullFrameRowAvgForRow(frameBufferPtr, imageWidth, imageHeight, row); // thisRowAvg = [self calcFullFrameRowMedianForRow: row]; if (row == 0) rowOffset = frameAvg - thisRowAvg; else rowOffset = rowAvg - thisRowAvg; // 11-23-07 inputPtr = frameBufferPtr; inputPtr = inputPtr + (row * imageWidth); for (col = 0; col < imageWidth; col++) // for (col = 0; col < (imageWidth / 2); col++) { // get the next pixel aPixel = *inputPtr; floatPixel = (float)aPixel; floatPixel += rowOffset; if (floatPixel > 65535.0) floatPixel = 65535.0; if (floatPixel < 0.0) floatPixel = 0.0; // put corrected value back *inputPtr++ = (UInt16)floatPixel; } } } // routine to strip the black columns form the image read from the camera. the camera's image is // assumed to be in gFrameBuffer and the pointer passed to this routine is where we will put the // stripped image; void fcImage_StripBlackCols(int camNum, UInt16 *frameBuffer) { //float reference; int row, col; int imageHeight, imageWidth; UInt16 *inputPtr; UInt16 *outputPtr; //UInt16 aPixel; //float rowAvg; //float thisRowAvg; //float minRowAvg; //float colAvg; //float frameAvg; //float rowOffset; //float colOffset; //float floatPixel; imageHeight = (gRoi_bottom[camNum - 1] - gRoi_top[camNum - 1]) + 1; imageWidth = (gRoi_right[camNum - 1] - gRoi_left[camNum - 1]) + 1; for (row = 0; row < imageHeight; row++) { inputPtr = gFrameBuffer; // if (row < (imageHeight / 2)) inputPtr = inputPtr + (row * (imageWidth + 16)) + 16; // else // inputPtr = inputPtr + (row * (imageWidth + 16)); outputPtr = frameBuffer; outputPtr = outputPtr + (row * imageWidth); for (col = 0; col < imageWidth; col++) { // transfer pixel *outputPtr++ = *inputPtr++; } } } // the following three routines are used to touch up the images from the IBIS1300 sensor // it normalizes the offsets in the columns. // clear out the black row vector for the IBIS1300 image sensor void fcImage_IBIS_clearBlackRowAverage(void) { int i; for (i = 0; i < 1280; i++) gBlackOffsets[i] = 0; } // accumulate another image's first black row from the IBIS image sensor void fcImage_IBIS_accumulateBlackRowAverage(void) { UInt16 *inputPtr; UInt16 aPixel; SInt32 bigPixel; int col; // we will average all of the pixels in the first row inputPtr = gFrameBuffer; for (col = 0; col < 1280; col++) { // get the next pixel aPixel = *inputPtr++; bigPixel = (SInt32)aPixel; gBlackOffsets[col] = gBlackOffsets[col] + bigPixel; } } // here after we accumulated all of the images first black row. now divide by the num of images taken void fcImage_IBIS_divideBlackRowAverage(void) { int i; for (i = 0; i < 1280; i++) gBlackOffsets[i] = gBlackOffsets[i] / 4; } // helper routine for fcImage_IBIS_doFullFrameColLevelNormalization. // will calculate the average level of the pixels in the // first black row of the image sensor // float fcImage_IBIS_calcFirstBlackRowAverage(UInt16 *frameBufferPtr, int imageWidth, int imageHeight) { INDI_UNUSED(frameBufferPtr); INDI_UNUSED(imageHeight); float floatPixel; float retValue; int /*row,*/ col; //bool evenRow; //UInt16 *inputPtr; SInt32 aPixel; retValue = 0.0; // we will average all of the pixels in the first row for (col = 0; col < imageWidth; col++) { // get the next pixel aPixel = gBlackOffsets[col]; floatPixel = (float)aPixel; retValue += floatPixel; } //divide by the number of pixels in the black row retValue = retValue / (float)imageWidth; return retValue; } // routine which will subtract out the offset pedestal from the image. It looks at the // first row of black pixels to determine the average of the row. Then it subtracts out // that number from each pixel in the image. void fcImage_IBIS_subtractPedestal(UInt16 *frameBufferPtr, int imageWidth, int imageHeight) { //float reference; int row, col; UInt16 *inputPtr; UInt16 aPixel; SInt32 bigPixel; SInt32 thePedestal; //float rowAvg; //float thisColBlack; //float minRowAvg; //float colAvg; float frameAvg; //float rowOffset; //float colOffset; //float floatPixel; // calculate the average of all the black pixels in the first row frameAvg = fcImage_IBIS_calcFirstBlackRowAverage(frameBufferPtr, imageWidth, imageHeight); thePedestal = (SInt32)frameAvg; // don't touch the black row. Start at row '1' inputPtr = frameBufferPtr; inputPtr = inputPtr + imageWidth; for (col = 0; col < imageWidth; col++) { for (row = 1; row < imageHeight; row++) { aPixel = *inputPtr; bigPixel = (SInt32)aPixel; bigPixel = bigPixel - thePedestal; if (bigPixel > 65535) bigPixel = 65535; if (bigPixel < 0) bigPixel = 0; // put corrected value back *inputPtr = (UInt16)bigPixel; // point to next inputPtr++; } } } // this routine is called everytime the gain setting is changed on the IBIS1300 image sensor. I takes 8 frames // and stores the average of the first black row of pixels in the sensor. The resulting vector is then used // to normalize the columns everytime a new image is readout. void fcImage_IBIS_computeAvgColOffsets(int camNum) { UInt32 savedIntegrationTime; bool done; UInt16 state; int i; // clear out the vector fcImage_IBIS_clearBlackRowAverage(); // remember the integration time that the user wants savedIntegrationTime = gCurrentIntegrationTime[camNum - 1]; // set a short integration time fcUsb_cmd_setIntegrationTime(camNum, 10); // 10 ms // take an initial picture fcUsb_cmd_startExposure(camNum); // wait till the picture is done done = false; while (!done) { state = fcUsb_cmd_getState(camNum); if (state == 0) done = true; } for (i = 0; i < 4; i++) { // take a picture fcUsb_cmd_startExposure(camNum); // wait till the picture is done done = false; while (!done) { state = fcUsb_cmd_getState(camNum); if (state == 0) done = true; } // read in the image into our local frame buffer fcUsb_cmd_getRawFrame(camNum, 1024, 1280, gFrameBuffer); // add to the average fcImage_IBIS_accumulateBlackRowAverage(); } // divide the vector by the number of picts taken fcImage_IBIS_divideBlackRowAverage(); // put the users' desired integration time back fcUsb_cmd_setIntegrationTime(camNum, savedIntegrationTime); } // routine to perform column level normalization on the RAW camera image // Used to get rid of the camera's fixed pattern noise associated with COLs // enter with pointer to 16 bit image // void fcImage_IBIS_doFullFrameColLevelNormalization(UInt16 *frameBufferPtr, int imageWidth, int imageHeight) { //float reference; int row, col; UInt16 *inputPtr; UInt16 aPixel; //float rowAvg; SInt32 thisColBlack; //float minRowAvg; //float colAvg; float frameAvg; //float rowOffset; SInt32 colOffset; //float floatPixel; SInt32 blackAvg; SInt32 bigPixel; //SInt32 theOffset; // make sure we are dealing with 16 bit pixels // printf("fcImage_IBIS_doFullFrameColLevelNormalization\n"); // calculate the average of all the black pixels frameAvg = fcImage_IBIS_calcFirstBlackRowAverage(frameBufferPtr, imageWidth, imageHeight); blackAvg = (SInt32)frameAvg; for (col = 0; col < imageWidth; col++) { // first get this cols black pixel from the first row of the image thisColBlack = gBlackOffsets[col]; colOffset = blackAvg - thisColBlack; for (row = 1; row < imageHeight; row++) { // get the pixel for this row/col inputPtr = frameBufferPtr; inputPtr = inputPtr + (row * imageWidth) + col; aPixel = *inputPtr; bigPixel = (SInt32)aPixel; // normalize bigPixel = bigPixel + colOffset; if (bigPixel > 65535) bigPixel = 65535; if (bigPixel < 0) bigPixel = 0; // put corrected value back *inputPtr = (UInt16)bigPixel; } } } // routine to compute the column level offsets in the image. // We do this by examining the vertical overscan region in the image // Computing the average in the particular column. void fcImage_PRO_calcColOffsets(UInt16 *frameBufferPtr, int imageWidth, int imageHeight) { INDI_UNUSED(imageHeight); //float reference; int row, col; UInt16 *inputPtr; UInt16 aPixel; //float rowAvg; //float thisRowAvg; //float minRowAvg; //float colAvg; //float frameAvg; //float rowOffset; //float colOffset; //float floatPixel; int startRow, endRow; SInt32 colAverage; // printf("fcImage_PRO_calcColOffsets\n"); Starfish_Log("fcImage_PRO_calcColOffsets\n"); // clear out any old results for (col = 0; col < 4096; col++) gProBlackColOffsets[col] = 0; // define the start row and end row of the vertical overscan region of the image startRow = 2100; endRow = 2300; // accumulate the average for (col = 0; col < imageWidth; col++) { for (row = startRow; row < endRow; row++) { inputPtr = frameBufferPtr; inputPtr = inputPtr + (row * imageWidth) + col; // get the next pixel aPixel = *inputPtr; // add up gProBlackColOffsets[col] += (SInt32)aPixel; } // divide by the number of rows in the overscan area gProBlackColOffsets[col] = gProBlackColOffsets[col] / (SInt32)(endRow - startRow); } // now calculate the average of all the columns colAverage = 0; for (col = 0; col < imageWidth; col++) { colAverage += gProBlackColOffsets[col]; } colAverage = colAverage / (SInt32)imageWidth; // normalize the offsets to the column average for (col = 0; col < imageWidth; col++) { gProBlackColOffsets[col] = gProBlackColOffsets[col] - colAverage; } } // routine to perform column level normalization on the RAW camera image // Used to get rid of the sensor's fixed pattern noise associated with COLs // enter with pointer to 16 bit image // void fcImage_PRO_doFullFrameColLevelNormalization(UInt16 *frameBufferPtr, int imageWidth, int imageHeight) { //float reference; int row, col; UInt16 *inputPtr; UInt16 aPixel; //float rowAvg; //float thisRowAvg; //float minRowAvg; //float colAvg; //float frameAvg; //float rowOffset; float colOffset; float floatPixel; // printf("fcImage_PRO_doFullFrameColLevelNormalization\n"); Starfish_Log("fcImage_PRO_doFullFrameColLevelNormalization\n"); // calculate the average of all the black pixels in the vertical overscan area // fcImage_PRO_calcColOffsets(frameBufferPtr, imageWidth, imageHeight); for (row = 0; row < imageHeight; row++) { inputPtr = frameBufferPtr; inputPtr = inputPtr + (row * imageWidth); for (col = 0; col < imageWidth; col++) { // get the next pixel aPixel = *inputPtr; // get the offset for this column colOffset = (float)gProBlackColOffsets[col]; floatPixel = (float)aPixel; floatPixel -= colOffset; if (floatPixel > 65535.0) floatPixel = 65535.0; if (floatPixel < 0.0) floatPixel = 0.0; // put corrected value back *inputPtr++ = (UInt16)floatPixel; } } } // this routine is used internally to calibrate the PRO series cameras. We do this each time // the fcPROP_NUMSAMPLES property is changed or if the sensor's temperature changes by more than 1 degree C. // // the primary job this routine performs is taking a bias frame and measuring the vertical overscan region // so that we know how to do column level normalization. We only can collect this information during a // bias frame since a long exposure light frame will have the scene bleed into the vertical overscan region // and corrupt the measurement. // void fcImage_PRO_calibrateProCamera(int camNum, UInt16 *frameBufferPtr, int imageWidth, int imageHeight) { UInt32 savedIntegrationTime; bool done; UInt16 state; int i; bool savedWantNorm; Starfish_Log("fcImage_PRO_calibrateProCamera\n"); if (gDoSimulation) return; // remember the current integration time setting so that we can put it back when we are done. savedIntegrationTime = gCurrentIntegrationTime[camNum - 1]; savedWantNorm = gProWantColNormalization; gProWantColNormalization = false; // set a short integration time. bias frame = 1ms exposure fcUsb_cmd_setIntegrationTime(camNum, 1); // 1 ms for (i = 0; i < 2; i++) { // take a picture fcUsb_cmd_startExposure(camNum); // wait till the picture is done done = false; while (!done) { state = fcUsb_cmd_getState(camNum); if (state == 0) done = true; } usleep(1000000); // read in the image into our local frame buffer fcUsb_cmd_getRawFrame(camNum, imageHeight, imageWidth, frameBufferPtr); } // calculate the offsets to use for all subsequent images fcImage_PRO_calcColOffsets(frameBufferPtr, imageWidth, imageHeight); // put the users' desired integration time back fcUsb_cmd_setIntegrationTime(camNum, savedIntegrationTime); gProWantColNormalization = savedWantNorm; } // routine to perform a 3x3 kernel filter on the image buffer // void fcImage_do_3x3_kernel(UInt16 imageHeight, UInt16 imageWidth, UInt16 *frameBuffer) { //float reference; int row, col; UInt16 *inputPtr; UInt16 *outputPtr; UInt16 aPixel; UInt32 accumPixel; UInt16 *tempBuffer; size_t size; // this routine will work 'in place'. We will first allocate a temporary image buffer // we copy the image to it and then fill the original buffer with the filtered image // size = imageWidth * imageHeight * 2; // 2 bytes/pixel tempBuffer = (UInt16 *)malloc(size); if (tempBuffer != NULL) { // copy the image buffer to my local storage memcpy(tempBuffer, frameBuffer, size); // Start at row '1' for (row = 1; row < (imageHeight - 1); row++) { for (col = 1; col < (imageWidth - 1); col++) { inputPtr = tempBuffer; inputPtr = inputPtr + (row * imageWidth) + col; outputPtr = frameBuffer; outputPtr = outputPtr + (row * imageWidth) + col; accumPixel = 0; inputPtr = inputPtr - imageWidth - 1; // 1 aPixel = *inputPtr; accumPixel = accumPixel + (UInt32)aPixel; inputPtr++; // 2 aPixel = *inputPtr; accumPixel = accumPixel + (UInt32)aPixel; inputPtr++; // 3 aPixel = *inputPtr; accumPixel = accumPixel + (UInt32)aPixel; inputPtr = inputPtr + imageWidth - 2; // 4 aPixel = *inputPtr; accumPixel = accumPixel + (UInt32)aPixel; inputPtr++; // 5 aPixel = *inputPtr; accumPixel = accumPixel + (UInt32)aPixel; inputPtr++; // 6 aPixel = *inputPtr; accumPixel = accumPixel + (UInt32)aPixel; inputPtr = inputPtr + imageWidth - 2; // 7 aPixel = *inputPtr; accumPixel = accumPixel + (UInt32)aPixel; inputPtr++; // 8 aPixel = *inputPtr; accumPixel = accumPixel + (UInt32)aPixel; inputPtr++; // 9 aPixel = *inputPtr; accumPixel = accumPixel + (UInt32)aPixel; // divide by the kernel size accumPixel = accumPixel / 9; // put filtered value back *outputPtr = (UInt16)accumPixel; } } free(tempBuffer); } } // routine to perform a 5x5 kernel filter on the image buffer // void fcImage_do_5x5_kernel(UInt16 imageHeight, UInt16 imageWidth, UInt16 *frameBuffer) { //float reference; int row, col; UInt16 *inputPtr; UInt16 *outputPtr; UInt16 aPixel; UInt32 accumPixel; UInt16 *tempBuffer; size_t size; int x, y; // this routine will work 'in place'. We will first allocate a temporary image buffer // we copy the image to it and then fill the original buffer with the filtered image // size = imageWidth * imageHeight * 2; // 2 bytes/pixel tempBuffer = (UInt16 *)malloc(size); if (tempBuffer != NULL) { // copy the image buffer to my local storage memcpy(tempBuffer, frameBuffer, size); // Start at row '2' for (row = 2; row < (imageHeight - 2); row++) { for (col = 2; col < (imageWidth - 2); col++) { inputPtr = tempBuffer; inputPtr = inputPtr + (row * imageWidth) + col; outputPtr = frameBuffer; outputPtr = outputPtr + (row * imageWidth) + col; accumPixel = 0; inputPtr = inputPtr - (3 * imageWidth) + 2; for (y = 0; y < 5; y++) { inputPtr = inputPtr + imageWidth - 4; aPixel = *inputPtr; accumPixel = accumPixel + (UInt32)aPixel; for (x = 0; x < 4; x++) { inputPtr++; aPixel = *inputPtr; accumPixel = accumPixel + (UInt32)aPixel; } } // divide by the kernel size accumPixel = accumPixel / 25; // put filtered value back *outputPtr = (UInt16)accumPixel; } } free(tempBuffer); } } // routine to perform hot pixel removal filter on the image buffer // // algorithm looks for the center pixel ina 3x3 grid being more than 20% // brighter than the brightest of the neigboring pixels. If it is // then it will replace it with the average of the neighboring pixels. // void fcImage_do_hotPixel_kernel(UInt16 imageHeight, UInt16 imageWidth, UInt16 *frameBuffer) { float floatBrightPixel; float floatCenterPixel; int row, col; UInt16 *inputPtr; UInt16 *outputPtr; UInt16 aPixel; UInt32 accumPixel; UInt16 *tempBuffer; size_t size; UInt16 brightestNeighbor; UInt16 thisPixel; int numHotPixels; // this routine will work 'in place'. We will first allocate a temporary image buffer // we copy the image to it and then fill the original buffer with the filtered image // size = imageWidth * imageHeight * 2; // 2 bytes/pixel tempBuffer = (UInt16 *)malloc(size); if (tempBuffer != NULL) { numHotPixels = 0; // copy the image buffer to my local storage memcpy(tempBuffer, frameBuffer, size); // Start at row '1' for (row = 1; row < (imageHeight - 1); row++) { for (col = 1; col < (imageWidth - 1); col++) { inputPtr = tempBuffer; inputPtr = inputPtr + (row * imageWidth) + col; outputPtr = frameBuffer; outputPtr = outputPtr + (row * imageWidth) + col; accumPixel = 0; brightestNeighbor = 0; inputPtr = inputPtr - imageWidth - 1; // 1 aPixel = *inputPtr; accumPixel = accumPixel + (UInt32)aPixel; if (brightestNeighbor < aPixel) brightestNeighbor = aPixel; inputPtr++; // 2 aPixel = *inputPtr; accumPixel = accumPixel + (UInt32)aPixel; if (brightestNeighbor < aPixel) brightestNeighbor = aPixel; inputPtr++; // 3 aPixel = *inputPtr; accumPixel = accumPixel + (UInt32)aPixel; if (brightestNeighbor < aPixel) brightestNeighbor = aPixel; inputPtr = inputPtr + imageWidth - 2; // 4 aPixel = *inputPtr; accumPixel = accumPixel + (UInt32)aPixel; if (brightestNeighbor < aPixel) brightestNeighbor = aPixel; inputPtr++; // 5 - center pixel aPixel = *inputPtr; thisPixel = aPixel; inputPtr++; // 6 aPixel = *inputPtr; accumPixel = accumPixel + (UInt32)aPixel; if (brightestNeighbor < aPixel) brightestNeighbor = aPixel; inputPtr = inputPtr + imageWidth - 2; // 7 aPixel = *inputPtr; accumPixel = accumPixel + (UInt32)aPixel; if (brightestNeighbor < aPixel) brightestNeighbor = aPixel; inputPtr++; // 8 aPixel = *inputPtr; accumPixel = accumPixel + (UInt32)aPixel; if (brightestNeighbor < aPixel) brightestNeighbor = aPixel; inputPtr++; // 9 aPixel = *inputPtr; accumPixel = accumPixel + (UInt32)aPixel; if (brightestNeighbor < aPixel) brightestNeighbor = aPixel; // divide by the number of surrounding pixels accumPixel = accumPixel / 8; floatBrightPixel = (float)brightestNeighbor; floatBrightPixel = floatBrightPixel * 1.2; floatCenterPixel = (float)thisPixel; if (floatCenterPixel > floatBrightPixel) { numHotPixels++; // substitute average *outputPtr = (UInt16)accumPixel; } } } free(tempBuffer); } // Starfish_LogFmt("fcImage_do_hotPixel_kernel numHotPixels = %d\n", numHotPixels); } // This is the framework initialization routine and needs to be called once upon application startup void fcUsb_init(void) { int i; size_t size; UInt16 rows, cols; //On OS X, Prefer embedded App location if it exists #ifdef __APPLE__ if (getenv("INDIPREFIX") != NULL) snprintf(driverSupportPath, MAXRBUF, "%s/Contents/Resources", getenv("INDIPREFIX")); else strncpy(driverSupportPath, "/usr/local/lib/indi", MAXRBUF); strncat(driverSupportPath, "/DriverSupport/fishcamp", MAXRBUF); #else snprintf(driverSupportPath, MAXRBUF, "/lib/firmware"); #endif gDoLogging = true; // default to do logging gDoSimulation = false; Starfish_Log("fcUsb_init routine\n"); libusb_init(&gCtx); #if LIBUSB_API_VERSION >= 0x01000106 libusb_set_option(gCtx, LIBUSB_OPTION_LOG_LEVEL, 3); #else libusb_set_debug(gCtx, 3); #endif if (!gFWInitialized) { for (i = 0; i < kNumCamsSupported; i++) { gCamerasFound[i].camVendor = 0; gCamerasFound[i].camRawProduct = 0; gCamerasFound[i].camFinalProduct = 0; gCamerasFound[i].camRelease = 0; gCamerasFound[i].dev = 0; gReadBlack[i] = false; // set if the host wishes to read the black pixels gDataXfrReadMode[i] = fc_classicDataXfr; // the type of data transfers we will be using when taking picts gDataFormat[i] = fc_16b_data; // the desired camera data format gCurrentIntegrationTime[i] = 50; gRoi_left[i] = 0; gRoi_top[i] = 0; gRoi_right[i] = 1279; gRoi_bottom[i] = 1023; gCameraImageFilter[i] = fc_filter_none; gBlackPedestal[i] = 0; } gRelease = 0; gNumCamerasDiscovered = 0; gFindCamState = fcFindCam_notYetStarted; gFindCamPercentComplete = 0.0; // allocate memory for the internal frame buffer rows = 2520; cols = 3364; // cols += 16; // room for black cols size = rows * cols * 2; // 2 bytes/pixel gFrameBuffer = (UInt16 *)malloc(size); gProWantColNormalization = true; gFWInitialized = true; Starfish_Log("fcCamFw initialized\n"); } } // Call this routine to enable / disable entrie in the log file // by default, logging is turned off. The log file will be created // in C:\Program Files\fishcamp\starfish_log.txt // // loggingState = true to turn logging on // void fcUsb_setLogging(bool loggingState) { gDoLogging = loggingState; } void fcUsb_setSimulation(bool simState) { gDoSimulation = simState; } // This is the framework close routine and needs to be called just before application termination void fcUsb_close(void) { int i; free(gFrameBuffer); for (i = 0; i < kNumCamsSupported; i++) { gCamerasFound[i].camVendor = 0; gCamerasFound[i].camRawProduct = 0; gCamerasFound[i].camFinalProduct = 0; gCamerasFound[i].camRelease = 0; if (gCamerasFound[i].dev != 0) { fcUsb_CloseCamera(i + 1); gCamerasFound[i].dev = 0; } } libusb_exit(gCtx); } // the prefered way of finding and opening a communications link to any of our supported cameras // This routine will call fcUsb_OpenCameraDriver and fcUsb_CloseCameraDriver routines to do its job // // will return the actual number of cameras found. // // be carefull, this routine can take a long time (> 5 secs) to execute // // Change added 2/28/07 to allow more time between looking for the RAW camera and // looking for the final cmaera. We will look up till 10 seconds for this to happen // before giving up. // //int fcUsb_FindCameras(void) //{ // int result; // int i; // GUID guid; // bool done; // int d; // char buffer[200]; // // // Starfish_Log("fcUsb_FindCameras routine\n"); // // gFindCamState = fcFindCam_looking4supported; // gFindCamPercentComplete = 20.0; // // // // create the GUID used in the driver's .INF file that was used // // to match the driver to the starfish camera // FcStringToGUID("B0C944D5-FBAF-478e-8E70-59F80C297347", &guid); // // // get a reference to the CyAPI library that handles communication // // to any of our cameras. // gUSBDevice = new CCyUSBDevice(NULL, guid); // Create an instance of CCyUSBDevice // // Does not register for PnP events // // // Look for any starfish cameras // gNumCamerasDiscovered = gUSBDevice->DeviceCount(); // Starfish_LogFmt("fcCamFw gNumCamerasDiscovered = %d\n", gNumCamerasDiscovered); // Starfish_Log (buffer ); // // gFindCamState = fcFindCam_initializingUSB; // gFindCamPercentComplete = 50.0; // // if (gNumCamerasDiscovered > 0) // { // // find any RAW starfish cameras // d = 0; // done = false; // do { // gUSBDevice->Open(d); // Open automatically calls Close( ) if necessary // // if ((gUSBDevice->VendorID == 0x1887) && (gUSBDevice->ProductID == 0x0002)) // { // // we found one of our RAW starfish cameras // // we need to download the 'gdr_usb.hex' file to the USB controller RAM and then execute it // RawDeviceAdded(); // } // // // d++; // if (d >= gNumCamerasDiscovered) // { // done = true; // } // // } while (!done); // } // // printOutDiscoveredCamerasDB(); // // gUSBDevice->~CCyUSBDevice(); // // // // Sleep(1000); // 2/28/08 used to wait a fixed 3 seconds // // // // // found any RAW starfish cameras and renumerated them to the programmed state of the USB controller // // gFindCamState = fcFindCam_initializingIP; // gFindCamPercentComplete = 80.0; // // // // get a reference to the CyAPI library that handles communication // // to any of our cameras. // gUSBDevice = new CCyUSBDevice(NULL, guid); // Create an instance of CCyUSBDevice // // Does not register for PnP events // // // Look for any starfish cameras // // we will look every second for up till 10 seconds. // // used to just look once 2/28/08 // i = 0; // done = false; // while (!done) // { // gNumCamerasDiscovered = gUSBDevice->DeviceCount(); // Starfish_LogFmt("fcCamFw gNumCamerasDiscovered = %d\n", gNumCamerasDiscovered); // Starfish_Log( buffer ); // // i++; // if ((gNumCamerasDiscovered > 0) || (i > 10)) // done = true; // // Sleep(1000); // } // // if (gNumCamerasDiscovered > 0) // { // // find any RAW starfish cameras // d = 0; // done = false; // do { // gUSBDevice->Open(d); // Open automatically calls Close( ) if necessary // // // make sure device is reset // gUSBDevice->Reset(); // gUSBDevice->Open(d); // // if ((gUSBDevice->VendorID == 0x1887) && (gUSBDevice->ProductID == 0x0003)) // { // // we found one of our RAW starfish cameras // // we need to download the 'gdr_usb.hex' file to the USB controller RAM and then execute it // NewDeviceAdded(); // } // // // d++; // if (d >= gNumCamerasDiscovered) // { // done = true; // } // // } while (!done); // // } // // printOutDiscoveredCamerasDB(); // // // // gFindCamState = fcFindCam_finished; // gFindCamPercentComplete = 100.0; // // // // if (gNumCamerasDiscovered > 0) // { // // set some default timeouts // gUSBDevice->BulkInEndPt->TimeOut = 20000; // increased to 20000 from 10000 6_13_10 // gUSBDevice->BulkOutEndPt->TimeOut = 20000; // increased to 20000 from 10000 6_13_10 // // // see results //// printOutDiscoveredCamerasDB(); // // // set some camera defaults // for (i = 0; i < gNumCamerasDiscovered; i++) // { // if (gCamerasFound[i].camFinalProduct == starfish_mono_rev2_final_deviceID) // is this a Starfish? // { // Starfish_LogFmt("Found Starfish - SN%04d\n", gCamerasFound[i].camRelease); // Starfish_Log( buffer ); // fcUsb_setStarfishDefaultRegs(i+1); // } // } // // } // // return gNumCamerasDiscovered; //} // will return the actual number of cameras found. // This routine will call fcUsb_OpenCameraDriver and fcUsb_CloseCameraDriver routines to do its job on any RAW cameras found. // It will return negative one if a raw camera is found and needs to be run again. // //int fcUsb_FindCameras(struct libusb_context *ctx) int fcUsb_FindCameras(void) { struct libusb_config_descriptor *cdesc; struct libusb_device **devs_list; //struct libusb_interface_descriptor *idesc; //struct libusb_endpoint_descriptor *edesc; struct libusb_device_descriptor descriptor; libusb_device *device; int cnt; //int ret; int i; //int j, k, l; int retValue, err; UInt16 vendor; UInt16 product; UInt16 release; int index; //int kr; Starfish_Log("fcUsb_FindCameras routine\n"); gNumCamerasDiscovered = 0; gFindCamState = fcFindCam_looking4supported; gFindCamPercentComplete = 20.0; if (gDoSimulation) { gFindCamState = fcFindCam_finished; gFindCamPercentComplete = 100.0; gCamerasFound[0].camVendor = fishcamp_USB_VendorID; gCamerasFound[0].camRawProduct = starfish_mono_rev2_raw_deviceID; gCamerasFound[0].camFinalProduct = starfish_mono_rev2_final_deviceID; gCamerasFound[0].camRelease = 12345; gCamerasFound[0].dev = 0; gNumCamerasDiscovered = 1; return gNumCamerasDiscovered; } if ((cnt = libusb_get_device_list(gCtx, &devs_list)) < 0) { Starfish_LogFmt(" libusb_get_device_list failed with 0x%x error code\n", cnt); return (EXIT_FAILURE); } if (cnt == 0) { Starfish_LogFmt(" No device match or lack of permissions.\n"); return (EXIT_SUCCESS); } Starfish_LogFmt("There are %i devices\n", cnt); for (i = 0; i < cnt; i++) { Starfish_LogFmt("|-- device number = %i\n", i); device = devs_list[i]; err = libusb_get_device_descriptor(device, &descriptor); vendor = descriptor.idVendor; product = descriptor.idProduct; release = descriptor.bcdDevice; Starfish_LogFmt("|---- vendor = %08x\n", vendor); Starfish_LogFmt("|---- product = %08x\n", product); Starfish_LogFmt("|---- release = %08x\n", release); if ((vendor == fishcamp_USB_VendorID) && (product == starfish_mono_rev2_raw_deviceID)) { // we found one of our RAW starfish cameras // put the new RAW camera in our data base if (!sawThisCameraAlready(vendor, product, 0xffff, release)) { index = getNextFreeDBIndex(); gCamerasFound[index].camVendor = vendor; gCamerasFound[index].camRawProduct = product; gCamerasFound[index].camFinalProduct = 0; gCamerasFound[index].camRelease = release; gCamerasFound[index].dev = 0; Starfish_LogFmt("|---- RawDeviceAdded - added RAW camera to DB index at index = %d\n", index); //This is to initialize the Raw cameras that haven't been seen before. Find Cameras must be run again afterwards. int rc = fcUsb_OpenCamera(i + 1); Starfish_LogFmt("fcUsb_OpenCamera to initialize it: opening cam #%d, returns %d\n", i + 1, rc); rc = fcUsb_CloseCamera(i + 1); Starfish_LogFmt("fcUsb_CloseCamera to initialize it: opening cam #%d, returns %d\n", i + 1, rc); return -1; } } if ((vendor == fishcamp_USB_VendorID) && (product == starfish_mono_rev2_final_deviceID)) { // put the new initialized camera in our data base // at this point only the RAW version of the camera will be in the data base, if at all. It // won't be in it at all if we re-started the application after previously been running // and the camera is already initialized from before. // by convention, the RAW productID will be an even number, the initialized version will be odd. // we use this knowledge to look for any previous entries of the RAW version of this camera. if (!sawThisCameraAlready(vendor, product & 0xfffe, 0xffff, release)) { // here if we haven't seen this camera in its RAW state // check to see if it was already addded in its initialized state. add it if not. if (getCameraDBIndex(vendor, 0xffff, product, release) == -1) { index = getNextFreeDBIndex(); gCamerasFound[index].camVendor = vendor; gCamerasFound[index].camRawProduct = product & 0xfffe; gCamerasFound[index].camFinalProduct = product; gCamerasFound[index].camRelease = release; gCamerasFound[index].dev = 0; Starfish_LogFmt("|---- NewDeviceAdded - added FINAL camera to DB at index = %d\n", index); } else Starfish_Log("|---- NewDeviceAdded - FINAL camera already in DB\n"); } else { index = getCameraDBIndex(vendor, product & 0xfffe, 0xffff, release); gCamerasFound[index].camVendor = vendor; // don't touch the following field. we already saw this camera added as a RAW device // gCamerasFound[index].camRawProduct = 0; gCamerasFound[index].camFinalProduct = product; gCamerasFound[index].camRelease = release; gCamerasFound[index].dev = 0; Starfish_LogFmt("|---- NewDeviceAdded - updating RAW camera at DB index = %d\n", index); } } retValue = libusb_get_active_config_descriptor(devs_list[i], &cdesc); if (retValue == LIBUSB_SUCCESS) { Starfish_LogFmt("|---- bLength : 0x%.2x\n", cdesc->bLength); Starfish_LogFmt("|---- bDescriptorType : 0x%.2x\n", cdesc->bDescriptorType); Starfish_LogFmt("|---- wTotalLength : 0x%.2x\n", cdesc->wTotalLength); Starfish_LogFmt("|---- bNumInterfaces : 0x%.2x\n", cdesc->bNumInterfaces); Starfish_LogFmt("|---- bConfigurationValue : 0x%.2x\n", cdesc->bConfigurationValue); Starfish_LogFmt("|---- iConfiguration : 0x%.2x\n", cdesc->iConfiguration); Starfish_LogFmt("|---- bmAttributes : 0x%.2x\n", cdesc->bmAttributes); Starfish_LogFmt("|---- MaxPower : 0x%.2x\n", cdesc->MaxPower); // for (j = 0 ; j < cdesc->bNumInterfaces ; j++) // { // for (k = 0 ; k < cdesc->interface[j].num_altsetting ; k++) // { // idesc = &cdesc->interface[j].altsetting[k]; // printf("|---- INTERFACE :\n"); // printf("|------ Interface %i%i\n", j, k); // printf("|------ bLength 0x%.2x\n", idesc->bLength); // printf("|------ bDescriptorType 0x%.2x\n", idesc->bDescriptorType); // printf("|------ bInterfaceNumber 0x%.2x\n", idesc->bInterfaceNumber); // printf("|------ bAlternateSetting 0x%.2x\n", idesc->bAlternateSetting); // printf("|------ bNumEndpoints 0x%.2x\n", idesc->bNumEndpoints); // printf("|------ bInterfaceClass 0x%.2x\n", idesc->bInterfaceClass); // printf("|------ bInterfaceSubClass 0x%.2x\n", idesc->bInterfaceSubClass); // printf("|------ bInterfaceProtocol 0x%.2x\n", idesc->bInterfaceProtocol); // printf("|------ iInterface 0x%.2x\n|\n", idesc->iInterface); // for (l = 0 ; l < idesc->bNumEndpoints ; l++) // { // edesc = &idesc->endpoint[l]; // printf("|------ ENDPOINT DESCRIPTOR :\n"); // printf("|-------- bLength 0x%.2x\n", edesc->bLength); // printf("|-------- bDescriptorType 0x%.2x\n", edesc->bDescriptorType); // printf("|-------- bEndpointAddress 0x%.2x\n", edesc->bEndpointAddress); // printf("|-------- bmAttributes 0x%.2x\n", edesc->bmAttributes); // printf("|-------- wMaxPacketSize 0x%.4x\n", edesc->wMaxPacketSize); // printf("|-------- bInterval 0x%.2x\n", edesc->bInterval); // printf("|-------- bRefresh 0x%.2x\n", edesc->bRefresh); // printf("|-------- bSynchAddress 0x%.2x\n|\n", edesc->bSynchAddress); // } // for l // } // for k // } // for j } // if (retValue == LIBUSB_SUCCESS) else { Starfish_LogFmt("libusb_get_active_config_descriptor failed: %s\n", libusb_error_name(retValue)); return (EXIT_FAILURE); } } // for i libusb_free_config_descriptor(cdesc); printOutDiscoveredCamerasDB(); gFindCamState = fcFindCam_finished; gFindCamPercentComplete = 100.0; gNumCamerasDiscovered = getNextFreeDBIndex(); return gNumCamerasDiscovered; } // call this routine to know how what state the fcUsb_FindCameras routine is currently executing // will return a result of fcFindCamState type // int fcUsb_GetFindCamsState(void) { return gFindCamState; } // call this routine to know how long it will take for the fcUsb_FindCameras routine to complete. // float fcUsb_GetFindCamsPercentComplete(void) { return gFindCamPercentComplete; } // need to open the camera before using it. // valid camNum is 1 -> fcUsb_GetNumCameras() // int fcUsb_OpenCamera(int camNum) { //int result; //int i; //bool done; //int d; UInt16 vendor; UInt16 product; UInt16 release; struct libusb_device_handle *usb_handle; int kr; int tries; int retval; Starfish_Log("fcUsb_OpenCamera routine\n"); if (gDoSimulation) { Starfish_LogFmt("Found Starfish - SN%04d\n", gCamerasFound[camNum - 1].camRelease); fcUsb_setStarfishDefaultRegs(camNum); return 0; } if (gCamerasFound[camNum - 1].dev == 0) { // this camera wasn't being used yet vendor = gCamerasFound[camNum - 1].camVendor; if (vendor != 0) { // this camera has a DB entry product = gCamerasFound[camNum - 1].camFinalProduct; if (product == 0) { // we have a RAW starfish camera being opened product = gCamerasFound[camNum - 1].camRawProduct; Starfish_LogFmt("Opening raw USB device with vendor: %08x prodcut: %08x\n", vendor, product); usb_handle = libusb_open_device_with_vid_pid(gCtx, vendor, product); gCamerasFound[camNum - 1].dev = usb_handle; if (usb_handle == NULL) { Starfish_Log("Unable to open the raw USB device\n"); return -1; } // the ReleaseNumber is used by fishcamp as a camera serial number. Store it away // make sure we store the camera serial number in gRelease. // the DownloadToAnchorDevice routine will make sure the newly renumerated // camera will have the same serial number. release = gCamerasFound[camNum - 1].camRelease; gRelease = release; kr = DownloadToAnchorDevice(usb_handle, vendor, product); if (0 != kr) { Starfish_LogFmt("unable to download to device: %08x\n", kr); libusb_close(usb_handle); return -1; } libusb_close(usb_handle); usb_handle = NULL; gCamerasFound[camNum - 1].dev = usb_handle; // found a RAW starfish cameras and renumerated it to the programmed state of the USB controller // the RAW camera has been renumerated. Wait for it to brecome ready // takes about three seconds for the device to reset and my laptop to find it again. Wait for 10. product = product + 1; for (tries = 0; tries < 25; tries++) { usb_handle = libusb_open_device_with_vid_pid(gCtx, vendor, product); if (usb_handle) { gCamerasFound[camNum - 1].camFinalProduct = product; break; } usleep(400 * 1000); } // let the device settle -- sometimes we're able to open it before it's ready to accept the S-Record download usleep(1000 * 1000); gCamerasFound[camNum - 1].dev = usb_handle; if (usb_handle == NULL) { Starfish_Log("Unable to open the final USB device\n"); } else { retval = libusb_claim_interface(usb_handle, 0); if (retval < 0) Starfish_Log("Couldn't claim interface 0\n"); // one last thing.... // need to load the MicroBlaze executable program before doing any camera stuff. if (gCamerasFound[camNum - 1].camRawProduct != 0) // if the camera was discovered in the RAW state. we will know this cause it will be non-zero { Starfish_Log("Calling - DownloadtToMicroBlaze \n"); DownloadtToMicroBlaze(camNum); } else { Starfish_Log("didn't need to call - DownloadtToMicroBlaze \n"); } // download_srec(usb_handle, argv[1], FC_STARFISH_BULK_OUT_ENDPOINT); } } //(product == 0) // we have a RAW starfish camera being opened else { // we have a FINAL starfish camera being opened Starfish_Log("we have a FINAL starfish camera being opened.\n"); usb_handle = libusb_open_device_with_vid_pid(gCtx, vendor, product); gCamerasFound[camNum - 1].dev = usb_handle; if (usb_handle == NULL) { Starfish_Log("Unable to open the final USB device\n"); } else { retval = libusb_claim_interface(usb_handle, 0); if (retval < 0) Starfish_Log("Couldn't claim interface 0\n"); if (gCamerasFound[camNum - 1].camFinalProduct == starfish_mono_rev2_final_deviceID) // is this a Starfish? { Starfish_LogFmt("Found Starfish - SN%04d\n", gCamerasFound[camNum - 1].camRelease); fcUsb_setStarfishDefaultRegs(camNum); } } } // we have a FINAL starfish camera being opened } // if - this camera has a DB entry } // this camera wasn't being used yet // printOutDiscoveredCamerasDB(); return 0; } // call this routine after you are finished making calls to this camera // This routine will free the designated camera for other applications to use // valid camNum is 1 -> fcUsb_GetNumCameras() // int fcUsb_CloseCamera(int camNum) { if (gDoSimulation) return 0; if (gCamerasFound[camNum - 1].dev) { libusb_release_interface(gCamerasFound[camNum - 1].dev, 0); libusb_reset_device(gCamerasFound[camNum - 1].dev); libusb_close(gCamerasFound[camNum - 1].dev); gCamerasFound[camNum - 1].dev = NULL; return 0; } return -1; } // call this routine to know how many of our supported cameras are available for use. // int fcUsb_GetNumCameras(void) { return gNumCamerasDiscovered; } bool fcUsb_haveCamera(void) { bool haveCamera; haveCamera = true; // do we have at least one camera? if (gNumCamerasDiscovered == 0) haveCamera = false; return haveCamera; } // return the numeric serial number of the camera specified. // valid camNum is 1 -> fcUsb_GetNumCameras() // int fcUsb_GetCameraSerialNum(int camNum) { return gCamerasFound[camNum - 1].camRelease; } // return the numeric vendorID of the camera specified. // valid camNum is 1 -> fcUsb_GetNumCameras() // int fcUsb_GetCameraVendorID(int camNum) { return gCamerasFound[camNum - 1].camVendor; } // return the numeric productID of the camera specified. // valid camNum is 1 -> fcUsb_GetNumCameras() // int fcUsb_GetCameraProductID(int camNum) { return gCamerasFound[camNum - 1].camFinalProduct; } // send the nop command to the starfish camera // int fcUsb_cmd_nop(int camNum) { UInt32 msgSize; fc_no_param myParameters; UInt32 numBytesRead; int maxBytes; Starfish_Log("fcUsb_cmd_nop\n"); if (gDoSimulation) return 0; myParameters.header = 'fc'; myParameters.command = fcNOP; myParameters.length = sizeof(myParameters); myParameters.cksum = fcUsb_GetUsbCmdCksum(&myParameters.header); msgSize = sizeof(myParameters); SendUSB(camNum, (unsigned char *)&myParameters, (int)msgSize); // get the ACK to the command maxBytes = 512; numBytesRead = RcvUSB(camNum, (unsigned char *)&gBuffer, maxBytes); return 0; } // send the rst command to the starfish camera // int fcUsb_cmd_rst(int camNum) { UInt32 msgSize; fc_no_param myParameters; UInt32 numBytesRead; int maxBytes; Starfish_Log("fcUsb_cmd_rst\n"); if (gDoSimulation) return 0; myParameters.header = 'fc'; myParameters.command = fcRST; myParameters.length = sizeof(myParameters); myParameters.cksum = fcUsb_GetUsbCmdCksum(&myParameters.header); msgSize = sizeof(myParameters); SendUSB(camNum, (unsigned char *)&myParameters, (int)msgSize); // get the ACK to the command maxBytes = 512; numBytesRead = RcvUSB(camNum, (unsigned char *)&gBuffer, maxBytes); return 0; } // send the fcGETINFO command to the starfish camera // read the return information // int fcUsb_cmd_getinfo(int camNum, fc_camInfo *camInfo) { UInt32 msgSize; UInt32 numBytesRead; fc_no_param myParameters; UInt16 *wordPtr1; UInt16 *wordPtr2; size_t i; int maxBytes; Starfish_Log("fcUsb_cmd_getinfo\n"); if (gDoSimulation) { camInfo->boardRevision = 1; camInfo->boardVersion = 2; camInfo->fpgaRevision = 1; camInfo->fpgaVersion = 2; camInfo->pixelHeight = 7; camInfo->pixelWidth = 7; camInfo->width = 1280; camInfo->height = 1024; } else { // send the command to the camera myParameters.header = 'fc'; myParameters.command = fcGETINFO; myParameters.length = sizeof(myParameters); myParameters.cksum = fcUsb_GetUsbCmdCksum(&myParameters.header); msgSize = sizeof(myParameters); SendUSB(camNum, (unsigned char *)&myParameters, (int)msgSize); // get the response to the command maxBytes = 512; numBytesRead = RcvUSB(camNum, (unsigned char *)&gBuffer, maxBytes); // we have the ACK message in gBuffer. It is proceeded by two words before the fc_camInfo // data. copy the real data to the user's data structure. wordPtr1 = (UInt16 *)&gBuffer[4]; wordPtr2 = (UInt16 *)camInfo; for (i = 0; i < sizeof(fc_camInfo); i += 2) *wordPtr2++ = *wordPtr1++; } // bug fix. The starfish puts out garbled text for the camera name string strcpy((char*)camInfo->camNameStr, "Starfish Mono"); // also need to fix up the serial number sprintf((char*)camInfo->camSerialStr, "%04x-%04x-%04x-%04x", gCamerasFound[camNum - 1].camVendor, gCamerasFound[camNum - 1].camRawProduct, gCamerasFound[camNum - 1].camFinalProduct, gCamerasFound[camNum - 1].camRelease); // JM (2013-12-13) camInfo->pixelWidth returns 1312 (0x520) which is wrong camInfo->pixelWidth = 52; camInfo->pixelHeight = 52; // print out the information returned Starfish_Log("fcUsb_cmd_getinfo:\n"); Starfish_LogFmt(" boardVersion - 0x%02x\n", camInfo->boardVersion); Starfish_LogFmt(" boardRevision - 0x%02x\n", camInfo->boardRevision); Starfish_LogFmt(" fpgaVersion - 0x%02x\n", camInfo->fpgaVersion); Starfish_LogFmt(" fpgaRevision - 0x%02x\n", camInfo->fpgaRevision); Starfish_LogFmt(" width - 0x%02x\n", camInfo->width); Starfish_LogFmt(" height - 0x%02x\n", camInfo->height); Starfish_LogFmt(" pixelWidth - 0x%02x\n", camInfo->pixelWidth); Starfish_LogFmt(" pixelHeight - 0x%02x\n", camInfo->pixelHeight); Starfish_LogFmt(" camSerialStr - %s\n", camInfo->camSerialStr); Starfish_LogFmt(" camNameStr - %s\n", camInfo->camNameStr); return 0; } // call to set a low level register in the camera // // for Starfish camera: // - call to set a low level register in the micron image sensor // - enter with the micron address register, and register data value // refer to the micron image sensor documentation for details // on available registers and bit definitions // // for IBIS1300 // - call to set the serial configuration word on the camera // - enter with regAddress = 0, dataValue // // valid camNum is 1 -> fcUsb_GetNumCameras() // int fcUsb_cmd_setRegister(int camNum, UInt16 regAddress, UInt16 dataValue) { UInt32 msgSize; fc_setReg_param myParameters; UInt32 numBytesRead; int maxBytes; // print out the information // printf("fcUsb_cmd_setRegister:\n"); // printf(" address - 0x%04x\n", regAddress); // printf(" data - 0x%04x\n", dataValue); Starfish_Log("fcUsb_cmd_setRegister\n"); if (gDoSimulation) return 0; myParameters.header = 'fc'; myParameters.command = fcSETREG; myParameters.length = sizeof(myParameters); myParameters.registerAddress = regAddress; myParameters.dataValue = dataValue; myParameters.cksum = fcUsb_GetUsbCmdCksum(&myParameters.header); msgSize = sizeof(myParameters); SendUSB(camNum, (unsigned char *)&myParameters, (int)msgSize); // get the ACK to the command maxBytes = 512; numBytesRead = RcvUSB(camNum, (unsigned char *)&gBuffer, maxBytes); return 0; } // call to get a low level register from the micron image sensor // UInt16 fcUsb_cmd_getRegister(int camNum, UInt16 regAddress) { UInt32 msgSize; fc_getReg_param myParameters; UInt32 numBytesRead; //UInt16 retValue; fc_regInfo myRegInfo; // int maxBytes; Starfish_Log("fcUsb_cmd_getRegister\n"); if (gDoSimulation) return 0; myParameters.header = 'fc'; myParameters.command = fcGETREG; myParameters.length = sizeof(myParameters); myParameters.registerAddress = regAddress; myParameters.cksum = fcUsb_GetUsbCmdCksum(&myParameters.header); msgSize = sizeof(myParameters); // Starfish_LogFmt(" myParameters.header - 0x%04x\n", myParameters.header); // Starfish_LogFmt(" myParameters.command - 0x%04x\n", myParameters.command); // Starfish_LogFmt(" myParameters.length - 0x%04x\n", myParameters.length); // Starfish_LogFmt(" myParameters.registerAddress - 0x%04x\n", myParameters.registerAddress); // Starfish_LogFmt(" myParameters.cksum - 0x%04x\n", myParameters.cksum); // Starfish_LogFmt(" msgSize - 0x%08x\n", msgSize); // Starfish_LogFmt(" gUSBDevice - 0x%08x\n", gUSBDevice); // Starfish_LogFmt(" BulkOutEndPt - 0x%08x\n", gUSBDevice->BulkOutEndPt); SendUSB(camNum, (unsigned char *)&myParameters, (int)msgSize); // Starfish_LogFmt(" msgSize - 0x%08x\n", msgSize); // get the ACK to the command maxBytes = 512; // Starfish_LogFmt(" numBytesRead - 0x%08x\n", numBytesRead); numBytesRead = RcvUSB(camNum, (unsigned char *)&gBuffer, maxBytes); // copy the Rx buffer to my local storage memcpy(&myRegInfo, &gBuffer, sizeof(myRegInfo)); // // print out the information returned // Starfish_LogFmt("fcUsb_cmd_getRegister:\n"); // Starfish_LogFmt(" address - 0x%04x\n", regAddress); // Starfish_LogFmt(" header - 0x%04x\n", myRegInfo.header); // Starfish_LogFmt(" command - 0x%04x\n", myRegInfo.command); // Starfish_LogFmt(" dataValue - 0x%04x\n", myRegInfo.dataValue); // Starfish_LogFmt(" numBytesRead - 0x%08x\n", numBytesRead); return myRegInfo.dataValue; } // call to set the integration time register. only 22 LSB significant (69 minutes with 1ms resolution) // int fcUsb_cmd_setIntegrationTime(int camNum, UInt32 theTime) { UInt32 msgSize; fc_setIntTime_param myParameters; UInt32 numBytesRead; UInt16 aWord; int maxBytes; Starfish_Log("fcUsb_cmd_setIntegrationTime\n"); if (gDoSimulation) return 0; // store the time away so we can decide if we want to read the black columns gCurrentIntegrationTime[camNum - 1] = theTime; //This is a nice idea, but there are 2 problems with it. //First, with the Starfish, for some reason the images fail to download when full frame images are requested. //I believe this is due to the fact that it is requesting images that are larger than it can do. //Second, if the region of interest is smaller than full frame, the images will download properly, but //then the black column positions will make no sense because the region of interest is not adjacent to black columns then. /** // special handling for the starfish guide camera if (gCamerasFound[camNum - 1].camFinalProduct == starfish_mono_rev2_final_deviceID) { // tell the camera the new setting of the read black cols mode bit. We will read the // black cols anytime the integration time is less than 2 seconds. fcUsb_cmd_setReadMode(camNum, gDataXfrReadMode[camNum - 1], gDataFormat[camNum - 1]); // resend the ROI params. the fcUsb_cmd_setReadMode routine will have set the gReadBlack variable // so the next routine will trick the camera into using a wider ROI. fcUsb_cmd_setRoi(camNum, gRoi_left[camNum - 1], gRoi_top[camNum - 1], gRoi_right[camNum - 1], gRoi_bottom[camNum - 1]); } **/ myParameters.header = 'fc'; myParameters.command = fcSETINTTIME; myParameters.length = sizeof(myParameters); aWord = theTime >> 16; aWord = aWord & 0x0ffff; myParameters.timeHi = aWord; aWord = theTime & 0x0ffff; myParameters.timeLo = aWord; myParameters.cksum = fcUsb_GetUsbCmdCksum(&myParameters.header); msgSize = sizeof(myParameters); SendUSB(camNum, (unsigned char *)&myParameters, (int)msgSize); // get the ACK to the command maxBytes = 512; numBytesRead = RcvUSB(camNum, (unsigned char *)&gBuffer, maxBytes); return 0; } // command to set the integration time period of the guider portion of // the IBIS1300 image sensor. This command is not recognized by the Starfish camera // int fcUsb_cmd_setGuiderIntegrationTime(int camNum, UInt32 theTime) { UInt32 msgSize; fc_setIntTime_param myParameters; UInt32 numBytesRead; UInt16 aWord; int maxBytes; Starfish_Log("fcUsb_cmd_setGuiderIntegrationTime\n"); if (gDoSimulation) return 0; // store the time away so we can decide if we want to read the black columns gCurrentIntegrationTime[camNum - 1] = theTime; // only the ibis1300 camera supports this right now if (gCamerasFound[camNum - 1].camFinalProduct == starfish_ibis13_final_deviceID) { // store the time away so we can decide if we want to read the black columns gCurrentGuiderIntegrationTime[camNum - 1] = theTime; myParameters.header = 'fc'; myParameters.command = fcSETGUIDEINTTIME; myParameters.length = sizeof(myParameters); aWord = theTime >> 16; aWord = aWord & 0x0ffff; myParameters.timeHi = aWord; aWord = theTime & 0x0ffff; myParameters.timeLo = aWord; myParameters.cksum = fcUsb_GetUsbCmdCksum(&myParameters.header); msgSize = sizeof(myParameters); SendUSB(camNum, (unsigned char *)&myParameters, (int)msgSize); // get the ACK to the command maxBytes = 512; numBytesRead = RcvUSB(camNum, (unsigned char *)&gBuffer, maxBytes); } return 0; } // send the 'start exposure' command to the camera // int fcUsb_cmd_startExposure(int camNum) { UInt32 msgSize; fc_no_param myParameters; UInt32 numBytesRead; int maxBytes; Starfish_Log("fcUsb_cmd_startExposure\n"); if (gDoSimulation) return 0; myParameters.header = 'fc'; myParameters.command = fcSTARTEXP; myParameters.length = sizeof(myParameters); myParameters.cksum = fcUsb_GetUsbCmdCksum(&myParameters.header); msgSize = sizeof(myParameters); SendUSB(camNum, (unsigned char *)&myParameters, (int)msgSize); // get the ACK to the command maxBytes = 512; numBytesRead = RcvUSB(camNum, (unsigned char *)&gBuffer, maxBytes); return 0; } // send the 'start exposure' command to the guider portion of the // IBIS1300 image sensor. This command is not recognized by the Starfish camera // int fcUsb_cmd_startGuiderExposure(int camNum) { UInt32 msgSize; fc_no_param myParameters; UInt32 numBytesRead; int maxBytes; Starfish_Log("fcUsb_cmd_startGuiderExposure\n"); if (gDoSimulation) return 0; // only the ibis1300 camera supports this right now if (gCamerasFound[camNum - 1].camFinalProduct == starfish_ibis13_final_deviceID) { myParameters.header = 'fc'; myParameters.command = fcSTARTGUIDEEXP; myParameters.length = sizeof(myParameters); myParameters.cksum = fcUsb_GetUsbCmdCksum(&myParameters.header); msgSize = sizeof(myParameters); SendUSB(camNum, (unsigned char *)&myParameters, (int)msgSize); // get the ACK to the command maxBytes = 512; numBytesRead = RcvUSB(camNum, (unsigned char *)&gBuffer, maxBytes); } return 0; } // send the 'abort exposure' command to the camera // int fcUsb_cmd_abortExposure(int camNum) { UInt32 msgSize; fc_no_param myParameters; UInt32 numBytesRead; int maxBytes; Starfish_Log("fcUsb_cmd_abortExposure\n"); if (gDoSimulation) return 0; myParameters.header = 'fc'; myParameters.command = fcABORTEXP; myParameters.length = sizeof(myParameters); myParameters.cksum = fcUsb_GetUsbCmdCksum(&myParameters.header); msgSize = sizeof(myParameters); SendUSB(camNum, (unsigned char *)&myParameters, (int)msgSize); // get the ACK to the command maxBytes = 512; numBytesRead = RcvUSB(camNum, (unsigned char *)&gBuffer, maxBytes); return 0; } // send the 'abort Guider exposure' command to the camera // This command is not recognized by the Starfish camera // // valid camNum is 1 -> fcUsb_GetNumCameras() // int fcUsb_cmd_abortGuiderExposure(int camNum) { UInt32 msgSize; fc_no_param myParameters; UInt32 numBytesRead; int maxBytes; Starfish_Log("fcUsb_cmd_abortGuiderExposure\n"); if (gDoSimulation) return 0; // only the ibis1300 camera supports this right now if (gCamerasFound[camNum - 1].camFinalProduct == starfish_ibis13_final_deviceID) { myParameters.header = 'fc'; myParameters.command = fcABORTGUIDEEXP; myParameters.length = sizeof(myParameters); myParameters.cksum = fcUsb_GetUsbCmdCksum(&myParameters.header); msgSize = sizeof(myParameters); SendUSB(camNum, (unsigned char *)&myParameters, (int)msgSize); // get the ACK to the command maxBytes = 512; numBytesRead = RcvUSB(camNum, (unsigned char *)&gBuffer, maxBytes); } return 0; } // send a command to get the current camera state // UInt16 fcUsb_cmd_getState(int camNum) { UInt32 msgSize; fc_no_param myParameters; UInt32 numBytesRead; //UInt16 retValue; fc_regInfo myRegInfo; int maxBytes; if (gDoSimulation) return 0; // printf("fcUsb_cmd_getState:\n"); // Starfish_Log("fcUsb_cmd_getState\n"); myParameters.header = 'fc'; myParameters.command = fcGETSTATE; myParameters.length = sizeof(myParameters); myParameters.cksum = fcUsb_GetUsbCmdCksum(&myParameters.header); msgSize = sizeof(myParameters); SendUSB(camNum, (unsigned char *)&myParameters, (int)msgSize); // printf("fcUsb_cmd_getState - about to read:\n"); // get the ACK to the command maxBytes = 512; numBytesRead = RcvUSB(camNum, (unsigned char *)&gBuffer, maxBytes); // copy the Rx buffer to my local storage memcpy(&myRegInfo, &gBuffer, sizeof(myRegInfo)); // print out the information returned // printf("fcUsb_cmd_getState:\n"); // printf(" dataValue - 0x%02x\n", myRegInfo.dataValue); usleep(10000); return myRegInfo.dataValue; } // send a command to get the current camera state of the guider sensor // This command is not recognized by the Starfish camera // // valid camNum is 1 -> fcUsb_GetNumCameras() // return values are: // 0 - idle // 1 - integrating // 2 - processing image // UInt16 fcUsb_cmd_getGuiderState(int camNum) { UInt32 msgSize; fc_no_param myParameters; UInt32 numBytesRead; //UInt16 retValue; fc_regInfo myRegInfo; int maxBytes; // printf("fcUsb_cmd_getGuiderState:\n"); Starfish_Log("fcUsb_cmd_getGuiderState\n"); if (gDoSimulation) return 0; // only the ibis1300 camera supports this right now if (gCamerasFound[camNum - 1].camFinalProduct == starfish_ibis13_final_deviceID) { myParameters.header = 'fc'; myParameters.command = fcGETGUIDESTATE; myParameters.length = sizeof(myParameters); myParameters.cksum = fcUsb_GetUsbCmdCksum(&myParameters.header); msgSize = sizeof(myParameters); SendUSB(camNum, (unsigned char *)&myParameters, (int)msgSize); // printf("fcUsb_cmd_getGuiderState - about to read:\n"); // get the ACK to the command maxBytes = 512; numBytesRead = RcvUSB(camNum, (unsigned char *)&gBuffer, maxBytes); // copy the Rx buffer to my local storage memcpy(&myRegInfo, &gBuffer, sizeof(myRegInfo)); // print out the information returned // printf("fcUsb_cmd_getGuiderState:\n"); // printf(" dataValue - 0x%02x\n", myRegInfo.dataValue); usleep(10000000); return myRegInfo.dataValue; } else { return 0; // idle state if not supported } } // turn on/off the frame grabber's test pattern generator // 0 = off, 1 = on // int fcUsb_cmd_setFrameGrabberTestPattern(int camNum, UInt16 state) { UInt32 msgSize; fc_setFgTp_param myParameters; UInt32 numBytesRead; //UInt16 retValue; int maxBytes; Starfish_Log("fcUsb_cmd_setFrameGrabberTestPattern\n"); if (gDoSimulation) return 0; myParameters.header = 'fc'; myParameters.command = fcSETFGTP; myParameters.length = sizeof(myParameters); myParameters.state = state; myParameters.cksum = fcUsb_GetUsbCmdCksum(&myParameters.header); msgSize = sizeof(myParameters); SendUSB(camNum, (unsigned char *)&myParameters, (int)msgSize); // get the ACK to the command maxBytes = 512; numBytesRead = RcvUSB(camNum, (unsigned char *)&gBuffer, maxBytes); return 0; } // here to read a specific scan line from the camera's frame grabber buffer // int fcUsb_cmd_rdScanLine(int camNum, UInt16 lineNum, UInt16 Xmin, UInt16 Xmax, UInt16 *lineBuffer) { UInt32 msgSize; UInt32 numBytesRead; fc_rdScanLine_param myParameters; UInt16 dataOdd; UInt16 dataEven; UInt16 *wordPtr1; UInt16 *wordPtr2; int i; int scanLineSize; fc_scanLineInfo myScanLineInfo; int maxBytes; Starfish_Log("fcUsb_cmd_rdScanLine\n"); // send the command to the camera myParameters.header = 'fc'; myParameters.command = fcRDSCANLINE; myParameters.LineNum = lineNum; myParameters.padZero = 0; myParameters.Xmin = Xmin; myParameters.Xmax = Xmax; myParameters.length = sizeof(myParameters); myParameters.cksum = fcUsb_GetUsbCmdCksum(&myParameters.header); msgSize = sizeof(myParameters); SendUSB(camNum, (unsigned char *)&myParameters, (int)msgSize); // get the response to the command maxBytes = (((Xmax - Xmin) + 1) * 2) + 12; // bigger is OK maxBytes = 2048; maxBytes = sizeof(myScanLineInfo); maxBytes = 4608; numBytesRead = RcvUSB(camNum, (unsigned char *)&myScanLineInfo, maxBytes); // we have the ACK message in myScanLineInfo. It is proceeded by several words before the fc_scanLineInfo // data. copy the real data to the user's data structure. wordPtr1 = &myScanLineInfo.lineBuffer[0]; wordPtr2 = lineBuffer; scanLineSize = Xmax - Xmin + 1; for (i = 0; i < scanLineSize; i = i + 2) { // *wordPtr2++ = *wordPtr1++; dataOdd = *wordPtr1++; dataEven = *wordPtr1++; // *wordPtr2++ = dataEven; // *wordPtr2++ = dataOdd; *wordPtr2++ = dataOdd; *wordPtr2++ = dataEven; } return 0; } // here to specify a new ROI to the sensor // X = 0 -> 2047 // Y = 0 -> 1535 // int fcUsb_cmd_setRoi(int camNum, UInt16 left, UInt16 top, UInt16 right, UInt16 bottom) { UInt32 msgSize; fc_setRoi_param myParameters; UInt32 numBytesRead; //UInt16 regVal; int maxBytes; Starfish_Log("fcUsb_cmd_setRoi\n"); // store user requested number away gRoi_left[camNum - 1] = left; gRoi_top[camNum - 1] = top; gRoi_right[camNum - 1] = right; gRoi_bottom[camNum - 1] = bottom; if (gDoSimulation) return 0; myParameters.header = 'fc'; myParameters.command = fcSETROI; myParameters.length = sizeof(myParameters); myParameters.left = left; myParameters.top = top; myParameters.right = right; myParameters.bottom = bottom; // if we need to read the black cols, increase the ROI width appropriately if (gReadBlack[camNum - 1]) myParameters.right = right + 16; myParameters.cksum = fcUsb_GetUsbCmdCksum(&myParameters.header); msgSize = sizeof(myParameters); SendUSB(camNum, (unsigned char *)&myParameters, (int)msgSize); // get the ACK to the command maxBytes = 512; numBytesRead = RcvUSB(camNum, (unsigned char *)&gBuffer, maxBytes); // regVal = top + 20; // default first row is 20 // regVal = regVal & 0x7fe; // 11 bits, must be even // fcUsb_cmd_setRegister(0x01, regVal); // regVal = left + 32; // default first row is 32 // regVal = regVal & 0xffe; // 12 bits, must be even // fcUsb_cmd_setRegister(0x02, regVal); // regVal = bottom - top; // regVal = regVal & 0x7ff; // 11 bits, must be odd // regVal = regVal | 0x0001; // fcUsb_cmd_setRegister(0x03, regVal); // regVal = right - left; // regVal = regVal & 0x7ff; // 11 bits, must be odd // regVal = regVal | 0x0001; // fcUsb_cmd_setRegister(0x04, regVal); // test // regVal = fcUsb_cmd_getRegister(camNum, 0x01); // regVal = fcUsb_cmd_getRegister(camNum, 0x02); // regVal = fcUsb_cmd_getRegister(camNum, 0x03); // regVal = fcUsb_cmd_getRegister(camNum, 0x04); return 0; } // set the binning mode of the camera. Valid binModes are 1, 2, 3 // int fcUsb_cmd_setBin(int camNum, UInt16 binMode) { UInt32 msgSize; fc_setBin_param myParameters; UInt32 numBytesRead; //UInt16 regVal; int maxBytes; Starfish_Log("fcUsb_cmd_setBin\n"); if (gDoSimulation) return 0; myParameters.header = 'fc'; myParameters.command = fcSETBIN; myParameters.length = sizeof(myParameters); myParameters.binMode = binMode; myParameters.cksum = fcUsb_GetUsbCmdCksum(&myParameters.header); msgSize = sizeof(myParameters); SendUSB(camNum, (unsigned char *)&myParameters, (int)msgSize); // get the ACK to the command maxBytes = 512; numBytesRead = RcvUSB(camNum, (unsigned char *)&gBuffer, maxBytes); // test // regVal = fcUsb_cmd_getRegister(camNum, 0x22); // regVal = fcUsb_cmd_getRegister(camNum, 0x23); return 0; } // turn on one of the relays on the camera. whichRelay is one of enum fc_relay // int fcUsb_cmd_setRelay(int camNum, int whichRelay) { UInt32 msgSize; fc_setClrRelay_param myParameters; UInt32 numBytesRead; //UInt16 regVal; int maxBytes; Starfish_Log("fcUsb_cmd_setRelay\n"); if (gDoSimulation) return 0; myParameters.header = 'fc'; myParameters.command = fcSETRELAY; myParameters.length = sizeof(myParameters); myParameters.relayNum = whichRelay; myParameters.cksum = fcUsb_GetUsbCmdCksum(&myParameters.header); msgSize = sizeof(myParameters); SendUSB(camNum, (unsigned char *)&myParameters, (int)msgSize); // get the ACK to the command maxBytes = 512; numBytesRead = RcvUSB(camNum, (unsigned char *)&gBuffer, maxBytes); return 0; } // turn off one of the relays on the camera. whichRelay is one of enum fc_relay // int fcUsb_cmd_clearRelay(int camNum, int whichRelay) { UInt32 msgSize; fc_setClrRelay_param myParameters; UInt32 numBytesRead; //UInt16 regVal; int maxBytes; Starfish_Log("fcUsb_cmd_clearRelay\n"); if (gDoSimulation) return 0; myParameters.header = 'fc'; myParameters.command = fcCLRRELAY; myParameters.length = sizeof(myParameters); myParameters.relayNum = whichRelay; myParameters.cksum = fcUsb_GetUsbCmdCksum(&myParameters.header); msgSize = sizeof(myParameters); SendUSB(camNum, (unsigned char *)&myParameters, (int)msgSize); // get the ACK to the command maxBytes = 512; numBytesRead = RcvUSB(camNum, (unsigned char *)&gBuffer, maxBytes); return 0; } // generate a pulse on one of the relays on the camera. whichRelay is one of enum fc_relay // pulse width parameters are in mS. you can specify the hi and lo period of the pulse. // if 'repeats' is true then the pulse will loop. // int fcUsb_cmd_pulseRelay(int camNum, int whichRelay, int onMs, int offMs, bool repeats) { UInt32 msgSize; fc_pulseRelay_param myParameters; UInt32 numBytesRead; //UInt16 regVal; int maxBytes; Starfish_Log("fcUsb_cmd_pulseRelay\n"); if (gDoSimulation) return 0; myParameters.header = 'fc'; myParameters.command = fcPULSERELAY; myParameters.length = sizeof(myParameters); myParameters.relayNum = whichRelay; myParameters.highPulseWidth = onMs & 0x7fff; // only 15 bits myParameters.lowPulseWidth = offMs & 0x7fff; // only 15 bits if (repeats) myParameters.repeats = 1; else myParameters.repeats = 0; myParameters.cksum = fcUsb_GetUsbCmdCksum(&myParameters.header); msgSize = sizeof(myParameters); SendUSB(camNum, (unsigned char *)&myParameters, (int)msgSize); // get the ACK to the command maxBytes = 512; numBytesRead = RcvUSB(camNum, (unsigned char *)&gBuffer, maxBytes); return 0; } // tell the camera what temperature setpoint to use for the TEC controller // this will also turn on cooling to the camera // int fcUsb_cmd_setTemperature(int camNum, SInt16 theTemp) { UInt32 msgSize; fc_setTemp_param myParameters; UInt32 numBytesRead; int maxBytes; if (gDoSimulation) return 0; Starfish_Log("fcUsb_cmd_setTemperature\n"); myParameters.header = 'fc'; myParameters.command = fcSETTEMP; myParameters.length = sizeof(myParameters); myParameters.theTemp = theTemp; myParameters.cksum = fcUsb_GetUsbCmdCksum(&myParameters.header); msgSize = sizeof(myParameters); SendUSB(camNum, (unsigned char *)&myParameters, (int)msgSize); // get the ACK to the command maxBytes = 512; numBytesRead = RcvUSB(camNum, (unsigned char *)&gBuffer, maxBytes); return 0; } // get the temperature of the image sensor // SInt16 fcUsb_cmd_getTemperature(int camNum) { UInt32 msgSize; fc_no_param myParameters; UInt32 numBytesRead; //UInt16 regVal; fc_tempInfo myTemperatureInfo; float theCurTemperature; int maxBytes; Starfish_Log("fcUsb_cmd_getTemperature\n"); if (gDoSimulation) return 25; myParameters.header = 'fc'; myParameters.command = fcGETTEMP; myParameters.length = sizeof(myParameters); myParameters.cksum = fcUsb_GetUsbCmdCksum(&myParameters.header); msgSize = sizeof(myParameters); SendUSB(camNum, (unsigned char *)&myParameters, (int)msgSize); // get the ACK to the command maxBytes = 512; numBytesRead = RcvUSB(camNum, (unsigned char *)&gBuffer, maxBytes); // copy the Rx buffer to my local storage memcpy(&myTemperatureInfo, &gBuffer, sizeof(myTemperatureInfo)); // put the current temperature in the log file theCurTemperature = (float)myTemperatureInfo.tempValue; theCurTemperature = theCurTemperature / 100.0; Starfish_LogFmt(" Got temperature - %2.1f degrees C\n", theCurTemperature); return myTemperatureInfo.tempValue; } UInt16 fcUsb_cmd_getTECPowerLevel(int camNum) { UInt32 msgSize; fc_no_param myParameters; UInt32 numBytesRead; //UInt16 regVal; fc_tempInfo myTemperatureInfo; UInt16 theCurPower; int maxBytes; Starfish_Log("fcUsb_cmd_getTECPowerLevel\n"); if (gDoSimulation) return 50; myParameters.header = 'fc'; myParameters.command = fcGETTEMP; myParameters.length = sizeof(myParameters); myParameters.cksum = fcUsb_GetUsbCmdCksum(&myParameters.header); msgSize = sizeof(myParameters); SendUSB(camNum, (unsigned char *)&myParameters, (int)msgSize); // get the ACK to the command maxBytes = 512; numBytesRead = RcvUSB(camNum, (unsigned char *)&gBuffer, maxBytes); // copy the Rx buffer to my local storage memcpy(&myTemperatureInfo, &gBuffer, sizeof(myTemperatureInfo)); // put the current power in the log file theCurPower = myTemperatureInfo.TECPwrValue; Starfish_LogFmt(" Got power level - %d percent\n", theCurPower); return myTemperatureInfo.TECPwrValue; } bool fcUsb_cmd_getTECInPowerOK(int camNum) { UInt32 msgSize; fc_no_param myParameters; UInt32 numBytesRead; //UInt16 regVal; fc_tempInfo myTemperatureInfo; int maxBytes; Starfish_Log("fcUsb_cmd_getTECInPowerOK\n"); if (gDoSimulation) return true; myParameters.header = 'fc'; myParameters.command = fcGETTEMP; myParameters.length = sizeof(myParameters); myParameters.cksum = fcUsb_GetUsbCmdCksum(&myParameters.header); msgSize = sizeof(myParameters); SendUSB(camNum, (unsigned char *)&myParameters, (int)msgSize); // get the ACK to the command maxBytes = 512; numBytesRead = RcvUSB(camNum, (unsigned char *)&gBuffer, maxBytes); // copy the Rx buffer to my local storage memcpy(&myTemperatureInfo, &gBuffer, sizeof(myTemperatureInfo)); if (myTemperatureInfo.TECInPwrOK == 0) return false; else return true; } // command camera to turn off the TEC cooler // int fcUsb_cmd_turnOffCooler(int camNum) { UInt32 msgSize; fc_no_param myParameters; UInt32 numBytesRead; int maxBytes; Starfish_Log("fcUsb_cmd_turnOffCooler\n"); if (gDoSimulation) return 0; myParameters.header = 'fc'; myParameters.command = fcTURNOFFTEC; myParameters.length = sizeof(myParameters); myParameters.cksum = fcUsb_GetUsbCmdCksum(&myParameters.header); msgSize = sizeof(myParameters); SendUSB(camNum, (unsigned char *)&myParameters, (int)msgSize); // get the ACK to the command maxBytes = 512; numBytesRead = RcvUSB(camNum, (unsigned char *)&gBuffer, maxBytes); return 0; } // here to read an entire frame in RAW format // int fcUsb_cmd_getRawFrame(int camNum, UInt16 numRows, UInt16 numCols, UInt16 *frameBuffer) { UInt32 msgSize; UInt32 numBytesRead = 0; fc_no_param myParameters; //UInt16 dataOdd; //UInt16 dataEven; //UInt16 *wordPtr1; //UInt16 *wordPtr2; //int i; //char errorString[513]; int maxBytes; Starfish_Log("fcUsb_cmd_getRawFrame\n"); if (gDoSimulation) return 0; // send the command to the camera myParameters.header = 'fc'; myParameters.command = fcGETRAWFRAME; myParameters.length = sizeof(myParameters); myParameters.cksum = fcUsb_GetUsbCmdCksum(&myParameters.header); msgSize = sizeof(myParameters); SendUSB(camNum, (unsigned char *)&myParameters, (int)msgSize); // get the response to the command if (gCamerasFound[camNum - 1].camFinalProduct == starfish_pro4m_final_deviceID) { maxBytes = numRows * numCols * 2; // 2 bytes / pixel numBytesRead = RcvUSB(camNum, (unsigned char *)&frameBuffer, maxBytes); Starfish_LogFmt(" read - %ld bytes\n", numBytesRead); if (gProWantColNormalization) fcImage_PRO_doFullFrameColLevelNormalization(frameBuffer, numCols, numRows); } else { if (gCamerasFound[camNum - 1].camFinalProduct == starfish_ibis13_final_deviceID) { maxBytes = numRows * numCols * 2; // 2 bytes / pixel numBytesRead = RcvUSB(camNum, (unsigned char *)&frameBuffer, maxBytes); fcImage_IBIS_doFullFrameColLevelNormalization(frameBuffer, numCols, numRows); fcImage_IBIS_subtractPedestal(frameBuffer, numCols, numRows); } else { // if we are doing black level compensation, then we read into our internal buffer // then strip out the balck cols after we are done with them if (gReadBlack[camNum - 1]) { maxBytes = numRows * (numCols + 16) * 2; // 2 bytes / pixel numBytesRead = RcvUSB(camNum, (unsigned char *)gFrameBuffer, maxBytes); } else { maxBytes = numRows * numCols * 2; // 2 bytes / pixel numBytesRead = RcvUSB(camNum, (unsigned char *)frameBuffer, maxBytes); } Starfish_LogFmt(" fcUsb_cmd_getRawFrame - numBytesRead - %i\n", (unsigned int)numBytesRead); if (gReadBlack[camNum - 1] && numBytesRead != 0) { fcImage_doFullFrameRowLevelNormalization(gFrameBuffer, (numCols + 16), numRows); fcImage_StripBlackCols(camNum, frameBuffer); } } // if Starfish } if (gCameraImageFilter[camNum - 1] == fc_filter_3x3) { // perform 3x3 kernel filter fcImage_do_3x3_kernel(numRows, numCols, frameBuffer); } if (gCameraImageFilter[camNum - 1] == fc_filter_5x5) { // perform 5x5 kernel filter fcImage_do_5x5_kernel(numRows, numCols, frameBuffer); } if (gCameraImageFilter[camNum - 1] == fc_filter_hotPixel) { // perform hot pixel removal filter fcImage_do_hotPixel_kernel(numRows, numCols, frameBuffer); } return (numBytesRead); } // here to set the analog gain on the camera. // // theGain the gain number desired. // // Valid gains are between 0 and 15. // For the IBIS camera this corresponds to 1.28 to 17.53 as per the sensor data sheet // int fcUsb_cmd_setCameraGain(int camNum, UInt16 theGain) { UInt32 msgSize; fc_setGain_param myParameters; UInt32 numBytesRead; int maxBytes; Starfish_Log("fcUsb_cmd_setCameraGain\n"); if (gDoSimulation) return 0; myParameters.header = 'fc'; myParameters.command = fcSETGAIN; myParameters.length = sizeof(myParameters); myParameters.theGain = theGain; myParameters.cksum = fcUsb_GetUsbCmdCksum(&myParameters.header); msgSize = sizeof(myParameters); SendUSB(camNum, (unsigned char *)&myParameters, (int)msgSize); // get the ACK to the command maxBytes = 512; numBytesRead = RcvUSB(camNum, (unsigned char *)&gBuffer, maxBytes); // if this is the IBIS1300 camera, then we need to get new black row averages if (gCamerasFound[camNum - 1].camFinalProduct == starfish_ibis13_final_deviceID) fcImage_IBIS_computeAvgColOffsets(camNum); gBlackPedestal[camNum - 1] = fcUsb_cmd_getBlackPedestal(camNum); return 0; } // here to set the analog offset on the camera. // // theOffset the offset number desired. // // For the IBIS camera valid offsets are between 0 and 15. // int fcUsb_cmd_setCameraOffset(int camNum, UInt16 theOffset) { UInt32 msgSize; fc_setOffset_param myParameters; UInt32 numBytesRead; int maxBytes; Starfish_Log("fcUsb_cmd_setCameraOffset\n"); if (gDoSimulation) return 0; myParameters.header = 'fc'; myParameters.command = fcSETOFFSET; myParameters.length = sizeof(myParameters); myParameters.theOffset = theOffset; myParameters.cksum = fcUsb_GetUsbCmdCksum(&myParameters.header); msgSize = sizeof(myParameters); SendUSB(camNum, (unsigned char *)&myParameters, (int)msgSize); // get the ACK to the command maxBytes = 512; numBytesRead = RcvUSB(camNum, (unsigned char *)&gBuffer, maxBytes); gBlackPedestal[camNum - 1] = fcUsb_cmd_getBlackPedestal(camNum); return 0; } // here to define some image readout modes of the camera. The state of these bits will be // used during the call to fcUsb_cmd_startExposure. When an exposure is started and subsequent // image readout is begun, the camera will assume an implied fcUsb_cmd_getRawFrame command // when the 'DataXfrReadMode' is a '1' or '2' and begin uploading pixel data to the host as the image // is being read from the sensor. When the 'ReadBlack' bit is set, the first black rows and cols // of pixels will also be read from the sensor. // DataFormat can be one of 8, 10, 12, 14, 16 // 8 - packed into a single byte // others - packed into a 16 bit word // int fcUsb_cmd_setReadMode(int camNum, int DataXfrReadMode, int DataFormat) { UInt32 msgSize; fc_setReadMode_param myParameters; UInt32 numBytesRead; bool DoOffsetCorrection; bool ReadBlack; int maxBytes; Starfish_Log("fcUsb_cmd_setReadMode\n"); if (gDoSimulation) return 0; if (gCamerasFound[camNum - 1].camFinalProduct == starfish_ibis13_final_deviceID) { ReadBlack = false; DoOffsetCorrection = false; // remember settings gReadBlack[camNum - 1] = ReadBlack; // set if the host wishes to read the black pixels gDataXfrReadMode[camNum - 1] = DataXfrReadMode; // the type of data transfers we will be using when taking picts gDataFormat[camNum - 1] = DataFormat; // the desired camera data format myParameters.header = 'fc'; myParameters.command = fcSETREADMODE; myParameters.length = sizeof(myParameters); if (ReadBlack) myParameters.ReadBlack = -1; else myParameters.ReadBlack = 0; myParameters.DataXfrReadMode = DataXfrReadMode; myParameters.DataFormat = DataFormat; if (DoOffsetCorrection) myParameters.AutoOffsetCorrection = -1; else myParameters.AutoOffsetCorrection = 0; } else { // the following two parameters are now managed automatically if (gCurrentIntegrationTime[camNum - 1] <= 2000) ReadBlack = false; //Note: The readblack function for the Fishcamp Starfish is disabled because it doesn't currently seem to work properly. See the note above. else ReadBlack = false; DoOffsetCorrection = true; // remember settings gReadBlack[camNum - 1] = ReadBlack; // set if the host wishes to read the black pixels gDataXfrReadMode[camNum - 1] = DataXfrReadMode; // the type of data transfers we will be using when taking picts gDataFormat[camNum - 1] = DataFormat; // the desired camera data format myParameters.header = 'fc'; myParameters.command = fcSETREADMODE; myParameters.length = sizeof(myParameters); if (ReadBlack) myParameters.ReadBlack = -1; else myParameters.ReadBlack = 0; myParameters.DataXfrReadMode = DataXfrReadMode; myParameters.DataFormat = DataFormat; if (DoOffsetCorrection) myParameters.AutoOffsetCorrection = -1; else myParameters.AutoOffsetCorrection = 0; } // send the constructed command myParameters.cksum = fcUsb_GetUsbCmdCksum(&myParameters.header); msgSize = sizeof(myParameters); SendUSB(camNum, (unsigned char *)&myParameters, (int)msgSize); // get the ACK to the command maxBytes = 512; numBytesRead = RcvUSB(camNum, (unsigned char *)&gBuffer, maxBytes); return 0; } // set some register defaults for the starfish camera void fcUsb_setStarfishDefaultRegs(int camNum) { UInt16 regValue; Starfish_Log("fcUsb_setStarfishDefaultRegs\n"); if (gDoSimulation) return; // Turn off auto black level compensation in the micron image sensor regValue = fcUsb_cmd_getRegister(camNum, 0x5F); regValue = regValue | 0x8080; fcUsb_cmd_setRegister(camNum, 0x5F, regValue); regValue = fcUsb_cmd_getRegister(camNum, 0x62); regValue = regValue | 0x0001; fcUsb_cmd_setRegister(camNum, 0x62, regValue); // setup some minimum offset in the 4 bayer channels. // Don't want to be too close to all zeros for pixel data fcUsb_cmd_setRegister(camNum, 0x60, 0x08); fcUsb_cmd_setRegister(camNum, 0x61, 0x08); fcUsb_cmd_setRegister(camNum, 0x63, 0x08); fcUsb_cmd_setRegister(camNum, 0x64, 0x08); } // here to set the filter type used for image processing // The specified filter will be performed on any images // transferred from the camera. // // 'theImageFilter' is one of fc_imageFilter // void fcUsb_cmd_setImageFilter(int camNum, int theImageFilter) { gCameraImageFilter[camNum - 1] = theImageFilter; } // call to get the black level pedestal of the image sensor. This is usefull if you wish // to subtract out the pedestal from the image returned from the camera. // // the return value will be scalled according to the currently set fc_dataFormat. See the // fcUsb_cmd_setReadMode routine for information on the pixel format // UInt16 fcUsb_cmd_getBlackPedestal(int camNum) { UInt32 msgSize; fc_no_param myParameters; UInt32 numBytesRead; fc_blackPedestal myPedestalInfo; UInt16 retValue; int maxBytes; Starfish_Log("fcUsb_cmd_getBlackPedestal\n"); if (gDoSimulation) return 0; myParameters.header = 'fc'; myParameters.command = fcGETPEDESTAL; myParameters.length = sizeof(myParameters); myParameters.cksum = fcUsb_GetUsbCmdCksum(&myParameters.header); msgSize = sizeof(myParameters); SendUSB(camNum, (unsigned char *)&myParameters, (int)msgSize); // get the ACK to the command maxBytes = 512; numBytesRead = RcvUSB(camNum, (unsigned char *)&gBuffer, maxBytes); // copy the Rx buffer to my local storage memcpy(&myPedestalInfo, &gBuffer, sizeof(myPedestalInfo)); retValue = myPedestalInfo.dataValue; // put the current power in the log file Starfish_LogFmt(" Got pedestal - 0x%04x\n", retValue); return retValue; } // call this routine to set a camera property. Various cameras support different properties // the following properties are defined: // // 1) fcPROP_NUMSAMPLES - enter with 'propertyValue' set to the number desired. Valid // numbers are binary numbers starting with 4 (4, 8, 16, 32, 64, 128) // // 2) fcPROP_PATTERNENABLE - enter with 'propertyValue' set to '1' to enable the frame grabber // pattern generator. '0' to get true sensor data // // 3) fcPROP_PIXCAPTURE - enter with 'propertyValue' set to '0' for normal CDS pixel sampling, // '1' for pixel level only and '2' for reset level only. // // 4) fcPROP_SHUTTERMODE - enter with 'propertyValue' set to '0' for AUTOMATIC shutter, // '1' for MANUAL shutter. // // 5) fcPROP_SHUTTERPRIORITY - enter with 'propertyValue' set to '0' for MECHANICAL shutter priority, // '1' for ELECTRONIC shutter priority // // 6) fcPROP_MOVESHUTTERFLAG = enter with 'propertyValue' set to '0' to CLOSE the mechanical shutter, // '1' to OPEN the mechanical shutter // // 7) fcPROP_COLNORM - enter with 'propertyValue' set to '0' for no column level normalization // '1' for column level normalization. // // 8) fcPROP_SERVOOPENPOS - enter with 'propertyValue' set to servo pulse period used for the OPEN position // // 9) fcPROP_SERVOCLOSEDPOS - enter with 'propertyValue' set to servo pulse period used for the CLOSED position // // void fcUsb_cmd_setCameraProperty(int camNum, int propertyType, int propertyValue) { UInt32 msgSize; fc_setProperty_param myParameters; UInt32 numBytesRead; int maxBytes; // print out the information // printf("fcUsb_cmd_setCameraProperty:\n"); // printf(" propertyType - 0x%04x\n", propertyType); // printf(" propertyValue - 0x%04x\n", propertyValue); Starfish_Log("fcUsb_cmd_setCameraProperty\n"); if (gDoSimulation) return; if (propertyType == fcPROP_COLNORM) { // this property is handled by the PC driver if (propertyValue == 0) gProWantColNormalization = false; else gProWantColNormalization = true; } else { // this one needs to be sent to the camera myParameters.header = 'fc'; myParameters.command = fcSETPROPERTY; myParameters.length = sizeof(myParameters); myParameters.propertyType = propertyType; myParameters.propertyValue = (UInt16)propertyValue; myParameters.cksum = fcUsb_GetUsbCmdCksum(&myParameters.header); msgSize = sizeof(myParameters); SendUSB(camNum, (unsigned char *)&myParameters, (int)msgSize); // get the ACK to the command maxBytes = 512; numBytesRead = RcvUSB(camNum, (unsigned char *)&gBuffer, maxBytes); // if the property was to change the number of samples, we need to re-calibrate the camera. // if (propertyType == fcPROP_NUMSAMPLES) // { // fcImage_PRO_calibrateProCamera(camNum, gFrameBuffer, 2304, 2305); // } } }