ZoneMinder Forums

I apologize in advance if I am asking a question that I should have been able to figure out, but I just don't get it . If I give an example maybe someone can tell me how the Min/Maximum Filtered , Filtered Area and Blob are work. I understand the concept behind the blob, but can't put all 3 together in my head:
Min/Max Alarmed Area=4000 - 0
Min/Max Filtered Area=3000 - 0
Min/Max Blob Area= 3000 - 0

I am really confused as to what I am doing. I am getting a reasonable number of appropriate alarms but I really wish I knew how this works. If someone that understands this could give me an example I think others would appreciate it also.

Thank you very much in advance.

So after 53 views not 1 person knows how this works. I find that surprising. I hate to think that this is one of those forums where every takes and no-one gives!

I am also interested because I don't understand it so much.
J.

Well in my opinion tech support is a boring job and few want to do it in there SPARE volunteer time.

http://en.wikipedia.org/wiki/Blob_detection

http://www.zoneminder.com/wiki/index.ph ... planations
I can believe its not there though

one of the dev will probably come by and say what it means in terms of zoneminder (It may take a few days)

I realize this is a spare time thing. There are quite a few people reading these forums, and there must be one that has read this that understands how the 3 blob settings relate to each other. The manual really is lacking in this area. I think many of us would like this cleared up. I wasn't trying to be a jerk, just trying to get a reaction.

Please anybody that can put this in simple terms, please let us all know.

I too am a bit perplexed. The 'filtered' concept isn't explained very well. The filter width height seems to be explained well (in order to 'participate' in further processing the pixel block must be a contiguous one of at least that size)

However the first sentence in the wiki regarding Min/Maximum Filtered area:

These are two additional bounds that specify the limits of pixels that would cause an alarm after this filtering process.

doesn't make any sense as nowhere is 'this filtering process' really defined. The rest of it is odd as well:

As the filtering process can only remove alarmed pixels it makes no sense for the Minimum and Maximum Filtered Area to be larger than the equivalent Alarmed Area

If the alarmed area is 300 min, 1000max and the 'filtering process' only operates on alarmed pixels, making it 100min and 200max would never allow an alarm as alarmed pixels would have to be 300 minimum (in this example).

However, reading this:

the next step in the analysis phase is the collation of any remaining alarmed areas into contiguous blobs. This process parses the image and forms any pixels that adjoin other alarmed pixels into one or more larger blobs. These blobs may be any shape and can be as large as the zone itself or as small as the filtered size.

May shed some light on the issue. Considering these parameters are grayed out when not using blob detection..

If the blob area can be as small as the filtered size, considering the previous 'Filter Width/Height' parameters which was pretty well explained. Perhaps this is just filtering out non-contiguous pixels blocks that aren't at least min and no larger than max? These are then combined into the 'blobs' for the next few steps?

That's my only guess on this without spending a lot of time reviewing the source code.

After reviewing this: http://www.zoneminder.com/wiki/index.ph ... _Algorithm I believe I can explain this parameter.

One thing that's not clear (or at least wasn't) is that the Alarm Check method (AlarmPixels, FilteredPixels and Blobs) are actually a 'chain' of processing. If you select AlarmPixels the analysis simply counts the number of pixels that have changed. If you select filtered pixels, the alarm must first pass the AlarmPixels test. With Blobs, the previous two analysis must pass.

I'll try to explain (as I understand it). Given the following setup:

Alarm Check Method: Blobs
Min/Max Pixel Threshold: 1
Filter Width/Height: 3/3
Min/Max Alarmed Area: 100/500
Min/Max Filtered Area: 50/200
Min/Max Blob Area: 20/150
Min/Max Blobs: 1/0

First the AlarmPixels check is made. The image is checked for differences (based on Pixel Threshold), then those differences are tallied up. For our example there are 200 pixels that changed, so proceed to the next step filtering.

Out of the pixels that passed the above alarm check, those pixels are checked for participation in a contiguous block (defined by Filtered Width/Height). Any changed pixels that are not in a block that big are removed from the 'tally' of alarmed pixels. For our example, say 100 remain. If what remains is withing the Min/Max Filtered area, this test is passed and an alarm raised. For our example, we proceed to the blob test.

Now the pixels remaining from the previous 2 tests are combined into blobs. Any that are not within the min/max blob area are removed. If any blobs remain, and the number of those blogs is within the Min/Max blobs, alarm is raised.

I think that's explains it, at least based on my understanding of the C code snipped, the Algorithm Pseudo Code wasn't very useful.