def testInt(self):
num = np.int(2562010)
self.assertEqual(np.int(ujson.decode(ujson.encode(num))), num)
num = np.int8(127)
self.assertEqual(np.int8(ujson.decode(ujson.encode(num))), num)
num = np.int16(2562010)
self.assertEqual(np.int16(ujson.decode(ujson.encode(num))), num)
num = np.int32(2562010)
self.assertEqual(np.int32(ujson.decode(ujson.encode(num))), num)
num = np.int64(2562010)
self.assertEqual(np.int64(ujson.decode(ujson.encode(num))), num)
num = np.uint8(255)
self.assertEqual(np.uint8(ujson.decode(ujson.encode(num))), num)
num = np.uint16(2562010)
self.assertEqual(np.uint16(ujson.decode(ujson.encode(num))), num)
num = np.uint32(2562010)
self.assertEqual(np.uint32(ujson.decode(ujson.encode(num))), num)
num = np.uint64(2562010)
self.assertEqual(np.uint64(ujson.decode(ujson.encode(num))), num)
def testIntMax(self):
num = np.int(np.iinfo(np.int).max)
self.assertEqual(np.int(ujson.decode(ujson.encode(num))), num)
num = np.int8(np.iinfo(np.int8).max)
self.assertEqual(np.int8(ujson.decode(ujson.encode(num))), num)
num = np.int16(np.iinfo(np.int16).max)
self.assertEqual(np.int16(ujson.decode(ujson.encode(num))), num)
num = np.int32(np.iinfo(np.int32).max)
self.assertEqual(np.int32(ujson.decode(ujson.encode(num))), num)
num = np.uint8(np.iinfo(np.uint8).max)
self.assertEqual(np.uint8(ujson.decode(ujson.encode(num))), num)
num = np.uint16(np.iinfo(np.uint16).max)
self.assertEqual(np.uint16(ujson.decode(ujson.encode(num))), num)
num = np.uint32(np.iinfo(np.uint32).max)
self.assertEqual(np.uint32(ujson.decode(ujson.encode(num))), num)
if platform.architecture()[0] != '32bit':
num = np.int64(np.iinfo(np.int64).max)
self.assertEqual(np.int64(ujson.decode(ujson.encode(num))), num)
# uint64 max will always overflow as it's encoded to signed
num = np.uint64(np.iinfo(np.int64).max)
self.assertEqual(np.uint64(ujson.decode(ujson.encode(num))), num)
def getMarkupTab(image):
#fallback margin size approximation so we can exit
left = 0
top = 0
height, width = image.shape[:2]
print "{width} x {height}".format(width=width, height=height)
## Iterate over the width then by height until we find a pixel red enough to make a decision
for x in xrange(width):
for y in xrange(height):
# Check individual pixel values
pixel = image[y,x]
b, g, r = pixel
temp_gb = np.uint16(g) + np.uint16(b)
# Checking the green blue and red threshold values
if r > 200 and temp_gb < 320:
return image[ top : height, left : x]
return None
def wire_value(token, solved_wires):
if str.isdigit(token):
return uint16(token)
elif token in solved_wires.keys():
return uint16(solved_wires.get(token))
else:
return None
def test_valid(self):
prop = bcpp.Int()
assert prop.is_valid(None)
assert prop.is_valid(0)
assert prop.is_valid(1)
assert prop.is_valid(np.int8(0))
assert prop.is_valid(np.int8(1))
assert prop.is_valid(np.int16(0))
assert prop.is_valid(np.int16(1))
assert prop.is_valid(np.int32(0))
assert prop.is_valid(np.int32(1))
assert prop.is_valid(np.int64(0))
assert prop.is_valid(np.int64(1))
assert prop.is_valid(np.uint8(0))
assert prop.is_valid(np.uint8(1))
assert prop.is_valid(np.uint16(0))
assert prop.is_valid(np.uint16(1))
assert prop.is_valid(np.uint32(0))
assert prop.is_valid(np.uint32(1))
assert prop.is_valid(np.uint64(0))
assert prop.is_valid(np.uint64(1))
# TODO (bev) should fail
assert prop.is_valid(False)
assert prop.is_valid(True)
def save(self, fname):
with open(fname, "w") as f:
np.uint16(self.location).tofile(f)
np.uint16(len(self.stack)).tofile(f)
np.array(self.stack, dtype=np.uint16).tofile(f)
self.register.tofile(f)
self.memory.tofile(f)
def _combine_bytes(msb, lsb):
msb = np.uint16(msb)
lsb = np.uint16(lsb)
value = (msb << 8) | lsb
return np.int16(value) / 900
def encode_color(grey_left, grey_right):
"""
encodes the two grey values from two corresponding pixels in
one color value.
grey_left, grey_right must be integer between 0 and 1023 or castable to it.
returns tuple of r,g,b as integer between 0 and 255.
>>> encode_color(0, 0)
(0, 0, 0)
>>> encode_color(1020, 0)
(0, 255, 0)
"""
# store most significant bits of grey_left in green
green = np.uint16(grey_left/4)
# store most significant bits of grey_right in red
red = np.uint16(grey_right/4)
# store least significant two bits in correct blue bits
# for left it has to be in the 5th and 6th bit
# for right it has to be in the 1st and 2nd bit
blue = np.uint16((grey_left % 4)*16 + (grey_right % 4)*1)
return( (green, red, blue) )
def write_sequence_file(awgData, fileName, miniLLRepeat=1):
'''
Main function to pack channel LLs into an APS h5 file.
'''
#Preprocess the sequence data to handle APS restrictions
LLs12, repeat12, wfLib12 = preprocess(awgData['ch12']['linkList'],
awgData['ch12']['wfLib'],
awgData['ch12']['correctionT'])
LLs34, repeat34, wfLib34 = preprocess(awgData['ch34']['linkList'],
awgData['ch34']['wfLib'],
awgData['ch34']['correctionT'])
assert repeat12 == repeat34, 'Failed to unroll sequence'
if repeat12 != 0:
miniLLRepeat *= repeat12
#Merge the the marker data into the IQ linklists
merge_APS_markerData(LLs12, awgData['ch1m1']['linkList'], 1)
merge_APS_markerData(LLs12, awgData['ch2m1']['linkList'], 2)
merge_APS_markerData(LLs34, awgData['ch3m1']['linkList'], 1)
merge_APS_markerData(LLs34, awgData['ch4m1']['linkList'], 2)
#Open the HDF5 file
if os.path.isfile(fileName):
os.remove(fileName)
with h5py.File(fileName, 'w') as FID:
#List of which channels we have data for
#TODO: actually handle incomplete channel data
channelDataFor = [1,2] if LLs12 else []
channelDataFor += [3,4] if LLs34 else []
FID['/'].attrs['Version'] = 2.1
FID['/'].attrs['channelDataFor'] = np.uint16(channelDataFor)
FID['/'].attrs['miniLLRepeat'] = np.uint16(miniLLRepeat - 1)
#Create the waveform vectors
wfInfo = []
for wfLib in (wfLib12, wfLib34):
wfInfo.append(create_wf_vector({key:wf.real for key,wf in wfLib.items()}))
wfInfo.append(create_wf_vector({key:wf.imag for key,wf in wfLib.items()}))
LLData = [LLs12, LLs34]
repeats = [0, 0]
#Create the groups and datasets
for chanct in range(4):
chanStr = '/chan_{0}'.format(chanct+1)
chanGroup = FID.create_group(chanStr)
chanGroup.attrs['isIQMode'] = np.uint8(1)
#Write the waveformLib to file
FID.create_dataset('{0}/waveformLib'.format(chanStr), data=wfInfo[chanct][0])
#For A channels (1 & 3) we write link list data if we actually have any
if (np.mod(chanct,2) == 0) and LLData[chanct//2]:
groupStr = chanStr+'/linkListData'
LLGroup = FID.create_group(groupStr)
LLDataVecs, numEntries = create_LL_data(LLData[chanct//2], wfInfo[chanct][1], os.path.basename(fileName))
LLGroup.attrs['length'] = numEntries
for key,dataVec in LLDataVecs.items():
FID.create_dataset(groupStr+'/' + key, data=dataVec)
else:
chanGroup.attrs['isLinkListData'] = np.uint8(0)
def read_calibration_data(self):
# Read calibration data
self.AC1 = numpy.int16(self.read_word(self.BMP183_REG['CAL_AC1']))
self.AC2 = numpy.int16(self.read_word(self.BMP183_REG['CAL_AC2']))
self.AC3 = numpy.int16(self.read_word(self.BMP183_REG['CAL_AC3']))
self.AC4 = numpy.uint16(self.read_word(self.BMP183_REG['CAL_AC4']))
self.AC5 = numpy.uint16(self.read_word(self.BMP183_REG['CAL_AC5']))
self.AC6 = numpy.uint16(self.read_word(self.BMP183_REG['CAL_AC6']))
self.B1 = numpy.int16(self.read_word(self.BMP183_REG['CAL_B1']))
self.B2 = numpy.int16(self.read_word(self.BMP183_REG['CAL_B2']))
self.MB = numpy.int16(self.read_word(self.BMP183_REG['CAL_MB']))
self.MC = numpy.int16(self.read_word(self.BMP183_REG['CAL_MC']))
self.MD = numpy.int16(self.read_word(self.BMP183_REG['CAL_MD']))
self.ID = numpy.int16(self.read_byte(self.BMP183_REG['ID']))
print "CALIBRATION DATA"
print "AC1: {0}".format(self.AC1)
print "AC2: {0}".format(self.AC2)
print "AC3: {0}".format(self.AC3)
print "AC4: {0}".format(self.AC4)
print "AC5: {0}".format(self.AC5)
print "B1: {0}".format(self.B1)
print "B2: {0}".format(self.B2)
print "MB: {0}".format(self.MB)
print "MC: {0}".format(self.MC)
print "MD: {0}".format(self.MD)
print "ID: {0}".format(self.ID)
print ""
def oldmovie(src, dst):
graph = Image.open(src)
mask = Image.open('PhotoManager/Library/mask.png')
size = graph.size
width = size[0]
height = size[1]
mask = mask.resize((width, height))
mask = ny.uint16(ny.array(mask))
result = ny.uint16(ny.array(graph))
b = 10
g = 130
r = 200
gray = 0
for row in range(height):
for col in range(width):
gray = (result[row, col, 0] + result[row, col, 1] + result[row, col, 2]) / 3
b = mode(gray, b)
g = mode(gray, g)
r = mode(gray, r)
result[row, col, 0] = mode(b, mask[row, col, 0])
result[row, col, 1] = mode(g, mask[row, col, 1])
result[row, col, 2] = mode(r, mask[row, col, 2])
result = Image.fromarray(ny.uint8(result)).convert('RGB')
result.save(dst)
return 0
def identify(self):
# get the current byte at pc
rom_instruction = True
self.instruction_byte = self._get_memory_owner(self.pc_reg).get(self.pc_reg)
if type(self.instruction_byte) is not bytes:
rom_instruction = False
self.instruction_byte = bytes([self.instruction_byte])
# turn the byte into an Instruction
self.instruction = self.instructions.get(self.instruction_byte, None) # type: Instruction
if self.instruction is None:
raise Exception('Instruction not found: {}'.format(self.instruction_byte.hex()))
# get the data bytes
if rom_instruction:
self.data_bytes = self.rom.get(self.pc_reg + np.uint16(1), self.instruction.data_length)
else:
if self.instruction.data_length > 0:
self.data_bytes = bytes([self.get_memory(self.pc_reg + np.uint16(1), self.instruction.data_length)])
else:
self.data_bytes = bytes()
# print out diagnostic information
# example: C000 4C F5 C5 JMP $C5F5 A:00 X:00 Y:00 P:24 SP:FD CYC: 0
print('{}, {}, {}, A:{}, X:{}, Y:{}, P:{}, SP:{}'.format(hex(self.pc_reg),
(self.instruction_byte + self.data_bytes).hex(),
self.instruction.__name__, hex(self.a_reg),
hex(self.x_reg), hex(self.y_reg),
hex(self.status_reg.to_int()), hex(self.sp_reg)))
def save(self, file_name):
'''
Save data to a binary file and flush output buffer
:param file_name:
'''
# Start of writing
try:
fid = open(file_name, 'wb')
except IOError:
print 'Can''t create file: {0}'.format(file_name)
return
# Write options to binary file
fid.write('fc')
fid.write(numpy.uint8([1, 0]))
fid.write(numpy.uint16(self.option.width))
fid.write(numpy.uint16(self.option.height))
fid.write(numpy.uint16(self.option.rank_size))
fid.write(numpy.uint16(self.option.min_rank_size))
fid.write(numpy.uint8(self.option.dom_step))
# Write main data to binary file
data_ln = numpy.uint32(numpy.ceil(self.cur_bit / 8.0))
fid.write(data_ln)
fid.write(self.out_buf[: (data_ln / 2)])
# End of writing and clear output buffer
fid.close()
del self.out_buf
def quantization(img, channels, r_bits=8, g_bits=8, b_bits=8):
img_out = None
if r_bits == 8 and r_bits == g_bits and r_bits == b_bits:
return img
if r_bits <= 16 and g_bits <= 16 and b_bits <= 16:
if r_bits < 8 or g_bits < 8 or b_bits < 8:
img_out = mediancut_algorithm(np_to_pil(img), 2 ** (r_bits+ g_bits + b_bits), np.array((r_bits, g_bits, b_bits)), channels)
else:
height = np.size(img,0)
width = np.size(img,1)
img_out = np.zeros(shape=img.shape, dtype=np.uint16)
for i in range (height):
for j in range (width):
if channels == 1:
aux = np.int(img[i][j]) / 255
img_out[i][j] = aux * ( 2 ** r_bits )
elif channels == 3:
r_aux = np.float(img[i][j][0]) / 255
g_aux = np.float(img[i][j][1]) / 255
b_aux = np.float(img[i][j][2]) / 255
new_r = np.uint16(r_aux * ( 2 ** r_bits ))
new_g = np.uint16(g_aux * ( 2 ** g_bits ))
new_b = np.uint16(b_aux * ( 2 ** b_bits ))
img_out[i, j] = np.array((new_r, new_g, new_b))
return img_out
def initialize(data, mode):
# mapping index to user name and book isbn
n = len(data)
p = len(user_list) + len(book_list)
x = ss.lil_matrix((n, p), dtype=np.uint16)
y = np.zeros((n, 1), dtype=np.float)
for row, entry in enumerate(data):
user = entry["user"]
isbn = entry["isbn"]
user_i = id_i[user]
isbn_i = id_i[isbn]
x[row, user_i] = np.uint16(1)
x[row, isbn_i] = np.uint16(1)
if mode == "train":
rating = entry["rating"]
y[row] = np.float(rating)
if mode == "train":
y -= train_mean
x = ss.csc_matrix(x)
# xtx = x.transpose().dot(x)
# xty = x.transpose().dot(y)
return x, y
else:
return x
def initialize(data):
# mapping index to user name and book isbn
n = len(data); p = len(user_list) + len(book_list)
x = ss.lil_matrix((n,p), dtype = np.uint16)
y = np.zeros((n,1), dtype = np.float)
row = 0
counter = 0
for entry in data:
counter += 1
if counter % 10000 == 0:
print int(counter/n * 100)
user = entry['user']; isbn = entry['isbn']; rating = entry['rating']
user_i = id_i[user]; isbn_i = id_i[isbn]
x[row, user_i] = np.uint16(1)
x[row, isbn_i] = np.uint16(1)
y[row] = np.float(rating)
row += 1
y -= global_mean
x = ss.csc_matrix(x)
#xtx = x.transpose().dot(x)
#xty = x.transpose().dot(y)
return x, y
def galois_lfsr(seed, taps):
seed = np.uint16(seed)
taps = np.uint16(taps)
start_state = np.uint16(seed) # Any nonzero start state will work
arg = "start_state \t\t%s" % bin(start_state)
print(arg)
lf_state_register = np.uint16(start_state)
period = 0
bit_sequence = []
while True:
lsb = lf_state_register & 1 # /* Get LSB (i.e., the output bit). */
bit_sequence.append(lsb)
lf_state_register >>= 1 # /* Shift register */
lf_state_register ^= (-lsb) & taps # /* If the output bit is 1, apply toggle mask.
# * The value has 1 at bits corresponding
# * to taps, 0 elsewhere. */
period += 1
# arg = "lf_state_register \t%s" % bin(lf_state_register)
# print(arg)
if lf_state_register == start_state:
break
# arg = "bit_sequence[0] %s" % bit_sequence[0]
# print(arg)
# arg = "bit_sequence[1] %s" % bit_sequence[1]
# print(arg)
return bit_sequence
def pack_waveform(analog, marker1, marker2):
'''
Helper function to convert a floating point analog channel and two logical marker channel to a sequence of 16bit integers.
AWG 5000 series binary data format
m2 m1 d14 d13 d12 d11 d10 d9 d8 d7 d6 d5 d4 d3 d2 d1
16-bit format with markers occupying left 2 bits followed by the 14 bit
analog channel value
'''
#Convert decimal shape on [-1,1] to binary on [0,2^14 (16383)]
#AWG actually makes 111,111,111,111,10 the 100% output, and
# 111,111,111,111,11 is one step larger than 100% output so we
# ignore the one extra positive number and scale from [0,16382]
analog[analog>1] = 1.0
analog[analog<-1] = -1.0
maxLength = max(analog.size, marker1.size, marker2.size)
if marker1.size < maxLength:
marker1 = np.append(marker1, np.zeros(maxLength-marker1.size, dtype=np.bool))
if marker2.size < maxLength:
marker2 = np.append(marker2, np.zeros(maxLength-marker2.size, dtype=np.bool))
if analog.size < maxLength:
analog = np.append(analog, np.zeros(maxLength-analog.size, dtype=np.float64))
binData = np.uint16( MAX_WAVEFORM_VALUE*analog + MAX_WAVEFORM_VALUE );
binData += 2**14*np.uint16(marker1) + 2**15*np.uint16(marker2)
return binData
def get_bits(self, b):
nb = numpy.uint8(b) # bit8
#
num_word = numpy.uint32(self.cur_bit) # bit32
nbit_on_word = numpy.uint8(num_word - ((num_word >> 4) << 4)) # bit8
num_word = num_word >> 4
nbit_on_sword = numpy.uint8(0) # bit8
#
rtail = 16 - numpy.int8(nbit_on_word + nb)
if rtail < 0:
nbit_on_sword = numpy.uint8(abs(rtail))
rtail = 0
#
if num_word < len(self.out_buf):
left_p = numpy.uint16((self.out_buf[num_word] << nbit_on_word) >> (nbit_on_word + rtail)) # bit16
else:
left_p = numpy.uint16(0)
if (num_word + 1) < len(self.out_buf):
right_p = numpy.uint16(self.out_buf[num_word + 1] >> (16 - nbit_on_sword)) # bit16
else:
right_p = numpy.uint16(0)
#
left_p <<= nbit_on_sword
#
self.cur_bit += b
return left_p + right_p
def mpl_Hough(csv_head, img, gray, png_x, png_y, hot_r, png_ruler, lowThreshold, higThreshold):
min_Dist, sml_Radius, big_Radius = hot_R_Hough(hot_r, png_ruler)
circles1 = cv2.HoughCircles(gray,cv2.HOUGH_GRADIENT ,1,
minDist=min_Dist,param1=lowThreshold,param2=higThreshold,
minRadius=sml_Radius,maxRadius=big_Radius)
img0 = np.array(img)
w, h = gray.shape
line_x = np.uint16(round(png_x))
line_y = np.uint16(round(png_y))
cv2.line(img0,(line_x,0),(line_x,h),(255,0,0),2)
cv2.line(img0,(0,line_y),(w,line_y),(255,0,0),2)
if circles1 is None:
cv2.imshow('mpl_Hough',img0)
return 0,0,0,0
else:
circles = circles1[0,:,:]#三维提取为二维,非常易出Bug，返回值为NoneType或数组
png_x, png_y, png_r = select_Hot_Spot(circles,png_x,png_y)
circles = np.uint16(np.around(circles))#四舍五入，取整
for i in circles[:]:
cv2.circle(img0,(i[0],i[1]),i[2],(0,0,255),2)#画圆
cv2.circle(img0,(i[0],i[1]),2,(0,0,255),2)#画圆心
box_x0, box_y0, box_x1, box_y1 = lock_Box_Draw(png_x, png_y, png_r)
cv2.rectangle(img0,(box_x0,box_y0),(box_x1,box_y1),(0,255,0),2)
pzt_x, pzt_y = pngXY_to_pztXY(csv_head, gray, png_x, png_y)
font = cv2.FONT_HERSHEY_SIMPLEX
cv2.putText(img0,"({:.2f}, {:.2f})".format(pzt_x, pzt_y),(10,30), font, 0.8,(255,255,255),2)
cv2.imshow('mpl_Hough',img0)
return 1, png_x, png_y, png_r #浮点像素坐标值
def load_lyrics(lyrics_file, tids):
lyrics = {}
# Enable fast lookup (hash based) of tids
tids = set(tids)
# Read in the list of terms at the beginning of the file
with open(lyrics_file, 'r') as f:
for line in f:
if line == '' or line.strip() == '':
continue
if line[0] in ('%'):
lyrics['terms'] = line.strip()[1:].split(',')
break
# Figure out the unstemmed versions of all the terms (note that this will
# not necessarily recover the originals since multiple words can be converted
# to the same stem)
stemmed_to_unstemmed = pd.read_csv('musicXmatch/mxm_reverse_mapping.txt',sep='<SEP>',header=None,index_col=0,names=['unstemmed'])
lyrics['unstemmed_terms'] = stemmed_to_unstemmed.loc[lyrics['terms']].unstemmed.values
# tdm = pd.read_csv(lyrics_file, skiprows=18, nrows=1000)
tdm = np.zeros([len(tids),len(lyrics['terms'])], dtype=np.uint32)
lyrics['track_id'] = []
start = time.time()
with open(lyrics_file, 'r') as f:
cnt_lines = 0
for line in f:
if line == '' or line.strip() == '':
continue
if line[0] in ('#', '%'):
continue
lineparts = re.split(r"[:,]",line)
tid = lineparts[0]
if not (tid in tids):
continue
indices = np.uint16(lineparts[2::2])
counts = np.uint16(lineparts[3::2])
tdm[cnt_lines,indices-1] = counts
#
lyrics['track_id'].append(lineparts[0])
#
# for wordcnt in lineparts[2:]:
# wordid, cnt = wordcnt.split(':')
# tdm[cnt_lines,int(wordid)-1] = int(cnt)
# print "%s\t%s" % (wordid,cnt) indices =
cnt_lines += 1
if cnt_lines % 1000 == 0:
print (time.time() - start) / 60.
print 'Done with %d tracks.' % cnt_lines
lyrics['tdm'] = scipy.sparse.csr_matrix(tdm)
print (time.time() - start) / 60.
return lyrics
def whiteDensity(image,ellipse): ((x,y),(h,w),a) = ellipse xi,xf = np.uint16(x - w/2), np.uint16(x + w/2) yi,yf = np.uint16(y - h/2), np.uint16(y + h/2) m = np.asarray(image[yi:yf,xi:xf]) m = m.astype(np.bool) return np.divide(np.sum(m), (w * h))
def convertStringToHex(hexString,modifier):
immediate = hexString.replace(" ","")
if(modifier=="n"):
return np.uint32(int(immediate,16))
elif (modifier=='u'):
return np.uint32(np.uint16(int(immediate,16)))
elif (modifier=='h'):
return np.uint32(np.uint16(int(immediate,16))<<16)
def crc_xmodem(self, crc, data):
crc = np.uint16(crc ^ (data << 8))
for i in range(0, 8):
if crc & 0x8000:
crc = np.uint16((crc << 1) ^ 0x1021)
else:
crc = np.uint16(crc << 1)
return crc
def rotate_image( a, resize = 1.5, angle = 180., interpolation = "linear", blocks = (16,16,1) ):
"""
Rotates the array. The new array has the new size and centers the
picture in the middle.
a - array (2-dim)
resize - new_image w/old_image w
angle - degrees to rotate the image
interpolation - "linear" or None
blocks - given to the kernel when run
returns: a new array with dtype=uint8 containing the rotated image
"""
angle = angle/180. *pi
# Convert this image to float. Unsigned int texture gave
# strange results for me. This conversion is slow though :(
a = a.astype("float32")
# Calculate the dimensions of the new image
calc_x = lambda (x,y): (x*a.shape[1]/2.*cos(angle)-y*a.shape[0]/2.*sin(angle))
calc_y = lambda (x,y): (x*a.shape[1]/2.*sin(angle)+y*a.shape[0]/2.*cos(angle))
xs = [ calc_x(p) for p in [ (-1.,-1.),(1.,-1.),(1.,1.),(-1.,1.) ] ]
ys = [ calc_y(p) for p in [ (-1.,-1.),(1.,-1.),(1.,1.),(-1.,1.) ] ]
new_image_dim = (
int(numpy.ceil(max(ys)-min(ys))*resize),
int(numpy.ceil(max(xs)-min(xs))*resize),
)
# Now generate the cuda texture
cuda.matrix_to_texref(a, texref, order="C")
# We could set the next if we wanted to address the image
# in normalized coordinates ( 0 <= coordinate < 1.)
# texref.set_flags(cuda.TRSF_NORMALIZED_COORDINATES)
if interpolation == "linear":
texref.set_filter_mode(cuda.filter_mode.LINEAR)
# Calculate the gridsize. This is entirely given by the size of our image.
gridx = new_image_dim[0]/blocks[0] if \
new_image_dim[0]%blocks[0]==1 else new_image_dim[0]/blocks[0] +1
gridy = new_image_dim[1]/blocks[1] if \
new_image_dim[1]%blocks[1]==0 else new_image_dim[1]/blocks[1] +1
# Get the output image
output = numpy.zeros(new_image_dim,dtype="uint8")
# Call the kernel
copy_texture_func(
numpy.float32(resize), numpy.float32(angle),
numpy.uint16(a.shape[1]), numpy.uint16(a.shape[0]),
numpy.uint16(new_image_dim[1]), numpy.uint16(new_image_dim[0]),
cuda.Out(output),texrefs=[texref],block=blocks,grid=(gridx,gridy))
return output
def saveTiff(self, drappingMain):
rasterPath = QFileDialog.getSaveFileName(drappingMain,"save file dialog" ,"/ortho.tiff","Images (*.tiff)")
maskedOrtho = self.ortho
pointRaster = self.pointRaster
im = self.image
if rasterPath:
cols = pointRaster.RasterXSize
rows = pointRaster.RasterYSize
geoTrans = pointRaster.GetGeoTransform()
geoTrans = list(geoTrans)
x_min = geoTrans[0]
pixelWidth = geoTrans[1]
y_min = geoTrans[3]
pixelHeight = geoTrans[5]
nDim = np.ndim(im)
if nDim == 3:
nBand = im.shape[2]
driver = gdal.GetDriverByName('GTiff')
outRaster = driver.Create(rasterPath, cols, rows, nBand, gdal.GDT_UInt16)
outRaster.SetGeoTransform((x_min, pixelWidth, 0, y_min, 0, pixelHeight))
for i in range(nBand):
outband = outRaster.GetRasterBand(i+1)
outband.WriteArray(np.uint16(maskedOrtho[:,:,i]))
outband.FlushCache()
outRasterSRS = osr.SpatialReference()
outRasterSRS.ImportFromEPSG(self.epsg)
outRaster.SetProjection(outRasterSRS.ExportToWkt())
outRaster = None
# driver = gdal.GetDriverByName('GTiff')
# outRaster = driver.Create(rasterSaveName, cols, rows, 1, gdal.GDT_UInt16)
# outRaster.SetGeoTransform((originX, pixelWidth, 0, originY, 0, pixelHeight))
# outband = outRaster.GetRasterBand(1)
# outband.WriteArray(boolMat)
# outRasterSRS = osr.SpatialReference()
# outRasterSRS.ImportFromEPSG(self.crs.srsid ())#2056)
# outRaster.SetProjection(outRasterSRS.ExportToWkt())
else:
driver = gdal.GetDriverByName('GTiff')
outRaster = driver.Create(rasterPath, cols, rows, 1, gdal.GDT_UInt16)
outRaster.SetGeoTransform((x_min, pixelWidth, 0, y_min, 0, pixelHeight))
outband = outRaster.GetRasterBand(1)
outband.WriteArray(np.uint16(maskedOrtho))
outRasterSRS = osr.SpatialReference()
outRasterSRS.ImportFromEPSG(self.epsg)
outRaster.SetProjection(outRasterSRS.ExportToWkt())
outband.FlushCache()
outRaster = None
def RGBAChannel ( self ):
"""Convert the uint32 back into 4x8 bit channels"""
zdim, ydim, xdim = self.data.shape
newcube = np.zeros( (4, zdim, ydim, xdim), dtype=np.uint16 )
newcube[0,:,:,:] = np.bitwise_and(self.data, 0xffff, dtype=np.uint16)
newcube[1,:,:,:] = np.uint16 ( np.right_shift( self.data, 16) & 0xffff )
newcube[2,:,:,:] = np.uint16 ( np.right_shift( self.data, 32) & 0xffff )
newcube[3,:,:,:] = np.uint16 ( np.right_shift (self.data, 48) )
self.data = newcube
def check_exists(word, connect_dict, values_dict, num_edges_dict):
if word not in connect_dict:
connect_dict[word] = dict()
if word not in values_dict:
if word.isdigit():
values_dict[word] = uint16(int(word))
else:
values_dict[word] = uint16(0)
if word not in num_edges_dict:
num_edges_dict[word] = 0
def _DoCRC(crc, onech):
assert(type(crc) is uint16 and type(onech) is uint8)
ans = uint32(crc ^ onech << uint16(8))
for ind in range(8):
if ans & uint32(0x8000):
ans <<= uint32(1)
ans = ans ^ uint32(4129)
else:
ans <<= uint32(1)
return uint16(ans)
def channelLastValue(self, channelNum, value):
if len(self.data) <= 0:
raise ValueError('No Channel Data. Try using the delayAndWidth method.')
if value == True or value > 0:
binChannel = numpy.uint16(2**channelNum)
self.data[-1] = self.data[-1] | binChannel
else:
binChannel = ~numpy.uint16(2**channelNum)
self.data[-1] = self.data[-1] & binChannel
return self.data
seconds = int(cap.get(cv2.CAP_PROP_POS_FRAMES) / cap.get(cv2.CAP_PROP_FPS))
videoTime = secs_to_HMS(seconds)
#Detect circles in images to block them from using black mask. This is because sewage pipes usually are connected by rings, which are not defects.
circles = cv2.HoughCircles(maskedImage,
cv2.HOUGH_GRADIENT,
1,
20,
param1=200,
param2=20,
minRadius=int(maskRadius / 2),
maxRadius=int(maskRadius))
#If detection is circle and apply detection is ON, block it by a circle mask.
if circles is not None and applyDetection:
circles = np.uint16(np.around(circles))
for i in circles[0, :]:
#Draw the outer circle
cv2.circle(maskedImage, (i[0], i[1]), i[2], (0, 0, 0), 20)
#Draw the maskCenter of the circle
arcDenoisedImage = detectArcs(dat, maskedImage, 2, circles)
contouredImage = highlightContours(arcDenoisedImage)
#If detection is not a circle and apply detection is ON, measure the detection size
elif circles is None and applyDetection:
contouredImage = highlightContours(maskedImage)
for contour in contouredImage:
#Get the contours measurements
[x, y, w, h] = cv2.boundingRect(contour)
new_blockage_area = w * h
new_blockage_y = y
w = 510
img = img[y:y + h, x:x + w]
"""
# invertimos la imagen
# if OVERRIDE_MAXVALUE != -1:
# img = OVERRIDE_MAXVALUE-img
"""
# Normalizamos
img = img/OVERRIDE_MAXVALUE
"""
if not os.path.exists(dest_path):
os.makedirs(dest_path)
cv2.imwrite(os.path.join(dest_path,
str(num_lamb) + ".png"), np.uint16(img))
# guardamos la etiqueta
label = [[1, 0] if j[key] == "bad" else [0, 1]][0]
label_list.append(label)
num_lamb += 1
i2 += 1
printProgressBar(i2,
num_images,
prefix='Estructurando JSON ' + str(json_number) + ':',
suffix='Completado',
length=100,
color=118)
def index():
if request.method == 'POST':
# check if the post request has the file part
if 'file' not in request.files:
print('No file part')
return redirect(request.url)
file = request.files['file']
# if user does not select file, browser also
# submit a empty part without filename
if file.filename == '':
flash('No selected file')
return redirect(request.url)
if file and allowed_file(file.filename):
filename = secure_filename(file.filename)
lokasi_file = os.path.join(app.config['UPLOAD_FOLDER'], filename)
file.save(lokasi_file)
# utama(filename)
filenamee = filename
iterate_name = 1
# loop through the input images
for file in glob.glob(input_path + "/*.bmp"):
try:
#disini hough
img_gray = cv2.imread(file, 0)
img_gray = cv2.medianBlur(img_gray, 5)
img_biner = cv2.cvtColor(img_gray, cv2.COLOR_GRAY2BGR)
#parameter class 1-7
circles = cv2.HoughCircles(img_gray,
cv2.HOUGH_GRADIENT,
1,
20,
param1=350,
param2=55,
minRadius=0,
maxRadius=0)
if (str(circles) == "None"):
circles = cv2.HoughCircles(img_gray,
cv2.HOUGH_GRADIENT,
1,
20,
param1=320,
param2=37,
minRadius=0,
maxRadius=0)
if (str(circles) == "None"):
continue
circles = np.uint16(np.around(circles))
# cv2.imshow("hasil", circles)
for i in circles[0, :]:
cv2.circle(img_biner, (i[0], i[1]), i[2], (0, 255, 255), 2)
cv2.circle(img_biner, (i[0], i[1]), 2, (0, 0, 255), 112)
flag = 1
row, col, ch = img_biner.shape
graykanvas = np.zeros((row, col, 1), np.uint8)
for i in range(0, row):
for j in range(0, col):
b, g, r = img_biner[i, j]
if (b == 255 & g == 0 & r == 0):
graykanvas.itemset((i, j, 0), 255)
if (flag == 1):
x = i
y = j
flag = 100
else:
graykanvas.itemset((i, j, 0), 0)
img_hasil = cv2.subtract(graykanvas, img_gray)
namafile = file.split("\\")[-1]
hasil_crop = img_hasil[x:x + 112, y - 56:y + 56] # im awe [y,x]
cv2.imwrite(os.path.join(hasil_path,
str(iterate_name) + '.jpg'), hasil_crop)
iterate_name += 1
print("crop")
print(hasil_crop)
print(type(hasil_crop))
except OSError as e:
print("Something happened:", e)
# for file in glob.glob(hasil_path + "/*.jpg"):
for file in glob.glob(hasil_path + "/*.jpg"):
try:
# baca gambar hasil Hough Transform
print("glob")
print(file)
print(type(file))
image = cv2.imread(file)
# resize gambarnya
image = cv2.resize(image, fixed_size)
fv_histogram = fd_histogram(image)
global_feature = np.hstack([fv_histogram])
# predict label of test image
modelrf = pickle.load(open("model.sav", 'rb'))
prediction = modelrf.predict(global_feature.reshape(1, -1))[0]
print("kelas:", train_labels[prediction])
# show predicted label on image
cv2.putText(image, train_labels[prediction], (20, 30),
cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 255), 1)
namafile = "hasil"
cv2.imwrite(os.path.join(input_path, namafile + "_hasil" + ".jpg"),
image)
print(train_labels[prediction])
return render_template('hasil.html',
hasil=train_labels[prediction],
nama=namafile + "_hasil" + ".jpg")
except OSError as e:
print("Something happened:", e)
return render_template('hasil.html')
#circles_s = cv2.HoughCircles(s_part,cv2.HOUGH_GRADIENT,1,minDist=500,
#param1=200,param2=13,minRadius=10,maxRadius=40)
circles_s = cv2.HoughCircles(s_part,
cv2.HOUGH_GRADIENT,
dbValue_s,
minDist=minDist_s,
param1=param1_s,
param2=param2_s,
minRadius=minRadius_s,
maxRadius=maxRadius_s)
#For basement pictures in TestDrone640 use minRadius=10,maxRadius=30)
#For pica 30 use: param1=500,param2=9,minRadius=5,maxRadius=15)
#pica 33: circles_s = cv2.HoughCircles(s_part,cv2.HOUGH_GRADIENT,1,minDist=500,
#param1=200,param2=13,minRadius=10,maxRadius=40)
circles_s = np.uint16(np.around(circles_s))
for i in circles_s[0, :]:
# draw the outer circle
cv2.circle(img_s, (i[0], i[1]), i[2], (0, 255, 0), 12)
# draw the center of the circle
cv2.circle(img_s, (i[0], i[1]), 2, (0, 0, 255), 8)
#cv2.imshow('detected circles_h',cimg)
#cv2.waitKey(0)
#cv2.destroyAllWindows()
#cv2.imshow('s part',img_s)
cimg_s = cv2.cvtColor(img_s, cv2.COLOR_BGR2RGB)
plt.figure('s part')
imgplot = plt.imshow(cimg_s)
"""
maxRadius=200)
circlesBlue = cv2.HoughCircles(greyBlue,
cv2.HOUGH_GRADIENT,
1,
50,
param1=50,
param2=30,
minRadius=10,
maxRadius=1000)
#Gestisco il caso in cui non vi siano cerchi nel frame( assurdo )
if circlesRed or circlesGreen or circlesBlue is None:
print("Nessuna circonferenza trovata")
continue
#Disegno le circonferenze DEBUG
circlesBlue = np.uint16(np.around(circlesBlue))
for i in circlesBlue[0, :]:
cv2.circle(foto, (i[0], i[1]), i[2], (255, 0, 0),
1) # draw the outer circle
cv2.circle(foto, (i[0], i[1]), 2, (255, 0, 0),
3) # draw the center of the circle
cv2.imwrite('processed/0processed.png', foto)
#return angles in radiants
def inverseCinematic(x, y, z, l1, l2, l3):
fi = 30 * math.pi / 180 #Angolo che definisce l'orientamento della pinza rispetto all'asse x.
xp = x - l3 * math.cos(fi)
zp = z - l3 * math.sin(fi)
teta2 = math.acos(((xp * xp + zp * zp - l1 * l1 - l2 * l2) / 2 * l1 * l2))
def test_numpy_numeric_type_uint16(self):
self.assertTrue(isnumeric(np.uint16(1)),
"Unsigned integer (0 to 65535)")
# le hacemos crop
x = 38
y = 102
h = 230
w = 510
img = img[y:y + h, x:x + w]
# invertimos la imagen
# if OVERRIDE_MAXVALUE != -1:
# img = OVERRIDE_MAXVALUE-img
if not os.path.exists(dest_path):
os.makedirs(dest_path)
cv2.imwrite(os.path.join(dest_path,
str(num_ret_img) + ".png"),
np.uint16(img))
# guardamos la etiqueta
label = j[key]["label"]
if label == "lamb":
num_lamb = num_lamb + 1
label = [1, 0, 0]
elif label == "empty":
num_empty = num_empty + 1
label = [0, 1, 0]
elif label == "wrong":
num_wrong = num_wrong + 1
label = [0, 0, 1]
else:
print("hay alguna etiqueta mala: " + str(j[key]["label"]))
def detect2(img_read, pt1, pt2, w):
try:
t1 = time.time()
crop_img = img_read[pt1[1]:pt2[1], pt1[0]:pt2[0]]
distance = conf["distance"]
#skp, tkp = cvlib.findKeyPoints(crop_img , target, distance)
crop_img = cv2.medianBlur(crop_img, conf["blur_level"])
gray = cv2.cvtColor(crop_img, cv2.COLOR_BGR2GRAY)
circles = cv2.HoughCircles(gray, cv2.cv.CV_HOUGH_GRADIENT,
conf["dp"],#29, ## dp
conf["minDist"],#100, ## minDist
conf["param1"],#param1=70,
conf["param2"],#param2=80, ##
conf["minRadius"],#minRadius=20,
conf["maxRadius"]) #maxRadius=0)
j = 0
if DEBUG == "true":
cv2.rectangle(img_read, pt1, pt2, (0,255,0))
"""
if DEBUG == "false":
if circles == None:
#print "None."
save(0,0,0)
return 0
else:
circles = np.uint16(np.around(circles))
save(circles)
return 1
"""
#print circles
#print type(circles)
if circles == None:
#print "none"
if DEBUG == "true":
cv2.imshow("camera", img_read)
save(0,0,0)
else:
circles = np.uint16(np.around(circles))
#x = circles[0][0][0]
#y = circles[0][0][1]
#r = circles[0][0][2]
#print "else"
for i in circles[0,:]:
if supress(i, w):
j = j + 1
save(1,1,1)
#print i[2], i
if DEBUG == "true":
cv2.circle(img_read,(pt1[0]+i[0],pt1[1]+i[1]),i[2],(0,255,0),2)
cv2.circle(img_read,(pt1[0]+i[0],pt1[1]+i[1]),2,(0,0,255),3)
#cp = [ i[0], i[1] ]
#print cp
if DEBUG == "true":
cv2.imshow("camera", img_read)
except Exception as ex:
#print(ex)
#print(traceback.format_exc())
logger.debug(ex)
Method - currently only cv2.HOUGH_GRADIENT available
dp - Inverse ratio of accumulator resolution
MinDist - the minimum distance between the center of detected circles
param1 - Gradient value used in the edge detection
param2 - Accumulator threshold for the HOUGH_GRADIENT method (lower allows more circles
to be detected (false positives))
minRadius - limits the smallest circle to this size (via radius)
MaxRadius - similarly sets the limit for the largest circles
"""
image = cv2.imread(os.path.dirname(__file__) + '/../images/bottlecaps.jpg')
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
blur = cv2.medianBlur(gray, 5)
circles = cv2.HoughCircles(blur, cv2.cv.CV_HOUGH_GRADIENT, 1.5, 10)
#circles = cv2.HoughCircles(gray, cv.CV_HOUGH_GRADIENT, 1, 10)
circles = np.uint16(np.around(
circles)) # np.around 'Evenly round to the given number of decimals'
for i in circles[0, :]:
# draw the outer circle
cv2.circle(image, (i[0], i[1]), i[2], (255, 0, 0), 2)
# draw the center of the circle
cv2.circle(image, (i[0], i[1]), 2, (0, 255, 0), 5)
cv2.imshow('detected circles', image)
cv2.waitKey(0)
cv2.destroyAllWindows()
def set_population(self,punit_buf,grid_buf,simTime=1,sample_rate=1000,Density=150,youngs=50*1e3,roi=[]):
self.E_ym=youngs
self.T=float (simTime)
self.dt = float (1/sample_rate) #Timestep
self.t= np.linspace(0,self.T,int( self.T/self.dt))
self.Rn=1
self.Rm=len(grid_buf)
self.stp=int(self.Rm/2)
self.Density=Density
self.V1=np.random.uniform(-0.000,0.000,(self.Rm*self.Rn,self.t.size))
self.V2=np.random.uniform(-0.000,0.000,(self.Rm*self.Rn,self.t.size))
self.G=np.mat(np.zeros((self.Rm*self.Rn,self.Rm*self.Rn)))
self.Gi=np.mat(np.zeros((self.Rm*self.Rn,self.Rm*self.Rn)))
self.Va=np.random.uniform(-70,-70,(self.Rm*self.Rn,self.t.size))
self.Vg=np.random.uniform(-0.000,0.000,(self.Rm*self.Rn,self.t.size))
self.Is=np.random.uniform(-0.000,0.000,(self.Rm*self.Rn,self.t.size))
self.Vs=np.zeros([self.Rm*self.Rn,self.t.size])
self.Vnf=np.random.uniform(-0.000,0.000,(self.Rm*self.Rn,self.t.size))
self.Vf=np.random.uniform(-0.000,0.000,(self.Rm*self.Rn,self.t.size))
self.X0=np.zeros((self.Rm*self.Rn,self.t.size))
self.VN=np.random.uniform(-10,10,(self.Rm*self.Rn,self.t.size))
self.SN=np.random.uniform(-0,0,(self.Rm*self.Rn,self.t.size))
#self.Vsa=np.array(np.zeros((self.Rm*self.Rn,self.t.size)));
self.Uc=np.array(np.zeros((self.Rm*self.Rn,self.t.size)));
#self.Ve=np.array(np.zeros((self.Rm*self.Rn,self.t.size)));
#self.Vi=np.array(np.zeros((self.Rm*self.Rn,self.t.size)));
#self.area_ei=np.zeros((2,self.t.size))
#self.U=np.array(np.zeros((self.Rm*self.Rn,self.t.size)));
self.Dt=np.random.uniform(-0.000,0.000,(self.Rm*self.Rn,self.t.size))
self.spike_trains=[]
#-----Locations of receptors-----#
self.r_pos=np.array(punit_buf);
tmp=grid_buf+100
entry_buf=np.int16(tmp[:,0]+tmp[:,1]*(100*2))
self.v_pos=entry_buf;
for i in range(self.Rm):
[w,v]=grid_buf[i,:]
tmp=grid_buf==[w-1,v]
sel=tmp[:,0]&tmp[:,1]
if(np.sum(sel)):
#loc=sel.nonzero()[0][0]
self.G[sel,i]=-1
tmp=grid_buf==[w+1,v]
sel=tmp[:,0]&tmp[:,1]
if(np.sum(sel)):
#loc=sel.nonzero()[0][0]
self.G[sel,i]=-1
tmp=grid_buf==[w,v-1]
sel=tmp[:,0]&tmp[:,1]
if(np.sum(sel)):
#loc=sel.nonzero()[0][0]
self.G[sel,i]=-1/self.Rwv
tmp=grid_buf==[w,v+1]
sel=tmp[:,0]&tmp[:,1]
if(np.sum(sel)):
#loc=sel.nonzero()[0][0]
self.G[sel,i]=-1/self.Rwv
self.G[i,i]=2*(1+self.Rwv)/(self.Rwv)/self.Cd
self.Gi=self.Rc*self.G.I
self.GiFit=self.G.I # inverse G for fitting
'---Presetup---'
#size of skin contact scaning image
self.rentrys=[]
Wc=roi[:,0].max()-roi[:,0].min()
Hc=roi[:,1].max()-roi[:,1].min()
self.Nc=int(Wc/Dbp)
self.Nr=int(Hc/Dbp)
OEs=np.hstack([np.uint16((self.r_pos[:,1:2]-roi[:,1].min())/Hc*self.Nr),
np.uint16((self.r_pos[:,0:1]-roi[:,0].min())/Wc*self.Nc)])
self.OEs=OEs
Esc=np.meshgrid(np.arange(0,self.Nr,1),np.arange(0,self.Nc,1))
Esc=np.hstack([Esc[0].reshape(Esc[0].size,1),Esc[1].reshape(Esc[0].size,1)])
#Dx=roi[:,0].max()-roi[:,0].min()
#Dy=roi[:,1].max()-roi[:,1].min()
locs=np.hstack([Esc[:,1:2]*Wc/self.Nc+roi[:,0].min(),Esc[:,0:1]*Hc/self.Nr+roi[:,1].min()])
sroi=np.vstack([roi,roi[0,:]])
sel=isPoisWithinPoly(sroi,locs)
#sel=alt.isin_multipolygon(locs,roi, contain_boundary=True)
pdots=Esc[sel,:] #Pixels in skin area
self.pdots=pdots
Esbuf=[]
for i in range(self.Rm):
Esbuf.append([])
# select closet pxiels in SC image that attribute to each tactile unit
for i in range(len(pdots)):
tmp=np.float32(pdots[i,:])-np.float32(OEs)
tmp=tmp[:,0]**2+tmp[:,1]**2
sel=int(np.where(tmp==tmp.min())[0][0])
Esbuf[sel].append(pdots[i,:])
Nbuf=np.zeros(self.Rm)
for i in range(self.Rm):
Nbuf[i]=len(Esbuf[i])
Nrcp=int(np.max(Nbuf))+1
rows=np.zeros([self.Rm,Nrcp])
cols=np.zeros([self.Rm,Nrcp])
for i in range(self.Rm):
'supply up to Nrcp pixel with center pixel for each tactile unit'
num=len(Esbuf[i])
if(num>0):
eadots=np.array(Esbuf[i]).T
supplys=np.ones([2,Nrcp-num])
else:
eadots=OEs[i,:].reshape(2,1)
supplys=np.ones([2,Nrcp-1])
supplys[0,:]=supplys[0,:]*OEs[i,0]
supplys[1,:]=supplys[1,:]*OEs[i,1]
rows[i,:]=np.hstack([eadots,supplys])[0,:]
cols[i,:]=np.hstack([eadots,supplys])[1,:]
self.Es=[np.uint16(rows),np.uint16(cols)]
def _export_data_to_h5(first_time_id, last_time_id, bf, tp, pre_data):
tp.timestamp = time()
tp.message = 'reading time values from SQL'
tp.save()
first_time = RecordedTime.objects.get(id=first_time_id)
time_id_min = BackgroundTask.objects.filter(
label='data acquision daemon', start__lte=first_time.timestamp).last()
if time_id_min:
time_id_min = RecordedTime.objects.filter(
timestamp__lte=time_id_min.start).last()
if time_id_min:
time_id_min = time_id_min.id
log.debug(("time_id_min %d to first_time_id %d") %
(time_id_min, first_time_id))
else:
time_id_min = 1
else:
time_id_min = 1
timevalues = [
timestamp_unix_to_matlab(element)
for element in RecordedTime.objects.filter(
id__range=(first_time_id,
last_time_id)).values_list('timestamp', flat=True)
]
time_ids = list(
RecordedTime.objects.filter(id__range=(first_time_id,
last_time_id)).values_list(
'id', flat=True))
tp.timestamp = time()
tp.message = 'writing time values to file'
tp.save()
bf.write_data('time', float64(timevalues))
bf.reopen()
data = {}
active_vars = list(
Variable.objects.filter(active=1, record=1,
client__active=1).values_list('pk', flat=True))
tp.timestamp = time()
tp.message = 'reading float data values from SQL'
tp.save()
raw_data = list(
RecordedDataFloat.objects.filter(
time_id__range=(first_time_id, last_time_id),
variable_id__in=active_vars).values_list('variable_id', 'time_id',
'value'))
tp.timestamp = time()
tp.message = 'prepare raw float data'
tp.save()
for item in raw_data:
if not data.has_key(item[0]):
data[item[0]] = []
data[item[0]].append([item[1], item[2]])
tp.timestamp = time()
tp.message = 'reading int data values from SQL'
tp.save()
raw_data = []
raw_data = list(
RecordedDataInt.objects.filter(
time_id__range=(first_time_id, last_time_id),
variable_id__in=active_vars).values_list('variable_id', 'time_id',
'value'))
tp.timestamp = time()
tp.message = 'prepare raw int data'
tp.save()
for item in raw_data:
if not data.has_key(item[0]):
data[item[0]] = []
data[item[0]].append([item[1], item[2]])
tp.timestamp = time()
tp.message = 'reading bool data values from SQL'
tp.save()
raw_data = []
raw_data = list(
RecordedDataBoolean.objects.filter(
time_id__range=(first_time_id, last_time_id),
variable_id__in=active_vars).values_list('variable_id', 'time_id',
'value'))
tp.timestamp = time()
tp.message = 'prepare raw bool data'
tp.save()
for item in raw_data:
if not data.has_key(item[0]):
data[item[0]] = []
data[item[0]].append([item[1], item[2]])
raw_data = []
tp.timestamp = time()
tp.message = 'writing data to file'
tp.save()
pre_data = {}
for var in Variable.objects.filter(active=1, record=1,
client__active=1).order_by('pk'):
tp.timestamp = time()
tp.message = 'processing variable_id %d' % var.pk
tp.save()
var_id = var.pk
variable_class = var.value_class
first_record = False
if data.has_key(var_id):
records = data[var_id]
if records[0][0] == first_time_id:
first_record = True
else:
records = []
if not first_record:
if pre_data.has_key(var_id):
records.insert(0, pre_data[var_id])
first_record = True
else:
first_record = _last_matching_record(variable_class,
first_time_id, var_id,
time_id_min)
if first_record:
records.insert(0, first_record)
if not first_record and not records:
tmp = [0] * len(time_ids)
if variable_class.upper() in ['FLOAT', 'FLOAT64', 'DOUBLE']:
tmp = float64(tmp)
elif variable_class.upper() in ['FLOAT32', 'SINGLE', 'REAL']:
tmp = float32(tmp)
elif variable_class.upper() in ['INT32']:
tmp = int32(tmp)
elif variable_class.upper() in ['WORD', 'UINT', 'UINT16']:
tmp = uint16(tmp)
elif variable_class.upper() in ['INT16', 'INT']:
tmp = int16(tmp)
elif variable_class.upper() in ['BOOL']:
tmp = uint8(tmp)
else:
tmp = float64(tmp)
bf.write_data(var.name, tmp)
bf.reopen()
continue
#blow up data ##########################################################
tmp = [0] * len(time_ids)
t_idx = 0
v_idx = 0
nb_v_idx = len(records) - 1
for id in time_ids:
if nb_v_idx < v_idx:
if t_idx > 0:
tmp[t_idx] = tmp[t_idx - 1]
else:
if records[v_idx][0] == id:
tmp[t_idx] = records[v_idx][1]
laid = id
v_idx += 1
elif t_idx > 0:
tmp[t_idx] = tmp[t_idx - 1]
elif records[v_idx][0] <= id:
tmp[t_idx] = records[v_idx][1]
laid = id
v_idx += 1
if nb_v_idx > v_idx:
logged = False
while records[v_idx][0] <= id and v_idx <= nb_v_idx:
if not logged:
log.debug(
("double id %d in var %d") % (id, var_id))
logged = True
v_idx += 1
t_idx += 1
pre_data[var_id] = tmp[-1]
if variable_class.upper() in ['FLOAT', 'FLOAT64', 'DOUBLE']:
tmp = float64(tmp)
elif variable_class.upper() in ['FLOAT32', 'SINGLE', 'REAL']:
tmp = float32(tmp)
elif variable_class.upper() in ['INT32']:
tmp = int32(tmp)
elif variable_class.upper() in ['WORD', 'UINT', 'UINT16']:
tmp = uint16(tmp)
elif variable_class.upper() in ['INT16', 'INT']:
tmp = int16(tmp)
elif variable_class.upper() in ['BOOL']:
tmp = uint8(tmp)
else:
tmp = float64(tmp)
bf.write_data(var.name, tmp)
bf.reopen()
return pre_data
"""
def extract_tiles(asset_path, offsets, height_target, normal_target):
tile_indices = [[0, 1, 2, 3]] if smallMap else [[0, 1, 2, 3], [0, 1, 2, 3], [0, 1, 2, 3], [0, 1, 2, 3]]
num_indices = len(numpy.array(tile_indices).flatten())
offset_scale = 2 if smallMap else 4
sequence_index = 0
for i, indices in enumerate(tile_indices):
for tile_index in indices:
if smallMap:
tile_path = asset_path % (offsets[0], offsets[1], tile_index)
else:
tile_path = asset_path % (offsets[0], offsets[1], i, tile_index)
tile = Image.open(tile_path)
tile_r, tile_g, tile_b, tile_a = tile.split()
# extract normal
channel_r = numpy.asarray(tile_b).flatten()
channel_g = numpy.asarray(tile_a).flatten()
channel_b = numpy.resize(numpy.uint8(), tile_size)
channel_b.fill(255)
rgb = numpy.dstack((channel_r, channel_g, channel_b)).flatten()
# # extract elevation
channel_l = numpy.left_shift(numpy.asarray(tile_r, numpy.uint16()).flatten(), 8)
channel_l = channel_l + numpy.asarray(tile_g).flatten()
# refine stitching sequence
x = offsets[0] * offset_scale + int(i % 2) * 2 + int(tile_index % 2)
y = offsets[1] * offset_scale + int(i / 2) * 2 + int(tile_index / 2)
ordered_index = y * 16 + x
# paste data
target_x = (ordered_index % 16) * tile_width
target_y = math.floor(ordered_index / 16) * tile_height
# write normal tile
normal_tile = Image.frombytes('RGB', (tile_width, tile_height), rgb)
normal_target.paste(normal_tile, (target_x, target_y))
# write height tile
height_tile = Image.frombytes('I;16', (tile_width, tile_height), numpy.asarray(channel_l, order = 'C'))
height_target.paste(height_tile, (target_x, target_y))
# display progress
progress = (offsets[0] * 4 + offsets[1]) * num_indices + sequence_index + 1
print ('processing', str(progress).rjust(2 if smallMap else 3, '0'), 'of', numTiles,
flush = True, end = ('\r' if progress < numTiles else '\n'))
sequence_index += 1
def get_address(cls, cpu, data_bytes: bytes) -> Optional[int]:
return np.uint16(int.from_bytes(data_bytes, byteorder='little') + cls.get_offset(cpu))
def get_address(cls, cpu: 'c.CPU', data_bytes: bytes):
return np.uint16(super().get_address(cpu, data_bytes) + cpu.y_reg)
def find_in_circle(self, frame: np.ndarray, erode=False):
g_frame = cv.cvtColor(frame, cv.COLOR_BGR2GRAY)
ys, ye, xs, xe = self.get_roi(frame)
g_frame = self.__eliminate_non_roi(g_frame, ys, ye, xs, xe)
_filter = self._filter
if _filter == 'threshold':
blur = cv.GaussianBlur(g_frame, tuple(self.blur), 0)
_, mask = cv.threshold(blur, self.threshold, 255,
cv.THRESH_BINARY_INV)
elif _filter == 'adaptative':
mask = cv.adaptiveThreshold(g_frame, 255,
cv.ADAPTIVE_THRESH_MEAN_C,
cv.THRESH_BINARY, 5, 2)
else:
cut_frame = frame.copy()
cut_frame = self.__eliminate_non_roi(cut_frame, ys, ye, xs, xe)
if _filter == 'hsv':
cvt_frame = cv.cvtColor(cut_frame, cv.COLOR_BGR2HSV)
lower = np.array((self.table_hsv[0][0], self.table_hsv[0][1],
self.table_hsv[0][2]), np.uint8)
higher = np.array((self.table_hsv[1][0], self.table_hsv[1][1],
self.table_hsv[1][2]), np.uint8)
else:
cvt_frame = cv.cvtColor(cut_frame, cv.COLOR_RGB2LAB)
lower = np.array((self.table_hsv[0][0], self.table_hsv[0][1],
self.table_hsv[0][2]), np.uint8)
higher = np.array((self.table_hsv[1][0], self.table_hsv[1][1],
self.table_hsv[1][2]), np.uint8)
mask = cv.inRange(cvt_frame, lower, higher)
if erode:
mask = cv.erode(mask, None, iterations=2)
mask = cv.dilate(mask, None, iterations=2)
if self.debug_tank:
cv.imshow('debug_tank', mask)
self.circles = cv.HoughCircles(mask,
cv.HOUGH_GRADIENT,
param1=self.params[0],
param2=self.params[1],
minDist=self.min_dist,
dp=self.radius[0],
minRadius=self.radius[1],
maxRadius=self.radius[2])
self.found = False
self.x, self.y, self.w, self.h = 0, 0, 0, 0
if self.circles is not None:
circles = np.uint16(np.around(self.circles))
for x, y, r in circles[0, :]:
calc_x = int(x -
r) if (x - r) > 0 and x < frame.shape[1] else 0
calc_y = int(y -
r) if (y - r) > 0 and y < frame.shape[0] else 0
if (calc_x > 0 and calc_x < frame.shape[1]) and (
calc_y > 0 and calc_y < frame.shape[0]):
self.w, self.h = 2 * abs(r), 2 * abs(r)
self.x, self.y = calc_x, calc_y
self.found = True
self.image = frame[self.y:self.y + self.h,
self.x:self.x + self.w]
'ply_output_dir') # e.g. /kpcn/data/shapenetV1/train/partial
parser.add_argument('num_scans', type=int)
args = parser.parse_args()
render_output_dir = os.path.join(
os.path.dirname(os.path.realpath(__file__)), 'render_out')
intrinsics = np.loadtxt(os.path.join(render_output_dir, 'intrinsics.txt'))
width = int(intrinsics[0, 2] * 2)
height = int(intrinsics[1, 2] * 2)
depth_dir = os.path.join(render_output_dir, 'depth', args.cat_model_id)
ply_dir = os.path.join(args.ply_output_dir, args.cat_model_id)
os.makedirs(depth_dir, exist_ok=True)
os.makedirs(ply_dir, exist_ok=True)
for i in range(args.num_scans):
exr_path = os.path.join(render_output_dir, 'exr', args.cat_model_id,
'%d.exr' % i)
pose_path = os.path.join(render_output_dir, 'pose', args.cat_model_id,
'%d.txt' % i)
depth = read_exr(exr_path, height, width)
depth_img = o3d.geometry.Image(np.uint16(depth * 1000))
o3d.io.write_image(os.path.join(depth_dir, '%d.png' % i), depth_img)
pose = np.loadtxt(pose_path)
points = depth2pcd(depth, intrinsics, pose)
cloud = o3d.geometry.PointCloud()
cloud.points = o3d.utility.Vector3dVector(points)
o3d.io.write_point_cloud(os.path.join(ply_dir, '%d.ply' % i), cloud)
def read_uint16(field: str) -> np.uint16:
"""Read a uint16."""
return np.uint16(field) if field != "" else 0
td_64 / dt_64 # E: No overload
td_64 % 1 # E: Unsupported operand types
td_64 % dt_64 # E: Unsupported operand types
class A:
def __float__(self):
return 1.0
np.int8(A()) # E: incompatible type
np.int16(A()) # E: incompatible type
np.int32(A()) # E: incompatible type
np.int64(A()) # E: incompatible type
np.uint8(A()) # E: incompatible type
np.uint16(A()) # E: incompatible type
np.uint32(A()) # E: incompatible type
np.uint64(A()) # E: incompatible type
np.void("test") # E: incompatible type
np.generic(1) # E: Cannot instantiate abstract class
np.number(1) # E: Cannot instantiate abstract class
np.integer(1) # E: Cannot instantiate abstract class
np.signedinteger(1) # E: Cannot instantiate abstract class
np.unsignedinteger(1) # E: Cannot instantiate abstract class
np.inexact(1) # E: Cannot instantiate abstract class
np.floating(1) # E: Cannot instantiate abstract class
np.complexfloating(1) # E: Cannot instantiate abstract class
np.character("test") # E: Cannot instantiate abstract class
np.flexible(b"test") # E: Cannot instantiate abstract class
def evaluate(opt):
"""Evaluates a pretrained model using a specified test set
"""
MIN_DEPTH = 1e-3
MAX_DEPTH = 80
assert sum((opt.eval_mono, opt.eval_stereo)) == 1, \
"Please choose mono or stereo evaluation by setting either --eval_mono or --eval_stereo"
if opt.ext_disp_to_eval is None:
opt.load_weights_folder = os.path.expanduser(opt.load_weights_folder)
assert os.path.isdir(opt.load_weights_folder), \
"Cannot find a folder at {}".format(opt.load_weights_folder)
print("-> Loading weights from {}".format(opt.load_weights_folder))
filenames = readlines(
os.path.join(splits_dir, opt.eval_split, "test_files.txt"))
encoder_path = os.path.join(opt.load_weights_folder, "encoder.pth")
decoder_path = os.path.join(opt.load_weights_folder, "depth.pth")
encoder_dict = torch.load(encoder_path)
dataset = datasets.KITTIRAWDataset(opt.data_path,
filenames,
encoder_dict['height'],
encoder_dict['width'], [0],
4,
is_train=False)
dataloader = DataLoader(dataset,
16,
shuffle=False,
num_workers=opt.num_workers,
pin_memory=True,
drop_last=False)
encoder = networks.ResnetEncoder(opt.num_layers, False)
depth_decoder = networks.DepthDecoder(encoder.num_ch_enc)
model_dict = encoder.state_dict()
encoder.load_state_dict(
{k: v
for k, v in encoder_dict.items() if k in model_dict})
depth_decoder.load_state_dict(torch.load(decoder_path))
encoder.cuda()
encoder.eval()
depth_decoder.cuda()
depth_decoder.eval()
pred_disps = []
print("-> Computing predictions with size {}x{}".format(
encoder_dict['width'], encoder_dict['height']))
with torch.no_grad():
for data in dataloader:
input_color = data[("color", 0, 0)].cuda()
if opt.post_process:
# Post-processed results require each image to have two forward passes
input_color = torch.cat(
(input_color, torch.flip(input_color, [3])), 0)
output = depth_decoder(encoder(input_color))
pred_disp, _ = disp_to_depth(output[("disp", 0)],
opt.min_depth, opt.max_depth)
pred_disp = pred_disp.cpu()[:, 0].numpy()
if opt.post_process:
N = pred_disp.shape[0] // 2
pred_disp = batch_post_process_disparity(
pred_disp[:N], pred_disp[N:, :, ::-1])
pred_disps.append(pred_disp)
pred_disps = np.concatenate(pred_disps)
else:
# Load predictions from file
print("-> Loading predictions from {}".format(opt.ext_disp_to_eval))
pred_disps = np.load(opt.ext_disp_to_eval)
if opt.eval_eigen_to_benchmark:
eigen_to_benchmark_ids = np.load(
os.path.join(splits_dir, "benchmark",
"eigen_to_benchmark_ids.npy"))
pred_disps = pred_disps[eigen_to_benchmark_ids]
if opt.save_pred_disps:
output_path = os.path.join(opt.load_weights_folder,
"disps_{}_split.npy".format(opt.eval_split))
print("-> Saving predicted disparities to ", output_path)
np.save(output_path, pred_disps)
if opt.no_eval:
print("-> Evaluation disabled. Done.")
quit()
elif opt.eval_split == 'benchmark':
save_dir = os.path.join(opt.load_weights_folder,
"benchmark_predictions")
print("-> Saving out benchmark predictions to {}".format(save_dir))
if not os.path.exists(save_dir):
os.makedirs(save_dir)
for idx in range(len(pred_disps)):
disp_resized = cv2.resize(pred_disps[idx], (1216, 352))
depth = STEREO_SCALE_FACTOR / disp_resized
depth = np.clip(depth, 0, 80)
depth = np.uint16(depth * 256)
save_path = os.path.join(save_dir, "{:010d}.png".format(idx))
cv2.imwrite(save_path, depth)
print(
"-> No ground truth is available for the KITTI benchmark, so not evaluating. Done."
)
quit()
gt_path = os.path.join(splits_dir, opt.eval_split, "gt_depths.npz")
gt_depths = np.load(gt_path, fix_imports=True, encoding='latin1')["data"]
print("-> Evaluating")
if opt.eval_stereo:
print(" Stereo evaluation - "
"disabling median scaling, scaling by {}".format(
STEREO_SCALE_FACTOR))
opt.disable_median_scaling = True
opt.pred_depth_scale_factor = STEREO_SCALE_FACTOR
else:
print(" Mono evaluation - using median scaling")
errors = []
ratios = []
for i in range(pred_disps.shape[0]):
# 获得groundtruth 的尺寸
gt_depth = gt_depths[i]
gt_height, gt_width = gt_depth.shape[:2]
# resize 预测深度图像
pred_disp = pred_disps[i]
pred_disp = cv2.resize(pred_disp, (gt_width, gt_height))
pred_depth = 1 / pred_disp
# 获取掩码
if opt.eval_split == "eigen":
# 逻辑与运算获得在约定范围内的gt
mask = np.logical_and(gt_depth > MIN_DEPTH, gt_depth < MAX_DEPTH)
# 裁减有效区域
crop = np.array([
0.40810811 * gt_height, 0.99189189 * gt_height,
0.03594771 * gt_width, 0.96405229 * gt_width
]).astype(np.int32)
crop_mask = np.zeros(mask.shape)
crop_mask[crop[0]:crop[1], crop[2]:crop[3]] = 1
mask = np.logical_and(mask, crop_mask)
else:
mask = gt_depth > 0
pred_depth = pred_depth[mask]
gt_depth = gt_depth[mask]
pred_depth *= opt.pred_depth_scale_factor
if not opt.disable_median_scaling:
ratio = np.median(gt_depth) / np.median(pred_depth)
ratios.append(ratio)
pred_depth *= ratio
pred_depth[pred_depth < MIN_DEPTH] = MIN_DEPTH
pred_depth[pred_depth > MAX_DEPTH] = MAX_DEPTH
errors.append(compute_errors(gt_depth, pred_depth))
if not opt.disable_median_scaling:
ratios = np.array(ratios)
med = np.median(ratios)
print(" Scaling ratios | med: {:0.3f} | std: {:0.3f}".format(
med, np.std(ratios / med)))
mean_errors = np.array(errors).mean(0)
print("\n " +
("{:>8} | " * 7
).format("abs_rel", "sq_rel", "rmse", "rmse_log", "a1", "a2", "a3"))
print(("&{: 8.3f} " * 7).format(*mean_errors.tolist()) + "\\\\")
print("\n-> Done!")
def model_test(use_existing):
cm.mkdir(cm.workingPath.testingResults_path)
# Loading test data:
filename = cm.filename
modelname = cm.modellist[0]
# Single CT:
originFile_list = sorted(
glob(cm.workingPath.originTestingSet_path + filename))
maskAortaFile_list = sorted(
glob(cm.workingPath.aortaTestingSet_path + filename))
maskPulFile_list = sorted(
glob(cm.workingPath.pulTestingSet_path + filename))
# Zahra CTs:
# originFile_list = sorted(glob(cm.workingPath.originTestingSet_path + "vol*.dcm"))
# maskAortaFile_list = sorted(glob(cm.workingPath.aortaTestingSet_path + "vol*.dcm"))
# maskPulFile_list = sorted(glob(cm.workingPath.pulTestingSet_path + "vol*.dcm"))
# Lidia CTs:
# originFile_list = sorted(glob(cm.workingPath.originLidiaTestingSet_path + "vol*.dcm"))[61:]
# maskAortaFile_list = sorted(glob(cm.workingPath.originLidiaTestingSet_path + "vol*.dcm"))[61:]
# maskPulFile_list = sorted(glob(cm.workingPath.originLidiaTestingSet_path + "vol*.dcm"))[61:]
# Abnormal CTs:
# originFile_list = sorted(glob(cm.workingPath.originAbnormalTestingSet_path + "vol126*.dcm"))
# maskAortaFile_list = sorted(glob(cm.workingPath.originAbnormalTestingSet_path + "vol126*.dcm"))
# maskPulFile_list = sorted(glob(cm.workingPath.originAbnormalTestingSet_path + "vol126*.dcm"))
for i in range(len(originFile_list)):
# Show runtime:
starttime = datetime.datetime.now()
vol_slices = []
out_test_images = []
out_test_masks = []
current_file = originFile_list[i].split('/')[-1]
current_dir = cm.workingPath.testingResults_path + str(
current_file[:-17])
cm.mkdir(current_dir)
cm.mkdir(current_dir + '/Plots/')
cm.mkdir(current_dir + '/Surface_Distance/')
cm.mkdir(current_dir + '/DICOM/')
cm.mkdir(current_dir + '/mhd/')
stdout_backup = sys.stdout
log_file = open(current_dir + "/logs.txt", "w")
sys.stdout = log_file
print('-' * 30)
print('Loading test data %04d/%04d...' % (i + 1, len(originFile_list)))
originVol, originVol_num, originVolwidth, originVolheight = dp.loadFile(
originFile_list[i])
maskAortaVol, maskAortaVol_num, maskAortaVolwidth, maskAortaVolheight = dp.loadFile(
maskAortaFile_list[i])
maskPulVol, maskPulVol_num, maskPulVolwidth, maskPulVolheight = dp.loadFile(
maskPulFile_list[i])
maskVol = maskAortaVol
for j in range(len(maskAortaVol)):
maskAortaVol[j] = np.where(maskAortaVol[j] != 0, 1, 0)
for j in range(len(maskPulVol)):
maskPulVol[j] = np.where(maskPulVol[j] != 0, 2, 0)
maskVol = maskVol + maskPulVol
for j in range(len(maskVol)):
maskVol[j] = np.where(maskVol[j] > 2, 0, maskVol[j])
# maskVol[j] = np.where(maskVol[j] != 0, 0, maskVol[j])
# Make the Vessel class
for j in range(len(maskVol)):
maskVol[j] = np.where(maskVol[j] != 0, 1, 0)
for i in range(originVol.shape[0]):
img = originVol[i, :, :]
out_test_images.append(img)
for i in range(maskVol.shape[0]):
img = maskVol[i, :, :]
out_test_masks.append(img)
vol_slices.append(originVol.shape[0])
maskAortaVol = None
maskPulVol = None
maskVol = None
originVol = None
nb_class = 2
outmasks_onehot = to_categorical(out_test_masks, num_classes=nb_class)
final_test_images = np.ndarray([sum(vol_slices), 512, 512, 1],
dtype=np.int16)
final_test_masks = np.ndarray([sum(vol_slices), 512, 512, nb_class],
dtype=np.int8)
for i in range(len(out_test_images)):
final_test_images[i, :, :, 0] = out_test_images[i]
final_test_masks[i, :, :, :] = outmasks_onehot[i]
outmasks_onehot = None
out_test_masks = None
out_test_images = None
row = cm.img_rows_3d
col = cm.img_cols_3d
row_1 = int((512 - row) / 2)
row_2 = int(512 - (512 - row) / 2)
col_1 = int((512 - col) / 2)
col_2 = int(512 - (512 - col) / 2)
slices = cm.slices_3d
gaps = cm.gaps_3d
final_images_crop = final_test_images[:, row_1:row_2, col_1:col_2, :]
final_masks_crop = final_test_masks[:, row_1:row_2, col_1:col_2, :]
sitk.WriteImage(
sitk.GetImageFromArray(np.uint16(final_test_masks[:, :, :, 1])),
current_dir + '/DICOM/masksAortaGroundTruth.dcm')
# sitk.WriteImage(sitk.GetImageFromArray(np.uint16(final_test_masks[:, :, :, 2])), current_dir + '/DICOM/masksPulGroundTruth.dcm')
sitk.WriteImage(
sitk.GetImageFromArray(np.uint16(final_test_masks[:, :, :, 1])),
current_dir + '/mhd/masksAortaGroundTruth.mhd')
# sitk.WriteImage(sitk.GetImageFromArray(np.uint16(final_test_masks[:, :, :, 2])), current_dir + '/mhd/masksPulGroundTruth.mhd')
# clear the masks for the final step:
final_test_masks = np.where(final_test_masks == 0, 0, 0)
num_patches = int((sum(vol_slices) - slices) / gaps)
test_image = np.ndarray([1, slices, row, col, 1], dtype=np.int16)
predicted_mask_volume = np.ndarray(
[sum(vol_slices), row, col, nb_class], dtype=np.float32)
# model = DenseUNet_3D.get_3d_denseunet()
# model = UNet_3D.get_3d_unet_bn()
# model = RSUNet_3D.get_3d_rsunet(opti)
# model = UNet_3D.get_3d_wnet(opti)
model = UNet_3D.get_3d_unet()
# model = RSUNet_3D_Gerda.get_3d_rsunet_Gerdafeature(opti)
using_start_end = 1
start_slice = cm.start_slice
end_slice = -1
if use_existing:
model.load_weights(modelname)
for i in range(num_patches):
count1 = i * gaps
count2 = i * gaps + slices
test_image[0] = final_images_crop[count1:count2]
predicted_mask = model.predict(test_image)
if i == int(num_patches * 0.63):
vs.visualize_activation_in_layer_one_plot(
model, test_image, current_dir)
else:
pass
predicted_mask_volume[count1:count2] += predicted_mask[
0, :, :, :, :]
t = len(predicted_mask_volume)
for i in range(0, slices, gaps):
predicted_mask_volume[i:(
i +
gaps)] = predicted_mask_volume[i:(i + gaps)] / (i / gaps + 1)
for i in range(0, slices, gaps):
predicted_mask_volume[(t - i -
gaps):(t - i)] = predicted_mask_volume[
(t - i - gaps):(t - i)] / (i / gaps + 1)
for i in range(slices, (len(predicted_mask_volume) - slices)):
predicted_mask_volume[i] = predicted_mask_volume[i] / (slices /
gaps)
np.save(cm.workingPath.testingSet_path + 'testImages.npy',
final_images_crop)
np.save(cm.workingPath.testingSet_path + 'testMasks.npy',
final_masks_crop)
np.save(cm.workingPath.testingSet_path + 'masksTestPredicted.npy',
predicted_mask_volume)
final_images_crop = None
final_masks_crop = None
predicted_mask_volume = None
imgs_origin = np.load(cm.workingPath.testingSet_path +
'testImages.npy').astype(np.int16)
imgs_true = np.load(cm.workingPath.testingSet_path +
'testMasks.npy').astype(np.int8)
imgs_predict = np.load(cm.workingPath.testingSet_path +
'masksTestPredicted.npy').astype(np.float32)
imgs_predict_threshold = np.load(cm.workingPath.testingSet_path +
'masksTestPredicted.npy').astype(
np.float32)
########## ROC curve aorta
actual = imgs_true[:, :, :, 1].reshape(-1)
predictions = imgs_predict[:, :, :, 1].reshape(-1)
# predictions = np.where(predictions < (0.7), 0, 1)
false_positive_rate_aorta, true_positive_rate_aorta, thresholds_aorta = roc_curve(
actual, predictions, pos_label=1)
roc_auc_aorta = auc(false_positive_rate_aorta,
true_positive_rate_aorta)
plt.figure(1, figsize=(6, 6))
plt.figure(1)
plt.title('ROC of Aorta')
plt.plot(false_positive_rate_aorta, true_positive_rate_aorta, 'b')
label = 'AUC = %0.2f' % roc_auc_aorta
plt.legend(loc='lower right')
plt.plot([0, 1], [0, 1], 'r--')
plt.xlim([-0.0, 1.0])
plt.ylim([-0.0, 1.0])
plt.xlabel('False Positive Rate')
plt.ylabel('True Positive Rate')
# plt.show()
saveName = '/Plots/ROC_Aorta_curve.png'
plt.savefig(current_dir + saveName)
plt.close()
########## ROC curve pul
# actual = imgs_true[:, :, :, 2].reshape(-1)
# predictions = imgs_predict[:, :, :, 2].reshape(-1)
#
# false_positive_rate_pul, true_positive_rate_pul, thresholds_pul = roc_curve(actual, predictions, pos_label=1)
# roc_auc_pul = auc(false_positive_rate_pul, true_positive_rate_pul)
# plt.figure(2, figsize=(6, 6))
# plt.figure(2)
# plt.title('ROC of pul')
# plt.plot(false_positive_rate_pul, true_positive_rate_pul, 'b')
# label = 'AUC = %0.2f' % roc_auc_pul
# plt.legend(loc='lower right')
# plt.plot([0, 1], [0, 1], 'r--')
# plt.xlim([-0.0, 1.0])
# plt.ylim([-0.0, 1.0])
# plt.xlabel('False Positive Rate')
# plt.ylabel('True Positive Rate')
# # plt.show()
# saveName = '/Plots/ROC_Pul_curve.png'
# plt.savefig(current_dir + saveName)
# plt.close()
false_positive_rate_aorta = None
true_positive_rate_aorta = None
false_positive_rate_pul = None
true_positive_rate_pul = None
imgs_predict_threshold = np.where(imgs_predict_threshold < (0.5), 0, 1)
if using_start_end == 1:
aortaMean = lf.dice_coef_np(
imgs_predict_threshold[start_slice:end_slice, :, :, 1],
imgs_true[start_slice:end_slice, :, :, 1])
# pulMean = lf.dice_coef_np(imgs_predict_threshold[start_slice:end_slice, :, :, 2],
# imgs_true[start_slice:end_slice, :, :, 2])
else:
aortaMean = lf.dice_coef_np(imgs_predict_threshold[:, :, :, 1],
imgs_true[:, :, :, 1])
# pulMean = lf.dice_coef_np(imgs_predict_threshold[:, :, :, 2], imgs_true[:, :, :, 2])
np.savetxt(current_dir + '/Plots/AortaDicemean.txt',
np.array(aortaMean).reshape(1, ),
fmt='%.5f')
# np.savetxt(current_dir + '/Plots/PulDicemean.txt', np.array(pulMean).reshape(1, ), fmt='%.5f')
print('Model file:', modelname)
print('-' * 30)
print('Aorta Dice Coeff', aortaMean)
# print('Pul Dice Coeff', pulMean)
print('-' * 30)
# Draw the subplots of figures:
color1 = 'gray' # ***
color2 = 'viridis' # ******
# color = 'plasma' # **
# color = 'magma' # ***
# color2 = 'RdPu' # ***
# color = 'gray' # ***
# color = 'gray' # ***
transparent1 = 1.0
transparent2 = 0.5
# Slice parameters:
#################################### Aorta
# Automatically:
steps = 40
slice = range(0, len(imgs_origin), steps)
plt_row = 3
plt_col = int(len(imgs_origin) / steps)
plt.figure(3, figsize=(25, 12))
plt.figure(3)
for i in slice:
if i == 0:
plt_num = int(i / steps) + 1
else:
plt_num = int(i / steps)
if plt_num <= plt_col:
ax1 = plt.subplot(plt_row, plt_col, plt_num)
title = 'slice=' + str(i)
plt.title(title)
ax1.imshow(imgs_origin[i, :, :, 0],
cmap=color1,
alpha=transparent1)
ax1.imshow(imgs_true[i, :, :, 1],
cmap=color2,
alpha=transparent2)
ax2 = plt.subplot(plt_row, plt_col, plt_num + plt_col)
title = 'slice=' + str(i)
plt.title(title)
ax2.imshow(imgs_origin[i, :, :, 0],
cmap=color1,
alpha=transparent1)
ax2.imshow(imgs_predict[i, :, :, 1],
cmap=color2,
alpha=transparent2)
ax3 = plt.subplot(plt_row, plt_col, plt_num + 2 * plt_col)
title = 'slice=' + str(i)
plt.title(title)
ax3.imshow(imgs_origin[i, :, :, 0],
cmap=color1,
alpha=transparent1)
ax3.imshow(imgs_predict_threshold[i, :, :, 1],
cmap=color2,
alpha=transparent2)
else:
pass
modelname = cm.modellist[0]
imageName = re.findall(r'\d+\.?\d*', modelname)
epoch_num = int(imageName[0]) + 1
accuracy = float(
np.loadtxt(current_dir + '/Plots/AortaDicemean.txt', float))
# saveName = 'epoch_' + str(epoch_num) + '_dice_' +str(accuracy) + '.png'
saveName = '/Plots/epoch_Aorta_%02d_dice_%.3f.png' % (epoch_num - 1,
accuracy)
plt.subplots_adjust(left=0.0,
bottom=0.05,
right=1.0,
top=0.95,
hspace=0.3,
wspace=0.3)
plt.savefig(current_dir + saveName)
plt.close()
# plt.show()
################################ Pulmonary
# steps = 40
# slice = range(0, len(imgs_origin), steps)
# plt_row = 3
# plt_col = int(len(imgs_origin) / steps)
#
# plt.figure(4, figsize=(25, 12))
# plt.figure(4)
# for i in slice:
# if i == 0:
# plt_num = int(i / steps) + 1
# else:
# plt_num = int(i / steps)
#
# if plt_num <= plt_col:
#
# ax1 = plt.subplot(plt_row, plt_col, plt_num)
# title = 'slice=' + str(i)
# plt.title(title)
# ax1.imshow(imgs_origin[i, :, :, 0], cmap=color1, alpha=transparent1)
# ax1.imshow(imgs_true[i, :, :, 2], cmap=color2, alpha=transparent2)
#
# ax2 = plt.subplot(plt_row, plt_col, plt_num + plt_col)
# title = 'slice=' + str(i)
# plt.title(title)
# ax2.imshow(imgs_origin[i, :, :, 0], cmap=color1, alpha=transparent1)
# ax2.imshow(imgs_predict[i, :, :, 2], cmap=color2, alpha=transparent2)
#
# ax3 = plt.subplot(plt_row, plt_col, plt_num + 2 * plt_col)
# title = 'slice=' + str(i)
# plt.title(title)
# ax3.imshow(imgs_origin[i, :, :, 0], cmap=color1, alpha=transparent1)
# ax3.imshow(imgs_predict_threshold[i, :, :, 2], cmap=color2, alpha=transparent2)
# else:
# pass
#
# modelname = cm.modellist[0]
#
# imageName = re.findall(r'\d+\.?\d*', modelname)
# epoch_num = int(imageName[0]) + 1
# accuracy = float(np.loadtxt(current_dir + '/Plots/PulDicemean.txt', float))
#
# # saveName = 'epoch_' + str(epoch_num) + '_dice_' +str(accuracy) + '.png'
# saveName = '/Plots/epoch_Pul_%02d_dice_%.3f.png' % (epoch_num - 1, accuracy)
#
# plt.subplots_adjust(left=0.0, bottom=0.05, right=1.0, top=0.95, hspace=0.3, wspace=0.3)
# plt.savefig(current_dir + saveName)
# plt.close()
# # plt.show()
print('Images saved')
# Save npy as dcm files:
final_test_aorta_predicted_threshold = final_test_masks[:, :, :, 1]
# final_test_pul_predicted_threshold = final_test_masks[:, :, :, 2]
final_test_aorta_predicted_threshold[:, row_1:row_2, col_1:
col_2] = imgs_predict_threshold[:, :, :,
1]
# final_test_pul_predicted_threshold[:, row_1:row_2, col_1:col_2] = imgs_predict_threshold[:, :, :, 2]
new_imgs_dcm = sitk.GetImageFromArray(
np.uint16(final_test_images + 4000))
new_imgs_aorta_predict_dcm = sitk.GetImageFromArray(
np.uint16(final_test_aorta_predicted_threshold))
# new_imgs_pul_predict_dcm = sitk.GetImageFromArray(np.uint16(final_test_pul_predicted_threshold))
sitk.WriteImage(new_imgs_dcm,
current_dir + '/DICOM/imagesPredicted.dcm')
sitk.WriteImage(new_imgs_aorta_predict_dcm,
current_dir + '/DICOM/masksAortaPredicted.dcm')
# sitk.WriteImage(new_imgs_pul_predict_dcm, current_dir + '/DICOM/masksPulPredicted.dcm')
sitk.WriteImage(new_imgs_dcm, current_dir + '/mhd/imagesPredicted.mhd')
sitk.WriteImage(new_imgs_aorta_predict_dcm,
current_dir + '/mhd/masksAortaPredicted.mhd')
# sitk.WriteImage(new_imgs_pul_predict_dcm, current_dir + '/mhd/masksPulPredicted.mhd')
mt.SegmentDist(current_dir + '/mhd/masksAortaPredicted.mhd',
current_dir + '/mhd/masksAortaGroundTruth.mhd',
current_dir + '/Surface_Distance/Aorta')
# mt.SegmentDist(current_dir + '/mhd/masksPulPredicted.mhd',current_dir + '/mhd/masksPulGroundTruth.mhd', current_dir + '/Surface_Distance/Pul')
# ds1 = dicom.read_file(maskAortaFile_list[0])
# ds2 = dicom.read_file(cm.workingPath.testingSet_path + 'masksAortaPredicted.dcm')
# ds1.PixelData = ds2.PixelData
# ds1.pop('pixel_array')
# ds1["pixel_array"] = ds2["pixel_array"]
# ds1.save_as(cm.workingPath.testingSet_path + 'masksAortaPredicted.dcm')
# ds1.save_as(cm.workingPath.testingSet_path + 'masksAortaPredicted.mhd')
#
# ds1 = dicom.read_file(maskPulFile_list[0])
# ds2 = dicom.read_file(cm.workingPath.testingSet_path + 'masksPulPredicted.dcm')
# ds1.PixelData = ds2.PixelData
# ds1["pixelarray"] = ds2["pixelarray"]
# ds1.save_as(cm.workingPath.testingSet_path + 'masksPulPredicted.dcm')
# ds1.save_as(cm.workingPath.testingSet_path + 'masksPulPredicted.mhd')
print('DICOM saved')
# Clear memory for the next testing sample:
final_test_aorta_predicted_threshold = None
final_test_pul_predicted_threshold = None
imgs_predict_threshold = None
new_imgs_dcm = None
new_imgs_aorta_predict_dcm = None
new_imgs_pul_predict_dcm = None
final_test_images = None
final_test_masks = None
imgs_origin = None
imgs_predict = None
imgs_true = None
predicted_mask = None
predictions = None
endtime = datetime.datetime.now()
print('-' * 30)
print('running time:', endtime - starttime)
log_file.close()
sys.stdout = stdout_backup
def write_APS_file(awgData, fileName, miniLLRepeat=1):
'''
Main function to pack channel LLs into an APS h5 file.
'''
#Preprocess the LL data to handle APS restrictions
LLs12 = [
preprocess_APS(miniLL, awgData['ch12']['wfLib'])
for miniLL in awgData['ch12']['linkList']
]
LLs34 = [
preprocess_APS(miniLL, awgData['ch34']['wfLib'])
for miniLL in awgData['ch34']['linkList']
]
#Merge the the marker data into the IQ linklists
merge_APS_markerData(LLs12, awgData['ch1m1']['linkList'], 1)
merge_APS_markerData(LLs12, awgData['ch2m1']['linkList'], 2)
merge_APS_markerData(LLs34, awgData['ch3m1']['linkList'], 1)
merge_APS_markerData(LLs34, awgData['ch4m1']['linkList'], 2)
#Open the HDF5 file
if os.path.isfile(fileName):
os.remove(fileName)
with h5py.File(fileName, 'w') as FID:
#List of which channels we have data for
#TODO: actually handle incomplete channel data
channelDataFor = [1, 2, 3, 4]
FID['/'].attrs['Version'] = 2.0
FID['/'].attrs['channelDataFor'] = np.uint16(channelDataFor)
FID['/'].attrs['miniLLRepeat'] = np.uint16(miniLLRepeat - 1)
#Create the waveform vectors
wfInfo = []
for wfLib in (awgData['ch12']['wfLib'], awgData['ch34']['wfLib']):
wfInfo.append(
create_wf_vector({key: wf.real
for key, wf in wfLib.items()}))
wfInfo.append(
create_wf_vector({key: wf.imag
for key, wf in wfLib.items()}))
LLData = [LLs12, LLs34]
#Create the groups and datasets
for chanct in range(4):
chanStr = '/chan_{0}'.format(chanct + 1)
chanGroup = FID.create_group(chanStr)
chanGroup.attrs['isIQMode'] = np.uint8(1)
#Write the waveformLib to file
FID.create_dataset('{0}/waveformLib'.format(chanStr),
data=wfInfo[chanct][0])
#For A channels (1 & 3) we write link list data
if np.mod(chanct, 2) == 0:
chanGroup.attrs['isLinkListData'] = np.uint8(1)
groupStr = chanStr + '/linkListData'
LLGroup = FID.create_group(groupStr)
LLDataVecs, numEntries = create_LL_data(
LLData[chanct // 2], wfInfo[chanct][1],
os.path.basename(fileName))
LLGroup.attrs['length'] = numEntries
for key, dataVec in LLDataVecs.items():
FID.create_dataset(groupStr + '/' + key, data=dataVec)
else:
chanGroup.attrs['isLinkListData'] = np.uint8(0)
def single2uint16(img):
return np.uint16((img.clip(0, 1) * 65535.).round())
def run():
if not 'screenshots' in os.listdir('./'):
os.mkdir('./screenshots')
#load Matlab data
# import scipy.io
# mri = scipy.io.loadmat('brainweb_128.mat')
# activity = scipy.io.loadmat('L.mat')
# v1 = uint16( activity['L']*(2**16*(1.0/dynrange)/activity['L'].max()) )
# v2 = uint16( mri['t1_128']*(2**16/mri['t1_128'].max()) )
#load Nifty data
from nifti import NiftiImage
v1 = NiftiImage('./activity_128.nii').data
v2 = 0 * v1
#create volume renderer and initialize it
V = VolumeRender((N, N, N), (512, 512))
V.show()
V.set_volume1(v1)
V.set_volume2(v2)
#set visualization parameters
V.set_density1(0.05)
V.set_brightness1(7.1)
V.set_transferOffset1(-0.04)
V.set_transferScale1(1.1)
V.set_density2(0.05)
V.set_brightness2(0.3)
V.set_transferOffset2(0.05)
V.set_transferScale2(1)
#visualize a dynamic scene and save screenshots
N_frames = N * image_steps
d_rotation_x = 0.0
d_rotation_y = 0.5
d_zoom = 0.004
im_frame_prev = 0
frame = 0
t_frame = 0
while 1:
frame += 1
if frame < 1460:
t_frame += 1
if frame < 150 + 250:
V.rotate(d_rotation_x, d_rotation_y)
if (frame > 150 + 150 and frame < 150 + 500):
V.zoom(d_zoom)
if frame > 150 + 250:
V.rotate(d_rotation_x / 4, d_rotation_y / 4)
im_frame = t_frame / image_steps
if not im_frame == im_frame_prev:
im_frame_prev = im_frame
if (im_frame < (N - thickness)):
v1b = double(v1)
v1b[:, :,
im_frame:im_frame + thickness] = dynrange * double(
v1[:, :, im_frame:im_frame + thickness])
#v1b = v1b*(2**16/v1b.max())
V.set_volume1(uint16(v1b))
if frame > 1500:
t_frame -= 1
im_frame = t_frame / image_steps
if not im_frame == im_frame_prev:
im_frame_prev = im_frame
if (im_frame < (N - thickness)):
v1b = double(v1)
v1b[:, :,
im_frame:im_frame + thickness] = dynrange * double(
v1[:, :, im_frame:im_frame + thickness])
#v1b = v1b*(2**16/v1b.max())
V.set_volume1(uint16(v1b))
if (frame > 2550 + 100):
break
elif (frame > 2550 + 75):
V.zoom(-d_zoom * 3.5)
elif frame > 2550:
V.rotate(d_rotation_x, d_rotation_y)
V.zoom(-d_zoom * 3.5)
V.dump_screenshot("./screenshots/%d.png" % frame)
sleep(0.003)
while 1:
pass
def generate_advanced_indices(self, N, many=True):
choices = [np.int16([0, N - 1, -2])]
if many:
choices += [np.uint16([0, 1, N - 1]), np.bool_([0, 1, 1, 0])]
return choices
process_pdf(rsrcmgr, device, pdf)
device.close()
content = retstr.getvalue()
retstr.close()
# 获取所有行
lines = str(content).split("\n")
return lines
#%%
my_pdf = open(mypdf[0], "rb")
out = read_pdf(my_pdf)
my_pdf.close()
theta_s = np.float64(out[40])
date = out[36]
year = np.uint16(date.split('年')[0])
tmp1 = date.split('月')
month = np.uint8(tmp1[0].split('年')[-1])
day = np.uint8(tmp1[1].split('日')[0])
for i in range(len(out)):
each = out[i]
if '增益参数' in each:
# print(i)
gain = out[i + 3:i + 3 + 32]
if '偏移参数' in each:
# print(i)
bias = out[i + 3:i + 3 + 32]
gain = np.float32(gain)
bias = np.float32(bias)
def read_str_u16(f):
return np.uint16(read_str_int(f, 'u16'))
def unpack(file):
"""Unpacks PulsOn 440 radar data from input file"""
with open(file, 'rb') as f:
# Read in configuration data
config_message = f.read(44)
config = dict()
config['type'] = hex(
np.frombuffer(config_message[0:2], dtype='>u2')[0])
config['id'] = np.frombuffer(config_message[2:4], dtype='>u2')[0]
config['node_id'] = np.frombuffer(config_message[4:8], dtype='>u4')[0]
config['scan_start'] = np.frombuffer(config_message[8:12],
dtype='>i4')[0]
config['scan_end'] = np.frombuffer(config_message[12:16],
dtype='>i4')[0]
config['scan_res'] = np.frombuffer(config_message[16:18],
dtype='>u2')[0]
config['pii'] = np.frombuffer(config_message[18:20], dtype='>u2')[0]
config['ant_mode'] = np.uint16(config_message[32])
config['tx_gain'] = np.uint16(config_message[33])
config['code_chan'] = np.uint16(config_message[34])
config['persist_flag'] = np.uint16(config_message[35])
config['time_stamp'] = np.frombuffer(config_message[36:40],
dtype='>u4')[0]
config['status'] = np.frombuffer(config_message[40:44], dtype='>u4')[0]
# Compute number of range bins in data
dTmin = 1 / (512 * 1.024)
Tbin = 32 * dTmin
dNbin = 96
dT0 = 10
scan_start_time = float(config['scan_start'])
scan_end_time = float(config['scan_end'])
num_range_bins = dNbin * math.ceil(
(scan_end_time - scan_start_time) / (Tbin * 1000 * dNbin))
num_packets_per_scan = math.ceil(num_range_bins / 350)
start_range = SPEED_OF_LIGHT * (
(scan_start_time * 1e-12) - dT0 * 1e-9) / 2
drange_bins = SPEED_OF_LIGHT * Tbin * 1e-9 / 2
range_bins = start_range + drange_bins * np.arange(
0, num_range_bins, 1)
# Read data
data = dict()
data = {
'scan_data': [],
'time_stamp': [],
'packet_ind': [],
'packet_pulse_ind': [],
'range_bins': range_bins
}
single_scan_data = []
packet_count = 0
pulse_count = 0
while True:
# Read a single data packet and break loop if not a complete packet
# (in terms of size)
packet = f.read(1452)
if len(packet) < 1452:
break
packet_count += 1
# Packet index
data['packet_ind'].append(np.frombuffer(packet[48:50], dtype='u2'))
# Extract radar data samples from current packet; process last
# packet within a scan seperately to get all data
if packet_count % num_packets_per_scan == 0:
num_samples = num_range_bins % 350
packet_data = np.frombuffer(packet[52:(52 + 4 * num_samples)],
dtype='>i4')
single_scan_data.append(packet_data)
data['scan_data'].append(np.concatenate(single_scan_data))
data['time_stamp'].append(
np.frombuffer(packet[8:12], dtype='>u4'))
single_scan_data = []
pulse_count += 1
else:
num_samples = 350
packet_data = np.frombuffer(packet[52:(52 + 4 * num_samples)],
dtype='>i4')
single_scan_data.append(packet_data)
# Add last partial scan if present
if single_scan_data:
single_scan_data = np.concatenate(single_scan_data)
num_pad = data['scan_data'][0].size - single_scan_data.size
single_scan_data = np.pad(single_scan_data, (0, num_pad),
'constant',
constant_values=0)
data['scan_data'].append(single_scan_data)
# Stack scan data into 2-D array
# (rows -> pulses, columns -> range bins)
data['scan_data'] = np.stack(data['scan_data'])
# Finalize remaining entries in data
data['time_stamp']
return data
def bilateral_filter(self, edge):
# bilateral filter based upon the work of
# Jiawen Chen, Sylvain Paris, and Fredo Durand, 2007 work
# note: if edge data is not provided, image is served as edge
# this is called normal bilateral filter
# if edge data is provided, then it is called cross or joint
# bilateral filter
# get width and height of the image
width, height = helpers(self.data).get_width_height()
# sigma_spatial
sigma_spatial = min(height, width) / 16.
# calculate edge_delta
edge_min = np.min(edge)
edge_max = np.max(edge)
edge_delta = edge_max - edge_min
# sigma_range and sampling_range
sigma_range = 0.1 * edge_delta
sampling_range = sigma_range
sampling_spatial = sigma_spatial
# derived_sigma_spatial and derived_sigma_range
derived_sigma_spatial = sigma_spatial / sampling_spatial
derived_sigma_range = sigma_range / sampling_range
# paddings
padding_xy = np.floor(2. * derived_sigma_spatial) + 1.
padding_z = np.floor(2. * derived_sigma_range) + 1.
# downsamples
downsample_width = np.uint16(
np.floor((width - 1.) / sampling_spatial) + 1. + 2. * padding_xy)
downsample_height = np.uint16(
np.floor((height - 1.) / sampling_spatial) + 1. + 2. * padding_xy)
downsample_depth = np.uint16(
np.floor(edge_delta / sampling_range) + 1. + 2. * padding_z)
grid_data = np.zeros(
(downsample_height, downsample_width, downsample_depth))
grid_weight = np.zeros(
(downsample_height, downsample_width, downsample_depth))
jj, ii = np.meshgrid(np.arange(0, width, 1),
np.arange(0, height, 1))
di = np.uint16(np.round(ii / sampling_spatial) + padding_xy + 1.)
dj = np.uint16(np.round(jj / sampling_spatial) + padding_xy + 1.)
dz = np.uint16(np.round((edge - edge_min) /
sampling_range) + padding_z + 1.)
for i in range(0, height):
for j in range(0, width):
data_z = self.data[i, j]
if not np.isnan(data_z):
dik = di[i, j]
djk = dj[i, j]
dzk = dz[i, j]
grid_data[dik, djk, dzk] = grid_data[dik,
djk, dzk] + data_z
grid_weight[dik, djk,
dzk] = grid_weight[dik, djk, dzk] + 1.
kernel_width = 2. * derived_sigma_spatial + 1.
kernel_height = kernel_width
kernel_depth = 2. * derived_sigma_range + 1.
half_kernel_width = np.floor(kernel_width / 2.)
half_kernel_height = np.floor(kernel_height / 2.)
half_kernel_depth = np.floor(kernel_depth / 2.)
grid_x, grid_y, grid_z = np.meshgrid(np.arange(0, kernel_width, 1),
np.arange(0, kernel_height, 1),
np.arange(0, kernel_depth, 1))
grid_x = grid_x - half_kernel_width
grid_y = grid_y - half_kernel_height
grid_z = grid_z - half_kernel_depth
grid_r_squared = ((np.multiply(grid_x, grid_x) +
np.multiply(grid_y, grid_y)) / np.multiply(derived_sigma_spatial, derived_sigma_spatial)) + \
(np.multiply(grid_z, grid_z) /
np.multiply(derived_sigma_range, derived_sigma_range))
kernel = np.exp(-0.5 * grid_r_squared)
blurred_grid_data = ndimage.convolve(grid_data, kernel, mode='reflect')
blurred_grid_weight = ndimage.convolve(
grid_weight, kernel, mode='reflect')
# divide
blurred_grid_weight = np.asarray(blurred_grid_weight)
mask = blurred_grid_weight == 0
blurred_grid_weight[mask] = -2.
normalized_blurred_grid = np.divide(
blurred_grid_data, blurred_grid_weight)
mask = blurred_grid_weight < -1
normalized_blurred_grid[mask] = 0.
blurred_grid_weight[mask] = 0.
# upsample
jj, ii = np.meshgrid(np.arange(0, width, 1),
np.arange(0, height, 1))
di = (ii / sampling_spatial) + padding_xy + 1.
dj = (jj / sampling_spatial) + padding_xy + 1.
dz = (edge - edge_min) / sampling_range + padding_z + 1.
# arrange the input points
n_i, n_j, n_z = np.shape(normalized_blurred_grid)
points = (np.arange(0, n_i, 1), np.arange(
0, n_j, 1), np.arange(0, n_z, 1))
# query points
xi = (di, dj, dz)
# multidimensional interpolation
output = interpolate.interpn(
points, normalized_blurred_grid, xi, method='linear')
return output
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
# Blur using 3 * 3 kernel.
gray_blurred = cv2.blur(gray, (3, 3))
# Apply Hough transform on the blurred image.
detected_circles = cv2.HoughCircles(gray_blurred,
cv2.HOUGH_GRADIENT,
1,
20,
param1=50,
param2=30,
minRadius=1,
maxRadius=40)
# Draw circles that are detected.
if detected_circles is not None:
# Convert the circle parameters a, b and r to integers.
detected_circles = np.uint16(np.around(detected_circles))
for pt in detected_circles[0, :]:
a, b, r = pt[0], pt[1], pt[2]
# Draw the circumference of the circle.
cv2.circle(img, (a, b), r, (0, 255, 0), 2)
# Draw a small circle (of radius 1) to show the center.
cv2.circle(img, (a, b), 1, (0, 0, 255), 3)
cv2.imshow("Detected Circle", img)
cv2.waitKey(0)
track[0, :, w, u] = track_initials[w, :, u]
Diffusion_selection = npy.random.multinomial(1, weights)
Diffusion_selection_elem = npy.nonzero(Diffusion_selection)
Diffuse_state = npy.sum(Diffusion_selection_elem)
track_D[w, 0, u] = Diffuse_state
for j in range(num_bacteria):
yst_image = cv2.circle(image, (int(bac_cells[j, 0]), int(bac_cells[j, 1])),
int(bac_cells[j, 2]), (0, 255, 0), -1, 8)
yst_image_final = cv2.cvtColor(yst_image, cv2.COLOR_BGR2GRAY)
# Check if the circles are overlapping
yst_image_16_reform = yst_image_final.reshape(pixels, resolution, pixels,
resolution).sum(3).sum(1)
yst_image_16 = npy.uint16(yst_image_16_reform)
non_zer_find = npy.nonzero(yst_image_16)
yst_image_16[yst_image_16 != 0] = 1
filename_bin = filename.replace(".tif", "_binary.tif")
#filename_bin.replace(".tif", "binary.tif")
#print(filename_bin)
cv2.imwrite(filename_bin, yst_image_16)
print('Initialization Complete')
with tifffile.TiffWriter(filename, bigtiff=True) as tif:
yst_array = npy.array(yst_image_final)
max_cell_value = npy.amax(yst_array)
index_max = npy.argwhere(yst_array == max_cell_value)
#index_max_background = npy.argwhere(rt4 != max_cell_value)
#rt4[index_max] = cell_background
for m in range(len(index_max)):
