def immediate(self):
value = super(ADC, self).immediate()
result = value + self.cpu.acc + self.cpu.ps['carry_flag']
self.cpu.ps['carry_flag'] = result > 0xff
self.cpu.ps['overflow_flag'] = (
(value >> 7) == (self.cpu.acc >> 7)) != (np.ubyte(result) >> 7)
self.cpu.acc = np.ubyte(result)
def test_cpu_write_word_ok(self, setup_cpu, address, value):
pc_start = setup_cpu.pc
setup_cpu.write_word(address, value)
assert setup_cpu.memory[address] == np.ubyte(value)
assert setup_cpu.memory[address + 1] == np.ubyte(value >> 8)
assert setup_cpu.clock.total_clock_cycles == 2
assert setup_cpu.pc == pc_start
def decode(self) -> str:
output_bits = list()
for i in range(self.im.size[0]):
for j in range(self.im.size[1]):
# outcode
c1, c2, c3 = self.px[i, j]
output_bits.append(
int(
round(
mean((round(mean(unpackbits(ubyte(c1))[-3:])),
round(mean(unpackbits(ubyte(c2))[-3:])),
round(mean(unpackbits(ubyte(c3))[-3:])))))))
if output_bits.__len__() == self.bitlength:
break
else:
continue
break
output_bits = output_bits[::-1]
output_bytes = bytearray()
byte = list()
for b in output_bits:
if byte.__len__() == 8:
output_bytes.append(packbits(byte)[0])
byte = list()
byte.append(b)
output_bytes.append(packbits(byte)[0])
return output_bytes.decode(self.encoding)
def int2TwosC(value):
"""2 byte twos compliment representation of value given"""
## b1, b0 = divmod(value, 1<<8)
## if b1<0 :
## b1 += 1<<8
b1, b0 = divmod(np.int16(value), 1 << 8)
return (np.ubyte(b1), np.ubyte(b0))
def _generate_round_keys(self, private_key: np.array) -> list:
working_array = np.zeros((4, 44), dtype=np.ubyte)
round_constants = [
None,
int('1', 16),
int('2', 16),
int('4', 16),
int('8', 16),
int('10', 16),
int('20', 16),
int('40', 16),
int('80', 16),
int('1b', 16),
int('36', 16)
]
for i in range(4):
for j in range(4):
working_array[i][j] = int(private_key[i][j], 16)
for key_number in range(1, 11):
for column_number in range(1, 5):
if column_number == 1:
tmp_column = working_array[:, 4 * key_number +
column_number - 2]
tmp_column = [
tmp_column[1], tmp_column[2], tmp_column[3],
tmp_column[0]
]
tmp_column = [hex(item)[2:] for item in tmp_column]
tmp_column = [
self.sbox.sbox_substitution(item)
for item in tmp_column
]
tmp_column = np.array(
[int(item, 16) for item in tmp_column], dtype=np.ubyte)
previous_column = working_array[:, 4 * key_number +
column_number - 5]
tmp_column = previous_column ^ tmp_column ^ np.array([
np.ubyte(round_constants[key_number]),
np.ubyte(0),
np.ubyte(0),
np.ubyte(0)
])
for i in range(4):
working_array[i][4 * key_number + column_number -
1] = tmp_column[i]
else:
tmp_column = working_array[:, 4 * key_number +
column_number - 2]
previous_column = working_array[:, 4 * key_number +
column_number - 5]
tmp_column = previous_column ^ tmp_column
for i in range(4):
working_array[i][4 * key_number + column_number -
1] = tmp_column[i]
return np.hsplit(working_array, 11)
def hub75_decompose(data):
pixels = np.frombuffer(data,
dtype=[('r', 'B'), ('g', 'B'), ('b', 'B'),
('a', 'B')])
channels = {
'D': ('r', 0),
'LAT': ('r', 1),
'A': ('r', 2),
'B2': ('r', 3),
'E': ('r', 4),
'B': ('r', 6),
'C': ('r', 7),
'R2': ('g', 0),
'G1': ('g', 1),
'G2': ('g', 4),
'CLK': ('g', 5),
'OE': ('b', 0),
'R1': ('b', 1),
'B1': ('b', 2)
}
output = {}
for name, source in channels.items():
channel = np.bitwise_and(pixels[source[0]], 1 << source[1])
channel = np.where(channel > 0, np.ubyte(ord('1')), np.ubyte(ord('_')))
output[name] = channel.tobytes().decode('utf-8')
return output
def encode(self, input_text: str) -> Image:
input_bytes = bytearray(input_text.encode(self.encoding))
input_bits = list()
for q in input_bytes:
for z in unpackbits(ubyte(q)):
input_bits.append(z)
if self.im.size[0] * self.im.size[1] < input_bits.__len__() + ceil(
input_bits.__len__() / 255):
raise OutOfSpace('Image is not large enough for a bitwise encode')
# encode LSB
self.bitlength = input_bits.__len__()
for i in range(self.im.size[0]):
for j in range(self.im.size[1]):
c1, c2, c3 = self.px[i, j]
# encode here
b = input_bits.pop()
c1 = packbits(list(unpackbits(ubyte(c1))[:-3]) + [b, b, b])[0]
c2 = packbits(list(unpackbits(ubyte(c2))[:-3]) + [b, b, b])[0]
c3 = packbits(list(unpackbits(ubyte(c3))[:-3]) + [b, b, b])[0]
self.px[i, j] = (c1, c2, c3)
if input_bits.__len__() == 0:
break
else:
continue
break
return True
def indirect_indexed(self):
address = super(ADC, self).indirect_indexed()
value = int(self.cpu.read_byte(address), base=0)
result = value + self.cpu.acc + self.cpu.ps['carry_flag']
self.cpu.ps['carry_flag'] = result > 0xff
self.cpu.ps['overflow_flag'] = (
(value >> 7) == (self.cpu.acc >> 7)) != (np.ubyte(result) >> 7)
self.cpu.acc = np.ubyte(result)
def indexed_indirect(self):
address = super(SBC, self).indexed_indirect()
value = int(self.cpu.read_byte(address), base=0)
result = self.cpu.acc - value - (1 - self.cpu.ps['carry_flag'])
self.cpu.ps['carry_flag'] = result > 0xff
self.cpu.ps['overflow_flag'] = (
(value >> 7) == (self.cpu.acc >> 7)) != (np.ubyte(result) >> 7)
self.cpu.acc = np.ubyte(result)
def _list2bits(arg):
# return a numpy.ubyte with bits set based on integers 0..7 in arg
if type(arg) == int and 0 <= arg < 8:
return ubyte(pow2[arg])
elif hasattr(arg, '__iter__'):
return ubyte(sum([pow2[btn] for btn in arg]))
else: # None
return ubyte(0)
def _list2bits(arg):
# return a numpy.ubyte with bits set based on integers 0..7 in arg
if type(arg) == int and 0 <= arg < 8:
return ubyte(pow2[arg])
elif hasattr(arg, '__iter__'):
return ubyte(sum([pow2[btn] for btn in arg]))
else: # None
return ubyte(0)
def test_cpu_pop_word_from_stack_ok(self, setup_cpu, value, sp):
pc_start = setup_cpu.pc
setup_cpu.sp = sp
setup_cpu.memory[setup_cpu.sp + 0x0102] = np.ubyte(value)
setup_cpu.memory[setup_cpu.sp + 0x0101] = np.ubyte(value >> 8)
assert hex(value) == setup_cpu.pull_word_from_stack()
assert setup_cpu.sp == sp + 2
assert setup_cpu.clock.total_clock_cycles == 4
assert setup_cpu.pc == pc_start
def crc8(byte, crc):
for i in range(8):
first_bit = crc & bit_mask
crc = crc << np.ubyte(1)
if np.ubyte(byte & (bit_mask >> i)):
crc = crc | np.ubyte(1)
if first_bit:
crc = crc ^ crc_poly
return crc
def test_cpu_push_word_on_stack_ok(self, setup_cpu, value, sp):
pc_start = setup_cpu.pc
setup_cpu.sp = sp
setup_cpu.push_word_on_stack(value)
assert setup_cpu.memory[setup_cpu.sp + 0x0102] == np.ubyte(value >> 8)
assert setup_cpu.memory[setup_cpu.sp + 0x0101] == np.ubyte(value)
assert setup_cpu.sp == sp - 2
assert setup_cpu.clock.total_clock_cycles == 3
assert setup_cpu.pc == pc_start
def get_char_bit():
import numpy
one = numpy.ubyte(1)
two = numpy.ubyte(2)
n = numpy.ubyte(2)
i = 1
while n >= two:
n <<= one
i += 1
return i
def get_char_bit():
import numpy
one = numpy.ubyte(1)
two = numpy.ubyte(2)
n = numpy.ubyte(2)
i = 1
while n>=two:
n <<= one
i += 1
return i
def test_lda_indexed_indirect(self, setup_cpu, value, zero_flag, neg_flag):
setup_cpu.idx = 0x5a
setup_cpu.memory[0x0200] = 0xa1 # LDA instruction
setup_cpu.memory[0x201] = 0xb8
setup_cpu.memory[np.ubyte(0xb8 + setup_cpu.idx)] = 0x88
setup_cpu.memory[np.ubyte(0xb8 + setup_cpu.idx) + 1] = 0x7a
setup_cpu.memory[0x7a88] = value
setup_cpu.execute(1)
assert setup_cpu.acc == value
assert setup_cpu.clock.total_clock_cycles == 6
assert setup_cpu.ps['negative_flag'] == neg_flag
assert setup_cpu.ps['zero_flag'] == zero_flag
def data2code(self, data):
'''
converts data from its value to a code (byte)
data is a numpy array
'''
data[data < -self.offset] = -self.offset / self.scale
# # No zero vel or sw
# if self.units == 'm/s':
# data[data == 0] = -self.offset/self.scale
data = np.ubyte(data * self.scale + self.offset)
data[data < 2] = np.ubyte(0) # No range folded data
data[data > 255] = np.ubyte(0) # No overflow
return data
def accumulator(self):
carry_flag_value = self.cpu.ps['carry_flag']
self.cpu.ps['carry_flag'] = self.cpu.acc % 2
self.cpu.acc = np.ubyte((self.cpu.acc >> 1) + (carry_flag_value << 7))
~self.cpu.clock
self.cpu.ps['zero_flag'] = self.cpu.acc == 0
self.cpu.ps['negative_flag'] = (self.cpu.acc >> 7) == 1
def dcoupe(img_gray,n):
window_size = (n,n)
img_size=img_gray.shape
new_gray=np.zeros(img_size)
quant=np.zeros(img_size)
dctblock=np.zeros(window_size)
newim=np.zeros(window_size)
t1=np.zeros((8,8))
t2=np.zeros((8,8))
# get the largest dimension
max_dim = max(img_size)
# Crop out the window and calculate
for r in range(0,img_size[0]-n+1, n):# X-(n-1)
for c in range(0,img_size[1]-n+1, n):
window = img_gray[r:r+n,c:c+n]#!!!!! i:i+n
# dctblock=np.zeros(window_size)
dctblock=dct2(window)
t1=quantification(dctblock, 5)
t2=DEquantification(t1, 5)
# newim=np.zeros(window_size)
newim=idct2(t2)#quant[r:r+n,c:c+n]
new_gray[r:r+n,c:c+n]=newim
# quantIm=pil.Image.fromarray(np.ubyte(np.round(255.0*quant,0)))
#pour sauver l'image en format jpeg pour une qualité voulue
# quantIm.save('quantif.jpeg',quality=20)
monIm=pil.Image.fromarray(np.ubyte(np.round(new_gray,0)))
# fich=open('madct.dat','wb')
# fich.write(np.reshape(quantIm,-1))
#on étend le tableau en 1D pour pouvoir enregistrer chaque octet
# fich.close()
return monIm
def resize(src, dstsize):
if src.ndim == 3:
dstsize.append(3)
dst = np.array(np.zeros(dstsize), src.dtype)
factory = float(np.size(src, 0)) / dstsize[0]
factorx = float(np.size(src, 1)) / dstsize[1]
print 'factory', factory, 'factorx', factorx
srcheight = np.size(src, 0)
srcwidth = np.size(src, 1)
print 'srcwidth', srcwidth, 'srcheight', srcheight
for i in range(dstsize[0]):
for j in range(dstsize[1]):
y = float(i) * factory
x = float(j) * factorx
if y + 1 > srcheight:
y -= 1
if x + 1 > srcwidth:
x -= 1
cy = np.ceil(y)
fy = cy - 1
cx = np.ceil(x)
fx = cx - 1
w1 = (cx - x) * (cy - y)
w2 = (x - fx) * (cy - y)
w3 = (cx - x) * (y - fy)
w4 = (x - fx) * (y - fy)
if (x - np.floor(x) > 1e-6 or y - np.floor(y) > 1e-6):
t = src[fy, fx] * w1 + src[fy, cx] * w2 + src[
cy, fx] * w3 + src[cy, cx] * w4
t = np.ubyte(np.floor(t))
dst[i, j] = t
else:
dst[i, j] = (src[y, x])
return dst
def write_header( weights, f ):
"""
Writes header to the file. File must be open
"""
# write version header
f.write( np.ubyte( 0 ).tobytes() )
# write reserved field
f.write( np.ubyte( 0 ).tobytes() )
# write the number of dimensions
f.write( np.uint32( len( weights.shape ) ).tobytes() )
# write the dimension info
for d in weights.shape:
f.write( np.uint32( d ).tobytes() )
# write datatype info (currently it is only float32
f.write( np.ubyte( 1 ).tobytes() )
def test_segments():
with pynrn.Context():
# Test .segments and .nodes iterators
s1 = pynrn.Section()
assert s1.nseg == 1
assert [s.x for s in s1.segments] == [0.5]
assert [s.x for s in s1.nodes] == [0, 1]
s1.nseg = 2
assert s1.nseg == 2
assert [s.x for s in s1.segments] == [0.25, 0.75]
assert [s.x for s in s1.nodes] == [0, 0.5, 1]
s1.nseg = 3
assert s1.nseg == 3
assert [s.x for s in s1.segments] == [1./6., 3./6., 5./6.]
assert [s.x for s in s1.nodes] == [0, 1./3., 2./3., 1]
# test x type does not cause segment cache miss
assert s1(0) is s1(0.0)
assert s1(0) is s1(np.float(0))
assert s1(0) is s1(np.ubyte(0))
# test non-numeric locations
for x in ['x', s1, np.array([1,2,3])]:
with pytest.raises(TypeError):
s1(x)
def yuv_to_rgb(y_dec, u_dec, v_dec):
r = clip(y_dec + 1.402 * (v_dec - 128), 0, 255)
g = clip(y_dec - 0.34414 * (u_dec - 128) - 0.71414 * (v_dec - 128), 0, 255)
b = clip(y_dec + 1.772 * (u_dec - 128), 0, 255)
rgb = ubyte(dstack((r, g, b)))
imsave('rgb_parrot.jpg', rgb)
return rgb
def imslant(img):
aa = np.transpose(img)
dimx = aa.shape[0]
dimy = aa.shape[1]
dimxh = aa.shape[0] / 2
dimyh = aa.shape[1] / 2
ii = np.where(aa > 0)
cc = len(ii[0])
xa = np.mean(ii[0])
ya = np.mean(ii[1])
slopenum = np.sum(ii[1] * (ii[0] - xa))
slopeden = np.sum(ii[1] * (ii[1] - ya))
slope = slopenum / slopeden
#print slope, xa, ya
ii = np.outer(range(28), np.ones(28))
jj = np.outer(np.ones(28), range(28))
fx = ii - xa + (jj - ya) * slope + dimxh
fy = jj - ya + dimyh
x = np.int16(fx)
y = np.int16(fy)
a = fx - x
b = fy - y
xx1 = x + 1
yy1 = y + 1
timg = np.zeros((2 * dimx + img.shape[0], 2 * dimy + img.shape[1]))
timg[dimx:(dimx + img.shape[0]), dimy:(dimy + img.shape[1])] = aa
imout = a * b * timg[xx1 + dimx, yy1 + dimy] + a * (1. - b) * timg[
xx1 + dimx, y + dimy] + (1. - a) * b * timg[x + dimx, yy1 + dimy] + (
1. - a) * (1. - b) * timg[x + dimx, y + dimy]
#imout=timg[x+dimxh,y+dimyh]
return (np.ubyte(np.transpose(imout)))
def calc_crc8():
crc = np.ubyte(0)
for i in b:
crc = crc8(i, crc)
crc = crc8(0b00000000, crc)
print('Контрольнаяя сумма')
print(hex(crc))
def pre_process_video(folder, social):
# Load Video
aviFiles = glob.glob(folder+'/*.avi')
aviFile = aviFiles[0]
vid = cv2.VideoCapture(aviFile)
numFrames = int(vid.get(cv2.CAP_PROP_FRAME_COUNT))
# Read First Frame
ret, im = vid.read()
previous = cv2.cvtColor(im, cv2.COLOR_BGR2GRAY)
width = np.size(previous, 1)
height = np.size(previous, 0)
# Alloctae Image Space
stepFrames = 250 # Add a background frame every 2.5 seconds for 50 seconds
bFrames = 50
thresholdValue=10
accumulated_diff = np.zeros((height, width), dtype = float)
backgroundStack = np.zeros((height, width, bFrames), dtype = float)
background = np.zeros((height, width), dtype = float)
bCount = 0
for i, f in enumerate(range(0, numFrames, stepFrames)):
vid.set(cv2.CAP_PROP_POS_FRAMES, f)
ret, im = vid.read()
current = cv2.cvtColor(im, cv2.COLOR_BGR2GRAY)
absDiff = cv2.absdiff(previous, current)
level, threshold = cv2.threshold(absDiff,thresholdValue,255,cv2.THRESH_TOZERO)
previous = current
# Accumulate differences
accumulated_diff = accumulated_diff + threshold
# Add to background stack
if(bCount < bFrames):
backgroundStack[:,:,bCount] = current
bCount = bCount + 1
print (numFrames-f)
print (bCount)
vid.release()
# Normalize accumulated difference image
accumulated_diff = accumulated_diff/np.max(accumulated_diff)
accumulated_diff = np.ubyte(accumulated_diff*255)
# Enhance Contrast (Histogram Equalize)
equ = cv2.equalizeHist(accumulated_diff)
# Compute Background Frame (median or mode)
background = np.median(backgroundStack, axis = 2)
saveFolder = folder
imageio.imwrite(saveFolder + r'/difference.png', equ)
cv2.imwrite(saveFolder + r'/background.png', background)
# Using SciPy to save caused a weird rescaling when the images were dim.
# This will change not only the background in the beginning but the threshold estimate
return 0
def add_light_source(self, x, y, intensity=ubyte(255)):
"""
Apply light algorythm to given position
x, y - position
intensity - light value for source block
"""
self._light_block(x, y, intensity=intensity)
def test_numpy(self):
"""NumPy objects get serialized to readable JSON."""
l = [
np.float32(12.5),
np.float64(2.0),
np.float16(0.5),
np.bool(True),
np.bool(False),
np.bool_(True),
np.unicode_("hello"),
np.byte(12),
np.short(12),
np.intc(-13),
np.int_(0),
np.longlong(100),
np.intp(7),
np.ubyte(12),
np.ushort(12),
np.uintc(13),
np.ulonglong(100),
np.uintp(7),
np.int8(1),
np.int16(3),
np.int32(4),
np.int64(5),
np.uint8(1),
np.uint16(3),
np.uint32(4),
np.uint64(5),
]
l2 = [l, np.array([1, 2, 3])]
roundtripped = loads(dumps(l2, cls=EliotJSONEncoder))
self.assertEqual([l, [1, 2, 3]], roundtripped)
def test_zero_page_y(self, setup_cpu, zp_address, idy, address):
setup_cpu.pc = address
setup_cpu.idy = idy
setup_cpu.memory[address] = zp_address
addressing = cpu6502.instructions.AbstractInstruction(setup_cpu)
assert addressing.zero_page_y() == np.ubyte(zp_address + idy)
assert setup_cpu.clock.total_clock_cycles == 2
def essentials_skeletonize():
image = skimage.data.imread('holsteiner-stute.png', as_gray=True) > 0
image_inv = skimage.util.invert(image)
distance = scipy.ndimage.distance_transform_edt(image_inv)
distance = skimage.util.invert(distance.astype(np.uint8))
distance_border = skimage.measure.find_contours(image, 0.5)
bg: np.ndarray = skimage.img_as_ubyte(distance)
bg_min, bg_max = np.amin(bg), np.amax(bg)
bg_mid = np.ubyte((int(bg_min) + int(bg_max)) / 2)
border: np.ndarray = np.zeros(bg.shape, dtype=np.bool_)
for b in distance_border:
for (x0, y0), (x1, y1) in pairwise(b):
rr, cc = skimage.draw.line(int(x0), int(y0), int(x1), int(y1))
border[rr, cc] = True
def finish(name: str, skeleton: np.ndarray):
skeleton = skimage.morphology.binary_dilation(skeleton)
skeleton_border = skimage.morphology.binary_dilation(skeleton)
out = bg.copy()
out[skeleton_border & image_inv] = bg_min
out[skeleton & image_inv] = 255
out[border] = bg_mid
write_image(name, out)
finish('essentials_skeletonize_medial_axis.png',
skimage.morphology.medial_axis(image_inv))
finish('essentials_skeletonize_thinning.png',
skimage.morphology.skeletonize(image_inv))
def imslant(img):
aa=np.transpose(img)
dimx=aa.shape[0]
dimy=aa.shape[1]
dimxh=aa.shape[0]/2
dimyh=aa.shape[1]/2
ii=np.where(aa>0)
cc=len(ii[0])
xa=np.mean(ii[0])
ya=np.mean(ii[1])
slopenum=np.sum(ii[1]*(ii[0]-xa))
slopeden=np.sum(ii[1]*(ii[1]-ya))
slope=slopenum/slopeden
#print slope, xa, ya
ii=np.outer(range(28),np.ones(28))
jj=np.outer(np.ones(28),range(28))
fx=ii-xa+(jj-ya)*slope+dimxh
fy=jj-ya+dimyh
x=np.int16(fx)
y=np.int16(fy)
a=fx-x
b=fy-y
xx1=x+1
yy1=y+1
timg=np.zeros((2*dimx+img.shape[0],2*dimy+img.shape[1]))
timg[dimx:(dimx+img.shape[0]),dimy:(dimy+img.shape[1])]=aa
imout=a*b*timg[xx1+dimx,yy1+dimy]+a*(1.-b)*timg[xx1+dimx,y+dimy]+(1.-a)*b*timg[x+dimx,yy1+dimy]+(1.-a)*(1.-b)*timg[x+dimx,y+dimy]
#imout=timg[x+dimxh,y+dimyh]
return(np.ubyte(np.transpose(imout)))
def test_numpy(self):
"""NumPy objects get serialized to readable JSON."""
l = [
np.float32(12.5),
np.float64(2.0),
np.float16(0.5),
np.bool(True),
np.bool(False),
np.bool_(True),
np.unicode_("hello"),
np.byte(12),
np.short(12),
np.intc(-13),
np.int_(0),
np.longlong(100),
np.intp(7),
np.ubyte(12),
np.ushort(12),
np.uintc(13),
np.ulonglong(100),
np.uintp(7),
np.int8(1),
np.int16(3),
np.int32(4),
np.int64(5),
np.uint8(1),
np.uint16(3),
np.uint32(4),
np.uint64(5),
]
l2 = [l, np.array([1, 2, 3])]
roundtripped = loads(dumps(l2, cls=EliotJSONEncoder))
self.assertEqual([l, [1, 2, 3]], roundtripped)
def findObstacle(depth):
start = time.clock()
ret, depth = cv2.threshold(depth, depth_range[0], 255, cv2.THRESH_TOZERO)
ret, depth = cv2.threshold(depth, depth_range[1], 255,
cv2.THRESH_TOZERO_INV)
depth = np.ubyte(depth)
# Get a 15x15 kernel filled with 1
kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (15, 15))
# Open operation, separate depth, suppress insignificant blocks
opening = cv2.morphologyEx(depth, cv2.MORPH_OPEN, kernel)
# Search contours
ret, binary_depth = cv2.threshold(depth, depth_thresh, 255,
cv2.THRESH_BINARY)
contours, hierarchy = cv2.findContours(binary_depth, cv2.RETR_EXTERNAL,
cv2.CHAIN_APPROX_SIMPLE)
# Find convex hull
hulls = contoursOut = []
for i in range(len(contours)):
if cv2.contourArea(contours[i]) >= area_thresh:
hulls.append(cv2.convexHull(contours[i], False))
contoursOut.append(contours[i])
return (depth, binary_depth, hulls, contours, hierarchy)
def test_sequential_runner_not_matching_answer2():
kernel_string = """__global__ void vector_add(float *c, float *a, float *b, int n) {
int i = blockIdx.x * block_size_x + threadIdx.x;
if (i<n) {
c[i] = a[i] + b[i];
}
} """
args = get_vector_add_args()
answer = [np.ubyte([12]), None, None, None]
tune_params = {"block_size_x": [128 + 64 * i for i in range(5)]}
try:
kernel_tuner.tune_kernel("vector_add",
kernel_string,
args[-1],
args,
tune_params,
method="diff_evo",
verbose=True,
answer=answer)
print("Expected a TypeError to be raised")
assert False
except TypeError as expected_error:
print(str(expected_error))
assert "Element 0" in str(expected_error)
except Exception:
print("Expected a TypeError to be raised")
assert False
def Numpy2QImage(i_image):
""" Converts Numpy to QImage that can be displayed in a QLabel
Only supports displaying grayscale Numpy and QImages. limited type checking!"""
image = numpy.ubyte(i_image).tostring()
o_image = QtGui.QImage( image, i_image.shape[1], i_image.shape[0], i_image.shape[1],
QtGui.QImage.Format_Indexed8 ).copy()
o_image.setColorTable( g_color_table )
return QtGui.QImage.convertToFormat ( o_image.copy(), QtGui.QImage.Format_RGB32 )
def flatten_matrix(matrix):
# each entry in the flattened matrix is an uchar4
f_matrix = []
count = 0
for i in range(matrix.shape[0]):
for j in range(matrix.shape[1]):
if matrix[i][j] != 0:
entry = numpy.array(
[numpy.byte(i), numpy.byte(j), numpy.byte(matrix[i][j]),
numpy.byte(0)])
f_matrix.append(entry)
count += 1
return numpy.array(f_matrix), numpy.ubyte(count)
def byte_to_bit(ar_byte):
'''
convert a byte array (ubyte) to a a bit array (ubyte)
Parameters
----------
ar_byte : 1d-array, ubyte (from 0 to 255)
Returns
-------
ar_bit : 1d-array, ubyte (only 0 and 1)
'''
return np.ravel( \
np.fromfunction( \
lambda i, j: np.ubyte(ar_byte[i] >> _BIT_INDEX[j] & 1),
(len(ar_byte), 8),
dtype=np.int)
)
def _getExifValue(data, data_type):
if data_type==1:
return np.ubyte(data)
elif data_type==2:
return str(data)
elif data_type==3:
return np.uint16(data)
elif data_type==4:
return np.uint32(data)
elif data_type==5:
n=np.uint32(0xffffffff&data)
d=np.uint32(((0xffffffff<<32)&data)>>32)
if n==0:
return 0
elif d==0:
return "nan"
else:
return (n,d)
elif data_type==6:
return np.byte(data)
elif data_type==7:
return data
elif data_type==8:
return np.int16(data)
elif data_type==9:
return np.int32(data)
elif data_type==10:
n=np.int32(0xffffffff&data)
d=np.int32(((0xffffffff<<32)&data)>>32)
if n==0:
return 0
elif d==0:
return "nan"
else:
return (n,d)
elif data_type==11:
return np.float32(data)
elif data_type==12:
return np.float64(data)
else:
return data
def test_sequential_runner_not_matching_answer2():
kernel_string = """__global__ void vector_add(float *c, float *a, float *b, int n) {
int i = blockIdx.x * block_size_x + threadIdx.x;
if (i<n) {
c[i] = a[i] + b[i];
}
} """
args = get_vector_add_args()
answer = [np.ubyte([12]), None, None, None]
tune_params = {"block_size_x": [128 + 64 * i for i in range(5)]}
try:
kernel_tuner.tune_kernel(
"vector_add", kernel_string, args[-1], args, tune_params,
method="diff_evo", verbose=True, answer=answer)
print("Expected a TypeError to be raised")
assert False
except TypeError as expected_error:
print(str(expected_error))
assert "Element 0" in str(expected_error)
except Exception:
print("Expected a TypeError to be raised")
assert False
def Numpy2Ipl(i_image):
image = numpy.ubyte(i_image)
return cv.NumPy2Ipl(image)
def createTestBuffer(self):
data = numpy.random.rand(self._samplesPerChannel)
data = numpy.ubyte(data * 255)
return data
def construct_dtype_and_converters(header, delimiter=INDEX_VALUES.sep_dipcp):
dtype = []
converters = {}
header = header.rstrip().split(delimiter)
for i, f in enumerate(header):
f = re.sub('-[\d]+s-', '-', f)
if f == '':
t = '|S1' #(np.str_, 1)
conv=np.str_
elif re.match('Time|\w*PacketDate|DIP[-\w]+Milli[sS]econds', f):
# time format
t = np.float_
conv = lambda s: np.float_(s or 0)
elif re.match('FlowIP|LastPacketIPSource', f):
t = '|S16' #(np.str_, 16)
conv=np.str_
elif re.match('FlowEth', f):
t = '|S17' #(np.str_, 17)
conv=np.str_
elif re.match('FlowPort', f):
t = np.uint16
conv = lambda s: np.uint16(s or 0)
elif re.match('DIP[-\w]+Number-Packets-', f):
t = np.uint32
conv = lambda s: np.uint32(s or 0)
elif re.match('DIP-Volume-Sum-Bytes-', f):
t = np.uint64
conv = lambda s: np.uint64(s or 0)
elif re.match('DIP-Thp-Number-Kbps-|ts-', f):
t = np.float_
conv = lambda s: np.float_(s or 0)
elif f == 'LastPacketProtocol':
t = '|S5' #(np.str_, 5)
conv=np.str_
elif re.match('[\w]*LastTcpPacketType', f):
t = '|S5' #(np.str_, 5)
conv=np.str_
elif re.match('SynCounter-', f):
t = np.uint8
conv = lambda s: np.uint8(s or 0)
elif re.match('(?!Size)[A-Z][a-z]+-[1-9]', f):
t = np.ubyte
conv = lambda s: np.ubyte(s or 0)
elif re.match('Size-[1-9]', f):
t = np.uint16
conv = lambda s: np.uint16(s or 0)
elif f == 'TOS':
t = np.ubyte
conv = lambda s: np.ubyte(s or 0)
elif f == 'LastPacketSize':
t = np.uint16
conv = lambda s: np.uint16(s or 0)
elif re.match('DIP[-\w]+NbMes-', f):
t = np.uint32
conv = lambda s: np.uint32(s or 0)
elif re.match('DIP[-\w]+Mean-', f):
t = np.float_
conv = lambda s: np.float_(s or 0)
elif re.match('DIP[-\w]+(?:Min|Max)-ms-', f):
t = np.float_
conv = lambda s: np.float_(s or 0)
# added for radius analysis
elif f == 'IMSI':
# IMSI and IP address both have 16 chars
t = '|S16' #(np.str_, 16) #'|S16'
conv=np.str_
elif f == 'RAT':
t = np.uint8
conv = lambda s: np.uint8(s or 0)
elif f == 'SGSN':
t = '|S16' #(np.str_, 16)
conv=np.str_
elif f == 'IMEI':
t = '|S48' #(np.str_, 48)
conv=np.str_
elif f == 'CellId':
t = np.int_
conv = lambda s: np.int_(s or 0)
elif f == 'Constructor':
t = '|S30'
conv=np.str_
elif f == 'DevType':
t = '|S10'
conv=np.str_
elif re.match('DIP[-\w]+(?:Min|Max)-s-', f):
t = np.float_
conv = lambda s: np.float_(s or 0)
else:
raise Exception, "unknown format: " + f
name = f
while name in [fi for (fi, ty) in dtype]:
name = '_'.join((name, 'TWICE'))
dtype.append((name, t))
# print t, type(t)
converters[i] = conv
# if type(t) is not tuple:
# # automatic converter does not work for tuples
# converters[i] = lambda s: t(s or 0)
# else:
# converters[i] = lambda s: str(s)
return dtype, converters
def dofilter(dlg, input, output, refband=1, memuse=100):
try:
from osgeo import gdal
except ImportError:
import gdal
from gdalconst import GA_ReadOnly, GDT_Float32
gdal.AllRegister()
w = 5
w2 = (w + 1) / 2
refband = int(refband)
memuse = int(memuse)
tif = gdal.Open(str(input), GA_ReadOnly)
nbands = tif.RasterCount
driver = tif.GetDriver()
xsize = tif.RasterXSize
ysize = tif.RasterYSize
out = driver.Create(str(output), xsize, ysize, nbands, gdal.GDT_Byte)
out.SetGeoTransform(tif.GetGeoTransform())
out.SetProjection(tif.GetProjection())
band = [None] * nbands
oband = [None] * nbands
for i in range(0, nbands):
band[i] = tif.GetRasterBand(i + 1)
oband[i] = out.GetRasterBand(i + 1)
nr = numpy.roll
na = numpy.add
band = nr(band, (1 - refband))
oband = nr(oband, (1 - refband))
refband2 = None
readrows = int((((memuse - 67) * 48036) / xsize) / 2)
oband[0].WriteArray(numpy.repeat(0, xsize * 2).reshape(2, -1), 0, 0)
arr = [None] * nbands
for i in range(0, nbands):
arr[i] = band[i].ReadAsArray(0, 0, xsize, 4)
for y in range(4, ysize, readrows):
QCoreApplication.processEvents()
if ysize - y < readrows:
readrows = ysize - y
arr1 = band[0].ReadAsArray(0, y, xsize, readrows)
arr1 = numpy.uint32(numpy.vstack((arr[0], arr1)))
arr[0] = arr1[readrows : readrows + 5,]
sum = na(
na(
na(
na(na(arr1, nr(arr1, 1, 1)), nr(arr1, -1, 1)),
na(nr(nr(arr1, -1, 1), -1, 0), nr(nr(arr1, -1, 1), 1, 0)),
),
na(nr(nr(arr1, 1, 1), -1, 0), nr(nr(arr1, 1, 1), 1, 0)),
),
na(nr(arr1, -1, 0), nr(arr1, 1, 0)),
)
sum2 = arr1 ** 2
sum2 = na(
na(
na(
na(na(sum2, nr(sum2, 1, 1)), nr(sum2, -1, 1)),
na(nr(nr(sum2, -1, 1), -1, 0), nr(nr(sum2, -1, 1), 1, 0)),
),
na(nr(nr(sum2, 1, 1), -1, 0), nr(nr(sum2, 1, 1), 1, 0)),
),
na(nr(sum2, -1, 0), nr(sum2, 1, 0)),
)
sum2 = numpy.uint16(numpy.round((sum2 - ((sum ** 2) / 9.0)) / 9.0))
sum = numpy.ubyte((sum / 9.0) + 0.5)
sum23 = nr(sum2, -2, 1)
t = numpy.vstack((sum2.flatten(), sum23.flatten(), nr(sum2, 2, 0).flatten(), nr(sum23, 2, 0).flatten()))
t = t == numpy.min(t, 0)
sum23 = nr(sum, -2, 1)
arr1 = nr(
nr(
numpy.ubyte(
numpy.reshape(
numpy.max(
(t)
* numpy.vstack(
(sum.flatten(), sum23.flatten(), nr(sum, 2, 0).flatten(), nr(sum23, 2, 0).flatten())
),
0,
),
(readrows + 4, -1),
)
),
-1,
0,
),
1,
1,
)[2 : (readrows + 2), 2 : (xsize - 2)]
oband[0].WriteArray(arr1, 2, y - 2)
dlg.progressBar.setValue(int((100 * (y + (readrows / nbands) + 4)) / ysize))
for i in range(1, nbands):
arr1 = band[i].ReadAsArray(0, y, xsize, readrows)
arr1 = numpy.uint32(numpy.vstack((arr[i], arr1)))
arr[i] = arr1[readrows : readrows + 5,]
sum = numpy.ubyte(
(
na(
na(
na(
na(na(arr1, nr(arr1, 1, 1)), nr(arr1, -1, 1)),
na(nr(nr(arr1, -1, 1), -1, 0), nr(nr(arr1, -1, 1), 1, 0)),
),
na(nr(nr(arr1, 1, 1), -1, 0), nr(nr(arr1, 1, 1), 1, 0)),
),
na(nr(arr1, -1, 0), nr(arr1, 1, 0)),
)
)
/ 9.0
+ 0.5
)
sum23 = nr(sum, -2, 1)
arr1 = nr(
nr(
numpy.ubyte(
numpy.reshape(
numpy.max(
(t)
* numpy.vstack(
(sum.flatten(), sum23.flatten(), nr(sum, 2, 0).flatten(), nr(sum23, 2, 0).flatten())
),
0,
),
(readrows + 4, -1),
)
),
-1,
0,
),
1,
1,
)[2 : (readrows + 2), 2 : (xsize - 2)]
oband[i].WriteArray(arr1, 2, y - 2)
dlg.progressBar.setValue(int((100 * (y + (((i + 1) * readrows) / nbands) + 4)) / ysize))
out = None
tif = None
return True
import numpy
C_CONTIGUOUS = numpy.ubyte(1)
F_CONTIGUOUS = numpy.ubyte(1) << 1
OWNDATA = numpy.ubyte(1) << 2
C_DIRTY = numpy.ubyte(1) << 3 # internal use only
F_DIRTY = numpy.ubyte(1) << 4 # internal use only
class Flags(object):
__slots__ = ['_value']
def __init__(self, value):
self._value = value
def __getitem__(self, name):
if name == 'C_CONTIGUOUS':
return self.c_contiguous
elif name == 'F_CONTIGUOUS':
return self.f_contiguous
elif name == 'OWNDATA':
return self.owndata
else:
raise KeyError('%s is not defined for cupy.ndarray.flags' % name)
def __repr__(self):
t = ' %s : %s'
ret = []
for name in 'C_CONTIGUOUS', 'F_CONTIGUOUS', 'OWNDATA':
def __init__(self,J,Jfb):
self.JJ=np.ubyte(J)
self.JJfb=np.ubyte(Jfb)
def compress_nets(NN):
for Nc in NN:
for P in Nc:
P.JJ=np.ubyte(P.JJ)
###########################################################################
# linear kernel on byte features
###########################################################################
from tools.load import LoadMatrix
from numpy import ubyte
lm=LoadMatrix()
traindat = ubyte(lm.load_numbers('../data/fm_train_byte.dat'))
testdat = ubyte(lm.load_numbers('../data/fm_test_byte.dat'))
parameter_list=[[traindat,testdat],[traindat,testdat]]
def kernel_linear_byte_modular(fm_train_byte=traindat,fm_test_byte=testdat):
from shogun.Kernel import LinearKernel
from shogun.Features import ByteFeatures
feats_train=ByteFeatures(fm_train_byte)
feats_test=ByteFeatures(fm_test_byte)
kernel=LinearKernel(feats_train, feats_train)
km_train=kernel.get_kernel_matrix()
kernel.init(feats_train, feats_test)
km_test=kernel.get_kernel_matrix()
return kernel
if __name__=='__main__':
print('LinearByte')
kernel_linear_byte_modular(*parameter_list[0])
def WBool(value):
if value:
outfile.write(np.ubyte(1))
else:
outfile.write(np.ubyte(0))
def SetPatternDefs(self, dataFrames):
patternSettings = np.zeros(1,PATTERN_INFO_DTYPE)
patternSettings['depth'] = 1
patternSettings['nPatterns'] = len(dataFrames)
patternSettings['invert'] = 0
patternSettings['trigger'] = PATTERN_TRIGGER.COMMAND
#patternSettings[']
h, d = self._ExecCommand(LC_PACKET_TYPE.HOST_WRITE, CMD_PATTERN_SETTING, patternSettings)
print(( h, d))
for index, data in enumerate(dataFrames):
im = Image.fromarray(data)#.convert('1')
output = StringIO.StringIO()
im.save(output, format='BMP')
contents = output.getvalue()
output.close()
#print contents[:50], np.fromstring(contents, 'u1')[:50]
h, d = self._ExecCommand(LC_PACKET_TYPE.HOST_WRITE, CMD_PATTERN_DEFINITION, np.hstack([np.ubyte(index),np.fromstring(contents, 'u1')]))
print(( h, d))
return h, d
