I have below code that needs to be recoded into Python for use in ESRI ArcGIS software.
I would greatly appreciate any assistance.
Thanks
Sheri
/* The Inner Loop of the Douglas-Peucker line generalization
algorithm is the process of finding, for a section of a polyline,
the vertex that is furthest from the line segment joining the
two endpoints. The method coded below in C (or C++) is the most
efficient, in terms of operation counts, that I have seen. */
/* _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ */
long FurthestFromSegment ( /* Return index of furthest point. */
long startindex, /* Index of start vertex in arrays. */
long endindex, /* Index of end vertex in arrays. */
double *x , /* Array, abscissae of polyline vertices. */
double *y , /* Array, ordinates of polyline vertices. */
double *distMaxSquare /* Return square of maximum distance. */
)
/*
This function, given a section of a polyline in arrays,
will return the index of the intermediate node that is furthest
from the segment joining the two endpoints of the section,
and the square of the distance from the segment.
If no intermediate point exists, then the returned index will
be the index of the start vertex and the returned distance
squared will be -1.0 . Caution: Do not calculate the square
root of this returned value without ruling out the possibility
that it may have defaulted to -1.0 . In a normal
Douglas-Peucker application, you should never have to calculate
the square root of this output value, and you should never
need to invoke this function without intermediate points.
*/
{
/*
The variable names below assume we find
the distance of point "A" from segment "BC" .
*/
long index, outindex ;
double distSquare, bcSquare ;
double cx, cy, bx, by, ax, ay ;
double bcx, bcy, bax, bay, cax, cay ;
*distMaxSquare = -1.0 ;
if ( endindex < startindex + 2 ) return startindex ;
outindex = startindex ;
bx = x[startindex] ;
by = y[startindex] ;
cx = x[endindex] ;
cy = y[endindex] ;
/* Find vector BC and the Square of its length. */
bcx = cx - bx ;
bcy = cy - by ;
bcSquare = bcx * bcx + bcy * bcy ;
/* The inner loop: */
for ( index = startindex + 1 ; index < endindex ; index++ )
{
/* Find vector BA . */
ax = x[index] ;
ay = y[index] ;
bax = ax - bx ;
bay = ay - by ;
/* Do scalar product and check sign. */
if ( bcx * bax + bcy * bay <= 0.0 )
{
/* Closest point on segment is B; */
/* find its distance (squared) from A . */
distSquare = bax * bax + bay * bay ;
}
else
{
/* Find vector CA . */
cax = ax - cx ;
cay = ay - cy ;
/* Do scalar product and check sign. */
if ( bcx * cax + bcy * cay >= 0.0 )
{
/* Closest point on segment is C; */
/* find its distance (squared) from A . */
distSquare = cax * cax + cay * cay ;
}
else
{
/* Closest point on segment is between B and C; */
/* Use perpendicular distance formula. */
distSquare = cax * bay - cay * bax ;
distSquare = distSquare * distSquare / bcSquare ;
/* Note that if bcSquare be zero, the first
of the three branches will be selected,
so division by zero will not occur here. */
}
}
if ( distSquare > *distMaxSquare )
{
outindex = index ;
*distMaxSquare = distSquare ;
}
}
/*
Note that in the inner loop above, if we follow
the most common path where the perpendicular
distance is the one to calculate, then for each
intermediate vertex the float operation count is
1 divide, 7 multiplies, 5 subtracts, 1 add, and 2 compares.
*/
return outindex ;
}
---------------------------------
Need a quick answer? Get one in minutes from people who know. Ask your question on Yahoo! Answers.