Créez un programme ou une fonction qui prend le nom de fichier comme argument ou le lit à partir de l'entrée standard et termine la tâche suivante:

1. Lire l'image à partir d'un fichier png (nom donné en argument).
2. Inversez les couleurs dans cette image, de sorte que par exemple le vert foncé (0, 75, 30) deviendrait (255, 180, 225) (car 255-0 = 255, 255-75 = 180 et 255-30 = 225). Vous ne devez pas modifier la valeur du canal alpha.
3. Exportez cette image dans un fichier appelé a.png(au format png) ou affichez-la dans la fenêtre GUI.

C'est du code-golf . Des échappatoires standard s'appliquent.

ImageMagick display -fx, 3 7 18 24 octets

1-u

L'outil ImageMagick displayavec le fxparamètre peut appliquer le programme ci-dessus à un png donné comme paramètre et afficher les résultats à l'écran.

Consultez mon post sur meta sur ImageMagick en tant que langage de programmation. J'ai écrit un testeur principal là-bas comme preuve de concept.

Le comptage des octets display -fx code filenameest équivalent à perl -e code filename, où nous comptons traditionnellement juste codepour la longueur.

Pyth, 16 15 13 octets

.w-LLL255'z\a

Sorties vers a.png.

          z    read input
         '     read as RGB triples from file
   LLL         map over rows, then triples, then individual values...
  -   255      ...subtract from 255
.w         \a  write as image to a.png

Merci à Jakube pour 2 octets!

MATL , 10 octets

255iYi-IYG

Il existe cinq sous - formats différents de PNG, selon la façon dont la couleur est codée. Aucun d'eux ne semble plus "facultatif" que les autres. J'ai choisi le plus flexible Truecolor, dans lequel chaque pixel peut avoir une couleur arbitraire. Le code ci-dessus prend également en charge Truecolor with alpha, en ignorant le canal alpha.

Pour connaître le sous-format de couleur d'un fichier PNG: recherchez la séquence d'octets [73 72 68 82]près du début du fichier; et le dixième octet à partir de là aura l'une des cinq valeurs du tableau lié ci-dessus .

Comment fonctionne le code

Assez simple:

255    % push 255 to the stack
i      % input filename with extension '.png'
Yi     % read contents of that file as (truecolor) image
-      % subtract
IYG    % show image

Exemple

Je n'ai pas pu résister à me voir inversé, j'ai donc téléchargé cette image (qui est en sous-format Truecolor with alpha), j'ai exécuté le code (la deuxième ligne est entrée par l'utilisateur)

>> matl 255iYi-IYG
> 'C:\Users\Luis\Desktop\me.png'

et j'ai

Java, 295

import javax.imageio.*;class V{public static void main(String[]a)throws
Exception{java.awt.image.BufferedImage m=ImageIO.read(new
java.io.File(a[0]));for(int
x=m.getWidth(),y;x-->0;)for(y=m.getHeight();y-->0;)m.setRGB(x,y,m.getRGB(x,y)^-1>>>8);ImageIO.write(m,"png",new
java.io.File("a.png"));}}

R, 124 octets

p=png::readPNG(readline());p[,,-4]=1-p[,,-4];png("a.png",h=nrow(p),w=ncol(p));par(mar=rep(0,4));plot(as.raster(p));dev.off()

Lit le nom du fichier via stdin ( readline()).

p=png::readPNG(readline()) #Reads in png as an RGBA array on range [0,1]
p[,,-4]=1-p[,,-4] #Takes the opposite value except on alpha layer
png("a.png",h=nrow(p),w=ncol(p)) #Prepares output png of same size as input
par(mar=rep(0,4)) #Makes the png take the full space of the figure region
plot(as.raster(p)) #Transforms p as a raster so that it can be plotted as is.
dev.off() #Closes the plotting device.

Exemple d'entrée / sortie utilisant le premier png que j'ai trouvé sur cet ordinateur :)

CSS, 19 octets

*{filter:invert(1)}

http://output.jsbin.com/suqayudoyu

Tcl, 176 octets

foreach r [[image c photo -file {*}$argv] d] {set x {}
foreach c $r {lappend x [format #%06X [expr "0xFFFFFF-0x[string ra $c 1 end]"]]}
lappend y $x}
image1 p $y
image1 w a.png

Charge le PNG via le photo type d'image, obtient les données d'image, convertit chaque ligne et couleur en soustrayant de #FFFFFF, puis réécrit le fichier sur le disque (sous la forme "a.png").

Pour de meilleurs résultats, utilisez des PNG TrueColor, car Tk essaiera d'utiliser la même résolution de couleur que les données d'image source.

Pour voir l'image sans problèmes d'échantillonnage, ajoutez

pack [label .i -image image1]

jusqu'à la fin. (Évidemment, c'est plus long que l'option de sauvegarde sur disque.)

Mathematica, 140 octets

Export["a.png",SetAlphaChannel[ColorCombine[Most@#],Last@#]&@MapAt[Image[1-ImageData@#]&,ColorSeparate[Import[#],{"R","G","B","A"}],{;;3}]]&

cmd + IrfanView, 19 caractères

i_view32 %1 /invert

Juste l'alternative coûteuse de la réponse de Sparr .

Julia, 94 79 octets

using FileIO
save(ARGS[1],map(x->typeof(x)(1-x.r,1-x.g,1-x.b,1),load(ARGS[1])))

Il s'agit d'un programme complet qui prend un nom de fichier comme argument de ligne de commande et écrase le fichier donné avec l'image inversée. Il nécessite que le package FileIOet Imagesoient installés. Ce dernier n'a cependant pas besoin d'être importé.

Appelez le programme à partir de la ligne de commande comme julia filename.jl /path/to/image.png .

Non golfé:

using FileIO # required for reading and writing image files

# Load the given image into a matrix where each element is an RGBA value
a = load(ARGS[1])

# Construct a new image matrix as the inverse of `a` by, for each element
# `x` in `a`, constructing a new RGBA value as 1 - the RGB portions of
# `x`, but with an alpha of 1 to avoid transparency.
b = map(x -> typeof(x)(1 - x.r, 1 - x.g, 1 - x.b, 1), a)

# Save the image using the same filename
save(ARGS[1], b)

Exemple:

Python + PIL, 85 octets

from PIL import Image
lambda a:Image.eval(Image.open(a),lambda x:255-x).save('a.png')

Cela définit une fonction anonyme qui prend un nom de fichier sous forme de chaîne et enregistre l'image résultante dans a.png.

Essai:

C + stb_image + stb_image_write, 175 162 octets (ou + 72 =247 234)

Ma première soumission sur ce site.

#include"stb_image.h"
#include"stb_image_write.h"
x,y,c,i;f(char*d){d=stbi_load(d,&x,&y,&c,i=0);for(;i<x*y*c;i++)d[i]=255-d[i];stbi_write_png("a.png",x,y,c,d,0);}

Pourrait probablement raser quelques octets. Nécessite la stb_*mise en œuvre soit dans une bibliothèque distincte, soit au début de ce fichier avec:

#define STB_IMAGE_IMPLEMENTATION
#define STB_IMAGE_WRITE_IMPLEMENTATION

Je ne l'ai pas inclus dans le décompte car il fait essentiellement partie de la bibliothèque (surtout s'il est compilé séparément). +72 octets pour ajouter cela si nécessaire, cependant.

Mise à jour 1:

Réalisé que seule une fonction (par opposition à un programme entier) est acceptable, rasant 15 octets. L' ancienne implémentation (qui est un programme entier), pour référence:

x,y,i;main(int c,char**d){*d=stbi_load(d[1],&x,&y,&c,0);for(;i<x*y*c;i++)i[*d]=255-i[*d];stbi_write_png("a.png",x,y,c,*d,0);}

Java, 300 298 octets

import javax.swing.*;void c(String f)throws Exception{java.awt.image.BufferedImage r=javax.imageio.ImageIO.read(new java.io.File(f));for(int i=0;i++<r.getWidth();)for(int j=0;j++<r.getHeight();)r.setRGB(i,j,(0xFFFFFF-r.getRGB(i,j))|0xFF000000);JOptionPane.showMessageDialog(null,new ImageIcon(r));}

MATLAB / Octave, 31 octets

Code:

imshow(imcomplement(imread(x)))

Exemple:

imshow(imcomplement(imread('balloons.png')))

Explication:

Lisez l'image, à xpartir d'un fichier graphique, complétez l'image, puis affichez l'image.

FFmpeg, 10 octets

Edit: S'inspirant de la réponse de @ Sparr

-vf negate

(ce qui précède lorsqu'il est passé à ffplay avec le nom de l'image, affichera l'image annulée)

ffplay %1 -vf negate

Ce qui précède est enregistré en tant que fichier de commandes.

Raquette 282 octets

(λ(fname)(let*((i(make-object bitmap% fname))(w(send i get-width))(h(send i get-height))(pixels(make-bytes(* w h 4)))(i2(make-object bitmap% w h)))
(send i get-argb-pixels 0 0 w h pixels)(send i2 set-argb-pixels 0 0 w h(list->bytes(map(lambda(x)(- 255 x))(bytes->list pixels))))i2))

Forme plus lisible:

(define(f fname)
  (let*(
        (i (make-object bitmap% fname))
        (w (send i get-width))
        (h (send i get-height))
        (pixels (make-bytes(* w h 4)))
        (i2 (make-object bitmap% w h)))
    (send i get-argb-pixels 0 0 w h pixels)
    (send i2 set-argb-pixels 0 0 w h
          (list->bytes
           (map
            (lambda(x) (- 255 x))
            (bytes->list pixels))))
    i2))

Usage:

(f "myimg.png")

Golang, 311 octets

package main
import("image"
."image/png"
."image/color"
."os")
func main(){f,_:=Open(Args[1])
i,_:=Decode(f)
q:=i.Bounds()
n:=image.NewRGBA(q)
s:=q.Size()
for x:=0;x<s.X;x++{for y:=0;y<s.Y;y++{r,g,b,a:=i.At(x,y).RGBA()
n.Set(x,y,RGBA{byte(255-r),byte(255-g),byte(255-b),byte(a)})}}
o,_:=Create("o")
Encode(o,n)}

non golfé

package main
import(
    "image"
    "image/png"
    "image/color"
    "os"
)

func main(){
    // open a png image.
    f, _ := os.Open(Args[1])

    // decode the png image to a positive image object(PIO).
    p, _ := png.Decode(f)

    // get a rectangle from the PIO.
    q := p.Bounds()

    // create a negative image object(NIO).
    n := image.NewRGBA(q)

    // get the size of the PIO.
    s := q.Size()

    // invert the PIO.
    for x := 0; x < s.X; x++ {
        for y := 0; y < s.Y; y++ {
            // fetch the value of a pixel from the POI.
            r, g, b, a := p.At(x, y).RGBA()

            // set the value of an inverted pixel to the NIO.
            // Note: byte is an alias for uint8 in Golang.
            n.Set(x, y, color.RGBA{uint8(255-r), uint8(255-g), uint8(255-b), uint8(a)})
        }
    }

    // create an output file.
    o, _ := os.Create("out.png")


    // output a png image from the NIO.
    png.Encode(o, n)
}

Python 2 + OpenCV , 55 octets

import cv2
cv2.imwrite('a.png',255-cv2.imread(input()))

La bibliothèque OpenCV utilise des tableaux NumPy pour lire, traiter et écrire des images. Voici un exemple de ce script inversant une image trouvée sur mozilla.org .

Tous les canaux, y compris le canal alpha, seront inversés. Cela pose problème pour les images transparentes. Mais comme @Mego l'a souligné, la prise en charge du canal alpha est facultative.

Voici une version commentée de 82 octets dont la propriété gère le canal alpha.

import cv2                # import OpenCV library
i=cv2.imread(input(),-1)  # image file name is specified from stdin
                          # read with the IMREAD_UNCHANGED option
                          # to preserve transparency
i[:,:,:3]=255-i[:,:,:3]   # invert R,G,B channels
cv2.imwrite('a.png',i)    # output to a file named a.png

Comme indiqué ci-dessous, cela gère correctement l'inversion du logo Firefox tout en préservant l'arrière-plan transparent.