Le problème:

Ce défi vient d'un vrai problème que j'avais. J'ai une configuration à double moniteur au travail et je voulais utiliser l'image suivante comme fond d'écran:

Cependant, mes moniteurs ont des lunettes assez importantes, et quand je règle mon arrière-plan, cela ressemble à ceci, où la jetée semble (appiers?) Être cassée:

J'ai pu résoudre ce problème en créant une image avec le centre découpé, puis en l'étirant à sa taille d'origine, comme dans l'image ci-dessous:

Le défi:

Écrivez un programme qui prend une image et la «surveille» pour l'utiliser avec une configuration à deux moniteurs (c'est-à-dire supprime la section centrale de l'image, où se trouvent les lunettes). Les règles sont les suivantes:

1. Il doit s'agir d'un programme complet qui accepte l'image, soit en tant que chemin (argument chaîne, etc.), soit sous la forme d'une boîte de dialogue de sélection de fichier.
2. Le programme doit prendre en entrée le nombre de lignes verticales (un pixel de largeur) à recadrer à partir du centre de l'image
3. Le recadrage doit provenir du centre (dans le sens de la largeur) de l'image originale
4. L'image résultante doit être redimensionnée à la taille d'origine de l'image d'entrée. (Les moitiés peuvent être mises à l'échelle individuellement, puis concaténées, ou concaténées puis mises à l'échelle. La mise à l'échelle individuelle produit une meilleure image / effet, mais est à peine perceptible dans le monde réel)
5. Les images d'arrière-plan sont généralement égales, donc pour faciliter ce défi, les images d'entrée n'auront qu'un nombre pair de pixels et le nombre de lignes à supprimer ne sera que pair.
6. Ce défi est le golf de code - le code le plus court en octets gagne

Bonne chance!

Octave, 85 octets

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

Définit une fonction anonyme avec fle nom de fichier et nle nombre de colonnes à supprimer. Puisqu'une fonction anonyme nécessite une seule expression, l'affectation en ligne est utilisée, une fonctionnalité non présente dans MATLAB.

MATLAB, 98 octets

En prime, j'ai également joué une réponse compatible MATLAB. Fait intéressant, cela ne fait que 13 octets de plus, car la version Octave a besoin de beaucoup de parenthèses pour analyser correctement les affectations en ligne.

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 octets

Voici ma tentative en Matlab. Ce ne sera certainement pas le code le plus court, mais c'est un début.

Attention, cela écrase l'image d'origine, donc faites d'abord une copie.

Version golfée

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

Code non golfé, avec des améliorations pour les tailles d'image impaires et le nombre impair de colonnes

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

Langue Wolfram, 134 , 127 , 119 111 octets

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

Crée une fonction fqui prend une image comme première entrée (comme symbole dans Mathematica ou Wolfram Cloud) et un entier comme deuxième entrée.

Non golfé :

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

Techniquement, cela ne fonctionnera pas correctement si l'une des dimensions de l'image dépasse 362 880 pixels, mais je suppose que c'est correct, car c'est bien en dehors de la portée du problème (et de certains ordinateurs). Fixé!

PHP, 206 octets

($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]);

prend trois arguments de ligne de commande: nom du fichier source, nombre de lignes à rogner et nom du fichier cible. Courez avec -r.

Vous voudrez peut-être utiliser à la imagecopyresampledplace de imagecopyresized(+2 octets) pour un meilleur résultat.

non golfé

$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

Je pourrais économiser 9 octets de plus en envoyant le résultat PNG à STDOUT ... mais pour quoi faire?