Common.h

Go to the documentation of this file.

 
#pragma once
 
#include <cstring>
#include <cmath>
#include <memory>
 
 
namespace INDI
{
namespace AlignmentSubsystem
{
typedef enum MountAlignment { ZENITH, NORTH_CELESTIAL_POLE, SOUTH_CELESTIAL_POLE } MountAlignment_t;
 
enum AlignmentDatabaseActions
{
    APPEND,
    INSERT,
    EDIT,
    DELETE,
    CLEAR,
    READ,
    READ_INCREMENT,
    LOAD_DATABASE,
    SAVE_DATABASE
};
 
enum AlignmentPointSetEnum
{
    ENTRY_OBSERVATION_JULIAN_DATE,
    ENTRY_RA,
    ENTRY_DEC,
    ENTRY_VECTOR_X,
    ENTRY_VECTOR_Y,
    ENTRY_VECTOR_Z
};
 
struct TelescopeDirectionVector
{
    TelescopeDirectionVector() : x(0), y(0), z(0) {}
 
    TelescopeDirectionVector(double X, double Y, double Z) : x(X), y(Y), z(Z) {}
 
    double x;
    double y;
    double z;
 
    inline const TelescopeDirectionVector operator*(const TelescopeDirectionVector &RHS) const
    {
        TelescopeDirectionVector Result;
 
        Result.x = y * RHS.z - z * RHS.y;
        Result.y = z * RHS.x - x * RHS.z;
        Result.z = x * RHS.y - y * RHS.x;
        return Result;
    }
 
    inline const TelescopeDirectionVector operator*(const double &RHS) const
    {
        TelescopeDirectionVector Result;
 
        Result.x = x * RHS;
        Result.y = y * RHS;
        Result.z = z * RHS;
        return Result;
    }
 
    inline const TelescopeDirectionVector &operator*=(const double &RHS)
    {
        x *= RHS;
        y *= RHS;
        z *= RHS;
        return *this;
    }
 
    inline const TelescopeDirectionVector operator-(const TelescopeDirectionVector &RHS) const
    {
        return TelescopeDirectionVector(x - RHS.x, y - RHS.y, z - RHS.z);
    }
 
    inline double operator^(const TelescopeDirectionVector &RHS) const
    {
        return x * RHS.x + y * RHS.y + z * RHS.z;
    }
 
    inline double Length() const
    {
        return sqrt(x * x + y * y + z * z);
    }
 
    inline void Normalise()
    {
        double length = sqrt(x * x + y * y + z * z);
        x /= length;
        y /= length;
        z /= length;
    }
 
    void RotateAroundY(double Angle);
};
 
struct AlignmentDatabaseEntry
{
    AlignmentDatabaseEntry() : ObservationJulianDate(0), RightAscension(0), Declination(0), PrivateDataSize(0) {}
 
    AlignmentDatabaseEntry(const AlignmentDatabaseEntry &Source)
        : ObservationJulianDate(Source.ObservationJulianDate), RightAscension(Source.RightAscension),
          Declination(Source.Declination), TelescopeDirection(Source.TelescopeDirection),
          PrivateDataSize(Source.PrivateDataSize)
    {
        if (0 != PrivateDataSize)
        {
            PrivateData.reset(new unsigned char[PrivateDataSize]);
            memcpy(PrivateData.get(), Source.PrivateData.get(), PrivateDataSize);
        }
    }
 
    inline const AlignmentDatabaseEntry &operator=(const AlignmentDatabaseEntry &RHS)
    {
        ObservationJulianDate = RHS.ObservationJulianDate;
        RightAscension        = RHS.RightAscension;
        Declination           = RHS.Declination;
        TelescopeDirection    = RHS.TelescopeDirection;
        PrivateDataSize       = RHS.PrivateDataSize;
        if (0 != PrivateDataSize)
        {
            PrivateData.reset(new unsigned char[PrivateDataSize]);
            memcpy(PrivateData.get(), RHS.PrivateData.get(), PrivateDataSize);
        }
 
        return *this;
    }
 
    double ObservationJulianDate;
 
    double RightAscension;
 
    double Declination;
 
    TelescopeDirectionVector TelescopeDirection;
 
    std::unique_ptr<unsigned char> PrivateData;
 
    int PrivateDataSize;
};
 
} // namespace AlignmentSubsystem
} // namespace INDI