Modules/ImageProcessor/VLCImageProcessor/VLCColorSpace.cpp

Go to the documentation of this file.

#include "VLCColorSpace.h"

ColorSpace::ColorSpace ()
{
  int i;

  for (i = 0; i < numOfColors; i++)
    colorCount[i] = 0.0;

  for (i = 0; i < numOfColors; i++)
        yCount[i] = 0.0;

  y = 0;
  dY = 0;
};
  
void ColorSpace::Normalize ()
{
  int i;
  double sum = this->Sum ();

  if (sum == 0)
    return;

  for (i = 0; i < numOfColors; i++)
    colorCount[i] /= sum;

  for (i = 0; i < BRIGHTNESS_LEVELS; i++)
        yCount[i] /= sum;

  y /= sum;
  dY /= sum;
};

double ColorSpace::Sum ()
{
  double result = 0;

  for (int i = 0; i < numOfColors; i++)
    result += colorCount[i];

  return result;
};

void ColorSpace::AddSample (colorClass color, double brightness, double dY)
{
  this->colorCount[color]++;
  this->y += brightness;
  this->dY += fabs (dY);
};

colorClass ColorSpace::getMajorColor ()
{
  double maxValue = 0;
  colorClass result = noColor;

  for (int i = 0; i < numOfColors; i++)
  {
    if (maxValue < colorCount[i])
    {
      result = (colorClass)i;
      maxValue = colorCount[i];
    }
  }

  return result;
};


/*
* ------------------------------------------------------------------------------------------------------
*/
RobotDirection::RobotDirection ()
{
  int i;

  for (i = 0; i < DIRECTION_LEVELS; i++)
    directionCount[i] = 0;
};

void RobotDirection::AddSample (double direction, int weight)
{
  while (direction >= pi2)
    direction -= pi2;

  while (direction < 0)
    direction += pi2;

  int dir = (int)((direction / pi2) * ((double)DIRECTION_LEVELS));

  directionCount[dir] += weight;
};

double RobotDirection::getDirection ()
{
  double result = 0;
  double maxValue = 0;

  int i;

  for (i = 0; i < DIRECTION_LEVELS; i++)
    if (directionCount[i] > maxValue)
    {
      maxValue = directionCount[i];
      result = pi2 * ((double)i) / ((double)DIRECTION_LEVELS);
    };

  return result;
};

double RobotDirection::getReliability ()
{
  double maxValue = 0;
  double sum = 0;

  int i;

  for (i = 0; i < DIRECTION_LEVELS; i++)
  {
    if (directionCount[i] > maxValue)
    {
      maxValue = directionCount[i];
    }

    sum += directionCount[i];
  };

  if (sum == 0)
    return 0;

  return maxValue / ((double)sum);
};

---