inc/histogram.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	histoResult
Defines
#define	HISTOGRAM_H
#define	DEFAULT_BIN_COUNT   26
Functions
void	freeHistoGram (struct histoResult **histoResults)
histoResult *	histoGram (float *values, size_t N, float binSize, unsigned binCount, float minValue, float min, float max, struct histoResult *accumHisto)

---

Define Documentation

#define DEFAULT_BIN_COUNT   26

Definition at line 6 of file histogram.h.

Referenced by autoScale(), and histoGram().

#define HISTOGRAM_H

Definition at line 4 of file histogram.h.

---

Function Documentation

void freeHistoGram

(

struct histoResult **

histoResults

)

Definition at line 114 of file histogram.c.

References histoResult::binCounts, freeMem(), histoResult::next, and histoResult::pValues.

{
if (histoResults && *histoResults)
    {
    struct histoResult *hr, *next;

    for (hr = *histoResults; hr; hr = next)
        {
        next = hr->next;
        freeMem(hr->binCounts);
        freeMem(hr->pValues);
        freeMem(hr);
        }
    *histoResults = NULL;
    }
}

Here is the call graph for this function:

struct histoResult* histoGram	(	float *	values,
		size_t	N,
		float	binSize,
		unsigned	binCount,
		float	minValue,
		float	min,
		float	max,
		struct histoResult *	accumHisto
	)			[read]

Definition at line 132 of file histogram.c.

References AllocArray, AllocVar, autoScale(), histoResult::binCount, histoResult::binCounts, histoResult::binSize, histoResult::binZero, histoResult::count, DEFAULT_BIN_COUNT, FALSE, NAN, histoResult::pValues, and TRUE.

            : when giving a binCount, it is actually one
 *      higher to get the minimum and maximum values in the first and
 *      last (binCount-1) bins correctly.  The resulting histogram will
 *      appear to be (binCount-1) number of bins.
 *      When given a pointer to accumHisto, use that existing histo gram
 *      and continue accumulations in it.
 */
{
float autoBinSize = NAN;        /*      pass NAN's to cause auto scaling */
float autoMinValue = NAN;
float range = 0.0;
unsigned autoBinCount = 0;
unsigned autoValueCount = 0;
boolean autoScaling = FALSE;
unsigned valueCount = 0;
unsigned i;                     /*      array index     */
struct histoResult *hr;
unsigned missed = 0;

if (N == 0)
    return NULL;        /*      we don't work on zero number of values  */

if (accumHisto)         /*      if accumulating in existing histogram   */
    {                   /*      use its parameters as the scaling values */
    autoBinCount = accumHisto->binCount;
    autoBinSize = accumHisto->binSize;
    autoMinValue = accumHisto->binZero;
    autoScaling = FALSE;
    range = autoBinSize * (autoBinCount - 1);
    valueCount = accumHisto->count;
    }
else
    {
/*      Caller may give us a range to work within       */
if ( (0.0 == min) && (0.0 == max) )
    autoScaling = TRUE;
else
    {
    range = max - min;
    if (range == 0.0)
        return NULL;    /*      caller gave us equal min, max ! */
    }

/*      Caller may give us any of the binCount, binSize, minValue */
if (binCount > 1)
    autoBinCount = binCount;
else if (!autoScaling)
    autoBinCount = DEFAULT_BIN_COUNT;

if (!isnan(binSize))
    autoBinSize = binSize;
else if (!autoScaling)
    autoBinSize = range / (autoBinCount - 1);

if (!isnan(minValue))
    autoMinValue = minValue;
else if (!autoScaling)
    autoMinValue = min;

if (autoScaling)
    {
    autoValueCount = autoScale(values, N, &autoBinSize,
                        &autoBinCount, &autoMinValue, &min, &max);
    if (autoValueCount == 0)
        return NULL;    /*      no result !     */
    }
else
    autoValueCount = N;
    }

if (accumHisto)         /*      if accumulating in existing histogram   */
    hr = accumHisto;
else
    {
    AllocVar(hr);
    AllocArray(hr->binCounts,autoBinCount);
    AllocArray(hr->pValues,autoBinCount);
    }

for (i = 0; i < N; ++i)
    {
    if (!isnan(values[i]) && (values[i] >= autoMinValue))
        {
        if ( (values[i] <= max) && (values[i] >= min) )
            {
            float f = values[i] - autoMinValue;
            int inx = (int) floor(f / autoBinSize);

            if ( (inx >= 0) && (inx < autoBinCount))
                {
                ++valueCount;
                ++hr->binCounts[inx];
                }
            else
                ++missed;
            }
            else
                ++missed;
        }
        else
            ++missed;
    }   /*      for (i = 0; i < N; ++i) */

if (accumHisto)         /*      if accumulating in existing histogram   */
    hr->count = valueCount;     /*      only this is new        */
else
    {
    hr->binSize = autoBinSize;
    hr->binCount = autoBinCount;
    hr->count = valueCount;
    hr->binZero = autoMinValue;
    }

for (i = 0; i < autoBinCount; ++i)
    {
    if (hr->binCounts[i] > 0)
        hr->pValues[i] = (float) hr->binCounts[i] / (float) valueCount;
    else
        hr->pValues[i] = 0.0;
    }

return hr;
}

Here is the call graph for this function:

---