def summary(file_path,Project,FW,Date):
filelist = getDataFile(file_path)
for file in filelist:
name=(file.split('\\')[-1]).split('.')[0]
img = cv2.imread(file)
imgRotation.imgRotate(img)
ImgDict=getLocation.getLocation()
imgsize=ImgSize.getImgSize()
er=ER.getER(ImgDict)
penToPen=PenToPen.getAlignmentData(ImgDict)
resolution=Resolution.getResolution(ImgDict)
labValue=LAB.getLAB(ImgDict)
with open('..\\data\\PQ.csv', 'a+', newline='') as f:
csv_write = csv.writer(f)
# csv_write.writerow([Project,FW,Date,name,imgsize[0],imgsize[1],np.mean(er[0]),np.mean(er[1]),penToPen[0],penToPen[1],penToPen[2],penToPen[3],penToPen[4],penToPen[5],resolution[0][0],resolution[0][1],resolution[0][2],resolution[1][0],resolution[1][1],resolution[1][2],labValue[0],labValue[1],labValue[2],labValue[3],labValue[4],labValue[5],labValue[6],labValue[7],labValue[8],labValue[9],labValue[10],labValue[11],labValue[12],labValue[13],labValue[14],labValue[15]])
csv_write.writerow([Project,FW,Date,name,imgsize[0],imgsize[1],np.mean(er[0]),np.mean(er[1]),penToPen[0],penToPen[1],penToPen[2],penToPen[3],penToPen[4],penToPen[5],resolution[0][0][0],resolution[0][0][1]-2.06,resolution[0][1][0],resolution[0][1][1]-2.06,resolution[0][2][0],resolution[0][2][1]-2.06,resolution[1][0][0],resolution[1][0][1]-2.06,resolution[1][1][0],resolution[1][1][1]-2.06,resolution[1][2][0],resolution[1][2][1]-2.06,max(labValue[0:4]),max(labValue[4:8]),max(labValue[8:12]),max(labValue[12:16])])
df=pd.read_csv('..\\data\\PQ.csv')
columns=['Project','FW','Date','Name','ImgHieghtDiff','ImgWidthDiff','ER_H','ER_V','KtoC_H','KtoM_H','KtoY_H','KtoC_V','KtoM_V','KtoY_V','Res200_H','Res200_H_score','Res300_H','Res300_H_score','Res400_H','Res400_H_score','Res200_V','Res200_V_score','Res300_V','Res300_V_score','Res400_V','Res400_V_score','maxDeltaE_K','maxDeltaE_C','maxDeltaE_M','maxDeltaE_Y']
if df.columns[0]==columns[0]:
df.to_csv('..\\data\\PQ.csv',index=False)
else:
df = pd.read_csv('..\\data\\PQ.csv',header=None)
df.columns=columns
df.to_csv('..\\data\\PQ.csv', index=False)
gc.collect()
def createNewResolution(committeeId, index, topic, ownerId):
conn, cursor = _getCursor()
spanishResString = None
englishResString = None
language = getCommitteeLanguage(committeeId)
if language in [ENGLISH, BILINGUAL]:
englishResString = json.dumps(Resolution.getEmptyResolution())
if language in [SPANISH, BILINGUAL]:
spanishResString = json.dumps(Resolution.getEmptyResolution())
cursor.execute("SELECT id FROM CommitteeTopics WHERE committeeId=%s AND `index`=%s", (committeeId, topic))
topicRow = cursor.fetchone()
if not topicRow:
raise NoSuchTopicError()
topicId = topicRow[0]
cursor.execute("INSERT INTO Resolutions (serializedResolutionObjectEnglish, serializedResolutionObjectSpanish, `status`, `index`, topicId, ownerId) VALUES (%s, %s, %s, %s, %s, %s)", (englishResString, spanishResString, NEW_DRAFT, index, topicId, ownerId))
cursor.close()
conn.commit()
def deplacerJoueur(self):
"""
fonction ecoutant les entrees clavier et redirigeant vers les fonctions de deplacement du joueur
@type self: Objet
@param self: instance du jeu
@rtype:None
@return:None
"""
finDeEtape=False
clock = pygame.time.Clock()
#écoute des touches des touches du clavier pour le déplacement du joueur
while finDeEtape != True :
clock.tick(60)
for event in pygame.event.get(): #On parcours la liste de tous les évènements reçus
if event.type == pygame.KEYUP :
#si c'est une des flèches du clavier alors on prend en consideration le deplacement
if event.key in [pygame.K_UP,pygame.K_DOWN,pygame.K_RIGHT,pygame.K_LEFT]:
self.deplacer(event.key)
#Ctrl+a (ou Ctrl+q) met fin au jeu
if pygame.key.get_mods() & pygame.KMOD_LCTRL and event.key == pygame.K_q:
sysexit()
#si on appuit sur entré on valide le parcours souhaité par le joueur
if event.key == pygame.K_RETURN:
finDeEtape=self.ValiderChemin()
#en appuyant sur espace on utilise le joker qui optimise le deplacement
if event.key == pygame.K_SPACE:
#generation de la racine de l'arbre des chemins
positionDuJoueur = list(self.listeJoueur[self.listeJoueur['joueurActif']].position)
Case = self.plateauDeJeu[positionDuJoueur[0]][positionDuJoueur[1]]
initArbreChemin = ArbreChemin(list([positionDuJoueur]),Resolution.calculeValeur(Case,self.fantomePouvantEtreMange,self.listeJoueur[self.listeJoueur['joueurActif']]))
#generation complete de l'arbre des chemins
arbreChemin = Resolution.generationArbre(self.plateauDeJeu,positionDuJoueur,initArbreChemin,copy(self.fantomePouvantEtreMange,self.listeJoueur[self.listeJoueur['joueurActif']]))
#recherche du meilleur chemin dans l'arbre
self.liste_deplacement,gain = Resolution.meilleurChemin(arbreChemin)
for position in self.liste_deplacement:
self.graph.ajouter_rouge (position)
sleep(0.1)
print "si vous utilisez ce chemin vous gagnerez ",gain
if event.type == pygame.QUIT: #Si un de ces évènements est de type QUIT
sysexit() #On arrête la boucle
def deplacer(self,_direction) :
"""
fonction generant une liste de deplacement du joueur
@type self: Objet
@param self: instance du jeu
@type _direction: String
@param _direction: direction du déplacement
@rtype:None
@return:None
"""
#on récupère la carte sur laquelle le joueur se trouve
cartePositionDeDepart = self.plateauDeJeu[self.liste_deplacement[-1][0]][self.liste_deplacement[-1][1]].Carte
#modification de la nouvelle position en fonction de l'ancienne et de la direction demandée
nouvelleposition=list(self.liste_deplacement[-1])
if _direction == pygame.K_UP :
nouvelleposition[0] = (nouvelleposition[0]-1)%self.configuration['nbCase']
elif _direction == pygame.K_DOWN :
nouvelleposition[0] = (nouvelleposition[0]+1)%self.configuration['nbCase']
elif _direction == pygame.K_RIGHT :
nouvelleposition[1] = (nouvelleposition[1]+1)%self.configuration['nbCase']
elif _direction == pygame.K_LEFT:
nouvelleposition[1] = (nouvelleposition[1]-1)%self.configuration['nbCase']
#recuperation de la carte sur laquelle le joueur veut aller
cartePositionDeArrivee = self.plateauDeJeu[nouvelleposition[0]][nouvelleposition[1]].Carte
#s'il y a un mur sur le chemin alors on annule le mouvement
if not Resolution.mouvementPossible(cartePositionDeDepart,_direction-pygame.K_UP,cartePositionDeArrivee) :
nouvelleposition=list(self.liste_deplacement[-1])
#le joueur ne peut pas passer deux fois sur une case lors d'un deplacement alors s'il revient sur une case on supprime le chemin intermediaire
indice=0
doublon=False
for position in self.liste_deplacement:
indice+=1
if nouvelleposition == position and doublon ==False:
self.liste_deplacement=self.liste_deplacement[:indice-1]
doublon=True
if doublon==True:
#si le joueur est repasse par une meme case alors la suite du chemin est reinitialise
self.graph.remplir_une_case(self.listeJoueur, self.plateauDeJeu, position)
self.liste_deplacement.append(nouvelleposition)
self.graph.ajouter_rouge (nouvelleposition)
def utiliserJoker(self,_erreur = 0):
"""
fonction fesant appel au joker puis realisant les instructions donne par le joker
@type self: Objet
@param self: instance du jeu
@type _erreur: int
@param _erreur: l'erreur correspond a la probabilite de choisir un chemin s'il n'est pas le chemin optimal
@rtype:None
@return:None
"""
self.liste_deplacement,fonction,position,rotation = Resolution.joker(self,_erreur)
#realisation des instruction donnee par le joker
self.CaseRestante.Carte.orientation = self.CaseRestante.Carte.orientation +(90*rotation)
self.CaseRestante.Carte.rotation90(rotation)
fonction(position["ligne"],position["colonne"],True)
#suppression du joker du joueur
joueurActif = self.listeJoueur[self.listeJoueur['joueurActif']]
joueurActif.suppJoker()
self.plateauDeJeu[joueurActif.position[0]][joueurActif.position[1]].Joueur.suppJoker()
def resolve_references(ast):
return Resolution.resolve_references(ast)
print ('RStar:', RStar/U.RSun,', LStar:', LStar/U.LSun, ', TStar:', TStar)
#---------------
#GRID Definition
#---------------
#Cubic grid, each edge ranges [-500, 500] AU.
sizex = sizey = sizez = 500 * U.AU
Nx = Ny = Nz = 150 #Number of divisions for each axis
GRID = Model.grid([sizex, sizey, sizez], [Nx, Ny, Nz])
NPoints = GRID.NPoints #Number of nodes in the grid
#--------
#DENSITY
#--------
Rho0 = Res.Rho0(MRate, Rd, MStar)
Arho = 24.1 #Disc-envelope density factor
Renv = 500 * U.AU #Envelope radius
Cavity = 40 * np.pi/180 #Cavity opening angle
density = Model.density_Ulrich(RStar, Rd, Rho0, Arho, GRID, discFlag = True, envFlag = True,
renv_max = Renv, ang_cavity = Cavity)
#-----------
#TEMPERATURE
#-----------
T10Env = 375. #Envelope temperature at 10 AU
BT = 5. #Adjustable factor for disc temperature. Extra, or less, disc heating.
temperature = Model.temperature(TStar, Rd, T10Env, RStar, MStar, MRate, BT, None, density, GRID,
ang_cavity = Cavity)
#--------
def resolve_references(ast):
return Resolution.resolve_references(ast)
ActiveVoltage = 10 # V
## These are set to generate the initial signal
MainActiveFrequencyHz = 0.5 # Hz
MainActiveFrequency = MainActiveFrequencyHz*2*math.pi # This converts the signal from Hz to rads/sec
#############################################################################
## Empty Matrices
size = 1111
MATRIX = np.zeros((size,5), dtype = float)
#############################################################################
Res = R.ResolutionFunc(UpperVoltage, LowerVoltage, BitNumber)
VoltFrac = VF.VoltageFractionFunc(ActiveVoltage, UpperVoltage, LowerVoltage)
## Loop for solving
for x in range(size):
t = x/100 # generates time step
MAIN = FG.MainVoltageSignal(ActiveVoltage, MainActiveFrequency, t) # generates main signal
NOISE = random.uniform(-1,1)/10 # generates some noise
TotalSignal = MAIN+NOISE # saves total signal
FilteredSignal = FS.FilteredSignalFunc(TotalSignal, VoltFrac, BitNumber, Res, LowerVoltage, UpperVoltage)
Error = abs(TotalSignal-FilteredSignal)
MATRIX[x,0] = t
MATRIX[x,1] = TotalSignal
MATRIX[x,2] = FilteredSignal
MATRIX[x,3] = Error
def resolve_references(ast, allow_forward):
return Resolution.resolve_references(ast, allow_forward)
def ContractionMI(self, contraction_statement):
"""Performs contraction on a given KB"""
# This method takes only CNF input for all its operations, uses a list of sets to represent the KB internally amd perform operations.
# Uses Entrenchment for cases where the random decision are to be made.
# The entrenchment used is the position of the given letter in the alphabet.
# Z has more priority over A.
KB_rep = [set(string.split(sep = '|')) for string in self.KB]
res = Resolution.Resolution()
contraction_statement_raw = contraction_statement.upper()
contraction_statement_raw = contraction_statement_raw.replace(' ', '')
and_count = contraction_statement_raw.count('&')
or_count = contraction_statement_raw.count('|')
if '&' in contraction_statement_raw:
contraction_statement = contraction_statement_raw.split(sep = '&')
contraction_statement_rep = [string.split(sep = '|') for string in contraction_statement if string != '~']
else:
contraction_statement_rep = contraction_statement_raw.split(sep = '|')
solo, statement_check = False, False
if len(contraction_statement_raw) == 2:
contraction_statement_rep = [contraction_statement_rep]
if and_count == 0 and or_count != 0:
contraction_statement_rep = [contraction_statement_rep]
if res.resolveKB(self.KB, contraction_statement_raw): # Performs contraction only if the entire CNF contraction statement is true.
for index in range(len(contraction_statement_rep)):
statement = contraction_statement_rep[index]
statement = sorted(statement, key = lambda x: ord(x) if len(x) < 2 else len(x))
KB_statement = '|'.join(statement)
truth_value = res.resolveKB(self.KB, KB_statement)
single_literal = False
if truth_value:
if solo:
single_literal = True
else:
try:
[statement] = statement
single_literal = True
except ValueError:
single_literal = False
if single_literal:
for location, sentence in enumerate(KB_rep):
literal = statement
if literal in sentence:
KB_rep[location].remove(literal)
break
else:
truth = [res.resolveKB(self.KB, literal) for literal in statement]
pos = [i for i, x in enumerate(truth) if not x]
for position in pos:
literal = statement[position]
for location, sentence in enumerate(KB_rep):
if literal in sentence:
KB_rep[location].remove(literal)
break
break
while True:
try:
KB_rep.remove(set())
except ValueError:
break
self.KB = ['|'.join(sentence) for sentence in KB_rep]
if len(self.KB) == 0:
print(self.KB)
return False
else:
print(self.KB)
return True
else:
# new belief follows KB therefore can directly be added into the KB if performing revision.
print(self.KB)
return True
