2012-12-10 12 views
6

का उपयोग करने वाले पहले चरण मैं रंग-अंधे लोगों को रूबी में छवियों को सही करने के लिए daltonize एल्गोरिदम को कार्यान्वित/परिवर्तित करने का प्रयास कर रहा हूं।ruby-vips

javascript और python + भाषाओं/वातावरण में अन्य कार्यान्वयन में दो प्राथमिक संदर्भ कार्यान्वयन हैं जिन्हें मैं परिचित नहीं हूं।

मुझे छवि प्रसंस्करण के साथ लगभग कोई अनुभव नहीं है, वीआईपीएस/रूबी-वीप्स के साथ अकेले रहने दें। मैं सोच रहा हूं कि पहला कदम कैसे बनाया जाए। प्रलेखन मुख्य रूप से सी/सी ++ में और रूबी पक्ष पर बहुत कम लगता है। यह भी बेहद विस्तृत है। मुझे यह भी सुनिश्चित नहीं है कि उपयोग करने के लिए कौन सा मूल संचालन है। ऐसा लगता है कि lin फ़ंक्शन एक अच्छा प्रारंभिक बिंदु है, लेकिन मुझे बिल्कुल यकीन नहीं है कि इसे कैसे लागू किया जाए।

कुछ वीआईपीएस अनुभव वाले कोई भी व्यक्ति कुछ मिनटों में पूरे एल्गोरिदम को संभवतः काम कर सकता है। मुझे आश्चर्य है कि कोई मुझे कहां से शुरू करने के बारे में कुछ संकेत दे सकता है। विशेष रूप से:

  • एकल (आर/जी/बी) तत्व का उपयोग कैसे करें?
  • क्या डाल्टोनाइज कार्यान्वयन के आधार पर बेहतर दृष्टिकोण हैं?

उत्तर

6

मैं रूबी-वीप्स रखरखाव हूं।

यहां काफी पूरा रूबी प्रलेखन है: किसी कारण डॉक्स ज्यादातर मणि (0.3.5) के वर्तमान संस्करण में याद कर रहे हैं के लिए http://rubydoc.info/gems/ruby-vips/0.3.0/frames

, लेकिन 0.3.0 में मौजूद हैं, मुझे नहीं है क्यों काम करने में सक्षम हो गया। 0.3.0 और 0.3.5 के बीच के परिवर्तन ज्यादातर बगफिक्स हैं, इसलिए 0.3.0 दस्तावेज़ उपयोग करने के लिए ठीक हैं।

अधिकांश छवि प्रसंस्करण पुस्तकालयों की तरह, आप रूबी-वीप्स (या केवल बहुत ही कम) के साथ एकल पिक्सल तक नहीं पहुंचते हैं। व्यावहारिक होने के लिए रूबी बहुत धीमी है। इसके बजाय आप रूबी-वीप्स द्वारा प्रदान किए गए वेक्टर ऑपरेशंस को एक साथ जोड़ते हैं।

#!/usr/bin/ruby 

require 'rubygems' 
require 'vips' 

a = VIPS::Image.jpeg(ARGV[0]) 

b = a.lin(1.1, 0) 

b.write(ARGV[1]) 

विधि x.lin(a, b) छवि एक्स लेता है और एक रेखीय बदलने लागू होता है: उदाहरण के लिए। यह एक नई छवि देता है जहां प्रत्येक पिक्सेल को a से गुणा किया गया है और उसके बाद b जोड़ा गया था, http://rubydoc.info/gems/ruby-vips/0.3.0/VIPS/Image#lin-instance_method देखें। आप इस कार्यक्रम के इस तरह चलाते हैं:

$ ./try.rb k2.jpg x.jpg 

यह छवि k2.jpg लोड होगा, 1.1 से हर पिक्सेल गुणा (। यानी यह 10% उज्जवल बनाएं) और x.jpg पर सहेजें।

आप केंद्रीय लाइन को बदल सकते हैं होने के लिए:

b = a.pow(1/2.4).lin(1.1, 0).pow(2.4) 

अब यह तीन आपरेशन करना होगा: पैमाने चमक यह छवि linearise जाएगा (यह मानते हुए इनपुट छवि के गामा 2.4 है), है, तो पुन: लागू गामा आंतरिक रूप से, वीपीएस इन तीन परिचालनों को एक बार में गणना करेंगे और आपके उपलब्ध प्रोसेसर पर काम फैलाएंगे।

अंत में, के बाद से संचालन हम प्रदर्शन कर रहे हैं कोई घूमता है के साथ एक सरल पिक्सेल द्वारा पिक्सेल गणना है (यह सबसे अच्छा तरीका है एक छवि linearise के लिए नहीं है, मैं सिर्फ श्रृंखलन दिखाने के लिए कोशिश कर रहा हूँ) या फ्लिप, हम छवि स्ट्रीम कर सकते हैं, हमें पूरी चीज को पहले से लोड करने की आवश्यकता नहीं है। आप लोड आपरेशन बदल सकते हैं होने के लिए:

a = VIPS::Image.jpeg(ARGV[0], :sequential => true) 

और अब माणिक वीआईपी आपके कंप्यूटर के माध्यम से छवि स्ट्रीम जाएगा और स्मृति में पूरे छवि लोड नहीं। यह आपको मेमोरी सीमाओं को मारने के बिना किसी भी आकार की छवियों को संसाधित करने देता है।

यहां एक संपूर्ण Daltonize उदाहरण

#!/usr/bin/ruby 

# daltonize an image with ruby-vips 
# based on 
# http://scien.stanford.edu/pages/labsite/2005/psych221/projects/05/ofidaner/colorblindness_project.htm 

require 'rubygems' 
require 'vips' 

im = VIPS::Image.new(ARGV[0]) 

# remove any alpha channel before processing 
alpha = nil 
if im.bands == 4 
    alpha = im.extract_band(3) 
    im = im.extract_band(0, 3) 
end 

begin 
    # import to CIELAB with lcms 
    # if there's no profile there, we'll fall back to the thing below 
    lab = im.icc_import_embedded(:relative) 
    xyz = lab.lab_to_xyz() 
rescue VIPS::Error 
    # nope .. use the built-in converter instead 
    xyz = im.srgb_to_xyz() 
end 

# and now to bradford cone space (a variant of LMS) 
brad = xyz.recomb([[0.8951, 0.2664, -0.1614], 
        [-0.7502, 1.7135, 0.0367], 
        [0.0389, -0.0685, 1.0296]]) 

# through the Deuteranope matrix 
# we need rows to sum to 1 in Bradford space --- the matrix in the original 
# Python code sums to 1.742 
deut = brad.recomb([[1, 0, 0], 
        [0.7, 0, 0.3], 
        [0, 0, 1]]) 

# back to xyz (this is the inverse of the brad matrix above) 
xyz = deut.recomb([[0.987, -0.147, 0.16], 
        [0.432, 0.5184, 0.0493], 
        [-0.0085, 0.04, 0.968]]) 

# .. and back to sRGB 
rgb = xyz.xyz_to_srgb() 

# so this is the colour error 
err = im - rgb 

# add the error back to other channels to make a compensated image 
im = im + err.recomb([[0, 0, 0], 
         [0.7, 1, 0], 
         [0.7, 0, 1]]) 

# reattach any alpha we saved above 
if alpha 
    im = im.bandjoin(alpha.clip2fmt(im.band_fmt)) 
end 

im.write(ARGV[1]) 
+1

वाह। बहुत बहुत धन्यवाद। यह मुझे जेएस/पायथन एल्गोरिदम को बदलने की कोशिश कर रहे इतने बेवकूफ खर्च घंटे महसूस करता है। मुझे पता था कि इस अनुभव के साथ किसी को यह काम करने में केवल कुछ मिनट लगेंगे। मैं यह देखने की कोशिश करूंगा कि क्या यह पता लगा सकता है कि यह कैसे काम करता है, इसलिए मैं शायद प्रक्रिया में थोड़ा सा सीख सकता हूं। काश मैं इसे +1000 कर सकता था। धन्यवाद! – gingerlime

+0

@YoavAner, यह भी देखें: http://stackoverflow.com/questions/10709995/ruby-vips-image-processing-library-are-there-any-good-examples-of-usage –

+0

धन्यवाद @ स्टैनिस्लो - मैंने किया अपने प्रश्न को पहले से ही देखें, लेकिन अभी भी डाल्टोनाइज रूपांतरण के साथ कोई प्रगति करने के तरीके पर बहुत खो गया था। मैंने अभी तक सुझाए गए कार्यान्वयन की कोशिश नहीं की है, लेकिन आशा है कि जल्द ही इसे फिर से खोला जाएगा। – gingerlime

1

नए चेहरे के लिए है: माणिक वीआईपी विकी है: के साथ 'उदाहरण' और उस में 'बुनियादी अवधारणाओं के पृष्ठों https://github.com/jcupitt/ruby-vips/wiki। वे रूबी-वीप्स उपयोग की मूल बातें दिखाते हैं।

इसके अलावा, अपने स्वयं के उपयोग के मामलों को जोड़ने के लिए स्वतंत्र महसूस करें, जैसे @YoavAner ने (Daltonize उदाहरण)।