डीएसपी

Question

के लिए फास्ट 2 डी रूपांतरण, मैं कुछ छवि-प्रोसेसिंग एल्गोरिदम लागू करना चाहता हूं जिसका उद्देश्य beagleboard पर चलाना है। ये एल्गोरिदम बड़े पैमाने पर संकल्प का उपयोग करते हैं। मैं 2 डी संकल्प (शायद फास्ट फूरियर ट्रांसफॉर्म का उपयोग कर) के लिए एक अच्छा सी कार्यान्वयन खोजने की कोशिश कर रहा हूं। मैं भी एल्गोरिदम को बीगलबोर्ड के डीएसपी पर चलाने में सक्षम होना चाहता हूं, क्योंकि मैंने सुना है कि डीएसपी को इन प्रकार के संचालन के लिए अनुकूलित किया गया है (इसके गुणा-संचित निर्देश के साथ)।

मेरे पास मैदान में कोई पृष्ठभूमि नहीं है, इसलिए मुझे लगता है कि स्वयं को संकल्प को लागू करने का अच्छा विचार नहीं होगा (शायद मैं इसे किसी ऐसे व्यक्ति के रूप में उतना अच्छा नहीं करूँगा जो इसके पीछे सभी गणित को समझता है)। मेरा मानना ​​है कि डीएसपी के लिए एक अच्छा सी संकल्प कार्यान्वयन कहीं मौजूद है लेकिन मुझे यह नहीं मिला?

कोई मदद कर सकता है?

संपादित करें: कर्नेल बहुत छोटा है। इसके आयाम या तो 2X2 या 3X3 हैं। तो मुझे लगता है कि मैं एक एफएफटी आधारित कार्यान्वयन की तलाश नहीं कर रहा हूं। मैं अपनी परिभाषा को देखने के लिए वेब पर संकल्प की खोज कर रहा था, इसलिए मैं इसे सीधे आगे बढ़ने के लिए कार्यान्वित कर सकता हूं (मुझे वास्तव में पता नहीं है कि संकल्प क्या है)। मुझे जो कुछ मिला है वह गुणा इंटीग्रल के साथ कुछ है और मुझे नहीं पता कि मैट्रिस के साथ इसे कैसे किया जाए। क्या कोई मुझे 2X2 कर्नेल केस के लिए कोड का एक टुकड़ा (या छद्म कोड) दे सकता है?

Answer 1

छवि और कर्नेल के आयाम क्या हैं? यदि कर्नेल बड़ा है तो आप एफएफटी-आधारित संकल्प का उपयोग कर सकते हैं, अन्यथा छोटे कर्नेल के लिए सीधे प्रत्यक्ष रूपांतरण का उपयोग करें।

डीएसपी ऐसा करने का सबसे अच्छा तरीका नहीं हो सकता है - सिर्फ इसलिए कि इसमें मैक निर्देश है इसका मतलब यह नहीं है कि यह अधिक कुशल होगा। क्या बीगल बोर्ड पर एआरएम सीपीयू ने नीयन सिम किया है? यदि ऐसा है तो यह जाने का तरीका हो सकता है (और अधिक मजेदार भी)।

एक छोटे से गिरी के लिए, आप इस तरह प्रत्यक्ष घुमाव के कर सकते हैं:

// in, out are m x n images (integer data) 
// K is the kernel size (KxK) - currently needs to be an odd number, e.g. 3 
// coeffs[K][K] is a 2D array of integer coefficients 
// scale is a scaling factor to normalise the filter gain 

for (i = K/2; i < m - K/2; ++i) // iterate through image 
{ 
    for (j = K/2; j < n - K/2; ++j) 
    { 
    int sum = 0; // sum will be the sum of input data * coeff terms 

    for (ii = - K/2; ii <= K/2; ++ii) // iterate over kernel 
    { 
     for (jj = - K/2; jj <= K/2; ++jj) 
     { 
     int data = in[i + ii][j +jj]; 
     int coeff = coeffs[ii + K/2][jj + K/2]; 

     sum += data * coeff; 
     } 
    } 
    out[i][j] = sum/scale; // scale sum of convolution products and store in output 
    } 
} 

आप इस संशोधित कर सकते हैं कश्मीर की भी मानों का समर्थन करने - यह सिर्फ एक छोटे से देखभाल दो पर ऊपरी/निचले सीमा के साथ ले जाता है आंतरिक लूप

Answer 2

मुझे पता है कि यह विषय बंद हो सकता है लेकिन सी और जावास्क्रिप्ट के बीच समानता के कारण मुझे विश्वास है कि यह अभी भी सहायक हो सकता है। पीएस .: @ पॉल आर जवाब से प्रेरित। जावास्क्रिप्ट में

दो आयाम 2 डी घुमाव के कलन विधि का उपयोग सरणियों

function newArray(size){ 
    var result = new Array(size); 
    for (var i = 0; i < size; i++) { 
     result[i] = new Array(size); 
    } 

    return result; 
} 

function convolveArrays(filter, image){ 
    var result = newArray(image.length - filter.length + 1); 

    for (var i = 0; i < image.length; i++) { 
     var imageRow = image[i]; 
     for (var j = 0; j <= imageRow.length; j++) { 

      var sum = 0; 
      for (var w = 0; w < filter.length; w++) { 
       if(image.length - i < filter.length) break; 

       var filterRow = filter[w]; 
       for (var z = 0; z < filter.length; z++) { 
        if(imageRow.length - j < filterRow.length) break; 
        sum += image[w + i][z + j] * filter[w][z]; 
       } 
      } 

      if(i < result.length && j < result.length) 
       result[i][j] = sum; 
     } 
    } 

    return result; 
} 

आप http://ec2-54-232-84-48.sa-east-1.compute.amazonaws.com/two-dimensional-convolution-algorithm-with-arrays-in-javascript/ पर पूर्ण ब्लॉग पोस्ट की जांच कर सकते