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

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

স্বয়ংক্রিয় চিত্র থ্রেসহোল্ডিং বিষয় উপস্থাপনের জন্য এই পদ্ধতি একটি সরল উদাহরণ।

অ্যালগরিদম
----------

সি নোটেশনে লিখিত নিচের তালিকাটি **ভারসাম্য হিস্টোগ্রাম থ্রেসহোল্ডিং** পদ্ধতির একটি সরল সংস্করণ: 

```
int BHThreshold(int[] histogram) {
 i\_m = (int)((i\_s + i\_e) / 2.0f); // center of the weighing scale I\_m
 w\_l = get\_weight(i\_s, i\_m + 1, histogram); // weight on the left W\_l
 w\_r = get\_weight(i\_m + 1, i\_e + 1, histogram); // weight on the right W\_r
 while (i\_s <= i\_e) {
 if (w\_r > w\_l) { // right side is heavier
 w\_r -= histogram[i\_e--];
 if (((i\_s + i\_e) / 2) < i\_m) {
 w\_r += histogram[i\_m];
 w\_l -= histogram[i\_m--];
 }
 } else if (w\_l >= w\_r) { // left side is heavier
 w\_l -= histogram[i\_s++]; 
 if (((i\_s + i\_e) / 2) >= i\_m) {
 w\_l += histogram[i\_m + 1];
 w\_r -= histogram[i\_m + 1];
 i\_m++;
 }
 }
 }
 return i\_m;
}

```
 নিম্নলিখিতটি পাইথন ভাষায় একটি সম্ভাব্য বাস্তবায়ন: 

```
def bht(hist, min\_count: int = 5) -> int:
    """Balanced histogram thresholding."""
    n\_bins = len(hist)  # assumes 1D histogram
    h\_s = 0
    while hist[h\_s] < min\_count:
        h\_s += 1  # ignore small counts at start
    h\_e = n\_bins - 1
    while hist[h\_e] < min\_count:
        h\_e -= 1  # ignore small counts at end
    # use mean intensity of histogram as center; alternatively: (h\_s + h\_e) / 2)
    h\_c = int(round(np.average(np.linspace(0, 2 \*\* 8 - 1, n\_bins), weights=hist)))
    w\_l = np.sum(hist[h\_s:h\_c])  # weight in the left part
    w\_r = np.sum(hist[h\_c : h\_e + 1])  # weight in the right part

    while h\_s < h\_e:
        if w\_l > w\_r:  # left part became heavier
            w\_l -= hist[h\_s]
            h\_s += 1
        else:  # right part became heavier
            w\_r -= hist[h\_e]
            h\_e -= 1
        new\_c = int(round((h\_e + h\_s) / 2))  # re-center the weighing scale

        if new\_c < h\_c:  # move bin to the other side
            w\_l -= hist[h\_c]
            w\_r += hist[h\_c]
        elif new\_c > h\_c:
            w\_l += hist[h\_c]
            w\_r -= hist[h\_c]

        h\_c = new\_c

    return h\_c

```

তথ্যসূত্র
---------

1. ↑  A. Anjos and H. Shahbazkia. Bi-Level Image Thresholding - A Fast Method. BIOSIGNALS 2008. Vol:2. P:70-76.
2. ↑  Nobuyuki Otsu (1979). "A threshold selection method from gray-level histograms". IEEE Trans. Sys. Man. Cyber. 9: 62–66.
3. ↑  Ridler TW, Calvard S. (1978) Picture thresholding using an iterative selection method, IEEE Trans. System, Man and Cybernetics, SMC-8: 630-632.

বহিসংযোগ
--------

* ইমেজজে প্লাগইন  ওয়েব্যাক মেশিনে আর্কাইভকৃত ১৭ অক্টোবর ২০১৩ তারিখে
* ওসু *বনাম বিএইচটি*