def ComprobarLista2(self):
if len(self.L_L_Goals) == 0:
return
with QtCore.QMutexLocker(self.mutex_bus):
try:
for x in range(0, len(self.L_L_Goals)):
with QtCore.QMutexLocker(self.mutex_goals):
m = self.L_L_Goals.pop(0)
for goal in m:
for x in self.motorParams:
if x.name == goal.name:
busId = x.busId
break
if x.invertedSign == "true":
goal.position = -goal.position
pos = np.ushort((goal.position + 2.618) * (1023 - 0) /
(2.618 + 2.618))
vel = np.ushort(goal.maxSpeed)
dynamixel.set_velocity(self.bus,
busId,
vel,
False,
num_error_attempts=1)
dynamixel.set_position(self.bus,
busId,
pos,
False,
num_error_attempts=1)
dynamixel.send_action_packet(self.bus)
except Ice.Exception, e:
traceback.print_exc()
print e
def calc_checksum(data):
"""Calculates the checksum of a package as described in the Nortek
integrators Section 10.2 verson Mar2016
"""
hChecksum = np.ushort(0xb58c)
for i in range(0,len(data),2):
tmp = int.from_bytes(data[i:i+2], byteorder='little')
hChecksum += tmp
return np.ushort(hChecksum)
def getpathintegers(m1, uptolength=7):
'''returns a list of integers describing the paths for molecule m1. This uses numpy 16 bit unsigned integers to reproduce the data in the Gobbi paper. The returned list is sorted'''
bondtypelookup = {}
for b in m1.GetBonds():
bondtypelookup[b.GetIdx()] = _BK_[b.GetBondType()], b.GetBeginAtom(), b.GetEndAtom()
pathintegers = {}
for a in m1.GetAtoms():
idx = a.GetIdx()
pathintegers[idx] = []
# for pathlength in range(1, uptolength+1):
# for path in rdmolops.FindAllPathsOfLengthN(m1, pathlength, rootedAtAtom=idx):
for ipath, path in enumerate(
FindAllPathsOfLengthMToN_Gobbi(m1, 1, uptolength, rootedAtAtom=idx, uniquepaths=False)):
strpath = []
currentidx = idx
res = []
for ip, p in enumerate(path):
bk, a1, a2 = bondtypelookup[p]
strpath.append(_BONDSYMBOL_[bk])
if a1.GetIdx() == currentidx:
a = a2
else:
a = a1
ak = a.GetAtomicNum()
if a.GetIsAromatic():
ak += 108
#trying to get the same behaviour as the Gobbi test code - it looks like a circular path includes the bond, but not the closure atom - this fix works
if a.GetIdx() == idx:
ak = None
if ak is not None:
astr = a.GetSymbol()
if a.GetIsAromatic():
strpath.append(astr.lower())
else:
strpath.append(astr)
res.append((bk, ak))
currentidx = a.GetIdx()
pathuniqueint = numpy.ushort(0) # work with 16 bit unsigned integers and ignore overflow...
for ires, (bi, ai) in enumerate(res):
#use 16 bit unsigned integer arithmetic to reproduce the Gobbi ints
# pathuniqueint = ((pathuniqueint+bi)*_nAT_+ai)*_nBT_
val1 = pathuniqueint + numpy.ushort(bi)
val2 = val1 * numpy.ushort(_nAT_)
#trying to get the same behaviour as the Gobbi test code - it looks like a circular path includes the bond, but not the closure atom - this fix works
if ai is not None:
val3 = val2 + numpy.ushort(ai)
val4 = val3 * numpy.ushort(_nBT_)
else:
val4 = val2
pathuniqueint = val4
pathintegers[idx].append(pathuniqueint)
#sorted lists allow for a quicker comparison algorithm
for p in pathintegers.values():
p.sort()
return pathintegers
def build_land_mask(quality_flags, bits):
""" Extand land mask to avoid detecting extreme values near the coast
while detecting min and max values. """
land_mask = numpy.zeros(quality_flags.shape, dtype='bool')
land_bit = numpy.ushort(1 << bits['land'])
coast_bit = numpy.ushort(1 << bits['coastline'])
land_mask = (land_mask | (numpy.bitwise_and(quality_flags, land_bit) > 0) |
(numpy.bitwise_and(quality_flags, coast_bit) > 0))
# Dilatation of land mask to remove coastal values
dil_kern = numpy.ones((5, 5), dtype='bool')
land_mask = binary_dilation(land_mask, structure=dil_kern)
return land_mask
def test_numpy(self):
"""NumPy objects get serialized to readable JSON."""
l = [
np.float32(12.5),
np.float64(2.0),
np.float16(0.5),
np.bool(True),
np.bool(False),
np.bool_(True),
np.unicode_("hello"),
np.byte(12),
np.short(12),
np.intc(-13),
np.int_(0),
np.longlong(100),
np.intp(7),
np.ubyte(12),
np.ushort(12),
np.uintc(13),
np.ulonglong(100),
np.uintp(7),
np.int8(1),
np.int16(3),
np.int32(4),
np.int64(5),
np.uint8(1),
np.uint16(3),
np.uint32(4),
np.uint64(5),
]
l2 = [l, np.array([1, 2, 3])]
roundtripped = loads(dumps(l2, cls=EliotJSONEncoder))
self.assertEqual([l, [1, 2, 3]], roundtripped)
def test_numpy(self):
"""NumPy objects get serialized to readable JSON."""
l = [
np.float32(12.5),
np.float64(2.0),
np.float16(0.5),
np.bool(True),
np.bool(False),
np.bool_(True),
np.unicode_("hello"),
np.byte(12),
np.short(12),
np.intc(-13),
np.int_(0),
np.longlong(100),
np.intp(7),
np.ubyte(12),
np.ushort(12),
np.uintc(13),
np.ulonglong(100),
np.uintp(7),
np.int8(1),
np.int16(3),
np.int32(4),
np.int64(5),
np.uint8(1),
np.uint16(3),
np.uint32(4),
np.uint64(5),
]
l2 = [l, np.array([1, 2, 3])]
roundtripped = loads(dumps(l2, cls=EliotJSONEncoder))
self.assertEqual([l, [1, 2, 3]], roundtripped)
def from_s(value, idx): # type: (np.float, np.float) -> str or np.nan
if pd.isnull(value) or isinstance(value, string_types):
return value
value = np.ushort(value)
name = (series.name if series.name in manycat2threecat else
to_manycat_name(series.name))
mapped = manycat2threecat.get(name)
try:
result = (value if mapped is None or len(mapped) < value else
mapped[4 if value == 5 else value])
except IndexError:
just = 20
print(
"mapped:".ljust(just),
"{!r}\n".format(mapped),
"value:".ljust(just),
"{!r}\n".format(value),
"idx:".ljust(just),
"{!r}\n".format(idx),
sep="",
)
print(series.index)
raise
return result
def setPosition(self, goal): m = [x for x in self.motorParams if x.name == goal.name] if len(m)>0: position=(goal.position + 2.618) * (1023 - 0) / (2.618 + 2.618) pos=np.ushort(position) dynamixel.set_position(self.bus, (m[0].busId),pos) dynamixel.send_action_packet(self.bus)
def setVelocity(self, goal): m = [x for x in self.motorParams if x.name == goal.name] if len(m)>0: pos=np.ushort(goal.velocity) dynamixel.set_velocity(self.bus, (m[0].busId),pos) dynamixel.send_action_packet(self.bus)
def setVelocity(self, goal):
m = [x for x in self.motorParams if x.name == goal.name]
if len(m) > 0:
pos = np.ushort(goal.velocity)
dynamixel.set_velocity(self.bus, (m[0].busId), pos)
dynamixel.send_action_packet(self.bus)
def generate_old_series(patternparms):
""" Generate a stripe series from the patternparms.
patternparms is a list of tuples: (pitch, angle, phase, wavelength),
where pitch is in microns, and both the angle and phase are specified
in radians.
"""
xindices = np.arange(512)
yindices = np.arange(512)
kk, ll = meshgrid(xindices, yindices)
sequence = []
mp2 = 1.5
for realpitch, angle, phase, waves, wavelength in patternparms:
pitch = realpitch / 15.0
pattern = np.ushort(
rint(
(mp2 / pi) *
(32767.5 + 32767.5 *
(mp2 / pi) * cos(phase + 2. * pi *
(kk * cos(angle) + ll * sin(angle)) / pitch))
))
# Scale to green LUT range
pattern *= (16256. / 65536.)
pattern += 49279
sequence.append(pattern)
return sequence
def setPosition(self, goal):
m = [x for x in self.motorParams if x.name == goal.name]
if len(m) > 0:
position = (goal.position + 2.618) * (1023 - 0) / (2.618 + 2.618)
pos = np.ushort(position)
dynamixel.set_position(self.bus, (m[0].busId), pos)
dynamixel.send_action_packet(self.bus)
def writesufp(fpout, amp, hdr, scale=1):
# fpout = opened file to write the data to
# amp = matrix containing the amplitudes of the data
# hdr = header object containing the headers for the data
# scale = scale the header data from python format to SU format (=1) or not (=0)
# Set global variables
global vari
global vari_bytes
# Scale the data back to the SU format
if scale == 1:
scalel = hdr.scalel[0]
scalco = hdr.scalco[0]
if scalel < 0:
scaledep = float(-1.0 / scalel)
elif scalel == 0:
scaledep = 1.0
else:
scaledep = float(scalel)
if scalco < 0:
scalepos = float(-1.0 / scalco)
elif scalco == 0:
scalepos = 1.0
else:
scalepos = float(scalco)
else:
scaledep = 1.0
scalepos = 1.0
# Get the size of the data to be written
[nz, nx] = np.shape(amp)
# Write out the data, check for the appropiate header format for every attribute
for ix in range(nx):
for ih in range(94):
if ih < 80:
if vari[ih] in vari[12:19]:
attrib = getattr(hdr, vari[ih]) / scaledep
elif vari[ih] in vari[21:25]:
attrib = getattr(hdr, vari[ih]) / scalepos
else:
attrib = getattr(hdr, vari[ih])
if vari_bytes[ih] == 'i':
fpout.write(struct.pack(vari_bytes[ih], int(attrib[ix])))
elif vari_bytes[ih] == 'h' and ih < 80:
fpout.write(struct.pack(vari_bytes[ih], np.short(attrib[ix])))
elif vari_bytes[ih] == 'h' and ih > 79:
fpout.write(struct.pack(vari_bytes[ih], np.short(0)))
elif vari_bytes[ih] == 'H':
fpout.write(struct.pack(vari_bytes[ih], np.ushort(attrib[ix])))
elif vari_bytes[ih] == 'f':
fpout.write(struct.pack(vari_bytes[ih], float(attrib[ix])))
data = amp[:, ix]
fpout.write(struct.pack('<%df' % len(data), *data))
def process(var):
global sym,symval
if var in symval:
return symval[var]
if(var.isdigit()):
return np.ushort(var)
ins = sym[var]
i = ins[0]
if(i == 'x'):
symval[var] = process(ins[1])
return np.ushort(symval[var])
elif(i == 'n'):
symval[var] = ~process(ins[1])
return np.ushort(symval[var])
elif(i == 'a'):
symval[var] = process(ins[1]) & process(ins[2])
return np.ushort(symval[var])
elif(i == 'o'):
symval[var] = process(ins[1]) | process(ins[2])
return np.ushort(symval[var])
elif(i == 'l'):
symval[var] = process(ins[1]) << process(ins[2])
return np.ushort(symval[var])
elif(i == 'r'):
symval[var] = process(ins[1]) >> process(ins[2])
return np.ushort(symval[var])
def ComprobarLista(self):
if len(self.lisPos) == 0:
return
try:
m = self.lisPos.popleft()
for x in self.motorParams:
if x.name == m.name:
busId = x.busId
break
pos = np.ushort(
(m.position + 2.618) * (1023 - 0) / (2.618 + 2.618))
vel = np.ushort(m.maxSpeed)
dynamixel.set_velocity(self.bus, busId, vel)
dynamixel.set_position(self.bus, busId, pos)
dynamixel.send_action_packet(self.bus)
except Ice.Exception, e:
traceback.print_exc()
print e
def ComprobarLista(self): if len(self.lisPos) == 0: return try: m = self.lisPos.popleft() for x in self.motorParams: if x.name == m.name: busId = x.busId break pos = np.ushort((m.position + 2.618) * (1023 - 0) / (2.618 + 2.618)) vel = np.ushort(m.maxSpeed) dynamixel.set_velocity(self.bus,busId, vel) dynamixel.set_position(self.bus, busId, pos) dynamixel.send_action_packet(self.bus) except Ice.Exception, e: traceback.print_exc() print e
def build_mask_rgb(channels, quality_flags, tie_lat, lat_crop):
""""""
bits = {
'coastline': 0,
'ocean': 1,
'tidal': 2,
'land': 3,
'inland_water': 4,
'unfilled': 5,
'spare': 6,
'spare_': 7,
'cosmetic': 8,
'duplicate': 9,
'day': 10,
'twilight': 11,
'sun_glint': 12,
'snow': 13,
'summary_cloud': 14,
'summary_pointing': 15
}
# Invalidate if these flags are all off
on_flags = numpy.ushort(0)
on_flags = on_flags + numpy.ushort(1 << bits['day'])
# Invalidate if any of these flags is on
off_flags = numpy.ushort(0)
off_flags = off_flags + numpy.ushort(1 << bits['coastline'])
off_flags = off_flags + numpy.ushort(1 << bits['land'])
off_flags = off_flags + numpy.ushort(1 << bits['snow'])
# Intialize mask to compute histograms on selected valid values
contrast_mask = numpy.zeros(quality_flags.shape, dtype='bool')
# Initialize mask to remove invalid data
data_mask = numpy.zeros(quality_flags.shape, dtype='bool')
lat_mask = (numpy.abs(tie_lat) > lat_crop)
contrast_mask = (contrast_mask | lat_mask)
data_mask = (data_mask | lat_mask)
# Mask data under sun_glint too
off_flags = off_flags + numpy.uint32(1 << bits['sun_glint'])
contrast_mask = (contrast_mask |
(numpy.bitwise_and(quality_flags, on_flags) <= 0) |
(numpy.bitwise_and(quality_flags, off_flags) > 0))
# Granules containing only night/twilight data must be ignored.
# Twilight data are only useful to improve the contrast when there is
# at least some daily data.
on_flags = numpy.ushort(0)
on_flags |= 1 << bits['day']
data_mask = (data_mask | (numpy.bitwise_and(quality_flags, on_flags) <= 0))
if data_mask.all():
raise OnlyNightData()
return contrast_mask, data_mask
def write_smv(self, path: str, i: int) -> str:
"""Write the image+header with sequence number `i` to the directory
`path` in SMV format.
Returns the path to the written image.
"""
img = self.data[i]
h = self.headers[i]
img = np.ushort(img)
shape_x, shape_y = img.shape
phi = self.start_angle + self.osc_angle * (i - 1)
# TODO: Dials reads the beam_center from the first image and uses that for the whole range
# For now, use the average beam center and consider it stationary, remove this line later
mean_beam_center = self.mean_beam_center
try:
date = str(datetime.fromtimestamp(h['ImageGetTime']))
except BaseException:
date = '0'
header = collections.OrderedDict()
header['HEADER_BYTES'] = 512
header['DIM'] = 2
header['BYTE_ORDER'] = 'little_endian'
header['TYPE'] = 'unsigned_short'
header['SIZE1'] = shape_x
header['SIZE2'] = shape_y
header['PIXEL_SIZE'] = self.physical_pixelsize
header['BIN'] = '1x1'
header['BIN_TYPE'] = 'HW'
header['ADC'] = 'fast'
header['CREV'] = 1
header['BEAMLINE'] = self.name # special ID for DIALS
header['DETECTOR_SN'] = 901 # special ID for DIALS
header['DATE'] = date
header['TIME'] = str(h['ImageExposureTime'])
header['DISTANCE'] = f'{self.distance:.4f}'
header['TWOTHETA'] = 0.00
header['PHI'] = '{phi:.4f}'
header['OSC_START'] = f'{phi:.4f}'
header['OSC_RANGE'] = f'{self.osc_angle:.4f}'
header['WAVELENGTH'] = f'{self.wavelength:.4f}'
# reverse XY coordinates for XDS
header['BEAM_CENTER_X'] = f'{mean_beam_center[1]:.4f}'
header['BEAM_CENTER_Y'] = f'{mean_beam_center[0]:.4f}'
header[
'DENZO_X_BEAM'] = f'{mean_beam_center[0]*self.physical_pixelsize:.4f}'
header[
'DENZO_Y_BEAM'] = f'{mean_beam_center[1]*self.physical_pixelsize:.4f}'
fn = path / f'{i:05d}.img'
write_adsc(fn, img, header=header)
return fn
def set_sim_sequence(self, angle_phase_wavelength):
""" Generate a SIM sequence from a list of parameters.
angle_phase_wavelength is a list where each element is a tuple of the
form (angle_number, phase_number, wavelength).
"""
num_phases = 0
num_angles = 0
wavelengths = []
for (angle, phase, wavelength) in angle_phase_wavelength:
num_phases = max(num_phases, phase + 1)
num_angles = max(num_angles, angle + 1)
if wavelength not in wavelengths:
wavelengths.append(wavelength)
phases = [
self.sim_phase_offset + n * TWO_PI / num_phases
for n in xrange(num_phases)
]
angles = [
self.sim_angle_offset + n * TWO_PI / num_angles
for n in xrange(num_angles)
]
## Calculate line pitches for each wavelength, once.
# d = m * wavelength / sin theta
# 1/1000 since wavelength in nm, pixel pitch in microns.
pitches = {
w: w / (1000. * sin(self.sim_diffraction_angle * TWO_PI / 360.))
for w in wavelengths
}
## Figure out the LUTs we need for each wavelength, once.
luts = {w: self.get_lut(w) for w in set(wavelengths)}
# retardation for equal powers in 0 and combined +/-1 orders
modulation = 65535 * 150. / 360.0
sequence = []
for (angle, phase, wavelength) in angle_phase_wavelength:
pp = pitches[wavelength] / self.pixel_pitch
th = angles[angle]
ph = phases[phase]
# Create a stripe 16-bit pattern
pattern16 = numpy.ushort(
rint((0.5 * modulation) + (0.5 * modulation) *
cos(ph + TWO_PI *
(cos(th) * self.kk + sin(th) * self.ll) / pp)))
# Lose two LSBs and pass through the LUT for given wavelength.
pattern = luts[wavelength][pattern16 / 4]
# Append to the sequence.
sequence.append(pattern)
self.sequence_parameters = angle_phase_wavelength
self.sequence = sequence
self.load_sequence()
def __init__(self, id, events):
self._events = dict()
self._id = numpy.ushort(id)
self._name = events.get("name").lower()
if "events" in events.keys():
self._parse_from_json(events.get("events"))
elif self._name == "ump send":
self._events[0] = make_trace_event("CHANNEL_SEND", 0, "ump send",
self)
elif self._name == "ump receive":
self._events[0] = make_trace_event("CHANNEL_RECV", 0, "ump send",
self)
def build_cloud_mask(raw_cloud_flags, cloud_bits):
""" Construct a cloud mask from the raw flags in the SLSTR flag mask. Bits
to consider in the mask have been selected to filter as much cloud as
possible without removing frontal structures."""
bits_to_mask = (
'visible',
'threshold',
'small_histogram1.6',
# 'large_histogram1.6',
'small_histogram2.25',
'gross_cloud',
'thin_cirrus',
'medium_high',
'fog_low_stratus',
# '3.7_11_view_difference',
'11_12_view_difference')
mask_ref = numpy.ushort(0)
# Enable selected mask bits
for mask_name in bits_to_mask:
mask_ref = mask_ref + (1 << cloud_bits[mask_name])
# Apply spatial coherence only if thermal histogram is flagged to
# avoid masking fronts
# 1 - Compute thermal_histogram mask
unmask_ref = numpy.ushort(0)
unmask_ref = unmask_ref + (1 << cloud_bits['thermal_histogram'])
# 2 - Compute spatial coherence mask
spatial = numpy.ushort(0)
spatial = spatial + (1 << cloud_bits['spatial_coherence'])
# 3 - Combine masks
spatial_mask = ((numpy.bitwise_and(raw_cloud_flags, unmask_ref) > 0) &
(numpy.bitwise_and(raw_cloud_flags, spatial) > 0))
# Build cloud mask
cloud_mask = numpy.zeros(shape=raw_cloud_flags.shape, dtype='bool')
cloud_mask = (cloud_mask | spatial_mask |
(numpy.bitwise_and(raw_cloud_flags, mask_ref) > 1))
return cloud_mask
def ComprobarLista2(self): if len(self.L_L_Goals) == 0: return with QtCore.QMutexLocker(self.mutex_bus): try: for x in range(0, len(self.L_L_Goals)): m = self.L_L_Goals.pop(0) for goal in m: for x in self.motorParams: if x.name == goal.name: busId = x.busId break if x.invertedSign == "true": goal.position = -goal.position pos = np.ushort((goal.position + 2.618) * (1023 - 0) / (2.618 + 2.618)) vel = np.ushort(goal.maxSpeed) dynamixel.set_velocity(self.bus, busId, vel, False, num_error_attempts=1) dynamixel.set_position(self.bus, busId, pos, False, num_error_attempts=1) dynamixel.send_action_packet(self.bus) except Ice.Exception, e: traceback.print_exc() print e
def set_sim_sequence(self, angle_phase_wavelength):
""" Generate a SIM sequence from a list of parameters.
angle_phase_wavelength is a list where each element is a tuple of the
form (angle_number, phase_number, wavelength).
"""
num_phases = 0
num_angles = 0
wavelengths = []
for (angle, phase, wavelength) in angle_phase_wavelength:
num_phases = max(num_phases, phase + 1)
num_angles = max(num_angles, angle + 1)
if wavelength not in wavelengths:
wavelengths.append(wavelength)
phases = [self.sim_phase_offset + n * TWO_PI / num_phases
for n in xrange(num_phases)]
angles = [self.sim_angle_offset + n * TWO_PI / num_angles
for n in xrange(num_angles)]
## Calculate line pitches for each wavelength, once.
# d = m * wavelength / sin theta
# 1/1000 since wavelength in nm, pixel pitch in microns.
pitches = {w: w / (1000. * sin(self.sim_diffraction_angle * TWO_PI / 360.))
for w in wavelengths}
## Figure out the LUTs we need for each wavelength, once.
luts = {w: self.get_lut(w) for w in set(wavelengths)}
# retardation for equal powers in 0 and combined +/-1 orders
modulation = 65535 * 150. / 360.0
sequence = []
for (angle, phase, wavelength) in angle_phase_wavelength:
pp = pitches[wavelength] / self.pixel_pitch
th = angles[angle]
ph = phases[phase]
# Create a stripe 16-bit pattern
pattern16 = numpy.ushort(
rint(
(0.5 * modulation) + (0.5 * modulation) * cos(
ph + TWO_PI * (cos(th) * self.kk + sin(th) * self.ll)
/ pp)
))
# Lose two LSBs and pass through the LUT for given wavelength.
pattern = luts[wavelength][pattern16 / 4]
# Append to the sequence.
sequence.append(pattern)
self.sequence_parameters = angle_phase_wavelength
self.sequence = sequence
self.load_sequence()
def testread(path):
image,label=decode_from_tfrecords(path)
images, sparse_labels=get_batch(image, label, 1)
init=tf.global_variables_initializer()
with tf.Session() as session:
session.run(init)
coord = tf.train.Coordinator()
threads = tf.train.start_queue_runners(sess=session)
for l in range(10):
images_np,batch_label_np=session.run([images,sparse_labels])
print images_np.shape
print batch_label_np.shape
img=np.ushort((np.reshape(images_np, (224,224,3))*255+127))
print img.shape
plt.figure()
plt.imshow(img)
plt.show()
coord.request_stop()
coord.join(threads)
def calculate_checksum(crc_accum, packet):
crc_table = [
0x0000, 0x8005, 0x800F, 0x000A, 0x801B, 0x001E, 0x0014, 0x8011, 0x8033,
0x0036, 0x003C, 0x8039, 0x0028, 0x802D, 0x8027, 0x0022, 0x8063, 0x0066,
0x006C, 0x8069, 0x0078, 0x807D, 0x8077, 0x0072, 0x0050, 0x8055, 0x805F,
0x005A, 0x804B, 0x004E, 0x0044, 0x8041, 0x80C3, 0x00C6, 0x00CC, 0x80C9,
0x00D8, 0x80DD, 0x80D7, 0x00D2, 0x00F0, 0x80F5, 0x80FF, 0x00FA, 0x80EB,
0x00EE, 0x00E4, 0x80E1, 0x00A0, 0x80A5, 0x80AF, 0x00AA, 0x80BB, 0x00BE,
0x00B4, 0x80B1, 0x8093, 0x0096, 0x009C, 0x8099, 0x0088, 0x808D, 0x8087,
0x0082, 0x8183, 0x0186, 0x018C, 0x8189, 0x0198, 0x819D, 0x8197, 0x0192,
0x01B0, 0x81B5, 0x81BF, 0x01BA, 0x81AB, 0x01AE, 0x01A4, 0x81A1, 0x01E0,
0x81E5, 0x81EF, 0x01EA, 0x81FB, 0x01FE, 0x01F4, 0x81F1, 0x81D3, 0x01D6,
0x01DC, 0x81D9, 0x01C8, 0x81CD, 0x81C7, 0x01C2, 0x0140, 0x8145, 0x814F,
0x014A, 0x815B, 0x015E, 0x0154, 0x8151, 0x8173, 0x0176, 0x017C, 0x8179,
0x0168, 0x816D, 0x8167, 0x0162, 0x8123, 0x0126, 0x012C, 0x8129, 0x0138,
0x813D, 0x8137, 0x0132, 0x0110, 0x8115, 0x811F, 0x011A, 0x810B, 0x010E,
0x0104, 0x8101, 0x8303, 0x0306, 0x030C, 0x8309, 0x0318, 0x831D, 0x8317,
0x0312, 0x0330, 0x8335, 0x833F, 0x033A, 0x832B, 0x032E, 0x0324, 0x8321,
0x0360, 0x8365, 0x836F, 0x036A, 0x837B, 0x037E, 0x0374, 0x8371, 0x8353,
0x0356, 0x035C, 0x8359, 0x0348, 0x834D, 0x8347, 0x0342, 0x03C0, 0x83C5,
0x83CF, 0x03CA, 0x83DB, 0x03DE, 0x03D4, 0x83D1, 0x83F3, 0x03F6, 0x03FC,
0x83F9, 0x03E8, 0x83ED, 0x83E7, 0x03E2, 0x83A3, 0x03A6, 0x03AC, 0x83A9,
0x03B8, 0x83BD, 0x83B7, 0x03B2, 0x0390, 0x8395, 0x839F, 0x039A, 0x838B,
0x038E, 0x0384, 0x8381, 0x0280, 0x8285, 0x828F, 0x028A, 0x829B, 0x029E,
0x0294, 0x8291, 0x82B3, 0x02B6, 0x02BC, 0x82B9, 0x02A8, 0x82AD, 0x82A7,
0x02A2, 0x82E3, 0x02E6, 0x02EC, 0x82E9, 0x02F8, 0x82FD, 0x82F7, 0x02F2,
0x02D0, 0x82D5, 0x82DF, 0x02DA, 0x82CB, 0x02CE, 0x02C4, 0x82C1, 0x8243,
0x0246, 0x024C, 0x8249, 0x0258, 0x825D, 0x8257, 0x0252, 0x0270, 0x8275,
0x827F, 0x027A, 0x826B, 0x026E, 0x0264, 0x8261, 0x0220, 0x8225, 0x822F,
0x022A, 0x823B, 0x023E, 0x0234, 0x8231, 0x8213, 0x0216, 0x021C, 0x8219,
0x0208, 0x820D, 0x8207, 0x0202
]
for d in packet:
i = (numpy.ushort(crc_accum >> 8) ^ d) & 0xff
crc_accum = (crc_accum << 8) ^ crc_table[i]
crc_accum &= 0xffffff
return crc_accum & 0xffff
def __init__(self):
NT = namedtuple('NT', tuple('abc'))
self.values = [
np.longlong(-1), np.int_(-1), np.intc(-1), np.short(-1), np.byte(-1),
np.ubyte(1), np.ushort(1), np.uintc(1), np.uint(1), np.ulonglong(1),
np.half(1.0), np.single(1.0), np.float_(1.0), np.longfloat(1.0),
np.csingle(1.0j), np.complex_(1.0j), np.clongfloat(1.0j),
np.bool_(0), np.str_('1'), np.unicode_('1'), np.void(1),
np.object(), np.datetime64('NaT'), np.timedelta64('NaT'), np.nan,
12, 12.0, True, None, float('NaN'), object(), (1, 2, 3),
NT(1, 2, 3), datetime.date(2020, 12, 31), datetime.timedelta(14),
]
# Datetime & Timedelta
for precision in ['ns', 'us', 'ms', 's', 'm', 'h', 'D', 'M', 'Y']:
for kind, ctor in (('m', np.timedelta64), ('M', np.datetime64)):
self.values.append(ctor(12, precision))
for size in (1, 8, 16, 32, 64, 128, 256, 512):
self.values.append(bytes(size))
self.values.append('x' * size)
def generate_stripe_series(patternparms):
""" Generate a stripe series from the patternparms.
patternparms is a list of tuples: (pitch, angle, phase, wavelength),
where pitch is in microns, and both the angle and phase are specified
in radians.
"""
xindices = np.arange(512)
yindices = np.arange(512)
kk, ll = meshgrid(xindices, yindices)
sequence = []
for realpitch, angle, phase, waves, wavelength in patternparms:
pitch = realpitch / 15.0
modulation = waves * (2**16)
lut = LUTS[whichLUT(wavelength)]
pattern16 = np.ushort(
rint(32768. + (modulation / 2) *
cos(phase + 2 * pi *
(kk * cos(angle) + ll * sin(angle)) / pitch)))
pattern = lut[pattern16 / 4]
sequence.append(pattern)
return sequence
def __init__(self, speed_mhz=0):
self.clock = CPU.Clock(speed_mhz=speed_mhz)
self.pc = ushort() # Program counter
self.sp = ubyte() # Stack pointer
self.acc = ubyte() # Accumulator
self.idx = ubyte() # Index Register X
self.idy = ubyte() # Index Register Y
# Processor status bits
self.ps = {
'carry_flag': bool(),
'zero_flag': bool(),
'interrupt_flag': bool(),
'decimal_flag': bool(),
'break_flag': bool(),
'reserved': bool(),
'overflow_flag': bool(),
'negative_flag': bool()
}
self.memory = None
self.io = None
self.instructions = cpu6502.instructions.instructions.Instructions(self, filepath=os.path.join(
os.path.dirname(os.path.abspath(cpu6502.__file__)), '6502_instructions.json'))
def generate_stripe_series(patternparms):
""" Generate a stripe series from the patternparms.
patternparms is a list of tuples: (pitch, angle, phase, wavelength),
where pitch is in microns, and both the angle and phase are specified
in radians.
"""
sequence = []
xindices = np.arange(512)
yindices = np.arange(512)
kk, ll = meshgrid(xindices, yindices)
for realpitch, angle, phase, wavelength in patternparms:
pitch = realpitch / 15.0
# Factor to balance m=0,+/-1 orders.
mp2 = 1.5
pattern = np.ushort(
rint((mp2 / pi) * 32767.5 + 32767.5 * cos(phase +
2 * pi * (cos(angle) * kk + sin(angle) * ll) / pitch)))
# Scale to green LUT range
pattern *= 16256. / 65535.
pattern += 49279.
sequence.append(pattern)
return sequence
class TestNumpyJSONEncoder(unittest.TestCase):
@parameterized.expand(
[(numpy.bool_(1), True), (numpy.bool8(1), True), (numpy.byte(1), 1),
(numpy.int8(1), 1), (numpy.ubyte(1), 1), (numpy.uint8(1), 1),
(numpy.short(1), 1), (numpy.int16(1), 1), (numpy.ushort(1), 1),
(numpy.uint16(1), 1), (numpy.intc(1), 1), (numpy.int32(1), 1),
(numpy.uintc(1), 1), (numpy.uint32(1), 1), (numpy.int_(1), 1),
(numpy.int32(1), 1), (numpy.uint(1), 1), (numpy.uint32(1), 1),
(numpy.longlong(1), 1), (numpy.int64(1), 1), (numpy.ulonglong(1), 1),
(numpy.uint64(1), 1), (numpy.half(1.0), 1.0),
(numpy.float16(1.0), 1.0), (numpy.single(1.0), 1.0),
(numpy.float32(1.0), 1.0), (numpy.double(1.0), 1.0),
(numpy.float64(1.0), 1.0), (numpy.longdouble(1.0), 1.0)] + ([
(numpy.float128(1.0), 1.0) # unavailable on windows
] if hasattr(numpy, 'float128') else []))
def test_numpy_primary_type_encode(self, np_val, py_val):
self.assertEqual(json.dumps(py_val),
json.dumps(np_val, cls=NumpyEncoder))
@parameterized.expand([
(numpy.array([1, 2, 3], dtype=numpy.int), [1, 2, 3]),
(numpy.array([[1], [2], [3]], dtype=numpy.double), [[1.0], [2.0],
[3.0]]),
(numpy.zeros((2, 2), dtype=numpy.bool_), [[False, False],
[False, False]]),
(numpy.array([('Rex', 9, 81.0), ('Fido', 3, 27.0)],
dtype=[('name', 'U10'), ('age', 'i4'),
('weight', 'f4')]), [['Rex', 9, 81.0],
['Fido', 3, 27.0]]),
(numpy.rec.array([(1, 2., 'Hello'), (2, 3., "World")],
dtype=[('foo', 'i4'), ('bar', 'f4'),
('baz', 'U10')]), [[1, 2.0, "Hello"],
[2, 3.0, "World"]])
])
def test_numpy_array_encode(self, np_val, py_val):
self.assertEqual(json.dumps(py_val),
json.dumps(np_val, cls=NumpyEncoder))
def generate_stripe_series(patternparms):
""" Generate a stripe series from the patternparms.
patternparms is a list of tuples: (pitch, angle, phase, wavelength),
where pitch is in microns, and both the angle and phase are specified
in radians.
"""
sequence = []
xindices = np.arange(512)
yindices = np.arange(512)
kk, ll = meshgrid(xindices, yindices)
for realpitch, angle, phase, wavelength in patternparms:
pitch = realpitch / 15.0
# Factor to balance m=0,+/-1 orders.
mp2 = 1.5
pattern = np.ushort(
rint((mp2 / pi) * 32767.5 +
32767.5 * cos(phase + 2 * pi *
(cos(angle) * kk + sin(angle) * ll) / pitch)))
# Scale to green LUT range
pattern *= 16256. / 65535.
pattern += 49279.
sequence.append(pattern)
return sequence
def __processNormalMap(self, img_path, final_w, final_h):
image = cv2.imread(img_path)
image = self.__bootstrap(image, self.bootstrap_type)
rows = image.shape[0]
cols = image.shape[1]
chan = image.shape[2]
aspect = float(cols) / float(rows)
aspect_need = float(final_w) / float(final_h)
new_w = cols
new_h = rows
cols_offset = 0
rows_offset = 0
if aspect_need != aspect:
if aspect > aspect_need:
new_w = rows
cols_offset = int((cols - new_w) / 2)
elif aspect < aspect_need:
new_h = cols
rows_offset = int((rows - new_h) / 2)
image_c = image[rows_offset:rows_offset + new_h,
cols_offset:cols_offset + new_w, :]
image_resized = cv2.resize(image_c, (final_h, final_w))
normal_map = estimateNormalMap(image_resized, 3, 25)
normal_map = normal_map * 65355
#cv2.imshow("normal_map", normal_map)
#cv2.moveWindow("normal_map", 380, 100)
#cv2.waitKey(1)
return np.ushort(normal_map)
reveal_type(np.bool8()) # E: numpy.bool_
reveal_type(np.bytes0()) # E: numpy.bytes_
reveal_type(np.string_()) # E: numpy.bytes_
reveal_type(np.object0()) # E: numpy.object_
reveal_type(np.void0(0)) # E: numpy.void
reveal_type(np.byte()) # E: {byte}
reveal_type(np.short()) # E: {short}
reveal_type(np.intc()) # E: {intc}
reveal_type(np.intp()) # E: {intp}
reveal_type(np.int0()) # E: {intp}
reveal_type(np.int_()) # E: {int_}
reveal_type(np.longlong()) # E: {longlong}
reveal_type(np.ubyte()) # E: {ubyte}
reveal_type(np.ushort()) # E: {ushort}
reveal_type(np.uintc()) # E: {uintc}
reveal_type(np.uintp()) # E: {uintp}
reveal_type(np.uint0()) # E: {uintp}
reveal_type(np.uint()) # E: {uint}
reveal_type(np.ulonglong()) # E: {ulonglong}
reveal_type(np.half()) # E: {half}
reveal_type(np.single()) # E: {single}
reveal_type(np.double()) # E: {double}
reveal_type(np.float_()) # E: {double}
reveal_type(np.longdouble()) # E: {longdouble}
reveal_type(np.longfloat()) # E: {longdouble}
reveal_type(np.csingle()) # E: {csingle}
reveal_type(np.singlecomplex()) # E: {csingle}
# This is an example for the initialization of a linear kernel on word (2byte)
# data.
from tools.load import LoadMatrix
from numpy import ushort
lm = LoadMatrix()
traindat = ushort(lm.load_numbers("../data/fm_train_word.dat"))
testdat = ushort(lm.load_numbers("../data/fm_test_word.dat"))
parameter_list = [[traindat, testdat, 1.2], [traindat, testdat, 1.2]]
def kernel_linear_word_modular(fm_train_word=traindat, fm_test_word=testdat, scale=1.2):
from shogun.Kernel import LinearKernel, AvgDiagKernelNormalizer
from shogun.Features import WordFeatures
feats_train = WordFeatures(fm_train_word)
feats_test = WordFeatures(fm_test_word)
kernel = LinearKernel(feats_train, feats_train)
kernel.set_normalizer(AvgDiagKernelNormalizer(scale))
kernel.init(feats_train, feats_train)
km_train = kernel.get_kernel_matrix()
kernel.init(feats_train, feats_test)
km_test = kernel.get_kernel_matrix()
return kernel
from tools.load import LoadMatrix
from numpy import ushort
from sg import sg
lm = LoadMatrix()
trainword = ushort(lm.load_numbers('../data/fm_test_word.dat'))
testword = ushort(lm.load_numbers('../data/fm_test_word.dat'))
parameter_list = [[trainword, testword, 10, 1.4],
[trainword, testword, 11, 1.5]]
def kernel_linearword(fm_train_word=trainword,
fm_test_word=testword,
size_cache=10,
scale=1.4):
sg('set_features', 'TRAIN', fm_train_word)
sg('set_features', 'TEST', fm_test_word)
sg('set_kernel', 'LINEAR', 'WORD', size_cache, scale)
km = sg('get_kernel_matrix', 'TRAIN')
km = sg('get_kernel_matrix', 'TEST')
return km
if __name__ == '__main__':
print 'LinearWord'
kernel_linearword(*parameter_list[0])
np.bool8() np.bytes0() np.string_() np.object0() np.void0(0) np.byte() np.short() np.intc() np.intp() np.int0() np.int_() np.longlong() np.ubyte() np.ushort() np.uintc() np.uintp() np.uint0() np.uint() np.ulonglong() np.half() np.single() np.double() np.float_() np.longdouble() np.longfloat() np.csingle() np.singlecomplex()
ppl.plot(list(range(nfrms)), vel[ptnum, :])
ppl.xlabel('Frame')
ppl.ylabel('Mean luminal velocity [mm/s]')
ppl.title('Velocity in vessel')
fig.canvas.draw()
print('Close the figure to continue...')
ppl.show(32)
# save the mask as a Nifti image
pchdr = pcimgs.header
pixel_size = pchdr.get_zooms()
print('get_zooms(): ', pixel_size)
nibimg = nib.Nifti1Image(np.ushort(masksum), None, pchdr)
hdr = nibimg.header
hdr.set_xyzt_units('mm', 'sec')
# print(hdr)
nib.save(nibimg, os.path.join(imgpath, 'mask2d_rs18.nii.gz'))
# here is how to save it as a 3D with it replicated nfrms times
mask3d = np.zeros((nrows, ncols, 1, nfrms))
for i in range(nfrms):
mask3d[:, :, 0, i] = masksum
print('pchdr.shape = ', pcdata.shape)
print('mask2.shape = ', mask2.shape)
print('masksum.shape = ', masksum.shape)
print('mask3d.shape = ', mask3d.shape)
def demo(self, image):
self.time2store = self.gen_datetime()
# self.time2store = datetime.now()
# print('min_side: {min_side}\nmax_side: {max_side}'.format(
# min_side=self.min_side4train, max_side=self.max_side4train))
# copy to draw on
draw = image.copy()
# preprocess image for network
image = preprocess_image(image)
# cv2.imshow('ss22', image)
image, scale = resize_image(
image, min_side=self.min_side4train, max_side=self.max_side4train)
time_ = self.time2store
# time_ = datetime.now()
image_id = time_.strftime('%Y%m-%d%H-%M%S-') + str(uuid4())
# process image
start = time.time()
boxes, scores, labels = self.model.predict_on_batch(
np.expand_dims(image, axis=0))
processing_time = time.time() - start
# print("processing time: ", processing_time)
img4elas, scale4elas = resize_image(
draw, min_side=self.min_side4elas, max_side=self.max_side4elas)
# correct for image scale
boxes /= scale
found_ = {}
main_body = {'image_id': image_id, 'time_': time_}
# visualize detections
print('es_mode: {}\nstatus: {}'.format(self.es_mode, self.es_status))
temp_data = []
index = 1
for box, score, label in zip(boxes[0], scores[0], labels[0]):
# scores are sorted so we can break
# print(index, box, score, self.labels_to_names[label])
if score < self.confThreshold:
break
color = label_color(label)
b = box.astype(int)
draw_box(draw, b, color=color)
caption = "{} {:.3f}".format(
self.labels_to_names[label], score)
# print(caption)
draw_caption(draw, b, caption)
temp_data.append([self.labels_to_names[label],
score, b, processing_time])
box = [np.ushort(x).item() for x in box]
# cv2.imshow(str(self.model_is), draw )
# cv2.waitKey()
# if self.es_mode and self.es_status:
# self.es.elas_record(label=label, score=np.float32(score).item(), box=box, image_id=image_id, time_=time_)
if self.es_mode and self.es_status and self.labels_to_names[label] == 'pigeon':
# print('{tag}\n\n{data}\n\n{tag}'.format(
# tag='#'*20,
# data='label: {label}\nscore: {score}'.format(
# label=self.labels_to_names[label], score=score)
# ))
cv2.waitKey(4)
self.es.elas_record(label=label, score=np.float32(
score).item(), box=box, **main_body)
index += 1
try:
found_[self.labels_to_names[label]] += 1
except:
found_[self.labels_to_names[label]] = 1
# os.makedirs("data4eval/non-pigeon/result/{}".format(self.model_is), exist_ok=True)
# cv2.imwrite("data4eval/non-pigeon/result/{}/{}-{}.jpg".format(self.model_is, self.model_is, datetime.now(), image_id), draw)
# scheduler = BackgroundScheduler(timezone=get_localzone())
# scheduler.add_job(task_deley, 'interval', seconds=sec_per_frame)
# scheduler.add_job(stopTurret, 'interval', seconds=20)
# scheduler.start()
try:
if found_['pigeon'] > 0:
self.silen_.alert()
if self.es_mode and self.es_status:
print('{tag}\n\n{data}\n\n{tag}'.format(
tag='#'*50,
data='id: {id}\nbird count: {found}'.format(
id=image_id, found=found_)))
self.es.elas_image(image=img4elas, scale=scale, found_=found_,
processing_time=processing_time, **main_body)
# self.es.elas_date(**main_body)
except Exception as e:
print(e)
return draw
# Generate test images from TIFFs.
images = []
test_files = os.listdir(TEST_PATH)
print "Loading test files:"
for f in test_files:
print " %s" % f
images.append(dev.read_tiff(f))
# Numerically-generated test images.
ind = np.arange(512)
kk, ll = np.meshgrid(ind, ind)
ndarray_images = []
ndarray_images.append(np.ushort(32767 + ((kk % 32) > 15) * 65535/2))
ndarray_images.append(np.ushort(32767 + (((kk + ll) % 48) > 23 )* 65535/2))
ndarray_images.append(np.ushort(32767 + ((ll % 32) > 15) * 65535/2))
# Show a single TIFF-derived image for five seconds.
print "Single image from TIFF."
dev.write_image(images[0])
dev.power = True
sleep(5)
# Run the TIFF-derived cycle for five seconds.
print "TIFF series"
dev.load_sequence(images)
dev.start_sequence()
sleep(5)
def execute(self):
for kk,file_name in enumerate(self.file_list):
print file_name
reader=vtk.vtkPolyDataReader()
reader.SetFileName(file_name)
reader.Update()
poly = self.compute_radius(reader.GetOutput(),spacing_list[kk])
if self.use_field_data == False:
poly.GetPointData().\
SetNormals(poly.GetPointData().\
GetArray(self.normal_map[self.feature_type]))
else:
poly.GetPointData().\
SetNormals(poly.GetFieldData().\
GetArray(self.normal_map[self.feature_type]))
glypher=self.create_glyphs(poly)
if len(self.color_list) <= kk:
color=[]
else:
color=self.color_list[kk]
if len(self.opacity_list) <= kk:
opacity=1
else:
opacity=self.opacity_list[kk]
self.create_actor(glypher,color=color,opacity=opacity)
# Adds the box interaction mechanism
self.boxWidgetParticles.SetInteractor(self.iren)
self.boxWidgetParticles.SetPlaceFactor(1.25)
self.boxWidgetParticles.SetInput(glypher.GetOutput())
self.boxWidgetParticles.PlaceWidget()
self.boxWidgetParticles.AddObserver("EndInteractionEvent", self.SelectPolygons)
self.boxWidgetParticles.EnabledOff()
## The SelectPolygons function is slow as hell - therefore it is only updated when it is released
# self.boxWidgetParticles.AddObserver("StartInteractionEvent", self.StartInteraction)
# self.boxWidgetParticles.AddObserver("InteractionEvent", self.SelectPolygons)
# self.boxWidgetParticles.AddObserver("EndInteractionEvent", self.EndInteraction)
if len(self.lung)>0:
## Generate a transfer function - the phantom is in the range -400, -200
# Converts the nrrd into a vtk volume
readdata, options = nrrd.read(self.lung)
print options
## This is to be changed!! FIXME - the minimum value does not need to be of interest - find the min val of HUs
readdata = readdata.transpose([2,1,0]) # yup, nrrd and axes
minval = readdata.min()
print minval
print readdata.max()
tfun = vtk.vtkPiecewiseFunction()
# tfun.AddPoint(100, 0);
# tfun.AddPoint(600, 1.0);
# tfun.AddPoint(700, 1.0);
# tfun.AddPoint(500, 0.0);
# tfun.AddPoint(1000, 0);
tfun.AddPoint(-minval-2000, 0);
tfun.AddPoint(-minval-1000, 0.0);
tfun.AddPoint(-minval-300, 1.0);
tfun.AddPoint(-minval-100, 1.0);
tfun.AddPoint(-minval-80, 0);
readdata = np.ushort(readdata - minval)
print readdata.min()
print readdata.max()
# tfun.AddPoint(-1000, 0.0);
# tfun.AddPoint(- 800, 0.0);
# tfun.AddPoint(- 400, 1.0);
# tfun.AddPoint(- 200, 1.0);
# tfun.AddPoint(- 180, 0.0);
# tfun.AddPoint( 100, 0.0);
# tfun.AddPoint( 300, 0.0);
# tfun.AddPoint( 800, 0.0);
# tfun.AddPoint( 1070, 0.0);
sz = readdata.shape
dataSpacing = options.get('space directions') # scale of the image
dataSpacing = [dataSpacing[0][0], dataSpacing[1][1], dataSpacing[2][2]]
dataOrigin = options.get('space origin')
dataImporter = vtk.vtkImageImport()
data_string = readdata.tostring()
dataImporter.CopyImportVoidPointer(data_string, len(data_string))
dataImporter.SetDataScalarTypeToUnsignedShort()
dataImporter.SetNumberOfScalarComponents(1) # it is a bw image
dataImporter.SetDataOrigin(dataOrigin) # location of the image
dataImporter.SetDataSpacing(dataSpacing)
dataImporter.SetDataExtent(0, sz[2]-1, 0, sz[1]-1, 0, sz[0]-1)
dataImporter.SetWholeExtent(0, sz[2]-1, 0, sz[1]-1, 0, sz[0]-1)
self.volume_size = [sz[2]-1, sz[1]-1, sz[0]-1]
dataImporter.Update()
print dataImporter.GetDataScalarTypeAsString()
volumeProperty = vtk.vtkVolumeProperty()
volumeProperty.SetScalarOpacity(tfun)
volumeProperty.SetInterpolationTypeToLinear()
# How is the volume going to be rendered?
compositeFunction = vtk.vtkVolumeRayCastCompositeFunction()
self.volumeMapper.SetVolumeRayCastFunction(compositeFunction)
self.volumeMapper.SetInputConnection(dataImporter.GetOutputPort())
# Finally generate the volume
self.volumeActor.SetMapper(self.volumeMapper)
self.volumeActor.SetProperty(volumeProperty)
# Add the new actors to the rendering pipeline
self.ren.AddVolume(self.volumeActor)
self.volume_added_to_renderer = True
self.volume_loaded = True
# Adds the box interaction mechanism
self.boxWidgetVolume.SetInteractor(self.iren)
self.boxWidgetVolume.SetPlaceFactor(1.0)
self.boxWidgetVolume.SetInput(dataImporter.GetOutput())
self.boxWidgetVolume.PlaceWidget()
self.boxWidgetVolume.InsideOutOn()
self.boxWidgetVolume.AddObserver("StartInteractionEvent", self.StartInteraction)
self.boxWidgetVolume.AddObserver("InteractionEvent", self.ClipVolumeRender)
self.boxWidgetVolume.AddObserver("EndInteractionEvent", self.EndInteraction)
outlineProperty = self.boxWidgetVolume.GetOutlineProperty()
outlineProperty.SetRepresentationToWireframe()
outlineProperty.SetAmbient(1.0)
outlineProperty.SetAmbientColor(1, 1, 1)
outlineProperty.SetLineWidth(3)
selectedOutlineProperty = self.boxWidgetVolume.GetSelectedOutlineProperty()
selectedOutlineProperty.SetRepresentationToWireframe()
selectedOutlineProperty.SetAmbient(1.0)
selectedOutlineProperty.SetAmbientColor(1, 0, 0)
selectedOutlineProperty.SetLineWidth(3)
# picker = vtk.vtkCellPicker()
# picker.SetTolerance(0.005)
# Adds the plane interactors
self.planeWidgetX.DisplayTextOn()
self.planeWidgetY.DisplayTextOn()
self.planeWidgetY.DisplayTextOn()
self.planeWidgetX.SetInput(dataImporter.GetOutput())
self.planeWidgetY.SetInput(dataImporter.GetOutput())
self.planeWidgetZ.SetInput(dataImporter.GetOutput())
self.planeWidgetX.SetPlaneOrientationToXAxes()
self.planeWidgetY.SetPlaneOrientationToYAxes()
self.planeWidgetZ.SetPlaneOrientationToZAxes()
self.planeWidgetX.SetSliceIndex(1)
self.planeWidgetY.SetSliceIndex(1)
self.planeWidgetZ.SetSliceIndex(1)
self.planeWidgetX.SetInteractor(self.iren)
self.planeWidgetY.SetInteractor(self.iren)
self.planeWidgetZ.SetInteractor(self.iren)
self.ren.SetBackground(0, 0, 0)
self.add_color_bar()
self.render()
from tools.load import LoadMatrix
from numpy import ushort
from sg import sg
lm=LoadMatrix()
trainword=ushort(lm.load_numbers('../data/fm_test_word.dat'))
testword=ushort(lm.load_numbers('../data/fm_test_word.dat'))
parameter_list=[[trainword,testword,10,1.4],
[trainword,testword,11,1.5]]
def kernel_linearword (fm_train_word=trainword,fm_test_word=testword,
size_cache=10, scale=1.4):
sg('set_features', 'TRAIN', fm_train_word)
sg('set_features', 'TEST', fm_test_word)
sg('set_kernel', 'LINEAR', 'WORD', size_cache, scale)
km=sg('get_kernel_matrix', 'TRAIN')
km=sg('get_kernel_matrix', 'TEST')
return km
if __name__=='__main__':
print('LinearWord')
kernel_linearword(*parameter_list[0])
def VolumeRenderingRayCast(inVolume, scale=[1, 1, 1], lowerThreshold=0, upperThreshold=None):
"""
Recieve a numpy volume and render it with RayCast method. This method employs CPU raycast
and will subject to upgrades of using GPUVolumeMapper in the future. The method returns
a vtkVolume actor which can be added to a vtkRenderer
:param inVolume: numpy volume
:param scale: scale [x, y, z] of the slice/voxel spacing to real spacing
:param lowerThreshold: lower Threshold for raycast. Default = 0
:param upperThreshold: upper Threshold for raycast. Default = inVolume.max()
:return: vtk.vtkVolume
"""
inVolume = np.ushort(inVolume)
inVolumeString = inVolume.tostring()
# Color map related
if upperThreshold == None:
upperThreshold = inVolume.max()
if upperThreshold <= lowerThreshold:
raise ValueError("Upper Threshold must be larger than lower Threshold.")
centerThreshold = (upperThreshold - lowerThreshold) / 2.0 + lowerThreshold
lowerQuardThreshold = (centerThreshold - lowerThreshold) / 2.0 + lowerThreshold
upperQuardThreshold = (upperThreshold - centerThreshold) / 2.0 + centerThreshold
dataImporter = vtk.vtkImageImport()
dataImporter.CopyImportVoidPointer(inVolumeString, len(inVolumeString))
dataImporter.SetDataScalarTypeToUnsignedShort()
dataImporter.SetNumberOfScalarComponents(1)
dataImporter.SetDataExtent(0, inVolume.shape[2] - 1, 0, inVolume.shape[1] - 1, 0, inVolume.shape[0] - 1)
dataImporter.SetWholeExtent(0, inVolume.shape[2] - 1, 0, inVolume.shape[1] - 1, 0, inVolume.shape[0] - 1)
alphaChannelFunc = vtk.vtkPiecewiseFunction()
alphaChannelFunc.AddPoint(lowerThreshold, 0)
alphaChannelFunc.AddPoint(lowerQuardThreshold, 0.05)
alphaChannelFunc.AddPoint(centerThreshold, 0.4)
alphaChannelFunc.AddPoint(upperQuardThreshold, 0.05)
alphaChannelFunc.AddPoint(upperThreshold, 0)
colorFunc = vtk.vtkColorTransferFunction()
colorFunc.AddRGBPoint(lowerThreshold, 0, 0, 0)
colorFunc.AddRGBPoint(centerThreshold, 0.5, 0.5, 0.5)
colorFunc.AddRGBPoint(upperThreshold, 0.8, 0.8, 0.8)
volumeProperty = vtk.vtkVolumeProperty()
volumeProperty.SetColor(colorFunc)
volumeProperty.SetScalarOpacity(alphaChannelFunc)
compositeFunction = vtk.vtkVolumeRayCastCompositeFunction()
volumeMapper = vtk.vtkVolumeRayCastMapper()
volumeMapper.SetVolumeRayCastFunction(compositeFunction)
volumeMapper.SetInputConnection(dataImporter.GetOutputPort())
volume = vtk.vtkVolume()
volume.SetMapper(volumeMapper)
volume.SetProperty(volumeProperty)
volume.SetScale(scale)
# Volume is returned for further rendering
return volume
