Creare un programma o una funzione che accetta il nome del file come argomento o lo legge dall'input standard e completa la seguente attività:

1. Leggi l'immagine da un file png (nome dato come argomento).
2. Inverti i colori in quell'immagine, in modo che ad esempio il verde scuro (0, 75, 30) diventi (255, 180, 225) (perché 255-0 = 255, 255-75 = 180 e 255-30 = 225). Non modificare il valore del canale alfa.
3. Invia quell'immagine su un file chiamato a.png(in formato png), oppure mostralo nella finestra della GUI.

Questo è code-golf . Si applicano scappatoie standard.

ImageMagick display -fx, 3 7 18 24 byte

1-u

Lo strumento ImageMagick displaycon il fxparametro può applicare il programma sopra a un png dato come parametro e visualizzare i risultati sullo schermo.

Dai un'occhiata al mio post su meta su ImageMagick come linguaggio di programmazione. Ho scritto un tester principale laggiù come prova del concetto.

Il conteggio dei byte, display -fx code filenameequivale a perl -e code filename, dove tradizionalmente contiamo solo codeper la lunghezza.

Pyth, 16 15 13 byte

.w-LLL255'z\a

Uscite a 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

Grazie a Jakube per 2 byte!

MATL , 10 byte

255iYi-IYG

Esistono cinque sottostrati diversi di PNG, a seconda di come viene codificato il colore. Nessuno di loro sembra essere più "facoltativo" degli altri. Ho scelto quello più flessibile Truecolor, in cui ogni pixel può avere un colore arbitrario. Supporta anche il codice sopra Truecolor with alpha, ignorando il canale alfa.

Per conoscere il sottomaschera colore di un file PNG: cercare la sequenza di byte [73 72 68 82]vicino all'inizio del file; e il decimo byte da lì avrà uno dei cinque valori nella tabella collegata sopra .

Come funziona il codice

Abbastanza diretto:

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

Esempio

Non ho resistito a vedermi invertito, quindi ho scaricato questa immagine (che è in sottomaschera Truecolor with alpha), ho eseguito il codice (la seconda riga è l'input dell'utente)

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

e ottenuto

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 byte

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()

Legge nel nome del file tramite 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.

Esempio di input / output usando il primo png che ho trovato su questo computer :)

CSS, 19 byte

*{filter:invert(1)}

http://output.jsbin.com/suqayudoyu

Tcl, 176 byte

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

Carica il PNG tramite il phototipo di immagine, ottiene i dati dell'immagine, convertendo ogni riga e colore sottraendo da #FFFFFF, quindi riscrive il file sul disco (come "a.png").

Per risultati ottimali, utilizzare i PNG TrueColor, poiché Tk tenterà di utilizzare la stessa risoluzione del colore dei dati dell'immagine di origine.

Per vedere l'immagine senza problemi di campionamento, aggiungi

pack [label .i -image image1]

all'estremità. (Ovviamente, questo è più lungo dell'opzione di salvataggio del disco.)

Mathematica, 140 byte

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

cmd + IrfanView, 19 caratteri

i_view32 %1 /invert

Proprio la costosa alternativa di Sparr 's risposta .

Julia, 94 79 byte

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

Questo è un programma completo che accetta un nome file come argomento della riga di comando e sovrascrive il file specificato con l'immagine invertita. Richiede l' installazione del pacchetto FileIOe Image. Tuttavia, non è necessario importare quest'ultimo.

Chiama il programma dalla riga di comando come julia filename.jl /path/to/image.png.

Ungolfed:

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)

Esempio:

Python + PIL, 85 byte

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

Questo definisce una funzione anonima che accetta un nome file come stringa e in cui salva l'immagine risultante a.png.

Prova:

C + stb_image + stb_image_write, 175 162 byte (o + 72 =247 234)

La mia prima presentazione su questo sito in assoluto.

#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);}

Probabilmente potrebbe radere qualche byte. È necessario che l' stb_*implementazione si trovi in ​​una libreria separata o all'inizio di questo file con:

#define STB_IMAGE_IMPLEMENTATION
#define STB_IMAGE_WRITE_IMPLEMENTATION

Non l'ho incluso nel conteggio perché è essenzialmente parte della libreria (specialmente se è compilato separatamente). +72 byte da aggiungere se necessario, tuttavia.

Aggiornamento 1:

Realizzata solo una funzione (al contrario di un intero programma) è accettabile, radendo via 15 byte. La vecchia implementazione (che è un intero programma), per riferimento:

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 byte

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 byte

Codice:

imshow(imcomplement(imread(x)))

Esempio:

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

Spiegazione:

Leggi l'immagine, xda un file grafico, completa l'immagine e quindi visualizza l'immagine.

FFmpeg, 10 byte

Modifica: prendendo spunto dalla risposta di @ Sparr

-vf negate

(quanto sopra quando passato a ffplay insieme al nome dell'immagine, visualizzerà l'immagine negata)

ffplay %1 -vf negate

Quanto sopra viene salvato come file batch.

Racchetta 282 byte

(λ(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))

Modulo più leggibile:

(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))

Uso:

(f "myimg.png")

Golang, 311 byte

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)}

ungolfed

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 byte

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

La libreria OpenCV utilizza array NumPy per leggere, elaborare e scrivere immagini. Di seguito è riportato un esempio di questo script che inverte un'immagine trovata su mozilla.org .

Tutti i canali, incluso il canale alfa, saranno invertiti. Questo è problematico per le immagini che hanno trasparenza. Ma come ha sottolineato @Mego, il supporto per il canale alfa è facoltativo.

Di seguito è riportata una versione commentata di 82 byte che la proprietà gestisce il canale alfa.

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

Come mostrato di seguito, questo gestisce correttamente l'inversione del logo Firefox preservando lo sfondo trasparente.