.. _program_listing_file__tmp_ws_src_aruco_ros_aruco_include_aruco_dictionary.h:

Program Listing for File dictionary.h
=====================================

|exhale_lsh| :ref:`Return to documentation for file <file__tmp_ws_src_aruco_ros_aruco_include_aruco_dictionary.h>` (``/tmp/ws/src/aruco_ros/aruco/include/aruco/dictionary.h``)

.. |exhale_lsh| unicode:: U+021B0 .. UPWARDS ARROW WITH TIP LEFTWARDS

.. code-block:: cpp

   
   #ifndef ARUCO_DICTIONARY_
   #define ARUCO_DICTIONARY_
   
   #include "aruco_export.h"
   
   #include <opencv2/core/core.hpp>
   
   #include <iostream>
   #include <map>
   #include <stdint.h>
   #include <string>
   #include <vector>
   
   namespace aruco
   {
   class MarkerMap;
   class ARUCO_EXPORT Dictionary
   {
   public:
     // loads from a set of predefined ones
     enum DICT_TYPES : uint64_t
     {
       ALL_DICTS = 0,
       ARUCO_MIP_36h12 = 1,  //*** recommended
       ARUCO = 2,            // original aruco dictionary. By default
       ARUCO_MIP_25h7 = 3,
       ARUCO_MIP_16h3 = 4,
       ARTAG = 5,  //
       ARTOOLKITPLUS = 6,
       ARTOOLKITPLUSBCH = 7,  //
       TAG16h5 = 8,
       TAG25h7 = 9,
       TAG25h9 = 10,
       TAG36h11 = 11,
       TAG36h10 = 12,   // april tags
       CHILITAGS = 13,  // chili tags dictionary . NOT RECOMMENDED. It has distance 0.
                        // Markers 806 and 682 should not be used!!!
       CUSTOM = 14,  // for used defined dictionaries  (using loadFromfile).
     };
     // indicates if a code is in the dictionary
     bool is(uint64_t code) const
     {
       return _code_id.find(code) != _code_id.end();
     }
   
     DICT_TYPES getType() const
     {
       return _type;
     }
   
     // reutnr the numerber of ids
     uint64_t size() const
     {
       return _code_id.size();
     }
     // returns the total number of bits of the binary code
     uint32_t nbits() const
     {
       return _nbits;
     }
     // returns the dictionary distance
     uint32_t tau() const
     {
       return _tau;
     }
     // returns the name
     std::string getName() const
     {
       return _name;
     }
     // return the set of ids
     const std::map<uint64_t, uint16_t>& getMapCode() const
     {
       return _code_id;
     }
   
     // returns the id of a given code.
     int operator[](uint64_t code)
     {
       return _code_id[code];
     }  // returns the id of a given code.
     int at(uint64_t code)
     {
       return _code_id[code];
     }
   
     // returns the image of the marker indicated by its id. It the id is not, returns empty
     // matrix
     //@param id of the marker image to return
     //@param bit_size of the image will be  AxA, A=(nbits()+2)*bit_size
     //@param enclosed_corners if true, extra rectagles are added touching the marker
     //corners. it can be used to allow subpixel refinement
     cv::Mat getMarkerImage_id(int id, int bit_size, bool addWaterMark = true,
                               bool enclosed_corners = false,
                               bool printExternalWhiteBorder = false, bool centralCircle = false);
   
     //   cv::Mat getMarkerMatrix_id(int id);
   
     // used for boards
     MarkerMap createMarkerMap(cv::Size gridSize, int MarkerSize, int MarkerDistance,
                               const std::vector<int>& Ids, bool chess_board = false);
   
     static Dictionary loadPredefined(DICT_TYPES type);
     static Dictionary loadPredefined(std::string type);
   
     static Dictionary loadFromFile(std::string path);
   
     static Dictionary load(std::string info);
   
     //    //io functions
     //    void saveToFile(std::string file);
     //    void readFromFile(std::string file);
     //    void saveToStream(std::ostream & str);
     //    void readFromStream(std::istream &str);
   
     // returns the dictionary distance
     static uint64_t computeDictionaryDistance(const Dictionary& d);
   
     // given a string,returns the type
     static DICT_TYPES getTypeFromString(std::string str);
     static std::string getTypeString(DICT_TYPES t);
     static bool isPredefinedDictinaryString(std::string str);
     static std::vector<std::string> getDicTypes();
   
   private:
     // obfuscate start
   
     void insert(uint64_t code, int id)
     {
       _code_id.insert(std::make_pair(code, id));
     }
     static void fromVector(const std::vector<uint64_t>& codes,
                            std::map<uint64_t, uint16_t>& code_id_map);
   
     std::map<uint64_t, uint16_t> _code_id;  // marker have and code (internal binary code),
                                             // which correspond to an id.
   
     uint32_t _nbits;  // total number of bits . So, there are sqrt(nbits) in each axis
     uint32_t _tau;    // minimum distance between elements
   
     DICT_TYPES _type;
     std::string _name;
     // obfuscate end
   };
   }  // namespace aruco
   
   #endif