def loadImg(self) -> None:
"""
Load image to process by CT.
:return: None
"""
filename = QtWidgets.QFileDialog.getOpenFileName(
self, "Open img", "../../..", "Image Files (*.png *.jpg *.bmp)")
if filename[0] == '':
return
else:
img = io.imread(path.expanduser(filename[0])) # rgb
circle_inside_img_radius = sqrt(img.shape[0]**2 +
img.shape[1]**2) // 2
fig = self.plots_layout["items"]["img_fig"]["object"]
fig.setPixmap(Conversion().array2qpixmap(img))
self.inputs["img"] = Conversion().rgb2greyscale(img)
self.inputs_layout["items"]["detectors_distance"][
"object"].setMaximum(2 * circle_inside_img_radius)
self.inputs_layout["items"]["detectors_distance"][
"object"].setEnabled(True)
self.buttons_layout["items"]["run"]["object"].setEnabled(True)
self.plots_layout["items"]["animation_slider"][
"object"].setDisabled(True)
def preprocessFrame(frame: np.ndarray) -> QPixmap:
"""
Convert greyscale frame into rgb QPixmap.
:param frame: numpy greyscale ndarray
:return: QPixmap
"""
conv = Conversion()
return conv.array2qpixmap(conv.greyscale2rgb(frame))
def preprocessFrames(frames: List[np.ndarray]) -> None:
"""
Convert greyscale frames into rgb QPixmap.
:param frames: numpy greyscale ndarray list
:return: None
"""
conv = Conversion(frames[0].shape)
for index, img in enumerate(frames):
frames[index] = conv.array2qpixmap(conv.greyscale2rgb(img))
def __init__(self):
self.ingredient = None
self.quantity = None
self.unit = None
self.conversion = Conversion()
def __init__(self):
self.date = None
self.name = None
self.instructions = []
self.time = None
self.outcomeSize = None
self.outcomeUnit = None
self.ingredients = []
self.conversion = Conversion()
def generate_polvar_metadata(polvar, filename = None):
"""
"""
load_myconfig(filename = filename)
polvar = Conversion().findKey('MXPOL', polvar)
if polvar in _DEFAULT_POLARNAMES:
standard_name, long_name, units, valid_min, valid_max, plot_interval = _DEFAULT_POLARNAMES[polvar]
else:
standard_name, long_name, units, valid_min, valid_max, plot_interval = None, None, None, None, None, None
polvar_metadata = get_mymetadata('Polvar', filename)
polvar_metadata['units'] = units
polvar_metadata['standard_name'] = standard_name
polvar_metadata['short_name'] = Conversion().findKey('MCH', polvar)
polvar_metadata['long_name'] = long_name
polvar_metadata['valid_min'] = valid_min
polvar_metadata['valid_max'] = valid_max
polvar_metadata['plot_interval'] = plot_interval
return polvar_metadata
def conv():
global operators, nums
op = operators
k = Conversion(nums)
if op == '-bd':
print(k.bd())
elif op == '-bh':
print(k.bh())
elif op == '-db':
print(k.db())
elif op == '-dh':
print(k.dh())
elif op == '-hb':
print(k.hb())
elif op == '-hd':
print(k.hd())
else:
print('error')
def get_price():
URL = 'https://www.etsy.com/au/listing/731261963/dr-phil-earrings?ga_order=most_relevant&ga_search_type=all&ga_view_type=gallery&ga_search_query=dr+phil&ref=sr_gallery-1-3&organic_search_click=1&pro=1'
page = urlopen(URL)
soup = BeautifulSoup(page.read(), "html.parser")
#Title of Product - Dr Phil Earrings
print("**************************************************")
title = (soup.find("h1", {"data-listing-id": "731261963"}))
print(title.text.strip())
price = soup.find("p", {"class": "wt-text-title-03 wt-mr-xs-2"})
#remove white space from price
price = str(price.text.strip())
#converting price from string to float
converted_price = Conversion.convert_price(price)
#converting price from string to float
print(converted_price)
if (converted_price < 11.50):
subject = 'Dr Phil earrings - price has fallen'
body = 'The price of the Dr Phil earrings has fallen - check the etsy link! https://www.etsy.com/au/listing/731261963/dr-phil-earrings?ga_order=most_relevant&ga_search_type=all&ga_view_type=gallery&ga_search_query=dr+phil&ref=sr_gallery-1-3&organic_search_click=1&pro=1'
Mailer.send_mail(subject, body)
else:
print("Price is above $11.50 - no email sent :-(")
def load(self) -> bool:
"""
Load DICOM file and insert file data into widgets.
:return: bool
"""
filename = QtWidgets.QFileDialog.getOpenFileName(self, "Open DICOM", "../../..", "DICOM File (*.dcm)")[0]
if filename == '':
self.close()
return False
else:
ds = pydicom.dcmread(filename)
ds.file_meta.TransferSyntaxUID = pydicom.uid.ImplicitVRLittleEndian
self.img_fig.setPixmap(Conversion().array2qpixmap(ds.pixel_array))
year, month, day = ds.ContentDate[:4], ds.ContentDate[4:6], ds.ContentDate[6:8]
hour, minute, second = ds.ContentTime[:2], ds.ContentTime[2:4], ds.ContentTime[4:6]
self.ct_date_time.setText(f"{year}/{month}/{day} {hour}:{minute}:{second}")
self.patient_name.setText(str(ds.PatientName))
self.patient_ID.setText(str(ds.PatientID))
self.patient_sex.setText(str(ds.PatientSex))
self.image_comments.setText(str(ds.ImageComments))
return True
class Recipe():
'''
Luokka reseptejä varten. Tämä luokka pitää sisällään kaikki reseptille ominaiset attribuutit sekä tarvittavat metodit niiden arvojen muuttamiseksi.
Attributes:
:self.date: Luontipäivä
:self.name: Reseptin nimi
:self.time: Reseptin tekemiseen menevä aika minuuttina (int)
:self.instructions: Ohjeet (str[])
:self.outcomeSize: Reseptin lopputuloksen koko, esim. 4 (kg)
:self.outcomeUnit: Reseptin lopputuloksen yksikkö, esim (4) kg
:self.ingredients: Raaka-aineet (object[])
Returns:
Attribuuttien muuttamiseen käytettävät metodit (set* & add* & delete/remove*) palauttavat True, jos muutos onnistuu
Raises:
Kaikki attribuuttien asettamiseen käytettävät metodit (set* & add*) heittävät SetAttributeErrorin, jos attribuutin arvon asetus epäonnistuu.
'''
def __init__(self):
self.date = None
self.name = None
self.instructions = []
self.time = None
self.outcomeSize = None
self.outcomeUnit = None
self.ingredients = []
self.conversion = Conversion()
def setName(self,name):
''' Validoi, että nimi on yli 2 merkkiä pitkä ja asettaa sen: self.name'''
if len(name) > 2:
self.name = name
return True
else:
raise SetAttributeError("Nimen tulee olla yli 2 merkkiä pitkä")
def setOutcomeSize(self, outcomeSize):
''' Muuttaa desimaalipilkun pisteeksi ja settaa määrän floattina: self.outcomeSize'''
try:
self.outcomeSize = float(str(outcomeSize).replace(",", "."))
return True
except ValueError:
raise SetAttributeError("Lopputuloksen tulee olla desimaaliluku")
def setOutcomeUnit(self, outcomeUnit):
''' Validoi, että yksikkö on ohjelman tuntema ja asettaa sen: self.outcomeUnit'''
outcomeUnit = outcomeUnit.lower()
if self.conversion.isValidUnit(outcomeUnit):
self.outcomeUnit = outcomeUnit
return True
else:
raise SetAttributeError("Yksikkö ei ole ohjelman tuntema")
def setDate(self,date):
''' Validoi päivämäärän ja asettaa sen stringinä: self.date'''
try:
datetime.datetime.strptime(date,'%d.%m.%Y')
self.date = date
return True
except ValueError:
raise SetAttributeError("Päivämäärää ei voitu tallentaa")
def setTime(self,time):
''' Asettaa reseptin tekemiseen menevän ajan (min) inttinä: self.time'''
try:
self.time = int(time)
return True
except ValueError:
raise SetAttributeError("Ajan täytyy olla kokonaisluku (min)")
def addInstruction(self,instruction):
''' Validoi, että ohje on yli 2 merkkiä pitkä ja lisää sen self.instruction[] listaan'''
if len(instruction) > 2:
self.instructions.append(instruction)
return True
else:
raise SetAttributeError("Ohjeen tulisi olla yli 2 merkkiä pitkä")
def deleteInstruction(self,index):
''' Poistaa reseptiltä ohjeen. Argumenttina annetaan ohjeen sijainti listassa (index)'''
try:
del self.instructions[index]
return True
except LookupError as e:
raise SetAttributeError("Ohjetta ei voitu poistaa")
def addIngredientContainer(self, ingredientContainer):
''' Validoi, että lisättävä raaka-aine on IngredientContainer-olio sekä lisää raaka-aineen(Container) self.ingredients[] listaan'''
if isinstance(ingredientContainer,IngredientContainer):
self.ingredients.append(ingredientContainer)
return True
else:
raise SetAttributeError("Raaka-aine ei ollut IngredientContainer-olio")
def deleteIngredient(self, index):
''' Poistaa reseptiltä raaka-aineen. Argumenttina annetaan ohjeen sijainti listassa (index)'''
try:
del self.ingredients[index]
return True
except LookupError as e:
raise SetAttributeError("Raaka-ainetta ei voitu poistaa")
def getName(self):
''' Palauttaa reseptin nimen'''
return self.name
def getDate(self):
''' Palauttaa reseptin luontipäivän'''
return self.date
def getTime(self):
''' Palauttaa reseptin tekemiseen menevän ajan inttinä'''
return self.time
def getTimeGUI(self):
''' Palauttaa reseptin tekemiseen menevän ajan stringinä'''
return str(self.time)
def getTimeStr(self):
''' Palauttaa reseptin tekemiseen menevän ajan stringinä, jonka lopussa on " Min"'''
return '' + str(self.time) + " Min"
def getInstructions(self):
''' Palauttaa ohjeet listana'''
return self.instructions
def getInstructionsStr(self):
''' Palauttaa ohjeet stringinä, jokainen ohje omalla rivillä ja edessä ohjeen järjestysnumero eli järjestys listassa'''
instructions = ''
a = 1
for i in self.instructions:
instructions += str(a) +". " + i + "\n"
a += 1
return instructions
def getIngredients(self):
''' Palauttaa reseptin raaka-aine oliot listana'''
return self.ingredients
def getIngredientsStr(self):
''' Palauttaa reseptin raaka-aineet stringinä, hyödyntää raaka-aine luokan __str__() metodia'''
ingredients = ''
for i in self.ingredients:
ingredients += i.__str__() + "\n"
return ingredients
def getIngredientsGUI(self):
''' Palauttaa raaka-aineiden nimet listana'''
ingredients = []
for i in self.ingredients:
ingredients.append(i.getName())
return ingredients
def getOutcomeStr(self):
''' Palauttaa reseptin lopputuloksen desimaalipilkulla muodossa "<määrä> <yksikkö>"'''
return '' + str(self.outcomeSize).replace(".", ",") + ' ' + self.outcomeUnit
def getOutcomeSize(self):
''' Palauttaa lopputuloksen floattina'''
return self.outcomeSize
def getOutcomeSizeGUI(self):
''' Palauttaa lopputuloksen stringinä desimaalipilkulla'''
return str(self.outcomeSize).replace(".", ",")
def getOutcomeUnit(self):
''' Palauttaa lopputuloksen yksikön'''
return self.outcomeUnit
def getAllergensDistinctGUI(self):
''' Palauttaa reseptien raaka-aineiden stringinä pilkulla erotettuna. Allergeeni esiintyy listassa vain kerran, vaikka se olisi monessa raaka-aineessa.'''
allergens = []
for ingredient in self.ingredients:
for allergen in ingredient.getAllergens():
allergens.append(allergen)
allergenSet = set(allergens)
string=' '
for i in allergenSet:
string += i+ ", "
#Lopussa ei tarvitse olla ", ", joten poistetaan ne.
string = string[:-2]
return string
def __str__(self):
return '' + self.getName()+", " + self.getTimeStr() + ", " + self.getOutcomeStr() + ". \nIngredients: \n" + \
self.getIngredientsStr() + "Instructions: \n" + self.getInstructionsStr()
from conversion import Conversion
print("Введите какую-нибудь строку")
first_string = input()
print("И еще одну строку")
second_string = input()
new_first_string = Conversion(first_string)
new_second_string = Conversion(second_string)
print(new_first_string)
print(new_second_string)
print("Объединяем строки", new_first_string.concatenation(second_string))
print("Введите искомый символ")
symbol = input()
print("Ищем символ, он:", new_first_string.search_symbol(symbol))
new_first_string.compare_string(second_string)
print("Преобразуем лист в строку:", new_first_string.list_in_string())
from tkinter import *
from conversion import Conversion
result = 0.0
rows = 5
columns = 7
root = Tk()
root.title("FPS Mouse Sensitivity Converter")
root.minsize(360, 240)
root.maxsize(360, 240)
convert = Conversion()
result_sensitivity = Entry(root, text=result)
input_current_sensitivity = Entry(root)
change_to = IntVar()
label_input_sensitivity = Label(root, text="Input your current sensitivity")
label_result = Label(root, text="Result")
label_convert_for_what_game = Label(root, text="Convert for what game?")
Radiobutton(root, text="Valorant", variable=change_to, value=1).grid(row=2,
column=1)
Radiobutton(root, text="CSGO", variable=change_to, value=2).grid(row=1,
column=1)
label_convert_for_what_game.grid(row=1, column=0)
label_input_sensitivity.grid(row=3, column=0)
label_result.grid(row=5, column=0)
result_sensitivity.grid(row=5, column=1)
# adding a bit of responsiveness on the window
for i in range(rows):
#__________________________________________________________________________
# Change the name of the database and collections to your liking
db = con.feature_extraction_database # #####REPLACE#####
song_features = db.song_features_collection # #####REPLACE#####
distance_features = db.distance_features_collection # #####REPLACE#####
#__________________________________________________________________________
options, rem = getopt(argv[1:], 'c:e:d:n:g:h', [
'conversion=', 'extraction=', 'distance', 'neighbour', 'graphdist',
'help'
])
for opt, arg in options:
if opt in ('-c', '--conversion'):
from conversion import Conversion
c = Conversion(arg, rem[0])
elif opt in ('-e', '--extraction'):
from extraction import Extraction
e = Extraction(arg, song_features)
elif opt in ('-d', '--distance'):
from distance import Distance
d = Distance(song_features, distance_features)
elif opt in ('-n', '--neighbour'):
from neighbour import Neighbour
n = Neighbour(song_features, distance_features)
elif opt in ('-g', '--graphdist'):
from graphdist import Graphdist
g = Graphdist(song_features, distance_features)
elif opt in ('-h', '--help'):
print """The following options are available:
-c, --conversion mp3/m4a
class IngredientContainer:
'''
Tämä luokka sisältää viittauksen raaka-aine olioon ja tämän lisäksi omat attribuutit määrästä sekä yksiköstä.
Tätä luokkaa hyödynnetään varastolistauksen sekä reseptien raaka-aineiden tallentamisessa. Samaa raaka-ainetta
käytetään hyvin todennäköisesti useassa eri reseptissä, jos Ingredient luokassa olisi määrä, niin silloin
tietoa joutuisi kopioimaan sekä säilyttämään moneen kertaan. Tämän luokan avulla esim. Jauhelihan tiedot ovat vain
kertaalleen Ingredient oliossa ja resepteissä olevat IngredientContainer oliot sisältävät viittauksen tähän.
Attributes:
:self.ingredient: Raaka-aine olio
:self.quantity: Raaka-aineen määrä
:self.unit: Määrän yksikkö
Returns:
:Attribuuttien muuttamiseen käytettävät metodit (set* & add* & delete/remove*) palauttavat True, jos muutos onnistuu
Raises:
:Attribuuttien asettamiseen käytettävät metodit (set* & add*) heittävät SetAttributeErrori:n, jos validointi epäonnistuu
'''
def __init__(self):
self.ingredient = None
self.quantity = None
self.unit = None
self.conversion = Conversion()
def setIngredient(self,ingredient,ingredientsList):
'''
Etsii halutun raaka-aineen annetusta raaka-ainelistasta nimen perusteella sekä asettaa sen: self.ingredient
Attributes:
:ingredient: Etsittävä raaka-aine (string)
:ingredientsList: Lista kaikista raaka-aineista
Returns:
:Onnistuessa: True
Raises:
:SetAttributeError epäonnistuessa
'''
for i in ingredientsList:
if i.getName().strip().lower() == ingredient.lower():
self.ingredient = i
return True
else:
# Raaka-ainetta kyseisellä nimellä ei löytynyt.
pass
raise SetAttributeError("Raaka-ainetta ei löytynyt")
def setQuantity(self,quantity):
''' Muuttaa desimaalipilkun pisteeksti ja asettaa määrän floattina: self.quantity'''
try:
self.quantity = float(str(quantity).replace(",","."))
return True
except ValueError:
raise SetAttributeError("Määrän tulee olla desimaaliluku")
def setUnit(self, unit):
''' Validoi, että yksikkö on ohjelman tuntema sekä asettaa sen: self.unit'''
unit = unit.lower()
if self.conversion.isValidUnit(unit):
self.unit = unit
return True
else:
raise SetAttributeError("Tuntematon yksikkö")
def getQuantity(self):
''' Palauttaa määrän floattina'''
return self.quantity
def getQuantityStr(self):
''' Palauttaa määrän stringinä, desimaalipilkulla'''
return str(self.quantity).replace(".", ",")
def getUnit(self):
''' Palauttaa määrän yksikön'''
return self.unit
def getIngredient(self):
''' Palauttaa raaka-aine olion'''
return self.ingredient
def getName(self):
''' Palauttaa raaka-aineen nimen'''
return self.ingredient.getName()
def getAllergensStr(self):
''' Palauttaa allergeenit stringinä pilkulla erotettuna sekä alkussa teksti "Allergeenit: "'''
return self.ingredient.getAllergensStr()
def getRecipe(self):
''' Palauttaa reseptiolion, jos raaka-aineella on'''
return self.ingredient.getRecipe()
def getRecipeStr(self):
''' Palauttaa reseptin nimen stringinä, jos raaka-aineella on'''
return self.ingredient.getRecipeStr()
def getDensity(self):
''' Palauttaa raaka-aineen tiheyden floattina'''
return self.ingredient.getDensity()
def hasRecipe(self):
''' Palauttaa True, jos raaka-aineella on tallennettu resepti, muuten false'''
if self.ingredient.getRecipeLoaded():
return True
else:
return False
def getAllergens(self):
''' Palauttaa allergeenit listana'''
return self.ingredient.getAllergens()
def __str__(self):
return '' + self.getName() +", " + str(self.getQuantity()) + " " + self.getUnit() + self.getAllergensStr() + self.getRecipeStr()
if __name__ == "__main__":
print "This is a script to help extract audio features and to calculate distances between songs with choice parameters."
print "All data is stored in a database of MongoDB."
print "The script only works with wave files, being named in a way described later. You can give mp3 or m4a files (ID3 taged!) "
print "to the script and it will convert them towave files with ffmpeg for you. Make sure ffmpeg and mutagen are installed."
print "For audio feature extraction, this script is using the bregman audio toolbox and aubio toolbox (for the rhythm) "
print "which you have to download and install (make sure both work)."
print "There is also a set of prerequisits for python: you should have installed numpy, etc." #update all python packages that have to be installed
print "__________________________________________"
print "At any time, press q if you want to quit."
print "__________________________________________"
y = None
while (y != "q"):
message = "What do you want to do? File conversion (c), feature extraction (e) or distance calculation(d)? : "
y = raw_input(message)
if y == "c":
c = Conversion()
elif y == "e":
e = Extraction()
elif y == "d":
d = Distance()
elif y == "q":
print "Goodbye!"
else:
print "There is no %r option, please try again." %(y)
import sys
from conversion import Conversion
def test(did_pass):
''' Print the result of a test. '''
linenum = sys._getframe(1).f_lineno
if did_pass:
msg = 'Test at line {0} ok.'.format(linenum)
else:
msg = ('Test at line {0} FAILED.'.format(linenum))
print(msg)
#test(menu() == print('BOB Blob Temperatur Converter\n1. Celcius to Fahrenheit\n2. Fahrenheit to Celcius\n3. Quit\n'))
test(Conversion.CtoF(Conversion(0)) == 32)
test(Conversion.FtoC(Conversion(32)) == 0)
test(Conversion.CtoF(Conversion(-40)) == -40)
from conversion import Conversion
import numpy as np
exp = input("Your expression here: ")
expression = list(exp)
obj = Conversion(len(expression)).toPostfix(expression)
print(obj)
operandos = []
for i in expression:
if i.isalpha():
operandos.append(i)
len = len(operandos)
row = 2**len
List = list(range(0, row))
n = []
for i in List:
n.append(list(np.binary_repr(i, width=len)))
print(" Operandos: {} and Binary List: {} ".format(operandos, n))
def test_conversion(self):
price = """Price:
AU$11.62"""
result = Conversion.convert_price(price)
self.assertEqual(result, 11.62)
def program():
if request.method == 'POST':
expr = request.form['expr']
# print(expr)
values = []
# expr = "(a+~c)*~(b+d)"
expression = tuple(expr)
operands = [
] # Save the input variables, only letter from english alphabet.
for i in expression:
if i.isalpha() and i not in operands:
operands.append(i)
operands.sort()
lena = len(
operands
) # Total of variable, this permit us to know how many columns and rows we gonna use.
row = 2**lena
List = list(range(0, row))
n = [
] # Depends of the length of the variable, we iterate the range of the total variables (form 0 to n) and coonvert them into binary number.
for i in List:
n.append(tuple(np.binary_repr(int(i), width=lena)))
obj = Conversion(len(expr)).toPostfix(
expr
) # This function convert the input expression into postfix expression.
result = [
] # We save a list of 0's an 1's, to use them like the truth and false values of the truth table.
for b in n:
result.append(Bin_sustitution(obj, operands, b))
# We evaluate the truth table column by column.
for col in result:
values.append(Evaluate_expr(col))
# The total of row of each index in, is equal to the total of variable.
total_of_row = len(n[0])
# Convert the binary array string in an integer binary array in order to facilitate the view of the web interface.
def toInteger(x):
return int(x)
# Get the index of each value.
def getIndexValue(o):
def get(array):
return array[o]
return get
# The map función allows us to take a specific object in a specific position in order to manipulate it, in this case we use
# map to make a list of integer number.
data = [] # Stores the new list of the truth table values
for i in range(total_of_row):
values_str = map(getIndexValue(i), n)
values_int = list(map(toInteger, values_str))
data.append(values_int)
prin_data = [
] # We save the truth values of each variable in a dictionnary to use later in the view.
for i, j in enumerate(operands):
c = dict()
c['title'] = j
c['values'] = list(data[i])
prin_data.append(c)
tauto = Is_tautology(
values
) # With this function we evaluate if the expression is a tautology.
contra = Is_contradiction(
values
) # With this function we evaluate if the expression is a contradiction.
conti = Is_contingency(
values
) # With this function we evaluate if the expression is a contingency.
satis = Is_satisfiable(
values
) # With this function we evaluate if the expression is satisfiable.
return render_template('result.html',
operands=operands,
expr=expr,
t_val=prin_data,
t_result=values,
tauto=tauto,
contra=contra,
conti=conti,
satis=satis)
import numpy as np
import pandas as pd
from conversion import Conversion
obj = Conversion()
obj.convertFilesIntoCSV('ham')
obj.convertFilesIntoCSV('spam')
ham = pd.read_csv('ham.csv')
spam = pd.read_csv('spam.csv')
Class =[]
Content = []
for i in range(ham.shape[0]):
Class.append('ham')
Content.append(ham['Message'][i])
for i in range(spam.shape[0]):
Class.append('spam')
Content.append(spam['Message'][i])
data = {'Message': Content, 'Class': Class}
data = pd.DataFrame(data)
data = data.iloc[np.random.permutation(len(data))] #mixing spam and ham messages
#splitting into train and test data
def initiate_conversions(self):
return [DefaultConversion(self), Conversion(self)]
def get_wants() -> List[Want]:
"""
Wants-file format (where a0af9f865b are the first 10 digits of the sha256 hash of
the utf8-encoded audio dir path):
{
"wants": [
"a0af9f865b:artist/album/01 - song.flac",
"a0af9f865b:some_song.mp3",
...
],
"wants_as": [
{
"codec": "opus",
"quality": 128,
"files": [
"a0af9f865b:artist/album/02 - song2.flac",
...
]
},
{
"codec": "mp3",
"quality": "320",
"files": [
"a0af9f865b:audiobook/chapter01.flac",
"a0af9f865b:audiobook/chapter02.flac",
...
]
}
]
}
"""
try:
with open(config.wants_file) as wants_file:
if wants_file.read().strip() == "":
raise json.JSONDecodeError(
"Empty file, expecting at least '{}'", "", 0)
wants_file.seek(0)
wants_data = json.load(wants_file)
except FileNotFoundError:
return []
except json.JSONDecodeError as err:
raise WantsFileParseError(err)
wants = []
wants_data_wants = wants_data["wants"] if "wants" in wants_data else []
wants_data_wants_as = wants_data[
"wants_as"] if "wants_as" in wants_data else []
for json_want in wants_data_wants:
want_dir, want_path = _split_json_want(json_want)
if want_dir is None:
continue
wants.append(Want(want_dir, want_path))
for want_conversion in wants_data_wants_as:
conversion = Conversion(want_conversion["codec"],
want_conversion["quality"] * 1000)
for json_want in want_conversion["files"]:
want_dir, want_path = _split_json_want(json_want)
if want_dir is None:
continue
wants.append(Want(want_dir, want_path, conversion))
return wants
def interp(self):
"""
Prepares data for the 2D gaussian fit:
Interpolates data to a regular grid and cuts off new grid according to
the data_2d function.
Parameters
----------
None
Returns
-------
newazim, list : azimuth values interpolated data
newelev, list : elevation values interpolated data
newdata, list : interpolated data values
See Also
--------
interp3
"""
# interpolation parameters
azim_interp = np.arange(min(self.azimuth), max(self.azimuth),
self.res_azim_interp)
elev_interp = np.arange(min(self.elevation), max(self.elevation),
self.res_elev_interp)
data_grid = np.zeros((len(elev_interp), len(azim_interp)))
num_samples = np.zeros((len(elev_interp), len(azim_interp)))
# convert data to linear values for interpolation
if self.var == 'SignalH':
data = self.data[self.gate]
else:
data = self.data[self.gate]
data = Conversion().logToLin(data, self.var)
# interpolate to grid
for dp in range(0, len(data)):
idx = (np.abs(elev_interp - self.elevation[dp]).argmin(),
np.abs(azim_interp - self.azimuth[dp]).argmin())
num_samples[idx] = num_samples[idx] + 1
data_grid[idx] = data_grid[idx] + data[dp]
num_samples[num_samples == 0] = float('nan')
data_grid = data_grid / num_samples
# assign value of closest bin to missing pixels
N = len(elev_interp)
M = len(azim_interp)
for i in range(0, N):
for j in range(0, M):
if (np.isnan(data_grid[i, j])):
values = []
if i - 1 >= 0:
values.append(data_grid[i - 1, j]) # pixel above
if j - 1 >= 0:
values.append(data_grid[i, j - 1]) # pixel to left
if i + 1 < N:
values.append(data_grid[i + 1, j]) # pixel below
if j + 1 < M:
values.append(data_grid[i,
j + 1]) # pixel to the right
data_grid[i, j] = np.nanmean(values)
if self.var == 'SignalH':
pass
else:
data_grid = Conversion().linToLog(data_grid, self.var)
# cut off grid to focus on sphere
ind, select = self.data_2d()
elev_select = self.elevation[ind]
azim_select = self.azimuth[ind]
e_start = np.abs(elev_interp - (elev_select[0] - 0.75)).argmin()
e_end = np.abs(elev_interp - (elev_select[-1] + 1.5)).argmin() + 1
a_start = np.abs(azim_interp - (np.nanmin(azim_select) - 0.3)).argmin()
a_end = np.abs(azim_interp - (np.nanmax(azim_select) + 1.25)).argmin()
newazim = azim_interp[a_start:a_end]
newelev = elev_interp[e_start:e_end]
newdata = data_grid[e_start:e_end, a_start:a_end]
"""
newdata = data_grid[40:81,40:81]
newazim = azim_interp[40:81]
newelev = elev_interp[40:81]"""
return newazim, newelev, newdata
def interp3(self, azim, elev, data):
"""
Interpolates data to a regular, spherical grid
Parameters
----------
azim, np.array : azimuth values of the data
elev, np.array : elevation values of the data
data, np.array : data values
Returns
-------
azim_interp, np.array : azimuth values interpolated data
elev_interp, np.array : elevation values interpolated data
grid, np.array : azimuth x elevation matrix interpolated data values
See Also
--------
interp
"""
# interpolation parameters
azim_interp = np.arange(min(azim), max(azim), self.res_azim_interp)
elev_interp = np.arange(min(elev), max(elev), self.res_elev_interp)
x, y = np.meshgrid(azim_interp, elev_interp)
points = np.vstack((azim, elev)).T
# select data
data_s = self.data[self.gate, :]
# convert data to linear
if self.var == 'SignalH':
pass
else:
data_s = Conversion().logToLin(data_s, self.var)
# find location max value
max_i = np.nanargmax(data_s)
if self.azim is None:
azimmid = self.azimuth[max_i]
else:
azimmid = self.azim
if self.elev is None:
elevmid = self.elevation[max_i]
else:
elevmid = self.elev
# take out values which are not within circle
for i in range(0, x.shape[0]):
for j in range(0, x.shape[1]):
if np.sqrt((x[i, j] - azimmid)**2 +
(y[i, j] - elevmid)**2) >= self.doa:
x[i, j] = np.nan
y[i, j] = np.nan
grid = griddata(points, data, (x, y), method='linear')
if self.var == 'SignalH':
pass
else:
grid = Conversion().linToLog(grid, self.var)
return azim_interp, elev_interp, grid
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from conversion import Conversion
from extraction import Extraction
from distance import Distance
from sys import argv
if __name__ == "__main__":
y = argv[1]
if "-c" in y:
c = Conversion(y)
elif "-e" in y:
e = Extraction(y)
elif y == "-d":
d = Distance()
else:
print "There is no %r option. Try -cmp3 -cm4a -e or -d." % (y)
def __init__(self):
self.conversion = Conversion()
# howManyIngredientsFoundInStorage metodi kutsuu iteratiivisesti itseään. Tämä mahdollistaa ikuisen loopin,
# joka on estetty laskemalla montako kertaa kyseistä metodia pyörii samaan aikaan.
self.inceptionCount = 0
class Search:
''' Tämän luokan metodeilla on mahdollista tehdä erilaisia hakuja. Ohjelma hyödyntää tätä luokkaa reseptien etsimisessä tietyillä hakuehdoilla
'''
def __init__(self):
self.conversion = Conversion()
# howManyIngredientsFoundInStorage metodi kutsuu iteratiivisesti itseään. Tämä mahdollistaa ikuisen loopin,
# joka on estetty laskemalla montako kertaa kyseistä metodia pyörii samaan aikaan.
self.inceptionCount = 0
def searcForhRecipesNIngredientsInStorage(self,recipesList,N,storageList, NNotInStorage):
'''
Tällä metodilla voidaan etsiä reseptejä, joihin löytyy vähintään N raaka-ainetta varastosta tai puuttuu maksimissaan N raaka-ainetta.
Args:
:recipesList: Lista kaikista reseptiolioista
:N: Monta raaka-ainetta löydyttävä/puututtava varastosta (int)
:storageList: Lista varastossa olevista raaka-aineolioista
:NNotInStorage: (Boolean) True arvolla N merkitsee sitä montako saa puuttua. False arvolla N merkitsee montako täytyy löytyä
Returns:
:recipesFound: Lista reseptio-olioista
'''
recipesFound = []
self.storageList = storageList
#Käydään kaikki reseptit läpi
for recipe in recipesList:
ingredientsFoundInStorage = self.howManyIngredientsFoundInStorage(recipe)
ingredientsInRecipe = len(recipe.getIngredients())
# Saa puuttua 0, joten N = raaka-aineiden määrä
if N == 0 and NNotInStorage:
if ingredientsFoundInStorage == ingredientsInRecipe:
recipesFound.append(recipe)
elif ingredientsFoundInStorage >= N and not NNotInStorage:
recipesFound.append(recipe)
elif ingredientsInRecipe - ingredientsFoundInStorage <= N and NNotInStorage:
recipesFound.append(recipe)
return recipesFound
def howManyIngredientsFoundInStorage(self, recipe):
''' Apumetodi, jota ei ole tarkoitus kutsua luokan ulkopuolelta.
Metodi käy reseptin raaka-aineet läpi ja montako niistä on tarpeeksi varastossa, metodi siis tarkastaa myös määrän.
Jos raaka-ainetta ei ole tarpeeksi varastossa, tarkastetaan voidaanko raaka-aine itse valmistaa reseptistä, jolloin kutsutaan
tätä samaa metodia. Tätä metodia voidaan kuitenkin kutsua maksimissaan 2 kertaa, jottei päädytä ikuiseen looppiin. Siis Raaka-aine - resepti
ketjua seurataan vain 2 kertaa.
'''
#Käydään reseptin kaikki raaka-aineet läpi
self.inceptionCount += 1 # Pidetään kirjaa, montako instanssia tästä metodista pyörii
ingredientsFoundInStorage = 0
for ingredientRecipe in recipe.getIngredients():
#Käydään koko varastolista läpi
for ingredientStorage in self.storageList:
#Katsotaan löytyykö reseptin raaka-aine varastosta
if ingredientRecipe.getIngredient() is ingredientStorage.getIngredient():
#Tarkistetaan, onko varastossa tarpeeksi raaka-ainetta
if self.amountDifferenceMax10Perc(ingredientRecipe, ingredientStorage):
ingredientsFoundInStorage += 1
elif ingredientRecipe.hasRecipe() and self.inceptionCount < 3:
if self.howManyIngredientsFoundInStorage(ingredientRecipe.getRecipe()) == len(ingredientRecipe.getRecipe().getIngredients()):
ingredientsFoundInStorage += 1
break
self.inceptionCount -= 1 # Vähennetään instanssilaskuria
return ingredientsFoundInStorage
def amountDifferenceMax10Perc(self, ingredientRecipe, ingredientStorage):
''' Apumetodi, jota ei ole tarkoitus kutsua luokan ulkopuolelta.
Tällä metodilla tarkastetaan onko varastossa tarpeeksi tiettyä raaka-ainetta. Jos resepti vaatii 1kg jauhelihaa, niin
900g kin kyllä riittää, joten varastosta saa puuttua maksimissaan 10% vaaditusta määrästä.
Args:
:ingredientRecipe: Reseptissä oleva ingredientContainer olio
:ingredientStorage: Varastossa oleva ingredientCOntainer olio
Returns:
:True: Raaka-aineiden määrän erotus on alle 10% tarvittavasta eli reseptin määrästä
:False: Erotus on yli 10% tarvittavasta määrästä
'''
maxDiff = 0.1
# Muutetaan reseptin raaka-aineen määrän yksikkö vastaamaan varastossa olevan raaka-aineen määrän yksikkö ja lasketaan erotus
difference = self.conversion.convertFromTo(ingredientStorage.getQuantity(),
ingredientStorage.getUnit(),
ingredientRecipe.getUnit(),
ingredientStorage.getDensity()) - ingredientRecipe.getQuantity()
# Armoa annetaan 10% vaaditusta määrästä, joten lisätään se erotukseen
# näin esim 9.5 kg - 10 kg = -0.5kg + 10*0.1 = -0.5kg + 1kg = +0.5kg > 0
difference = difference + ingredientRecipe.getQuantity() * maxDiff
if difference >= 0:
return True
else:
return False
def searchFromList(self, searchFor, searchList):
''' Tällä metodilla etsitään olio listasta tiettyä oliota sen nimen perusteella.
Vertailu tapahtuu stringeinä ja vaatii, että listassa olevilla olioilla on getName() metodi.
Args:
:searchFor: Etsittävä nimi (string)
:searchList: Lista olioista, joilla on getName() metodi
returns:
:recipesFound: Lista löydetyistä olioista. Tyhjä, jos ei löytynyt
'''
recipesFound = []
for i in searchList:
if searchFor.strip().lower() == i.getName().strip().lower():
recipesFound.append(i)
return recipesFound
return recipesFound
def searchIncludesIngredient(self,ingredientStr, recipesList):
''' Tällä metodilla etsitään reseptejä, jotka sisältävät tietyn raaka-aineen. Vertailutapahtuu stringeinä
Args:
:ingredientStr: Raaka-aineen nimi (string)
:recipesList: Lista reseptiolioista
Returns:
:recipesFound: Lista reseptiolioista. Tyhjä, jos ei löytynyt
'''
recipesFound = []
for recipe in recipesList:
for ingredientRecipe in recipe.getIngredients():
if ingredientRecipe.getName().strip().lower() == ingredientStr.strip().lower():
recipesFound.append(recipe)
break
return recipesFound
def searchNoAllergen(self,allergenStr,recipesList):
''' Tämmä metodilla etsitään reseptejä, jotka eivät sisällä tiettyä allergeeniä.
Allergeenien vertailu tapahtuu stringeinä
Args:
:allergenStr: Allergeeni (string)
:recipesList: Lista reseptiolioista
Returns:
:recipesFound: Lista reseptiolioista. Tyhjä, jos ei löytynyt
'''
recipesFound = []
for recipe in recipesList:
found = False
for ingredientRecipe in recipe.getIngredients():
for allergen in ingredientRecipe.getAllergens():
if allergen.strip().lower() == allergenStr.strip().lower():
found = True
break
if found:
break
if not found:
recipesFound.append(recipe)
return recipesFound
Main function
Load from the conversion configuration file
"""
import os
import sys
import cherrypy
from conversion import Conversion
def CORS():
"""
CORS
"""
cherrypy.response.headers["Access-Control-Allow-Origin"] = "*"
if __name__ == '__main__':
cherrypy.tools.CORS = cherrypy.Tool('before_handler', CORS)
CONF_FILE_REL = sys.argv[1] if len(sys.argv) == 2 and os.path.isfile(
sys.argv[1]) else "conversion.conf"
BASE_DIR = os.path.dirname(os.path.abspath(__file__))
CONF_FILE_ABS = os.path.join(BASE_DIR, CONF_FILE_REL)
cherrypy.config.update(CONF_FILE_ABS)
cherrypy.log.error_log.setLevel('ERROR')
cherrypy.quickstart(Conversion.get_instance(), config=CONF_FILE_ABS)