ViBe - पृष्ठभूमि घटाव एल्गोरिथ्म

प्रागितिहास

कुछ साल पहले, चलती वस्तुओं के आवंटन और ट्रैकिंग से संबंधित एक परियोजना के दौरान, बहुत सारे पृष्ठभूमि घटाव एल्गोरिदम देखे गए थे, और परिणामस्वरूप, जिनमें से एक पर चर्चा की जाएगी बाद में सबसे दिलचस्प में से एक निकला। इसका मुख्य दोष पेटेंट का एक गुच्छा है जिसके साथ यह संरक्षित है। लेकिन निस्संदेह लाभों में से एक लिनक्स के लिए एक पुस्तकालय की उपस्थिति है, जिसे गैर-वाणिज्यिक परियोजनाओं में उपयोग करने की अनुमति है। इसके विवरण के साथ पृष्ठ पर आप इसे बहुत ही पुस्तकालय, साथ ही विंडोज और एंड्रॉइड के लिए डेमो-प्रोग्राम, पेटेंट के लिंक (जहां आप एल्गोरिदम के मूल विवरण पा सकते हैं) और अन्य रोचक जानकारी पा सकते हैं।

एल्गोरिथ्म का उपयोग करना

लाइब्रेरी हेडर फ़ाइल में उपयोग का एक उदाहरण है। स्केल छवियों के लिए:

#include "vibe-background.h" int main(int argc, char **argv){ //   ViBe vibeModel_t *model = libvibeModelNew(); // stride -  ,     uint8_t *image_data = acquire_image(stream); int32_t width = get_image_width(stream); int32_t height = get_image_height(stream); int32_t stride = get_image_stride(stream); //     uint8_t *segmentation_map = malloc(stride * height); //     libvibeModelAllocInit_8u_C1R(model, image_data, width, height, stride); //     //   -  segmentation_map while(!finished(stream)){ image_data = acquire_image(stream); libvibeModelUpdate_8u_C1R(model, image_data, segmentation_map); } //   libvibeModelFree(model); } 

उसकी जिद

अगला सबसे दिलचस्प होगा। डेवलपर्स ने लाइब्रेरी के स्रोत पाठ को नहीं दिखाया, लेकिन अगर पेटेंट, एच - फाइल और लाइब्रेरी से विवरण है, तो रात के एक जोड़े और कई लीटर कॉफी इसे पार्स करने के लिए पर्याप्त हैं।
तो यह कैसे काम करता है

VibeModel_t संरचना:

 typedef struct { u8b *samples; u32b numberOfSamples; u32b sizeOfSample; } pixel; typedef struct { pixel *pixels; u32b width; u32b height; u32b stride; u32b numberOfSamples; u32b matchingThreshold; u32b matchingNumber; u32b updateFactor; } vibeModel; typedef vibeModel vibeModel_t; 

यहां क्यों है - यह एल्गोरिदम से आगे समझा जाएगा।
एक मॉडल बनाएं, डिफ़ॉल्ट मान सेट करें और यादृच्छिक आरंभ करें।

 vibeModel *libvibeModelNew() { vibeModel *model = (vibeModel*)calloc(1,sizeof(vibeModel)); if (model) { model->numberOfSamples = 20; model->matchingThreshold = 20; model->matchingNumber = 2; model->updateFactor = 16; } u32b seed = time(0); srand(seed); return model; } 

इसके अलावा, यहां कोड का एक गुच्छा नहीं लिखने के लिए, मान लें कि हमारे पास कुछ फ़ंक्शन है

 u32b getRandPixel(const u8b *image_data, const u32b width, const u32b height, const u32b stride, const u32b x, const u32b y); 

जो [xy] पिक्सेल के बगल में बेतरतीब ढंग से चयनित पिक्सेल का मान लौटाता है। तब मॉडल का आरंभ इस तरह दिखता है:

 s32b libvibeModelAllocInit_8u_C1R(vibeModel *model, const u8b *image_data, const u32b width, const u32b height, const u32b stride) { if (!model || !image_data || !width || !height || !stride || (stride<width)) return 1; //    model->width = width; model->height = height; model->stride = stride; //      model->pixels = 0; model->pixels = (pixel*)calloc(model->width*model->height, sizeof(pixel)); if (!model->pixels) return 1; //          . for (u32b i=0; i < model->width*model->height; i++) { model->pixels[i].numberOfSamples=model->numberOfSamples; model->pixels[i].sizeOfSample = 1; model->pixels[i].samples = 0; model->pixels[i].samples = (u8b*)calloc(model->numberOfSamples,sizeof(u8b)); if (!model->pixels[i].samples) return 1; } //  . //   .           , //       . u32b n=0; for (u32b j=0; j < model->height; j++) { for (u32b i=0; i < model->width; i++) { model->pixels[n].samples[0] = image_data[i+j*stride]; for (u32b k=1; k < model->numberOfSamples; k++) model->pixels[n].samples[k] = getRandPixel(image_data, width, height, stride, i, j); n++; } } return 0; } 

मॉडल तैयार है। LibvibeModelAllocInit_8u_C3R फ़ंक्शन की संरचना समान है, लेकिन प्रत्येक नमूने में एक बाइट नहीं है, लेकिन तीन हैं।
इसके बाद बैकग्राउंड का सबट्रेक्शन और उसके मॉडल को अपडेट करना आता है। शुरू करने के लिए, एक पिक्सेल की पृष्ठभूमि मॉडल के साथ तुलना करने के कार्य पर विचार करें, यह निम्नानुसार आयोजित किया जाता है:

 // pix_data -   // pixel -     vibeModel s32b comparePixel(u8b pix_data, pixel *pixel, u32b matchingThreshold, u32b matchingNumber) { u32b matchingCounter=0; //     for (u32b i=0; i<pixel->numberOfSamples; i++) { if (abs((s32b)pix_data-(s32b)pixel->samples[i]) < matchingThreshold) { //         MatchingNumber, //  ,         matchingCounter++; if (matchingCounter >= matchingNumber) return 1; } } return 0; } 

अभी भी एक समारोह की जरूरत है

 updateModel(vibeModel *model, u8b pix_data, u32b width, u32b height, u32b stride, u32b x, u32b y); 

जो, getRandPixel (...) की तरह लंबा और सरल है, इसलिए मैं कोड प्रदान नहीं करता। यह निम्नलिखित करता है: जब 1 / मॉडल-> अपडेटफैक्टर की संभावना के साथ कहा जाता है, तो यह पिक्सेल मॉडल [x, y] के यादृच्छिक रूप से चयनित नमूने के लिए pix_data का मान लिखता है, और पास के पिक्सेल (यादृच्छिक भी) के नमूनों में से एक के लिए।

और अंत में, मुख्य कार्य:

 s32b libvibeModelUpdate_8u_C1R(vibeModel *model, const u8b *image_data, u8b *segmentation_map) { s32b ad = model->stride - model->width; if (!model || !image_data || !segmentation_map) return 1; if (model->stride < model->width) return 1; u32b n=0; for (u32b j=0; j < model->height; j++) { for (u32b i=0; i < model->width; i++) { //      if (comparePixel(image_data[n], &(model->pixels[n]), model->matchingThreshold, model->matchingNumber)) { //    -      segmentation_map[n] = 0; updateModel(model, image_data[n], model->width, model->height, model->stride,i,j); } else { //    segmentation_map[n] = 0xFFU; } n++; } if (model->stride > model->width) n+=ad; } return 0; } 

LibvibeModelUpdate_8u_C3R के लिए सब कुछ फिर से समान है।

सामान्य इंप्रेशन

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