गैर-शक्ति-दो छवियों पर 2 डी सिग्नल प्रोसेसिंग के लिए आईओएस त्वरित फ्रेमवर्क का उपयोग करना?

Question

// संपादित करें ...

मैं विशेष रूप से गैर-शक्ति-दो छवियों के साथ काम करने के मुद्दे को हल करने के लिए थोड़ा सा प्रश्न संपादित कर रहा हूं। मेरे पास एक बुनियादी संरचना है जो वर्ग ग्रेस्केल छवियों के साथ 256x256 या 1024x1024 जैसी आकारों के साथ काम करती है, लेकिन यह नहीं देख सकती कि मनमाने ढंग से आकार वाली छवियों को सामान्यीकृत कैसे किया जाए। एफएफटी फ़ंक्शंस आपको लगता है कि आप चौड़ाई और ऊंचाई के लॉग 2 को शामिल करना चाहते हैं, लेकिन उसके बाद यह स्पष्ट नहीं है कि परिणामी डेटा को कैसे अनपैक करना है, या यदि डेटा स्कैम्बल नहीं हो रहा है। मुझे लगता है कि करने के लिए स्पष्ट बात एनपीओटी छवि को एक बड़ी, सभी काले छवि के भीतर केंद्रित करना होगा और फिर डेटा को देखते समय उन पदों में किसी भी मूल्य को अनदेखा करना होगा। लेकिन सोच रहा है कि एनपीओटी डेटा के साथ काम करने के लिए कम अजीब तरीका है या नहीं।

//...END संपादित

मैं में तेजी लाने की रूपरेखा प्रलेखन के साथ परेशानी का एक सा हो रही है। मैं आमतौर पर एफएफटीडब्ल्यू 3 का उपयोग करता हूं, लेकिन मुझे वास्तविक आईओएस डिवाइस पर संकलन करने में परेशानी हो रही है (यह question देखें)। क्या कोई मुझे त्वरित रूप से उपयोग करके एक सुपर सरल कार्यान्वयन के लिए इंगित कर सकता है जो निम्न की तरह कुछ करता है:

1) छवि डेटा को एक उचित डेटा संरचना में बदल देता है जिसे एक्सेलेरेट की एफएफटी विधियों में पारित किया जा सकता है।
एफएफटीडब्ल्यू 3 में, ग्रेस्केल छवि का उपयोग करके, सबसे सरल रूप से, इसमें हस्ताक्षर किए गए बाइट्स को "fftw_complex" सरणी में रखना शामिल है, जो कि केवल दो फ्लोट्स की संरचना है, एक वास्तविक मूल्य धारण करता है और दूसरा काल्पनिक (और जहां प्रत्येक पिक्सेल के लिए काल्पनिक शून्य में प्रारंभ किया जाता है)।

2) इस डेटा संरचना को लेता है और उस पर एक एफएफटी करता है।

3) परिमाण और चरण को प्रिंट करता है।

4) इस पर एक आईएफएफटी करता है।

5) आईएफएफटी के परिणामस्वरूप मूल छवि को पुन: उत्पन्न करता है।

हालांकि यह एक बहुत ही बुनियादी उदाहरण है, मुझे ऐप्पल की साइट से दस्तावेज़ों का उपयोग करने में परेशानी हो रही है। SO answer by Pi here बहुत उपयोगी है, लेकिन मैं अभी भी कुछ हद तक उलझन में हूं कि ग्रेस्केल (या रंग) 2 डी छवि का उपयोग करके इस बुनियादी कार्यक्षमता को बढ़ाने के लिए कैसे उपयोग करें।

किसी भी तरह, किसी भी पॉइंटर्स या विशेष रूप से कुछ साधारण काम कोड जो 2 डी छवि को संसाधित करते हैं, बहुत उपयोगी होंगे!

\\\ संपादित \\\

ठीक है, कुछ समय के दस्तावेज और एसओ रूप में अच्छी तरह पर pkmital's github repo के रूप में के बारे में कुछ बहुत ही उपयोगी कोड में गोता लगाने के लेने के बाद, मैं कुछ काम कर कोड है कि मैंने सोचा था कि मुझे मिल गया है '1 से 1 पोस्ट) मुझे इसे समझने में थोड़ी देर लग गई और 2) क्योंकि मेरे पास कुछ शेष प्रश्न हैं ...

एफएफटी "योजना" शुरू करें।एक वर्ग बिजली के- दो छवि मान लिया जाये कि: एक वर्ग बिजली के- दो ग्रेस्केल छवि के लिए एक बाइट सरणी में

#include <Accelerate/Accelerate.h> 
... 
UInt32 N = log2(length*length); 
UInt32 log2nr = N/2; 
UInt32 log2nc = N/2; 
UInt32 numElements = 1 << (log2nr + log2nc); 
float SCALE = 1.0/numElements; 
SInt32 rowStride = 1; 
SInt32 columnStride = 0; 
FFTSetup setup = create_fftsetup(MAX(log2nr, log2nc), FFT_RADIX2); 

पास है और यह एक COMPLEX_SPLIT में बदल जाते हैं:

COMPLEX_SPLIT in_fft; 
in_fft.realp = (float*) malloc (numElements * sizeof (float)); 
in_fft.imagp = (float*) malloc (numElements * sizeof (float)); 

for (UInt32 i = 0; i < numElements; i++) { 
    if (i < t->width * t->height) { 
     in_fft.realp[i] = t->data[i]/255.0; 
     in_fft.imagp[i] = 0.0; 
    } 
} 

पर FFT भागो

COMPLEX_SPLIT out_fft; 
out_fft.realp = (float*) malloc (numElements * sizeof (float)); 
out_fft.imagp = (float*) malloc (numElements * sizeof (float)); 

fft2d_zop (setup, &in_fft, rowStride, columnStride, &out_fft, rowStride, columnStride, log2nc, log2nr, FFT_FORWARD); 

magnitude = (float *) malloc(numElements * sizeof(float)); 
phase = (float *) malloc(numElements * sizeof(float)); 

for (int i = 0; i < numElements; i++) { 
    magnitude[i] = sqrt(out_fft.realp[i] * out_fft.realp[i] + out_fft.imagp[i] * out_fft.imagp[i]) ; 
    phase[i] = atan2(out_fft.imagp[i],out_fft.realp[i]); 
} 

अब आप मूल छवि पाने के लिए out_fft डेटा पर एक IFFT चला सकते हैं ...

0123: तब्दील छवि डेटा है, तो परिमाण और चरण हड़पने

for (UInt32 i = 0; i < numElements; i++) { 
    t->data[i] = (int) (out_ifft.realp[i] * 255.0); 
}  

मैं:

COMPLEX_SPLIT out_ifft; 
out_ifft.realp = (float*) malloc (numElements * sizeof (float)); 
out_ifft.imagp = (float*) malloc (numElements * sizeof (float)); 
fft2d_zop (setup, &out_fft, rowStride, columnStride, &out_ifft, rowStride, columnStride, log2nc, log2nr, FFT_INVERSE); 

vsmul(out_ifft.realp, 1, SCALE, out_ifft.realp, 1, numElements); 
vsmul(out_ifft.imagp, 1, SCALE, out_ifft.imagp, 1, numElements); 

या आप एक ऑटो सहसंबंध पाने के लिए भयावहता पर एक IFFT चला सकते हैं ...

COMPLEX_SPLIT in_ifft; 
in_ifft.realp = (float*) malloc (numElements * sizeof (float)); 
in_ifft.imagp = (float*) malloc (numElements * sizeof (float)); 
for (int i = 0; i < numElements; i++) { 
    in_ifft.realp[i] = (magnitude[i]); 
    in_ifft.imagp[i] = 0.0; 
} 

fft2d_zop (setup, &in_fft, rowStride, columnStride, &out_ifft, rowStride, columnStride, log2nc, log2nr, FFT_INVERSE);  

vsmul(out_ifft.realp, 1, SCALE, out_ifft.realp, 1, numElements); 
vsmul(out_ifft.imagp, 1, SCALE, out_ifft.imagp, 1, numElements); 

अंत में, आप एक छवि सरणी में वापस IFFT परिणाम रख सकते हैं गैर-शक्ति-दो छवियों को संभालने के लिए त्वरित ढांचे का उपयोग कैसे करें, यह पता नहीं लगाया है। अगर मैं सेटअप में पर्याप्त मेमोरी आवंटित करता हूं, तो मैं अपनी मूल छवि प्राप्त करने के लिए एक एफएफटी कर सकता हूं, इसके बाद आईएफएफटी के बाद। लेकिन अगर एक ऑटोकोरिलेशन (एफएफटी की परिमाण के साथ) करने की कोशिश करें, तो मेरी छवि को विजयी परिणाम मिलते हैं। मुझे छवि को उचित रूप से पैड करने का सबसे अच्छा तरीका नहीं है, इसलिए उम्मीद है कि किसी को यह कैसे करना है इसका विचार है। (या vDSP_conv विधि का एक वर्किंग वर्जन साझा करें!)

Answer 1

मैं कहूंगा कि मनमानी छवि आकारों पर काम करने के लिए, आपको बस अपनी इनपुट वैल्यू सरणी को अगली शक्ति 2 के लिए उचित रूप से आकार देना है।

कठिन हिस्सा यह है कि अपना मूल छवि डेटा कहां रखा जाए और क्या भरना है। आप वास्तव में छवि से छवि या डेटा खदान करने की कोशिश कर रहे हैं महत्वपूर्ण है।

नीचे लिंक पीडीएफ में, बस ऊपर 12.4.2 http://www.mathcs.org/java/programs/FFT/FFTInfo/c12-4.pdf

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

का कहना है कि हमारे पास 900 है: 90012: पहले हम छवि को 512 के ऊर्ध्वाधर स्ट्रिप्स में विभाजित कर सकते हैं, 256, 128, और 4. हम प्रत्येक पंक्ति के लिए 4 1 डी एफएफटी को संसाधित करेंगे, पहले 512 पिक्सेल के लिए, अगले 256 पिक्सेल के लिए अगला, अगले 128 के लिए अगला, फिर शेष 4 के लिए अंतिम होगा। एफएफटी का उत्पादन आवृत्ति की अनिवार्य रूप से लोकप्रियता है, फिर इन्हें केवल जोड़ा जा सकता है (आवृत्ति केवल परिप्रेक्ष्य से, कोणीय ऑफसेट नहीं)। हम फिर इसी तकनीक को दूसरे आयाम की तरफ धक्का दे सकते थे। इस बिंदु पर हम वास्तव में पैड के बिना हर इनपुट पिक्सेल को ध्यान में रखते थे।

यह वास्तव में सिर्फ विचार के लिए भोजन है, मैंने इसे स्वयं नहीं किया है, और वास्तव में इसे स्वयं शोधना चाहिए। यदि आप वास्तव में इस तरह के काम कर रहे हैं, तो आपके पास इस बिंदु पर मुझसे अधिक समय हो सकता है।