"मॉनिटर" एक छवि

Question

समस्या:

यह चुनौती एक वास्तविक समस्या से आती है जो मैं कर रहा था। मेरे पास काम पर एक दोहरी मॉनिटर सेटअप है, और मैं अपने वॉलपेपर के रूप में निम्न छवि का उपयोग करना चाहता था:

हालांकि, मेरे मॉनिटर में काफी महत्वपूर्ण bezels हैं, और जब मैं अपनी पृष्ठभूमि सेट करता हूं, तो यह कुछ ऐसा दिखता है, जहां घाट (ऐपियर?) को तोड़ा जाना है:?

मैं इसे केंद्र से कटने के साथ एक छवि बनाकर हल करने में सक्षम था, और फिर इसे मूल आकार में वापस खींच रहा था, जैसा कि नीचे की छवि में है:

---

चुनौती:

एक प्रोग्राम लिखें जो एक छवि में लेता है और एक दोहरी मॉनिटर सेटअप के साथ उपयोग के लिए इसे "मॉनिटर करता है" (यानी छवि के केंद्र अनुभाग को हटा देता है, जहां बेज़ेल्स हैं)। नियम इस प्रकार हैं:

1. यह एक पूर्ण कार्यक्रम होना चाहिए जो छवि को स्वीकार करता है, या तो एक पथ (स्ट्रिंग तर्क, आदि) के रूप में, या फ़ाइल चयनकर्ता संवाद के रूप में।
2. छवि के केंद्र से बाहर फसल के लिए कार्यक्रम को एक ऊर्ध्वाधर रेखाओं (चौड़ाई में एक पिक्सेल) की संख्या के रूप में लेना चाहिए
3. क्रॉपिंग को मूल छवि के केंद्र (चौड़ाई-वार) से आना चाहिए
4. परिणामी छवि को इनपुट छवि के मूल आकार में फिर से स्केल किया जाना चाहिए। (या तो हिस्सों को व्यक्तिगत रूप से बढ़ाया जा सकता है, और फिर संक्षिप्त, या संक्षिप्त और फिर स्केल किया जा सकता है। व्यक्तिगत रूप से स्केलिंग एक बेहतर छवि / प्रभाव पैदा करता है, लेकिन वास्तविक दुनिया में शायद ही ध्यान देने योग्य है)
5. पृष्ठभूमि छवियां आम तौर पर भी होती हैं, इसलिए इस चुनौती को आसान बनाने के लिए, इनपुट छवियों में केवल समान संख्या में पिक्सेल होंगे, और निकालने के लिए लाइनों की संख्या केवल और भी होगी।
6. यह चुनौती कोड गोल्फ है - बाइट्स जीत में सबसे छोटा कोड

शुभ लाभ!

Comments

1. यह तस्वीरों से बहुत स्पष्ट नहीं है कि ऑपरेशन क्या है, क्योंकि वे एक ही चौड़ाई में स्केल किए गए हैं। शायद पहले और आखिरी वाले चित्रों को बदल दें जो मध्य आकार के समान हैं और सफेद के साथ गद्देदार हैं? 2. क्या हम rescaling के किसी भी रूप का उपयोग कर सकते हैं (रैखिक शायद सबसे सस्ता है) या क्या यह एक विशिष्ट होना चाहिए (जैसे घन, सिनैक, आदि)?

— पीटर टेलर

@PeterTaylor नियम 3 के अनुसार, इनपुट और आउटपुट छवियों को समान चौड़ाई माना जाता है। या तो प्रत्येक आधे को आधा मूल चौड़ाई में बदल दिया जाता है, और फिर संक्षिप्त किया जाता है, या फसली हिस्सों को संक्षिप्त किया जाता है, फिर मूल आकार में वापस स्केल किया जाता है। और हां, कोई भी स्केलिंग ठीक है।

— dberm22

"शायद" वाक्य की शुरुआत इस बात का सुझाव थी कि सवाल को समझने में आसान कैसे बनाया जाए, चुनौती की व्याख्या नहीं की गई। मैंने खुद बदलाव किया है।

— पीटर टेलर

@PeterTaylor आह, मुझे लगता है, यह स्पष्ट करता है। धन्यवाद।

— dberm22

क्या हम मान सकते हैं कि छवि परिदृश्य उन्मुख होगी?

— स्कॉट मिलनर

Answer 1

ऑक्टेव, 85 बाइट्स

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

fफ़ाइल नाम, और nहटाने के लिए स्तंभों की संख्या के साथ एक अनाम फ़ंक्शन को परिभाषित करता है । चूंकि एक अनाम फ़ंक्शन को एकल अभिव्यक्ति की आवश्यकता होती है, इनलाइन असाइनमेंट का उपयोग किया जाता है, MATLAB में मौजूद नहीं है।

MATLAB, 98 बाइट्स

एक बोनस के रूप में, मैंने MATLAB संगत जवाब भी दिया। दिलचस्प बात यह है कि यह केवल 13 बाइट्स लंबा है, क्योंकि ऑक्टेव संस्करण को इनलाइन असाइनमेंट को सही ढंग से पार्स करने के लिए बहुत सारे कोष्ठकों की आवश्यकता होती है।

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

Answer 2

मतलाब 2013, 150 बाइट्स

यहां मतलब में मेरी कोशिश है। निश्चित रूप से सबसे छोटा कोड नहीं होगा, लेकिन यह एक शुरुआत है।

चेतावनी, यह मूल छवि को अधिलेखित करता है, इसलिए पहले एक प्रतिलिपि बनाएँ।

गोल्फ संस्करण

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

---

असंबद्ध कोड, विषम छवि आकार और स्तंभों की विषम संख्या में सुधार के साथ

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

Comments

बस इसे जोड़ना: चुनौतियों का जवाब दिए गए स्कोरिंग मानदंड के अनुकूलन पर एक गंभीर प्रयास करना चाहिए। इस तरह की एक कोड-गोल्फ चुनौती में, इसका मतलब है कि कोड की लंबाई को कम करने वाले किसी भी स्पष्ट सुधार को किया जाना चाहिए।

अप्रयुक्त स्थानों और व्हाट्सएप को हटाने का प्रयास करें।

— dkudriavtsev

@ ais523 धन्यवाद डाउन टू 220 बाइट्स!

— dberm22

इसके अलावा, प्रत्येक दो-बाइट चर एक बहुत अधिक है। पठनीयता महत्वपूर्ण नहीं है, इसलिए osवर्णमाला के किसी भी अन्य अक्षर में रिफ्लेक्टर आदि! और क्यों न केवल fपूरी छवि को सहेजने के लिए छवि को वापस इनपुट छवि पर लिखें strcat? (जो संयोग से, आप ['',...]इसके बजाय बदल सकते हैं strcat(...))

— Sanchises

@ सेंचुरीज़ थैंक्स, जो अनलॉक्ड / इम्प्रूव्ड वर्जन से बचे हुए थे। नियमों में कुछ भी नहीं कहा गया है कि यह अधिलेखित नहीं हो सकता है, या बहुत नामांकित आउटपुट के लिए आवश्यक है। धन्यवाद ... कि 70 बाइट्स से बाइट की संख्या घट गई!

— dberm22

Answer 3

वोल्फ्राम लैंग्वेज, 134 , 127 , 119 111 बाइट्स

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

एक फ़ंक्शन बनाता है fजो पहले इनपुट के रूप में एक छवि लेता है (गणितज्ञ या वोल्फ्राम क्लाउड में प्रतीक के रूप में), और दूसरा इनपुट के रूप में एक पूर्णांक।

अधूरा :

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

तकनीकी रूप से, यह ठीक से काम नहीं करेगा यदि दोनों में से कोई भी छवि आयाम 362,880 पिक्सल से अधिक हो, लेकिन मुझे लगता है कि यह ठीक है, क्योंकि यह समस्या के दायरे से बाहर है (और कुछ कंप्यूटर)। फिक्स्ड!

Answer 4

PHP, 206 बाइट्स

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

तीन कमांड लाइन तर्क लेता है: स्रोत फ़ाइल नाम, फसल की लाइनों की संख्या और फ़ाइल नाम लक्षित करें। के साथ भागो -r।

आप उपयोग कर सकते हैं imagecopyresampledके बजाय imagecopyresizedबेहतर परिणाम के लिए (+2 बाइट्स)।

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

मैं PND परिणाम STDOUT को भेजकर 9 और बाइट्स बचा सकता था ... लेकिन किस लिए?

Comments

"मैं PND परिणाम STDOUT को भेजकर 9 और बाइट्स बचा सकता हूं ... लेकिन किस लिए?" तब आप कुछ इस तरह चला सकते हैं php -r image.php image.png 1 > output.png, है ना?

— ।