मैं पर्ल में छवि :: मैजिक के साथ एक विशिष्ट पिक्सेल के आरजीबी मूल्य को कैसे बढ़ा सकता हूं?

Question

मैं 1 पिक्सेल (x=3, y=3) हो और अपने आरजीबी मूल्यों (आर 100 से 101 को, जी 99 से 100 को, बी 193 से 194 करने के लिए) को बदलने चाहते हैं।

use strict; 
use Image::Magick; 
my $p = new Image::Magick; 
    $p->Read('myfile.jpg'); 

    my $pix = $p->GetPixel(
      width  => 1, 
      height => 1, 
      x   => 3, 
      y   => 3, 
      map  => 'RGB', 
      normalize => 0 
     ); 

    # in $pix RGB value now? 

कैसे मैं सभी आरजीबी घटकों के लिए 1 जोड़ने करते हैं?

क्या मैं दशमलव आरजीबी को 3 मानों (आर, जी, बी) में विभाजित कर सकता हूं और अलग से वृद्धि कर सकता हूं और फिर तीन आर, जी, बी मानों को एक आरजीबी में विलय कर सकता हूं? :) मैं उसको कैसे करू?

$pix = .... something code here... 

    # make changes 
    $p->SetPixel(
      x  => 3, 
      y  => 3, 
      channel => 'RGB', 
      color => [ $pix ] 
     ); 
    $p->Write ('my_new_file.jpg'); 

Answer 1

यह पता लगाने में थोड़ा मुश्किल था, लेकिन यहां हम जाते हैं। मैं आपको दिखाऊंगा कि परिणाम के लिए मैंने क्या किया, न कि यह कैसे काम करता है।

मैं एक छोटी छवि का उपयोग कर रहा हूं जिसमें आपका प्रारंभिक रंग (100, 99, 193) है।

मेरा कार्यक्रम के शीर्ष पर मैं हमेशा इस कोड होगा।

use strict; 
use warnings; 
use Data::Printer; 
use Image::Magick; 
my $p = new Image::Magick; 
$p->Read('33141038.jpg'); 

my @pixel = $p->GetPixel(
    x   => 1, 
    y   => 1, 
    map  => 'RGB', 
    normalize => 1, 
); 

मैंने the documentation at imagemagick.org. चेक किया। यह Image::Magick on CPAN में जुड़ा हुआ है। वहां मैंने GetPixel खोजा। इससे दो उपयोगी चीजें मिलती हैं। एक स्पष्टीकरण है, दूसरा an example जो दिखाता है कि एक सरणी @pixel लौटा दी गई है, और आपके द्वारा प्रयास की जाने वाली स्केलर नहीं है।

यहाँ हम आधे से (1,1) में लाल घटक की तीव्रता को कम:

@pixels = $image->GetPixel(x=>1,y=>1); 

ठीक है। चलिए इसका इस्तेमाल करते हैं। मुझे पहले से ही मेरे कोड में @pixel मिल गया है। ध्यान दें कि मैंने normalize विकल्प भी चालू कर दिया है। आप इसे डिफ़ॉल्ट रूप से चालू कर सकते हैं।

p @pixel; 

# [ 
#  [0] 0.392156862745098, 
#  [1] 0.388235294117647, 
#  [2] 0.756862745098039 
# ] 

तो वे फ्लोट हैं। कुछ googling के बाद मुझे this answer मिला, जो कुछ इसी तरह से संबंधित है। यह 255 के अंश की तरह दिखता है। चलो गुणा करें। हम पोस्टफिक्स foreach में $_ को असाइन करके @pixel में चीजों को संशोधित कर सकते हैं। काफी अच्छा है।

$_ *= 255 foreach @pixel; 
p @pixel; 

# [ 
#  [0] 100, 
#  [1] 99, 
#  [2] 193 
# ] 

यही वही है जो हम चाहते थे। काफी आसान। आइए प्रत्येक को जोड़ दें।

$_ = ($_ * 255) + 1 foreach @pixel; 
p @pixel; 

# [ 
#  [0] 101, 
#  [1] 100, 
#  [2] 194 
# ] 

अभी भी अच्छा है। लेकिन हम इसे वापस कैसे प्राप्त कर सकते हैं? Manipulate section में दस्तावेज़ों के पास SetPixel के बारे में कुछ कहना है।

रंग => नाव की सरणी
[...]
एक एकल पिक्सेल सेट महत्व देता है। डिफ़ॉल्ट रूप से सामान्यीकृत पिक्सेल मानों की अपेक्षा की जाती है।

तो स्पष्ट रूप से हमें फ्लोट पर वापस जाने की आवश्यकता है। कोई बात नहीं।

$_ = (($_ * 255) + 1)/255 foreach @pixel; 
p @pixel; 

# [ 
#  [0] 0.396078431372549, 
#  [1] 0.392156862745098, 
#  [2] 0.76078431372549 
# ] 

अच्छा। हम निश्चित रूप से गणित को थोड़ा छोटा बना सकते हैं। नतीजा वही है।

$_ = $_ + 1/255 foreach @pixel; 

अब इसे छवि पर वापस लिखें।

$p->SetPixel(
    x => 1, 
    y => 1, 
    color => \@pixel, # need the array ref here 
); 

$p->Write('my_new_file.jpg'); 

स्क्रीनशॉट में, मैं जोड़ने के लिए 1 के बजाय 20 तो यह अधिक दृश्यमान हो यह बदल दिया है।

कोड को साफ करने के बाद इस तरह दिखता है।

use strict; 
use warnings; 
use Data::Printer; 
use Image::Magick; 

my $p = new Image::Magick; 
$p->Read('33141038.jpg'); 

my @pixel = $p->GetPixel(
    x => 1, 
    y => 1, 
); 

# increase RGB by 1 each 
$_ = $_ + 1/255 foerach @pixel; 

$p->SetPixel(
    x  => 1, 
    y  => 1, 
    color => \@pixel, 
); 

$p->Write('my_new_file.jpg'); 

मैं GetPixel से map और channel तर्क को हटा दिया है और SetPixelRGB के रूप में डिफ़ॉल्ट है। normalize के लिए वही।