Das Problem:

Diese Herausforderung kommt von einem echten Problem, das ich hatte. Ich habe ein Dual-Monitor-Setup bei der Arbeit und wollte das folgende Bild als Hintergrundbild verwenden:

Meine Monitore haben jedoch ziemlich bedeutende Einfassungen, und wenn ich meinen Hintergrund einstelle, sieht es ungefähr so ​​aus, als ob der Pier (Appiers?) Gebrochen zu sein scheint:

Ich konnte dies lösen, indem ich ein Bild mit ausgeschnittener Mitte machte und es dann wieder auf die ursprüngliche Größe streckte, wie im Bild unten:

Die Herausforderung:

Schreiben Sie ein Programm, das ein Bild aufnimmt und es für die Verwendung mit einem Dual-Monitor-Setup "überwacht" (dh löscht den mittleren Bereich des Bildes, in dem sich die Rahmen befinden). Die Regeln lauten wie folgt:

1. Es muss ein vollständiges Programm sein, das das Bild entweder als Pfad (Zeichenfolgenargument usw.) oder in Form eines Dateiauswahldialogs akzeptiert.
2. Das Programm muss die Anzahl der vertikalen Linien (ein Pixel breit) als Eingabe verwenden, um aus der Bildmitte herauszuschneiden
3. Das Zuschneiden muss von der Mitte (in der Breite) des Originalbilds erfolgen
4. Das resultierende Bild muss auf die ursprüngliche Größe des Eingabebildes zurückskaliert werden. (Entweder können die Hälften einzeln skaliert und dann verkettet oder verkettet und dann skaliert werden. Die individuelle Skalierung erzeugt ein besseres Bild / einen besseren Effekt, ist jedoch in der realen Welt kaum wahrnehmbar.)
5. Hintergrundbilder sind im Allgemeinen gerade. Um diese Herausforderung zu vereinfachen, haben Eingabebilder nur eine gerade Anzahl von Pixeln und die Anzahl der zu entfernenden Zeilen ist ebenfalls gerade.
6. Diese Herausforderung ist Code Golf - der kürzeste Code in Bytes gewinnt

Viel Glück!

Oktave, 85 Bytes

@(f,n)imsave(imresize((o=imread(f))(:,[1:(end-n)/2,(end+n)/2:end],:),size(o)(1:2)),f)

Definiert eine anonyme Funktion mit fdem Dateinamen und nder Anzahl der zu entfernenden Spalten. Da für eine anonyme Funktion ein einzelner Ausdruck erforderlich ist, wird die Inline-Zuweisung verwendet, eine Funktion, die in MATLAB nicht vorhanden ist.

MATLAB, 98 Bytes

Als Bonus habe ich auch eine MATLAB-kompatible Antwort gespielt. Interessanterweise ist dies nur 13 Byte länger, da die Octave-Version viele Klammern benötigt, um die Inline-Zuweisungen korrekt zu analysieren.

function  m(f,n)
o=imread(f);imsave(imresize(o(:,[1:(end-n)/2,(end+n)/2:end],:),size(o(:,:,1))),f)

Matlab 2013, 150 Bytes

Hier ist mein Versuch in Matlab. Wird definitiv nicht der kürzeste Code sein, aber es ist ein Anfang.

Achtung, dies überschreibt das Originalbild. Erstellen Sie daher zuerst eine Kopie.

Golfversion

function  mi(f,n)
o=imread(f);
s=size(o);
imwrite([imresize(o(:,1:((s(2)-n)/2),:),[s(1),s(2)/2]) imresize(o(:,((s(2)+n)/2):end,:),[s(1),s(2)/2])], f);
end

Ungolfed Code mit Verbesserungen für ungerade Bildgrößen und ungerade Anzahl von Spalten

function  monitorizeImage( filename, num_columns )

orig = imread(filename);
orig_size = size(orig);

f = factor(orig_size(2));
origsize_iseven = f(1)==2;

f = factor(num_columns);
num_columns_iseven = f(1)==2;

odd_even_size_mismatch = xor(origsize_iseven,num_columns_iseven);

img_resized = imresize(orig,[orig_size(1) orig_size(2)+odd_even_size_mismatch]);

leftimg = img_resized(:,1:((orig_size(2)+odd_even_size_mismatch-num_columns)/2),:);
leftimg = imresize(leftimg,[orig_size(1),floor(orig_size(2)/2)]);
rightimg = img_resized(:,((orig_size(2)-odd_even_size_mismatch+num_columns)/2):end,:);
rightimg = imresize(rightimg,[orig_size(1),floor(orig_size(2)/2)]);

monitorized_image = [leftimg rightimg];
monitorized_image = imresize(monitorized_image,[orig_size(1),orig_size(2)+ ~origsize_iseven]);

[~, ~, ext] = fileparts(filename); 

imwrite(monitorized_image,strcat(filename(1:end-length(ext)),'_',num2str(num_columns),ext));

end

Wolfram Language, 134 , 127 , 119, 111 Byte

f[i_,c_]:=(d=ImageDimensions@i;ImageAssemble[ImageTake[i,a=All,#]&/@{{0,e=-#&@@d/2-c/2},{-e,a}}]~ImageResize~d)

Erstellt eine Funktion f, die ein Bild als erste Eingabe (als Symbol in Mathematica oder der Wolfram Cloud) und eine Ganzzahl als zweite Eingabe verwendet.

Ungolfed :

f[image_,columns_]:=(  (*Define Function*)
    d=ImageDimensions[image];  (*Get image dimensions*)
    e=d[[1]]/2+columns/2;  (*Add half the image width to half the number of removed columns*)
    ImageResize[ImageAssemble[Map[ImageTake[i,All,#]&,{{0,-e},{e,All}}]],d]  (*Map the function onto a list with the desired column ranges and merge and scale the resulting image*)
)

Technisch gesehen funktioniert es nicht richtig, wenn eine der Bildabmessungen 362.880 Pixel überschreitet, aber ich gehe davon aus, dass dies in Ordnung ist, da dies weit außerhalb des Bereichs des Problems (und einiger Computer) liegt. Fest!

PHP, 206 Bytes

($c=imagecopyresized)($t=imagecreatetruecolor($w=imagesx($s=imagecreatefrompng($argv[1])),$h=imagesy($s)),$s,0,0,0,0,$v=$w/2,$h,$x=$v-$argv[2]/2,$h);$c($t,$s,$v,0,$w-$x,0,$v,$h,$x,$h);imagepng($t,$argv[3]);

Es werden drei Befehlszeilenargumente verwendet: Name der Quelldatei, Anzahl der zu beschneidenden Zeilen und Zieldateiname. Laufen Sie mit-r .

Möglicherweise möchten Sie imagecopyresampledanstelle von imagecopyresized(+2 Byte) ein besseres Ergebnis erzielen.

ungolfed

$s=imagecreatefrompng($argv[1]);    # load source image
$w=imagesx($s);$h=imagesy($s);      # get image dimensions
$t=imagecreatetruecolor($w,$h);     # create target image
$v=$w/2;                            # $v = half width
$x=$v-$argv[2]/2;                   # $x = width of remaining halves
                                    # resize and copy halves:
imagecopyresized($t,$s, 0,0,    0,0,$v,$h,$x,$h);
imagecopyresized($t,$s,$v,0,$w-$x,0,$v,$h,$x,$h);
imagepng($t,$argv[3]);              # save target image

Ich könnte 9 weitere Bytes sparen, indem ich das PNG-Ergebnis an STDOUT sende ... aber wozu?