J'essaie donc d'utiliser PIL pour tracer des valeurs RVB pour créer une image.

Le code que j'utilise pour le traçage est le suivant:

from PIL import Image, ImageDraw

class DrawDisplay(object):
    def __init__(self, size_x, size_y):
        self.size_x = size_x                                       #Length of the image
        self.size_y = size_y                                       #Width of the image
        self.img = Image.new("RGB", (self.size_x, self.size_y))    #Creates the drawing canvas
    def plot(self, xy, colour):
        d = ImageDraw.Draw(self.img)
        d.point(xy, colour)                                        #xy is co-ordinate in form of tuple, colour is rgb value in form of tuple
    def write(self, filename):
        self.img.save(filename)                                    #Saves image with the variable filename as the name

Je sais qu'il n'y a aucun problème avec le code ci-dessus car je l'ai testé avec:

dd = DrawDisplay(64, 64)                                           #Utilises the drawing class
for i in range(64):
    for j in range(64):
        r = i * 4    #Pretty colours
        g = j * 4
        b = 0
        dd.plot((i, j),(r, g, b))                                  #Uses method from earlier with i and j as x and y
dd.write("testname.png")                                           #Saves the image as testname

Et j'obtiens une jolie jolie image si je clique sur testname.png dans mon dossier

Comme ça

Supposons maintenant que j'avais un tableau non ordonné avec chaque numéro jusqu'à 64 ^ 2 ou 4096:

my_list = shuffle(range(4096))

Maintenant, c'est là que j'ai besoin d'aide, comment pourrais-je traiter chaque valeur dans my_list pour obtenir un tuple de coordonnées xy en utilisant une formule / fonction?

Voici une autre façon de voir cette question:

Imaginez une grille 4x4. Si je mets 1 dans cette fonction, ma sortie serait (1,1) (ou (0,0) si vous voulez simplifier ce problème.)

  1 2 3 4    #Visualised
1 1 - - -
2 - - - -
3 - - - -
4 - - - -

16 comme entrée produirait (4,4) (ou (3,3)):

  1 2 3 4
1 - - - -
2 - - - -
3 - - - -
4 - - - 16

Et 7 sorties (3,2) (ou (2,1)):

  1 2 3 4
1 - - - -
2 - - 7 -
3 - - - -
4 - - - -

Quelle serait ma formule / fonction?

0
Victor Ciobanu 11 avril 2018 à 16:17

3 réponses

Meilleure réponse

Si vous avez différentes tailles de grille, cela peut vous aider. Ce n'est pas le plus élégant, mais ça marche

def fun(val, grid):
    pos = []
    for val in lst:
        x = val//grid[1]
        r = val%grid[1]
        if(r==0):
            pos.append([x, grid[1]])
        else:
            pos.append([x+1, val-(x*grid[1]])
   return pos
0
shriyan 11 avril 2018 à 13:37

Je pense que cela devrait le faire:

def idx2point(idx):
   return (idx/64,idx%64)

Vous pouvez ajouter 1 à chaque coordonnée si vous souhaitez compter à partir de 1 plutôt que de 0.

0
kittel 11 avril 2018 à 13:33

J'ai une autre fonction pour calculer les coordonnées:

from math import floor, sqrt

def f(num):
    a = floor(sqrt(num))
    if a**2 == num:
        return (a, a)
    b = (num - a**2 + 1) // 2
    if num % 2 == a % 2:
        return (b, a+1)
    else:
        return (a+1, b)

Cela donne les résultats suivants:

f(1)
>>> (1, 1)
f(9)
>>> (3, 3)
f(10)
>>> (4, 1)
f(11)
>>> (1, 4)
f(12)
>>> (4, 2)
0
Olivier CAYROL 11 avril 2018 à 14:11