Method GetError

Common/DataModel/vtkAttributesErrorMetric.cxx:154–221

------------------------------------------------------------------------------ Description: Return the error at the mid-point. The type of error depends on the state of the concrete error metric. For instance, it can return an absolute or relative error metric. See RequiresEdgeSubdivision() for a description of the arguments. \post positive_result: result>=0

// See RequiresEdgeSubdivision() for a description of the arguments.
// \post positive_result: result>=0
double vtkAttributesErrorMetric::GetError(
  double* leftPoint, double* midPoint, double* rightPoint, double alpha)
{
  assert("pre: leftPoint_exists" && leftPoint != nullptr);
  assert("pre: midPoint_exists" && midPoint != nullptr);
  assert("pre: rightPoint_exists" && rightPoint != nullptr);
  assert("pre: clamped_alpha" && alpha > 0 && alpha < 1);

  double ae;
  vtkGenericAttributeCollection* ac;

  this->ComputeSquareAbsoluteAttributeTolerance();

  constexpr int ATTRIBUTE_OFFSET = 6;

  ac = this->DataSet->GetAttributes();
  vtkGenericAttribute* a = ac->GetAttribute(ac->GetActiveAttribute());

  if (this->GenericCell->IsAttributeLinear(a))
  {
    // don't need to do anything:
    ae = 0;
  }
  else
  {
    if (ac->GetActiveComponent() >= 0) // one component
    {
      int i = ac->GetAttributeIndex(ac->GetActiveAttribute()) + ac->GetActiveComponent() +
        ATTRIBUTE_OFFSET;
      double tmp = leftPoint[i] + alpha * (rightPoint[i] - leftPoint[i]) - midPoint[i];
      ae = tmp * tmp;
    }
    else // module of the vector
    {
      // If x and y are two vectors, we compute: |x-y|
      // We should compute ||x|-|y|| but |x-y| is usually enough
      // and tends to produce less degenerated edges.
      // Remind that: ||x|-|y||<=|x-y|
      int i = ac->GetAttributeIndex(ac->GetActiveAttribute()) + ATTRIBUTE_OFFSET;
      int j = 0;
      int c = ac->GetNumberOfComponents();
      double tmp;

      ae = 0;
      while (j < c)
      {
        tmp = leftPoint[i + j] + alpha * (rightPoint[i + j] - leftPoint[i + j]) - midPoint[i + j];
        ae += tmp * tmp;
        ++j;
      }
    }
  }

  double result;

  if (this->Range != 0)
  {
    result = sqrt(ae) / this->Range;