QRCode.h

/*
 * QR Code generator library (C++)
 *
 * Copyright (c) Project Nayuki. (MIT License)
 * https://www.nayuki.io/page/qr-code-generator-library
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy of
 * this software and associated documentation files (the "Software"), to deal in
 * the Software without restriction, including without limitation the rights to
 * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
 * the Software, and to permit persons to whom the Software is furnished to do so,
 * subject to the following conditions:
 * - The above copyright notice and this permission notice shall be included in
 *   all copies or substantial portions of the Software.
 * - The Software is provided "as is", without warranty of any kind, express or
 *   implied, including but not limited to the warranties of merchantability,
 *   fitness for a particular purpose and noninfringement. In no event shall the
 *   authors or copyright holders be liable for any claim, damages or other
 *   liability, whether in an action of contract, tort or otherwise, arising from,
 *   out of or in connection with the Software or the use or other dealings in the
 *   Software.
 */
 
#pragma once
#include "DLLInfo.h"
#include <NDEVR/Buffer.h>
#include <NDEVR/String.h>
#include <NDEVR/RGBColor.h>
namespace NDEVR {
 
    class QrSegment;

    typedef AlocatingAlignedBuffer<QrSegment, sizeof(void*) == 4 ? 16 : 32> QrSegmentBuffer;

    class QrSegment final
    {
 
        /*---- Public helper enumeration ----*/
 
    public:
        class Mode final
        {
 
            /*-- Constants --*/
 
        public:
            static const Mode NUMERIC;      
            static const Mode ALPHANUMERIC; 
            static const Mode BYTE;         
            static const Mode KANJI;        
            static const Mode ECI;          
 
 
            /*-- Fields --*/
 
        private:
            int modeBits;           
 
            int numBitsCharCount[3]; 
 
 
            /*-- Constructor --*/

            Mode(int mode, int cc0, int cc1, int cc2);
        public:
            int getModeBits() const;

            int numCharCountBits(int ver) const;
 
        };
    public:
        static QrSegment makeBytes(const uint01* data, uint04 size);
 

        static QrSegment makeNumeric(const char* digits);
 

        static QrSegment makeAlphanumeric(const char* text);
 

        static QrSegmentBuffer makeSegments(const char* text);
 

        static QrSegment makeEci(long assignVal);
 
 
        /*---- Public static helper functions ----*/

        static bool isNumeric(const char* text);
 

        static bool isAlphanumeric(const char* text);
 
 
 
        /*---- Instance fields ----*/
 
    private:
        const Mode* mode;   
 
        int numChars;       
 
        Buffer<bool> data;  
 
 
    public:
        /*---- Constructors (low level) ----*/

        QrSegment(const Mode& md, int numCh, const Buffer<bool>& dt);
 

    public: QrSegment(const Mode& md, int numCh, Buffer<bool>&& dt);
 
 
        /*---- Methods ----*/

    public: const Mode& getMode() const;
 

    public: int getNumChars() const;
 

    public: const Buffer<bool>& getData() const;
 

    public: static int getTotalBits(const QrSegmentBuffer& segs, int version);
 
 
        /*---- Private constant ----*/
 
    private:
        static const char* ALPHANUMERIC_CHARSET; 
 
    };
 
 

    class NDEVR_DESIGN_API QrCode final {
 
        /*---- Public helper enumeration ----*/

    public: enum class Ecc
    {
        LOW = 0,   
        MEDIUM,    
        QUARTILE,  
        HIGH,      
    };
 

    private: static int getFormatBits(Ecc ecl);
 
 
 
        /*---- Static factory functions (high level) ----*/

    public: static QrCode encodeText(const char* text, Ecc ecl);

        static QrCode encodeLink(const char* text, Ecc ecl);

    public: static QrCode encodeBinary(const uint01* data, uint04 size, Ecc ecl);
 
 
        /*---- Static factory functions (mid level) ----*/

    public: static QrCode encodeSegments(const QrSegmentBuffer& segs, Ecc ecl,
        int minVersion = 1, int maxVersion = 40, int mask = -1, bool boostEcl = true);  // All optional parameters

        String toSVG(uint04 border, RGBColor color, RGBColor background = Constant<RGBColor>::Invalid) const;
 
 
        /*---- Instance fields ----*/
 
    private:
        int version;                    
 
        uint04 m_size;                  
 
        Ecc errorCorrectionLevel;       
 
        int mask;                       
 
        Buffer<Buffer<bool>> modules;   
 
        Buffer<Buffer<bool>> isFunction; 
 
 
 
        /*---- Constructor (low level) ----*/

    public: QrCode(int ver, Ecc ecl, const Buffer<std::uint8_t>& dataCodewords, int msk);
 
 
 
        /*---- Public instance methods ----*/

    public: int getVersion() const;
 

    public: int getSize() const;
 

    public: Ecc getErrorCorrectionLevel() const;
 

    public: int getMask() const;
 

    public: bool getModule(int x, int y) const;
 
 
 
        /*---- Private helper methods for constructor: Drawing function modules ----*/

    private: void drawFunctionPatterns();
 

    private: void drawFormatBits(int msk);
 

        void drawVersion();
 

        void drawFinderPattern(int x, int y);
 

        void drawAlignmentPattern(int x, int y);
 

        void setFunctionModule(uint04 x, uint04 y, bool isDark);
 

        bool module(uint04 x, uint04 y) const;
 
 
        /*---- Private helper methods for constructor: Codewords and masking ----*/

        Buffer<std::uint8_t> addEccAndInterleave(const Buffer<std::uint8_t>& data) const;
 

        void drawCodewords(const Buffer<std::uint8_t>& data);
 

        void applyMask(int msk);
 

        long getPenaltyScore() const;
 
 
 
        /*---- Private helper functions ----*/

        Buffer<int> getAlignmentPatternPositions() const;
 

        static int getNumRawDataModules(int ver);
 

        static int getNumDataCodewords(int ver, Ecc ecl);

        static Buffer<std::uint8_t> reedSolomonComputeDivisor(int degree);

        static Buffer<std::uint8_t> reedSolomonComputeRemainder(const Buffer<std::uint8_t>& data, const Buffer<std::uint8_t>& divisor);

        static std::uint8_t reedSolomonMultiply(std::uint8_t x, std::uint8_t y);

        uint04 finderPenaltyCountPatterns(const std::array<int, 7>& runHistory) const;

        uint04 finderPenaltyTerminateAndCount(bool currentRunColor, int currentRunLength, std::array<int, 7>& runHistory) const;

        void finderPenaltyAddHistory(int currentRunLength, std::array<int, 7>& runHistory) const;

        static bool getBit(long x, int i);
 
    public:
        static constexpr int MIN_VERSION = 1;  
        static constexpr int MAX_VERSION = 40;  
 
 
    private:
        static const int PENALTY_N1; 
        static const int PENALTY_N2; 
        static const int PENALTY_N3; 
        static const int PENALTY_N4; 
        static const sint01 ECC_CODEWORDS_PER_BLOCK[4][41]; 
        static const sint01 NUM_ERROR_CORRECTION_BLOCKS[4][41]; 
 
    };
 
 
 
    /*---- Public exception class ----*/

    class data_too_long : public std::length_error
    {
    public:
        explicit data_too_long(const std::string& msg);
 
    };
 
 

    class QRBitBuffer final : public Buffer<bool>
    {
    public:
        QRBitBuffer();
 
 
 
        /*---- Method ----*/
 
    public:
        void appendBits(uint04 val, uint04 len);
 
    };
 
}