void adjustAntiClockWise(DjiEdge * edge){
deleteCollinearPoint(edge->edge);
deleteClosedPoint(edge->edge, MIN_DIST_TO_DELETE);
if (isSelfIntersect(edge->edge))
printLog("error isSelfIntersect, in dataPreHandle", true);
if (!isAntiClockwise(edge->edge))
{
edge->edge = reversePoints(edge->edge);
if (!isAntiClockwise(edge->edge))
{
printLog("edge points size= " + int2string(edge->edge.size()));
for (int j = 0; j < edge->edge.size(); j++)
{
printPoint(int2string(j), edge->edge[j]);
}
printLog("edge not anti-clockwise or clockwise, in dataPreHandle", true);
}
}
}
void OGRCircularString::segmentize( double dfMaxLength )
{
if( !IsValidFast() || nPointCount == 0 )
return;
// So as to make sure that the same line followed in both directions
// result in the same segmentized line.
if( paoPoints[0].x < paoPoints[nPointCount - 1].x ||
(paoPoints[0].x == paoPoints[nPointCount - 1].x &&
paoPoints[0].y < paoPoints[nPointCount - 1].y) )
{
reversePoints();
segmentize(dfMaxLength);
reversePoints();
}
std::vector<OGRRawPoint> aoRawPoint;
std::vector<double> adfZ;
for( int i = 0; i < nPointCount - 2; i += 2 )
{
const double x0 = paoPoints[i].x;
const double y0 = paoPoints[i].y;
const double x1 = paoPoints[i+1].x;
const double y1 = paoPoints[i+1].y;
const double x2 = paoPoints[i+2].x;
const double y2 = paoPoints[i+2].y;
double R = 0.0;
double cx = 0.0;
double cy = 0.0;
double alpha0 = 0.0;
double alpha1 = 0.0;
double alpha2 = 0.0;
aoRawPoint.push_back(OGRRawPoint(x0, y0));
if( padfZ )
adfZ.push_back(padfZ[i]);
// We have strong constraints on the number of intermediate points
// we can add.
if( OGRGeometryFactory::GetCurveParmeters(x0, y0, x1, y1, x2, y2,
R, cx, cy,
alpha0, alpha1, alpha2) )
{
// It is an arc circle.
const double dfSegmentLength1 = fabs(alpha1 - alpha0) * R;
const double dfSegmentLength2 = fabs(alpha2 - alpha1) * R;
if( dfSegmentLength1 > dfMaxLength ||
dfSegmentLength2 > dfMaxLength )
{
const double dfVal =
1 + 2 * std::floor(dfSegmentLength1 / dfMaxLength / 2.0);
if ( dfVal >= std::numeric_limits<int>::max() ||
dfVal < 0.0 ||
CPLIsNan(dfVal) )
{
CPLError(
CE_Failure, CPLE_AppDefined,
"segmentize nIntermediatePoints invalid: %lf", dfVal);
break;
}
const int nIntermediatePoints = static_cast<int>(dfVal);
const double dfStep =
(alpha1 - alpha0) / (nIntermediatePoints + 1);
for( int j = 1; j <= nIntermediatePoints; ++j )
{
double alpha = alpha0 + dfStep * j;
const double x = cx + R * cos(alpha);
const double y = cy + R * sin(alpha);
aoRawPoint.push_back(OGRRawPoint(x, y));
if( padfZ )
{
const double z =
padfZ[i] +
(padfZ[i+1] - padfZ[i]) * (alpha - alpha0) /
(alpha1 - alpha0);
adfZ.push_back(z);
}
}
}
aoRawPoint.push_back(OGRRawPoint(x1, y1));
if( padfZ )
adfZ.push_back(padfZ[i+1]);
if( dfSegmentLength1 > dfMaxLength ||
dfSegmentLength2 > dfMaxLength )
{
const double dfVal =
1 + 2 * std::floor(dfSegmentLength2 / dfMaxLength / 2.0);
if ( dfVal >= std::numeric_limits<int>::max() ||
dfVal < 0.0 ||
CPLIsNan(dfVal) )
{
CPLError(
CE_Failure, CPLE_AppDefined,
"segmentize nIntermediatePoints invalid 2: %lf", dfVal);
break;
}
int nIntermediatePoints = static_cast<int>(dfVal);
const double dfStep =
(alpha2 - alpha1) / (nIntermediatePoints + 1);
for( int j = 1; j <= nIntermediatePoints; ++j )
{
const double alpha = alpha1 + dfStep * j;
const double x = cx + R * cos(alpha);
const double y = cy + R * sin(alpha);
aoRawPoint.push_back(OGRRawPoint(x, y));
if( padfZ )
{
const double z =
padfZ[i+1] +
(padfZ[i+2] - padfZ[i+1]) *
(alpha - alpha1) / (alpha2 - alpha1);
adfZ.push_back(z);
}
}
}
}
else
{
// It is a straight line.
const double dfSegmentLength1 = dist(x0, y0, x1, y1);
const double dfSegmentLength2 = dist(x1, y1, x2, y2);
if( dfSegmentLength1 > dfMaxLength ||
dfSegmentLength2 > dfMaxLength )
{
const double dfVal =
1 + 2 * std::ceil(dfSegmentLength1 / dfMaxLength / 2.0);
if ( dfVal >= std::numeric_limits<int>::max() ||
dfVal < 0.0 ||
CPLIsNan(dfVal) )
{
CPLError(
CE_Failure, CPLE_AppDefined,
"segmentize nIntermediatePoints invalid 2: %lf", dfVal);
break;
}
int nIntermediatePoints = static_cast<int>(dfVal);
for( int j = 1; j <= nIntermediatePoints; ++j )
{
aoRawPoint.push_back(OGRRawPoint(
x0 + j * (x1-x0) / (nIntermediatePoints + 1),
y0 + j * (y1-y0) / (nIntermediatePoints + 1)));
if( padfZ )
adfZ.push_back(padfZ[i] + j * (padfZ[i+1]-padfZ[i]) /
(nIntermediatePoints + 1));
}
}
aoRawPoint.push_back(OGRRawPoint(x1, y1));
if( padfZ )
adfZ.push_back(padfZ[i+1]);
if( dfSegmentLength1 > dfMaxLength ||
dfSegmentLength2 > dfMaxLength )
{
const double dfVal =
1 + 2 * std::ceil(dfSegmentLength2 / dfMaxLength / 2.0);
if ( dfVal >= std::numeric_limits<int>::max() ||
dfVal < 0.0 ||
CPLIsNan(dfVal) )
{
CPLError(
CE_Failure, CPLE_AppDefined,
"segmentize nIntermediatePoints invalid 3: %lf", dfVal);
break;
}
const int nIntermediatePoints = static_cast<int>(dfVal);
for( int j = 1; j <= nIntermediatePoints; ++j )
{
aoRawPoint.push_back(OGRRawPoint(
x1 + j * (x2-x1) / (nIntermediatePoints + 1),
y1 + j * (y2-y1) / (nIntermediatePoints + 1)));
if( padfZ )
adfZ.push_back(padfZ[i+1] + j * (padfZ[i+2]-padfZ[i+1])
/ (nIntermediatePoints + 1));
}
}
}
}
aoRawPoint.push_back(paoPoints[nPointCount-1]);
if( padfZ )
adfZ.push_back(padfZ[nPointCount-1]);
CPLAssert(aoRawPoint.empty() ||
(aoRawPoint.size() >= 3 && (aoRawPoint.size() % 2) == 1));
if( padfZ )
{
CPLAssert(adfZ.size() == aoRawPoint.size());
}
// Is there actually something to modify?
if( nPointCount < static_cast<int>(aoRawPoint.size()) )
{
nPointCount = static_cast<int>(aoRawPoint.size());
paoPoints = static_cast<OGRRawPoint *>(
CPLRealloc(paoPoints, sizeof(OGRRawPoint) * nPointCount));
memcpy(paoPoints, &aoRawPoint[0], sizeof(OGRRawPoint) * nPointCount);
if( padfZ )
{
padfZ = static_cast<double *>(
CPLRealloc(padfZ, sizeof(double) * aoRawPoint.size()));
memcpy(padfZ, &adfZ[0], sizeof(double) * nPointCount);
}
}
}
