Ecrivez un programme qui prend une chaîne ou un fichier texte dont la première ligne a la forme

width height

et chaque ligne suivante a la forme

x y intensity red green blue

où:

• widthet heightpeut être n'importe quel entier positif.
• xet ypeuvent être des nombres entiers.
• intensity peut être n'importe quel entier non négatif.
• red, greenet bluepeuvent être des nombres entiers compris entre 0 et 255 inclus.

Votre programme doit générer une image truecolor dans n’importe quel format de fichier image sans perte commun dont les dimensions sont définies widthpar height. Chaque x y intensity red green blueligne représente une étoile ou un globe coloré à dessiner sur l’image. Il peut y avoir un nombre quelconque d'étoiles à dessiner, y compris 0. Vous pouvez supposer que la chaîne ou le fichier a une nouvelle ligne.

L'algorithme pour dessiner l'image est le suivant, mais vous pouvez l'implémenter à votre guise tant que le résultat est identique:

Pour chaque pixel ( X , Y ) de l’image ( X étant 0 au bord le plus à gauche et 1 à la largeur au bord le plus à droite, et Y à 0 au bord supérieur et à la hauteur 1 au bord inférieur), le canal de couleur C ϵ { rouge , vert , bleu } (une valeur épinglée entre 0 et 255) est donné par l'équation:

Où la fonction dist est soit une distance euclidienne :

Ou distance de Manhattan :

Choisissez la fonction de distance que vous préférez, en fonction de la golfabilité ou de l'esthétique.

En plus de la première, chacune des lignes de l'entrée est un élément du jeu d' étoiles . Ainsi, par exemple, S _x représente la xvaleur sur l' une des lignes d'entrée, et S _C représente soit red, greenou blue, selon le canal de couleur est en cours de calcul.

Exemples

Exemple A

Si l'entrée est

400 150
-10 30 100 255 128 0

la sortie devrait être

si vous utilisez la distance euclidienne, et

si vous utilisez la distance de Manhattan.

Exemple B

Si l'entrée est

200 200
100 100 10 255 255 255
20 20 40 255 0 0
180 20 40 255 255 0
180 180 40 0 255 0
20 180 40 0 0 255

les sorties respectives pour la distance euclidienne et Manhattan devraient être

et .

Exemple C

Si l'entrée est

400 400
123 231 10 206 119 85
358 316 27 170 47 99
95 317 3 202 42 78
251 269 17 142 150 153
43 120 3 145 75 61
109 376 6 230 231 52
331 78 21 31 81 126
150 330 21 8 142 23
69 155 11 142 251 199
218 335 7 183 248 241
204 237 13 112 253 34
342 89 18 140 11 123

la sortie devrait être

si vous utilisez la distance euclidienne, et

si vous utilisez la distance de Manhattan.

Exemple D

Si l'entrée est

400 400
123 231 5 206 119 85
358 316 5 170 47 99
95 317 5 202 42 78
251 269 5 142 150 153
43 120 5 145 75 61
109 376 5 230 231 52
331 78 5 31 81 126
150 330 5 8 142 23
69 155 5 142 251 199
218 335 5 183 248 241
204 237 5 112 253 34
342 89 5 140 11 123

la sortie devrait être

si vous utilisez la distance euclidienne, et

si vous utilisez la distance de Manhattan.

Exemple E

Si l'entrée est

100 1

la sortie devrait alors être une image complètement noire de 100 pixels de large par 1 pixel de haut.

Remarques

• Prenez la chaîne d'entrée ou le nom d'un fichier texte qui le contient à partir de stdin ou de la ligne de commande, ou écrivez une fonction prenant une chaîne.
• "Produire" l'image signifie soit:
  • Sauvegarde dans un fichier avec le nom de votre choix.
  • Impression des données de fichier image brutes sur stdout.
  • Affichage de l'image, comme avec PIL de image.show().
• Je ne vérifierai pas que vos images sont parfaitement pixelisées (Stack Exchange compresse néanmoins les images avec perte), mais je serai très suspicieux si je peux distinguer visuellement toute différence.
• Vous pouvez utiliser des bibliothèques de graphiques / d'images.

Gagnant

La soumission la plus courte en octets l'emporte. En cas d'égalité, la première soumission gagne.

Bonus amusant: donnez une entrée pour une image de sortie vraiment spectaculaire.

Pyth - 46 octets

C'était amusant! J'ai enfin pu utiliser les fonctionnalités d'E / S de l'image de Pyth. Fait distance euclidienne à cause de Golfiness, bien que Manhattan est juste un changement court.

Krz7.wcmmsm/*@[email protected],<b2_.DdhKrR7.zU3*FKhK

Cela fait simplement une boucle à travers tous les pixels avec la formule, bien que cela condense la boucle de pixel en une boucle et l'utilise divmodpuisque Pyth ne supporte que 3 cartes imbriquées et que les calculs en prennent deux (une pour les RVB et une pour les étoiles).

Enregistre l'image sous o.png. Assez lent, effectue les 2 premiers tests en <2 min, mais les 2 autres prennent environ une demi-heure.

Il y a un bug dans .wlequel personne n'a remarqué parce que personne ne l'utilise;) mais j'ai introduit une demande d'extraction, utilisez donc mon fork pour tester si elle n'est pas fusionnée bientôt. Fusionné!

Exemples de sorties

Exemple A

Exemple B

Exemple C

Exemple D

JavaScript 394 344

function X(a){for(l=a.match(/\d+/g),h=document,v=h.body.appendChild(h.createElement("canvas")),v.width=W=l[0],v.height=H=l[1],w=v.getContext("2d"),e=w.createImageData(W,H),d=e.data,N=W*H;N--;)for(i=2,c=N*4,d[c+3]=255;i<l.length;)for(x=N%W-l[i++],y=~~(N/W)-l[i++],k=l[i++],q=0;q<3;)d[c+q++]+=k*l[i++]/-~Math.sqrt(x*x+y*y);w.putImageData(e,0,0);}

Edit: raccourci le code en appliquant les superbes suggestions de wolfhammer .

Tester

Remarque: attendez quelques secondes que l'extrait de code ci-dessous soit rendu (cela prend environ 4 secondes sur ma machine).

function X(a){for(l=a.match(/\d+/g),h=document,v=h.body.appendChild(h.createElement("canvas")),v.width=W=l[0],v.height=H=l[1],w=v.getContext("2d"),e=w.createImageData(W,H),d=e.data,N=W*H;N--;)for(i=2,c=N*4,d[c+3]=255;i<l.length;)for(x=N%W-l[i++],y=~~(N/W)-l[i++],k=l[i++],q=0;q<3;)d[c+q++]+=k*l[i++]/-~Math.sqrt(x*x+y*y);w.putImageData(e,0,0);}

var start = Date.now();

X("400 150\n" +
  "-10 30 100 255 128 0");

X("200 200\n" +
  "100 100 10 255 255 255\n" +
  "20 20 40 255 0 0\n" +
  "180 20 40 255 255 0\n" +
  "180 180 40 0 255 0\n" +
  "20 180 40 0 0 255");

X("400 400\n" +
  "123 231 10 206 119 85\n" +
  "358 316 27 170 47 99\n" +
  "95 317 3 202 42 78\n" +
  "251 269 17 142 150 153\n" +
  "43 120 3 145 75 61\n" +
  "109 376 6 230 231 52\n" +
  "331 78 21 31 81 126\n" +
  "150 330 21 8 142 23\n" +
  "69 155 11 142 251 199\n" +
  "218 335 7 183 248 241\n" +
  "204 237 13 112 253 34\n" +
  "342 89 18 140 11 123");

X("400 400\n" +
  "123 231 5 206 119 85\n" +
  "358 316 5 170 47 99\n" +
  "95 317 5 202 42 78\n" +
  "251 269 5 142 150 153\n" +
  "43 120 5 145 75 61\n" +
  "109 376 5 230 231 52\n" +
  "331 78 5 31 81 126\n" +
  "150 330 5 8 142 23\n" +
  "69 155 5 142 251 199\n" +
  "218 335 5 183 248 241\n" +
  "204 237 5 112 253 34\n" +
  "342 89 5 140 11 123");

var end = Date.now();

console.log('Done in ' + (end - start)/1000 + 's.');

canvas {
  display: block;
  padding: 10px;
}

Vous pouvez également l'exécuter dans JSFiddle .

Bonus: Eclipse Bleue

function X(a){for(l=a.match(/\d+/g),h=document,v=h.body.appendChild(h.createElement("canvas")),v.width=W=l[0],v.height=H=l[1],w=v.getContext("2d"),e=w.createImageData(W,H),d=e.data,N=W*H;N--;)for(i=2,c=N*4,d[c+3]=255;i<l.length;)for(x=N%W-l[i++],y=~~(N/W)-l[i++],k=l[i++],q=0;q<3;)d[c+q++]+=k*l[i++]/-~Math.sqrt(x*x+y*y);w.putImageData(e,0,0);}

var j = 0;
var renderFrame = function () {
  if(window.h && window.v){h.body.removeChild(v);} // clear prev frame
  X("225 150\n" +
    (70 + j) + " " + (120 - j) + " 170 135 56 0\n" + 
    j * 5 + " " + j * 3 + " 64 0 50 205");       
  if(++j < 50) { setTimeout(renderFrame, 1); } else { console.log('done!'); }
};
setTimeout(renderFrame, 10);

Vous pouvez également l'exécuter dans JSFiddle .

La description

Il s'agit d'une implémentation directe de canevas JavaScript + HTML5: une fonction qui prend un argument de chaîne (sans espaces de fin ni nouvelles lignes) et affiche la sortie dans le DOM. Il utilise la distance euclidienne.

Voici le code lisible:

X = function (str) {
  var lines = str.split("\n");  
  var canvas = document.createElement('canvas');
  var z = lines[0].split(u=' ');
  var width = z[0], height = z[1];

  canvas.width = width;
  canvas.height = height;
  document.body.appendChild(canvas);

  var ctx = canvas.getContext("2d");
  var imageData = ctx.createImageData(width, height);

  for(var y = 0; y < height; y++){
    for(var x=0; x < width; x++){
      var coord = (y * width + x) * 4;

      for(i=1; i < lines.length;i++){
        var t = lines[i].split(u);

        var 
          dx = x - t[0], 
          dy = y - t[1];

        var distance = Math.sqrt(dx * dx + dy * dy);

        for(var channel = 0; channel < 3; channel++) {
          var channelIndex = coord + channel;
          imageData.data[channelIndex] += t[2] * t[3 + channel] / (distance + 1);
        }
      }

      var alphaIndex = coord + 3;
      imageData.data[alphaIndex] = 255;
    }
  }

  ctx.putImageData(imageData, 0, 0);
};

Java - 627 octets

Java est en effet l’une des meilleures langues de golf :)

import java.awt.image.*;class M{void f(String n)throws Exception{String[]p=n.split("\n");int[]b=s(p[0]);BufferedImage o=new BufferedImage(b[0],b[1],2);for(int i=0;i<b[0];i++)for(int j=0;j<b[1];j++){int[]c=new int[3];for(int l=1;l<p.length;l++){int[]r=s(p[l]);for(int k=0;k<3;k++){c[k]+=r[2]*r[3+k]/(Math.sqrt(Math.pow(i-r[0],2)+Math.pow(j-r[1],2))+1);if(c[k]>255)c[k]=255;}}o.setRGB(i,j,new java.awt.Color(c[0],c[1],c[2]).getRGB());}javax.imageio.ImageIO.write(o,"png",new java.io.File("o.png"));}int[]s(String s){String[]a=s.split(" ");int[]r=new int[a.length];for(int i=0;i<a.length;i++)r[i]=Integer.valueOf(a[i]);return r;}}

En utilisant les informations ci-dessous, vous pouvez créer un modèle relativement réaliste de notre système solaire (la taille de certaines planètes est fausse, mais la distance qui les sépare doit être précise). J'ai essayé de donner des bagues à Saturne, mais ça n'a pas fonctionné ... Source

1950 50
-15 25 25 255 255 0
39 25 1 255 0 0
55 25 3 255 140 0
68 25 4 0 191 255
92 25 2 255 0 0
269 ​​25 10 245 222 179
475 25 7 245 245 220
942 25 6 0 250 150
1464 25 6 0 0 255
1920 25 1 255 245 238

Image Full HD , ce qui n’a pas l’air fantastique, serait heureux si quelqu'un pouvait l’améliorer!

Bash, 147 145 octets

ImageMagick est utilisé pour manipuler des images. La distance euclidienne est utilisée.

read w h
o=o.png
convert -size $w\x$h canvas:black $o
while read x y i r g b
do
convert $o -fx "u+$i*rgb($r,$g,$b)/(hypot(i-$x,j-$y)+1)" $o
done

Python 3, 189 octets

Je ne suis pas l'idée d'un golfeur expert, mais voilà.

• Entrée vient stdinet va stdoutdans le format PPM .
• Courez comme ça: python3 codegolf_stars_golfed.py < starfield.txt > starfield.pnm

Tout d'abord, distance de Manhattan:

import sys
(w,h),*S=[list(map(int,l.split()))for l in sys.stdin]
print('P3',w,h,255,*(min(int(sum((I*C[z%3]/(abs(X-z//3%h)+abs(Y-z//3//h)+1))for
X,Y,I,*C in S)),255)for z in range(h*w*3)))

Et deuxièmement, la distance euclidienne:

import sys
(w,h),*S=[list(map(int,l.split()))for l in sys.stdin]
print('P3',w,h,255,*(min(int(sum((I*C[z%3]/(abs(X-z//3%h+(Y-z//3//h)*1j)+1))for
X,Y,I,*C in S)),255)for z in range(h*w*3)))

Je pourrais économiser quatre octets en utilisant la division entière au lieu de int(), et en fait, cela semble être ce que font les images originales - vous pouvez à peine distinguer quelques stries dans les franges sombres de la lueur d'étoile qui ne sont pas présentes dans des conditions parfaitement correctes. code. En l'état actuel, ce code suit la description, pas les images.

La version non-golfée, et mon parcours de golf original avant les nombreuses optimisations que d'autres ont indiquées ou que je suis tombé sur moi-même, sont dans cette optique .

EDIT: j'ai enregistré 7 octets en déplaçant for xet for yen une seule print(ou o) fonction, mais cela produit un fichier PNM avec une très longue ligne, ce qui peut causer ou non des problèmes.

EDIT 2: Maltysen m'a sauvé 20 octets supplémentaires. Merci!

EDIT à nouveau: maintenant qu’il n’y en a plus qu’un print, le opseudonyme est un passif, pas une économie. 4 octets de plus.

EDIT encore: Sp3000 m'a sauvé 2 octets de plus. Pendant ce temps, le pseudonyme mapde mne sauvegardait rien, alors, dans un souci de lisibilité (!), Je l’ai développé à nouveau. C'est maintenant un joli tour 2 ⁸ octets.

EDIT the last (?): Maintenant, avec le support de distance euclidien - et en abusant de nombres complexes, je l’ai fait exactement avec le même nombre d’octets!

EDIT, le redémarrage d'Hollywood: la prochaine suggestion de Sp3000 supprimait 5 octets.

EDIT, la suite bêtement nommée: 6 octets supprimés, grâce à une suggestion de Maltysen que je n’ai pas saisie jusqu’à ce que Sp3000 le répète ... puis encore 8 octets d’ %abus. Et en parler en causant une phénoménale2126 octets. Je suis humble.

C ++, 272 octets

#include<png.hpp>
#define G(a)i>>C;for(x=0;x<w*h;++x){auto&p=img[x%h][x/h];c=p.a+I*C/(abs(x/h-X)+abs(x%h-Y)+1);p.a=c>255?255:c;}
auto&i=std::cin;main(){int w,h,x,X,Y,I,c,C;i>>w>>h;png::image<png::rgb_pixel>img(w,h);while(i>>X>>Y>>I){G(red)G(green)G(blue)}img.write("a");}

Nécessite un compilateur indulgent C ++ 11 (GCC 4.9.2 n’est que légèrement contrarié) et la bibliothèque png ++ , qui elle-même est nécessaire libpng. Manhattan distance utilisée. Accepte les entrées stdin, les sorties dans un fichier nommé "a" dans le répertoire actuel au format PNG.

Exemple D:

Python 2, 240 232 228 octets

from PIL.Image import*
def f(S):
 L=map(int,S.split());t=a,b=L[:2];I=new("RGB",t)
 for k in range(a*b):I.load()[k/a,k%a]=tuple(sum(x[2]*x[c]/(abs(x[0]-k/a)-~abs(x[1]-k%a))for x in zip(*[iter(L[2:])]*6))for c in(3,4,5))
 I.show()

Utilise la distance de Manhattan. Ce serait probablement encore plus court dans Python 3, mais j'ai récemment bousillé mes paquets Python et je ne parviens pas à réinstaller Pillow. La PPM serait probablement encore plus courte, mais j'aime bien la PIL.

Pour le plaisir, j'ai essayé d'appliquer l'algorithme tel quel dans l' espace colorimétrique L * a * b * , pensant qu'il donnerait un meilleur mélange des couleurs (en particulier dans l'exemple B). Malheureusement, l'algorithme de Calvin permet aux canaux de dépasser leurs valeurs maximales, ce qui rend les images un peu moins impressionnantes que je ne l'aurais espéré ...

Mathematica, 146 octets

Image@Table[Total[#3{##4}/255&@@@{##2}/(1+#~ManhattanDistance~{x,y}&/@({#1,#2}&@@@{##2}))],{y,0,Last@#-1},{x,0,#&@@#-1}]&@@#~ImportString~"Table"&

Une fonction pure prenant une chaîne. Pour l' exécuter dans un laps de temps raisonnable, remplacer 1dans 1+#~ManhattanDistance...un 1.; cela oblige le calcul numérique au lieu de symbolique.

Ungolfed:

Image[
    Table[
        Total[
        (#3 * {##4} / 255 & @@@ {##2})
            / (1 + ManhattanDistance[#, {x, y}]& /@ ({#1, #2}& @@@ {##2}) )
        ], {y, 0, Last[#]-1}, {x, 0, First[#]-1}
    ] (* Header is #, data is {##2} *)
]& @@ ImportString[#, "Table"]&

Python 2, 287 251 octets

Une version golfée du code original que j'ai utilisé pour générer les images. Pourrait probablement être joué un peu plus au golf (par un meilleur golfeur que moi). C'est une fonction qui prend toute la chaîne d'entrée. Traitement des images effectué avec le module d’image de PIL . Utilise la distance de Manhattan.

from PIL import Image
def S(I,r=range):
 I=map(int,I.split());w,h=I[:2];M=Image.new('RGB',(w,h));P=M.load()
 for z in r(w*h):
  P[z%w,z/w]=tuple(int(sum(I[i+2]*I[i+j+3]/(1.+abs(I[i]-z%w)+abs(I[i+1]-z/w))for i in r(2,len(I),6)))for j in r(3))
 M.show()

L'utilisation de la distance euclidienne est plus longue de 5 octets (256 octets):

from PIL import Image
def O(I,r=range):
 I=map(int,I.split());w,h=I[:2];M=Image.new('RGB',(w,h));P=M.load()
 for z in r(w*h):
  P[z%w,z/w]=tuple(int(sum(I[i+2]*I[i+j+3]/(1+((I[i]-z%w)**2+(I[i+1]-z/w)**2)**.5)for i in r(2,len(I),6)))for j in r(3))
 M.show()

Voici une suite de tests complète qui exécute les exemples A à E de la question, pour les deux métriques de distance:

from PIL import Image
def S(I,r=range):
 I=map(int,I.split());w,h=I[:2];M=Image.new('RGB',(w,h));P=M.load()
 for z in r(w*h):
  P[z%w,z/w]=tuple(int(sum(I[i+2]*I[i+j+3]/(1.+abs(I[i]-z%w)+abs(I[i+1]-z/w))for i in r(2,len(I),6)))for j in r(3))
 M.show()

def O(I,r=range):
 I=map(int,I.split());w,h=I[:2];M=Image.new('RGB',(w,h));P=M.load()
 for z in r(w*h):
  P[z%w,z/w]=tuple(int(sum(I[i+2]*I[i+j+3]/(1+((I[i]-z%w)**2+(I[i+1]-z/w)**2)**.5)for i in r(2,len(I),6)))for j in r(3))
 M.show()

A = """400 150
-10 30 100 255 128 0"""
B = """200 200
100 100 10 255 255 255
20 20 40 255 0 0
180 20 40 255 255 0
180 180 40 0 255 0
20 180 40 0 0 255"""
C = """400 400
123 231 10 206 119 85
358 316 27 170 47 99
95 317 3 202 42 78
251 269 17 142 150 153
43 120 3 145 75 61
109 376 6 230 231 52
331 78 21 31 81 126
150 330 21 8 142 23
69 155 11 142 251 199
218 335 7 183 248 241
204 237 13 112 253 34
342 89 18 140 11 123"""
D = """400 400
123 231 5 206 119 85
358 316 5 170 47 99
95 317 5 202 42 78
251 269 5 142 150 153
43 120 5 145 75 61
109 376 5 230 231 52
331 78 5 31 81 126
150 330 5 8 142 23
69 155 5 142 251 199
218 335 5 183 248 241
204 237 5 112 253 34
342 89 5 140 11 123"""
E = """100 1"""
for i in (A, B, C, D, E):
    S(i) #S for Star
    O(i) #O for Orb

Ils ont tous l'air indiscernables. Les plus gros peuvent prendre quelques secondes à courir.

C, 247 octets

Je ne vais pas gagner, mais j'aime jouer au golf en C. Aucune bibliothèque d'images externe utilisée, sorties sur stdout au format PPM. Prend une entrée sur stdin. Utilise la distance de Manhattan pour les golfeurs.

j,w,h,k,*b,t[6];main(){scanf("%d %d",&w,&h);b=calloc(w*h,24);for(;~scanf("%d",t+j++%6);)for(k=0;j%6?0:k<3*w*h;k++)b[k]=fmin(b[k]+t[2]*t[3+k%3]/(abs(k/3%w-*t)+abs(k/3/w-t[1])+1),255);printf("P6\n%d %d\n255\n",w,h);for(k=0;k<3*w*h;putchar(b[k++]));}

Voici la variante de distance euclidienne (257 octets):

j,w,h,k,*b,t[6];main(){scanf("%d %d",&w,&h);b=calloc(w*h,24);for(;~scanf("%d",t+j++%6);)for(k=0;j%6?0:k<3*w*h;k++)b[k]=fmin(b[k]+t[2]*t[3+k%3]/(sqrt(pow(k/3%w-*t,2)+pow(k/3/w-t[1],2))+1),255);printf("P6\n%d %d\n255\n",w,h);for(k=0;k<3*w*h;putchar(b[k++]));}

CJam, 86 octets

q~]"P3 "\_2>:T;2<_S*" 255 "@:,~\m*{(+0a3*T6/{_2<3$.-:z~+)d\2>(f*\f/.+}/:i255fe<\;S*S}/

Bien que cela puisse paraître long pour une langue de golf, je pense que parmi les solutions publiées jusqu'à présent, c'est la plus courte qui n'utilise pas la fonctionnalité de sortie d'image. Cela produit un fichier PPM sous forme ASCII. L'image ci-dessous a été convertie de PPM en PNG à l'aide de GIMP.

Je ne recommande pas d'exécuter le code dans l'interpréteur en ligne de CJam. Du moins pas pour les images en taille réelle. Mon navigateur est bloqué, probablement à cause de l'utilisation de la mémoire. Il complète les images 400x400 de la deuxième gamme avec la version hors connexion.

Explication:

q~      Read and parse input.
]       Wrap it in an array.
"P3 "   Output start of PPM header.
\       Swap input to top.
_2>     Slice off first two values, leaving the star descriptors.
:T;     Store star descriptors in variable T.
2<      Get first two values in input, which is the image size.
_S*     Leave a copy of the size in the output for the PPM header.
" 255 " Rest of PPM header, range of color values.
@       Pop sizes to top.
:,      Expand sizes to ranges.
~       Unwrap size ranges into separate stack elements.
\       Swap ranges, since we need x-range second for Cartesian product.
m*      Generate all coordinate pairs with Cartesian product.
{       Loop over pixel coordinate pairs.
  (+      Swap values in coordinate pair to get x-coordinate first again.
  0a3*    Generate [0 0 0] array. Will be used to sum up colors from stars.
  T       Get list of stars.
  6/      Split into sub-lists with 6 values for each star.
  {       Loop over the stars.
    _2<     Get the first two values (position) of the star.
    3$      Pull current pixel coordinates to top of stack.
    .-      Subtract pixel coordinates from star position.
    :z      Absolute value of difference.
    ~+      Unpack differences and add them to get Manhattan distance.
    )d      Add 1 and convert to double to get denominator of formula.
    \       Swap star values to top.
    2>      Slice off first two values, leaving intensity and color.
    (       Pop off intensity.
    f*      Multiply it with color values.
    \       Swap denominator to top.
    f/      Perform division of color components by denominator.
    .+      Add it to sum of colors.
  }/      End loop over stars.
  :i      Convert double values for colors to integer.
  255fe<  Cap color components at 255.
  \;      Swap pixel coordinate to top and pop it.
  S*S     Join color components with space, and add another space.
}/      End loop over coordinate pairs.

C # 718 octets

Je me rends compte que c # est terrible pour le golf, mais voici ma tentative de 718 octets

namespace System{using Collections.Generic;using Drawing;using Linq;using O=Convert;class P{int j,i;List<S> s=new List<S>();Image G(string t){var l=t.Replace("\r","").Split('\n');var w=O.ToInt32(l[0].Split(' ')[0]);var h=O.ToInt32(l[0].Split(' ')[1]);for(i=1;i < l.Length;i++){var p=l[i].Split(' ');s.Add(new S{X=O.ToInt32(p[0]),Y=O.ToInt32(p[1]),I=O.ToSingle(p[2]),R=O.ToByte(p[3]),G=O.ToByte(p[4]),B=O.ToByte(p[5])});}var b=new Bitmap(w,h);for(j=0;j<h;j++)for(i=0;i<w;i++)b.SetPixel(i,j,C());return b;}Color C(){return Color.FromArgb(X(x=>x.R),X(x=>x.G),X(x=>x.B));}int X(Func<S,float>f){return(int)Math.Min(s.Sum(x=>x.I*f(x)/(Math.Sqrt((x.X-i)*(x.X-i)+(x.Y-j)*(x.Y-j))+1)),255);}class S{public float X,Y,R,G,B,I;}}}

Si quelqu'un a des suggestions pour le raccourcir, n'hésitez pas à me le faire savoir.

Python, 259 octets

Finalement fait! Premier code de golf que j'ai essayé, j'ai décidé d'utiliser Python et je suis parti avec Manhattan. Shoutout à Maltysen pour m'avoir aidé avec les itérateurs, réduit la taille totale à près de la moitié!

from PIL.Image import new
N,*s=[list(map(int,i.split()))for i in iter(input,'')]
q,m=new("RGB",(N[0],N[1])),[]
[m.append(tuple(sum(k[2]*k[i]//(abs(k[1]-x)+abs(k[0]-y)+1)for k in s)for i in(3,4,5)))for x in range(N[1])for y in range(N[0])]
q.show(q.putdata(m))

CJam, 70 octets

"P3"l_~\:W*255\,[q~]6Te]6/f{\[Wmd\]f{.-Z/~\)\~mh)/f*}:.+{i255e<}/}~]S*

Distance euclidienne, sortie ASCII en PPM. Essayez-le en ligne

Il devrait être possible de compresser quelques octets supplémentaires, mais je ne veux pas passer trop de temps.