indi-orion-ssg3-0.1+20221222180647/ 0000755 0001751 0001751 00000000000 14351116270 015110 5 ustar debian debian indi-orion-ssg3-0.1+20221222180647/orion_ssg3.c 0000644 0001751 0001751 00000046227 14174600255 017360 0 ustar debian debian /**
* Orion StarShoot G3 driver
* This code was reverse engineered by inspecting USB traffic.
*
* Copyright (c) 2020-2021 Ben Gilsrud (bgilsrud@gmail.com)
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this program. If not, see .
*/
#include
#include
#include
#include
#include
#include "orion_ssg3.h"
#ifdef __APPLE__
#include
#define le16toh(x) OSSwapLittleToHostInt16(x)
#define be16toh(x) OSSwapBigToHostInt16(x)
#else
#include
#endif /* __APPLE__ */
#define ORION_SSG3_VID 0x07ee
#define ORION_SSG3_PID 0x0502
#define ORION_SSG3_INTERFACE_NUM 0
#define ORION_SSG3_BULK_EP 0x82
/* These are the defaults that Orion Camera Studio sets */
#define ORION_SSG3_DEFAULT_OFFSET 127
#define ORION_SSG3_DEFAULT_GAIN 185
#define ORION_SSG3_DEFAULT_BINNING 1
#define ICX419_EFFECTIVE_X_START 3
#define ICX419_EFFECTIVE_X_COUNT 752
#define ICX419_EFFECTIVE_Y_START 12
#define ICX419_EFFECTIVE_Y_COUNT 582
#define ICX419_PIXEL_SIZE_X 8.6
#define ICX419_PIXEL_SIZE_Y 8.4
#define countof(x) (sizeof(x)/sizeof(x[0]))
static const struct orion_ssg3_model ssg3_models[] = {
{
.vid = 0x7ee,
.pid = 0x0502,
.name = "Orion StarShoot G3 Color",
.color = true
},
{
.vid = 0x7ee,
.pid = 0x0501, /* This is a guess */
.name = "Orion StarShoot G3 Mono",
.color = false
}
};
enum {
SSG3_CMD_BINNING = 13,
SSG3_CMD_START_EXPOSURE = 16,
SSG3_CMD_ST4 = 18,
SSG3_CMD_STATUS_ST4 = 19,
SSG3_CMD_UNKNOWN_STATUS1 = 20,
SSG3_CMD_SET_TEMPERATURE = 22,
SSG3_CMD_READ_TEMPERATURE = 23,
SSG3_CMD_UNKNOWN_STATUS2 = 24, /* Cooler status; on or off */
SSG3_CMD_GAIN_OFFSET = 25,
SSG3_CMD_X_READOUT_START = 31,
SSG3_CMD_X_READOUT_END = 32,
SSG3_CMD_Y_READOUT_START = 33,
SSG3_CMD_Y_READOUT_END = 34,
SSG3_CMD_READ_COOLER_POWER = 35, /* This is still a guess */
SSG3_CMD_UNKNOWN_STATUS3 = 38, /* Seems to also track cooler on/off */
};
static int orion_ssg3_set_gain_offset(struct orion_ssg3 *ssg3, uint8_t gain,
uint8_t offset);
/**
* Convert libusb error codes to standard errno
* @param lu_err: The libusb error code to be translated
* @return: The corresponding errno
*/
static int libusb_to_errno(int lu_err)
{
int rc = ENOTTY;
switch (lu_err) {
case LIBUSB_ERROR_IO:
rc = EIO;
break;
case LIBUSB_ERROR_INVALID_PARAM:
rc = EINVAL;
break;
case LIBUSB_ERROR_ACCESS:
rc = EPERM;
break;
case LIBUSB_ERROR_NO_DEVICE:
rc = ENODEV;
break;
case LIBUSB_ERROR_BUSY:
rc = EBUSY;
break;
case LIBUSB_ERROR_TIMEOUT:
rc = ETIMEDOUT;
break;
case LIBUSB_ERROR_OVERFLOW:
rc = EOVERFLOW;
break;
case LIBUSB_ERROR_PIPE:
rc = EPIPE;
break;
case LIBUSB_ERROR_INTERRUPTED:
rc = EINTR;
break;
case LIBUSB_ERROR_NO_MEM:
rc = ENOMEM;
break;
case LIBUSB_ERROR_NOT_SUPPORTED:
rc = ENOMEM;
break;
}
return rc;
}
/**
* Get information about connected cameras
* @param infos: The array of orion_ssg3_info structures to be filled in
* @param max_cameras: The maximum number of entries in the infos array
* @return: -errno on error, the number of cameras detected on success
*/
int orion_ssg3_camera_info(struct orion_ssg3_info *infos, int max_cameras)
{
int rc;
int i;
int j;
int cnt = 0;
int found = 0;
libusb_device **list;
struct libusb_device_descriptor desc;
libusb_init(NULL);
rc = libusb_get_device_list(NULL, &list);
if (rc < 0) {
return rc;
}
cnt = rc;
for (i = 0; i < cnt && found < max_cameras; i++) {
libusb_device *dev;
dev = list[i];
rc = libusb_get_device_descriptor(dev, &desc);
if (rc) {
continue;
}
for (j = 0; j < (int) countof(ssg3_models); j++) {
const struct orion_ssg3_model *model = &ssg3_models[j];
if (model->vid == desc.idVendor &&
model->pid == desc.idProduct) {
struct orion_ssg3_info *info = &infos[found];
info->dev = dev;
libusb_ref_device(dev);
info->model = model;
found++;
}
}
}
libusb_free_device_list(list, 1);
if (!rc) {
rc = found;
}
return rc;
}
/**
* Open a connection to an Orion StarShoot G3 device.
* @param ssg3: A orion_ssg3 struct that will be used to handle the connection
* @param info: The info structure of the camera (from orion_ssg3_camera_info) to be opened
* @return: 0 on success, -errno on failure
*/
int orion_ssg3_open(struct orion_ssg3 *ssg3, struct orion_ssg3_info *info)
{
int rc;
ssg3->model = info->model;
/* Set defaults since we don't know how to read them from the camera */
ssg3->offset = ORION_SSG3_DEFAULT_OFFSET;
ssg3->gain = ORION_SSG3_DEFAULT_GAIN;
ssg3->bin_x = ORION_SSG3_DEFAULT_BINNING;
ssg3->bin_y = ORION_SSG3_DEFAULT_BINNING;
ssg3->x1 = ICX419_EFFECTIVE_X_START;
ssg3->x_count = ICX419_EFFECTIVE_X_COUNT;
ssg3->y1 = ICX419_EFFECTIVE_Y_START;
ssg3->y_count = ICX419_EFFECTIVE_Y_COUNT;
rc = libusb_open(info->dev, &ssg3->devh);
if (rc) {
return -libusb_to_errno(rc);
}
rc = libusb_set_configuration(ssg3->devh, 1);
if (rc) {
libusb_close(ssg3->devh);
return -libusb_to_errno(rc);
}
rc = libusb_claim_interface(ssg3->devh, ORION_SSG3_INTERFACE_NUM);
if (rc) {
libusb_close(ssg3->devh);
return -libusb_to_errno(rc);
}
return 0;
}
/**
* Close a connection to an Orion StarShoot G3 device.
* @param ssg3: A orion_ssg3 struct that was used to open a connection
* @return: 0 on success, -errno on failure
*/
int orion_ssg3_close(struct orion_ssg3 *ssg3)
{
if (ssg3->devh) {
libusb_release_interface(ssg3->devh, ORION_SSG3_INTERFACE_NUM);
libusb_close(ssg3->devh);
ssg3->devh = NULL;
}
return 0;
}
/**
* Helper function for sending commands to Orion SSG3.
* All of the command/control of the SSG3 is done using control transfers.
*/
static int orion_ssg3_control_set(struct orion_ssg3 *ssg3, uint16_t cmd, uint16_t wValue, uint16_t wIndex)
{
int rc;
uint8_t bmRequestType;
bmRequestType = LIBUSB_RECIPIENT_DEVICE | LIBUSB_REQUEST_TYPE_RESERVED
| LIBUSB_ENDPOINT_OUT;
rc = libusb_control_transfer(ssg3->devh, bmRequestType, cmd, wValue, wIndex, NULL, 0, 100);
if ((cmd == SSG3_CMD_START_EXPOSURE) && (rc == LIBUSB_ERROR_PIPE)) {
rc = 0;
}
if (rc < 0) {
return -libusb_to_errno(rc);
}
return 0;
}
/**
* Helper function for sending commands to Orion SSG3.
* All of the command/control of the SSG3 is done using control transfers.
*/
static int orion_ssg3_control_get(struct orion_ssg3 *ssg3, uint16_t cmd,
uint16_t wValue, uint16_t wIndex, uint8_t *data, uint16_t wLength)
{
int rc;
uint8_t bmRequestType;
bmRequestType = LIBUSB_RECIPIENT_DEVICE | LIBUSB_REQUEST_TYPE_RESERVED
| LIBUSB_ENDPOINT_IN;
rc = libusb_control_transfer(ssg3->devh, bmRequestType, cmd, wValue, wIndex, data, wLength, 100);
if (rc < 0) {
return -libusb_to_errno(rc);
}
return 0;
}
/**
* Set the gain and offset.
* I would like to be able to set gain or offset independently, but none of the
* usb dumps show a read transaction for these values. So, instead, we manually
* track the gain and offset in the ssg3 structure.
* @param ssg3: The ssg3 structure that handles the connection to the device
* @param gain: The gain to be set. This is 0-255
* @param offset: The gain to be set. This is 0-255
* @return: 0 on success, -errno on failure
*/
static int orion_ssg3_set_gain_offset(struct orion_ssg3 *ssg3, uint8_t gain,
uint8_t offset)
{
int rc;
rc = orion_ssg3_control_set(ssg3, SSG3_CMD_GAIN_OFFSET, (gain << 8) | offset, 2);
if (!rc) {
ssg3->offset = offset;
ssg3->gain = gain;
}
return rc;
}
int orion_ssg3_set_gain(struct orion_ssg3 *ssg3, uint8_t gain)
{
return orion_ssg3_set_gain_offset(ssg3, gain, ssg3->offset);
}
int orion_ssg3_set_offset(struct orion_ssg3 *ssg3, uint8_t offset)
{
return orion_ssg3_set_gain_offset(ssg3, ssg3->gain, offset);
}
/**
* Set the CCD binning
* OCS allows for any combination of 1/2 binning (1x1, 1x2, 2x1, 2x2). I don't
* know how the x/y bin is set, but I'm guessing that x is sent in the MSB. It
* would be easy to confirm with an additional packet capture.
* @param ssg3: The ssg3 structure used to control the camera
* @param x: The number of pixels to bin x
* @param y: The number of pixels to bin y
* @return: 0 on success, -errno otherwise
*/
int orion_ssg3_set_binning(struct orion_ssg3 *ssg3, uint8_t x, uint8_t y)
{
int rc;
if (x > 2 || x < 1 || y > 2 || y < 1) {
return -EINVAL;
}
rc = orion_ssg3_control_set(ssg3, SSG3_CMD_BINNING, (x << 8) | y, 0);
if (!rc) {
/* This complicated logic is to maintain the same ROI when changing binning */
if (x < ssg3->bin_x) {
ssg3->x1 = ssg3->bin_x * ssg3->x1 / x;
ssg3->x_count = ssg3->bin_x * ssg3->x_count / x;
}
if (y < ssg3->bin_y) {
ssg3->y1 = ssg3->bin_y * ssg3->y1 / y;
ssg3->y_count = ssg3->bin_y * ssg3->y_count / y;
}
if (y != ssg3->bin_y) {
}
if (ssg3->x1 < ICX419_EFFECTIVE_X_START) {
ssg3->x1 = ICX419_EFFECTIVE_X_START;
}
if (ssg3->x1 + ssg3->x_count > ICX419_EFFECTIVE_X_COUNT) {
ssg3->x_count = ICX419_EFFECTIVE_X_COUNT;
}
if (ssg3->y1 < ICX419_EFFECTIVE_Y_START) {
ssg3->y1 = ICX419_EFFECTIVE_Y_START;
}
if (ssg3->y1 + ssg3->y_count > ICX419_EFFECTIVE_Y_COUNT) {
ssg3->y_count = ICX419_EFFECTIVE_Y_COUNT;
}
ssg3->bin_x = x;
ssg3->bin_y = y;
}
return rc;
}
/**
* Start an exposure on the camera.
* This sequence mimics what Orion Camera Studio does. For each exposure, OCS
* sends a sequence of commands that specify the offsets at which the data that
* is clocked out of the CCD should be sent over the USB. This would allow the
* same firmware to be used for CCDs that have different geometries without any
* changes.
*/
int orion_ssg3_start_exposure(struct orion_ssg3 *ssg3, uint32_t msec)
{
int rc;
rc = orion_ssg3_control_set(ssg3, SSG3_CMD_X_READOUT_START, ssg3->x1, 0);
if (rc)
fprintf(stderr, "Failed to set x readout start: %d\n", rc);
rc = orion_ssg3_control_set(ssg3, SSG3_CMD_X_READOUT_END, ssg3->x1 + ssg3->x_count - 1, 0);
if (rc)
fprintf(stderr, "Failed to set x readout end: %d\n", rc);
rc = orion_ssg3_control_set(ssg3, SSG3_CMD_Y_READOUT_START, ssg3->y1, 0);
if (rc)
fprintf(stderr, "Failed to set y readout start: %d\n", rc);
rc = orion_ssg3_control_set(ssg3, SSG3_CMD_Y_READOUT_END, ssg3->y1 + ssg3->y_count - 1, 0);
if (rc)
fprintf(stderr, "Failed to set y readout end: %d\n", rc);
rc = orion_ssg3_control_set(ssg3, SSG3_CMD_START_EXPOSURE, msec, msec >> 16);
if (!rc) {
gettimeofday(&ssg3->exp_done_time, NULL);
if (msec > 1000) {
msec = msec - 1000;
} else {
msec = 0;
}
ssg3->exp_done_time.tv_sec += msec / 1000;
ssg3->exp_done_time.tv_usec += (msec % 1000) * 1000;
if (ssg3->exp_done_time.tv_usec > 1000000) {
ssg3->exp_done_time.tv_sec++;
ssg3->exp_done_time.tv_sec -= 1000000;
}
}
return rc;
}
static int get_x2(struct orion_ssg3 *ssg3)
{
return ssg3->x1 + ssg3->x_count - 1;
}
static int get_y2(struct orion_ssg3 *ssg3)
{
return ssg3->y1 + ssg3->y_count - 1;
}
/**
* Set the subframe
* The subframe selects which region of the CCD data will be sent to the host
* via USB.
* @param x1: The x offset in the effective pixel area
* @param x_count: The number of horizontal pixels after x1
* @param y1: The y offset in the effective piyel area
* @param y_count: The number of vertical rows after y1
* @return: 0 on success, -errno on failure
*/
int orion_ssg3_subframe(struct orion_ssg3 *ssg3, uint16_t x1, uint16_t x_count,
uint16_t y1, uint16_t y_count)
{
int rc;
ssg3->x1 = ICX419_EFFECTIVE_X_START + x1;
ssg3->x_count = x_count;
ssg3->y1 = ICX419_EFFECTIVE_Y_START + y1;
ssg3->y_count = y_count;
rc = orion_ssg3_control_set(ssg3, SSG3_CMD_X_READOUT_START, ssg3->x1, 0);
rc = orion_ssg3_control_set(ssg3, SSG3_CMD_X_READOUT_END, get_x2(ssg3), 0);
rc = orion_ssg3_control_set(ssg3, SSG3_CMD_Y_READOUT_START, ssg3->y1, 0);
rc = orion_ssg3_control_set(ssg3, SSG3_CMD_Y_READOUT_END, get_y2(ssg3), 0);
return rc;
}
/**
* Download an image
* @param ssg3: The ssg3 structure used to communicate with the camera
* @param buf: The buffer to store the frame in
* @param len: The number of bytes available in buf
*/
int orion_ssg3_image_download(struct orion_ssg3 *ssg3, uint8_t *buf, int len)
{
int line_sz;
int got;
uint16_t *tmp;
int x, y;
uint16_t *frame;
int rc = 0;
int i;
int fail_cnt;
int needed;
int total;
frame = (uint16_t *) buf;
needed = ssg3->x_count * ssg3->y_count * 2; /* 2 bytes/pixel */
if (needed < len) {
return -ENOSPC;
}
tmp = malloc(needed);
if (!tmp) {
return -ENOMEM;
}
line_sz = ssg3->x_count * 2; /* 2 bytes/pixel */
for (i = 0, fail_cnt = 0, total = 0; i < ssg3->y_count && fail_cnt < 10;) {
rc = libusb_bulk_transfer(ssg3->devh, ORION_SSG3_BULK_EP, &(((unsigned char *) tmp)[i * line_sz]), line_sz, &got, 5000);
if (!rc) {
total += got;
i++;
fail_cnt = 0;
} else {
fail_cnt++;
}
}
fprintf(stderr, "needed = %d, total = %d, len = %d\n", needed, total, len);
/* The SSG3 has an interlace CCD, so the horizontal lines don't come out in order. Instead,
they are split into an even and odd field. We get the even lines first and then the odd
lines. This loop below de-interlaces the image to put the lines in the correct order
in the frame buffer. */
for (y = 0; y < ssg3->y_count; y++) {
int download_y; /* The y line in the download buffer */
if (y % 2 == 0) {
download_y = (y / 2);
} else {
download_y = (ssg3->y_count / 2) + (y / 2);
}
for (x = 0; x < ssg3->x_count; x++) {
/* The raw pixel data is sent big-endian */
frame[x + y * ssg3->x_count] = be16toh(tmp[x + download_y * ssg3->x_count]);
}
}
free(tmp);
return rc;
}
int orion_ssg3_get_gain(struct orion_ssg3 *ssg3, uint8_t *gain)
{
*gain = ssg3->gain;
return 0;
}
int orion_ssg3_get_offset(struct orion_ssg3 *ssg3, uint8_t *offset)
{
*offset = ssg3->offset;
return 0;
}
int orion_ssg3_get_image_width(struct orion_ssg3 *ssg3)
{
return ssg3->x_count / ssg3->bin_x;
}
int orion_ssg3_get_image_height(struct orion_ssg3 *ssg3)
{
return ssg3->y_count / ssg3->bin_y;
}
int orion_ssg3_get_pixel_bit_size(struct orion_ssg3 *ssg3)
{
(void) ssg3;
return 16;
}
/**
* Get the x dimension of the CCD pixel
* @param ssg3: The ssg3 structure used to communicate with camera
* @return: The x dimension of the pixel, in um
*/
float orion_ssg3_get_pixel_size_x(struct orion_ssg3 *ssg3)
{
(void) ssg3;
return ICX419_PIXEL_SIZE_X;
}
/**
* Get the y dimension of the CCD pixel
* @param ssg3: The ssg3 structure used to communicate with camera
* @return: The y dimension of the pixel, in um
*/
float orion_ssg3_get_pixel_size_y(struct orion_ssg3 *ssg3)
{
(void) ssg3;
return ICX419_PIXEL_SIZE_Y;
}
/**
* Determine if the current exposure is done
* @param ssg3: The ssg3 structure used to communicate with camera
* @return: 1 if the exposure is done, 0 if it's not
*/
int orion_ssg3_exposure_done(struct orion_ssg3 *ssg3)
{
struct timeval now;
gettimeofday(&now, NULL);
if ((now.tv_sec > ssg3->exp_done_time.tv_sec) ||
((now.tv_sec == ssg3->exp_done_time.tv_sec) &&
(now.tv_usec >= ssg3->exp_done_time.tv_usec))) {
return 1;
}
return 0;
}
/**
* Get the temperature of the camera
* @param ssg3: The ssg3 structure used to communicate with camera
* @param temperature: The buffer to store the temperature in
* @return: 0 on success, -errno on failure
*/
int orion_ssg3_get_temperature(struct orion_ssg3 *ssg3, float *temperature)
{
int rc;
uint16_t val;
rc = orion_ssg3_control_get(ssg3, SSG3_CMD_READ_TEMPERATURE, 0, 0, (uint8_t *) &val, 2);
if (rc)
return -libusb_to_errno(rc);
/* Temperature comes from camera as 16-bit little-endian format */
val = le16toh(val);
if (temperature)
*temperature = (val - 123.8) / 6.0;
/* Value = (Temperature) * 6 + 123.8 */
return 0;
}
/**
* Set cooling target temperature
* @param ssg3: The ssg3 structure used to communicate with camera
* @param temperature: The desired temperature set point
* @return: 0 on success, < 0 on failure
*/
int orion_ssg3_set_temperature(struct orion_ssg3 *ssg3, float temperature)
{
/* wIndex = 1 turns cooling on, wIndex = 0 turns cooling off */
uint16_t val = temperature * 6 + 123.8;
return orion_ssg3_control_set(ssg3, SSG3_CMD_SET_TEMPERATURE, val, 1);
}
/**
* Turn cooling off
* @param ssg3: The ssg3 structure used to communicate with camera
* @return: 0 on success, < 0 on failure
*/
int orion_ssg3_cooling_off(struct orion_ssg3 *ssg3)
{
return orion_ssg3_control_set(ssg3, SSG3_CMD_SET_TEMPERATURE, 0, 0);
}
/**
* Get the cooling power of the TEC.
* The power is the percentage of the total cooling capacity of the TEC.
* @param ssg3: The ssg3 structure used to communicate with camera
* @param power: Buffer to store the cooling power percentage in.
* @return: 0 on success, < 0 on failure
*/
int orion_ssg3_get_cooling_power(struct orion_ssg3 *ssg3, float *power)
{
int rc;
uint8_t val;
rc = orion_ssg3_control_get(ssg3, SSG3_CMD_READ_COOLER_POWER, 0, 0, &val, 1);
if (rc < 0)
return -libusb_to_errno(rc);
if (val <= 50) {
*power = val * 2;
} else {
*power = 100;
}
return 0;
}
/**
* Guide via ST-4 port
* @param ssg3: The ssg3 structure used to communicate with camera
* @param dir: The direction to guide (SSG3_GUIDE_*)
* @param ms: The number of ms to guide for
* @return: 0 on success, < 0 on failure
*/
int orion_ssg3_st4(struct orion_ssg3 *ssg3, int dir, int ms)
{
return orion_ssg3_control_set(ssg3, SSG3_CMD_ST4, ms, dir);
}
indi-orion-ssg3-0.1+20221222180647/orion_ssg3_ccd.h 0000644 0001751 0001751 00000005621 14174600255 020167 0 ustar debian debian /**
* INDI driver for Orion StarShoot G3
*
* Copyright (C) 2020 Ben Gilsrud
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#pragma once
#include
#include
#include
#include
#include
#include "orion_ssg3.h"
namespace SSG3
{
class Device;
}
class SSG3CCD : public INDI::CCD
{
public:
SSG3CCD(struct orion_ssg3_info *info, int inst);
virtual bool ISNewNumber(const char *dev, const char *name, double values[], char *names[], int n) override;
virtual bool ISNewSwitch(const char *dev, const char *name, ISState *states, char *names[], int n) override;
protected:
// General device functions
virtual bool Connect() override;
virtual bool Disconnect() override;
virtual const char *getDefaultName() override;
virtual bool initProperties() override;
virtual bool updateProperties() override;
// CCD specific functions
virtual bool UpdateCCDBin(int hor, int ver) override;
virtual bool StartExposure(float duration) override;
virtual bool AbortExposure() override;
virtual void TimerHit() override;
virtual int SetTemperature(double temperature) override;
// Guide Port
virtual IPState GuideNorth(uint32_t ms) override;
virtual IPState GuideSouth(uint32_t ms) override;
virtual IPState GuideEast(uint32_t ms) override;
virtual IPState GuideWest(uint32_t ms) override;
void stopNSGuide();
void stopWEGuide();
// misc functions
virtual bool saveConfigItems(FILE *fp) override;
private:
// Utility functions
void setupParams();
void grabImage();
bool activateCooler(bool enable);
void updateTemperature(void);
bool InExposure;
float ExposureRequest;
INDI::PropertyNumber GainNP{1};
INDI::PropertyNumber OffsetNP{1};
INDI::PropertyNumber CoolerPowerNP{1};
INDI::PropertySwitch CoolerSP{2};
enum {
COOLER_ON,
COOLER_OFF,
};
struct orion_ssg3_info *ssg3_info;
struct orion_ssg3 ssg3;
int instance;
char name[64];
double TemperatureRequest;
INDI::Timer TemperatureTimer;
INDI::Timer WETimer;
INDI::Timer NSTimer;
INDI::ElapsedTimer ExposureElapsedTimer;
};
indi-orion-ssg3-0.1+20221222180647/cmake_modules/ 0000755 0001751 0001751 00000000000 14347562502 017730 5 ustar debian debian indi-orion-ssg3-0.1+20221222180647/cmake_modules/FindGPSD.cmake 0000644 0001751 0001751 00000001036 14174600255 022264 0 ustar debian debian # - 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)
indi-orion-ssg3-0.1+20221222180647/cmake_modules/FindFTDI1.cmake 0000644 0001751 0001751 00000002672 14174600255 022345 0 ustar debian debian # - 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)
indi-orion-ssg3-0.1+20221222180647/cmake_modules/FindOpenAL.cmake 0000644 0001751 0001751 00000006604 14174600255 022653 0 ustar debian debian # 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)
indi-orion-ssg3-0.1+20221222180647/cmake_modules/FindFFTW3.cmake 0000644 0001751 0001751 00000002573 14174600255 022367 0 ustar debian debian # - 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)
indi-orion-ssg3-0.1+20221222180647/cmake_modules/FindSVBONY.cmake 0000644 0001751 0001751 00000002740 14347562502 022556 0 ustar debian debian # - Try to find SVBONY Library
# Once done this will define
#
# SVBONY_FOUND - system has SVBONY CCD
# SVBONY_INCLUDE_DIR - the SVBONY CCD include directory
# SVBONY_LIBRARIES - Link these to use SVBONY CCD
# Redistribution and use is allowed according to the terms of the BSD license.
# For details see the accompanying COPYING-CMAKE-SCRIPTS file.
if (SVBONY_INCLUDE_DIR AND SVBONY_LIBRARIES)
# in cache already
set(SVBONY_FOUND TRUE)
message(STATUS "Found libsvbony: ${SVBONY_LIBRARIES}")
else (SVBONY_INCLUDE_DIR AND SVBONY_LIBRARIES)
# find headers
find_path(SVBONY_INCLUDE_DIR NAMES SVBCameraSDK.h
PATH_SUFFIXES libsvbony
${_obIncDir}
${GNUWIN32_DIR}/include
)
# find libraries
find_library(SVBONY_LIBRARIES NAMES SVBCameraSDK
PATHS
${_obLinkDir}
${GNUWIN32_DIR}/lib
)
if(SVBONY_INCLUDE_DIR AND SVBONY_LIBRARIES)
set(SVBONY_FOUND TRUE)
else (SVBONY_INCLUDE_DIR AND SVBONY_LIBRARIES)
set(SVBONY_FOUND FALSE)
endif(SVBONY_INCLUDE_DIR AND SVBONY_LIBRARIES)
if (SVBONY_FOUND)
if (NOT SVBONY_FIND_QUIETLY)
message(STATUS "Found SVBONY libraries : ${SVBONY_LIBRARIES}")
endif (NOT SVBONY_FIND_QUIETLY)
else (SVBONY_FOUND)
if (SVBONY_FIND_REQUIRED)
message(FATAL_ERROR "SVBONY libraries not found. Please install libsvbony http://www.indilib.org")
endif (SVBONY_FIND_REQUIRED)
endif (SVBONY_FOUND)
mark_as_advanced(SVBONY_INCLUDE_DIR SVBONY_LIBRARIES)
endif (SVBONY_INCLUDE_DIR AND SVBONY_LIBRARIES)
indi-orion-ssg3-0.1+20221222180647/cmake_modules/FindMALLINCAM.cmake 0000644 0001751 0001751 00000003013 14174600255 023021 0 ustar debian debian # - 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)
indi-orion-ssg3-0.1+20221222180647/cmake_modules/FindNova.cmake 0000644 0001751 0001751 00000003046 14174600255 022435 0 ustar debian debian # - 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)
indi-orion-ssg3-0.1+20221222180647/cmake_modules/FindVorbis.cmake 0000644 0001751 0001751 00000002044 14174600255 022773 0 ustar debian debian # - 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)
indi-orion-ssg3-0.1+20221222180647/cmake_modules/FindJPEG.cmake 0000644 0001751 0001751 00000001663 14174600255 022262 0 ustar debian debian # - 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 )
indi-orion-ssg3-0.1+20221222180647/cmake_modules/FindCFITSIO.cmake 0000644 0001751 0001751 00000004346 14174600255 022636 0 ustar debian debian # - 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)
indi-orion-ssg3-0.1+20221222180647/cmake_modules/FindUSB1.cmake 0000644 0001751 0001751 00000005623 14174600255 022247 0 ustar debian debian # - 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()
indi-orion-ssg3-0.1+20221222180647/cmake_modules/FindGMock.cmake 0000644 0001751 0001751 00000011623 14174600255 022532 0 ustar debian debian #.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()
indi-orion-ssg3-0.1+20221222180647/cmake_modules/FindPackageMessage.cmake 0000644 0001751 0001751 00000003755 14174600255 024401 0 ustar debian debian #.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()
indi-orion-ssg3-0.1+20221222180647/cmake_modules/FindFTDI.cmake 0000644 0001751 0001751 00000002671 14174600255 022263 0 ustar debian debian # - 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)
indi-orion-ssg3-0.1+20221222180647/cmake_modules/FindMODBUS.cmake 0000644 0001751 0001751 00000003201 14174600255 022514 0 ustar debian debian # - 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)
indi-orion-ssg3-0.1+20221222180647/cmake_modules/FindSTARSHOOTG.cmake 0000644 0001751 0001751 00000003070 14174600255 023224 0 ustar debian debian # - 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)
indi-orion-ssg3-0.1+20221222180647/cmake_modules/InstallImported.cmake 0000644 0001751 0001751 00000006611 14174600255 024044 0 ustar debian debian
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 ()
indi-orion-ssg3-0.1+20221222180647/cmake_modules/FindAHPXC.cmake 0000644 0001751 0001751 00000002732 14174600255 022376 0 ustar debian debian # - 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)
indi-orion-ssg3-0.1+20221222180647/cmake_modules/FindFLI.cmake 0000644 0001751 0001751 00000002645 14174600255 022150 0 ustar debian debian # - 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)
indi-orion-ssg3-0.1+20221222180647/cmake_modules/FindASI.cmake 0000644 0001751 0001751 00000003565 14174600255 022154 0 ustar debian debian # - 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)
indi-orion-ssg3-0.1+20221222180647/cmake_modules/FindINDI.cmake 0000644 0001751 0001751 00000034574 14174600255 022267 0 ustar debian debian # 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")
indi-orion-ssg3-0.1+20221222180647/cmake_modules/CMakeCommon.cmake 0000644 0001751 0001751 00000013667 14174600255 023074 0 ustar debian debian
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)
indi-orion-ssg3-0.1+20221222180647/cmake_modules/FindFLIPRO.cmake 0000644 0001751 0001751 00000003140 14347562502 022524 0 ustar debian debian # - Try to find Finger Lakes Instruments Library
# Once done this will define
#
# FLIPRO_FOUND - system has FLI
# FLIPRO_INCLUDE_DIR - the FLI include directory
# FLIPRO_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 (FLIPRO_INCLUDE_DIR AND FLIPRO_LIBRARIES)
# in cache already
set(FLIPRO_FOUND TRUE)
message(STATUS "Found libflipro: ${FLIPRO_LIBRARIES}")
else (FLIPRO_INCLUDE_DIR AND FLIPRO_LIBRARIES)
# Might need to remove lib prefix once FLI fixes their library name
find_path(FLIPRO_INCLUDE_DIR libflipro.h
PATH_SUFFIXES fli
${_obIncDir}
${GNUWIN32_DIR}/include
)
find_library(FLIPRO_LIBRARIES NAMES libflipro
PATHS
${_obLinkDir}
${GNUWIN32_DIR}/lib
)
if(FLIPRO_INCLUDE_DIR AND FLIPRO_LIBRARIES)
set(FLIPRO_FOUND TRUE)
else (FLIPRO_INCLUDE_DIR AND FLIPRO_LIBRARIES)
set(FLIPRO_FOUND FALSE)
endif(FLIPRO_INCLUDE_DIR AND FLIPRO_LIBRARIES)
if (FLIPRO_FOUND)
if (NOT FLIPRO_FIND_QUIETLY)
message(STATUS "Found FLIPRO: ${FLIPRO_LIBRARIES}")
endif (NOT FLIPRO_FIND_QUIETLY)
else (FLIPRO_FOUND)
if (FLIPRO_FIND_REQUIRED)
message(FATAL_ERROR "FLIPRO not found. Please install it and try again. http://www.indilib.org")
endif (FLIPRO_FIND_REQUIRED)
endif (FLIPRO_FOUND)
mark_as_advanced(FLIPRO_INCLUDE_DIR FLIPRO_LIBRARIES)
endif (FLIPRO_INCLUDE_DIR AND FLIPRO_LIBRARIES)
indi-orion-ssg3-0.1+20221222180647/cmake_modules/FindINOVASDK.cmake 0000644 0001751 0001751 00000002753 14174600255 022754 0 ustar debian debian # - 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)
indi-orion-ssg3-0.1+20221222180647/cmake_modules/FindQHY.cmake 0000644 0001751 0001751 00000002426 14174600255 022174 0 ustar debian debian # - 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)
indi-orion-ssg3-0.1+20221222180647/cmake_modules/FindPENTAX.cmake 0000644 0001751 0001751 00000005530 14174600255 022531 0 ustar debian debian # - 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)
indi-orion-ssg3-0.1+20221222180647/cmake_modules/FindGLIB2.cmake 0000644 0001751 0001751 00000013271 14174600255 022332 0 ustar debian debian # - 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 )
indi-orion-ssg3-0.1+20221222180647/cmake_modules/FindATIK.cmake 0000644 0001751 0001751 00000002540 14174600255 022260 0 ustar debian debian # - 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)
indi-orion-ssg3-0.1+20221222180647/cmake_modules/FindALUT.cmake 0000644 0001751 0001751 00000005042 14174600255 022275 0 ustar debian debian # - 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)
indi-orion-ssg3-0.1+20221222180647/cmake_modules/FindAHPGT.cmake 0000644 0001751 0001751 00000003333 14347562502 022400 0 ustar debian debian # - Try to find AHPGT
# Once done this will define
#
# AHPGT_FOUND - system has AHPGT
# AHPGT_INCLUDE_DIR - the AHPGT include directory
# AHPGT_LIBRARIES - Link these to use AHPGT
# AHPGT_VERSION_STRING - Human readable version number of ahp_gt
# AHPGT_VERSION_MAJOR - Major version number of ahp_gt
# AHPGT_VERSION_MINOR - Minor version number of ahp_gt
# 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 (AHPGT_INCLUDE_DIR AND AHPGT_LIBRARIES)
# in cache already
set(AHPGT_FOUND TRUE)
message(STATUS "Found AHPGT: ${AHPGT_LIBRARIES}")
else (AHPGT_INCLUDE_DIR AND AHPGT_LIBRARIES)
find_path(AHPGT_INCLUDE_DIR ahp_gt.h
PATH_SUFFIXES ahp
${_obIncDir}
${GNUWIN32_DIR}/include
)
find_library(AHPGT_LIBRARIES NAMES ahp_gt
PATHS
${_obLinkDir}
${GNUWIN32_DIR}/lib
/usr/local/lib
HINTS ${CMAKE_C_IMPLICIT_LINK_DIRECTORIES}
)
if(AHPGT_INCLUDE_DIR AND AHPGT_LIBRARIES)
set(AHPGT_FOUND TRUE)
else (AHPGT_INCLUDE_DIR AND AHPGT_LIBRARIES)
set(AHPGT_FOUND FALSE)
endif(AHPGT_INCLUDE_DIR AND AHPGT_LIBRARIES)
if (AHPGT_FOUND)
if (NOT AHPGT_FIND_QUIETLY)
message(STATUS "Found AHPGT: ${AHPGT_LIBRARIES}")
endif (NOT AHPGT_FIND_QUIETLY)
else (AHPGT_FOUND)
if (AHPGT_FIND_REQUIRED)
message(FATAL_ERROR "AHPGT not found. Please install libahp_gt-dev")
endif (AHPGT_FIND_REQUIRED)
endif (AHPGT_FOUND)
mark_as_advanced(AHPGT_LIBRARIES)
endif (AHPGT_INCLUDE_DIR AND AHPGT_LIBRARIES)
indi-orion-ssg3-0.1+20221222180647/cmake_modules/FindD2XX.cmake 0000644 0001751 0001751 00000002620 14174600255 022254 0 ustar debian debian # - 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)
indi-orion-ssg3-0.1+20221222180647/cmake_modules/FindARAVIS.cmake 0000644 0001751 0001751 00000002723 14174600255 022520 0 ustar debian debian # - 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)
indi-orion-ssg3-0.1+20221222180647/cmake_modules/FindFISHCAMP.cmake 0000644 0001751 0001751 00000003225 14174600255 022723 0 ustar debian debian # - 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)
indi-orion-ssg3-0.1+20221222180647/cmake_modules/FindDC1394.cmake 0000644 0001751 0001751 00000002643 14174600255 022343 0 ustar debian debian # - 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)
indi-orion-ssg3-0.1+20221222180647/cmake_modules/FindTIFFXX.cmake 0000644 0001751 0001751 00000001763 14174600255 022546 0 ustar debian debian # - 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)
indi-orion-ssg3-0.1+20221222180647/cmake_modules/FindGSL.cmake 0000644 0001751 0001751 00000022241 14174600255 022155 0 ustar debian debian #.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()
indi-orion-ssg3-0.1+20221222180647/cmake_modules/FindMICAM.cmake 0000644 0001751 0001751 00000002567 14174600255 022367 0 ustar debian debian # - 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)
indi-orion-ssg3-0.1+20221222180647/cmake_modules/FindPackageHandleStandardArgs.cmake 0000644 0001751 0001751 00000035657 14174600255 026514 0 ustar debian debian #[=======================================================================[.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()
indi-orion-ssg3-0.1+20221222180647/cmake_modules/FindOggTheora.cmake 0000644 0001751 0001751 00000002472 14174600255 023413 0 ustar debian debian #
# 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
)
indi-orion-ssg3-0.1+20221222180647/cmake_modules/FindMEADE.cmake 0000644 0001751 0001751 00000002477 14174600255 022354 0 ustar debian debian # - 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)
indi-orion-ssg3-0.1+20221222180647/cmake_modules/FindTOUPCAM.cmake 0000644 0001751 0001751 00000002676 14174600255 022652 0 ustar debian debian # - 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)
indi-orion-ssg3-0.1+20221222180647/cmake_modules/FindQSI.cmake 0000644 0001751 0001751 00000002455 14174600255 022171 0 ustar debian debian # - 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)
indi-orion-ssg3-0.1+20221222180647/cmake_modules/UnityBuild.cmake 0000644 0001751 0001751 00000016277 14174600255 023033 0 ustar debian debian #
# 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 ()
indi-orion-ssg3-0.1+20221222180647/cmake_modules/FindLibRaw.cmake 0000644 0001751 0001751 00000005625 14174600255 022717 0 ustar debian debian # - 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
)
indi-orion-ssg3-0.1+20221222180647/cmake_modules/FindALTAIRCAM.cmake 0000644 0001751 0001751 00000003010 14174600255 023016 0 ustar debian debian # - 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)
indi-orion-ssg3-0.1+20221222180647/cmake_modules/FindSBIG.cmake 0000644 0001751 0001751 00000002512 14174600255 022253 0 ustar debian debian # - 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)
indi-orion-ssg3-0.1+20221222180647/cmake_modules/CMakeParseArguments.cmake 0000644 0001751 0001751 00000001642 14174600255 024572 0 ustar debian debian #.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.)
indi-orion-ssg3-0.1+20221222180647/cmake_modules/FindGPHOTO2.cmake 0000644 0001751 0001751 00000005626 14174600255 022622 0 ustar debian debian # - 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)
indi-orion-ssg3-0.1+20221222180647/cmake_modules/FindMMAL.cmake 0000644 0001751 0001751 00000003032 14174600255 022253 0 ustar debian debian # 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()
indi-orion-ssg3-0.1+20221222180647/cmake_modules/FindAIOUSB.cmake 0000644 0001751 0001751 00000003713 14174600255 022515 0 ustar debian debian # - 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)
indi-orion-ssg3-0.1+20221222180647/cmake_modules/FindAPOGEE.cmake 0000644 0001751 0001751 00000003115 14174600255 022467 0 ustar debian debian # - 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)
indi-orion-ssg3-0.1+20221222180647/cmake_modules/FindFFmpeg.cmake 0000644 0001751 0001751 00000016154 14243553447 022711 0 ustar debian debian # - 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)
indi-orion-ssg3-0.1+20221222180647/cmake_modules/FindNUTClient.cmake 0000644 0001751 0001751 00000003040 14347562502 023335 0 ustar debian debian # - Try to find nutclient library (version 2) and include files
# Once done this will define
#
# NUTCLIENT_FOUND - system has NUTCLIENT
# NUTCLIENT_INCLUDE_DIR - the NUTCLIENT include directory
# NUTCLIENT_LIBRARIES - Link these to use NUTCLIENT
# Redistribution and use is allowed according to the terms of the BSD license.
# For details see the accompanying COPYING-CMAKE-SCRIPTS file.
if (NUTCLIENT_INCLUDE_DIR AND NUTCLIENT_LIBRARIES)
# in cache already
set(NUTCLIENT_FOUND TRUE)
message(STATUS "Found libnutclient: ${NUTCLIENT_LIBRARIES}")
else (NUTCLIENT_INCLUDE_DIR AND NUTCLIENT_LIBRARIES)
find_path(NUTCLIENT_INCLUDE_DIR nutclient.h
PATH_SUFFIXES nutclient
${_obIncDir}
${GNUWIN32_DIR}/include
)
find_library(NUTCLIENT_LIBRARIES NAMES nutclient
PATHS
${_obLinkDir}
${GNUWIN32_DIR}/lib
)
if(NUTCLIENT_INCLUDE_DIR AND NUTCLIENT_LIBRARIES)
set(NUTCLIENT_FOUND TRUE)
else (NUTCLIENT_INCLUDE_DIR AND NUTCLIENT_LIBRARIES)
set(NUTCLIENT_FOUND FALSE)
endif(NUTCLIENT_INCLUDE_DIR AND NUTCLIENT_LIBRARIES)
if (NUTCLIENT_FOUND)
if (NOT NUTCLIENT_FIND_QUIETLY)
message(STATUS "Found NUTCLIENT: ${NUTCLIENT_LIBRARIES}")
endif (NOT NUTCLIENT_FIND_QUIETLY)
else (NUTCLIENT_FOUND)
if (NUTCLIENT_FIND_REQUIRED)
message(FATAL_ERROR "NUTCLIENT not found. Please install libnutclient development package.")
endif (NUTCLIENT_FIND_REQUIRED)
endif (NUTCLIENT_FOUND)
mark_as_advanced(NUTCLIENT_INCLUDE_DIR NUTCLIENT_LIBRARIES)
endif (NUTCLIENT_INCLUDE_DIR AND NUTCLIENT_LIBRARIES)
indi-orion-ssg3-0.1+20221222180647/cmake_modules/FindIconv.cmake 0000644 0001751 0001751 00000004261 14174600255 022610 0 ustar debian debian #
# 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
)
indi-orion-ssg3-0.1+20221222180647/cmake_modules/FindLIMESUITE.cmake 0000644 0001751 0001751 00000003012 14174600255 023063 0 ustar debian debian # - 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)
indi-orion-ssg3-0.1+20221222180647/cmake_modules/FindOMEGONPROCAM.cmake 0000644 0001751 0001751 00000003233 14247236061 023417 0 ustar debian debian # - 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)
indi-orion-ssg3-0.1+20221222180647/cmake_modules/FindPLAYERONE.cmake 0000644 0001751 0001751 00000003221 14347562502 023067 0 ustar debian debian # - 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.3 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)
indi-orion-ssg3-0.1+20221222180647/cmake_modules/FindLibCameraApps.cmake 0000644 0001751 0001751 00000004251 14347562502 024200 0 ustar debian debian # - Try to find LIBCAMERAAPPS Library
# Once done this will define
#
# LIBCAMERAAPPS_FOUND - system has LIBCAMERAAPPS
# LIBCAMERAAPPS_APPS - Link these to use Apps
# LIBCAMERAAPPS_ENCODERS - Link these to use Encoders
# LIBCAMERAAPPS_IMAGES - Link these to use Images
# LIBCAMERAAPPS_OUTPUTS - Link these to use Outputs
# LIBCAMERAAPPS_PREVIEW - Link these to use Preview
# LIBCAMERAAPPS_POST - Link these to use Post Processing Stages
# Redistribution and use is allowed according to the terms of the BSD license.
# For details see the accompanying COPYING-CMAKE-SCRIPTS file.
if (LIBCAMERAAPPS_APPS)
# in cache already
set(LIBCAMERAAPPS_FOUND TRUE)
message(STATUS "Found LIBCAMERAAPPS: ${LIBCAMERAAPPS_APPS}")
else (LIBCAMERAAPPS_APPS)
find_library(LIBCAMERAAPPS_APPS NAMES camera_app
PATHS
${_obLinkDir}
${GNUWIN32_DIR}/lib
)
find_library(LIBCAMERAAPPS_ENCODERS NAMES encoders
PATHS
${_obLinkDir}
${GNUWIN32_DIR}/lib
)
find_library(LIBCAMERAAPPS_IMAGES NAMES images
PATHS
${_obLinkDir}
${GNUWIN32_DIR}/lib
)
find_library(LIBCAMERAAPPS_OUTPUTS NAMES outputs
PATHS
${_obLinkDir}
${GNUWIN32_DIR}/lib
)
find_library(LIBCAMERAAPPS_POST NAMES post_processing_stages
PATHS
${_obLinkDir}
${GNUWIN32_DIR}/lib
)
find_library(LIBCAMERAAPPS_PREVIEW NAMES preview
PATHS
${_obLinkDir}
${GNUWIN32_DIR}/lib
)
if(LIBCAMERAAPPS_APPS)
set(LIBCAMERAAPPS_FOUND TRUE)
else (LIBCAMERAAPPS_APPS)
set(LIBCAMERAAPPS_FOUND FALSE)
endif(LIBCAMERAAPPS_APPS)
if (LIBCAMERAAPPS_FOUND)
if (NOT LIBCAMERAAPPS_FIND_QUIETLY)
message(STATUS "Found LIBCAMERAAPPS Library: ${LIBCAMERAAPPS_APPS}")
endif (NOT LIBCAMERAAPPS_FIND_QUIETLY)
else (LIBCAMERAAPPS_FOUND)
if (LIBCAMERAAPPS_FIND_REQUIRED)
message(FATAL_ERROR "LIBCAMERAAPPS Library not found. Please install libcamera-apps")
endif (LIBCAMERAAPPS_FIND_REQUIRED)
endif (LIBCAMERAAPPS_FOUND)
mark_as_advanced(LIBCAMERAAPPS_APPS LIBCAMERAAPPS_ENCODERS LIBCAMERAAPPS_IMAGES LIBCAMERAAPPS_OUTPUTS LIBCAMERAAPPS_POST LIBCAMERAAPPS_PREVIEW)
endif (LIBCAMERAAPPS_APPS)
indi-orion-ssg3-0.1+20221222180647/cmake_modules/FindNNCAM.cmake 0000644 0001751 0001751 00000002563 14174600255 022371 0 ustar debian debian # - 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)
indi-orion-ssg3-0.1+20221222180647/cmake_modules/FindRT.cmake 0000644 0001751 0001751 00000001525 14174600255 022057 0 ustar debian debian # 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() indi-orion-ssg3-0.1+20221222180647/99-orionssg3.rules 0000644 0001751 0001751 00000000113 14243553447 020357 0 ustar debian debian # All Orion Cameras
SUBSYSTEMS=="usb", ATTR{idVendor}=="07ee", MODE="0666"
indi-orion-ssg3-0.1+20221222180647/LICENSE 0000644 0001751 0001751 00000104515 14174600255 016127 0 ustar debian debian GNU GENERAL PUBLIC LICENSE
Version 3, 29 June 2007
Copyright (C) 2007 Free Software Foundation, Inc.
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
Preamble
The GNU General Public License is a free, copyleft license for
software and other kinds of works.
The licenses for most software and other practical works are designed
to take away your freedom to share and change the works. By contrast,
the GNU General Public License is intended to guarantee your freedom to
share and change all versions of a program--to make sure it remains free
software for all its users. We, the Free Software Foundation, use the
GNU General Public License for most of our software; it applies also to
any other work released this way by its authors. You can apply it to
your programs, too.
When we speak of free software, we are referring to freedom, not
price. Our General Public Licenses are designed to make sure that you
have the freedom to distribute copies of free software (and charge for
them if you wish), that you receive source code or can get it if you
want it, that you can change the software or use pieces of it in new
free programs, and that you know you can do these things.
To protect your rights, we need to prevent others from denying you
these rights or asking you to surrender the rights. Therefore, you have
certain responsibilities if you distribute copies of the software, or if
you modify it: responsibilities to respect the freedom of others.
For example, if you distribute copies of such a program, whether
gratis or for a fee, you must pass on to the recipients the same
freedoms that you received. You must make sure that they, too, receive
or can get the source code. And you must show them these terms so they
know their rights.
Developers that use the GNU GPL protect your rights with two steps:
(1) assert copyright on the software, and (2) offer you this License
giving you legal permission to copy, distribute and/or modify it.
For the developers' and authors' protection, the GPL clearly explains
that there is no warranty for this free software. For both users' and
authors' sake, the GPL requires that modified versions be marked as
changed, so that their problems will not be attributed erroneously to
authors of previous versions.
Some devices are designed to deny users access to install or run
modified versions of the software inside them, although the manufacturer
can do so. This is fundamentally incompatible with the aim of
protecting users' freedom to change the software. The systematic
pattern of such abuse occurs in the area of products for individuals to
use, which is precisely where it is most unacceptable. Therefore, we
have designed this version of the GPL to prohibit the practice for those
products. If such problems arise substantially in other domains, we
stand ready to extend this provision to those domains in future versions
of the GPL, as needed to protect the freedom of users.
Finally, every program is threatened constantly by software patents.
States should not allow patents to restrict development and use of
software on general-purpose computers, but in those that do, we wish to
avoid the special danger that patents applied to a free program could
make it effectively proprietary. To prevent this, the GPL assures that
patents cannot be used to render the program non-free.
The precise terms and conditions for copying, distribution and
modification follow.
TERMS AND CONDITIONS
0. Definitions.
"This License" refers to version 3 of the GNU General Public License.
"Copyright" also means copyright-like laws that apply to other kinds of
works, such as semiconductor masks.
"The Program" refers to any copyrightable work licensed under this
License. Each licensee is addressed as "you". "Licensees" and
"recipients" may be individuals or organizations.
To "modify" a work means to copy from or adapt all or part of the work
in a fashion requiring copyright permission, other than the making of an
exact copy. The resulting work is called a "modified version" of the
earlier work or a work "based on" the earlier work.
A "covered work" means either the unmodified Program or a work based
on the Program.
To "propagate" a work means to do anything with it that, without
permission, would make you directly or secondarily liable for
infringement under applicable copyright law, except executing it on a
computer or modifying a private copy. Propagation includes copying,
distribution (with or without modification), making available to the
public, and in some countries other activities as well.
To "convey" a work means any kind of propagation that enables other
parties to make or receive copies. Mere interaction with a user through
a computer network, with no transfer of a copy, is not conveying.
An interactive user interface displays "Appropriate Legal Notices"
to the extent that it includes a convenient and prominently visible
feature that (1) displays an appropriate copyright notice, and (2)
tells the user that there is no warranty for the work (except to the
extent that warranties are provided), that licensees may convey the
work under this License, and how to view a copy of this License. If
the interface presents a list of user commands or options, such as a
menu, a prominent item in the list meets this criterion.
1. Source Code.
The "source code" for a work means the preferred form of the work
for making modifications to it. "Object code" means any non-source
form of a work.
A "Standard Interface" means an interface that either is an official
standard defined by a recognized standards body, or, in the case of
interfaces specified for a particular programming language, one that
is widely used among developers working in that language.
The "System Libraries" of an executable work include anything, other
than the work as a whole, that (a) is included in the normal form of
packaging a Major Component, but which is not part of that Major
Component, and (b) serves only to enable use of the work with that
Major Component, or to implement a Standard Interface for which an
implementation is available to the public in source code form. A
"Major Component", in this context, means a major essential component
(kernel, window system, and so on) of the specific operating system
(if any) on which the executable work runs, or a compiler used to
produce the work, or an object code interpreter used to run it.
The "Corresponding Source" for a work in object code form means all
the source code needed to generate, install, and (for an executable
work) run the object code and to modify the work, including scripts to
control those activities. However, it does not include the work's
System Libraries, or general-purpose tools or generally available free
programs which are used unmodified in performing those activities but
which are not part of the work. For example, Corresponding Source
includes interface definition files associated with source files for
the work, and the source code for shared libraries and dynamically
linked subprograms that the work is specifically designed to require,
such as by intimate data communication or control flow between those
subprograms and other parts of the work.
The Corresponding Source need not include anything that users
can regenerate automatically from other parts of the Corresponding
Source.
The Corresponding Source for a work in source code form is that
same work.
2. Basic Permissions.
All rights granted under this License are granted for the term of
copyright on the Program, and are irrevocable provided the stated
conditions are met. This License explicitly affirms your unlimited
permission to run the unmodified Program. The output from running a
covered work is covered by this License only if the output, given its
content, constitutes a covered work. This License acknowledges your
rights of fair use or other equivalent, as provided by copyright law.
You may make, run and propagate covered works that you do not
convey, without conditions so long as your license otherwise remains
in force. You may convey covered works to others for the sole purpose
of having them make modifications exclusively for you, or provide you
with facilities for running those works, provided that you comply with
the terms of this License in conveying all material for which you do
not control copyright. Those thus making or running the covered works
for you must do so exclusively on your behalf, under your direction
and control, on terms that prohibit them from making any copies of
your copyrighted material outside their relationship with you.
Conveying under any other circumstances is permitted solely under
the conditions stated below. Sublicensing is not allowed; section 10
makes it unnecessary.
3. Protecting Users' Legal Rights From Anti-Circumvention Law.
No covered work shall be deemed part of an effective technological
measure under any applicable law fulfilling obligations under article
11 of the WIPO copyright treaty adopted on 20 December 1996, or
similar laws prohibiting or restricting circumvention of such
measures.
When you convey a covered work, you waive any legal power to forbid
circumvention of technological measures to the extent such circumvention
is effected by exercising rights under this License with respect to
the covered work, and you disclaim any intention to limit operation or
modification of the work as a means of enforcing, against the work's
users, your or third parties' legal rights to forbid circumvention of
technological measures.
4. Conveying Verbatim Copies.
You may convey verbatim copies of the Program's source code as you
receive it, in any medium, provided that you conspicuously and
appropriately publish on each copy an appropriate copyright notice;
keep intact all notices stating that this License and any
non-permissive terms added in accord with section 7 apply to the code;
keep intact all notices of the absence of any warranty; and give all
recipients a copy of this License along with the Program.
You may charge any price or no price for each copy that you convey,
and you may offer support or warranty protection for a fee.
5. Conveying Modified Source Versions.
You may convey a work based on the Program, or the modifications to
produce it from the Program, in the form of source code under the
terms of section 4, provided that you also meet all of these conditions:
a) The work must carry prominent notices stating that you modified
it, and giving a relevant date.
b) The work must carry prominent notices stating that it is
released under this License and any conditions added under section
7. This requirement modifies the requirement in section 4 to
"keep intact all notices".
c) You must license the entire work, as a whole, under this
License to anyone who comes into possession of a copy. This
License will therefore apply, along with any applicable section 7
additional terms, to the whole of the work, and all its parts,
regardless of how they are packaged. This License gives no
permission to license the work in any other way, but it does not
invalidate such permission if you have separately received it.
d) If the work has interactive user interfaces, each must display
Appropriate Legal Notices; however, if the Program has interactive
interfaces that do not display Appropriate Legal Notices, your
work need not make them do so.
A compilation of a covered work with other separate and independent
works, which are not by their nature extensions of the covered work,
and which are not combined with it such as to form a larger program,
in or on a volume of a storage or distribution medium, is called an
"aggregate" if the compilation and its resulting copyright are not
used to limit the access or legal rights of the compilation's users
beyond what the individual works permit. Inclusion of a covered work
in an aggregate does not cause this License to apply to the other
parts of the aggregate.
6. Conveying Non-Source Forms.
You may convey a covered work in object code form under the terms
of sections 4 and 5, provided that you also convey the
machine-readable Corresponding Source under the terms of this License,
in one of these ways:
a) Convey the object code in, or embodied in, a physical product
(including a physical distribution medium), accompanied by the
Corresponding Source fixed on a durable physical medium
customarily used for software interchange.
b) Convey the object code in, or embodied in, a physical product
(including a physical distribution medium), accompanied by a
written offer, valid for at least three years and valid for as
long as you offer spare parts or customer support for that product
model, to give anyone who possesses the object code either (1) a
copy of the Corresponding Source for all the software in the
product that is covered by this License, on a durable physical
medium customarily used for software interchange, for a price no
more than your reasonable cost of physically performing this
conveying of source, or (2) access to copy the
Corresponding Source from a network server at no charge.
c) Convey individual copies of the object code with a copy of the
written offer to provide the Corresponding Source. This
alternative is allowed only occasionally and noncommercially, and
only if you received the object code with such an offer, in accord
with subsection 6b.
d) Convey the object code by offering access from a designated
place (gratis or for a charge), and offer equivalent access to the
Corresponding Source in the same way through the same place at no
further charge. You need not require recipients to copy the
Corresponding Source along with the object code. If the place to
copy the object code is a network server, the Corresponding Source
may be on a different server (operated by you or a third party)
that supports equivalent copying facilities, provided you maintain
clear directions next to the object code saying where to find the
Corresponding Source. Regardless of what server hosts the
Corresponding Source, you remain obligated to ensure that it is
available for as long as needed to satisfy these requirements.
e) Convey the object code using peer-to-peer transmission, provided
you inform other peers where the object code and Corresponding
Source of the work are being offered to the general public at no
charge under subsection 6d.
A separable portion of the object code, whose source code is excluded
from the Corresponding Source as a System Library, need not be
included in conveying the object code work.
A "User Product" is either (1) a "consumer product", which means any
tangible personal property which is normally used for personal, family,
or household purposes, or (2) anything designed or sold for incorporation
into a dwelling. In determining whether a product is a consumer product,
doubtful cases shall be resolved in favor of coverage. For a particular
product received by a particular user, "normally used" refers to a
typical or common use of that class of product, regardless of the status
of the particular user or of the way in which the particular user
actually uses, or expects or is expected to use, the product. A product
is a consumer product regardless of whether the product has substantial
commercial, industrial or non-consumer uses, unless such uses represent
the only significant mode of use of the product.
"Installation Information" for a User Product means any methods,
procedures, authorization keys, or other information required to install
and execute modified versions of a covered work in that User Product from
a modified version of its Corresponding Source. The information must
suffice to ensure that the continued functioning of the modified object
code is in no case prevented or interfered with solely because
modification has been made.
If you convey an object code work under this section in, or with, or
specifically for use in, a User Product, and the conveying occurs as
part of a transaction in which the right of possession and use of the
User Product is transferred to the recipient in perpetuity or for a
fixed term (regardless of how the transaction is characterized), the
Corresponding Source conveyed under this section must be accompanied
by the Installation Information. But this requirement does not apply
if neither you nor any third party retains the ability to install
modified object code on the User Product (for example, the work has
been installed in ROM).
The requirement to provide Installation Information does not include a
requirement to continue to provide support service, warranty, or updates
for a work that has been modified or installed by the recipient, or for
the User Product in which it has been modified or installed. Access to a
network may be denied when the modification itself materially and
adversely affects the operation of the network or violates the rules and
protocols for communication across the network.
Corresponding Source conveyed, and Installation Information provided,
in accord with this section must be in a format that is publicly
documented (and with an implementation available to the public in
source code form), and must require no special password or key for
unpacking, reading or copying.
7. Additional Terms.
"Additional permissions" are terms that supplement the terms of this
License by making exceptions from one or more of its conditions.
Additional permissions that are applicable to the entire Program shall
be treated as though they were included in this License, to the extent
that they are valid under applicable law. If additional permissions
apply only to part of the Program, that part may be used separately
under those permissions, but the entire Program remains governed by
this License without regard to the additional permissions.
When you convey a copy of a covered work, you may at your option
remove any additional permissions from that copy, or from any part of
it. (Additional permissions may be written to require their own
removal in certain cases when you modify the work.) You may place
additional permissions on material, added by you to a covered work,
for which you have or can give appropriate copyright permission.
Notwithstanding any other provision of this License, for material you
add to a covered work, you may (if authorized by the copyright holders of
that material) supplement the terms of this License with terms:
a) Disclaiming warranty or limiting liability differently from the
terms of sections 15 and 16 of this License; or
b) Requiring preservation of specified reasonable legal notices or
author attributions in that material or in the Appropriate Legal
Notices displayed by works containing it; or
c) Prohibiting misrepresentation of the origin of that material, or
requiring that modified versions of such material be marked in
reasonable ways as different from the original version; or
d) Limiting the use for publicity purposes of names of licensors or
authors of the material; or
e) Declining to grant rights under trademark law for use of some
trade names, trademarks, or service marks; or
f) Requiring indemnification of licensors and authors of that
material by anyone who conveys the material (or modified versions of
it) with contractual assumptions of liability to the recipient, for
any liability that these contractual assumptions directly impose on
those licensors and authors.
All other non-permissive additional terms are considered "further
restrictions" within the meaning of section 10. If the Program as you
received it, or any part of it, contains a notice stating that it is
governed by this License along with a term that is a further
restriction, you may remove that term. If a license document contains
a further restriction but permits relicensing or conveying under this
License, you may add to a covered work material governed by the terms
of that license document, provided that the further restriction does
not survive such relicensing or conveying.
If you add terms to a covered work in accord with this section, you
must place, in the relevant source files, a statement of the
additional terms that apply to those files, or a notice indicating
where to find the applicable terms.
Additional terms, permissive or non-permissive, may be stated in the
form of a separately written license, or stated as exceptions;
the above requirements apply either way.
8. Termination.
You may not propagate or modify a covered work except as expressly
provided under this License. Any attempt otherwise to propagate or
modify it is void, and will automatically terminate your rights under
this License (including any patent licenses granted under the third
paragraph of section 11).
However, if you cease all violation of this License, then your
license from a particular copyright holder is reinstated (a)
provisionally, unless and until the copyright holder explicitly and
finally terminates your license, and (b) permanently, if the copyright
holder fails to notify you of the violation by some reasonable means
prior to 60 days after the cessation.
Moreover, your license from a particular copyright holder is
reinstated permanently if the copyright holder notifies you of the
violation by some reasonable means, this is the first time you have
received notice of violation of this License (for any work) from that
copyright holder, and you cure the violation prior to 30 days after
your receipt of the notice.
Termination of your rights under this section does not terminate the
licenses of parties who have received copies or rights from you under
this License. If your rights have been terminated and not permanently
reinstated, you do not qualify to receive new licenses for the same
material under section 10.
9. Acceptance Not Required for Having Copies.
You are not required to accept this License in order to receive or
run a copy of the Program. Ancillary propagation of a covered work
occurring solely as a consequence of using peer-to-peer transmission
to receive a copy likewise does not require acceptance. However,
nothing other than this License grants you permission to propagate or
modify any covered work. These actions infringe copyright if you do
not accept this License. Therefore, by modifying or propagating a
covered work, you indicate your acceptance of this License to do so.
10. Automatic Licensing of Downstream Recipients.
Each time you convey a covered work, the recipient automatically
receives a license from the original licensors, to run, modify and
propagate that work, subject to this License. You are not responsible
for enforcing compliance by third parties with this License.
An "entity transaction" is a transaction transferring control of an
organization, or substantially all assets of one, or subdividing an
organization, or merging organizations. If propagation of a covered
work results from an entity transaction, each party to that
transaction who receives a copy of the work also receives whatever
licenses to the work the party's predecessor in interest had or could
give under the previous paragraph, plus a right to possession of the
Corresponding Source of the work from the predecessor in interest, if
the predecessor has it or can get it with reasonable efforts.
You may not impose any further restrictions on the exercise of the
rights granted or affirmed under this License. For example, you may
not impose a license fee, royalty, or other charge for exercise of
rights granted under this License, and you may not initiate litigation
(including a cross-claim or counterclaim in a lawsuit) alleging that
any patent claim is infringed by making, using, selling, offering for
sale, or importing the Program or any portion of it.
11. Patents.
A "contributor" is a copyright holder who authorizes use under this
License of the Program or a work on which the Program is based. The
work thus licensed is called the contributor's "contributor version".
A contributor's "essential patent claims" are all patent claims
owned or controlled by the contributor, whether already acquired or
hereafter acquired, that would be infringed by some manner, permitted
by this License, of making, using, or selling its contributor version,
but do not include claims that would be infringed only as a
consequence of further modification of the contributor version. For
purposes of this definition, "control" includes the right to grant
patent sublicenses in a manner consistent with the requirements of
this License.
Each contributor grants you a non-exclusive, worldwide, royalty-free
patent license under the contributor's essential patent claims, to
make, use, sell, offer for sale, import and otherwise run, modify and
propagate the contents of its contributor version.
In the following three paragraphs, a "patent license" is any express
agreement or commitment, however denominated, not to enforce a patent
(such as an express permission to practice a patent or covenant not to
sue for patent infringement). To "grant" such a patent license to a
party means to make such an agreement or commitment not to enforce a
patent against the party.
If you convey a covered work, knowingly relying on a patent license,
and the Corresponding Source of the work is not available for anyone
to copy, free of charge and under the terms of this License, through a
publicly available network server or other readily accessible means,
then you must either (1) cause the Corresponding Source to be so
available, or (2) arrange to deprive yourself of the benefit of the
patent license for this particular work, or (3) arrange, in a manner
consistent with the requirements of this License, to extend the patent
license to downstream recipients. "Knowingly relying" means you have
actual knowledge that, but for the patent license, your conveying the
covered work in a country, or your recipient's use of the covered work
in a country, would infringe one or more identifiable patents in that
country that you have reason to believe are valid.
If, pursuant to or in connection with a single transaction or
arrangement, you convey, or propagate by procuring conveyance of, a
covered work, and grant a patent license to some of the parties
receiving the covered work authorizing them to use, propagate, modify
or convey a specific copy of the covered work, then the patent license
you grant is automatically extended to all recipients of the covered
work and works based on it.
A patent license is "discriminatory" if it does not include within
the scope of its coverage, prohibits the exercise of, or is
conditioned on the non-exercise of one or more of the rights that are
specifically granted under this License. You may not convey a covered
work if you are a party to an arrangement with a third party that is
in the business of distributing software, under which you make payment
to the third party based on the extent of your activity of conveying
the work, and under which the third party grants, to any of the
parties who would receive the covered work from you, a discriminatory
patent license (a) in connection with copies of the covered work
conveyed by you (or copies made from those copies), or (b) primarily
for and in connection with specific products or compilations that
contain the covered work, unless you entered into that arrangement,
or that patent license was granted, prior to 28 March 2007.
Nothing in this License shall be construed as excluding or limiting
any implied license or other defenses to infringement that may
otherwise be available to you under applicable patent law.
12. No Surrender of Others' Freedom.
If conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License. If you cannot convey a
covered work so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you may
not convey it at all. For example, if you agree to terms that obligate you
to collect a royalty for further conveying from those to whom you convey
the Program, the only way you could satisfy both those terms and this
License would be to refrain entirely from conveying the Program.
13. Use with the GNU Affero General Public License.
Notwithstanding any other provision of this License, you have
permission to link or combine any covered work with a work licensed
under version 3 of the GNU Affero General Public License into a single
combined work, and to convey the resulting work. The terms of this
License will continue to apply to the part which is the covered work,
but the special requirements of the GNU Affero General Public License,
section 13, concerning interaction through a network will apply to the
combination as such.
14. Revised Versions of this License.
The Free Software Foundation may publish revised and/or new versions of
the GNU General Public License from time to time. Such new versions will
be similar in spirit to the present version, but may differ in detail to
address new problems or concerns.
Each version is given a distinguishing version number. If the
Program specifies that a certain numbered version of the GNU General
Public License "or any later version" applies to it, you have the
option of following the terms and conditions either of that numbered
version or of any later version published by the Free Software
Foundation. If the Program does not specify a version number of the
GNU General Public License, you may choose any version ever published
by the Free Software Foundation.
If the Program specifies that a proxy can decide which future
versions of the GNU General Public License can be used, that proxy's
public statement of acceptance of a version permanently authorizes you
to choose that version for the Program.
Later license versions may give you additional or different
permissions. However, no additional obligations are imposed on any
author or copyright holder as a result of your choosing to follow a
later version.
15. Disclaimer of Warranty.
THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
16. Limitation of Liability.
IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
SUCH DAMAGES.
17. Interpretation of Sections 15 and 16.
If the disclaimer of warranty and limitation of liability provided
above cannot be given local legal effect according to their terms,
reviewing courts shall apply local law that most closely approximates
an absolute waiver of all civil liability in connection with the
Program, unless a warranty or assumption of liability accompanies a
copy of the Program in return for a fee.
END OF TERMS AND CONDITIONS
How to Apply These Terms to Your New Programs
If you develop a new program, and you want it to be of the greatest
possible use to the public, the best way to achieve this is to make it
free software which everyone can redistribute and change under these terms.
To do so, attach the following notices to the program. It is safest
to attach them to the start of each source file to most effectively
state the exclusion of warranty; and each file should have at least
the "copyright" line and a pointer to where the full notice is found.
Copyright (C)
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see .
Also add information on how to contact you by electronic and paper mail.
If the program does terminal interaction, make it output a short
notice like this when it starts in an interactive mode:
Copyright (C)
This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
This is free software, and you are welcome to redistribute it
under certain conditions; type `show c' for details.
The hypothetical commands `show w' and `show c' should show the appropriate
parts of the General Public License. Of course, your program's commands
might be different; for a GUI interface, you would use an "about box".
You should also get your employer (if you work as a programmer) or school,
if any, to sign a "copyright disclaimer" for the program, if necessary.
For more information on this, and how to apply and follow the GNU GPL, see
.
The GNU General Public License does not permit incorporating your program
into proprietary programs. If your program is a subroutine library, you
may consider it more useful to permit linking proprietary applications with
the library. If this is what you want to do, use the GNU Lesser General
Public License instead of this License. But first, please read
.
indi-orion-ssg3-0.1+20221222180647/CMakeLists.txt 0000644 0001751 0001751 00000003467 14174600255 017666 0 ustar debian debian cmake_minimum_required(VERSION 2.8)
PROJECT(indi-orion_ssg3 CXX C)
LIST(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake_modules/")
LIST(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/../cmake_modules/")
include(GNUInstallDirs)
IF(APPLE)
ELSE(APPLE)
set(RULES_INSTALL_DIR "/lib/udev/rules.d")
ENDIF()
set (ORION_SSG3_VERSION_MAJOR 0)
set (ORION_SSG3_VERSION_MINOR 1)
find_package(CFITSIO REQUIRED)
find_package(INDI REQUIRED)
find_package(ZLIB REQUIRED)
find_package(USB1 REQUIRED)
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/config.h.cmake ${CMAKE_CURRENT_BINARY_DIR}/config.h )
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/indi_orion_ssg3.xml.cmake ${CMAKE_CURRENT_BINARY_DIR}/indi_orion_ssg3.xml)
include_directories( ${CMAKE_CURRENT_BINARY_DIR})
include_directories( ${CMAKE_CURRENT_SOURCE_DIR})
include_directories( ${INDI_INCLUDE_DIR})
include_directories( ${CFITSIO_INCLUDE_DIR})
include(CMakeCommon)
# This warning only valid for Clang above version 3.9
IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang" AND CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 3.8.9)
SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-undefined-var-template")
ENDIF ()
########### DSI ###########
set(indiorionssg3_SRCS
${CMAKE_CURRENT_SOURCE_DIR}/orion_ssg3.c
${CMAKE_CURRENT_SOURCE_DIR}/orion_ssg3_ccd.cpp
)
IF (UNITY_BUILD)
ENABLE_UNITY_BUILD(indiorionssg3 indiorionssg3_SRCS 10 cpp)
ENDIF ()
add_executable(indi_orion_ssg3_ccd ${indiorionssg3_SRCS})
target_link_libraries(indi_orion_ssg3_ccd ${INDI_LIBRARIES} ${CFITSIO_LIBRARIES} ${USB1_LIBRARIES} )
install(TARGETS indi_orion_ssg3_ccd RUNTIME DESTINATION bin )
install(FILES ${CMAKE_CURRENT_BINARY_DIR}/indi_orion_ssg3.xml DESTINATION ${INDI_DATA_DIR})
IF (${CMAKE_SYSTEM_NAME} MATCHES "Linux")
install(FILES 99-orionssg3.rules DESTINATION ${RULES_INSTALL_DIR})
ENDIF()
indi-orion-ssg3-0.1+20221222180647/config.h.cmake 0000644 0001751 0001751 00000000423 14174600255 017610 0 ustar debian debian #ifndef CONFIG_H
#define CONFIG_H
/* Define INDI Data Dir */
#cmakedefine INDI_DATA_DIR "@INDI_DATA_DIR@"
/* Define Driver version */
#define ORION_SSG3_VERSION_MAJOR @ORION_SSG3_VERSION_MAJOR@
#define ORION_SSG3_VERSION_MINOR @ORION_SSG3_VERSION_MINOR@
#endif // CONFIG_H
indi-orion-ssg3-0.1+20221222180647/README.md 0000644 0001751 0001751 00000001116 14174600255 016372 0 ustar debian debian This package provides the INDI driver for the Orion StarShoot G3 cameras. It
expected that this will also work with Brightstar Mammut Lyuba cameras.
# Requirements
+ INDI
+ CFITSIO
+ libusb
# Installation
Go to the directory where you unpacked indi_orion_ssg3 sources and do:
mkdir build
cd build
cmake -DCMAKE_INSTALL_PREFIX=/usr ..
make
sudo make install
# Running
Once installed, the Orion StarShoot G3 INDI driver can be used by an INDI client such as
KStars (Ekos) or OpenPHD. It can also be used manually by invoking it via the
indi_server:
$ indi_server indi_orion_ssg3_ccd
indi-orion-ssg3-0.1+20221222180647/indi_orion_ssg3.xml.cmake 0000644 0001751 0001751 00000000553 14174600255 022010 0 ustar debian debian
indi_orion_ssg3_ccd
@ORION_SSG3_VERSION_MAJOR@.@ORION_SSG3_VERSION_MINOR@
indi-orion-ssg3-0.1+20221222180647/orion_ssg3_ccd.cpp 0000644 0001751 0001751 00000034474 14243553447 020541 0 ustar debian debian /**
* INDI driver for Orion Starshoot G3 (and similar) cameras
*
* Copyright (c) 2020-2021 Ben Gilsrud
* Copyright (c) 2021 Jasem Mutlaq
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include
#include
#include
#include
#include "orion_ssg3_ccd.h"
#include "orion_ssg3.h"
#include "config.h"
#include