def build_features(self, image_shape):
height, width = image_shape
features = []
# TODO: play with minimum feature size
for w in range(1, width+1):
for h in range(1, height+1):
x = 0
while x + w < width:
y = 0
while y + h < height:
# 2 horizontally aligned blocks
root = Region(x,y,w, h)
right = Region(x+w, y, w,h)
# check if the VJ feature can be fit into the image
if x + 2 * w < width:
features.append(Feature([right], [root]))
bottom = Region(x, y+h, w, h)
# 2 vertically aligned blocks
if y + 2 * h < height:
features.append(Feature([root],[bottom]))
# 3 horizontally aligned blocks
right2 = Region(x+2*w, y, w,h)
if x + 3 * w < width:
features.append(Feature([right], [right2, root]))
cross_bottom = Region(x+w, y+h, w, h)
if x + 2 * w < width and y + 2 * h < height:
features.append(Feature([right, bottom], [root, cross_bottom]))
y += 1
x += 1
return features
def feature_detection(S_ana_log):
indices = np.argwhere(
~np.isnan(S_ana_log)) # Find all non-NaN indices in S_ana_log
#print(np.shape(indices))
Features_list = [] # initialize Features_list
for [x_ind, y_ind] in indices: # For each pair of indices (pixel)
if len(Features_list) == 0: # if len of feature_list is 0
newFeature = Feature(x_ind, y_ind) # create a new feature
Features_list.append(newFeature) # add new feature to feature_list
else:
border_list = [
] # initialize list of logicals on where a Feature borders current pixel
sublist = [
] # initialize list of neighboring Features that boarder current pixel
for currentFeature in Features_list: # for each feature in list
border_list.append(currentFeature.borders(
x_ind, y_ind)) # find all features that boarders the pixel
indslist = np.where(border_list)[0]
if len(indslist
) == 1: # if current pixel boarders the exactly 1 Feature
hunterFeature = Features_list[indslist[0]] # find that Feature
hunterFeature.add(x_ind,
y_ind) # add current pixel to that Feature
if len(indslist
) > 1: # if the current pixel boarders more than 1 Feature
for ind in indslist:
sublist.append(
Features_list[ind]) # add those Features to a list
for s in sublist:
Features_list.remove(
s) # remove those Features from Features_list
hunterFeature = conjoin(
sublist) # conjoin all Features in sublist
hunterFeature.add(
x_ind, y_ind) # add current pixel to conjoined Feature
Features_list.append(
hunterFeature) # add conjoined Feature to Feature_list
else: # if current pixel does not boarder any existing features
newFeature = Feature(x_ind, y_ind) # create a new feature
Features_list.append(
newFeature) # add new feature to feature_list
return (Features_list, indices)
def decorate_outside(obj, options=Map()):
obj.points = []
obj.points_edges = []
obj.material_clear = Blocks.AIR
border = flatten_list_of_lists(
[vg.get_line_from_points(l[0], l[1]) for l in options.lines])
if options.options.outside == "flowers":
flowers_1 = []
flowers_2 = []
for i, b in enumerate(border):
# TODO: Refactor to have multiple numbers of flowers
if (i % 2) == 0:
flowers_1.append(b)
else:
flowers_2.append(b)
colors = Blocks.kind("Flower")
np.random.shuffle(colors)
obj.features.append(
Feature("flowers", flowers_1, Map(material=colors[0])))
obj.features.append(
Feature("flowers", flowers_2, Map(material=colors[1])))
elif options.options.outside == "trees":
trees = []
for i, b in enumerate(border):
if (i % 3) == 0:
trees.append(b)
colors = Blocks.kind("Sapling")
np.random.shuffle(colors)
obj.features.append(Feature("flowers", trees, Map(material=colors[0])))
elif options.options.outside == "grass":
trees = []
for i, b in enumerate(border):
if (i % 3) == 0:
trees.append(b)
obj.features.append(
Feature("flowers", trees, Map(material=Blocks.DOUBLETALLGRASS)))
elif options.options.outside == "fence":
fence_type = np.random.random_integers(188, 192)
obj.features.append(Feature("fence", border, Map(material=fence_type)))
return obj
def create_features(self, img_height, img_width, min_feature_width, max_feature_width, min_feature_height, max_feature_height):
features = []
print('Creating feature ...')
for feature in FeatureTypes:
feature_start_width = max(min_feature_width, feature[0])
for feature_width in range(feature_start_width, max_feature_width, feature[0]):
feature_start_height = max(min_feature_height, feature[1])
for feature_height in range(feature_start_height, max_feature_height, feature[1]):
for x in range(img_width - feature_width):
for y in range(img_height - feature_height):
features.append(Feature(feature, (x, y), feature_width, feature_height, 0, 1))
features.append(Feature(feature, (x, y), feature_width, feature_height, 0, -1))
print('..done. ' + str(len(features)) + ' features created.')
return features
def prepare(self, scales):
# const vector<Size>& scales
# Initialize test locations for features
totalFeatures = self.nstructs * self.structSize
for i in range(len(scales)):
tmp = []
self.features.append(tmp)
for i in range(totalFeatures):
x1f = random.random()
x2f = random.random()
y1f = random.random()
y2f = random.random()
for j in range(len(scales)):
# scales[j][0] = width, scales[j][1] = height
x1 = x1f * scales[j][0]
y1 = y1f * scales[j][1]
x2 = x2f * scales[j][0]
y2 = y2f * scales[j][1]
self.features[j].append(Feature(x1, y1, x2, y2))
# Thresholds
self.thrN = 0.5 * self.nstructs
# Initialize Posteriors
# positives = Pcounter, negatives = Ncounter
for i in range(self.nstructs):
self.posteriors.append([0] * pow(2, self.structSize))
self.pCounter.append([0] * pow(2, self.structSize))
self.nCounter.append([0] * pow(2, self.structSize))
def test_avg(iterations, test_file, beam_size):
data = prepare_data.read_file(test_file)
feature = Feature()
decoder = Decoder(beam_size, feature.get_score)
count = 0
data_size = len(data)
model_file = open(
'/home/xzt/CWS/model_result/avg-model_beam-size-' + str(beam_size) +
'.pkl', 'rb')
feature.load_model(model_file)
model_file.close()
for line in data:
z = decoder.beamSearch(line)
seg_data = ' '.join(z)
seg_data_file = '/home/xzt/CWS/test_seg_data/avg-test-seg-data' + '_beam-size-' + str(
beam_size) + '.txt'
with open(seg_data_file, 'a') as f:
f.write(seg_data + '\n')
count += 1
if count % 1000 == 0:
print("segment with avg-model, finish %.2f%%" %
((count / data_size) * 100))
f.close()
print("segment with avg model finish")
def train(iterations, train_file, beam_size):
data = prepare_data.read_file(train_file)
feature = Feature()
decoder = Decoder(beam_size, feature.get_score)
for t in range(iterations):
count = 0
data_size = len(data)
for line in data:
y = line.split()
z = decoder.beamSearch(line)
if z != y:
feature.update_weight(y, z)
train_seg = ' '.join(z)
seg_data_file = '/home/xzt/CWS/train_seg_data/train-seg-data_ model-' + str(
t) + '.txt'
with open(seg_data_file, 'a') as f:
f.write(train_seg + '\n')
count += 1
if count % 1000 == 0:
print("iter %d , finish %.2f%%" % (t,
(count / data_size) * 100))
model_file = open(
"/home/xzt/CWS/model_result/model-" + str(t) + "_beam-size-" +
str(beam_size) + '.pkl', 'wb')
feature.save_model(model_file)
model_file.close()
f.close()
print("segment with model-%d finish" % t)
print("iteration %d finish" % t)
def add_alters_to_ego_net(ego_net, alter_features_file, ego_net_features):
'''
ego_net: object of EgoNet class
alter_features_file: file the user inputs
ego_net_features: used to access feature dictionary
function splits information in file
gets the feature name and value using the different classes
calls add_feature function from Node class and adds that to a node
uses add_alter_node function from EgoNet class using ego_net object
returns the ego_net object
'''
for line in alter_features_file: #goes through each line in the file
pieces = line.split() #splits and creates list with information
node_id = int(pieces[0]) #gets the id
new_node = Node(node_id, len(
pieces[1:])) #calls Node class using id and other information
for i, j in enumerate(
pieces[1:]
): #uses enumerate to get index and value of the information
feature_name = ego_net_features[i][1] #gets feature name
feature_value = ego_net_features[i][0] #gets feature value
feature_object = Feature(
feature_name, feature_value,
int(j)) #calls Feature class to get information
new_node.add_feature(
i, feature_object
) #calls the add_feature funtion from the Node class and adds that to a node
ego_net.add_alter_node(
new_node
) #uses add_alter_node function from EgoNet class using ego_net object
return ego_net #returns the ego_net object
def add_feature(self, feature, **kwargs):
""" add_feature(self, feature, **args)
o feature Bio.SeqFeature object
o **kwargs Keyword arguments for Feature. Named attributes
of the Feature
Add a Bio.SeqFeature object to the diagram (will be stored
internally in a Feature wrapper
"""
id = self.next_id # get id number
self.features[id] = Feature(self, id, feature) # add feature
for key in kwargs:
if key == "colour" or key == "color":
#Deal with "colour" as a special case by also mapping to color.
#If Feature.py used a python property we wouldn't need to call
#set_color explicitly. However, this is important to make sure
#every color gets mapped to a colors object - for example color
#numbers, or strings (may not matter for PDF, but does for PNG).
self.features[id].set_color(kwargs[key])
continue
setattr(self.features[id], key, kwargs[key])
self.next_id += 1 # increment next id
def add_alters_to_ego_net(ego_net, alter_features_file, ego_net_features):
'''
Iterates through each line in the features_file using for loop
Splits each line into a list separated by spaces
Isolates the alter_id, and the alter values in the line_list
Creates a Node object using the alter_id and the number of features
For each value in the alter_values
Use the alter add_feature method to add features to that alter
Add the node/alter to the ego_net
Returns: ego_net
'''
#Iterates through each line in the feature_fil;e
for line in alter_features_file:
#Splits line into a list
a_list = line.split()
#Isolates values
alter_id = int(a_list[0])
line_list = a_list[1:]
#Creates an node object and assigning it to alter
alter = Node(alter_id, len(line_list))
#Iterates through each value in the alter_values list
for i, digit in enumerate(line_list):
# in order to add a feature we must create a Feature instance
alter.add_feature(
i,
Feature((ego_net_features[i][1]), ego_net_features[i][0],
int(digit)))
#Add the alter to the ego_net
ego_net.add_alter_node(alter)
return ego_net
def flw_dataset_classify():
f = Feature()
paths, classes = loadFaceData('face.csv', nrows=82)
X = []
y = []
for index, path in enumerate(paths):
ar = f.getFeature(path)
print(index, path)
if ar.all() == 0:
continue
X.append(ar)
y.append(classes[index])
X = np.array(X)
y = np.array(y)
print(X.shape)
print(X)
print(y)
X_train_data, X_test_data, y_train_data, y_test_data = train_test_split(
X, y, test_size=0.3, stratify=y)
nearestCentroid = NearestCentroid()
nearestCentroid.fit(X_train_data, y_train_data)
predict_y = nearestCentroid.predict(X_test_data)
acc = accuracy_score(y_test_data, predict_y)
print(acc)
def scut_fbp_test():
f = Feature()
# af1and5 0.890287769784
paths, classes = loadFaceData(
'./dataset/af1and5.csv',
nrows=100) # './dataset/all(round_score).csv' for full class
X = []
y = []
for index, path in enumerate(paths):
ar = f.getFeature(path)
print(index, path)
if ar.all() == 0:
continue
X.append(ar)
y.append(round(classes[index]))
X = np.array(X)
y = np.array(y)
print(X.shape)
print(X)
print(y)
X_train_data, X_test_data, y_train_data, y_test_data = train_test_split(
X, y, test_size=0.3, stratify=y)
nearestCentroid = NearestCentroid()
nearestCentroid.fit(X_train_data, y_train_data)
predict_y = nearestCentroid.predict(X_test_data)
acc = accuracy_score(y_test_data, predict_y)
print(acc)
def __scaffold_contigs(self, contig_ids=None):
seq = str(self.get_original_seq()).upper()
s_id = self.get_name()
slen = len(seq)
i = c_start = 0
contig_count = 0
value = 1
id = None
last_contig = 0
while True:
i = seq.find('N', i)
if i < 0: break
# count consecutive Ns
n_start = i
while i < slen and seq[i] == 'N':
i += 1
# this many Ns in a row constitute a contig break (gap)
n_len = i - n_start
if n_len >= self.minGapSize:
c_len = n_start - c_start
if c_len >= self.minConSize:
id = s_id + "_c" + str(contig_count + 1)
if contig_ids:
id = contig_ids[contig_count]
self.contigs.append(Feature(c_start, n_start, value, id))
contig_count += 1
last_contig = n_start
elif contig_count == 0:
self.seq_start = i
c_start = i
#contig_count += 1
if last_contig < slen:
if slen - c_start > self.minConSize:
id = s_id + "_c" + str(contig_count + 1)
if contig_ids:
id = contig_ids[contig_count]
self.contigs.append(Feature(c_start, slen, value, id))
else:
self.seq_end = last_contig
self.get_contig_lengths_list()
assert self.get_contig_length() + self.get_gap_length(
) == self.get_length()
def __init__(self, symbole, **traits):
self.__symbole = symbole
self.__traits = set(map(lambda x: Feature(x[0], x[1]), traits.items()))
recup = self.__memory.get(symbole)
if recup == traits:
print('Cette combinaison traits-symbole existe déjà.')
else:
self.__memory[symbole] = traits
def saveCharFeatures(self, fileOut):
feature = Feature()
if len(self.charEmb) == 0:
self.loadCharEmbeddings()
xuidPairs = self.getAllXUIDPairs()
xuids = set()
for (xuid1, xuid2) in xuidPairs:
xuids.add(xuid1)
xuids.add(xuid2)
for xuid in xuids:
charEmb = []
numCharsFound = 0
for t in self.corpus.XUIDToMention[xuid].tokens:
lemma = self.getBestStanToken(t.stanTokens).lemma.lower()
for char in lemma:
if char == "ô":
char = "o"
if char in self.charEmb:
if numCharsFound == 20:
break
else:
charEmb += self.charEmb[char]
numCharsFound += 1
else:
print("* WARNING: we don't have char:", str(char),
"of len:", len(char))
#exit(1)
while len(charEmb) < 400: # 20 chars * 20 dim
charEmb.append(0.0)
feature.setSingle(self.corpus.XUIDToMention[xuid].UID, charEmb)
# go through all pairs to compute relational data
if self.saveRelationalFeatures:
proc = 0
completed = set()
for xuid1, xuid2 in xuidPairs:
uid1, uid2 = sorted([
self.corpus.XUIDToMention[xuid1].UID,
self.corpus.XUIDToMention[xuid2].UID
])
if (uid1, uid2) in completed or (uid2, uid1) in completed:
continue
completed.add((uid1, uid2))
flatv1 = feature.singles[uid1]
flatv2 = feature.singles[uid2]
(dp, cs) = self.getDPCS(flatv1, flatv2)
feature.addRelational(uid1, uid2, dp)
feature.addRelational(uid1, uid2, cs)
if proc % 1000 == 0:
print("\tprocessed",
proc,
"of",
len(xuidPairs),
"(%2.2f)" % float(100.0 * proc / len(xuidPairs)),
end="\r")
proc += 1
pickle_out = open(fileOut, 'wb')
pickle.dump(feature, pickle_out)
def __init__(self,csvFileName):
self.csvFileName = csvFileName
self.table = []
df = pd.read_csv(csvFileName)
t_flag = 1
index= []
for i in range(1,len(df)+1):
index.append(i)
for col in df.columns:
if df[col].dtype == "float64" or df[col].dtype == "int64":
f = Feature(col,df[col].values)
self.table.append(f)
b = f.getSampels() == index
if b.all():
t_flag = 0
if t_flag:
f = Feature("TimeStamp",index)
self.table.append(f)
def LoadDigitData(self, file_path):
feature = []
for line in open(file_path):
line = line.strip()
line_feature = [ord(ch) - ord('0') for ch in line]
feature.extend(line_feature)
self.dim = len(feature)
return Feature(np.array(feature))
def _feature(self, i):
def context(input):
line = input.words[input.index][2]
inputId = (input.input.path, line[0])
if inputId != self.cachedInputId:
raise Exception('Unexpected call to feature')
return self.cachedScopeChain[self.cachedDepth - 1 - i]
return Feature('{}scope'.format(i), context, word)
def create_feature(feature_description):
feature_name = feature_description[0]
if "{" in feature_description[1] and "}" in feature_description[1]:
feature_type = "CATEGORICAL"
else:
feature_type = "NUMERIC"
feature_possible_values = (feature_description[1].replace("{", "").replace("}", "")).split(",")
feature = Feature(feature_name, feature_type, feature_possible_values)
# append feature to features_list
features_list.append(feature)
def decorate_wall(obj, options):
if options.options.windows == "window_line":
spaced_points = vg.extrude(
obj.bottom(), Map(spacing=V3(0, math.ceil(obj.height / 2), 0)))
for vec in spaced_points:
obj.features.append(Feature("window", vec,
options=options.options))
elif options.options.windows == "window_line_double":
spaced_points = vg.extrude(
obj.bottom(), Map(spacing=V3(0, math.ceil(obj.height / 2), 0)))
spaced_points2 = vg.extrude(spaced_points, Map(spacing=V3(0, 1, 0)))
for vec in spaced_points + spaced_points2:
obj.features.append(Feature("window", vec,
options=options.options))
elif options.options.windows == "window_slits":
spaced_points = vg.points_spaced(obj.bottom(), Map(every=5))
spaced_points = vg.extrude(
spaced_points, Map(spacing=V3(0, math.ceil(obj.height / 2), 0)))
spaced_points2 = vg.extrude(spaced_points, Map(spacing=V3(0, 1, 0)))
for vec in spaced_points + spaced_points2:
obj.features.append(Feature("spacing", vec))
else:
spaced_points = vg.points_spaced(obj.bottom(), Map(every=3))
spaced_points = vg.extrude(
spaced_points, Map(spacing=V3(0, math.ceil(obj.height / 2), 0)))
for vec in spaced_points:
obj.features.append(Feature("window", vec,
options=options.options))
mid_points = vg.middle_of_line(obj.bottom(),
Map(center=True, max_width=2, point_per=10))
for vec in mid_points:
obj.features.append(
Feature(
"door", vec,
Map(cardinality=obj.cardinality,
door_inside=options.options.door_inside)))
return obj
def add_ego_net_features_to_ego(ego, ego_feature_file, ego_net_features):
'''Reads a one-line file of features for the ego node'''
line_list = ego_feature_file.readline().split() # read one line
# i is the index, digit is the value
for i, digit in enumerate(line_list):
# in order to add a feature we must create a Feature instance
ego.add_feature(
i,
Feature(ego_net_features[i][1], ego_net_features[i][0],
int(digit)))
return ego
def saveWordNetFeatures(self, fileOut):
feature = Feature()
synSynToScore = {}
xuidPairs = self.getAllXUIDPairs()
print("calculating wordnet features for", len(xuidPairs),
"unique pairs")
i = 0
completed = set()
for xuid1, xuid2 in xuidPairs:
uid1 = self.corpus.XUIDToMention[xuid1].UID
uid2 = self.corpus.XUIDToMention[xuid2].UID
if (uid1, uid2) in completed or (uid2, uid1) in completed:
continue
completed.add((uid1, uid2))
textTokens1 = self.corpus.XUIDToMention[xuid1].text
textTokens2 = self.corpus.XUIDToMention[xuid2].text
bestScore = -1
for t1 in textTokens1:
syn1 = wn.synsets(t1)
if len(syn1) == 0:
continue
syn1 = syn1[0]
for t2 in textTokens2:
syn2 = wn.synsets(t2)
if len(syn2) == 0:
continue
syn2 = syn2[0]
curScore = -1
if (syn1, syn2) in synSynToScore:
curScore = synSynToScore[(syn1, syn2)]
elif (syn2, syn1) in synSynToScore:
curScore = synSynToScore[(syn2, syn1)]
else: # calculate it
curScore = wn.wup_similarity(syn1, syn2)
# don't want to store tons. look-up is cheap
synSynToScore[(syn1, syn2)] = curScore
if curScore != None and curScore > bestScore:
bestScore = curScore
feature.addRelational(uid1, uid2, bestScore)
i += 1
if i % 1000 == 0:
print("\tprocessed",
i,
"of",
len(xuidPairs),
"(%2.2f)" % float(100.0 * i / len(xuidPairs)),
end="\r")
pickle_out = open(fileOut, 'wb')
pickle.dump(feature, pickle_out)
print("")
def saveLemmaFeatures(self, fileOut):
feature = Feature()
if len(self.gloveEmb) == 0: # don't want to wastefully load again
self.loadGloveEmbeddings()
xuidPairs = self.getAllXUIDPairs()
xuids = set()
for (xuid1, xuid2) in xuidPairs:
xuids.add(xuid1)
xuids.add(xuid2)
for xuid in xuids:
sumEmb = [0] * 300
for t in self.corpus.XUIDToMention[xuid].tokens:
lemma = self.getBestStanToken(t.stanTokens).lemma.lower()
if lemma not in self.gloveEmb:
print("* ERROR: no emb for", lemma)
continue
curEmb = self.gloveEmb[lemma]
sumEmb = [x + y for x, y in zip(sumEmb, curEmb)]
#print("saving lemma for:", xuid, ": (", self.corpus.XUIDToMention[xuid].UID, ")")
feature.setSingle(self.corpus.XUIDToMention[xuid].UID, sumEmb)
if self.saveRelationalFeatures:
# go through all pairs to compute relational data
proc = 0
completed = set()
for xuid1, xuid2 in xuidPairs:
uid1, uid2 = sorted([
self.corpus.XUIDToMention[xuid1].UID,
self.corpus.XUIDToMention[xuid2].UID
])
if (uid1, uid2) in completed or (uid2, uid1) in completed:
continue
completed.add((uid1, uid2))
flatv1 = feature.singles[uid1]
flatv2 = feature.singles[uid2]
(dp, cs) = self.getDPCS(flatv1, flatv2)
feature.addRelational(uid1, uid2, dp)
feature.addRelational(uid1, uid2, cs)
if proc % 1000 == 0:
print("\tprocessed",
proc,
"of",
len(xuidPairs),
"(%2.2f)" % float(100.0 * proc / len(xuidPairs)),
end="\r")
proc += 1
pickle_out = open(fileOut, 'wb')
pickle.dump(feature, pickle_out)
def parse_all_docs(self):
fob = Feature(self.exp)
cob = Category()
cob.get_category_done_list()
stime = time.time()
print "Parsing documents in " + self.exp
print "Start time: " + time.ctime(stime)
with open(self.listing_document_path, 'r') as f:
lines = [line.strip() for line in f]
lines = [line for line in lines[2:] if line]
document_id = ''
for line in lines:
elements = line.split(' ')
if elements[0] == '#':
document_id = elements[3]
continue
c_id, category = self._get_category(elements[0])
if category == 'NA':
continue
if c_id in cob.category_done_list and \
not self.ignore_duplicate_category:
continue
sample = self._get_features(fob, elements[1:])
sample['Category'] = category
sample['Id'] = document_id
self.samples = self.samples.append(sample, ignore_index=True)
print "Document #" + document_id + " parsed"
self.samples = self.samples.fillna(0)
etime = time.time()
print "Documents in " + self.exp + ' parsed'
print "End time: " + time.ctime(etime)
print "Time taken: " + str(etime - stime) + " seconds"
cob.update_category_done_list([self.category_id1, self.category_id2])
fob.destroy_list()
def decorate_roof_shape(obj, options=Map()):
settings = options.options
if settings.roof_shape_color_pattern == "RainbowGlass":
material = Texture1D.COMMON_TEXTURES.RainbowGlass
elif settings.roof_shape_color_pattern == "OldStoneWall":
material = Texture1D.COMMON_TEXTURES.OldStoneWall
elif settings.roof_shape_color_pattern == "WoodBlends":
material = Texture1D.COMMON_TEXTURES.WoodBlends
elif settings.roof_shape_color_pattern == "Glow":
material = Texture1D.COMMON_TEXTURES.Glow
else:
material = Blocks.match(settings.roof_material)
if not material:
material = obj.material
boundaries = vg.bounds(options.corner_vectors)
min_radius = min(boundaries.x_radius, boundaries.z_radius)
pos = boundaries.center
if settings.roof_shape_object == "cylinder":
func = vg.cylinder
height = min_radius * (settings.roof_shape_height_multiplier or 1)
elif settings.roof_shape_object == "cone":
func = vg.cone
height = min_radius * (settings.roof_shape_height_multiplier or 1)
elif settings.roof_shape_object == "box":
func = vg.box
height = min_radius * (settings.roof_shape_height_multiplier or 1)
else: # sphere
func = vg.oblate_sphere
height = None
if settings.roof_shape_floating:
pos = vg.up(boundaries.center, min_radius)
sides = func(pos, min_radius, tight=settings.roof_shape_tight, height=height,
options=Map(min_y_pct=.5, x_radius=boundaries.x_radius, z_radius=boundaries.z_radius))
roof_lists = list()
roof_lists.append(Map(blocks=sides, material=material))
obj.features.append(Feature("roof", boundaries.center, Map(block_lists=roof_lists)))
obj.points_edges = []
return obj
def __initialize_windows(self,bam,window):
window_coverage = {}
lengths = self.__get_header_info(bam)
for seq in sorted(lengths.iterkeys()):
length = lengths[seq]
for i in xrange(0,length,window):
start = i
end = i + window
if end > length:
end = length
if seq not in window_coverage:
window_coverage[seq] = []
window_coverage[seq].append(Feature(start,end,0,seq))
return window_coverage,lengths
def preprocess(paths, classes):
f = Feature()
X = []
y = []
start = time.clock()
for index, path in enumerate(paths):
print('Preprocessing', index, path)
ar = f.getFeature(path)
if ar.all() == 0:
continue
X.append(ar)
y.append(classes[index])
test_time = time.clock() - start
print("Preprocessing Total time: {0:.2f}".format(test_time))
X = np.array(X)
y = np.array(y)
return X, y
def decorate_roof_triangular(obj, options=Map()):
settings = options.options
material = Blocks.match(settings.roof_material)
if material:
obj.material = material
p1, p2, radius, ends, sides = vg.best_points_for_triangular_roof(
options.corner_vectors)
chop_pct = settings.roof_triangular_chop_pct or 0
radius += settings.roof_triangular_overhang
height = radius
if round(height) == int(height):
height += 1
if settings.roof_triangular_stairs or settings.roof_triangular_end_cap_in:
# It's a more complex roof, build it as a Feature
roof_lists = vg.prism_roof(
p1,
p2,
height=height,
radius=radius,
chop_pct=chop_pct,
sloped=settings.roof_triangular_sloped,
material=obj.material,
endpoint_out=settings.roof_triangular_end_cap_out)
obj.features.append(Feature("roof", p1, Map(block_lists=roof_lists)))
else:
# Nothing fancy, color each block all the same type
roof = vg.triangular_prism(p1,
p2,
height=height,
radius=radius,
chop_pct=chop_pct,
sloped=settings.roof_triangular_sloped)
obj.points.update(roof)
obj.points_edges = []
return obj
def decorate_castle_outer_wall(obj, options):
height = options.options.roof_battlement_height
spacing = options.options.roof_battlement_space
p1 = options.p1
p2 = options.p2
# TODO: Add in inner and outer, create walkway and arrow slits
# TODO: Add X,Z outward from center as option
roof_line = vg.getLine(p1.x, p1.y + height, p1.z, p2.x, p2.y + height, p2.z)
obj.points.extend(vg.points_spaced(roof_line, Map(every=spacing)))
mid_points = vg.middle_of_line(obj.bottom(), Map(center=True, max_width=2, point_per=10))
for vec in mid_points:
obj.features.append(
Feature("door", vec, Map(cardinality=obj.cardinality, door_inside=options.options.door_inside)))
return obj
def get_audio_contents(c, filename):
if c is not None:
ctype, cstring = str(c).split(',')
decoded = base64.b64decode(cstring)
music['filepath'] = os.path.dirname(
os.path.realpath(__file__)) + "/resource/temp/" + filename
try:
file = open(music.get('filepath'), 'wb')
file.write(decoded)
file.close()
except:
print("something went wrong")
# record all necessary information into dictionary
music['name'] = filename
music['binary'] = c
music_feature = Feature(music['filepath'])
# get all extracted feature
music['energy_feature'] = (Feature.sync_frames(
music_feature,
music_feature.extract_energy_features())).mean(axis=0)
music['timbre_feature'] = (Feature.sync_frames(
music_feature,
music_feature.extract_timbre_features())).mean(axis=0)
music['melody_feature'] = (Feature.sync_frames(
music_feature,
music_feature.extract_melody_features())).mean(axis=0)
music['rhythm_feature'] = (Feature.sync_frames(
music_feature, music_feature.extract_rhythm_features()))[:-3]
# data preparation for prediction
data = misc.series_to_supervised(
np.transpose(music_feature.get_all_features()), 3, 1)
data = data.values.reshape(data.values.shape[0], 4, 146)
predict = model.predict(data)
# save prediction into dictionary
music['arousal_predict'] = predict[:, 0]
music['valance_predict'] = predict[:, 1]
music['duration'] = [
i for i in misc.frange(0.5,
len(music['timbre_feature']) * 0.5, 0.5)
]
'''['%d:%2.1f' % (int((i + 1.5) / 60), (i + 1.5) % 60) for i in
