wordrec/chop.cpp File Reference

#include "chop.h"
#include "debug.h"
#include "outlines.h"
#include "olutil.h"
#include "tordvars.h"
#include "callcpp.h"
#include "plotedges.h"
#include "const.h"
#include <math.h>

Go to the source code of this file.

Defines

• #define length_product(p1, p2)

  Compute the product of the length of two vectors.
  

Functions

• void add_point_to_list (POINT_GROUP point_list, EDGEPT *point)

  Add an edge point to a POINT_GROUP containg a list of other points.
  

• int angle_change (EDGEPT *point1, EDGEPT *point2, EDGEPT *point3)

  Return the change in angle (degrees) of the line segments between points one and two, and two and three.
  

• void init_chop ()

  Create the required chopper variables.
  

• int is_little_chunk (EDGEPT *point1, EDGEPT *point2)

  Return TRUE if one of the pieces resulting from this split would less than some number of edge points.
  

• int is_small_area (EDGEPT *point1, EDGEPT *point2)

  Test the area defined by a split accross this outline.
  

• void new_max_point (EDGEPT *local_max, POINT_GROUP points)

  Found a new minimum point try to decide whether to save it or not.
  

• void new_min_point (EDGEPT *local_min, POINT_GROUP points)

  Found a new minimum point try to decide whether to save it or not.
  

• EDGEPT * pick_close_point (EDGEPT *critical_point, EDGEPT *vertical_point, int *best_dist)

  Choose the edge point that is closest to the critical point.
  

• PRIORITY point_priority (EDGEPT *point)

  Assign a priority to and edge point that might be used as part of a split.
  

• void prioritize_points (TESSLINE *outline, POINT_GROUP points)

  Find a list of edge points from the outer outline of this blob.
  

• void vertical_projection_point (EDGEPT *split_point, EDGEPT *target_point, EDGEPT **best_point)

  Find projection for split point.
  

---

Define Documentation

#define length_product	(	p1,
		p2		)

Value:

(sqrt ((((float) (p1).x * (p1).x + (float) (p1).y * (p1).y) *    \
         ((float) (p2).x * (p2).x + (float) (p2).y * (p2).y))))

Compute the product of the length of two vectors.

The vectors must be of type POINT. This product is used in computing angles.

Definition at line 92 of file chop.cpp.

Referenced by angle_change().

---

Function Documentation

void add_point_to_list	(	POINT_GROUP	point_list,
		EDGEPT *	point
	)

Add an edge point to a POINT_GROUP containg a list of other points.

Definition at line 115 of file chop.cpp.

References chop_debug, HEAPENTRY::Data, HeapStore(), HEAPENTRY::Key, mark_outline(), MAX_NUM_POINTS, point_priority(), and SizeOfHeap.

Referenced by new_max_point(), new_min_point(), and prioritize_points().

                                                              {
  HEAPENTRY data;

  if (SizeOfHeap (point_list) < MAX_NUM_POINTS - 2) {
    data.Data = (char *) point;
    data.Key = point_priority (point);
    HeapStore(point_list, &data);
  }

#ifndef GRAPHICS_DISABLED
  if (chop_debug)
    mark_outline(point);
#endif
}

int angle_change	(	EDGEPT *	point1,
		EDGEPT *	point2,
		EDGEPT *	point3
	)

Return the change in angle (degrees) of the line segments between points one and two, and two and three.

Definition at line 136 of file chop.cpp.

References CROSS, length_product, PI, edgeptstruct::pos, SCALAR, TPOINT::x, and TPOINT::y.

                                                                 {
  VECTOR vector1;
  VECTOR vector2;

  int angle;
  float length;

  /* Compute angle */
  vector1.x = point2->pos.x - point1->pos.x;
  vector1.y = point2->pos.y - point1->pos.y;
  vector2.x = point3->pos.x - point2->pos.x;
  vector2.y = point3->pos.y - point2->pos.y;
  /* Use cross product */
  length = length_product (vector1, vector2);
  if ((int) length == 0)
    return (0);
  angle = (int) (asin (CROSS (vector1, vector2) / length) / PI * 180.0);

  /* Use dot product */
  if (SCALAR (vector1, vector2) < 0)
    angle = 180 - angle;
  /* Adjust angle */
  if (angle > 180)
    angle -= 360;
  if (angle <= -180)
    angle += 360;
  return (angle);
}

void init_chop

(

)

Create the required chopper variables.

Definition at line 170 of file chop.cpp.

Referenced by init_ms_debug().

                 {
  make_same_distance();
  make_vertical_creep();
  make_x_y_weight();
  make_chop_enable();
  make_chop_debug();
  make_split_dist();
  make_overlap_knob();
  make_sharpness_knob();
  make_width_change();
  make_good_split();
  make_ok_split();
  make_center_knob();
  make_split_length();
  make_min_points();
  make_inside_angle();
  make_outline_area();
}

int is_little_chunk	(	EDGEPT *	point1,
		EDGEPT *	point2
	)

Return TRUE if one of the pieces resulting from this split would less than some number of edge points.

Definition at line 195 of file chop.cpp.

References FALSE, is_same_edgept(), is_small_area(), min_outline_points, edgeptstruct::next, and TRUE.

Referenced by constrained_split().

                                                    {
  EDGEPT *p = point1;            /* Iterator */
  int counter = 0;

  do {
                                 /* Go from P1 to P2 */
    if (is_same_edgept (point2, p)) {
      if (is_small_area (point1, point2))
        return (TRUE);
      else
        break;
    }
    p = p->next;
  }
  while ((p != point1) && (counter++ < min_outline_points));
  /* Go from P2 to P1 */
  p = point2;
  counter = 0;
  do {
    if (is_same_edgept (point1, p)) {
      return (is_small_area (point2, point1));
    }
    p = p->next;
  }
  while ((p != point2) && (counter++ < min_outline_points));

  return (FALSE);
}

int is_small_area	(	EDGEPT *	point1,
		EDGEPT *	point2
	)

Test the area defined by a split accross this outline.

Definition at line 229 of file chop.cpp.

References CROSS, is_same_edgept(), min_outline_area, edgeptstruct::next, edgeptstruct::pos, edgeptstruct::vec, TPOINT::x, and TPOINT::y.

Referenced by is_little_chunk().

                                                  {
  EDGEPT *p = point1->next;      /* Iterator */
  int area = 0;
  TPOINT origin;

  do {
                                 /* Go from P1 to P2 */
    origin.x = p->pos.x - point1->pos.x;
    origin.y = p->pos.y - point1->pos.y;
    area += CROSS (origin, p->vec);
    p = p->next;
  }
  while (!is_same_edgept (point2, p));

  return (area < min_outline_area);
}

void new_max_point	(	EDGEPT *	local_max,
		POINT_GROUP	points
	)

Found a new minimum point try to decide whether to save it or not.

Return the new value for the local minimum. If a point is saved then the local minimum is reset to NULL.

Definition at line 382 of file chop.cpp.

References add_point_to_list(), direction(), and point_priority().

Referenced by prioritize_points().

                                                          {
  INT16 dir;

  dir = direction (local_max);

  if (dir > 0) {
    add_point_to_list(points, local_max);
    return;
  }

  if (dir == 0 && point_priority (local_max) < 0) {
    add_point_to_list(points, local_max);
    return;
  }
}

void new_min_point	(	EDGEPT *	local_min,
		POINT_GROUP	points
	)

Found a new minimum point try to decide whether to save it or not.

Return the new value for the local minimum. If a point is saved then the local minimum is reset to NULL.

Definition at line 358 of file chop.cpp.

References add_point_to_list(), direction(), and point_priority().

Referenced by prioritize_points().

                                                          {
  INT16 dir;

  dir = direction (local_min);

  if (dir < 0) {
    add_point_to_list(points, local_min);
    return;
  }

  if (dir == 0 && point_priority (local_min) < 0) {
    add_point_to_list(points, local_min);
    return;
  }
}

EDGEPT* pick_close_point	(	EDGEPT *	critical_point,
		EDGEPT *	vertical_point,
		int *	best_dist
	)

Choose the edge point that is closest to the critical point.

This point may not be exactly vertical from the critical point.

Definition at line 253 of file chop.cpp.

References edgept_dist, FALSE, is_exterior_point, edgeptstruct::next, NULL, edgeptstruct::pos, same_point, and TRUE.

Referenced by vertical_projection_point().

                                         {
  EDGEPT *best_point = NULL;
  int this_distance;
  int found_better;

  do {
    found_better = FALSE;

    this_distance = edgept_dist (critical_point, vertical_point);
    if (this_distance <= *best_dist) {

      if (!(same_point (critical_point->pos, vertical_point->pos) ||
        same_point (critical_point->pos, vertical_point->next->pos)
        || best_point != NULL
        && same_point (best_point->pos, vertical_point->pos) ||
      is_exterior_point (critical_point, vertical_point))) {
        *best_dist = this_distance;
        best_point = vertical_point;
        if (vertical_creep)
          found_better = TRUE;
      }
    }
    vertical_point = vertical_point->next;
  }
  while (found_better == TRUE);

  return (best_point);
}

PRIORITY point_priority

(

EDGEPT *

point

)

Assign a priority to and edge point that might be used as part of a split.

The argument should be of type EDGEPT.

Definition at line 106 of file chop.cpp.

References point_bend_angle.

Referenced by add_point_to_list(), grade_sharpness(), new_max_point(), new_min_point(), and prioritize_points().

                                       {
  return ((PRIORITY) point_bend_angle (point));
}

void prioritize_points	(	TESSLINE *	outline,
		POINT_GROUP	points
	)

Find a list of edge points from the outer outline of this blob.

For each of these points assign a priority. Sort these points using a heap structure so that they can be visited in order.

Definition at line 292 of file chop.cpp.

References add_point_to_list(), cprintf(), debug_5, direction(), is_inside_angle, olinestruct::loop, new_max_point(), new_min_point(), edgeptstruct::next, NULL, point_priority(), edgeptstruct::pos, edgeptstruct::prev, edgeptstruct::vec, TPOINT::x, and TPOINT::y.

Referenced by pick_good_seam().

                                                              {
  EDGEPT *this_point;
  EDGEPT *local_min = NULL;
  EDGEPT *local_max = NULL;

  this_point = outline->loop;
  local_min = this_point;
  local_max = this_point;
  do {
    if (debug_5)
      cprintf ("(%3d,%3d)  min=%3d, max=%3d, dir=%2d, ang=%2.0f\n",
        this_point->pos.x, this_point->pos.y,
        (local_min ? local_min->pos.y : 999),
      (local_max ? local_max->pos.y : 999),
      direction (this_point), point_priority (this_point));

    if (this_point->vec.y < 0) {
                                 /* Look for minima */
      if (local_max != NULL)
        new_max_point(local_max, points);
      else if (is_inside_angle (this_point))
        add_point_to_list(points, this_point);
      local_max = NULL;
      local_min = this_point->next;
    }
    else if (this_point->vec.y > 0) {
                                 /* Look for maxima */
      if (local_min != NULL)
        new_min_point(local_min, points);
      else if (is_inside_angle (this_point))
        add_point_to_list(points, this_point);
      local_min = NULL;
      local_max = this_point->next;
    }
    else {
      /* Flat area */
      if (local_max != NULL) {
        if (local_max->prev->vec.y != 0) {
          new_max_point(local_max, points);
        }
        local_max = this_point->next;
        local_min = NULL;
      }
      else {
        if (local_min->prev->vec.y != 0) {
          new_min_point(local_min, points);
        }
        local_min = this_point->next;
        local_max = NULL;
      }
    }

                                 /* Next point */
    this_point = this_point->next;
  }
  while (this_point != outline->loop);
}

void vertical_projection_point	(	EDGEPT *	split_point,
		EDGEPT *	target_point,
		EDGEPT **	best_point
	)

Find projection for split point.

Parameters:

	split_point	Split point
	target_point	FIX: point of intersection of projection with edge?
	best_point	Modified by function

Returns:

None, best_point is modified

For one point on the outline, find the corresponding point on the other side of the outline that is a likely projection for a split point.

This is done by iterating through the edge points until the X value of the point being looked at is greater than the X value of the split point. Ensure that the point found is not right next to the split point.

Note:

v1.02 used to RETURN the best_point

Definition at line 418 of file chop.cpp.

References edgept_dist, LARGE_DISTANCE, near_point(), ELIST_LINK::next, edgeptstruct::next, NULL, pick_close_point(), edgeptstruct::pos, same_point, and TPOINT::x.

Referenced by try_vertical_splits().

                                                    {
  EDGEPT *p;                     /* Iterator */
  EDGEPT *this_edgept;           /* Iterator */
  int x = split_point->pos.x;    /* X value of vertical */
  int best_dist = LARGE_DISTANCE;/* Best point found */

  if (*best_point != NULL)
    best_dist = edgept_dist(split_point, *best_point);

  p = target_point;
  /* Look at each edge point */
  do {
    if ((((p->pos.x <= x) && (x <= p->next->pos.x)) ||
      ((p->next->pos.x <= x) && (x <= p->pos.x))) &&
      !same_point (split_point->pos, p->pos) &&
      !same_point (split_point->pos, p->next->pos)
    && (*best_point == NULL || !same_point ((*best_point)->pos, p->pos))) {

      this_edgept = near_point (split_point, p, p->next);

      if (*best_point == NULL)
        best_dist = edgept_dist (split_point, this_edgept);

      this_edgept =
        pick_close_point(split_point, this_edgept, &best_dist);
      if (this_edgept)
        *best_point = this_edgept;
    }

    p = p->next;
  }
  while (p != target_point);
}

---