Exemple #1
0
        public string Calculate(string data)
        {
            char currCode = Code128Encoder.ResolveStartCode(data[0]);

            // start character
            int sum = Code128Encoder.SymbolValue(data[0].ToString(), currCode);

            for (int i = 1, pos = 1; i < data.Length; ++i, ++pos)
            {
                string curr  = data[i].ToString();
                int    value = 0;

                if (currCode == Code128Encoder.CodeC && char.IsNumber(data[i]))
                {
                    value = Code128Encoder.SymbolValue(curr + data[++i].ToString(), currCode);
                }
                else
                {
                    value = Code128Encoder.SymbolValue(curr, currCode);
                }

                sum += pos * value;

                // detect change in current code
                switch (data[i])
                {
                case Code128Encoder.CodeA:
                case Code128Encoder.CodeB:
                case Code128Encoder.CodeC:
                    currCode = data[i];
                    break;
                }
            }

            return(Code128Encoder.SymbolString(sum % 103, currCode));
        }
Exemple #2
0
        // code the 128 barcode data to use as little space as possible
        public string Code(string data)
        {
            if (data.Length == 0)
            {
                return("");
            }

            // first determine what codes can be used to code every character
            _allCodes = new int[data.Length];
            for (int i = 0; i < data.Length; ++i)
            {
                string curr = data[i].ToString();
                if (Code128Encoder.CanCode(curr, Code128Encoder.CodeA))
                {
                    _allCodes[i] |= codeA;
                }
                if (Code128Encoder.CanCode(curr, Code128Encoder.CodeB))
                {
                    _allCodes[i] |= codeB;
                }

                // code C will code more than one character (FNC1??)
                //if (Code128Encoder.CanCode(curr, Code128Encoder.CodeC)) _allCodes[i] |= codeC; //FNC1??
                if (i < data.Length - 1 &&
                    Code128Encoder.CanCode(curr + data[i + 1].ToString(), Code128Encoder.CodeC))
                {
                    _allCodes[i]     |= codeCFirst;
                    _allCodes[i + 1] |= codeCSecond;
                }
            }

            // backtrack to find the best configuration
            _bestCodeValue = int.MaxValue;
            _bestCode      = new int[_allCodes.Length];
            _currCode      = new int[_allCodes.Length];
            SolveCode(0);
            for (int i = 0; i < _bestCode.Length; ++i)
            {
                if (_bestCode[i] > codeC)
                {
                    _bestCode[i] = codeC;               // change codeCFirst and codeCSecond to codeC
                }
            }

            DebugCode(data);

            // put code start and code changes in result string
            StringBuilder sb   = new StringBuilder();
            int           code = _bestCode[0];

            switch (code)
            {
            case codeA: sb.Append(Code128Encoder.StartA); break;

            case codeB: sb.Append(Code128Encoder.StartB); break;

            case codeC: sb.Append(Code128Encoder.StartC); break;
            }
            for (int i = 0; i < _bestCode.Length; ++i)
            {
                if (_bestCode[i] != code)
                {
                    code = _bestCode[i];
                    switch (code)
                    {
                    case codeA: sb.Append(Code128Encoder.CodeA); break;

                    case codeB: sb.Append(Code128Encoder.CodeB); break;

                    case codeC: sb.Append(Code128Encoder.CodeC); break;
                    }
                }
                sb.Append(data[i]);
            }

            return(sb.ToString());
        }