예제 #1
0
파일: plateau.py 프로젝트: nd974/CLUED-IUTO
def distancePieces(plateau, lig, col):
    """
	retourne un dictionnaire dont les clés sont les identifiant des pièces et les valeurs la distance
	a parcourir pour atteindre la pièce à partir de la case de coordonnées (lig,col)
	paramètres: plateau le plateau considéré
				lig: le numéro de la ligne de la case considérée
				col: le numéro de la colonne de la case considérée
	résultat: le dictionnaire décrit plus haut
	"""
    dico_idpiece_distance = {}
    nbLignes = getNbLignesP(plateau)
    nbColonnes = getNbColonnesP(plateau)
    calque = matrice.Matrice(nbLignes, nbColonnes, None)
    matrice.setVal(calque, lig, col, 0)
    modif = True
    i = 0

    while modif:
        modif = marquageDirect(plateau, calque, i, i + 1)
        i += 1

    def chercherLaDistance(une_entree):
        ligne_une_entree, colonne_une_entree = entree.getLigne(
            une_entree), entree.getColonne(une_entree)
        return matrice.getVal(calque, ligne_une_entree, colonne_une_entree)

    for id_piece, instance_piece in getPieces(plateau).items():
        dico_idpiece_distance[id_piece] = chercherLaDistance(
            min(piece.getListeEntrees(instance_piece), key=chercherLaDistance))
    return dico_idpiece_distance
예제 #2
0
파일: plateau.py 프로젝트: nd974/CLUED-IUTO
def casesAccessibles(plateau, listeDepart, distance):
    """
	retourne la liste des cases accessibles sous la forme de liste de couples 
	de coordonnées (lig,col)
	paramètres: plateau le plateau considéré
				listeDepart: une liste de couples (lig,col) indiquant les points de départ de la recherche
				distance: un entier positif indiquant de combien de cases on a le droit de se déplacer
	résultat: la liste des case atteignable à partir d'un des départs en utilisant moins de distance déplacements
	"""
    res = set()
    nbLignes = getNbLignesP(plateau)
    nbColonnes = getNbColonnesP(plateau)
    for (lig, col) in listeDepart:
        calque = matrice.Matrice(nbLignes, nbColonnes, None)
        matrice.setVal(calque, lig, col, 0)
        for dist in range(0, distance):
            marquageDirect(plateau, calque, dist, dist + 1)
        for ligne in range(nbLignes):
            for colonne in range(nbColonnes):
                dist2 = matrice.getVal(calque, ligne, colonne)
                if dist2:
                    if not getContenuP(plateau, ligne, colonne):
                        if getCategorieP(plateau, ligne,
                                         colonne) and getCategorieP(
                                             plateau, ligne, colonne) > 0:
                            res.add((ligne, colonne))
                        elif dist2 % 2 == distance % 2:
                            res.add((ligne, colonne))
    return res
예제 #3
0
파일: plateau.py 프로젝트: nd974/CLUED-IUTO
def Plateau(nbLig, nbCol):
    """
	créer un plateau de nbLig sur nbCol cases vides avec une liste de pièces vide
	paramètres: nbLig et nbCol deux entiers strictement positifs
	"""
    plateau = {
        MATRICE_CASES: matrice.Matrice(nbLig, nbCol, COULOIR_LIBRE),
        LISTE_PIECES: {}
    }
    return plateau
예제 #4
0
    def fb(self, l):
        """Compute the Partitions with Lexique l, using
forward-backward algorithm, on the already stored data. On each
position, the first best descriptor is kept.
"""
        m = matrice.Matrice()
        for x in self:
            x[1] = partition.Partition()
            m.fb(x[0], l)
            x[1].read_Matrice(m)
예제 #5
0
        for j in range(numMod):
            fout.write(str(liste[1 + numMod + j]) + "\t")
            mod[j][i - 1] = float(liste[1 + numMod + j])
        fout.write("\n")
        i = i + 1

f.close()
fout.close()

lx = lexique.Lexique(str=lexiqueString)  #"0:#0 1:#1 ")

#print lx

import matrice

m = matrice.Matrice(fic=out)

# lx=lexique.Lexique(fprop="prob")

# m=matrice.Matrice()
# s=sequence.Sequence(fic="lambda.seq")
# m.prediction(s,lx)

# lx2=lexique.Lexique(str="1:#1 2:#2 3:#3 4:#4")
# lx2.init_trans()

# lx2.g_trans(1,1,math.log(0.9985))
# lx2.g_trans(1,2,math.log(0.0005))
# lx2.g_trans(1,3,math.log(0.0005))
# lx2.g_trans(1,4,math.log(0.0005))
# lx2.g_trans(2,2,math.log(0.9985))