QImage/QPixmap आकार सीमाएं?

Question

क्या QPixmap और/या QImage ऑब्जेक्ट्स का कोई ज्ञात आकार/स्थान सीमा है? मुझे इसके बारे में कोई उपयोगी जानकारी नहीं मिली। मैं वर्तमान में ओएसएक्स और विंडोज पर क्यूटी 4.7.3 का उपयोग कर रहा हूं। Particulary मुझे इसमें दिलचस्पी है:

• चौड़ाई/ऊंचाई सीमाएं?
• रंग प्रारूप के आधार पर सीमाएं?
• 32/64 बिट मशीनों के बीच अंतर?
• ओएस के बारे में अंतर?

मैं भोलेपन पर शक होता है कि स्मृति केवल सीमा है, इसलिए एक

चौड़ाई x ऊँचाई से अधिकतम आकार की गणना कर सकते एक्स byte_per_pixel

मुझे लगता है कि वहाँ एक और अधिक व्यापक नियम यह है कि अंगूठे का; जब आप जीबी आयामों में भाग लेते हैं तो 32 बिट मशीनों में समस्याएं हल हो सकती हैं।

अंत में मैं आकार में लगभग 16000x16000 पिक्सेल की कई आरजीबीए छवियों को स्टोर करना चाहता हूं और QGraphicsScene के भीतर एक दूसरे पर पारदर्शिता का उपयोग करके उन्हें प्रस्तुत करना चाहता हूं। उपलब्ध वर्कस्टेशन में बहुत सी रैम हो सकती है, आइए 16 जीबी कहें।

टीएल; डॉ: QImage/QPixmap की किस आकार सीमाएं आप जानते हैं, या मुझे ऐसी जानकारी कहां मिल सकती है?

संपादित करें: मुझे टाइलिंग दृष्टिकोण से अवगत है और मैं इसके साथ ठीक हूं। अभी भी ऊपर वर्णित चीजों को जानना बहुत अच्छा होगा।

धन्यवाद!

Answer 1

दोनों 32767x32767 पिक्सल तक सीमित हैं। यही है, आप एक्स और वाई दोनों संकल्प के लिए हस्ताक्षरित 16-बिट मान का उपयोग करने के बारे में सोच सकते हैं।

कोई धुरी 32767 पिक्सेल से अधिक नहीं हो सकती है, भले ही अन्य धुरी केवल 1 पिक्सेल हो। ऑपरेटिंग सिस्टम "बैपटर" सीमा को प्रभावित नहीं करता है। अंतर्निहित प्रणाली अन्य सीमाओं में चल सकती है, जैसे कि आपके द्वारा वर्णित स्मृति, इस तरह की एक बड़ी छवि बनाई जा सकती है।

आप निम्नलिखित स्रोत कोड में इस सीमा का एक उदाहरण देख सकते हैं: http://git.zx2c4.com/qt/plain/src/gui/image/qpixmap_x11.cpp

if (uint(w) >= 32768 || uint(h) >= 32768) { 
    w = h = 0; 
    is_null = true; 
    return; 
} 

Answer 2

मैं वास्तव में एक समय में इस पर विचार करने के लिए अवसर था। "संभावित ओवरफ्लो के लिए सैनिटी चेक" के लिए qimage.cpp के स्रोत कोड में एक खोज करें और आप चेक देख सकते हैं कि क्यूटी कर रही है। असल में,

• आवश्यक बाइट की संख्या (चौड़ाई * ऊंचाई * depth_for_format) INT_MAX से कम होना चाहिए।
• यह उस बिंदु पर malloc उन बाइट्स में सक्षम होना चाहिए जो आप QImage उदाहरण बना रहे हैं।

Answer 3

क्या आप 64 बिट ऐप बना रहे हैं? यदि नहीं, तो आप स्मृति मुद्दों में बहुत जल्दी चलने जा रहे हैं।विंडोज़ पर, यहां तक ​​कि यदि मशीन में 16 जीबी रैम है, तो 32 बिट प्रक्रिया 2 जीबी तक सीमित होगी (जब तक कि यह 3 जीबी तक लर्जडेक्टवेयर नहीं है)। एक 16000x16000 छवि केवल 1 जीबी से कम होगी, इसलिए आप केवल 1 के लिए पर्याप्त मेमोरी आवंटित करने में सक्षम होंगे, शायद 2 यदि आप बहुत भाग्यशाली हैं।

64 बिट ऐप के साथ आप कई छवियों के लिए पर्याप्त स्मृति आवंटित करने में सक्षम होना चाहिए। @ चार्ल्स-जलता द्वारा उत्तर पर

Answer 4

भवन, यहाँ QImage के लिए प्रासंगिक स्रोत कोड है:

QImageData *d = 0; 

if (format == QImage::Format_Invalid) 
    return d; 

const int depth = qt_depthForFormat(format); 
const int calc_bytes_per_line = ((width * depth + 31)/32) * 4; 
const int min_bytes_per_line = (width * depth + 7)/8; 

if (bpl <= 0) 
    bpl = calc_bytes_per_line; 

if (width <= 0 || height <= 0 || !data 
    || INT_MAX/sizeof(uchar *) < uint(height) 
    || INT_MAX/uint(depth) < uint(width) 
    || bpl <= 0 
    || height <= 0 
    || bpl < min_bytes_per_line 
    || INT_MAX/uint(bpl) < uint(height)) 
    return d;          // invalid parameter(s) 

तो यहाँ, bpl प्रति पंक्ति बाइट की संख्या है, जो प्रभावी रूप से width * depth_in_bytes है। कि अंतिम अवैध परीक्षण पर बीजगणित का उपयोग करना:

• INT_MAX/uint(bpl) < uint(height)
• INT_MAX < uint(height) * uint(bpl)
• INT_MAX < height * width * depth_in_bytes

तो, कुल में अपनी छवि का आकार कम से कम 2147483647 (के लिए 32-बिट ints) होना चाहिए।