#ifdef HAVE_TBB 

class KMeansDistanceComputer

{

  float *distances;

  int *labels;

  const cv::Mat& data;

  const cv::Mat& centers;

public:

  KMeansDistanceComputer(float *_distances,

			 int *_labels,

			 const cv::Mat& _data,

			 const cv::Mat& _centers)

    : distances(_distances),

      labels(_labels),

      data(_data),

      centers(_centers)

  {

    CV_DbgAssert(centers.cols == data.cols);

  }

  void operator()(const cv::BlockedRange& range) const

  {

    const int begin = range.begin();

    const int end = range.end();

    const int K = centers.rows;

    const int dims = centers.cols;

    const float *sample;

    for( int i=begin; i<end; ++i) 

    {

      sample = data.ptr<float>(i);

      int k_best = 0;

      double min_dist = DBL_MAX;

      for( int k = 0; k < K; k++ )

      {

	  const float* center = centers.ptr<float>(k);

	  const double dist = distance(sample, center, dims);

	  if( min_dist > dist )

	  {

	      min_dist = dist;

	      k_best = k;

	  }

      }

      distances[i] = min_dist;

      labels[i] = k_best;

    }

  }

};

#endif //HAVE_TBB

#ifdef HAVE_TBB 

    cv::Mat dists(N, 1, CV_32F);

#endif //HAVE_TBB

#ifndef HAVE_TBB 

#else

	    float* dist = dists.ptr<float>(0);

	    cv::parallel_for(cv::BlockedRange(0, N),

			     KMeansDistanceComputer(dist, labels, data, centers));

	    compactness = 0;

	    for( i = 0; i < N; i++ )

	    {

	      compactness += dist[i];

	    }

#endif //HAVE_TBB