Quixels - Pixels Quantiques

35

introduction

Un quixel est un pixel quantique. Semblable à un pixel classique, il est représenté avec 3 valeurs entières (rouge, vert et bleu). Cependant, les quixels sont dans une super position de ces 3 états au lieu d'une combinaison. Cette super position ne dure que jusqu’à ce que le quixel soit observé, puis se réduit à l’un des trois pixels classiques; RGB(255,0,0), RGB(0,255,0)Et RGB(0,0,255).

spécification

  • Représentation
    • Chaque quixel est représenté par un tableau de 3 entiers compris entre 0 et 255 r, get brespectivement.
  • Super positions
    • Chaque QUIXEL est dans une position super entre le rouge, bleu et vert états représentés par R, Get Brespectivement.
  • Observation
    • Lorsque chaque quixel est observé, il s'effondre dans l'un des trois états. La probabilité de chaque état classique est R = (r + 1) / (r + g + b +3), G = (g + 1) / (r + g + b + 3) et B = (b + 1) / (r + g + b + 3). De cette façon, chaque état classique a toujours une probabilité d’apparition différente de zéro.
  • Contribution
    • La fonction ou le programme doit prendre une image de quixels. Comment cela fonctionne-t-il? Un nom de fichier, en utilisant un tableau multi-dimensionnel, etc. sont tous acceptables.
  • Sortie
    • La fonction ou le programme doit produire une image de pixels classiques. La structure de données pour cette image produite est également flexible. Notez que tous les pixels devraient être l' un de ces trois: RGB(255,0,0), RGB(0,255,0)etRGB(0,0,255)
    • Le résultat ne devrait pas être déterministe ; ce sont des pixels quantiques ! La même entrée devrait donner des sorties différentes.
    • Si votre langue n'a aucun moyen de générer un nombre aléatoire, vous pouvez utiliser des octets aléatoires en tant qu'entrée.
  • Notation
    • C’est du si peu d’octets gagnent.

Images

Mona Lisa de Leonardo da Vinci Mona Lisa

Nuit étoilée de Vincent van Gogh entrez la description de l'image ici

La persistance de la mémoire par Salvador Dali entrez la description de l'image ici

Teddy Roosevelt VS. Bigfoot par SharpWriter entrez la description de l'image ici

Fruit non linéaire
la source
Le nom de fichier / URL de l'image peut-il être un argument d'entrée?
Luis Mendo
2
Cette image JPEG de la Mona Lisa provoque des artefacts visuels importants de 16 x 16 sur les images de sortie.
wizzwizz4
1
@ wizzwizz4 En fait, ce n'est pas. C'est l'aperçu réduit qui contient des artefacts. Cliquez sur une image pour la voir en taille réelle. Je suppose que c'est la largeur particulière de cette image qui donne l'effet.
Adám
2
Vous obtiendrez de meilleurs résultats (visuels) si votre espace quantique était RGBK, où K=255*3-R-G-B, puis définissez vos pixels quantiques sur l’un des 4 (si K est sélectionné, affichez (0,0,0). Étendez vos équations RVB dans la manière évidente, changer 3s à 4s, ajouter K quand vous ajouteriez R + G + B, etc.). Un flou après cela devrait reconstituer une copie assez décente et bruyante de l'original. (K signifie noir ou clé, au cas où vous vous le demanderiez)
Yakk
2
@TLW Si votre langue n'a aucun moyen de générer un nombre aléatoire, vous pouvez utiliser des octets aléatoires en entrée
NonlinearFruit

Réponses:

13

Dyalog APL , 23 21 19 octets

Prend la table de triplés (R, G, B).

Inspiré par l'algorithme de miles

Renvoie la table des index en {(255, 0, 0), (0, 255, 0), (0, 0, 255)}. Horriblement inutile.

(?∘≢⊃⊢)¨(⊂⍳3)/¨⍨1+⊢

(
?∘≢index aléatoire
sélectionne
de
chacun des

(
l'ensemble des
⍳3trois premiers indices
)/¨⍨répliqués par chacun des

1+⊢ les triplets incrémentés

TryAPL!


Ancienne version

Renvoie une table d'indices basés sur 0 en {(255, 0, 0), (0, 255, 0), (0, 0, 255)}

{+/(?0)≥+\(1+⍵)÷3++/⍵}¨

{... }¨ pour chaque quixel du tableau, trouvez le:

+/ la somme de (nombre de vérités de)

(?0)≥ un aléatoire 0 <nombre <1 étant supérieur ou égal à

+\ la somme cumulée de

(1+⍵)÷ les valeurs RVB incrémentées divisées par

3+ trois plus

+/⍵ la somme du quixel

Remarque: Dyalog APL vous permet de choisir entre le générateur de congruence linéaire de Lehmer , le Twister de Mersenne et le RNG ¹ ² du système d'exploitation .

Par exemple, l'image:

┌──────────┬──────────┬───────────┬───────────┬─────────┐
52 241 198148 111 45197 165 1809 137 120  46 62 75 
├──────────┼──────────┼───────────┼───────────┼─────────┤
81 218 1040 0 255   0 255 0    181 202 116122 89 76
├──────────┼──────────┼───────────┼───────────┼─────────┤
181 61 34 84 7 27   233 220 24939 184 160 255 0 0  
└──────────┴──────────┴───────────┴───────────┴─────────┘

peut donner

┌─┬─┬─┬─┬─┐
10221
├─┼─┼─┼─┼─┤
22112
├─┼─┼─┼─┼─┤
02120
└─┴─┴─┴─┴─┘

Notez comment les trois "purs" quixels se sont effondrés à leurs couleurs respectives.

TryAPL en ligne!

Effondré Mona Lisa

Adam
la source
8

Mathematica, 53 octets

RandomChoice[255#+1->IdentityMatrix@3]&~ImageApply~#&

Fonction anonyme. Prend Mathematica Imageen entrée et renvoie un Imageen sortie. Notez que l'image d'entrée doit avoir un espace colorimétrique RVB.

LegionMammal978
la source
Comment ça marche?
GreenAsJade
2
@GreenAsJade <...>~ImageApply~#applique une fonction sur tous les pixels de l'image et RandomChoice[255#+1->IdentityMatrix@3]utilise un RNG pondéré pour produire une rangée de la matrice d'identité 3 × 3 (c'est {1, 0, 0}-à- dire {0, 1, 0}, ou {0, 0, 1}) qui correspond au rouge, au vert ou au bleu.
LegionMammal978
5

C #, 366 243 octets

Un grand merci à @TheLethalCoder pour avoir joué au golf!

var r=new Random();c=>{double t=c.R+c.G+c.B+3,x=(c.R+1)/t,d=r.NextDouble();return d<=x?Color.Red:d<=x+(c.G+1)/t?Color.Lime:Color.Blue;};b=>{fo‌​r(int x=0,y;x<b.Width;x++)for(y=0;y<b.Height;y++)b.SetPixel(x,y,g(‌​b.GetPixel(x,y)));re‌​turn b;};

Idée basique:

using System;
using System.Drawing;
static Random r = new Random();

static Image f(Bitmap a) {
    for (int x = 0; x < a.Width; x++) {
        for (int y = 0; y < a.Height; y++) {
            a.SetPixel(x, y, g(a.GetPixel(x, y)));
        }
    }
    return a;
}

static Color g(Color c) {
    int a = c.R;
    int g = c.G;
    double t = a + g + c.B + 3;
    var x = (a + 1) / t;
    var y = x + (g + 1) / t;
    var d = r.NextDouble();
    return d <= x ? Color.Red : d <= y ? Color.Lime : Color.Blue;
}

Exemples:

Mona Lisa

entrez la description de l'image ici

Nuit étoilée

entrez la description de l'image ici

La persistance de la mémoire

entrez la description de l'image ici

Teddy Roosevelt VS. Bigfoot

entrez la description de l'image ici

Voici un album imgur mis à jour avec quelques exemples supplémentaires, pour montrer que c'est non déterministe.

ThreeFx
la source
6
Color.Lime est la couleur verte pure. Pour référence future, voici la table de couleurs connue .
lait
1
Voici une version pour 237 octets var r=new Random();c=>{double t=c.R+c.G+c.B+3,x=(c.R+1)/t,d=r.NextDouble();return d<=x?Color.Red:d<=x+(c.G+1)/t?Color.Lime:Color.Blue;};b=>{for(int x=0,y;x<b.Width;x++)for(y=0;y<b.Height;y++)b.SetPixel(x,y,g(b.GetPixel(x,y)));return b;};
jouée au golf
En fait, ses 237 octets sont des caractères invisibles ajoutés dans le commentaire de code, je crois
TheLethalCoder
4

Python 2, 172 166 162 octets

Les deuxième et troisième niveaux de retrait sont un onglet brut et un onglet brut plus un espace, respectivement; cela joue vraiment mal avec Markdown, donc les onglets ont été remplacés par deux espaces.

from random import*
i=input()
E=enumerate
for a,y in E(i):
 for b,x in E(y):
  t=sum(x)+3.;n=random()
  for j,u in E(x):
   n-=-~u/t
   if n<0:i[a][b]=j;break
print i

Utilise un format d'entrée / sortie similaire à la réponse APL d' Adám . L'entrée est un tableau 2D de n-uplets RVB; la sortie est un tableau 2D de 0, 1ou 2représentant respectivement le rouge, le vert et le bleu. Par exemple:

$ echo "[[(181,61,34),(39,184,160),(255,0,0)],[(84,7,27),(123,97,5),(12,24,88)]]" | python quixel.py
[[2, 2, 0], [0, 0, 0]]

Vous trouverez ci-dessous ma réponse plus ancienne à Python 3 en utilisant PIL.

Python 3 + PIL, 271 250 245 243 octets

import random as a,PIL.Image as q
i=q.open(input())
w,h=i.size
for k in range(w*h):
 m=k//h,k%h;c=i.getpixel(m);t=sum(c)+3;n=a.random()
 for j,u in enumerate(c):
  n-=-~u/t
  if n<0:z=[0]*3;z[j]=255;i.putpixel(m,tuple(z));break
i.save('o.png')

Itère sur chaque pixel et lui applique la fonction quixel. Prend le nom de fichier en entrée et enregistre sa sortie dans o.png.

Voici quelques résultats:

$ echo mona-lisa.jpg | python quixel.py

Mona Lisa, quixelized

$ echo starry-night.jpg | python quixel.py

Nuit étoilée, quixelized

$ echo persistence-of-memory.jpg | python quixel.py

Persistance de la mémoire, quixelized

$ echo roosevelt-vs-bigfoot.jpg | python quixel.py

Teddy Roosevelt vs Bigfoot, quixelized

Cuivre
la source
@Doddy Probablement parce qu'il s'agit d'un PRNG et non d'un RNG cryptographiquement sécurisé.
somewithpc
@ someonewithpc Oh, en fait, j’ai posé cette question lors de la visualisation sur mon téléphone, où la dernière image présente un motif régulier semblable à une grille, mais maintenant, si elle est affichée sur un ordinateur, c’est la première image avec cet effet.
Doddy
@Doddy Oh, oui! Essayez d'appuyer sur l'image sur votre téléphone: les effets vont basculer! Je suppose que cela concerne l'échantillonnage d'images ...
somewithpc
@Doddy Peut-être supprimez-vous votre première question, alors nous ne pensons pas que vous posez des questions sur les denses bandes rouges du drapeau ...
GreenAsJade
4

R, 58 octets

mapply(function(r,g,b)rmultinom(1,1,c(r+1,g+1,b+1)),r,g,b)

Entrée se compose de trois vecteurs numériques tenue à r, get brespectivement.

Nous n'avons pas besoin de normaliser les probabilités pour faire une somme de 1, cela se produit automatiquement en rmultinom.

La sortie est de la forme

     [,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8] [,9] [,10]
[1,]    0    0    0    0    0    0    0    0    0     0
[2,]    0    0    0    1    0    0    1    1    1     0
[3,]    1    1    1    0    1    1    0    0    0     1

Où il y en a un 1dans chaque colonne. Le 1est dans la première ligne pour "R" pixels, la deuxième ligne pour "G" et la troisième ligne pour "B".

JDL
la source
4

Pyth - 11 à 10 octets

Prend bitmap RVB 2D et génère une image bitmap avec une couleur indexée 3 bits.

mLOs.emkbk

Ce niveau de nidification me fait mal à la tête.

Essayez-le en ligne ici .

Maltysen
la source
4

J, 20 18 17 octets

(>:({~?@#)@##\)"1

L’image est entrée sous forme de tableau de dimensions h x w x 3 représentant les valeurs RVB sous forme d’entiers compris entre 0 et 255. La sortie est un tableau de dimensions h x w où 1 est une valeur rgb de (255, 0, 0 ), 2 est (0, 255, 0) et 3 est (0, 0, 255).

Explication

Le ()"1représente que ce verbe doit être appliqué à chaque tableau de rang 1 dans l'entrée, ce qui signifie qu'il s'appliquera à chaque pixel .

>:({~?@#)@##\  Input: array [R G B]
>:             Increment each, gets [R+1, G+1, B+1]
           #\  Gets the length of each prefix of [R G B], forms [1 2 3]
          #    Make a new array with R+1 copies of 1, G+1 copies of 2,
               and B+1 copies of 3
  (     )@     Operate on that array
       #         Get the length of the array of copies, will be R+G+B+3
     ?@          Generate a random integer in the range [0, R+G+B+3)
   {~            Select the value at that index from the array of copies and return

Exemple

milles
la source
1
Votre Mona Lisa a une palette de couleurs différente des autres. Êtes-vous sûr que cela fonctionne bien?
wizzwizz4
@ wizzwizz4 Merci, lors de l'affichage de l'image, j'avais les pixels RVB dans l'ordre inverse.
miles
4

Gelée , 8 7 octets

Jx‘Xµ€€

L'entrée est une liste 3D de dimensions h x w x 3. La sortie est une liste 2D de dimensions h x w, où 1 représente la valeur de la valeur de référence (255, 0, 0), 2 la valeur (0, 255, 0) et 3 est (0, 0, 255).

L'échantillon ci-dessous est la région 4 x 4 en haut à gauche de l'image Mona Lisa.

Essayez-le en ligne!

Explication

Jx‘Xµ€€  Input: The 3d list of rgb pixels
    µ    Begin a monadic chain (Will operate on each pixel, input: [R, G, B])
J          Enumerate indices to get [1, 2, 3]
  ‘        Increment each to get [R+1, G+1, B+1]
 x         Make R+1 copies of 1, G+1 copies of 2, B+1 copies of 3
   X       Select a random value from that list of copies and return
     €€  Apply that monadic chain for each list inside each list
milles
la source
3

Python 3, 119 octets

mest l'entrée prise comme un tableau 2D de pixels où chaque pixel est une liste de la forme [r,g,b]. À la position de chaque pixel, revient 0,1,2à représenter (250,0,0), (0,250,0), and (0,0,250)respectivement.

import random
lambda m:[map(lambda x:x.index(sum((((i+1)*[i])for i in x),[])[random.randint(0,sum(x)+2)]),i)for i in m]
Gowrath
la source
Je ne crois pas que vous puissiez utiliser les entrées comme variable (lors de l'écriture d'un programme complet dans un langage qui prend en charge les opérations d'E / S normales). Je pense que vous devez utiliser inputou en faire une fonction et prendre men paramètre.
NonlinearFruit