Source Code for Module mcbase.libs.barcodegenerator.code128

  1  # -*- coding: utf-8 -*- 
  2   
  3  ############################################################################ 
  4  # code128.py 
  5  # 
  6  # Code128 barkod üretme araçları 
  7  # 
  8  # (C) 2008 Likya Yazılım ve Bilişim Hizmetleri Ltd. 
  9  ############################################################################ 
 10   
 11  import re 
 12   
 13  from barcodegenerator import BarcodeGenerator 
 14   
 15 -class Code128(BarcodeGenerator): 
 16       
 17 -    def __init__(self, code): 
 18          ''' 
 19          Code 128 için gerekli ön tanımlamaları yapar. 
 20          ''' 
 21          BarcodeGenerator.__init__(self) 
 22           
 23          self._encodeMap = ['11011001100', '11001101100', '11001100110', '10010011000', '10010001100', '10001001100',  
 24                             '10011001000', '10011000100', '10001100100', '11001001000', '11001000100', '11000100100',  
 25                             '10110011100', '10011011100', '10011001110', '10111001100', '10011101100', '10011100110',  
 26                             '11001110010', '11001011100', '11001001110', '11011100100', '11001110100', '11101101110',  
 27                             '11101001100', '11100101100', '11100100110', '11101100100', '11100110100', '11100110010',  
 28                             '11011011000', '11011000110', '11000110110', '10100011000', '10001011000', '10001000110',  
 29                             '10110001000', '10001101000', '10001100010', '11010001000', '11000101000', '11000100010',  
 30                             '10110111000', '10110001110', '10001101110', '10111011000', '10111000110', '10001110110',  
 31                             '11101110110', '11010001110', '11000101110', '11011101000', '11011100010', '11011101110',  
 32                             '11101011000', '11101000110', '11100010110', '11101101000', '11101100010', '11100011010',  
 33                             '11101111010', '11001000010', '11110001010', '10100110000', '10100001100', '10010110000',  
 34                             '10010000110', '10000101100', '10000100110', '10110010000', '10110000100', '10011010000',  
 35                             '10011000010', '10000110100', '10000110010', '11000010010', '11001010000', '11110111010',  
 36                             '11000010100', '10001111010', '10100111100', '10010111100', '10010011110', '10111100100',  
 37                             '10011110100', '10011110010', '11110100100', '11110010100', '11110010010', '11011011110',  
 38                             '11011110110', '11110110110', '10101111000', '10100011110', '10001011110', '10111101000',  
 39                             '10111100010', '11110101000', '11110100010', '10111011110', '10111101110', '11101011110',  
 40                             '11110101110', '11010000100', '11010010000', '11010011100', '11000111010',  
 41                            ] 
 42           
 43          # Set'lerin sonlarındaki özel karakterler 
 44          #  
 45          # Index  A        B        C        Code 
 46          # ======================================== 
 47          #   96   FNC3     FNC3     96       \xC4 
 48          #   97   FNC2     FNC2     97       \xC5 
 49          #   98   Shift    Shift    98       \xC6 
 50          #   99   Code C   Code C   99       \xC7 
 51          #  100   Code B   Code B   Code B   \xC8 
 52          #  101   FNC4     Code A   Code A   \xC9 
 53          #  102   FNC1     FNC1     FNC1     \xCA 
 54          #  103   Start A  Start A  Start A  \xCB 
 55          #  104   Start B  Start B  Start B  \xCC 
 56          #  105   Start C  Start C  Start C  \xCD 
 57          #  106   Stop     Stop     Stop     \xCE 
 58           
 59          endList = ['FNC3', 'FNC2', 'Shift', 'Code C', 'Code B', 'Code A', 'FNC1', 'Start A', 'Start B', 'Start C', 'Stop', ] 
 60          commonAB = list(' !"#$%&\'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_') 
 61           
 62          self._setA = commonAB + map(lambda x: chr(x), range(0, 32)) + endList 
 63          self._setB = commonAB + map(lambda x: chr(x), range(96, 128)) + endList 
 64          self._setC = map(lambda x: '%02d' % x, range(0, 100)) + endList[4:] 
 65           
 66          # Hatalı karakterler varsa, barkodu oluşturmuyoruz. 
 67          for c in code: 
 68              if c not in self._setA and c not in self._setB: 
 69                  raise Exception('Hatali barkod kodu') 
 70           
 71          self._code = code 
 72          self._bits = None 
 73       
 74 -    def computeChecksum(self, positions): 
 75          ''' 
 76          Checksum karakterini bulur. 
 77          ''' 
 78          sum = 0 
 79           
 80          for i, position in enumerate(positions): 
 81               
 82              # Başlama karakterinin ağırlığını de 1 sayıyoruz. 
 83              weight = i if i != 0 else 1 
 84               
 85              # Ağırlıklı toplama ekliyoruz. 
 86              sum += position * weight 
 87           
 88          checksum = sum % 103 
 89           
 90          return checksum 
 91       
 92 -    def makeBits(self): 
 93          ''' 
 94          Barkodun ikili kodlamasını yapar. 
 95          ''' 
 96          if self._bits is not None: 
 97              return self._bits 
 98           
 99          blocks = [] 
100          # Sayıları sıkıştırılmış yazmak için ikili olanları ayırıyoruz. Uzunluğu en az dört olmalı. 
101          charsAndNumbers = re.findall(r'(?:(?:\d\d){2,})|.', self._code, re.DOTALL) 
102           
103          # A, B ve C arasındaki geçişleri ayarlıyoruz. Önce en uygun set'leri ayarlıyoruz. 
104          for block in charsAndNumbers: 
105               
106              # Sadece ikili sayılardan oluşuyorsa, C set'i yapıyoruz. 
107              if re.match(r'^(\d\d)+$', block): 
108                  blocks.append(('Code C', block)) 
109               
110              # B set'i öncelikli 
111              elif block in self._setB: 
112                  blocks.append(('Code B', block)) 
113               
114              else: 
115                  blocks.append(('Code A', block)) 
116           
117          # Blokları karakterlere çeviriyoruz. B set'i ile başlıyoruz. 
118          positions = [104] # Start B 
119          lastSetCode = 'Code B' 
120          lastSet = self._setB 
121          sets = { 
122              'Code A': self._setA,  
123              'Code B': self._setB,  
124              'Code C': self._setC,  
125          } 
126           
127          for setCode, value in blocks: 
128               
129              if setCode == lastSetCode: 
130                  positions.append(lastSet.index(value)) 
131               
132              else: 
133                  positions.append(lastSet.index(setCode)) 
134                   
135                  lastSetCode = setCode 
136                  lastSet = sets[setCode] 
137                   
138                  # Sayı ise ikili sayılar halinde atıyoruz. 
139                  if setCode == 'Code C': 
140                      for char in re.findall(r'(\d\d)', value): 
141                          positions.append(lastSet.index(char)) 
142                   
143                  else: 
144                      positions.append(lastSet.index(value)) 
145           
146          # Checksum'ı ekliyoruz 
147          checksum = self.computeChecksum(positions) 
148          positions.append(checksum) 
149           
150          # Stop pozisyonunu da ekliyoruz. 
151          positions.append(106) 
152           
153          # Karakterleri bit'e çeviriyoruz. 
154          bits = [] 
155           
156          for position in positions: 
157              bits.append(self._encodeMap[position]) 
158           
159          # Termination bitlerini ekliyoruz 
160          bits.append('11') 
161           
162          self._bits = "".join(bits) 
163           
164          return self._bits 
165       
166 -    def digitLocations(self): 
167          ''' 
168          Yazılacak rakamların bit olarak yerlerini gösterir. 
169          ''' 
170          start = (len(self._bits) - (7 * len(self._code))) / 2 
171           
172          locations = range(start, start + (7 * len(self._code)), 7) 
173           
174          return locations 
175       
176 -    def leftMargin(self): 
177          return 1 
178       
179 -    def rightMargin(self): 
180          return 1 
181