def check_result(detail):
expected_list = []
expected_list.append(
volume.Volume(CREATE_VOL_BASIC_1.VOL_NAME, CREATE_VOL_BASIC_1.VOL_SIZE,
CREATE_VOL_BASIC_1.VOL_IOPS, CREATE_VOL_BASIC_1.VOL_BW))
expected_list.append(
volume.Volume(CREATE_VOL_BASIC_2.VOL_NAME, CREATE_VOL_BASIC_2.VOL_SIZE,
CREATE_VOL_BASIC_2.VOL_IOPS, CREATE_VOL_BASIC_2.VOL_BW))
expected_list.append(
volume.Volume(CREATE_VOL_BASIC_3.VOL_NAME, CREATE_VOL_BASIC_3.VOL_SIZE,
CREATE_VOL_BASIC_3.VOL_IOPS, CREATE_VOL_BASIC_3.VOL_BW))
data = json.loads(detail)
actual_list = []
for item in data['Response']['result']['data']['volumes']:
vol = volume.Volume(item['name'], item['total'], item['maxiops'],
item['maxbw'])
actual_list.append(vol)
if len(actual_list) != len(expected_list):
return "fail"
for actual in actual_list:
checked = False
for expected in expected_list:
if actual.name == expected.name and actual.total == expected.total and actual.maxiops == expected.maxiops and actual.maxbw == expected.maxbw:
checked = True
break
if checked == False:
return "fail"
return "pass"
def check_result(detail):
expected_list = []
for i in range(0, pos_constant.MAX_VOL_CNT):
expected_list.append(
volume.Volume(VOL_NAME_PREFIX + str(i + 1), VOL_SIZE, VOL_IOPS,
VOL_BW))
data = json.loads(detail)
actual_list = []
for item in data['Response']['result']['data']['volumes']:
vol = volume.Volume(item['name'], item['total'], item['maxiops'],
item['maxbw'])
actual_list.append(vol)
if len(actual_list) != len(expected_list):
return "fail"
for actual in actual_list:
checked = False
for expected in expected_list:
if actual.name == expected.name and actual.total == expected.total and actual.maxiops == expected.maxiops and actual.maxbw == expected.maxbw:
checked = True
break
if checked == False:
return "fail"
return "pass"
def event(self, event):
if self.confirmation:
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_LEFT:
self.confirmed = (self.confirmed - 1) % 2
elif event.key == pygame.K_RIGHT:
self.confirmed = (self.confirmed + 1) % 2
if event.key == pygame.K_SPACE or event.key == pygame.K_RETURN:
if self.confirmed:
globes.Globals.HIGHSCORES.clear_file()
self.confirmation = False
else:
self.confirmation = False
else:
if event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE:
globes.Globals.STATE = menu.Menu(True)
if event.type == pygame.KEYDOWN and event.key == pygame.K_UP:
self.option = (self.option - 1) % 4
if event.type == pygame.KEYDOWN and event.key == pygame.K_DOWN:
self.option = (self.option + 1) % 4
if event.type == pygame.KEYDOWN and \
(event.key == pygame.K_SPACE or
event.key == pygame.K_RETURN):
if self.option == 0:
self.confirmation = True
elif self.option == 1:
globes.Globals.STATE = joystick.Joystick()
elif self.option == 2:
globes.Globals.STATE = volume.Volume(True)
if self.option == 3:
globes.Globals.STATE = menu.Menu(True)
def test_volume():
path1 = "../../data/volume_test/Takacs_Akos_20180131_038318067_STD19194862AMR806_SER1401_ACQ14.con"
path2 = "../../data/SA_all/17352962AMR801/901/contour.con"
path4 = "../../data/SA_all/17577538AMR801/901/contour.con"
path5 = "../../data/SA_all/17651351AMR806/1301/contour.con"
path6 = "../../data/SA_all/17827245AMR809/1301/contour.con"
v = vol.Volume(path6)
v.calculate_volumes('pixel')
print('---------------------------')
print('LEFT VEN.')
print('LVED: %.3f'%v.lved)
print('LVED-idx: %.3f'%v.lved_i)
print('LVES: %.3f'%v.lves)
print('LVES-idx: %.3f'%v.lves_i)
print('LVSV: %.3f'%v.lvsv)
print('LVSV-idx: %.3f'%v.lvsv_i)
print('---------------------------')
print('RIGHT VEN.')
print('RVED: %.3f'%v.rved)
print('RVED-idx: %.3f'%v.rved_i)
print('RVES: %.3f'%v.rves)
print('RVES-idx: %.3f'%v.rves_i)
print('RVSV: %.3f'%v.rvsv)
print('RVSV-idx: %.3f'%v.rvsv_i)
def main():
cargs = parse_args(sys.argv[1:])
data_type = np.dtype(cargs.dtype)
fd = np.memmap(cargs.raw, dtype=data_type, mode='r')
tf_x = np.loadtxt(cargs.tf, dtype=np.float64, usecols=0, skiprows=1)
tf_y = np.loadtxt(cargs.tf, dtype=np.float64, usecols=1, skiprows=1)
vdims = np.array([cargs.vx, cargs.vy, cargs.vz], dtype=np.uint64)
bcount = np.array([cargs.bx, cargs.by, cargs.bz], dtype=np.uint64)
bdims = np.divide(vdims, bcount)
blocks = np.zeros(cargs.bx * cargs.by * cargs.bz)
block_size = vdims / bcount
block_extent = block_size * bcount
print('Running volume analysis')
vol_min, vol_max, vol_tot = run_volume(fd, np.prod(vdims))
print('Running relevance analysis')
relevancies = run_block(fd, tf_x, tf_y, vol_min, vol_max, vdims, bdims,
bcount)
rov_min = np.min(relevancies)
rov_max = np.max(relevancies)
print("Creating index file")
vol_path, vol_name = os.path.split(cargs.raw)
tr_path, tr_name = os.path.split(cargs.tf)
max_dim = np.max(vdims)
world_dims = [vdims[0] / max_dim, vdims[1] / max_dim, vdims[2] / max_dim]
world_origin = [0.0, 0.0, 0.0]
vol_stats = volume.VolStats(min=vol_min, max=vol_max, avg=0.0, tot=vol_tot)
vol = volume.Volume(world_dims, world_origin, vdims.tolist(), rov_min,
rov_max)
blocks = indexfile.create_file_blocks(bcount, fd.dtype, vol, relevancies)
ifile = indexfile.IndexFile(
**{
'world_dims': world_dims,
'world_origin': world_origin,
'vol_stats': vol_stats,
'vol_name': vol_name,
'vol_path': vol_path,
'volume': vol,
'tr_func': tr_name,
'dtype': fd.dtype.name,
'num_blocks': bcount,
'blocks_extent': block_extent,
'blocks': blocks,
})
ifile.write(cargs.out)
def __init__(self, samps = None,
bounds = None,
volume = None,
measure = None,
is_eq = True,
bandlims = None):
#TODO: remove this member
self.is_eq = is_eq
if samps is None:
self.samps = gd.Grid()
self.bounds = gd.Grid()
else:
self.samps = samps
self.bounds = bounds
self.ns = self.samps.get_curr_cards()
if volume is None:
self.volume = vol.Volume()
else:
self.volume = volume
if measure is None:
self.measure = ms.Measure()
else:
self.measure = measure
if bandlims is None:
bounds = deep(self.bounds)
self.bandlims = deep(bounds.get_lims() )
else:
self.bandlims = deep(bandlims)
return
def testBoundsZeroAlign(self):
OneToTwo = meshwithrbffallback.MeshWithRBFFallback(
IdentityTransformPoints)
OneToThree = meshwithrbffallback.MeshWithRBFFallback(
MirrorTransformPoints)
vol = volume.Volume()
vol.AddSection(2, OneToTwo)
vol.AddSection(3, OneToThree)
volBounds = vol.VolumeBounds
self.assertEqual(volBounds.ToTuple(), (-10, -10, 10, 10),
"Volume bounds are not correct")
vol.TranslateToZeroOrigin()
zeroedVolBounds = vol.VolumeBounds
self.assertEqual(zeroedVolBounds.ToTuple(), (0, 0, 20, 20),
"Volume bounds are not correct")
pass
foreground=dk_grey,
background=grey),
widget.TaskList(borderwidth=1,
background=grey,
border=cyan,
urgent_border=red),
widget.TextBox(text="\u25e4 ", fontsize=42, padding=-8, foreground=grey),
#widget.TextBox(text=u'\U0001f321'),
widget.Systray(),
widget.TextBox(text="\u2328", foreground=cyan),
widget.KeyboardLayout(configured_keyboards=["us dvorak", "us"],
foreground=cyan,
update_interval=5),
tempsensor.TempSensor(font="fontawesome"),
networkmonitor.NetworkMonitor(font="fontawesome"),
volume.Volume(font="fontawesome"),
widget.Clock(format='%m-%d-%Y %a %H:%M:%S'),
]
widgets2 = [
widget.TextBox(text="\u25e4 ", fontsize=42, padding=-8, foreground=grey),
widget.GroupBox(borderwidth=4,
highlight_method='line',
margin=0,
disable_drag=True,
this_current_screen_border=cyan,
this_screen_border=lt_grey,
other_screen_border=med_grey,
urgent_border=red),
widget.TextBox(text="\u25e4",
fontsize=42,
import volume
from subprocess import call
volume = volume.Volume('vdrive')
volume.format()
call('head -n 1 vdrive', shell=True)
def play(self):
self.emit("preplay")
self.player = gst.Pipeline("player")
self.queue_video = gst.element_factory_make("queue", "queue_video")
self.player.add(self.queue_video)
self.input_type = 0
# Source selection
self.source_pads = {}
self.audio_pads = {}
self.pip_pads = {}
self.output_bins = {}
type = 0
source_number = 0
pip_number = 0
self.pip = PictureInPicture()
self.player.add(self.pip)
for row in self.sources.get_store():
(name, source) = row
element = source.create()
self.player.add(element)
if element.does_audio():
if not self.input_type & MEDIA_AUDIO:
# The pipeline has audio sources, and this is the first
# audio source we add
if self.audio_source is None:
self.emit("error", "You need to select an audio source")
self.emit("stopped")
return
self.input_type |= MEDIA_AUDIO
self.input_selector = gst.element_factory_make(
"input-selector", "audio-selector"
)
self.player.add(self.input_selector)
audiobin = audioinputbin.AudioInputBin(source)
self.player.add(audiobin)
element.audio_pad.link(audiobin.get_static_pad("sink"))
self.audio_pads[name] = \
self.input_selector.get_request_pad("sink%d")
audiobin.src_pad.link(self.audio_pads[name])
if element.does_video():
self.input_type |= MEDIA_VIDEO
self.source_pads[name] = source_number
source_number = source_number + 1
# Thumbnail preview
tee = gst.element_factory_make("tee", None)
self.player.add(tee)
element.video_pad.link(tee.sink_pads().next())
thumbnail_queue = gst.element_factory_make("queue", None)
self.player.add(thumbnail_queue)
self.thumbnails[name] = Preview(self)
self.player.add(self.thumbnails[name])
thumbnail_err = gst.element_link_many(
tee, thumbnail_queue, self.thumbnails[name]
)
if thumbnail_err == False:
self.emit("error", "Error conecting thumbnail preview.")
# Picture in Picture
self.pip_pads[name] = pip_number
pip_number = pip_number + 1
main_queue = gst.element_factory_make("queue", None)
self.player.add(main_queue)
pip_queue = gst.element_factory_make("queue", None)
self.player.add(pip_queue)
tee.link(main_queue)
tee.link(pip_queue)
main_queue.src_pads().next().link(self.pip.get_request_pad_A())
pip_queue.src_pads().next().link(self.pip.get_request_pad_B())
if name == self.video_source:
type |= element.get_type()
if name == self.audio_source:
type |= element.get_type()
self.watermark = gst.element_factory_make(
"cairoimageoverlay", "cairoimageoverlay"
)
self.player.add(self.watermark)
self.colorspace = gst.element_factory_make(
"ffmpegcolorspace", "colorspace-imageoverlay-videobalance"
)
self.player.add(self.colorspace)
self.videobalance = gst.element_factory_make(
"videobalance", "videobalance"
)
self.player.add(self.videobalance)
if self.videobalance_contrast:
self.videobalance.set_property(
"contrast", self.videobalance_contrast
)
if self.videobalance_brightness:
self.videobalance.set_property(
"brightness", self.videobalance_brightness
)
if self.videobalance_hue:
self.videobalance.set_property(
"hue", self.videobalance_hue
)
if self.videobalance_saturation:
self.videobalance.set_property(
"saturation", self.videobalance_saturation
)
gst.element_link_many(
self.pip, self.watermark, self.colorspace, self.videobalance,
self.queue_video
)
self._switch_source()
self._switch_pip()
if self.pip_position:
self.pip.set_property("position", self.pip_position)
self.effect[MEDIA_VIDEO] = effect.video_effect.VideoEffect(
self.effect_name[MEDIA_VIDEO]
)
self.player.add(self.effect[MEDIA_VIDEO])
self.overlay = gst.element_factory_make("textoverlay", "overlay")
self.overlay.set_property("font-desc", self.overlay_font)
self.overlay.set_property("halign", self.halign)
self.overlay.set_property("valign", self.valign)
self.player.add(self.overlay)
gst.element_link_many(
self.queue_video, self.effect[MEDIA_VIDEO], self.overlay
)
self.preview_tee = multeequeue.MulTeeQueue()
self.player.add(self.preview_tee)
self.overlay.link(self.preview_tee)
if self.input_type & MEDIA_AUDIO:
self.convert = gst.element_factory_make("audioconvert", "convert")
self.player.add(self.convert)
self.effect[MEDIA_AUDIO] = effect.audio_effect.AudioEffect(
self.effect_name[MEDIA_AUDIO]
)
self.player.add(self.effect[MEDIA_AUDIO])
self.audio_tee = gst.element_factory_make("tee", "audio_tee")
self.player.add(self.audio_tee)
self.volume = volume.Volume()
self.player.add(self.volume)
gst.element_link_many(
self.input_selector, self.volume,
self.effect[MEDIA_AUDIO], self.convert, self.audio_tee
)
self.input_selector.set_property(
"active-pad", self.audio_pads[self.audio_source]
)
added_encoders = {}
pip_width = 0
pip_height = 0
for row in self.outputs.get_store():
(name, output) = row
output_bin = outputbin.OutputBin(output)
self.output_bins[name] = output_bin
self.player.add(output_bin)
encoder_name = output.get_config()["parent"]
encoder_item = self.encoders.get_item(encoder_name)
if encoder_item is None:
self.emit("error", "Please, add an encoder.")
break
if added_encoders.has_key(encoder_name):
tee = added_encoders[encoder_name]
tee.link(output_bin)
else:
tee = gst.element_factory_make("tee", None)
self.player.add(tee)
converter_item = encoder_item.parent
converter = converter_item.create()
if converter_item.config["width"] > pip_width:
pip_width = converter_item.config["width"]
if converter_item.config["height"] > pip_height:
pip_height = converter_item.config["height"]
self.player.add(converter)
encoder = encoder_item.factory.create(type)
if encoder.vorbisenc:
self.metadata = metadata.Metadata(encoder.vorbisenc)
self.metadata.set_tags(self.taglist)
encoder.config(encoder_item.config)
self.player.add(encoder)
added_encoders[encoder_name] = tee
self.preview_tee.get_src_pad().link(
converter.sink_pads().next()
)
gst.element_link_many(
converter, encoder, tee, output_bin
)
if self.input_type & MEDIA_AUDIO:
audio_queue = gst.element_factory_make("queue", None)
self.player.add(audio_queue)
gst.element_link_many(self.audio_tee, audio_queue, encoder)
self.preview = Preview(self)
self.player.add(self.preview)
self.preview_tee.get_src_pad().link(self.preview.sink_pads().next())
if pip_width == 0:
pip_width = 320
pip_height = 240
self.pip.set_property("width", int(pip_width))
self.pip.set_property("height", int(pip_height))
self.video_width = int(pip_width)
self.video_height = int(pip_height)
self._set_watermark(self.video_width, self.video_height)
self.overlay.set_property("text", self.overlay_text)
if self.volume_value is not None:
self.volume.set_property("volume", self.volume_value)
self.emit("pipeline-ready")
bus = self.player.get_bus()
bus.add_signal_watch()
bus.enable_sync_message_emission()
bus.connect("message", self.on_message)
bus.connect("sync-message::element", self.on_sync_message)
cr = self.player.set_state(gst.STATE_PLAYING)
if cr == gst.STATE_CHANGE_SUCCESS:
self.emit("playing")
elif cr == gst.STATE_CHANGE_ASYNC:
self.pending_state = gst.STATE_PLAYING
# Add Aircraft section
aircraftFrame = aircraft.Aircraft(root, mainFrame)
aircraftFrame.grid(column=0, row=2, sticky='w')
# Add horizontal line
ttk.Separator(mainFrame, orient=HORIZONTAL).grid(column=0, row=3, sticky='ew')
# Add Origin Section
originFrame = origin.Origin(root, mainFrame)
originFrame.grid(column=0, row=4, sticky='w')
# Add horizontal line
ttk.Separator(mainFrame, orient=HORIZONTAL).grid(column=0, row=5, sticky='ew')
# Create Volumne section
volumeFrame = volume.Volume(root, mainFrame, originFrame)
volumeFrame.grid(column=0, row=6, sticky='w')
originFrame.volFrame = volumeFrame
# Add horizontal line
ttk.Separator(mainFrame, orient=HORIZONTAL).grid(column=0, row=7, sticky='ew')
# Create Generate section
generateFrame = tools.Generate(root, mainFrame, displayFrame, aircraftFrame,
originFrame, volumeFrame)
generateFrame.grid(column=0, row=8)
# Close on Escape
root.bind('<Key-Escape>', generateFrame.close)
# Change close function
def factory(bandlims, ns, shf = [0.0], gdtype = 'cartes'):
res = None
if 'cartes' == gdtype:
ct = ns[0]
lim_t = ct * 4 - 1
lbpar_t = cd.LbFixParams( [ct], [lim_t] )
shf_t = shf[0]
T = bandlims[0][1]
dt = T / ct
diff = [dt]
shf = [shf_t]
band = [T]
ptpar = cd.PtFixParams(diff, shf, band)
lb_t = cd.LbGen(lbpar_t)
pt_t = cd.PtGen(ptpar)
dim_lb = (0, 0)
obj_lb = [lb_t]
dims_lb = [dim_lb]
mst_lb = mst.MdimStruct(obj_lb, dims_lb)
dims_pt = [ (0, 0) ]
obj_pt = [pt_t]
mst_pt = mst.MdimStruct(obj_pt, dims_pt)
gen = gn.Generator(mst_lb, mst_pt)
samps = gd.Grid(gen)
shf = [0.0]
ptpar = cd.PtFixParams(diff, shf, band)
pt_t = cd.PtGen(ptpar)
dims_pt = [ (0, 0) ]
obj_pt = [pt_t]
mst_pt = mst.MdimStruct(obj_pt, dims_pt)
gen = gn.Generator(mst_lb, mst_pt)
bounds = gd.Grid(gen)
bandstr = mst.MdimStruct( [ [0, T] ], [ (0,0) ] )
res = Domain(samps, bounds, None, None, True, bandstr)
elif 'polar' == gdtype:
R = bandlims[0][1]
A = bandlims[1][1]
cr = int( ns[0] )
ca = int( ns[1] )
lim_r = cr * 4 - 1
lim_a = ca * 2 - 1
lbpar_r = pl.LbFixParams( [cr], [lim_r] )
lbpar_a = pl.LbFixParams( [ca], [lim_a] )
shf_r = shf[0]
shf_a = shf[1]
dr = R / cr
da = A / ca
diff = [dr, da]
shf = [shf_r, shf_a]
band = [R, A]
ptpar = pl.PtFixParams(diff, shf, band)
pol_lb_r = pl.PolarLbGen(lbpar_r)
pol_lb_a = pl.PolarLbGen(lbpar_a)
pol_pt = pl.PolarPtGen(ptpar)
dim_lb_r = (0, 0)
dim_lb_a = (1, 1)
obj_lb = [pol_lb_r, pol_lb_a]
dims_lb = [dim_lb_r, dim_lb_a]
mst_lb = mst.MdimStruct(obj_lb, dims_lb)
dims_pt = [ (0, 1) ]
obj_pt = [pol_pt]
mst_pt = mst.MdimStruct(obj_pt, dims_pt)
gen = gn.Generator(mst_lb, mst_pt)
samps = gd.Grid(gen)
shf_r = 0.0
shf_a = 0.0
ptpar = pl.PtFixParams(diff, shf, band)
pol_pt = pl.PolarPtGen(ptpar)
dims_pt = [ (0, 1) ]
obj_pt = [pol_pt]
mst_pt = mst.MdimStruct(obj_pt, dims_pt)
gen = gn.Generator(mst_lb, mst_pt)
bounds = gd.Grid(gen)
volume = vol.Volume( mst.MdimStruct( [vol.sector], [ (0,1) ] ) )
meas = ms.Measure( mst.MdimStruct( [ms.sector], [ (0,1) ] ) )
bandstr = mst.MdimStruct( [ [0, R], [0, A] ], [ (0,0), (1,1) ] )
res = Domain(samps, bounds, volume, meas, True, bandstr)
else:
pass
return res
def reconnect(self,filename):
self.volume = volume.Volume(filename)
self.volume.reconnect()
def format(self,filename):
self.volume = volume.Volume(filename)
self.volume.format()
