def producerLoop(exclusiveUnprocessedFileQueue, processedHistogramBuffer, numProducers):
'''
loops through, each time grabs a file from the unprocessed queue
and creates an individual histogram for that file.
Then adds that histogram to the processed buffer
for the consumer to acess
'''
global doneProducing
#while not doneProducing:
while not exclusiveUnprocessedFileQueue.isEmpty():
fileToProcess = exclusiveUnprocessedFileQueue.pop()
if fileToProcess != None: #none returned if unprocessed q was empty
#makes individual file histogram
fileHistogram = Histogram(fileToProcess)
fileHistogram.buildHistogram()
processedHistogramBuffer.add(fileHistogram)
itemsAvailable.release()
else:
continue
producerProcessedLock.acquire()
if exclusiveUnprocessedFileQueue.isEmpty() and not doneProducing:
doneProducing = 1
producerProcessedLock.release()
#tells consumer that a thread is done processing
itemsAvailable.release()
def _get_ping_property(cursor, path, histograms_url, additional_histograms):
is_histogram = False
is_keyed_histogram = False
if path[0] == "histograms":
is_histogram = True
elif path[0] == "keyedHistograms":
# Deal with histogram names that contain a slash...
path = path[:2] + (["/".join(path[2:])] if len(path) > 2 else [])
is_keyed_histogram = True
try:
for field in path:
cursor = cursor[field]
except:
return None
if cursor is None:
return None
if is_histogram:
return Histogram(path[-1],
cursor,
histograms_url=histograms_url,
additional_histograms=additional_histograms)
elif is_keyed_histogram:
histogram = Histogram(path[-2],
cursor,
histograms_url=histograms_url,
additional_histograms=additional_histograms)
histogram.name = "/".join(path[-2:])
return histogram
else:
return cursor
def test_histograms(self):
ftmp = NamedTemporaryFile(suffix='.h5', delete=False)
try:
ftmp.close()
hh = dict(h0=Histogram(3, [0, 1]),
h1=Histogram(3, [0, 1], data=[-1, 0, 2]),
h2=Histogram(3, [0, 1],
data=[-1, 0, 2],
uncert=[0.5, -0.2, 1000.]),
h3=Histogram(3, [0, 1], label='counts'),
h4=Histogram(3, [0, 1], label='counts', title='title'),
h5=Histogram(3, [0, 1], 4, [-1, 1]),
h6=Histogram(3, [0, 1],
2, [-1, 1],
data=[[1, 2], [3, 4], [5, 6]]),
h7=Histogram(3, [0, 1],
2, [-1, 1],
data=[[1, 2], [3, 4], [5, 6]],
uncert=[[1, 2], [3, 4], [5, 6]]),
h8=Histogram(3, [0, 1], 2, [-1, 1], label='counts'),
h9=Histogram(3, [0, 1],
2, [-1, 1],
label='counts',
title='τιτλε'))
save_histograms(hh, ftmp.name)
hhtmp = load_histograms(ftmp.name)
#histogram.serialization.serialization.save_histograms(hh, ftmp.name)
#hhtmp = histogram.serialization.serialization.load_histograms(ftmp.name)
for k in sorted(hh):
self.assertTrue(hh[k].isidentical(hhtmp[k]))
finally:
os.remove(ftmp.name)
def __init__(self,
world,
filename=None,
simulator=None,
once=False,
headless=False):
logging.info('Initialising vision')
if simulator:
self.capture = SimCapture(simulator)
else:
self.capture = Capture(self.rawSize, filename, once)
self.headless = headless
self.threshold = threshold.AltRaw()
self.pre = Preprocessor(self.rawSize, self.threshold, simulator)
self.featureEx = FeatureExtraction(self.pre.cropSize)
self.interpreter = Interpreter()
self.world = world
self.gui = GUI(world, self.pre.cropSize, self.threshold)
self.histogram = Histogram(self.pre.cropSize)
self.times = []
self.N = 0
#debug.thresholdValues(self.threshold.Tblue, self.gui)
logging.debug('Vision initialised')
def update(self, iterable):
"""Update this histogram with the items in the given iterable"""
for sentence in iterable:
# First word in sentence (start)
previous_words = self._generate_empty_previous_words()
# Run through the sentence
for index, word in enumerate(sentence):
current_key = tuple(previous_words)
if self.get(current_key) is not None:
self[current_key].insert(word)
else:
self[current_key] = Histogram()
self[current_key].insert(word)
previous_words.pop(0)
previous_words.append(word)
# End of sentence
current_key = tuple(previous_words)
if self.get(current_key) is None:
self[current_key] = Histogram()
self[current_key].insert("*STOP*")
def create_histogram():
parent_filename = request.json[PARENT_FILENAME_NAME]
histogram_filename = request.json[HISTOGRAM_FILENAME_NAME]
fields_name = request.json[FIELDS_NAME]
request_errors = analyse_request_errors(request_validator, parent_filename,
histogram_filename, fields_name)
if request_errors is not None:
return request_errors
histogram = Histogram(database, metadata)
histogram.create_file(
parent_filename,
histogram_filename,
fields_name,
)
return (
jsonify({
MESSAGE_RESULT:
f'{MICROSERVICE_URI_GET}{histogram_filename}'
f'{MICROSERVICE_URI_GET_PARAMS}'
}),
HTTP_STATUS_CODE_SUCCESS_CREATED,
)
def test_cut_2d(self):
h2 = Histogram((100,[0,10]),(90,[-3,3]))
#h2a = h2.cut((-1,1),axis=0)
h3 = Histogram((100,[-30,330]), (100,[-50,50]))
#h3a = h3.cut(-30,30,axis=0)
h3b = h3.cut(270,330,axis=0)
def _get_ping_property(cursor, path, histograms_url, additional_histograms):
is_histogram = False
is_keyed_histogram = False
if path[0] == "histograms":
is_histogram = True
elif path[0] == "keyedHistograms":
# Deal with histogram names that contain a slash...
path = path[:2] + (["/".join(path[2:])] if len(path) > 2 else [])
is_keyed_histogram = True
try:
for field in path:
cursor = cursor[field]
except:
return None
if cursor is None:
return None
if is_histogram:
return Histogram(path[-1], cursor, histograms_url=histograms_url,
additional_histograms=additional_histograms)
elif is_keyed_histogram:
histogram = Histogram(path[-2], cursor, histograms_url=histograms_url,
additional_histograms=additional_histograms)
histogram.name = "/".join(path[-2:])
return histogram
else:
return cursor
def _get_ping_property(cursor, path):
is_histogram = False
is_keyed_histogram = False
if path[0] == "histograms":
is_histogram = True
elif path[0] == "keyedHistograms":
# Deal with histogram names that contain a slash...
path = path[:2] + (["/".join(path[2:])] if len(path) > 2 else [])
is_keyed_histogram = True
for partial in path:
cursor = cursor.get(partial, None)
if cursor is None:
break
if cursor is None:
return None
if is_histogram:
return Histogram(path[-1], cursor)
elif is_keyed_histogram:
histogram = Histogram(path[-2], cursor)
histogram.name = "/".join(path[1:])
return histogram
else:
return cursor
def parse_input(target_sequence: str, input_fasta_file: str) -> None:
"""
parse_input
:param target_sequence: The target sequence as a string.
:param input_fasta_file: The path to a FASTA file.
"""
if not Helpers.valid_dna_sequence(target_sequence):
raise click.UsageError(
'The target sequence is not a valid DNA sequence.')
input_sequence = Helpers.fasta_file_to_sequence(input_fasta_file)
if not input_sequence:
raise click.UsageError('Passed input file not in FASTA format.')
optimal_alignment_finder = OptimalAlignmentFinder(target_sequence,
input_sequence)
# If the results directory doesn't exist, create it.
if not os.path.exists(RESULTS_DIRECTORY):
os.makedirs(RESULTS_DIRECTORY)
Alignment.save_alignments(f'{RESULTS_DIRECTORY}forward_alignments.json',
optimal_alignment_finder.forward_alignments)
Histogram.save_histograms(optimal_alignment_finder.forward_alignments,
True)
Alignment.save_alignments(
f'{RESULTS_DIRECTORY}reverse_complement_alignments.json',
optimal_alignment_finder.reverse_complement_alignments)
Histogram.save_histograms(
optimal_alignment_finder.reverse_complement_alignments, False)
def compute_color_histograms(cloud, using_hsv=True):
# Compute histograms for the clusters
point_colors_list = []
# Step through each point in the point cloud
for point in pc2.read_points(cloud, skip_nans=True):
rgb_list = float_to_rgb(point[3]) # rgb_list is [r,g,b]
if using_hsv:
point_colors_list.append(rgb_to_hsv(rgb_list) * 255)
else:
point_colors_list.append(rgb_list)
# Populate lists with color values
channel_1_vals = []
channel_2_vals = []
channel_3_vals = []
for color in point_colors_list:
channel_1_vals.append(color[0])
channel_2_vals.append(color[1])
channel_3_vals.append(color[2])
a = Histogram(channel_1_vals, channel_2_vals, channel_3_vals)
normed_features = a.generate_normalised_concatenated_histogram()
return normed_features
def __init__(self, dates, open, high, low, close, vol, start, end):
if start > end:
(start, end) = (end, start)
self.report_log = []
max = None
max_date = None
min = None
min_date = None
seq_start = dates[0]
seq_end = dates[0]
series = []
n = 0
for i in range(len(dates)):
d = dates[i]
if (d > start) and (d < end):
series.append(close[i])
if (d < seq_start):
seq_start = d
if (d > seq_end):
seq_end = d
n = n + 1
h = high[i]
if max == None:
max = h
max_date = d
else:
if h > max:
max = h
max_date = d
l = low[i]
if min == None:
min = l
min_date = d
else:
if l < min:
min = l
min_date = d
self.report_log.append('%s - %s' % (seq_start, seq_end))
self.report_log.append('%d trading days' % n)
self.report_log.append('Max = %s - %s' % (str(max), max_date))
self.report_log.append('Min = %s - %s' % (str(min), min_date))
h = Histogram(series)
for l in h.report():
self.report_log.append(l)
def test_hist_1d_line(self):
rand.seed(1)
h = Histogram(40, [0, 1], 'χ (cm)', 'counts', 'Some Data')
h.fill(rand.normal(0.5, 0.1, 300))
fig, ax = plt.subplots()
pt = ax.plothist(h, style='line')
self.assertTrue(
conf.comparator.compare_images(fig.savefig, 'hist_1d_line.png'))
def load_hue_histograms(self):
for h in self.known_histograms.keys():
hist = Histogram()
hist.load(self.known_histograms[h][0])
self.known_histograms[h][1] = hist
for h in self.known_histograms:
print h
print self.known_histograms[h][1]
def test_hist_4d(self):
ftmp = NamedTemporaryFile(suffix='.root', delete=False)
try:
h = Histogram(3, [0, 1], 3, [0, 1], 3, [0, 1], 3, [0, 1])
with self.assertRaises(ValueError):
h.save(ftmp.name)
finally:
os.remove(ftmp.name)
def test_hist_2d(self):
rand.seed(1)
h = Histogram(40, [0, 1], 'χ (cm)', 30, [-5, 5], 'ψ', 'counts',
'Some Data')
h.fill(rand.normal(0.5, 0.1, 1000), rand.normal(0, 1, 1000))
fig, ax = plt.subplots()
pt = ax.plothist(h)
self.assertTrue(
conf.comparator.compare_images(fig.savefig, 'hist_2d.png'))
def test_plot_hist2d():
npoints = 100000
h2 = Histogram((100, (0, 10), 'x'), (100, (0, 10), 'y'), 'z', 'title')
h2.fill(rand.normal(5, 2, npoints), rand.uniform(0, 10, npoints))
fig, ax = pyplot.subplots(1, 2)
ax[0].plothist(h2)
ax[1].plothist(h2)
ax[1].plothist(h2.smooth(1), style='contour', overlay=True)
pyplot.savefig('test_images/test_plotting_fig_hist2d.png')
def test_1dfit(self):
p = [100, -20, 1, -0.2]
h = Histogram(100, [0, 10])
x = h.axes[0].bincenters
h.data = poly(p)(x) + rand.normal(0, np.sqrt(p[0]), len(x))
p0 = [1, 1, 1, 1]
popt, pcov, ptest = h.fit(lambda x, *p: poly(p)(x), p0)
assert np.allclose(popt, p, rtol=0.03, atol=0.5)
assert pcov.shape == (len(p), len(p))
def test_plot_hist2d():
npoints = 100000
h2 = Histogram((100,(0,10),'x'),(100,(0,10),'y'),'z','title')
h2.fill(rand.normal(5,2,npoints),
rand.uniform(0,10,npoints))
fig,ax = pyplot.subplots(1,2)
ax[0].plothist(h2)
ax[1].plothist(h2)
ax[1].plothist(h2.smooth(1), style='contour', overlay=True)
pyplot.savefig('test_images/test_plotting_fig_hist2d.png')
def main():
instanceHistogram = Histogram("ABCDF")
dataset = open('score_transcript.txt', "r")
for each_line in dataset:
letter_grade = scoreToLetterGrade(int(each_line))
instanceHistogram.increaseCount(letter_grade)
# when for loop exit, the five category have finished their statistic, ready for subsequently display
gen_chart(instanceHistogram)
def __init__(self):
# Variables for the graph
ranging_variable = "Services"
frequency = "People Count"
report_name = "Different Referral Services"
# Get the dataframe from query
df = self.get_data(ranging_variable, frequency)
# Create graph and display
his = Histogram(df, ranging_variable, frequency, title=report_name)
his.display()
def test_1dfit(self):
p = [100, -20, 1, -0.2]
h = Histogram(100, [0, 10])
x = h.axes[0].bincenters
h.data = poly(p)(x) + rand.normal(0, np.sqrt(p[0]), len(x))
p0 = [1, 1, 1, 1]
popt, pcov, ptest = h.fit(lambda x, *p: poly(p)(x), p0)
assert np.allclose(popt, p, rtol=0.03, atol=0.5)
assert pcov.shape == (len(p), len(p))
def test_plot_hist1d():
npoints = 100000
h1 = Histogram(100, (0, 10), 'x', 'y', 'title')
h1.fill(rand.normal(5, 2, npoints))
fig, ax = pyplot.subplots(2, 2)
ax[0, 0].plothist(h1, style='polygon', baseline='bottom')
ax[0, 1].plothist(h1, style='errorbar', baseline='bottom')
ax[1, 0].plothist(h1, style='polygon') #, baseline='left')
ax[1, 1].plothist(h1, style='errorbar') #, baseline='left')
pyplot.savefig('test_images/test_plotting_fig_hist1d.png')
def test_hist_3d(self):
h = Histogram(3, [0, 1], 'xx', 4, [-1, 1], 'yy', 5, [5, 10], 'zz',
'counts', 'data')
ftmp = NamedTemporaryFile(suffix='.root', delete=False)
try:
ftmp.close()
with warnings.catch_warnings(record=True) as w:
h.save(ftmp.name)
self.assertEqual(len(w), 1)
self.assertRegex(str(w[-1].message), 'label')
finally:
os.remove(ftmp.name)
def test_plot_hist1d():
npoints = 100000
h1 = Histogram(100,(0,10),'x','y','title')
h1.fill(rand.normal(5,2,npoints))
fig,ax = pyplot.subplots(2,2)
ax[0,0].plothist(h1, style='polygon' , baseline='bottom')
ax[0,1].plothist(h1, style='errorbar', baseline='bottom')
ax[1,0].plothist(h1, style='polygon' )#, baseline='left')
ax[1,1].plothist(h1, style='errorbar')#, baseline='left')
pyplot.savefig('test_images/test_plotting_fig_hist1d.png')
class HistogramTest(unittest.TestCase):
def setUp(self):
self.h = Histogram()
self.h.add("Apache")
self.h.add("Apache")
def test_add(self):
assert self.h.get_dict().get("Apache") is not None
def test_count(self):
self.assertEqual(self.h.count("Apache"), 2)
def test_2dfit(self):
fn = lambda xy, *p: poly(p[:4])(xy[0]) + poly([0] + list(p[4:]))(xy[1])
p = [100, -20, 1, -0.2, 80, -5, 0.8]
h = Histogram(100, [0, 10], 100, [0, 10])
xy = h.grid
h.data = fn(xy, *p)
h.data += rand.normal(0, np.sqrt(p[0]), h.data.shape)
p0 = [1, 1, 1, 1, 1, 1, 1]
popt, pcov, ptest = h.fit(fn, p0)
assert np.allclose(popt, p, rtol=0.01, atol=0.01)
assert pcov.shape == (len(p), len(p))
def test_2dfit(self):
fn = lambda xy, *p: poly(p[:4])(xy[0]) + poly([0] + list(p[4:]))(xy[1])
p = [100, -20, 1, -0.2, 80, -5, 0.8]
h = Histogram(100, [0, 10], 100, [0, 10])
xy = h.grid
h.data = fn(xy, *p)
h.data += rand.normal(0, np.sqrt(p[0]), h.data.shape)
p0 = [1, 1, 1, 1, 1, 1, 1]
popt, pcov, ptest = h.fit(fn, p0)
assert np.allclose(popt, p, rtol=0.01, atol=0.01)
assert pcov.shape == (len(p), len(p))
def plt_manual(xx):
print(len(xx))
xxx = []
for i in range(len(xx)):
manual_data = (x_pool[xx[i]],y_pool[xx[i]],t_pool[xx[i]],i_pool[xx[i]])
histogram = Histogram(manual_data)
histogram.createImage()
y_pool[xx[i]] = histogram.result
print(y_pool[xx[i]])
if y_pool[xx[i]] != cf.NONE_SENSE_DATA_TYPE:
xxx.append(xx[i])
print(y_pool[xx[i]])
return np.array(xxx)
def test_1dfit_zeros(self):
p = [100, -20, 1, -0.2]
h = Histogram(100, [0, 10])
x = h.axes[0].bincenters
h.data = poly(p)(x) + rand.normal(0, np.sqrt(p[0]), len(x))
ii = rand.randint(0, h.axes[0].nbins, 5)
h.data[ii] = 0
p0 = [1, 1, 1, 1]
popt, pcov, ptest = h.fit(lambda x, *p: poly(p)(x), p0)
assert np.allclose(popt, p, rtol=0.1, atol=1.)
assert pcov.shape == (len(p), len(p))
def test_1dfit_zeros(self):
p = [100, -20, 1, -0.2]
h = Histogram(100, [0, 10])
x = h.axes[0].bincenters
h.data = poly(p)(x) + rand.normal(0, np.sqrt(p[0]), len(x))
ii = rand.randint(0, h.axes[0].nbins, 5)
h.data[ii] = 0
p0 = [1, 1, 1, 1]
popt, pcov, ptest = h.fit(lambda x, *p: poly(p)(x), p0)
assert np.allclose(popt, p, rtol=0.1, atol=1.0)
assert pcov.shape == (len(p), len(p))
def make_histo(reads):
'''Given a dict of reads keyed by sequence, create a Histogram
object summarising the distribution of duplicated reads.'''
LOGGER.debug("making histogram...")
total = 0
histo = Histogram()
for read in reads.iterkeys():
histo.add(reads[read])
if reads[read] >= 1000:
sys.stdout.write("%s\t%d\n" % (read, reads[read]))
total += 1
if total % 100000 == 0 and ISATTY:
sys.stderr.write("%9d\r" % (total, ))
return histo
def create_histogram(parent_filename):
database = MongoOperations(
collection_database_url(os.environ[DATABASE_URL],
os.environ[DATABASE_REPLICA_SET]),
os.environ[DATABASE_PORT],
os.environ[DATABASE_NAME],
)
request_validator = HistogramRequestValidator(database)
try:
request_validator.histogram_filename_validator(
request.json[HISTOGRAM_FILENAME_NAME])
except Exception as invalid_histogram_filename:
return (
jsonify({
MESSAGE_RESULT:
invalid_histogram_filename.args[FIRST_ARGUMENT]
}),
HTTP_STATUS_CODE_CONFLICT,
)
try:
request_validator.filename_validator(parent_filename)
except Exception as invalid_filename:
return (
jsonify({MESSAGE_RESULT: invalid_filename.args[FIRST_ARGUMENT]}),
HTTP_STATUS_CODE_NOT_ACCEPTABLE,
)
try:
request_validator.fields_validator(parent_filename,
request.json[FIELDS_NAME])
except Exception as invalid_fields:
return (
jsonify({MESSAGE_RESULT: invalid_fields.args[FIRST_ARGUMENT]}),
HTTP_STATUS_CODE_NOT_ACCEPTABLE,
)
histogram = Histogram(database)
histogram.create_histogram(
parent_filename,
request.json[HISTOGRAM_FILENAME_NAME],
request.json[FIELDS_NAME],
)
return (
jsonify({MESSAGE_RESULT: MESSAGE_CREATED_FILE}),
HTTP_STATUS_CODE_SUCESS_CREATED,
)
def getHistogramViews(self):
"""
Return a list of the histogram views defined by the layout.
If there is more than one histogram view in the current
application layout, each one can be accessed via its own element
in the list. For example, if there are 3 histogram views in the
GUI, the following sequence of commands can be used to set a
different clip range percent in each one:
h = v.getHistogramViews()
h[0].setClipRangePercent(1, 99)
h[1].setClipRangePercent(5, 95)
h[2].setClipRangePercent(0.1, 99.9)
Returns
-------
list
A list of Histogram objects.
"""
commandStr = "getHistogramViews"
histogramViewsList = self.con.cmdTagList(commandStr)
histogramViews = []
if (histogramViewsList[0] != ""):
for hv in histogramViewsList:
histogramView = Histogram(hv, self.con)
histogramViews.append(histogramView)
return histogramViews
class Dictogram(dict):
def __init__(self, text_file=None):
self.histogram = None
if text_file is not None:
self.histogram = Histogram(text_file)
self.create_dictogram()
def create_dictogram(self):
if self.histogram is not None:
for index, word in enumerate(self.histogram.words_list):
if index + 1 > len(self.histogram.words_list) - 1:
return
next_word = self.histogram.words_list[index + 1]
if word not in self:
self[word] = {}
histogram = Histogram()
#pdb.set_trace()
#histogram = {next_word:0}
self[word] = histogram.add(next_word)
else:
self.histogram = self[word]
self[word] = self.histogram.add(next_word)
def __init__(self, jsonDict):
self.index = 1
self.title = ""
self.xtitle = ""
self.ytitle = ""
self.__dict__ = jsonDict
self.items = []
if "__items__" in jsonDict:
for item in jsonDict["__items__"]:
if item["type"] == "Line2D":
self.items.append(Line2D(item))
elif item["type"] == "Point2D":
self.items.append(Line2D(item))
elif item["type"] == "Histogram":
self.items.append(Histogram(item))
elif item["type"] == "Text":
self.items.append(Text(item))
elif item["type"] == "Annotation":
self.items.append(Annotation(item))
elif item["type"] == "Hline":
self.items.append(Hline(item))
elif item["type"] == "Vline":
self.items.append(Vline(item))
elif item["type"] == "Arc":
self.items.append(Arc(item))
if "grid" in jsonDict:
self.grid = Grid(jsonDict["grid"])
else:
self.grid = Grid()
def create_dictogram(self):
if self.histogram is not None:
for index, word in enumerate(self.histogram.words_list):
if index + 1 > len(self.histogram.words_list) - 1:
return
next_word = self.histogram.words_list[index + 1]
if word not in self:
self[word] = {}
histogram = Histogram()
#pdb.set_trace()
#histogram = {next_word:0}
self[word] = histogram.add(next_word)
else:
self.histogram = self[word]
self[word] = self.histogram.add(next_word)
def get_histogram(self, node_index, feature_index, class_key):
if node_index not in self.histograms:
self.histograms[node_index] = dict()
if feature_index not in self.histograms[node_index]:
self.histograms[node_index][feature_index] = dict()
if class_key not in self.histograms[node_index][feature_index]:
self.histograms[node_index][feature_index][class_key] = Histogram(self.bins_count)
return self.histograms[node_index][feature_index][class_key]
def test_unicode(self):
ftmp = NamedTemporaryFile(suffix='.root', delete=False)
try:
ftmp.close()
h = Histogram(3, [0, 3])
h.data[:] = [-3, 0, 5]
h.uncert = np.sqrt(np.abs(
h.data)) # ROOT will always return uncert
h.title = 'χ-squared'
h.label = 'αβγ'
h.axes[0].label = 'θ'
h.save(ftmp.name)
htmp = Histogram.load(ftmp.name)
self.assertTrue(h.isidentical(htmp))
finally:
os.remove(ftmp.name)
def reports(scanner):
if args.excel:
rp = ReportCreator(scanner.get_report_list(), dirs['reports'])
rp.excel_report()
if args.graph:
try:
from graphcreator import ToGraph
graph = ToGraph(scanner.get_report_list())
graph.write_graph()
except ImportError as exc:
logger.exception(exc)
print(
"You need graph-tool installed to draw a graph, please visit https://graph-tool.skewed.de/"
)
if args.histogram:
ist = Histogram(scanner.get_report_list())
ist.create_histogram()
def show_distribution(quicktipp, two_dee):
if two_dee:
from histogram import Histogram2d
histogram = Histogram2d()
else:
from histogram import Histogram
histogram = Histogram()
histogram.tipps(q.get())
histogram.skipped(q.get_skipped())
histogram.show()
def test_mean(self):
h = Histogram(10,[0,10])
h.fill([3,3,3])
assert_almost_equal(h.mean()[0],3.5)
h.fill([1,5])
assert_almost_equal(h.mean()[0],3.5)
def test_rebin(self):
h = Histogram(10,[0,10])
h.set(1)
hexpect = Histogram(5,[0,10])
hexpect.set(2)
hrebin = h.rebin(2)
assert_array_almost_equal(hrebin.data, hexpect.data)
assert_array_almost_equal(hrebin.axes[0].edges, hexpect.axes[0].edges)
def test_hdf5(self):
try:
import h5py
h = self.h.clone()
filename = 'h.hdf5'
h.save(filename)
hh = Histogram.load(filename)
assert h.isidentical(hh)
except ImportError:
pass
def __init__(self, topic=DEF_TOPIC_NAME, hist_file=DEF_HISTOGRAM_FILE):
rospy.init_node("skin_detection", anonymous=True)
rospy.Subscriber(topic, Image, self.rgb_cb)
cv2.namedWindow("wnd_orig")
cv2.namedWindow("wnd_prob")
cv2.namedWindow("wnd_skin")
self.skin_threshold = 127
cv2.createTrackbar("track_skin", "wnd_skin", self.skin_threshold, 255, self.on_skin_track)
rospy.on_shutdown(self.on_shutdown)
self.hist = Histogram()
self.hist.load(hist_file)
def get_next_hop(self):
hist = Histogram()
print hist
for message in self.ferry.messages:
hist.count(message.dest)
priorities = hist.norm_hist()
hop = random.choice(self.ferry.term_map.items())
max_rating = 0.0
for term in self.ferry.term_map.keys():
try:
prio = priorities[term]
d = self.dist(self.term_pos(self.current_term), self.term_pos(term))
rating = priorities[term] / self.dist(self.term_pos(self.current_term), self.term_pos(term))
except:
rating = 0.0
if rating > max_rating:
max_rating = rating
hop = term, self.term_pos(term)
self.current_term = hop[0]
return hop
def test___itruediv__(self):
h1 = Histogram(3,[0,10],data=[1,2,3])
h2 = Histogram(3,[0,10],data=[2,1,0])
h3 = h1.clone(np.float64)
h3 /= 2
assert_array_equal(h1.data, np.array([1,2,3],dtype=np.int64))
assert_array_almost_equal(h3.data, [0.5,1,1.5])
h3 = h1.clone()
try:
h3 /= h1
except TypeError:
assert True
else:
assert False
h3 = h1.clone(np.float64)
h3 /= h2
assert_array_equal(h1.data, np.array([1,2,3],dtype=np.int64))
assert_array_almost_equal(h3.data, [0.5,2.0,0.0])
class SkinDetector:
def __init__(self, topic=DEF_TOPIC_NAME, hist_file=DEF_HISTOGRAM_FILE):
rospy.init_node("skin_detection", anonymous=True)
rospy.Subscriber(topic, Image, self.rgb_cb)
cv2.namedWindow("wnd_orig")
cv2.namedWindow("wnd_prob")
cv2.namedWindow("wnd_skin")
self.skin_threshold = 127
cv2.createTrackbar("track_skin", "wnd_skin", self.skin_threshold, 255, self.on_skin_track)
rospy.on_shutdown(self.on_shutdown)
self.hist = Histogram()
self.hist.load(hist_file)
def on_skin_track(self, pos, *argv):
self.skin_threshold = pos
def find_skin(self, img):
img_hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)
mask = hsv_filter_mask(img_hsv)
back_proj = calc_back_proj(img_hsv, self.hist.hist, hsv=True)
back_proj &= mask
skin_bin = cv2.threshold(back_proj, self.skin_threshold, 255, cv2.THRESH_BINARY)
return (back_proj, skin_bin[1])
def rgb_cb(self, msg):
try:
img = bridge.imgmsg_to_cv(msg, "bgr8")
img = np.asarray(img)
except CvBridgeError, e:
print >> stderr, "Cannot convert from ROS msg to CV image:", e
(img_prob, img_skin) = self.find_skin(img)
cv2.imshow("wnd_orig", img)
cv2.imshow("wnd_prob", img_prob)
cv2.imshow("wnd_skin", img_skin)
ch = cv2.waitKey(3)
if ch == 27:
rospy.signal_shutdown("Quit")
elif ch == ord(" "):
cv2.imwrite("img_prob.png", img_prob)
def getServersDict(all_servers):
h = Histogram()
for server in all_servers:
if server is not None:
if 'apache' in server.lower():
h.add('Apache')
if 'nginx' in server.lower():
h.add('nginx')
if 'IIS' in server.upper():
h.add('IIS')
return h
def get_headers(self):
all_links = self.parse_html()
server_names = ["Apache", "nginx", "Zeus", "Microsoft-IIS"]
histogram = Histogram()
for link in all_links:
try:
if link is not None and "link.php?id=" in link:
req = requests.head(self.url + link, timeout=3, allow_redirects=True)
get_server = req.headers["Server"]
print(get_server)
for servers in server_names:
if servers in get_server:
get_server = servers
histogram.add(get_server)
break
if servers == server_names[-1]:
get_server = "other servers"
histogram.add(get_server)
except Exception:
print("The page is not responding...")
continue
return histogram
def hist_set(self):
""" A method to generate and yield (energy, histogram) pairs.
Usage: for energy, hist in fits_parser.hist_set():
... do something ...
yield:
(float, Histogram): The energy and histogram pairs. This will yield one set
for each energy in the fits file.
"""
print 'Generating hist set'
xedges = self._get_edges(self._x_ref, self._x_del)
yedges = self._get_edges(self._y_ref, self._y_del)
for i, energy in enumerate(self._energies):
print '\tHistogram for', energy
h = Histogram()
h.setup(self._data[i], xedges, yedges)
energy = energy[0]
yield (energy, h)
print 'Done'
def test_root(self):
# For CERN/ROOT, we resorted to converting everything
# into float64's so histograms are not typically
# "identical" but they should be "close"
try:
import ROOT
h = self.h.clone()
filename = 'h.root'
self.h.save(filename)
hh = Histogram.load(filename)
assert np.allclose(h.data,hh.data)
assert np.allclose(h.uncert,hh.uncert)
assert h.label == hh.label
assert h.title == hh.title
for a,aa in zip(h.axes,hh.axes):
assert np.allclose(a.edges,aa.edges)
assert a.label == aa.label
except ImportError:
pass
def __init__(self, world, filename=None, simulator=None):
logging.info('Initialising vision')
if simulator:
self.capture = SimCapture(simulator)
else:
self.capture = MPlayerCapture(self.rawSize, filename)
#self.capture = Capture(self.rawSize, filename)
self.threshold = threshold.PrimaryRaw()
self.pre = Preprocessor(self.rawSize, self.threshold, simulator)
self.featureEx = FeatureExtraction(self.pre.cropSize)
self.interpreter = Interpreter()
self.world = world
self.gui = GUI(world, self.pre.cropSize, self.threshold)
self.histogram = Histogram(self.pre.cropSize)
self.times=[]
self.N=0
debug.thresholdValues(self.threshold.Tfg, self.gui)
logging.debug('Vision initialised')
def get_histograms(path, bad_words):
histograms = []
names = []
pair = []
for element in os.listdir(path):
temp_path = os.path.join(path, element)
for directory in os.listdir(temp_path):
full_path = os.path.join(temp_path, directory)
# for document in directory create histogram
hist = Histogram(full_path)
# process file
hist.process_file(bad_words)
# full-fill words and numbers table
hist.get_words()
# sort histogram
hist_sort = hist.sort_histogram()
# append histograms table with histogram of current document
histograms.append(hist_sort)
names.append(hist.push_name())
pair = [histograms, names]
return pair
def setUp(self):
rc.overwrite.overwrite = 'always'
np.random.seed(1)
h = Histogram(100,[0,10],'Δx', 'y', 'title')
h.fill(np.random.normal(5,2,10000))
h.uncert = np.sqrt(h.data)
if sys.version_info < (3,0):
def _to_unicode(s):
if not isinstance(s,unicode):
return unicode(s,'utf-8')
else:
return s
h.title = _to_unicode(h.title)
h.label = _to_unicode(h.label)
for ax in h.axes:
ax.label = _to_unicode(ax.label)
self.h = h
# mm1queue.py
#-----------------------------------------------------------------------
import sys
import stddraw
import stdrandom
from linkedqueue import Queue
from histogram import Histogram
# Accept float command-line arguments lamb and mu. Simulate an
# M/M/1 queue with arrival rate lamb and service rate mu.
lamb = float(sys.argv[1]) # Arrival rate
mu = float(sys.argv[2]) # Service rate
histogram = Histogram(60 + 1)
queue = Queue()
stddraw.setCanvasSize(700, 500)
# Compute time of next arrival.
nextArrival = stdrandom.exp(lamb)
# Compute time of next completed service.
nextService = nextArrival + stdrandom.exp(mu)
# Simulate the M/M/1 queue.
while True:
# Next event is an arrival.
while nextArrival < nextService:
# Simulate an arrival
def test_inserts(words, tree):
hist = Histogram(tree)
for i in words:
hist.add_word(i)
def test_inserts(words, tree):
hist = Histogram(tree)
for i in words:
hist.add_word(i)
def test_frequency(word, hist):
hist.frequency(word)
WORDS_ALL = get_full_word_list()
WORDS_100 = WORDS_ALL[:100]
if __name__ == "__main__":
radix_freq = Histogram(RadixTree)
binary_freq = Histogram(BinaryTree)
for word in WORDS_ALL:
radix_freq.add_word(word)
binary_freq.add_word(word)
print("radix_space: ", len(pickle.dumps(radix_freq)))
print("binary_space: ", len(pickle.dumps(binary_freq)))
radix_insert_test = "test_inserts(WORDS_100, RadixTree)"
binary_insert_test = "test_inserts(WORDS_100, BinaryTree)"
radix_freq_test = "test_frequency('{}', radix_freq)".format(WORDS_ALL[-1])
binary_freq_test = "test_frequency('{}',binary_freq)".format(WORDS_ALL[-1])
trial_nums = [10, 100, 1000, 10000]
# -*- coding: utf-8 -*- import numpy as np from histogram import Histogram np.random.seed(1) h = Histogram(100,[0,10],'Δx', 'y', 'title') h.fill(np.random.normal(5,2,10000)) h.uncert = np.sqrt(h.data)