コード例 #1
0
 def ttl_read(self):
     sp = self.create_WASYNC_PAR()
     sp.s_Type = L_ASYNC_TTL_INP
     self.io_async(sp)
     ret = BitArray(uint=sp.Data[0], length=16)
     ret.reverse()
     return ret
コード例 #2
0
ファイル: RTCM_decode.py プロジェクト: AlessioMorale/pyUblox
    def get_word(self, allow_recalc=False):
        word = BitArray(0)
        for i in range(5):
            b = self.buf.popleft()

            if b >> 6 != 1:
                pass
                #print("6-of-8 decode wrong")
                #raise RTCMBitError()

            b = BitArray(uint=(b&0x3f), length=6)
            b.reverse()
            word.append(b)

        if self.p30:
            word ^= BitArray(uint=0x3fffffc0, length=30)

        print(hex(word.uint))

        if allow_recalc and self.calculate_parity(word) != word.uint & 0x3f:
            self.p29 = 1

        if self.calculate_parity(word) != word.uint & 0x3f:
            raise RTCMParityError()

        self.p30 = word.uint & 1
        self.p29 = (word.uint & 2) >> 1

        return word
コード例 #3
0
    def get_word(self, allow_recalc=False):
        word = BitArray(0)
        for i in range(5):
            b = self.buf.popleft()

            if b >> 6 != 1:
                pass
                #print("6-of-8 decode wrong")
                #raise RTCMBitError()

            b = BitArray(uint=(b & 0x3f), length=6)
            b.reverse()
            word.append(b)

        if self.p30:
            word ^= BitArray(uint=0x3fffffc0, length=30)

        print(hex(word.uint))

        if allow_recalc and self.calculate_parity(word) != word.uint & 0x3f:
            self.p29 = 1

        if self.calculate_parity(word) != word.uint & 0x3f:
            raise RTCMParityError()

        self.p30 = word.uint & 1
        self.p29 = (word.uint & 2) >> 1

        return word
コード例 #4
0
def convert_value(frame_data, item):
    convert_value = ''
    if XMLParser.Abytepos in item.keys():
        bytedata = BitArray()
        bytepos = item.get(XMLParser.Abytepos)
        if ',' in bytepos or '-' in bytepos:
            for pos_str in bytepos.split(','):
                pos_str = pos_str.replace(' ', '')
                if '-' not in pos_str:
                    bytedata.append(frame_data[int(pos_str):int(pos_str) + 1])

                elif '-' in pos_str:
                    min_pos_str, max_pos_str = pos_str.split('-')
                    for pos in range(int(min_pos_str), int(max_pos_str) + 1):
                        bytedata.append(frame_data[pos:pos + 1])
        else:
            bytedata.append(frame_data[int(bytepos):int(bytepos) + 1])

        convert_value = convert(item, bytedata)
    elif XMLParser.Abitpos in item.keys():
        byte_pos, bit_pos = item.get(XMLParser.Abitpos).split(',')
        bytedata = BitArray('uint:8={}'.format(frame_data[int(byte_pos)]))
        bytedata.reverse()
        bitdata = bytedata[int(bit_pos):int(bit_pos) + 1]
        convert_value = convert(item, bitdata)
    return convert_value
コード例 #5
0
def xvcShift(TMS, TDI):

    numBits = TMS.len

    print("TMS: ", TMS)
    print("TDI: ", TDI)

    ## Pad to nearest byte alignment
    TMS += BitArray((8 - numBits) % 8)
    TDI += BitArray((8 - numBits) % 8)

    ## Make "little-endian" essentially where bit 0 of first byte is
    ## the first bit out.
    TMS.reverse()
    TMS.byteswap()
    TDI.reverse()
    TDI.byteswap()

    msg = numBits.to_bytes(4, byteorder='little') + TMS.bytes + TDI.bytes
    resp = xvcdSend('shift:', msg, TMS.len // 8)
    TDO = BitArray(resp)
    TDO.byteswap()
    TDO.reverse()
    TDO = TDO[0:numBits]

    #print("< 0x{} == ".format(resp.hex()), TDO)
    print("< 0x{}".format(resp.hex()))
    print("TDO: ", TDO)
    print()

    return TDO
コード例 #6
0
 def encode(self, value):
     '''
     :param value: value to encode
     '''
     kassert.is_of_types(value, Bits)
     result = BitArray(value)
     result.reverse()
     return result
コード例 #7
0
ファイル: encoder.py プロジェクト: labba/kitty
 def encode(self, value):
     '''
     :param value: value to encode
     '''
     kassert.is_of_types(value, Bits)
     result = BitArray(value)
     result.reverse()
     return result
コード例 #8
0
def encode(x):
    n = ceil(log2(x + 1) / 8) if x > 0 else 1
    z = ""
    for i in range(n):
        temp = x % 256
        temp = BitArray(uint=temp, length=8)
        temp.reverse()
        z += temp.bin
        x //= 256
    return z, n
コード例 #9
0
def GenerateValidDominos(Start = 0, End = 4095):
    logging.debug("Checking Domino Values from {} to {}" . format(Start, End))

    bPass = 1
    Row1 = 0
    Row2 = 0
    ValidValues = []

    for x in range(Start,(End+1),1):
        bPass = True
        DPips = BitArray('0x000')
        DPips.uint = x
        Row1 = DPips[:6]
        Row2 = DPips[-6:]
        logging.debug("Index Value:{} Binary Value:{}" .format(x,DPips.bin))
        
        #Row 1 and 2 Pip Count
        R1_PC = len(list(Row1.findall([1])))
        R2_PC = len(list(Row2.findall([1])))

        #Total pips between rows must be 6.
        if (R1_PC + R2_PC) != 6: bPass = False

        logging.debug("Row 1 Value:{} Binary Value:{} Pip Count:{}" .format(Row1.uint, Row1.bin, R1_PC))
        logging.debug("Row 2 Value:{} Binary Value:{} Pip Count:{}" .format(Row2.uint, Row2.bin, R2_PC))
        logging.debug("Pip count validity: {}" . format(bPass))

        #Generate the reverse of the bit stream.
        DFlip = BitArray('0x000')
        DFlip.uint = x
        DFlip.reverse()
        ReversedValue = DFlip.uint

        logging.debug("Flipped Row Value:{} Binary Value:{}" .format(ReversedValue, DFlip.bin))        

        #The domino is a mirror iamge of itself and is invalid.
        if (ReversedValue == x):
            logging.debug("Fail: Mirror Domino")
            bPass = False
        
        #The rotated domino exists as a prior value.
        if (ReversedValue in ValidValues):
            logging.debug("Fail: Exists previously (rotated)")
            bPass = False

        #The specified domino passed all rules and is valid.
        if (bPass == True):
            ValidValues.append(x)
            logging.debug("Passed: Added Value {}({}) to list." . format(x, DPips.bin))


        logging.debug("---")

    logging.debug(ValidValues)
    return ValidValues
コード例 #10
0
def render_calibrator(image, block_height, block_width, pixel_width):
    '''This creates the checkboard-like pattern along the top and left of the first frame of video streams, and every
    frame of image streams.  This is what the reader uses to initially lock onto the frame.  Stream block_width and
    block_height are encoded into this pattern, using alternating color palettes so no two repeating values produce a
    continuous block of color, interfering with the frame lock process.'''

    initializer_palette_dict_a = ValuesToColor(palette_grabber('1'),
                                               'initializer_palette A')
    initializer_palette_dict_b = ValuesToColor(palette_grabber('11'),
                                               'initializer_palette B')

    draw = ImageDraw.Draw(image)
    draw.rectangle((0, 0, pixel_width - 1, pixel_width - 1), fill='rgb(0,0,0)')

    block_width_encoded = BitArray(uint=block_width, length=block_width - 1)
    block_width_encoded.reverse()
    readable_block_width = ConstBitStream(block_width_encoded)

    for i in range(block_width - 1):
        next_bit = readable_block_width.read('bits : 1')

        if i % 2 == 0:
            color_value = initializer_palette_dict_b.get_color(
                ConstBitStream(next_bit))

        else:
            color_value = initializer_palette_dict_a.get_color(
                ConstBitStream(next_bit))

        draw.rectangle((pixel_width * i + pixel_width, 0, pixel_width *
                        (i + 1) - 1 + pixel_width, pixel_width - 1),
                       fill=f'rgb{str(color_value)}')

    block_height_encoded = BitArray(uint=block_height, length=block_height - 1)
    block_height_encoded.reverse()
    readable_block_height = ConstBitStream(block_height_encoded)

    for i in range(block_height - 1):
        next_bit = readable_block_height.read('bits : 1')

        if i % 2 == 0:
            color_value = initializer_palette_dict_b.get_color(
                ConstBitStream(next_bit))

        else:
            color_value = initializer_palette_dict_a.get_color(
                ConstBitStream(next_bit))

        draw.rectangle(
            (0, pixel_width * i + pixel_width, pixel_width - 1, pixel_width *
             (i + 1) - 1 + pixel_width),
            fill=f'rgb{str(color_value)}')

    return image
コード例 #11
0
def verifyBlocksX(image,
                  pixelWidth,
                  blockWidthEstimate,
                  combinedColors,
                  initializerPaletteADict,
                  initializerPaletteBDict,
                  override=False):
    '''This is a function used within frameLockOn().  It verifies the correct values for the X axis.'''

    calibratorBitsX = BitArray()
    for xBlock in range(17):
        snappedValue = colorSnap(scanBlock(image, pixelWidth, xBlock, 0),
                                 combinedColors)

        if xBlock % 2 == 0:
            calibratorBitsX.append(
                initializerPaletteADict.getValue(snappedValue))

        else:
            calibratorBitsX.append(
                initializerPaletteBDict.getValue(snappedValue))

    calibratorBitsX.reverse()
    readCalibratorX = ConstBitStream(calibratorBitsX)

    if readCalibratorX.read('uint:16') != blockWidthEstimate:
        if override == True:
            logging.warning(
                'blockWidthOverride is not equal to what was read on calibrator.  Aborting...'
            )

        else:
            logging.warning(
                'blockWidth verification does not match initial read.  This could be the result of \n'
                'sufficiently distorted frames.  Aborting...')

        return False

    if readCalibratorX.read('bool') != False:
        logging.warning('0,0 block unexpected value.  Aborting...')
        return False

    if override == True:
        logging.info('blockWidthOverride successfully verified.')

    else:
        logging.debug('blockWidth successfully verified.')

    return True
コード例 #12
0
    def write_tms_tdi_read_tdo(self, tms, tdi):
        """Write out TMS bits while holding TDI constant and reading back in TDO"""
        if not (isinstance(tms, BitStream) or isinstance(tms, BitArray)):
            raise JtagError('Expect a BitStream or BitArray')
        length = len(tms)
        if not (0 < length < 8):
            raise JtagError('Invalid TMS length')
        tms.reverse()           # must reverse bits since only lsb write seems to be supported
        tms.prepend(8-len(tms)) # prepend 0's to be 8 bits long

        # left-most bit will be for TDI
        if isinstance(tdi, BitStream) or isinstance(tdi, BitArray):
            tms[0] = tdi[0]
        elif isinstance(tdi, bool):
            tms[0] = tdi            
        else:
            raise JtagError('Incorrect type for tdi - must be BitStream, BitArray or bool')
        
        # apply the last TDI bit
        #@@@if self._last is not None:
        #@@@    out[7] = self._last
        # print("TMS", tms, (self._last is not None) and 'w/ Last' or '')
        # reset last bit
        #@@@self._last = None

        ## Send the byte to the FTDI
        cmd = array('B', (Ftdi.RW_BITS_TMS_PVE_NVE, length-1, tms.uint))
        self._stack_cmd(cmd)
        self.sync()

        ## Read the response from FTDI
        data = self._ftdi.read_data_bytes(1, 4)
        if (len(data) != 1):
            raise JtagError('Not all data read! Expected {} bytes but only read {} bytes'.format(1,len(data)))

        tdo = BitArray(data)

        # FTDI handles returned LSB bit data by putting the first bit
        # in bit 7 and shifting to the right with every new bit. So
        # the first bit clocked will be in the lowest bit number, but
        # which bit number it will be in depends on how many bits
        # clocked. [It is kinda stupid, if you ask me. I think the bit
        # order should be the same as tehe bit written, but they
        # aren't.]
        tdo = tdo[:length]
        
        # return to bitstring bit ordering with left-most bit the lsb
        tdo.reverse()
        return tdo
コード例 #13
0
def checkBH(bh, lf):
    if bh[0] == 3 and bh[1] == 16384 and bh[3] == 22 and bh[10] == 48059:
        lf.write('New buffer started.\n')
        bitflags = BitArray(int=bh[7], length=16)
        bitflags.reverse()
        data_format = '>HHH'
        if bitflags[4] or bitflags[5]:
            data_format += 'H'
        if bitflags[5]:
            data_format += 'HH'
        if bitflags[6]:
            data_format += 'HH'
        return (data_format)
    else:
        lf.write('Buffer header error at: ')
        lf.write(str(data_file.tell()) + '\n')
        return ('0')
コード例 #14
0
ファイル: tat2.py プロジェクト: cstuartroe/misc
def rrs(ba):
    if isinstance(ba, str):
        ba = BitArray(bytes(ba, "utf-8"))

    out = []
    for _ in range(ba.length):
        try:
            out.append(ba.bytes.decode('utf-8'))
        except UnicodeDecodeError:
            pass
        ba.ror(1)
    ba.reverse()
    for _ in range(ba.length):
        try:
            out.append(ba.bytes.decode('utf-8'))
        except UnicodeDecodeError:
            pass
        ba.ror(1)
    ba.reverse()

    return out
コード例 #15
0
ファイル: main.py プロジェクト: joshuagenders/code-golf
def encode(data: bytes):
    root = build_tree(data)

    translation_list = build_character_translation(root, [])
    # print(f'translation list {translation_list}')
    translation = merge_dictionaries(translation_list)
    # print(f'translation {translation}')
    translated = list(itertools.chain(*[translation.get(byte) for byte in data]))
    # print(f'l translated {len(translated)}')
    additional_bytes = len(translated) % 8
    # print(f'additional bytes {additional_bytes}')
    x = BitArray(translated) + BitArray([0] * (8 - additional_bytes))
    x.reverse()
    x.byteswap()
    # print (f'x {x.bin}')
    encoded_bytes = x.tobytes()
    # print(f'encoded bytes: {encoded_bytes}')
    root.additional_bytes = additional_bytes
    
    serialised_tree = DefaultEncoder().encode(root)
    output = bytes(serialised_tree, 'ascii') + encoded_bytes
    return output
コード例 #16
0
def verify_blocks_x(image, pixel_width, block_width_estimate, combined_colors, initializer_palette_a_dict,
                    initializer_palette_b_dict, override = False):
    '''This is a function used within frame_lock_on().  It verifies the correct values for the X axis.'''

    calibrator_bits_x = BitArray()
    for x_block in range(17):
        snapped_value = color_snap(scan_block(image, pixel_width, x_block, 0), combined_colors)

        if x_block % 2 == 0:
            calibrator_bits_x.append(initializer_palette_a_dict.get_value(snapped_value))

        else:
            calibrator_bits_x.append(initializer_palette_b_dict.get_value(snapped_value))

    calibrator_bits_x.reverse()
    read_calibrator_x = ConstBitStream(calibrator_bits_x)

    if read_calibrator_x.read('uint:16') != block_width_estimate:
        if override == True:
            logging.warning('block_width_override is not equal to what was read on calibrator.  Aborting...')

        else:
            logging.warning('block_width verification does not match initial read.  This could be the result of \n'
                            'sufficiently distorted frames.  Aborting...')

        return False

    if read_calibrator_x.read('bool') != False:
        logging.warning('0,0 block unexpected value.  Aborting...')
        return False

    if override == True:
        logging.info('block_width_override successfully verified.')

    else:
        logging.debug('block_width successfully verified.')

    return True
コード例 #17
0
def main():
    file = open(sys.argv[1], "rb")
    msg = ConstBitStream(file)

    s_in = BitArray()
    keys = {Bits(''): 0}
    s_out = BitArray()
    count = 1
    n_bits = 0
    while True:
        try:
            s_in.append(msg.read(1))
        except ReadError:
            break

        #Se a palavra nao tiver no dicionario
        if Bits(s_in) not in keys:
            # x = yb
            y = s_in[:-1]
            b = s_in[-1:]

            pos = keys[Bits(y)]

            #log base 2 |keys|
            n_bits = ceil(log2(len(keys)))

            if n_bits != 0:
                prefix = Bits(uint=int(pos), length=n_bits)
            else:
                prefix = Bits('')

            s_out.append(Bits('0b' + str(prefix.bin) + str(b.bin)))

            keys[Bits(s_in)] = count
            count += 1
            s_in.clear()

    #Add padding: 00000 10101
    #Numero de zeros é o tamanho dos bits extra para depois no descompressor saber
    if s_in[:1].bin == Bits(1):
        z = Bits('0b' + '0' * len(s_in))
    else:
        z = Bits('0b' + '1' * len(s_in))

    s_in.reverse()
    s_out.reverse()

    s_out.append(s_in)
    s_out.append(z)

    s_out.reverse()

    with open(sys.argv[2], 'wb') as f_out:
        s_out.tofile(f_out)

    file.close()
コード例 #18
0
ファイル: motifs.py プロジェクト: louzounlab/PYGON
 def _get_group_number(self, nbunch):
     func = permutations if self._gnx.is_directed() else combinations
     # Reversing is a technical issue. We saved our node variations files
     bit_form = BitArray(self._gnx.has_edge(n1, n2) for n1, n2 in func(nbunch, 2))
     bit_form.reverse()
     return bit_form.uint
コード例 #19
0
def pixelCreep(pixelObject, initializerPaletteA, initializerPaletteB,
               combinedColors, initializerPaletteADict,
               initializerPaletteBDict, imageWidth, imageHeight, width):
    '''This function moves across the calibrator on the top and left of the frame one pixel at a time, and after
    'snapping' the colors, decodes an unsigned integer from each axis, which if read correctly, is the block width and
    block height of the frame.
    '''

    calibratorBits = BitArray()
    snappedValues = []
    activeColor = (0, 0, 0)
    activeDistance = 0
    pixelOnDimension = 1
    paletteAIsActive = False

    if width == True:
        axisOnImage = pixelOnDimension, 0
        axisAnalyzed = imageWidth

    else:
        axisOnImage = 0, pixelOnDimension
        axisAnalyzed = imageHeight

    for value in range(16):
        while True:
            if width == True:
                axisOnImage = pixelOnDimension, 0
                axisAnalyzed = imageWidth

            else:
                axisOnImage = 0, pixelOnDimension
                axisAnalyzed = imageHeight

            newPaletteLocked = False
            activeScan = pixelObject[axisOnImage]
            activeDistance = returnDistance(activeScan, activeColor)

            pixelOnDimension += 1
            if activeDistance < 100:  # Iterating over same colored blocks, until distance exceeds 100.
                continue

            else:  # We are determining if we are within < 100 dist of a new color, or are in fuzzy space.
                if paletteAIsActive == False:
                    activePalette = initializerPaletteB.colorSet

                else:
                    activePalette = initializerPaletteA.colorSet

                for color in activePalette:
                    activeDistance = returnDistance(activeScan, color)

                    if activeDistance < 100:
                        paletteAIsActive = not paletteAIsActive
                        newPaletteLocked = True
                        break

                    else:
                        continue

            if newPaletteLocked == True:
                break

        activeColor = colorSnap(activeScan, combinedColors)
        snappedValues.append(activeColor)

        if value % 2 != 0:
            calibratorBits.append(
                initializerPaletteADict.getValue(activeColor))

        else:
            calibratorBits.append(
                initializerPaletteBDict.getValue(activeColor))

        activeDistance = 0

    calibratorBits.reverse()
    readCalibratorBits = ConstBitStream(calibratorBits)
    blockDimensionGuess = readCalibratorBits.read('uint:16')
    pixelWidth = axisAnalyzed / blockDimensionGuess

    return pixelWidth, blockDimensionGuess
コード例 #20
0
def right_encode(x):
    z, n = encode(x)
    temp = BitArray(uint=n, length=8)
    temp.reverse()
    z += temp.bin
    return z
コード例 #21
0
# -*- coding: utf-8 -*-
#
# Python 2.7.1
#

from bitstring import BitArray

fname = 'image.jpg'

with open(fname, 'r+b') as fh:
    byte_map = [ord(b) for b in fh.read(4)]
    byte_list = [byte_map[0], byte_map[1], byte_map[2], byte_map[3]]
    print 'retrieved', len(byte_list), 'from file', fname
    offset = 0
    for ascii_val in byte_list:
        bin_val = BitArray(hex(ascii_val))
        print bin_val.bin
        BitArray.reverse(bin_val)
        print bin_val.bin
        fh.seek(offset)
        bin_val.tofile(fh)
        print 'writing offset', offset, 'of file', fname
        offset += 1

fh.close()
コード例 #22
0
ファイル: pcb-rom.py プロジェクト: brouhaha/pcb-rom
#print("drive space %f %s" % (drive_space, default_unit))

array_width = args.words * args.drive_pitch
#print("array width %f %s" % (array_width, default_unit))

sense_space = (args.sense_pitch - (3 * args.trace_width)) / 3.0
#print("sense space %f %s" % (sense_space, default_unit))

array_height = args.bits * args.sense_pitch - sense_space
#print("array height %f %s" % (array_height, default_unit))

data = BitArray(args.input)
if len(data) != args.words * args.bits:
    raise RuntimeError("input file size %d bits, should be %d bits\n" % (len(data), args.words * args.bits))
for i in range(0, len(data), 8):
    data.reverse(i, i+8)


board = EagleBoardFile(numlayers = 4)

board.add_rectangular_board_outline(0, 0, args.width, args.length);


y = args.length / 2.0 - ((args.words // 2) - 0.5) * args.drive_pitch
word_y = [None] * args.words
for word in range(args.words):
    word_y [word] = [y,
                     y - (args.trace_width + drive_space) / 2.0,
                     y + (args.trace_width + drive_space) / 2.0]
    y += args.drive_pitch
コード例 #23
0
    def __createpocsagmsg(self, address, source, txt):

        # checking input
        if not (0 < address <= 0x1fffff):
            raise ValueError(address)
        #end if

        if not (0 <= source <= 3):
            raise ValueError(source)
        #nd if

        if len(txt) == 0:
            raise ValueError(txt)
        #end if

    #	if len(txt) >= 40:
    #		txt=txt[:39]
    #		print("Warning, text truncated to 39 characters: {txt}".format(txt=txt))
    #end if

    # init pocsag message
    # init data
    # 2 batches
    # 1 batch = sync codeword + 8 frames
    # 1 frame = 1 codeword

        syncpattern = 0xAAAAAAAA
        synccodeword = 0x7cd215d8

        idlepattern = 0x7ac9c197

        # init all codewords with idle pattern: 2 batches = 16 frames = 32 codewords
        codeword = [idlepattern for i in range(32)]

        # part 1: address + source

        # parse address and source
        addressline = address >> 3

        # add address-source
        addressline <<= 2
        addressline += source
        # the message starts at the frame address determined by the last 3 bits of the address
        cwnum = ((address % 8) << 1)  # codeword number

        codeword[cwnum] = self.__CalculateCRCandParity(datatype=0,
                                                       data=addressline)

        # part 2: text

        # 2.1 convert text into int, also add EOT char
        ts = [ord(c) for c in txt] + [0x04]

        # 2.2 make sure all characers are 7 bit
        ts = list(map(lambda x: x % 128, ts))

        # 2.3 create one big list of bits
        textbits = ''

        for c in ts:
            # BitArray(uint=c,length=7).bin to convert character to 7-character bit-string)
            # note, for transmission, the bit-order must be reversed
            charbits = BitArray(uint=c, length=7)
            # reverse order of bits
            charbits.reverse()

            # add to total string
            textbits += charbits.bin
        #end for

        nbits = len(textbits)

        # 2.4 make the list of bits  a multiple of 20 bits
        bitstoadd = 20 - (nbits % 20)

        if bitstoadd == 20:
            bitstoadd = 0
        #end if
        bitstoadd_rest = bitstoadd % 2
        bitstoadd_2bit = bitstoadd >> 1
        textbits += '01' * bitstoadd_2bit
        if bitstoadd_rest == 1:
            textbits += '0'
        #end if

        # 2.5 for every block of 20 bits, calculate crc and partity, and add to codeword
        ncw = len(textbits) / 20  # number of codewords

        startbit = 0
        stopbit = 20  # (actually, the 19th bit)
        for i in range(ncw):
            thiscw = textbits[startbit:stopbit]
            thiscw_i = int(thiscw, 2)  # convert list of bits to int

            #move up all pointers
            startbit = stopbit  # stopbit is startbit + 20
            stopbit += 20

            #codeword pointer
            cwnum += 1

            # calculate CRC for a text block (datatype = 1)
            codeword[cwnum] = self.__CalculateCRCandParity(datatype=1,
                                                           data=thiscw_i)
        #end for (number of

        # done

        # now create complete pocsag message
        # sync pattern
        ret = [syncpattern for i in range(18)]

        # add sync codeword of 1st batch
        ret.append(synccodeword)

        # add frames 0 to 7 (i.e. codewords 0 to 15)
        ret += [codeword[n] for n in range(16)]

        # create add 2nd batch if the text has spilled into the 2nd batch
        if cwnum >= 16:
            # long message, 2 batches
            nbatch = 2

            # add sync codeword
            ret.append(synccodeword)

            # and add frames 8 to 15 (i.e. codewords 16 to 31)
            ret += [codeword[n] for n in range(16, 32)]
        else:
            # short message, 1 batch
            nbatch = 1

        #end else - ifif

        return ((nbatch, ret))
コード例 #24
0
def left_encode(x):
    z, n = encode(x)
    temp = BitArray(uint=n, length=8)
    temp.reverse()
    z = temp.bin + z
    return z
コード例 #25
0
def pixel_creep(image, initializer_palette_a, initializer_palette_b, combined_colors, initializer_palette_a_dict,
                initializer_palette_b_dict, image_width, image_height, width):
    '''This function moves across the calibrator on the top and left of the frame one pixel at a time, and after
    'snapping' the colors, decodes an unsigned integer from each axis, which if read correctly, is the block width and
    block height of the frame.
    '''

    calibrator_bits = BitArray()
    snapped_values = []
    active_color = (0, 0, 0)
    active_distance = 0
    pixel_on_dimension = 1
    palette_a_is_active = False

    if width == True:
        axis_on_image = pixel_on_dimension, 0
        axis_analyzed = image_width

    else:
        axis_on_image = 0, pixel_on_dimension
        axis_analyzed = image_height

    for value in range(16):
        while True:
            if width == True:
                axis_on_image = 0, pixel_on_dimension
                axis_analyzed = image_width

            else:
                axis_on_image = pixel_on_dimension, 0
                axis_analyzed = image_height

            new_palette_locked = False
            active_scan = flip(image[axis_on_image])
            active_distance = return_distance(active_scan, active_color)

            pixel_on_dimension += 1
            if active_distance < 100:  # Iterating over same colored blocks, until distance exceeds 100.
                continue

            else:  # We are determining if we are within < 100 dist of a new color, or are in fuzzy space.
                if palette_a_is_active == False:
                    active_palette = initializer_palette_b.color_set

                else:
                    active_palette = initializer_palette_a.color_set

                for color in active_palette:
                    active_distance = return_distance(active_scan, color)

                    if active_distance < 100:
                        palette_a_is_active = not palette_a_is_active
                        new_palette_locked = True
                        break

                    else:
                        continue

            if new_palette_locked == True:
                break

        active_color = color_snap(active_scan, combined_colors)
        snapped_values.append(active_color)

        if value % 2 != 0:
            calibrator_bits.append(initializer_palette_a_dict.get_value(active_color))

        else:
            calibrator_bits.append(initializer_palette_b_dict.get_value(active_color))

        active_distance = 0

    calibrator_bits.reverse()
    read_calibrator_bits = ConstBitStream(calibrator_bits)
    block_dimension_guess = read_calibrator_bits.read('uint:16')
    pixel_width = axis_analyzed / block_dimension_guess

    return pixel_width, block_dimension_guess