অসীম বিটম্যাপ [বন্ধ]

10

বন্ধ থাকে। এই প্রশ্নটি অফ-টপিক । এটি বর্তমানে উত্তর গ্রহণ করছে না।

এই প্রশ্নটি উন্নত করতে চান? প্রশ্নটি আপডেট করুন যাতে এটি সফটওয়্যার ইঞ্জিনিয়ারিং স্ট্যাক এক্সচেঞ্জের বিষয়বস্তু ।

4 বছর আগে বন্ধ ছিল ।

আমি রানটাইমের সময় একটি বিটম্যাপ তৈরি করতে চাই। বিটম্যাপটি চারদিকে স্কেলেযোগ্য হওয়া উচিত এবং পিক্সেল অ্যাক্সেসটি শান্ত দক্ষ হওয়া উচিত।

কিছু চিত্র http://img546.imageshack.us/img546/4995/maptm.jpg

ছবিতে প্রদর্শিত কমান্ডগুলির মধ্যে এবং তার পরে, মানচিত্র.সেটপিক্সেল () এবং ম্যাপ.জেটপিক্সেল () বিটম্যাপে সংরক্ষিত ডেটা সেট / রিটার্ন করা উচিত।

আমি সেটাকে পিক্সেল () / গেটপিক্সেল যত দ্রুত সম্ভব মেমোরিটিকে কীভাবে বরাদ্দ করা যায় তার একটি ধারণার বাস্তবায়ন আশা করি না।

concepts memory

— SecStone
সূত্র

ধূসর ক্ষেত্রটি কি সর্বদা বিন্দু (0,0) হয় বা এটি অন্য কোনও স্থানাঙ্কও হতে পারে?

— ফ্যালকন

2

আরও বিশদ প্রয়োজন। সেট পিক্সেলগুলি কি বিরল হতে চলেছে? আপনি কিভাবে মন্থর করে করতে ইচ্ছুক extendXঅনুক্রমে করতে পদ্ধতি setPixelএবং getPixelবেশী ফাস্ট?

— পিটার টেলর

1

বিটম্যাপটি কি স্মৃতিতে ফিট করার জন্য খুব বড় হবে? দ্রুত অপারেশনগুলি কী হওয়া উচিত - সম্প্রসারণ, সেটপিক্সেল (), গেটপিক্সেল ()?

1

@ ফ্যালকন: না, পর্যাপ্ত সময় পাওয়া যায়

— সেকস্টোন

3

আমি এই প্রশ্নটিকে অফ-টপিক হিসাবে বন্ধ করতে ভোট দিচ্ছি কারণ প্রশ্নটি অন্তর্ভুক্ত চিত্রটির উপর নির্ভর করে, যা মুছে ফেলা হয়েছে। যেমনটি বর্তমানে লেখা হয়েছে, এটি খুব একটা বোঝায় না।

9

যদি extend()অপারেশনটি যুক্তিসঙ্গতভাবে দ্রুত হওয়া দরকার, তবে একটি চতুর্থাংশ একটি ভাল ফিট হতে পারে; এটি আসলে এমনকি সুস্পষ্ট প্রসারিত ক্রিয়াকলাপ প্রয়োজন হবে না। স্বীকার করা যায়, এটি পৃথক পিক্সেলগুলিতে এলোমেলো অ্যাক্সেসের জন্য সর্বোত্তম কর্মক্ষমতা অর্জন করতে পারে না, তবে আপনার মন্তব্য বলেছে যে আপনার প্রাথমিক ক্রিয়াকলাপটি পিক্সেলগুলির উপরে পুনরাবৃত্তি করছে, যা একটি চতুর্থাংশ খুব দ্রুত করতে পারে, সম্ভবত ম্যাট্রিক্স-ভিত্তিক প্রয়োগ হিসাবে প্রায় দ্রুত (এবং দ্রুত) যদি পুনরাবৃত্তি সর্বদা ম্যাট্রিক্স নির্ধারিত একইভাবে না ঘটে))

আপনার প্রয়োজনীয়তাগুলি এমন মনে হচ্ছে আপনি গেম অফ লাইফের মতো সেলুলার অটোমেটন বাস্তবায়নের চেষ্টা করছেন। আপনি হাশলাইফকে একবার দেখতে চাইতে পারেন , একটি অসীম গ্রিডে গেম অফ লাইফ বাস্তবায়নের জন্য একটি অত্যন্ত উচ্চ-কার্যকারী উপায়। নোট করুন এটি একটি চতুষ্কোণের উপর ভিত্তি করে তৈরি হয়েছে, তবে গেমের নিয়মের স্থানীয়তার উপর ভিত্তি করে কিছু খুব স্মার্ট অতিরিক্ত অপ্টিমাইজেশন করে।

— মাইকেল বর্গওয়ার্ট
সূত্র

এই ধারণার জন্য আপনাকে ধন্যবাদ! আমি কিছু পরীক্ষা করব এবং ফলাফলগুলি রিপোর্ট করব।

— সেকস্টোন

2

@ সেকস্টোন বলেছে যে সম্প্রসারণ অপারেশনের জন্য পর্যাপ্ত সময় পাওয়া যায়, তাই পিক্সেলগুলি সংরক্ষণ করার সহজতম এবং কার্যকর উপায়টি একটি একক ফ্ল্যাট অ্যারে বা একটি দ্বি মাত্রিক অ্যারে ব্যবহার করে, কারণ পিক্সেলগুলি অবিচ্ছিন্ন সময়ে অ্যাক্সেস করা যায়।

— বাজপাখি
সূত্র

4

আপনি কীভাবে সম্প্রসারণকে মোকাবেলা করা উচিত বলে আপনি যদি কোনও ভাল পরামর্শ দেন তবে আমি এটিকে ভোট দিয়ে যাব।

— ডক ব্রাউন

@ ডক ব্রাউন: যদি পর্যাপ্ত সময় থাকে তবে অ্যারে শিফট করুন। অথবা হতে পারে আপনি কিছু অংশে কাজ করতে পারেন এবং একটি অনুবাদক ফাংশন বিন্যাসে বিন্যাস এবং শঙ্কা সূচক (যা ধ্রুব সময়েও চলমান))

— ফ্যালকন

2

হাতের দ্বারা

যদি মেমরিটি খুব কম ছড়িয়ে যায় না তবে আমি বড় অংশগুলিতে কাজ করার বিষয়টি বিবেচনা করি।
এখানে কিছু সিডো-কোড দেওয়া আছে।

class Chunk {
    Chunk new(int size) {...}
    void setPixel(int x, int y, int value) {...}
    int getPixel(int x, int y) {...}
}

class Grid {
    Map<int, Map<Chunk>> chunks;
    Grid new(int chunkSize) {...}
    void setPixel(int x, int y, int value) {
         getChunk(x,y).setPixel(x % chunkSize, y % chunkSize, value);//actually the modulo could be right in Chunk::setPixel and getPixel for more safety
    }
    int getPixel(int x, int y) { /*along the lines of setPixel*/ }
    private Chunk getChunk(int x, int y) {
         x /= chunkSize;
         y /= chunkSize;
         Map<Chunk> row = chunks.get(y);
         if (row == null) chunks.set(y, row = new Map<Chunk>());
         Chunk ret = row.get(x);
         if (ret == null) row.set(x, ret = new Chunk(chunkSize));
         return ret;
    }
}

এই বাস্তবায়ন বেশ নিষ্পাপ।
একটির জন্য, এটি গেটপিক্সেলগুলিতে খণ্ডগুলি তৈরি করে (মূলত এটি 0 বা তাই ফিরে আসা ভাল হবে, যদি কোনও অবস্থার জন্য এই অংশটির জন্য সংজ্ঞা দেওয়া হয়নি)। দ্বিতীয়ত এটি অনুমানের উপর ভিত্তি করে তৈরি করা হয়েছে যে আপনার কাছে মানচিত্রের যথেষ্ট দ্রুত এবং স্কেলযোগ্য বাস্তবায়ন রয়েছে। আমার জ্ঞান অনুসারে প্রতিটি শালীন ভাষার একটি রয়েছে

এছাড়াও আপনাকে খণ্ড আকারের সাথে খেলতে হবে। ঘন বিটম্যাপের জন্য, একটি বড় অংশের আকার ভাল, বিরল বিটম্যাপের জন্য একটি ছোট অংশের আকার আরও ভাল। প্রকৃতপক্ষে খুব অল্প সংখ্যক লোকের ক্ষেত্রে, "অংশের আকার" 1 সবচেয়ে ভাল, "খণ্ডগুলি" নিজেকে অপ্রচলিত করে এবং পিক্সেলের কোনও মানচিত্রের একটি মানচিত্রে ডেটা কাঠামো হ্রাস করে।

বালুচর বন্ধ

অন্য সমাধান হতে পারে কিছু গ্রাফিক লাইব্রেরি তাকান। তারা একটিতে 2D বাফার আঁকতে আসলে বেশ ভাল। এর অর্থ হ'ল আপনি কেবল একটি বৃহত্তর বাফার বরাদ্দ করতে পারেন এবং সেই অনুযায়ী স্থানাঙ্কগুলিতে এটিতে মূলটি আঁকেন।

একটি সাধারণ কৌশল হিসাবে: যখন "গতিশীলভাবে ক্রমবর্ধমান মেমরি ব্লক" থাকে, এটি ব্যবহার হয়ে গেলে এটির একাধিক বরাদ্দ করা ভাল ধারণা। এটি বরং স্মৃতি তীব্র, তবে বরাদ্দ এবং অনুলিপি ব্যয়কে উল্লেখযোগ্যভাবে হ্রাস করে । বেশিরভাগ ভেক্টর বাস্তবায়নগুলি তার আকার দ্বিগুণ হওয়ার পরে বরাদ্দ দেয়। সুতরাং বিশেষত আপনি যদি অফ-দ্য শেল্ফ সমাধানটি নিয়ে যান তবে আপনাকে কেবল 1 পিক্সেল দ্বারা বাফার বাড়িয়ে দেবেন না, কারণ কেবল একটি পিক্সেল অনুরোধ করা হয়েছিল। বরাদ্দ মেমরি সস্তা। পুনর্নির্মাণ, অনুলিপি এবং মুক্তি ব্যয়বহুল।

— back2dos
সূত্র

1

পরামর্শের মাত্র কয়েক দফা:

আপনি যদি এটি কিছু অবিচ্ছেদ্য ধরণের অ্যারে হিসাবে প্রয়োগ করেন (বা এর অ্যারের ...) আপনার সম্ভবত প্রতিবার কয়েকটি বিট / পিক্সেল দ্বারা ব্যাকিং অ্যারে বৃদ্ধি করা উচিত যাতে আপনি অনুলিপি করার সাথে সাথে বিটগুলি স্থানান্তরিত না করে এড়াতে পারেন। নীচের দিকটি হ'ল আপনি আরও স্থান ব্যবহার করেন তবে বিটম্যাপটি বড় হওয়ার সাথে সাথে নষ্ট স্থানের অনুপাত।
আপনি যদি মানচিত্র-ভিত্তিক ডেটা কাঠামো ব্যবহার করেন তবে আপনি এক্স, ওয়াই getPixelএবং setPixelকলগুলির সমন্বয় যুক্তিগুলি স্থানান্তরিত করে বিটম্যাপটি বাড়ানোর সমস্যাটিকে সূক্ষ্ম করতে পারেন ।
আপনি যদি মানচিত্র ভিত্তিক ডেটা কাঠামো ব্যবহার করেন তবে আপনার কেবল "একটি" এর জন্য মানচিত্রের প্রবেশের প্রয়োজন। "জিরোস" কোনও প্রবেশের অভাবে নির্দেশ করতে পারে। এটি উল্লেখযোগ্য পরিমাণে স্থান বাঁচায়, বিশেষত যদি বিটম্যাপটি বেশিরভাগ শূন্য হয়।
আপনাকে মানচিত্রের মানচিত্র ব্যবহার করার দরকার নেই। আপনি intএকক হিসাবে একটি এক্স, ওয়াই জোড় এনকোড করতে পারেন long। একটি অ্যারেতে অ্যারের অ্যারে ম্যাপ করার জন্য অ্যানালগাস প্রক্রিয়া ব্যবহার করা যেতে পারে।

শেষ অবধি, আপনার তিনটি জিনিসের ভারসাম্য বজায় রাখতে হবে:

এর কর্মক্ষমতা getPixelএবং setPixel,
extend*অপারেশনগুলির পারফরম্যান্স এবং
স্থান ব্যবহার।

— স্টিফেন সি
সূত্র

1

আরও জটিল কোনও কিছুর চেষ্টা করার আগে এবং আপনি যতক্ষণ না মেমরির সব কিছু ধরে রাখতে পারবেন, ততক্ষণ জিনিসগুলিকে সহজ রাখুন এবং আপনার সমন্বিত সিস্টেমের উত্স সম্পর্কে তথ্যের সাথে একটি দ্বিমাত্রিক অ্যারে ব্যবহার করুন। এটি প্রসারিত করতে একই কৌশল ব্যবহার করুন, উদাহরণস্বরূপ, C ++ std :: ভেক্টর করেন: আপনার অ্যারের প্রকৃত আকার এবং অ্যারের ক্ষমতার মধ্যে পার্থক্য তৈরি করুন এবং যখনই সীমাটি পৌঁছে যায় তখন খণ্ডগুলিতে ক্ষমতা বাড়ান। "ক্ষমতা" এখানে অন্তর্বর্তী (থেকে_ x, থেকে_x), (from_y, to_y) হিসাবে সংজ্ঞায়িত করা উচিত।

এটি সময়ে সময়ে মেমরির সম্পূর্ণ পুনর্বিবেচনার প্রয়োজন হতে পারে, তবে যতক্ষণ না এটি খুব বেশি ঘন ঘন ঘটে না ততক্ষণ এটি আপনার উদ্দেশ্যটির জন্য যথেষ্ট দ্রুত হতে পারে (আসলে, আপনাকে এটির চেষ্টা / প্রোফাইল করতে হবে)।

— ডক ব্রাউন
সূত্র

1

পিক্সেল অ্যাক্সেস করার নিখুঁত দ্রুততম উপায় হ'ল পৃথকভাবে সম্বোধনযোগ্য পিক্সেলের একটি দ্বিমাত্রিক অ্যারে।

এক্সটেনশানগুলির জন্য, এমন একটি সাধারণ বাস্তবায়ন দিয়ে শুরু করুন যা প্রতিবার পুনরায় স্থান এবং প্রতিলিপি হয় (যেহেতু আপনার যে কোনওভাবেই কোডটি প্রয়োজন হবে)। প্রোফাইলিং যদি এটি নির্দেশ করে না যে আপনি এতে প্রচুর সময় ব্যয় করছেন তবে এটিকে আরও পরিমার্জন করার দরকার নেই।

যদি প্রোফাইলিং পুনরায় বরাদ্দ সংখ্যা কম রাখার প্রয়োজনীয়তা প্রকাশ করে এবং আপনি মেমরি-সীমাবদ্ধ নন, প্রতিটি দিকের শতাংশের চেয়ে বেশি বরাদ্দ বিবেচনা করুন এবং একটি অফসেট উত্সে সঞ্চয় করবেন। (উদাহরণস্বরূপ, আপনি যদি 1x1 এ একটি নতুন বিটম্যাপ শুরু করেন এবং এটি ধরে রাখতে 9x9 অ্যারে বরাদ্দ করেন তবে প্রাথমিক xএবং yঅফসেটগুলি হবে 4)) অফসেটটি প্রয়োগ করতে পিক্সেল অ্যাক্সেসের সময় এখানে ট্রেড অফকে অতিরিক্ত গণিত করতে হবে।

যদি এক্সটেনশানগুলি সত্যই ব্যয়বহুল হয়ে থাকে, আপনি এই দুটি বা একটি ব্যবহার করতে পারেন:

উল্লম্ব এবং অনুভূমিক এক্সটেনশনগুলি আলাদাভাবে পরিচালনা করুন। কোনও দিকের উল্লম্বভাবে একটি অ্যারের প্রসারিত করা একটি নতুন ব্লক বরাদ্দ করে এবং নতুন স্মৃতিতে যথাযথ অফসেটে সম্পূর্ণ বিদ্যমান অ্যারের একক অনুলিপি করে সম্পন্ন করা যায়। অনুভূমিক এক্সটেনশনের সাথে এর তুলনা করুন, যেখানে প্রতি সারিতে একবার আপনাকে সেই ক্রিয়াকলাপ করতে হবে কারণ নতুন ডেটাতে বিদ্যমান ডেটা সুসংগত নয়।
সর্বাধিক ঘন পরিমাণ এবং এক্সটেনশনের দিক সম্পর্কে নজর রাখুন। নতুন আকার এবং অফসেট নির্বাচন করতে সেই তথ্যটি ব্যবহার করুন যা কোনও এক্সটেনশনের জন্য পুনরায় বরাদ্দকরণ এবং অনুলিপি করার সম্ভাবনা হ্রাস করবে।

ব্যক্তিগতভাবে, আমি সন্দেহ করি যে পিক্সেল-অ্যাক্সেস-থেকে এক্সটেনশান অনুপাত কম না হলে আপনার যে কোনওটির প্রয়োজন হবে।

— Blrfl
সূত্র

1

ধ্রুব আকারের টাইলিং (বলুন, 256x256, তবে অসীম সংখ্যক টাইলস সহ)
একটি বিটম্যাপ মোড়ক সরবরাহ করুন যা নেতিবাচক পিক্সেল স্থানাঙ্ককে অনুমতি দেয় (এই ধারণাটি দিতে যে বিদ্যমান চিত্রের সমন্বয় মানগুলির সাথে পুনরায় সংগতি / সিঙ্ক্রোনাইজ করা ছাড়াই একটি চিত্র সমস্ত চারদিকে প্রসারিত হতে পারে)
- প্রকৃত বিটম্যাপ শ্রেণি (মোড়কের নীচে কাজ করা) তবে কেবল পরম (অ-নেতিবাচক) স্থানাঙ্ককে সমর্থন করা উচিত।
মোড়কের নীচে, মেমরি-ম্যাপযুক্ত I / O ব্যবহার করে টাইল-স্তর (ব্লক-স্তর) অ্যাক্সেস সরবরাহ করুন
একসাথে একক পিক্সেল সংশোধন করা ছাড়াও Map.setPixel()এবং Map.getPixel()যা একই সাথে পিক্সেলের একটি আয়তক্ষেত্র অনুলিপি করে এবং সংশোধন করে এমন পদ্ধতিও সরবরাহ করে । এটি কলারের কাছে উপলব্ধ তথ্যের উপর নির্ভর করে অ্যাক্সেসের আরও কার্যকর ফর্মটি চয়ন করতে অনুমতি দেবে।
- বাণিজ্যিক লাইব্রেরিগুলি আপডেট করার জন্য পদ্ধতিগুলি সরবরাহ করে: এক সারি পিক্সেল, পিক্সেলের একটি কলাম, স্ক্রেটার / আপডেটগুলি সংগ্রহ করা এবং পাটিগণিত / লজিক ব্লিটার অপারেশনগুলি এক ধাপে (ডেটা অনুলিপি হ্রাস করতে)।

(আসুন হাস্যকর উত্তরগুলিকে উজ্জীবিত করি না ...)

— rwong
সূত্র

0

সর্বাধিক নমনীয় এবং সম্ভবত নির্ভরযোগ্য বাস্তবায়ন এক্স-স্থানাঙ্ক, ওয়াই-কো-অর্ডিনেট এবং বিট মান দেওয়ার সাথে যুক্ত একটি লিঙ্কযুক্ত তালিকা linked আমি এটি প্রথম তৈরি করব এবং এটি কাজ করব।

তারপরে, যদি এটি খুব ধীর এবং / অথবা বড় হয় তবে এটির গতি বাড়ানোর স্বাভাবিক উপায়গুলি চেষ্টা করুন: অ্যারে, ম্যাট্রিক্স, বিটম্যাপ, সংক্ষেপণ, ক্যাশেিং, বিপরীতমুখীকরণ, কেবল '1' মানগুলি সংরক্ষণ করা ইত্যাদি

বগি দ্রুত বাস্তবায়ন স্থির করার চেয়ে ধীরে ধীরে সঠিক বাস্তবায়ন করা আরও সহজ। এবং আপনার 'দ্রুত' দ্বিতীয় বাস্তবায়ন পরীক্ষা করার সময় আপনি এর সাথে তুলনা করার জন্য একটি রেফারেন্স মান পেয়েছেন।

এবং কে জানে, আপনি সম্ভবত আবিষ্কার করতে পারবেন যে ধীর সংস্করণটি যথেষ্ট দ্রুত। যতক্ষণ না পুরো কাঠামো স্মৃতিতে ফিট করে, ইতিমধ্যে জিনিসগুলি আশ্চর্যজনকভাবে দ্রুত।

— অ্যান্ডি ক্যানফিল্ড
সূত্র

3

-1: "এটি দ্রুত তৈরি করার আগে এটি কাজ করুন" সবচেয়ে খারাপ সম্ভাব্য প্রয়োগকারী দ্বারা শুরু করা ভাল কারণ নয়। তদ্ব্যতীত, ব্যবহারিকভাবে এমন কোনও কোড থাকবে না যা অন্তর্নিহিত ডেটা কাঠামোর সাথে পুরোপুরি পরিবর্তনের প্রয়োজন হবে না, সুতরাং সেই স্তরে পুনরাবৃত্তি এখানে একটি সম্পূর্ণ asinine পরামর্শ।

— মাইকেল বার্গওয়ার্ড

এজন্য আপনার একটি এপিআই রয়েছে। এপিআই অন্তর্নিহিত বাস্তবায়নটি আড়াল করে। সেটভ্যালু (মাইম্যাট্রিক্স, এক্স, ওয়াই, মান) এবং গেটভ্যালু (মাইম্যাট্রিক্স, এক্স, ওয়াই) মাইম্যাট্রিক্স 1 বা 2 ডাইমেনশনাল অ্যারে, বা একটি লিঙ্কযুক্ত তালিকা, বা ডিস্কে ক্যাশেড, বা এসকিউএল টেবিল, বা যা কিছু লুকায়। কলারের পুনরায় সংযোগের প্রয়োজন হতে পারে তবে কোড পরিবর্তন করার প্রয়োজন নেই।

— অ্যান্ডি ক্যানফিল্ড

0

পাইথনে নিম্নলিখিত প্রয়োগের প্রস্তাব করছি:

class Map(dict): pass

এর নিম্নলিখিত সুবিধা রয়েছে:

এর মাধ্যমে গেট / সেট অ্যাক্সেস map[(1,2)]বিবেচনা করা যেতে পারে O(1)।
স্পষ্টভাবে গ্রিড প্রসারিত করার প্রয়োজনীয়তা অদৃশ্য হয়ে যায়।
বাগের জন্য খুব কম জায়গা আছে।
যদি প্রয়োজন হয় তবে এটি সহজেই 3 ডি তে আপগ্রেড করা হয়।

— blubb
সূত্র

0

আপনি যদি আসলে কোন অবাধ আকারের একটি বিটম্যাপ প্রয়োজন - এবং 1000000x1000000 করার 1x1 থেকে আমি গড় কিছু আপ AMD, এবং এটি চাহিদা এক্সপানডেবেল প্রয়োজন ... এক সম্ভাব্য উপায়ে একটি ডাটাবেস ব্যবহার করা হয়। এটি প্রথমে স্বজ্ঞাত মনে হতে পারে তবে আপনার কাছে যা আছে তা স্টোরেজ সমস্যা। একটি ডাটাবেস আপনাকে পৃথক পিক্সেল অ্যাক্সেস করতে এবং অনুমতি সহ কোনও পরিমাণের ডেটা সঞ্চয় করতে দেয়। আমি অগত্যা একটি এসকিউএল ডিবি, বিটিডাব্লু বলতে চাই না।

এটি কি আপনার উদ্দেশ্যে যথেষ্ট দ্রুত হবে? আমি উত্তর দিতে পারছি না, কারণ এই বিটম্যাপটি নিয়ে আপনি কী করছেন সে সম্পর্কে এখানে কোনও প্রসঙ্গ নেই। তবে এটি যদি স্ক্রিন প্রদর্শনের জন্য হয় তবে বিবেচনা করুন যে আপনাকে সাধারণত সমস্ত স্ক্রোল স্ক্রোল হিসাবে প্রদর্শন করতে অতিরিক্ত স্ক্যান সারিগুলি পিছনে টানতে হবে, সমস্ত ডেটা নয়।

বলা হচ্ছে, আমি সাহায্য করতে পারছি না তবে আপনি যদি কোনও ভুল সম্পর্কে যাচ্ছেন তবে ভাবছি। পরিবর্তে ভেক্টর ভিত্তিক গ্রাফিক ব্যবহার করে এবং মেমরিতে স্বতন্ত্র এন্টিটিগুলি ট্র্যাক করে এবং তারপরে পর্দার জন্য প্রয়োজনীয় বিটম্যাপটি কেবলমাত্র এত বড় করে দেওয়া উচিত?

— GrandmasterB
সূত্র

সম্ভবত কোনও ওএসজিও মানচিত্রের সার্ভার।

— rwong

0

এটি সঠিকভাবে কাজ করার জন্য পদক্ষেপ এখানে:

বিটম্যাপ উপস্থাপন করে এমন বস্তুর গাছ তৈরি করতে এক ইন্টারফেস থেকে অন্য ইন্টারফেসে ফরোয়ার্ডিং ব্যবহার করুন
বিটম্যাপের প্রতিটি "এক্সটেনশন" এর নিজস্ব স্মৃতি বরাদ্দ করবে এবং এর জন্য অন্য একটি ইন্টারফেস সরবরাহ করবে

উদাহরণ বাস্তবায়ন হবে:

template<class T, class P>
class ExtendBottom {
public:
   ExtendBottom(T &t, int count) : t(t), count(count),k(t.XSize(), count) { }
   P &At(int x, int y) const { if (y<t.YSize()) return t.At(x,y); else return k.At(x, y-t.YSize()); }
   int XSize() const { return t.XSize(); }
   int YSize() const { return t.YSize()+count; }
private:
   T &t;
   int count;
   MemoryBitmap k;
};

স্পষ্টতই বাস্তব বাস্তবায়নের জন্য, এক্সসাইজ () এবং ওয়াই সাইজ () কাজ করবে না, তবে আপনাকে সূচী সংখ্যার ধারাবাহিকতা বজায় রাখতে MinX (), ম্যাক্সএক্স (), মিনিওয়াই (), ম্যাক্সওয়াই () বা এর মতো কিছু দরকার।

— tp1
সূত্র