vex_vision.h

Go to the documentation of this file.

/*----------------------------------------------------------------------------*/
/*                                                                            */
/*    Copyright (c) Innovation First 2017-2019, All rights reserved.          */
/*                                                                            */
/*    Module:     vex_vision.h                                                */
/*    Author:     James Pearman                                               */
/*    Created:    30 June 2017                                                */
/*                                                                            */
/*    Revisions:                                                              */
/*                V1.00     TBD - Initial release                             */
/*                                                                            */
/*----------------------------------------------------------------------------*/
 
#ifndef   VEX_VISION_CLASS_H
#define   VEX_VISION_CLASS_H
 
/*-----------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
/*-----------------------------------------------------------------------------*/
/*-----------------------------------------------------------------------------*/
namespace vex {
  class vision : public device {
    private:
      #define VISION_MAX_OBJECTS                4
      #define VISION_DEFAULT_SNAPSHOT_OBJECTS   4
            
      // Variadic template for signature setting
      void _setsig() {};
      template <typename signature, typename... Args>
      void _setsig( signature &sig, Args &... args ) {
        setSignature( sig );
        _setsig( args... );
      }
 
    public:
 
      vision( int32_t index );  
      ~vision();
 
      template <typename... Args>
      vision( int32_t index, uint8_t bright, Args &... sigs  ) : vision( index ) {
        setBrightness( bright );
        _setsig( sigs... );
      }
      vision( int32_t index, uint8_t bright, Args &... sigs  ) : vision( index ) {…}
           
      bool            installed();
      int32_t         value();
 
      enum class detectionMode {
        objectDetect = kVisionModeNormal,
        mixedDetect  = kVisionModeMixed,
        lineDetect   = kVisionModeLineDetect,
        test         = kVisionTypeTest
      };
      
      enum class whiteBalanceMode {
        automatic    = kVisionWBNormal,
        start        = kVisionWBStart,
        manual       = kVisionWBManual
      };
 
      enum class ledMode {
        automatic    = kVisionLedModeAuto,
        manual       = kVisionLedModeManual
      };
 
      enum class wifiMode {
        off          = kVisionWifiModeOff,
        on           = kVisionWifiModeOn
      };
 
      class object {          
          int16_t _id;
          int16_t _originX;
          int16_t _originY;
          int16_t _centerX;
          int16_t _centerY;
          int16_t _width;
          int16_t _height;
          bool    _exists;
          float   _angle;
      
        public:
 
          object();
          ~object();
        
          void      set( IQ_VisionDetectionObj obj );
        
          void      flipAngle();
 
          void      clear();
        
          object& operator=( const object &obj );
          object& operator=( int32_t signatureId );
 
          const int16_t  &id;
          const int16_t  &originX;
          const int16_t  &originY;
          const int16_t  &centerX;
          const int16_t  &centerY;
          const int16_t  &width;
          const int16_t  &height;
          const float    &angle;
          const bool &exists;
      };
      class object {…};
 
      class signature {
        friend class vex::vision;
 
        private:
          #define   MAX_MAME    32
 
          int16_t   _id;
          int16_t   _uMin;
          int16_t   _uMax;
          int16_t   _uMean;
          int16_t   _vMin;
          int16_t   _vMax;
          int16_t   _vMean;
          uint16_t  _type;
          float     _range;
          //uint32_t  _rgb;
 
          void      clear();
                  
          static void setTypeColorCode() {};
          template <typename signature, typename... Args>
          static void setTypeColorCode( signature &sig, Args &... args ) {
            sig._type = 1;
            setTypeColorCode( args... );
          }
 
        public:
          signature();
          ~signature();
          
          signature( int32_t id, int32_t uMin, int32_t uMax, int32_t uMean, int32_t vMin, int32_t vMax, int32_t vMean, float range, int32_t type );
 
 
          // read only references to internal variables
          //const int32_t   &id;
          //const int32_t   &uMin;
          //const int32_t   &uMax;
          //const int32_t   &uMean;
          //const int32_t   &vMin;
          //const int32_t   &vMax;
          //const int32_t   &vMean;
          //const float     &range;
          //const uint32_t  &rgb;
          //const uint32_t  &type;
      };
      class signature {…};
      
    class code {
        private:
          uint32_t _code;
          bool     _flipped = false;
        
        public:
          code(int32_t sig1, int32_t sig2);
          code(int32_t sig1, int32_t sig2, int32_t sig3);
          code(int32_t sig1, int32_t sig2, int32_t sig3, int32_t sig4);
          code(int32_t sig1, int32_t sig2, int32_t sig3, int32_t sig4, int32_t sig5 );
  
          code( signature &s1, signature &s2 );
          code( signature &s1, signature &s2, signature &s3 );
          code( signature &s1, signature &s2, signature &s3, signature &s4 );
          code( signature &s1, signature &s2, signature &s3, signature &s4, signature &s5 ); 
      
          uint32_t getCode()   { return _code;    }
          bool     isFlipped() { return _flipped; } 
      };      
    class code {…};
      
      int32_t         takeSnapshot( uint32_t id );
 
      int32_t         takeSnapshot( code &cc );
 
      int32_t         takeSnapshot( signature &sig );
 
      int32_t         takeSnapshot( uint32_t id, uint32_t count );
 
      int32_t         takeSnapshot( code &cc, uint32_t count );
 
      int32_t         takeSnapshot( signature &sig, uint32_t count );
 
      int32_t         objectCount;
 
      object          largestObject;
 
      safearray< object, VISION_MAX_OBJECTS > objects;  
 
      // not part of current spec
      bool            setSignature( IQ_VisionDetectionSettings *settings );
      bool            getSignature( IQ_VisionDetectionSettings *settings );
      bool            setSignature( signature &sig );
      bool            getSignature( uint32_t id, signature &sig );
      bool            setMode( detectionMode mode );
      detectionMode   getMode( void );
      bool            setBrightness( uint8_t value );
      uint8_t         getBrightness( void );
      bool            setWhiteBalanceMode( whiteBalanceMode mode );
      whiteBalanceMode getWhiteBalanceMode( void );
      bool            setWhiteBalanceValues( uint8_t red, uint8_t green, uint8_t blue );
      bool            getWhiteBalanceValues( uint8_t *red, uint8_t *green, uint8_t *blue );
 
      bool            setLedMode( ledMode mode );
 
      ledMode         getLedMode( void );
 
      bool            setLedBrightness( uint8_t percent );
 
      uint8_t         getLedBrightness( void );
 
      bool            setLedColor( uint8_t red, uint8_t green, uint8_t blue );
 
      bool            getLedColor( uint8_t *red, uint8_t *green, uint8_t *blue );
 
      
      bool            setWifiMode( wifiMode mode );
      wifiMode        getWifiMode( void );
                  
    private:
      // storage for raw data from camera
      IQ_VisionDetectionObj _objects[ VISION_MAX_OBJECTS ];
      // set all objects to 0
      void               _clearObjects( void );
  };
  class vision : public device {…};
};
 
#endif // VEX_VISION_CLASS_H