def move_right(data): # 反转====反转回来
"""
2048整体向右移动
源数据:
[2 0 2 0]
[0 0 0 0]
[0 0 0 0]
[0 0 0 0]
反转
[0 2 0 2]
[0 0 0 0]
[0 0 0 0]
[0 0 0 0]
向左移动
[4 0 0 0]
[0 0 0 0]
[0 0 0 0]
[0 0 0 0]
反转:
[0 0 0 4]
[0 0 0 0]
[0 0 0 0]
[0 0 0 0]
"""
invertData = invert(data)
return invert(move_left(invertData))
def find_endpoint_bounds(positive_example, tolerance_a, tolerance_b,
param_boundaries):
"""
Find upper and lower bounds for where the endpoints of the boundary can be
Returns a tuple of 4 coordinates: (left_upper_bound, right_upper_bound,
left_lower_bound, right_lower_bound)
positive_example should be some boundary.
tolerance_a and tolerance_b should be floats.
param_boundaries should be a list of lists giving lower and upper bounds for
the possible parameter values. Specifically, it should be a list of the form
[[lower_bound_x, upper_bound_x], [lower_bound_y, upper_bound_y]]
"""
print("In find_endpoint_bounds.")
# use helper function to find upper bounds
upper_bounds = find_upper_endpoint_bounds(positive_example, tolerance_a,
tolerance_b, param_boundaries,
False)
# negate the example, find upper bounds of the negated thing, then negate
# that to find lower bounds
# but instead of negating, you want to take the limits minus the example,
# so that you remain within the same parameter boundaries
inv_pos_example = utils.invert(positive_example, param_boundaries)
# print("in find_endpoint_bounds, the positive example is",
# positive_example)
# print("in find_endpoint_bounds, inv_pos_example is", inv_pos_example)
inv_upper_bounds = find_upper_endpoint_bounds(inv_pos_example, tolerance_a,
tolerance_b,
param_boundaries, True)
lower_bounds = utils.invert(inv_upper_bounds, param_boundaries)
return (upper_bounds[0], upper_bounds[1], lower_bounds[0], lower_bounds[1])
def verify(sig, e, pub, g, n):
r, s = sig
w = utils.invert(s, n)
u1 = e * w % n
u2 = r * w % n
x, y = point_add(point_mult(g, u1), point_mult(pub, u2))
return r == x
def label(boundary, should_invert=False, param_boundaries=[[0.0, 20.0],
[0, 1.0]],
epsilon=0.01, num_points=200, lipschitz_param=0.05):
"""
Takes a boundary, and returns its proper label, which is True or False.
Correct implementation will depend on context, and in the extreme case will
require computation done by the human.
"""
# TODO: add type assertions
if should_invert:
my_boundary = utils.invert(boundary, param_boundaries)
else:
my_boundary = boundary
# print("endpoints of labelled boundary:", [my_boundary[0], my_boundary[-1]])
utils.plot(my_boundary, 'tab:orange', param_boundaries)
print("in the label function")
# print("in the label function, should_invert is", should_invert)
# print("boundary that label is synthesising", my_boundary)
# print(num_points)
xs = [z3.Real('x%d' % i) for i in range(num_points)]
us = [z3.Real('u%d' % i) for i in range(num_points)]
def make_phi(xs, us):
# this basically makes a formula encoding dynamics of a system xs
# controlled by us
formula = True
for i in range(num_points - 1):
formula = z3.And(formula, xs[i+1] == xs[i] + us[i],
# xs[i+1] - xs[i] <= lipschitz_param,
# xs[i] - xs[i+1] <= lipschitz_param,
xs[i] >= 0, xs[i+1] >= 0, xs[i] <= 1, xs[i+1] <= 1)
return formula
trace = bt.trace(my_boundary, epsilon, num_points, xs,
param_boundaries[0][1], make_phi(xs, us))
# print("trace that is being labelled is", trace)
utils.plot(trace, 'b-', param_boundaries)
# in this labelling function, we demand that the trace's velocity be below
# the lines connecting the points (0,1), (8, 0.9), (14, 0.6), (20, 0.2),
# i.e. those points should be the polygon that the boundary has to be below
below_top = True
for point in trace:
if point[0] <= 8:
below_top = below_top and (point[1] <= point[0]/(-80.0) + 1.0)
if point[0] <= 14 and point[0] >= 8:
below_top = below_top and (point[1] <= point[0]/(-20.0) + 13.0/10)
if point[0] >= 14:
below_top = below_top and (point[1] <= point[0]/(-15.0) + 23.0/15)
# print("below top?", below_top)
return below_top
def __init__(self, n): self.n = n self.acceptable = set(string.uppercase) self.e_table = dict(zip(self.acceptable, utils.nLetterGenerator(self.acceptable, self.n))) self.e_transform = utils.mkTransform(self.e_table) self.d_table = utils.invert(self.e_table) self.d_transform = utils.mkTransform(self.d_table) self.key = json.dumps(self.e_table)
def sign(e, g, n, d):
while True:
k = utils.randomnumber(n-1)
x, y = point_mult(g, k)
if x % n != 0:
break
r = x
s = utils.invert(k, n) * (e + r * d) % n
return r, s
def key_gen(p, q):
if utils.nonrec_gcd(p, q) != 1:
# non-distinct
exit(1)
n = p * q
g = n + 1
lmdba = (p - 1) * (q - 1)
mu = utils.invert(lmdba, n)
return (n, g), (n, p, q, g, lmdba, mu)
def __init__(self): # self.lower=u"aąbcćdeęfghijklłmnńoóprsśtuwyzźż" self.upper=u"AĄBCĆDEĘFGHIJKLŁMNŃOÓPRSŚTUWYZŹŻ" self.acceptable = set(self.upper) bigrams = utils.nLetterGenerator(string.uppercase, 2) self.e_table = dict(zip(self.acceptable, bigrams)) self.e_transform = utils.mkTransform(self.e_table) self.d_table = utils.invert(self.e_table) self.d_transform = utils.mkTransform(self.d_table) self.key = json.dumps(self.e_table)
def verify(m, sig, y, p=P, q=Q, g=G):
r, s = sig
w = utils.invert(s, q)
u1 = m * w % q
u2 = r * w % q
r1 = gmpy2.powmod(g, u1, p)
r2 = gmpy2.powmod(y, u2, p)
r3 = r1 * r2 % p
v = r3 % q
return v == r
def run(sources, destination):
"""
sources: list of mve scene folders (name:path)
destination: target folder
"""
Path(destination).mkdir(exist_ok=True)
for source in sources:
i = source.index(':')
setname = source[0:i]
path = source[i + 1:]
dst = Path(destination) / setname
dst.mkdir(exist_ok=True)
children = sorted((Path(path) / "output" / "views").iterdir())
for child in children:
metafile = child / "meta.ini"
meta = ConfigParser()
meta.read(metafile)
if 'view' not in meta or 'camera' not in meta or float(
meta['camera']['focal_length']) <= 0:
continue
name = meta['view']['name']
orgfile = child / "original.jpg"
colorfile = child / "undistorted.png"
maskfile = child / "mask.png"
depthfile = child / "mask-depth.png"
if not metafile.exists() or not (orgfile.exists()
or colorfile.exists()):
continue
dstinput = dst / (name + '.png')
dstmask = dst / (name + '.mask')
dstweight = dst / (name + '.weight')
if colorfile.exists() and not dstinput.exists():
logger.info(dstinput)
os.symlink(colorfile.resolve(), dstinput)
elif orgfile.exists() and not dstinput.exists():
logger.info(dstinput)
os.symlink(orgfile.resolve(), dstinput)
if not dstmask.exists() and maskfile.exists():
logger.info(dstmask)
mask = binarymask(
normalize(cv2.imread(str(maskfile), cv2.IMREAD_ANYDEPTH)),
0.1, 5, 5, 10)
cv2.imwrite(str(dstmask) + '.png', tobytes(mask))
(dst / (name + '.mask.png')).replace(dstmask)
if not dstweight.exists() and depthfile.exists():
logger.info(dstweight)
weight = invert(
normalize(cv2.imread(str(depthfile), cv2.IMREAD_ANYDEPTH)))
cv2.imwrite(str(dstweight) + '.png', tobytes(weight))
(dst / (name + '.weight.png')).replace(dstweight)
def sign(m, p, q, g, x):
k = utils.randomnumber(q - 1, inf=2)
while True:
r = utils.powmod(g, k, p) % q
if r == 0:
k = utils.randomnumber(q, inf=2)
continue
break
inv = utils.invert(k, q)
h = m + x * r
s = inv * h % q
return r, s
def label(boundary, should_invert=False, param_boundaries=[[0.0, 20.0],
[0,1.0]],
epsilon=0.01, num_points=200, lipschitz_param=0.05):
"""
Takes a boundary, and returns its proper label, which is True or False.
Correct implementation will depend on context, and in the extreme case will
require computation done by the human.
"""
# TODO: add type assertions
if should_invert:
my_boundary = utils.invert(boundary, param_boundaries)
else:
my_boundary = boundary
utils.plot(my_boundary, 'tab:orange', param_boundaries)
print("in the label function")
# print("in the label function, should_invert is", should_invert)
# print("boundary that label is synthesising", my_boundary)
# print(num_points)
xs = [z3.Real('x%d' % i) for i in range(num_points)]
us = [z3.Real('u%d' % i) for i in range(num_points)]
def make_phi(xs, us):
# this basically makes a formula encoding dynamics of a system xs
# controlled by us
formula = True
for i in range(num_points - 1):
formula = z3.And(formula, xs[i+1] == xs[i] + us[i],
# xs[i+1] - xs[i] <= lipschitz_param,
# xs[i] - xs[i+1] <= lipschitz_param,
xs[i] >= 0, xs[i+1] >= 0, xs[i] <= 1, xs[i+1] <= 1)
return formula
trace = bt.trace(my_boundary, epsilon, num_points, xs,
param_boundaries[0][1], make_phi(xs, us))
# print("trace that is being labelled is", trace)
# utils.plot(trace)
class_val = True
for point in trace:
if point[0] >= 10:
class_val = class_val and (point[1] <= (-0.08)*point[0] + 1.8)
return class_val
def bob_round_2(pi, m, alpha, zeta, r, k2, x2, r2, y1, y2, ka_pub, kb_pub, zkp):
n, g = ka_pub
n2 = n * n
rq = r[0] % ecdsa.n
if rq == 0:
print("signature failed, retry")
exit(1)
z2 = utils.invert(k2, ecdsa.n)
x2z2 = (x2 * z2) % ecdsa.n
x3 = utils.randomnumber(pow(ecdsa.n, 5)-1, inf=1)
if not eczkp.pi_verify(pi, r, ecdsa.G, r2, y1, alpha, zeta, zkp, ka_pub):
print "Error: zkp failed"
exit(1)
mu1 = paillier.mult(alpha, m * z2, n2)
mu2 = paillier.mult(zeta, rq * x2z2, n2)
mu3, rnumb = paillier.encrypt(x3 * ecdsa.n, ka_pub)
mu = paillier.add(paillier.add(mu1, mu2, n2), mu3, n2)
muprim, rmuprim = paillier.encrypt(z2, kb_pub)
c = r2
d = ecdsa.G
w1 = ecdsa.G
w2 = y2
m1 = muprim # ENCRYPTED Z2
m2 = mu # ENCRYPTED RESULT
m3 = alpha # ENCRYPTED Z1
m4 = zeta # ENCRYPTED X1Z1
r1 = rmuprim
r2 = rnumb
x1 = z2
x2 = x2z2
x4 = m
x5 = rq
pi2 = eczkp.pi2(c, d, w1, w2, m1, m2, m3, m4, r1, r2, x1, x2, x3, x4, x5, zkp, ka_pub, kb_pub)
if not pi2:
print "Error: zkp failed"
exit(1)
return mu, muprim, pi2
def bob_round_2(pi, m, alpha, zeta, r, k2, x2, r2, y1, y2, ka_pub, kb_pub,
zkpa, zkpb):
n, g = ka_pub
n2 = n * n
rq = r % dsa.Q
N, h1, h2 = zkpa
if rq == 0:
print("signature failed, retry")
z2 = utils.invert(k2, dsa.Q)
x2z2 = (x2 * z2) % dsa.Q
c = x3 = utils.randomnumber(pow(dsa.Q, 5) - 1, inf=1)
if not zkp.pi_verify(pi, r, dsa.G, r2, y1, alpha, zeta, N, h1, h2, ka_pub):
return False
mu1 = paillier.mult(alpha, (m * z2) % dsa.Q, n2)
mu2 = paillier.mult(zeta, (rq * x2z2) % dsa.Q, n2)
mu3, rnumb = paillier.encrypt(c * dsa.Q, ka_pub)
mu = paillier.add(paillier.add(mu1, mu2, n2), mu3, n2)
muprim, rmuprim = paillier.encrypt((m * z2) % dsa.Q, kb_pub)
c = r2
d = dsa.G
w2 = y2
m1 = muprim
m2 = mu
m3 = alpha
m4 = zeta
r1 = rmuprim
r2 = rnumb
x1 = z2
x2 = (rq * x2z2) % dsa.Q
w1 = dsa.G
pi2 = zkp.pi2(m, c, d, w1, w2, m1, m2, m3, m4, r1, r2, x1, x2, x3, zkpb,
ka_pub, kb_pub)
return mu, muprim, pi2
def run(sources,
threshold=1e-6,
open_size=0,
close_size=0,
min_area=0,
expand_size=0,
preview=False):
"""
sources: list of image folders
"""
for source in sources:
path = Path(source)
if not (path / "items.json").exists():
continue
with io.open(path / "items.json") as f:
for (filename, meta) in json.load(f).items():
if not meta['active']:
continue
srcimg = path / filename
srcmask = srcimg.parent / (srcimg.stem + '.mask')
if not srcmask.exists():
continue
logger.info(srcmask)
mask = normalize(cv2.imread(str(srcmask),
cv2.IMREAD_GRAYSCALE))
binarymask = 255 * np.ones(
mask.shape, dtype=np.uint8) * (mask >= threshold)
if close_size > 0:
kernel = cv2.getStructuringElement(
cv2.MORPH_ELLIPSE, (close_size, close_size))
binarymask = cv2.dilate(binarymask, kernel)
binarymask = cv2.erode(binarymask, kernel)
if open_size > 0:
kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE,
(open_size, open_size))
binarymask = cv2.erode(binarymask, kernel)
binarymask = cv2.dilate(binarymask, kernel)
contours_outline = np.zeros(binarymask.shape, np.uint8)
if min_area > 0:
_, contours, hierarchy = cv2.findContours(
binarymask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)
valid = list()
for contour in contours:
area = cv2.contourArea(contour)
if area >= min_area:
valid.append(contour)
binarymask = np.zeros(binarymask.shape, np.uint8)
cv2.drawContours(binarymask, valid, -1, 255, cv2.FILLED)
cv2.drawContours(contours_outline, valid, -1, 255, 2)
if expand_size > 0:
kernel = cv2.getStructuringElement(
cv2.MORPH_ELLIPSE, (expand_size, expand_size))
binarymask = cv2.dilate(binarymask, kernel)
binarymask = normalize(binarymask)
contours_outline = normalize(contours_outline)
if preview:
preview_before = cv2.cvtColor(resizemax(mask, 1600),
cv2.COLOR_GRAY2BGR)
preview_after = cv2.cvtColor(resizemax(binarymask, 1600),
cv2.COLOR_GRAY2BGR)
preview_contours = resizemax(contours_outline, 1600)
preview_after[:, :, 0] = preview_contours
preview_after[:, :, 1] *= invert(preview_contours)
preview_after[:, :, 2] = preview_before[:, :, 0] * invert(
preview_contours)
zeros1 = np.zeros([preview_before.shape[0], 10, 3],
np.float32)
ones1 = np.ones([preview_before.shape[0], 10, 3],
np.float32)
padded1 = np.concatenate([
zeros1, preview_before, zeros1, ones1, zeros1,
preview_after, zeros1
],
axis=1)
zeros2 = np.zeros([10, padded1.shape[1], 3], np.float32)
padded2 = np.concatenate([zeros2, padded1, zeros2], axis=0)
cv2.imshow('cv2: mask', padded2)
key = cv2.waitKey()
while key != ord('q') and key != ord('c'):
key = cv2.waitKey()
if key == ord('q'):
break
else:
cv2.imwrite(str(srcmask) + '.png', tobytes(binarymask))
(srcimg.parent /
(srcimg.stem + '.mask.png')).replace(srcmask)
def decode_packet(self, packet):
raw = packet
kw = {}
if (len(packet) < 56) or (len(packet) > 89):
print "!invalid packet length: ", len(packet)
#return
nibbles = [int(utils.invert(s[::-1]),2) for s in utils.batch_gen(packet,4)]
if len(nibbles) < 14:
#~ logging.info("!invalid nibbles length: %s" % len(nibbles))
return
if len(nibbles) > 24:
pass
# print "!invalid nibbles length: ", len(nibbles)
else:
pass
# print "nibbles len=", len(nibbles)
if nibbles[0] != 10:
# print "!syncrobyte ", hex(nibbles[0]), " does not match 0xa"
return
sensor_type = ((nibbles[1] << 12)+(nibbles[2] << 8)+(nibbles[3] << 4) + nibbles[4])
channel = nibbles[5]
rolling_code = (nibbles[7] << 4) + nibbles[6]
status = nibbles[8]
# print "sensor type: ", hex(sensor_type)[2:], "code: ", hex(rolling_code)[2:], " channel: ", str(channel), "status: ", hex(status)[2:]
if (sensor_type in self.SENSOR_BLOCKTYPE) :
bt = self.SENSOR_BLOCKTYPE.get(sensor_type)
bl = self.BLOCK_LEN.get(bt)
else:
bt = self.BLOCKTYPE_UNKN;
bl = 0
kw['error'] = "Unknown sensor type " + hex(sensor_type)[2:] + "! ";
if (bl != 0) and (bl + 3 < len(nibbles)):
# print "fix message len ", len(nibbles), " to ", bl
del nibbles[bl + 3:]
expected_checksum = sum(nibbles[:-4]) - 0xA
checksum = nibbles[-3] * 16 + nibbles[-4]
#~ print checksum, expected_checksum
if checksum != expected_checksum:
# print "!invalid checksum: ", hex(checksum)[2:], " expected: ", hex(expected_checksum)[2:]
return
else:
# print "checksum matched: ", hex(checksum)[2:]
pass
#TODO: !!! if sensor_type == 1d20 or 1d30 => only 3 channels (bitcoded) change channel 4 to channel 3
kw['raw'] = raw
kw['channel'] = str(channel)
kw['type'] = hex(sensor_type)[2:]
kw['code'] = hex(rolling_code)[2:]
kw['lowbat'] = str(1 if (status & 0b0100) else 0)
kw['forced'] = str(1 if (status & 0b1000) else 0)
if bt == self.BLOCKTYPE_T:
self.decode_temp(nibbles, 9, kw)
elif bt == self.BLOCKTYPE_TH:
self.decode_temp(nibbles, 9, kw)
self.decode_humidity(nibbles, 13, kw)
elif bt == self.BLOCKTYPE_UV:
self.decode_UV(nibbles, 9, kw)
elif bt == self.BLOCKTYPE_UV2:
self.decode_UV(nibbles, 12, kw)
elif bt == self.BLOCKTYPE_W:
self.decode_wind(nibbles, 9, kw)
elif bt == self.BLOCKTYPE_R:
self.decode_rain(nibbles, 9, kw)
elif bt == self.BLOCKTYPE_R2:
self.decode_rain2(nibbles, 9, kw)
elif bt == self.BLOCKTYPE_THB:
self.decode_temp(nibbles, 9, kw)
self.decode_humidity(nibbles, 13, kw)
else:
kw['UNKN'] = 'Ok'
return kw
def create_windows(array_input, window_shape, step):
"""
Creates windows in an array in a given shape (window_shape). The Overlap is defined by the parameter step.
Returns a list of the offset points of the created windows that pass the threshold (Checkbox or Slice).
In this function the step_size equals the checkbox_size.
:type step: tuple or int
:type window_shape: tuple or int
:type array_input: ndarray
"""
from utils import invert
import numpy as np
from skimage.util import view_as_windows
"""Check the binary image"""
numberOfValues = np.unique(array_input, return_counts=True)
if numberOfValues[1][1] > numberOfValues[1][0]:
pass
else:
array_input = invert(array_input)
"""changes the values to 0 and 1 instead of 0 and 255"""
array_input[array_input == 0] = 1
array_input[array_input == 255] = 0
listCoordinates = []
new_array = view_as_windows(array_input, window_shape, step=step)
"""Check the dimensions of the array"""
if array_input.ndim == 2:
n = window_shape[0]
m = window_shape[1]
if type(step) == tuple:
stepY = step[0]
stepX = step[1]
if type(step) == int:
stepX = step
stepY = step
"""Iterating over the windows of new_array"""
for y in range(new_array.shape[0]):
for x in range(new_array.shape[1]):
window = new_array[y, x]
"""Creating the central slice of the window"""
OffSetSliceY = np.uint8((n - stepY) / 2)
OffSetSliceX = np.uint8((m - stepX) / 2)
SliceOfWindow = window[OffSetSliceY:OffSetSliceY + stepY, OffSetSliceX:OffSetSliceX + stepX]
"""Threshold"""
sumSlice = np.sum(SliceOfWindow, axis=(0, 1))
if sumSlice >= min(SliceOfWindow.shape[0], SliceOfWindow.shape[1]):
listCoordinates.append((y * stepY, x * stepX))
if array_input.ndim == 3:
k = window_shape[0]
n = window_shape[1]
m = window_shape[2]
if type(step) == tuple:
stepZ = step[0]
stepY = step[1]
stepX = step[2]
if type(step) == int:
stepZ = step
stepX = step
stepY = step
"""Iterating over the windows of new_array"""
for z in range(new_array.shape[0]):
for y in range(new_array.shape[1]):
for x in range(new_array.shape[2]):
window = new_array[z, y, x]
"""Creating the central slice of the window"""
OffSetSliceZ = np.uint8((k - stepZ) / 2)
OffSetSliceY = np.uint8((n - stepY) / 2)
OffSetSliceX = np.uint8((m - stepX) / 2)
SliceOfWindow = window[OffSetSliceZ:OffSetSliceZ + stepZ, OffSetSliceY:OffSetSliceY + stepY,
OffSetSliceX:OffSetSliceX + stepX]
"""Threshold"""
sumSlice = np.sum(SliceOfWindow, axis=(0, 1, 2))
if sumSlice >= min(SliceOfWindow.shape[0], SliceOfWindow.shape[1], SliceOfWindow.shape[2]):
listCoordinates.append((z * stepZ, y * stepY, x * stepX))
"""Changing the values back to 0 and 255"""
array_input[array_input == 0] = 255
array_input[array_input == 1] = 0
return listCoordinates
def create_windows_slice_nth(array_input, window_shape, step, checkbox_shape, nth):
"""
Same as create_windows function, but the checkbox_shape does not depend on the step_size.
:type checkbox_shape: tuple
:type step: tuple or int
:type window_shape: tuple or int
:type array_input: ndarray
"""
from utils import invert
import numpy as np
from skimage.util import view_as_windows
"""Check the binary image"""
numberOfValues = np.unique(array_input, return_counts=True)
if numberOfValues[1][1] > numberOfValues[1][0]:
pass
else:
array_input = invert(array_input)
"""changes the values to 0 and 1 instead of 0 and 255"""
array_input[array_input == 0] = 1
array_input[array_input == 255] = 0
listCoordinates = []
new_array = view_as_windows(array_input, window_shape, step=step)
"""Check the dimensions of the array"""
if array_input.ndim == 2:
n = window_shape[0]
m = window_shape[1]
if type(step) == tuple:
stepY = step[0]
stepX = step[1]
if type(step) == int:
stepX = step
stepY = step
"""Iterating over the windows of new_array"""
for y in range(0, new_array.shape[0], nth):
for x in range(0, new_array.shape[1], nth):
window = new_array[y, x]
"""Creating the central slice of the window"""
OffSetSliceY = np.uint8((n - checkbox_shape[0]) / 2)
OffSetSliceX = np.uint8((m - checkbox_shape[1]) / 2)
SliceOfWindow = window[OffSetSliceY:OffSetSliceY + checkbox_shape[0],
OffSetSliceX:OffSetSliceX + checkbox_shape[1]]
"""Threshold"""
sumSlice = np.sum(SliceOfWindow, axis=(0, 1))
if sumSlice >= min(SliceOfWindow.shape[0], SliceOfWindow.shape[1]):
listCoordinates.append((y * stepY, x * stepX))
if array_input.ndim == 3:
k = window_shape[0]
n = window_shape[1]
m = window_shape[2]
if type(step) == tuple:
stepZ = step[0]
stepY = step[1]
stepX = step[2]
if type(step) == int:
stepZ = step
stepX = step
stepY = step
"""Iterating over the windows of new_array"""
for z in range(0, new_array.shape[0], nth):
for y in range(0, new_array.shape[1], nth):
for x in range(0, new_array.shape[2], nth):
window = new_array[z, y, x]
"""Creating the central slice of the window"""
OffSetSliceZ = np.uint8((k - checkbox_shape[0]) / 2)
OffSetSliceY = np.uint8((n - checkbox_shape[1]) / 2)
OffSetSliceX = np.uint8((m - checkbox_shape[2]) / 2)
SliceOfWindow = window[OffSetSliceZ:OffSetSliceZ + checkbox_shape[0],
OffSetSliceY:OffSetSliceY + checkbox_shape[1],
OffSetSliceX:OffSetSliceX + checkbox_shape[2]]
"""Threshold"""
sumSlice = np.sum(SliceOfWindow, axis=(0, 1, 2))
if sumSlice >= min(SliceOfWindow.shape[0], SliceOfWindow.shape[1], SliceOfWindow.shape[2]):
listCoordinates.append((z * stepZ, y * stepY, x * stepX))
"""Changing the values back to 0 and 255"""
array_input[array_input == 0] = 255
array_input[array_input == 1] = 0
return listCoordinates
def alice_round_1(m, x1, y1, ka_pub, ka_priv):
k1 = utils.randomnumber(dsa.Q - 1, inf=2)
z1 = utils.invert(k1, dsa.Q)
alpha, r1 = paillier.encrypt(z1, ka_pub)
zeta, r2 = paillier.encrypt(x1 * z1 % dsa.Q, ka_pub)
return k1, z1, alpha, zeta, r1, r2
def decode_packet(self, packet):
raw = packet
kw = {}
if (len(packet) < 56) or (len(packet) > 89):
print "!invalid packet length: ", len(packet)
#return
nibbles = [
int(utils.invert(s[::-1]), 2) for s in utils.batch_gen(packet, 4)
]
if len(nibbles) < 14:
#~ logging.info("!invalid nibbles length: %s" % len(nibbles))
return
if len(nibbles) > 24:
pass
# print "!invalid nibbles length: ", len(nibbles)
else:
pass
# print "nibbles len=", len(nibbles)
if nibbles[0] != 10:
# print "!syncrobyte ", hex(nibbles[0]), " does not match 0xa"
return
sensor_type = ((nibbles[1] << 12) + (nibbles[2] << 8) +
(nibbles[3] << 4) + nibbles[4])
channel = nibbles[5]
rolling_code = (nibbles[7] << 4) + nibbles[6]
status = nibbles[8]
# print "sensor type: ", hex(sensor_type)[2:], "code: ", hex(rolling_code)[2:], " channel: ", str(channel), "status: ", hex(status)[2:]
if (sensor_type in self.SENSOR_BLOCKTYPE):
bt = self.SENSOR_BLOCKTYPE.get(sensor_type)
bl = self.BLOCK_LEN.get(bt)
else:
bt = self.BLOCKTYPE_UNKN
bl = 0
kw['error'] = "Unknown sensor type " + hex(sensor_type)[2:] + "! "
if (bl != 0) and (bl + 3 < len(nibbles)):
# print "fix message len ", len(nibbles), " to ", bl
del nibbles[bl + 3:]
expected_checksum = sum(nibbles[:-4]) - 0xA
checksum = nibbles[-3] * 16 + nibbles[-4]
#~ print checksum, expected_checksum
if checksum != expected_checksum:
# print "!invalid checksum: ", hex(checksum)[2:], " expected: ", hex(expected_checksum)[2:]
return
else:
# print "checksum matched: ", hex(checksum)[2:]
pass
#TODO: !!! if sensor_type == 1d20 or 1d30 => only 3 channels (bitcoded) change channel 4 to channel 3
kw['raw'] = raw
kw['channel'] = str(channel)
kw['type'] = hex(sensor_type)[2:]
kw['code'] = hex(rolling_code)[2:]
kw['lowbat'] = str(1 if (status & 0b0100) else 0)
kw['forced'] = str(1 if (status & 0b1000) else 0)
if bt == self.BLOCKTYPE_T:
self.decode_temp(nibbles, 9, kw)
elif bt == self.BLOCKTYPE_TH:
self.decode_temp(nibbles, 9, kw)
self.decode_humidity(nibbles, 13, kw)
elif bt == self.BLOCKTYPE_UV:
self.decode_UV(nibbles, 9, kw)
elif bt == self.BLOCKTYPE_UV2:
self.decode_UV(nibbles, 12, kw)
elif bt == self.BLOCKTYPE_W:
self.decode_wind(nibbles, 9, kw)
elif bt == self.BLOCKTYPE_R:
self.decode_rain(nibbles, 9, kw)
elif bt == self.BLOCKTYPE_R2:
self.decode_rain2(nibbles, 9, kw)
elif bt == self.BLOCKTYPE_THB:
self.decode_temp(nibbles, 9, kw)
self.decode_humidity(nibbles, 13, kw)
else:
kw['UNKN'] = 'Ok'
return kw
def loadKey(self, table): self.e_table = table self.e_transform = utils.mkTransform(self.e_table) self.d_table = utils.invert(self.e_table) self.d_transform = utils.mkTransform(self.d_table) self.key = json.dumps(self.e_table)
h.update(message.encode("utf-8"))
m = long(h.hexdigest(), 16)
sig = sign(m, G, n, priv)
print(sig)
print(verify(sig, m, pub, G, n))
h.update("an other one".encode("utf-8"))
m = long(h.hexdigest(), 16)
print(verify(sig, m, pub, G, n))
if __name__ == "__main__":
print("ECDSA")
# test()
# run_ecdsa()
k1 = utils.randomnumber(n-1, inf=1)
z1 = utils.invert(k1, n)
k2 = utils.randomnumber(n-1, inf=1)
z2 = utils.invert(k2, n)
r2 = point_mult(G, k2)
r = point_mult(r2, k1)
r1 = point_mult(r, z1)
print r2
print r
print r1
def __init__(self, table, preserveAll=False): self.preserveAll = preserveAll self.e_table = table self.e_transform = utils.mkTransform(table) self.d_table = utils.invert(table) self.d_transform = utils.mkTransform(self.d_table)