PhenomTypes.h

/*
 *  PhenomTypes.h
 *  PhenomCtl
 *
 *  Created by Sander Stoks on 1/7/11.
 *  Copyright 2011 Phenom World B.V. All rights reserved.
 *
 */

#ifndef PHENOMTYPES_H
#define PHENOMTYPES_H

#include "gSOAP/soapStub.h"
#include <stdexcept>
#include <boost/shared_ptr.hpp>

#undef min
#undef max

namespace PhenomTypes
{
    enum RetVal
    {
        OM_OK           = om__RetVal__OM_OK,            
        OM_FAIL         = om__RetVal__OM_FAIL,          
        OM_CONTEXT      = om__RetVal__OM_CONTEXT,       
        OM_COMM_ERROR   = om__RetVal__OM_COMM_ERROR,    
        OM_CLIPPED      = om__RetVal__OM_CLIPPED,       
        OM_UNCAL        = om__RetVal__OM_UNCAL,         
        
        // Only during connection phase
        ACCESSDENIED    = -13,                          
        EXCLUSIVE       = -16,                          
        INVALID_ADDRESS = -22,                          
        UNREACHABLE     = -1000,                        
        NORESPONSE      = -19,                      

        OTHER           = -1
    };
    const char* string(RetVal e);
    RetVal OMRetVal(om__RetVal retVal);
    
    struct Error
    {
        Error(RetVal code, const std::string& description);
        
        RetVal code;
        std::string description;
    };
    
    enum InstrumentMode
    {
        INSTRUMENT_MODE_OFF             = om__instrumentMode__INSTRUMENT_MODE_OFF,          
        INSTRUMENT_MODE_OPERATIONAL     = om__instrumentMode__INSTRUMENT_MODE_OPERATIONAL,  
        INSTRUMENT_MODE_STANDBY         = om__instrumentMode__INSTRUMENT_MODE_STANDBY,      
        INSTRUMENT_MODE_HIBERNATE       = om__instrumentMode__INSTRUMENT_MODE_HIBERNATE,    
        INSTRUMENT_MODE_INITIALIZING    = om__instrumentMode__INSTRUMENT_MODE_INITIALIZING, 
        INSTRUMENT_MODE_CLOSINGDOWN     = om__instrumentMode__INSTRUMENT_MODE_CLOSINGDOWN,  
        INSTRUMENT_MODE_ERROR           = om__instrumentMode__INSTRUMENT_MODE_ERROR         
    };
    const char* string(InstrumentMode m);
    
    enum OperationalMode
    {
        OPERATIONAL_MODE_UNAVAILABLE        = om__operationalMode__OPERATIONAL_MODE_UNAVAILABLE,        
        OPERATIONAL_MODE_LOADPOS            = om__operationalMode__OPERATIONAL_MODE_LOADPOS,            
        OPERATIONAL_MODE_UNLOADING          = om__operationalMode__OPERATIONAL_MODE_UNLOADING,          
        OPERATIONAL_MODE_SELECTINGNAVCAM    = om__operationalMode__OPERATIONAL_MODE_SELECTINGNAVCAM,    
        OPERATIONAL_MODE_SELECTINGSEM       = om__operationalMode__OPERATIONAL_MODE_SELECTINGSEM,       
        OPERATIONAL_MODE_LIVENAVCAM         = om__operationalMode__OPERATIONAL_MODE_LIVENAVCAM,         
        OPERATIONAL_MODE_LIVESEM            = om__operationalMode__OPERATIONAL_MODE_LIVESEM,            
        OPERATIONAL_MODE_ACQUIRENAVCAMIMAGE = om__operationalMode__OPERATIONAL_MODE_ACQUIRENAVCAMIMAGE, 
        OPERATIONAL_MODE_ACQUIRESEMIMAGE    = om__operationalMode__OPERATIONAL_MODE_ACQUIRESEMIMAGE     
    };
    const char* string(OperationalMode m);
    
    enum ImagingDevice
    {
        NAVCAMIMDEV = om__imagingDevice__NAVCAMIMDEV,   
        SEMIMDEV    = om__imagingDevice__SEMIMDEV       
    };
    const char* string(ImagingDevice d);
    
    struct Position
    {
        Position();
        Position(double x, double y);
        Position(const om__position& pos);
        double x;
        double y;
    };
    const Position CenterPosition;
    
    enum StageNavigationMode
    {
        STAGE_NAVIGATION_MODE_NOT_AVAILABLE = om__stageNavigMode__STAGE_NAVIGATION_MODE_NOT_AVAILABLE,  
        STAGE_NAVIGATION_MODE_REST          = om__stageNavigMode__STAGE_NAVIGATION_MODE_REST,           
        STAGE_NAVIGATION_MODE_PTP           = om__stageNavigMode__STAGE_NAVIGATION_MODE_PTP,            
        STAGE_NAVIGATION_MODE_JOG           = om__stageNavigMode__STAGE_NAVIGATION_MODE_JOG,            
        STAGE_NAVIGATION_MODE_NOT_HOMED     = om__stageNavigMode__STAGE_NAVIGATION_MODE_NOT_HOMED       
    };
    const char* string(StageNavigationMode m);
    
    struct StageModeAndPosition
    {
        StageNavigationMode mode;
        Position position;
    };
    
    enum NavigationAlgorithm
    {
        NAVIGATION_AUTO             = om__navigationAlgorithm__NAVIGATION_AUTO,             
        NAVIGATION_BACKLASH_ONLY    = om__navigationAlgorithm__NAVIGATION_BACKLASH_ONLY,    
        NAVIGATION_RAW              = om__navigationAlgorithm__NAVIGATION_RAW               
    };
    const char* string(NavigationAlgorithm a);

    struct StageStroke
    {
        Position NavCamMin;     
        Position NavCamMax;     
        Position SEMMin;        
        Position SEMMax;        
    };
    
    struct Range
    {
        Range();
        Range(double min, double max);
        double min;
        double max;
    };
    
    enum AutoFocusAlgorithm
    {
        AUTOFOCUS_AUTO          = om__autoFocusAlgorithm__AUTOFOCUS_AUTO,           
        AUTOFOCUS_COARSE_FINE   = om__autoFocusAlgorithm__AUTOFOCUS_COARSE_FINE,    
        AUTOFOCUS_FINE_ONLY     = om__autoFocusAlgorithm__AUTOFOCUS_FINE_ONLY       
    };
    const char* string(AutoFocusAlgorithm a);
    
    enum DetectorSegment
    {
        OM_SEM_DETECTOR_SEGMENT_OFF     = om__detectorSegment__OM_SEM_DETECTOR_SEGMENT_OFF,     
        OM_SEM_DETECTOR_SEGMENT_ON      = om__detectorSegment__OM_SEM_DETECTOR_SEGMENT_ON,      
        OM_SEM_DETECTOR_SEGMENT_INVERT  = om__detectorSegment__OM_SEM_DETECTOR_SEGMENT_INVERT   
    };
    const char* string(DetectorSegment d);
    const char* shortstring(DetectorSegment d);
    
    struct Size
    {
        Size();
        Size(int width, int height);
        int width;
        int height;
    };
    
    struct CamParams
    {
        CamParams();
        CamParams(const Size& size, int nFrames = 1);
        CamParams(int width, int height, int nFrames = 1);
        Size size;
        int nFrames;
    };
    
    enum DetectorMode
    {
        SEM_DETECTOR_MODE_ALL           = om__detector__SEM_DETECTOR_MODE_ALL,          
        SEM_DETECTOR_MODE_NORTHSOUTH    = om__detector__SEM_DETECTOR_MODE_NORTHSOUTH,   
        SEM_DETECTOR_MODE_EASTWEST      = om__detector__SEM_DETECTOR_MODE_EASTWEST,     
        SEM_DETECTOR_MODE_A             = om__detector__SEM_DETECTOR_MODE_A,            
        SEM_DETECTOR_MODE_B             = om__detector__SEM_DETECTOR_MODE_B,            
        SEM_DETECTOR_MODE_C             = om__detector__SEM_DETECTOR_MODE_C,            
        SEM_DETECTOR_MODE_D             = om__detector__SEM_DETECTOR_MODE_D             
    };
    const char* string(DetectorMode m);
    
    struct ScanParams
    {
        ScanParams();
        ScanParams(const Size& size, int nFrames = 1, DetectorMode detector = SEM_DETECTOR_MODE_ALL, bool hdr = false, double scale = 1, const Position& center = CenterPosition);
        ScanParams(int width, int height, int nFrames = 1, DetectorMode detector = SEM_DETECTOR_MODE_ALL, bool hdr = false, double scale = 1, const Position& center = CenterPosition);
        Size size;
        int nFrames;
        DetectorMode detector;
        bool hdr;
        Position center;
        double scale;
    };
    
    enum ScanMode
    {
        SEM_SCAN_MODE_BLANK     = om__scanMode__SEM_SCAN_MODE_BLANK,    
        SEM_SCAN_MODE_IMAGING   = om__scanMode__SEM_SCAN_MODE_IMAGING,  
        SEM_SCAN_MODE_SPOT      = om__scanMode__SEM_SCAN_MODE_SPOT      
    };
    const char* string(ScanMode m);
    
    struct SEMViewingMode
    {
        SEMViewingMode(ScanMode scanMode, const ScanParams& scanParams);
        
        ScanMode scanMode;
        ScanParams scanParams;
    };
    
    enum Encoding
    {
        Unsigned8,  
        Unsigned16, 
        RGB         
    };
    
    struct Image
    {
        Image();
        Image(int width, int height, Encoding encoding, int stride_x, int stride_y, void* data);
        ~Image();
        
        int width;
        int height;
        Encoding encoding;
        int stride_x;
        int stride_y;
        void* data;
        
        typedef boost::shared_ptr<Image> ptr;
        
    private:
        Image(const Image&);
        Image& operator=(Image&);
    };
    
    enum AcquisitionType
    {
        ACQUISITION_NAVCAM  = om__acquisitionType__OM_ACQ_TYPE_NAVCAM,  
        ACQUISITION_SEM     = om__acquisitionType__OM_ACQ_TYPE_SEM      
    };

    struct AcquisitionState
    {
        AcquisitionState();
        AcquisitionState(om__acquisitionState* acqState);
        
        AcquisitionType         acquisitionType;
        std::string             softwareVersion;
        std::string             instrumentID;
        int                     dataBarHeight;      
        double                  pixelWidth;         
        double                  pixelHeight;        
        time_t                  time;
        Position                sourceTilt;
        Position                stigmator;
        int                     integrations;
        Position                position;           
        double                  rotation;           
        double                  dwellTime;          
        double                  workingDistance;    
        double                  sourceTime;         
        double                  highVoltage;        
        double                  emissionCurrent;    
        double                  filamentPower;      
        DetectorSegment         segment[4];         
        double                  appliedContrast;
        double                  appliedBrightness;
        double                  appliedGamma;
    };
    
    struct Acquisition
    {
        Acquisition();
        Acquisition(Image::ptr image, const AcquisitionState& metadata);
        
        Image::ptr image;
        AcquisitionState metadata;
    };
}

#endif