tesseract::DetLineFit Class Reference

#include <detlinefit.h>

Public Member Functions
	DetLineFit ()
	~DetLineFit ()=default
void	Clear ()
void	Add (const ICOORD &pt)
void	Add (const ICOORD &pt, int halfwidth)
double	Fit (ICOORD *pt1, ICOORD *pt2)
double	Fit (int skip_first, int skip_last, ICOORD *pt1, ICOORD *pt2)
double	ConstrainedFit (const FCOORD &direction, double min_dist, double max_dist, bool debug, ICOORD *line_pt)
bool	SufficientPointsForIndependentFit () const
double	Fit (float *m, float *c)
double	ConstrainedFit (double m, float *c)

Detailed Description

Definition at line 54 of file detlinefit.h.

Constructor & Destructor Documentation

DetLineFit()

tesseract::DetLineFit::DetLineFit

(

)

Definition at line 41 of file detlinefit.cpp.

: square_length_(0.0) {}

~DetLineFit()

tesseract::DetLineFit::~DetLineFit ( )

default

Member Function Documentation

Add() [1/2]

void tesseract::DetLineFit::Add

(

const ICOORD &

pt

)

Definition at line 50 of file detlinefit.cpp.

                                     {
  pts_.emplace_back(pt, 0);
}

Add() [2/2]

void tesseract::DetLineFit::Add	(	const ICOORD &	pt,
		int	halfwidth
	)

Definition at line 57 of file detlinefit.cpp.

                                                    {
  pts_.emplace_back(pt, halfwidth);
}

Clear()

void tesseract::DetLineFit::Clear

(

)

Definition at line 44 of file detlinefit.cpp.

                       {
  pts_.clear();
  distances_.clear();
}

ConstrainedFit() [1/2]

double tesseract::DetLineFit::ConstrainedFit	(	const FCOORD &	direction,
		double	min_dist,
		double	max_dist,
		bool	debug,
		ICOORD *	line_pt
	)

Definition at line 133 of file detlinefit.cpp.

                                                               {
  ComputeConstrainedDistances(direction, min_dist, max_dist);
  // Do something sensible with no points or computed distances.
  if (pts_.empty() || distances_.empty()) {
    line_pt->set_x(0);
    line_pt->set_y(0);
    return 0.0;
  }
  auto median_index = distances_.size() / 2;
  std::nth_element(distances_.begin(), distances_.begin() + median_index, distances_.end());
  *line_pt = distances_[median_index].data();
  if (debug) {
    tprintf("Constrained fit to dir %g, %g = %d, %d :%zu distances:\n", direction.x(), direction.y(),
            line_pt->x(), line_pt->y(), distances_.size());
    for (unsigned i = 0; i < distances_.size(); ++i) {
      tprintf("%d: %d, %d -> %g\n", i, distances_[i].data().x(), distances_[i].data().y(),
              distances_[i].key());
    }
    tprintf("Result = %zu\n", median_index);
  }
  // Center distances on the fitted point.
  double dist_origin = direction * *line_pt;
  for (auto &distance : distances_) {
    distance.key() -= dist_origin;
  }
  return sqrt(EvaluateLineFit());
}

ConstrainedFit() [2/2]

double tesseract::DetLineFit::ConstrainedFit	(	double	m,
		float *	c
	)

Definition at line 187 of file detlinefit.cpp.

                                                    {
  // Do something sensible with no points.
  if (pts_.empty()) {
    *c = 0.0f;
    return 0.0;
  }
  double cos = 1.0 / sqrt(1.0 + m * m);
  FCOORD direction(cos, m * cos);
  ICOORD line_pt;
  double error = ConstrainedFit(direction, -FLT_MAX, FLT_MAX, false, &line_pt);
  *c = line_pt.y() - line_pt.x() * m;
  return error;
}

Fit() [1/3]

double tesseract::DetLineFit::Fit	(	float *	m,
		float *	c
	)

Definition at line 171 of file detlinefit.cpp.

                                         {
  ICOORD start, end;
  double error = Fit(&start, &end);
  if (end.x() != start.x()) {
    *m = static_cast<float>(end.y() - start.y()) / (end.x() - start.x());
    *c = start.y() - *m * start.x();
  } else {
    *m = 0.0f;
    *c = 0.0f;
  }
  return error;
}

Fit() [2/3]

double tesseract::DetLineFit::Fit ( ICOORD *  pt1, ICOORD *  pt2  )

inline

Definition at line 73 of file detlinefit.h.

                                       {
    return Fit(0, 0, pt1, pt2);
  }

Fit() [3/3]

double tesseract::DetLineFit::Fit	(	int	skip_first,
		int	skip_last,
		ICOORD *	pt1,
		ICOORD *	pt2
	)

Definition at line 64 of file detlinefit.cpp.

                                                                              {
  // Do something sensible with no points.
  if (pts_.empty()) {
    pt1->set_x(0);
    pt1->set_y(0);
    *pt2 = *pt1;
    return 0.0;
  }
  // Count the points and find the first and last kNumEndPoints.
  int pt_count = pts_.size();
  ICOORD *starts[kNumEndPoints];
  if (skip_first >= pt_count) {
    skip_first = pt_count - 1;
  }
  int start_count = 0;
  int end_i = std::min(skip_first + kNumEndPoints, pt_count);
  for (int i = skip_first; i < end_i; ++i) {
    starts[start_count++] = &pts_[i].pt;
  }
  ICOORD *ends[kNumEndPoints];
  if (skip_last >= pt_count) {
    skip_last = pt_count - 1;
  }
  int end_count = 0;
  end_i = std::max(0, pt_count - kNumEndPoints - skip_last);
  for (int i = pt_count - 1 - skip_last; i >= end_i; --i) {
    ends[end_count++] = &pts_[i].pt;
  }
  // 1 or 2 points need special treatment.
  if (pt_count <= 2) {
    *pt1 = *starts[0];
    if (pt_count > 1) {
      *pt2 = *ends[0];
    } else {
      *pt2 = *pt1;
    }
    return 0.0;
  }
  // Although with between 2 and 2*kNumEndPoints-1 points, there will be
  // overlap in the starts, ends sets, this is OK and taken care of by the
  // if (*start != *end) test below, which also tests for equal input points.
  double best_uq = -1.0;
  // Iterate each pair of points and find the best fitting line.
  for (int i = 0; i < start_count; ++i) {
    ICOORD *start = starts[i];
    for (int j = 0; j < end_count; ++j) {
      ICOORD *end = ends[j];
      if (*start != *end) {
        ComputeDistances(*start, *end);
        // Compute the upper quartile error from the line.
        double dist = EvaluateLineFit();
        if (dist < best_uq || best_uq < 0.0) {
          best_uq = dist;
          *pt1 = *start;
          *pt2 = *end;
        }
      }
    }
  }
  // Finally compute the square root to return the true distance.
  return best_uq > 0.0 ? sqrt(best_uq) : best_uq;
}

SufficientPointsForIndependentFit()

bool tesseract::DetLineFit::SufficientPointsForIndependentFit

(

)

const

Definition at line 164 of file detlinefit.cpp.

                                                         {
  return distances_.size() >= kMinPointsForErrorCount;
}

---

The documentation for this class was generated from the following files:

• /media/home/debian/src/github/tesseract-ocr/tesseract/src/ccstruct/detlinefit.h
• /media/home/debian/src/github/tesseract-ocr/tesseract/src/ccstruct/detlinefit.cpp