bool ON_IntersectLineLine(
const ON_Line& lineA,
const ON_Line& lineB,
double* a,
double* b,
double tolerance,
bool bIntersectSegments
)
{
bool rc = ON_Intersect(lineA,lineB,a,b) ? true : false;
if (rc)
{
if ( bIntersectSegments )
{
if ( *a < 0.0 )
*a = 0.0;
else if ( *a > 1.0 )
*a = 1.0;
if ( *b < 0.0 )
*b = 0.0;
else if ( *b > 1.0 )
*b = 1.0;
}
if ( tolerance > 0.0 )
{
rc = (lineA.PointAt(*a).DistanceTo(lineB.PointAt(*b)) <= tolerance);
}
}
return rc;
}
double ON_Line::MinimumDistanceTo( const ON_Line& L ) const
{
ON_3dPoint A, B;
double a, b, t, x, d;
bool bCheckA, bCheckB;
bool bGoodX = ON_Intersect(*this,L,&a,&b);
bCheckA = true;
if ( a < 0.0) a = 0.0; else if (a > 1.0) a = 1.0; else bCheckA=!bGoodX;
bCheckB = true;
if ( b < 0.0) b = 0.0; else if (b > 1.0) b = 1.0; else bCheckB=!bGoodX;
A = PointAt(a);
B = L.PointAt(b);
d = A.DistanceTo(B);
if ( bCheckA )
{
L.ClosestPointTo(A,&t);
if (t<0.0) t = 0.0; else if (t > 1.0) t = 1.0;
x = L.PointAt(t).DistanceTo(A);
if ( x < d )
d = x;
}
if ( bCheckB )
{
ClosestPointTo(B,&t);
if (t<0.0) t = 0.0; else if (t > 1.0) t = 1.0;
x = PointAt(t).DistanceTo(B);
if (x < d )
d = x;
}
return d;
}
int ON_Intersect(
const ON_Line& line,
const ON_Arc& arc,
double* line_t0,
ON_3dPoint& arc_point0,
double* line_t1,
ON_3dPoint& arc_point1
)
{
ON_Circle c = arc;
ON_3dPoint p[2];
double t[2], a[2], s;
ON_BOOL32 b[2] = {false,false};
int i, xcnt = ON_Intersect( line, c, &t[0], p[0], &t[1], p[1] );
if ( xcnt > 0 )
{
// make sure points are on the arc;
ON_Interval arc_domain = arc.DomainRadians();
for ( i = 0; i < xcnt; i++ )
{
b[i] = c.ClosestPointTo(p[i], &a[i]);
if ( b[i] )
{
s = arc_domain.NormalizedParameterAt(a[i]);
if ( s < 0.0 )
{
if ( s >= -ON_SQRT_EPSILON )
{
a[i] = arc_domain[0];
p[i] = c.PointAt(a[i]);
b[i] = line.ClosestPointTo( p[i], &t[i] );
}
else
b[i] = false;
}
else if ( s > 1.0 )
{
if ( s <= 1.0+ON_SQRT_EPSILON )
{
a[i] = arc_domain[1];
p[i] = c.PointAt(a[i]);
b[i] = line.ClosestPointTo( p[i], &t[i] );
}
else
b[i] = false;
}
}
}
if ( !b[0] && !b[1] )
xcnt = 0;
if ( xcnt == 2 )
{
if ( !b[1] )
xcnt = 1;
if ( !b[0] )
{
xcnt = 1;
b[0] = b[1];
t[0] = t[1];
a[0] = a[1];
p[0] = p[1];
b[1] = 0;
}
if ( xcnt == 2 && t[0] == t[1] )
{
xcnt = 1;
b[1] = 0;
ON_3dPoint q = line.PointAt(t[0]);
if ( p[0].DistanceTo(q) > p[1].DistanceTo(q) )
{
a[0] = a[1];
t[0] = t[1];
p[0] = p[1];
}
}
}
if ( xcnt == 1 && !b[0] )
xcnt = 0;
if ( xcnt >= 1 )
{
if ( line_t0 )
*line_t0 = t[0];
arc_point0 = p[0];
}
if ( xcnt == 2 )
{
if ( line_t1 )
*line_t1 = t[1];
arc_point1 = p[1];
}
}
return xcnt;
}
int ON_Intersect(
const ON_Line& line,
const ON_Circle& circle,
double* line_t0,
ON_3dPoint& circle_point0,
double* line_t1,
ON_3dPoint& circle_point1
)
{
// transform to coordinate system where equation of circle
// is x^2 + y^2 = R^2 and solve for line parameter(s).
ON_Xform xform;
xform.ChangeBasis( circle.plane, ON_xy_plane );
xform.ChangeBasis( ON_xy_plane, circle.plane );
ON_Line L = line;
L.Transform(xform);
double r = fabs(circle.radius);
double tol = r*ON_SQRT_EPSILON;
if ( tol < ON_ZERO_TOLERANCE )
tol = ON_ZERO_TOLERANCE;
int xcnt;
if ( fabs(L.from.x - L.to.x) <= tol
&& fabs(L.from.y - L.to.y) <= tol
&& fabs(L.from.z - L.to.z) > tol )
{
xcnt = 0;
}
else
{
xcnt = Intersect2dLineCircle( L.from, L.to, r, tol, line_t0, line_t1 );
if ( xcnt == 3 )
xcnt = 1;
}
if ( xcnt == 0 )
{
if ( L.ClosestPointTo( circle.Center(), line_t0 ) )
{
xcnt = 1;
*line_t1 = *line_t0;
}
}
ON_3dPoint line_point1, line_point0 = line.PointAt(*line_t0);
circle_point0 = circle.ClosestPointTo(line_point0);
double d1, d0 = line_point0.DistanceTo(circle_point0);
if ( xcnt == 2 )
{
line_point1 = line.PointAt(*line_t1);
circle_point1 = circle.ClosestPointTo(line_point1);
d1 = line_point1.DistanceTo(circle_point1);
}
else
{
line_point1 = line_point0;
circle_point1 = circle_point0;
d1 = d0;
}
if ( xcnt==2 && (d0 > tol && d1 > tol) )
{
xcnt = 1;
if ( d0 <= d1 )
{
*line_t1 = *line_t0;
line_point1 = line_point0;
circle_point1 = circle_point0;
d1 = d0;
}
else
{
*line_t0 = *line_t1;
line_point0 = line_point1;
circle_point0 = circle_point1;
d0 = d1;
}
}
if ( xcnt == 1 && d0 > tol )
{
// TODO: iterate to closest point
}
return xcnt;
}
int ON_Intersect( // returns 0 = no intersections,
// 1 = one intersection,
// 2 = 2 intersections
// 3 = line lies on cylinder
// If 0 is returned, first point is point
// on line closest to cylinder and 2nd point is the point
// on the sphere closest to the line.
// If 1 is returned, first point is obtained by evaluating
// the line and the second point is obtained by evaluating
// the cylinder.
const ON_Line& line,
const ON_Cylinder& cylinder, // if cylinder.height[0]==cylinder.height[1],
// then infinite cyl is used. Otherwise
// finite cyl is used.
ON_3dPoint& A, ON_3dPoint& B // intersection point(s) returned here
)
{
ON_BOOL32 bFiniteCyl = true;
int rc = 0;
const double cylinder_radius = fabs(cylinder.circle.radius);
double tol = cylinder_radius*ON_SQRT_EPSILON;
if ( tol < ON_ZERO_TOLERANCE )
tol = ON_ZERO_TOLERANCE;
ON_Line axis;
axis.from = cylinder.circle.plane.origin + cylinder.height[0]*cylinder.circle.plane.zaxis;
axis.to = cylinder.circle.plane.origin + cylinder.height[1]*cylinder.circle.plane.zaxis;
if ( axis.Length() <= tol ) {
axis.to = cylinder.circle.plane.origin + cylinder.circle.plane.zaxis;
bFiniteCyl = false;
}
//ON_BOOL32 bIsParallel = false;
double line_t, axis_t;
if ( !ON_Intersect(line,axis,&line_t,&axis_t) ) {
axis.ClosestPointTo( cylinder.circle.plane.origin, &axis_t );
line.ClosestPointTo( cylinder.circle.plane.origin, &line_t );
}
ON_3dPoint line_point = line.PointAt(line_t);
ON_3dPoint axis_point = axis.PointAt(axis_t);
double d = line_point.DistanceTo(axis_point);
if ( bFiniteCyl ) {
if ( axis_t < 0.0 )
axis_t = 0.0;
else if ( axis_t > 1.0 )
axis_t = 1.0;
axis_point = axis.PointAt(axis_t);
}
if ( d >= cylinder_radius-tol) {
rc = ( d <= cylinder_radius+tol ) ? 1 : 0;
A = line_point;
ON_3dVector V = line_point - axis_point;
if ( bFiniteCyl ) {
V = V - (V*cylinder.circle.plane.zaxis)*cylinder.circle.plane.zaxis;
}
V.Unitize();
B = axis_point + cylinder_radius*V;
if ( rc == 1 ) {
// check for overlap
ON_3dPoint P = axis.ClosestPointTo(line.from);
d = P.DistanceTo(line.from);
if ( fabs(d-cylinder_radius) <= tol ) {
P = axis.ClosestPointTo(line.to);
d = P.DistanceTo(line.to);
if ( fabs(d-cylinder_radius) <= tol ) {
rc = 3;
A = cylinder.ClosestPointTo(line.from);
B = cylinder.ClosestPointTo(line.to);
}
}
}
}
else {
// transform to coordinate system where equation of cyl
// is x^2 + y^2 = R^2 and solve for line parameter(s).
ON_Xform xform;
xform.Rotation( cylinder.circle.plane, ON_xy_plane );
ON_Line L = line;
L.Transform(xform);
const double x0 = L.from.x;
const double x1 = L.to.x;
const double x1mx0 = x1-x0;
double ax = x1mx0*x1mx0;
double bx = 2.0*x1mx0*x0;
double cx = x0*x0;
const double y0 = L.from.y;
const double y1 = L.to.y;
const double y1my0 = y1-y0;
double ay = y1my0*y1my0;
double by = 2.0*y1my0*y0;
double cy = y0*y0;
double t0, t1;
int qerc = ON_SolveQuadraticEquation(ax+ay, bx+by, cx+cy-cylinder_radius*cylinder_radius,
&t0,&t1);
if ( qerc == 2 ) {
// complex roots - ignore (tiny) imaginary part caused by computational noise.
t1 = t0;
}
A = cylinder.ClosestPointTo(line.PointAt(t0));
B = cylinder.ClosestPointTo(line.PointAt(t1));
d = A.DistanceTo(B);
if ( d <= ON_ZERO_TOLERANCE ) {
A = line_point;
ON_3dVector V = line_point - axis_point;
if ( bFiniteCyl ) {
V = V - (V*cylinder.circle.plane.zaxis)*cylinder.circle.plane.zaxis;
}
V.Unitize();
B = axis_point + cylinder_radius*V;
rc = 1;
}
else
rc = 2;
}
return rc;
}
bool ON_Intersect( const ON_BoundingBox& bbox,
const ON_Line& line,
double tol,
ON_Interval* line_parameters)
{
double a,b,d,mn,mx,s0,s1, t0, t1;
const double M = 1.0e308;
// i,j,k are indices of coordinates to trim.
// trim the direction with the biggest line deltas first
ON_3dVector v = line.Direction();
const int i = v.MaximumCoordinateIndex();
// gaurd against ON_UNSET_VALUE as input
if ( !(tol >= 0.0) )
tol = 0.0;
// clip i-th coordinate
a = line.from[i];
b = line.to[i];
mn = bbox.m_min[i];
mx = bbox.m_max[i];
if ( !(mn <= mx) )
return false;
mn -= (tol+a);
mx += (tol-a);
if ( !(mn <= mx) )
return false;
d = b-a;
if ( 0.0 == d )
{
// happens when line.from == line.to
if ( 0.0 < mn || 0.0 > mx )
{
// point is in box
if ( line_parameters )
{
// setting parameters makes no sense - just use 0.0
// so it's clear we have a point
line_parameters->Set(0.0,0.0);
}
return true;
}
return false; // point is outside box
}
if ( fabs(d) < 1.0 && (fabs(mn) >= fabs(d)*M || fabs(mx) >= fabs(d)*M) )
{
// the value of mn/d or mx/d is too large for a realistic answer to be computed
return false;
}
d = 1.0/d;
t0 = mn*d;
t1 = mx*d;
// set "chord" = line segment that begins and ends on the
// i-th coordinate box side planes.
ON_Line chord(line.PointAt(t0),line.PointAt(t1));
// test j-th coordinate direction
const int j = (i + (fabs(v[(i+1)%3])>fabs(v[(i+2)%3])?1:2) ) % 3;
a = chord.from[j];
b = chord.to[j];
mn = bbox.m_min[j];
mx = bbox.m_max[j];
if ( !(mn <= mx) )
return false;
mn -= (tol+a);
mx += (tol-a);
if ( !(mn <= mx) )
return false;
d = b-a;
if ( (0.0 < mn && d < mn) || (0.0 > mx && d > mx) )
{
// chord lies outside the box
return false;
}
while ( fabs(d) >= 1.0 || (fabs(mn) <= fabs(d)*M && fabs(mx) <= fabs(d)*M) )
{
// The chord is not (nearly) parallel to the j-th sides.
// See if the chord needs to be trimmed by the j-th sides.
d = 1.0/d;
s0 = mn*d;
s1 = mx*d;
if ( s0 > 1.0 )
{
if ( s1 > 1.0 )
{
// unstable calculation happens when
// fabs(d) is very tiny and chord is
// on the j-th side.
break;
}
s0 = 1.0;
}
else if ( s0 < 0.0 )
{
if (s1 < 0.0)
{
// unstable calculation happens when
// fabs(d) is very tiny and chord is
// on the j-th side.
break;
}
s0 = 0.0;
}
if ( s1 < 0.0 ) s1 = 0.0; else if ( s1 > 1.0 ) s1 = 1.0;
d = (1.0-s0)*t0 + s0*t1;
t1 = (1.0-s1)*t0 + s1*t1;
t0 = d;
v = chord.PointAt(s0);
chord.to = chord.PointAt(s1);
chord.from = v;
break;
}
// test k-th coordinate direction
const int k = (i&&j) ? 0 : ((i!=1&&j!=1)?1:2);
a = chord.from[k];
b = chord.to[k];
mn = bbox.m_min[k];
mx = bbox.m_max[k];
if ( !(mn <= mx) )
return false;
mn -= (tol+a);
mx += (tol-a);
if ( !(mn <= mx) )
return false;
d = b-a;
if ( (0.0 < mn && d < mn) || (0.0 > mx && d > mx) )
{
// chord does not intersect the rectangle
return false;
}
if ( line_parameters )
{
while ( fabs(d) >= 1.0 || (fabs(mn) <= fabs(d)*M && fabs(mx) <= fabs(d)*M) )
{
// The chord is not (nearly) parallel to the k-th sides.
// See if the chord needs to be trimmed by the k-th sides.
d = 1.0/d;
s0 = mn*d;
s1 = mx*d;
if ( s0 > 1.0 )
{
if ( s1 > 1.0 )
{
// unstable calculation happens when
// fabs(d) is very tiny and chord is
// on the k-th side.
break;
}
s0 = 1.0;
}
else if ( s0 < 0.0 )
{
if (s1 < 0.0)
{
// unstable calculation happens when
// fabs(d) is very tiny and chord is
// on the k-th side.
break;
}
s0 = 0.0;
}
if ( s1 < 0.0 ) s1 = 0.0; else if ( s1 > 1.0 ) s1 = 1.0;
d = (1.0-s0)*t0 + s0*t1;
t1 = (1.0-s1)*t0 + s1*t1;
t0 = d;
break;
}
if (t0 > t1 )
{
line_parameters->Set(t1,t0);
}
else
{
line_parameters->Set(t0,t1);
}
}
return true;
}
bool ON_Intersect( const ON_Line& lineA, const ON_Line& lineB,
double* lineA_parameter,
double* lineB_parameter
)
{
// If you are looking at this code because you don't like an
// answer you are getting, then the first thing to try is
// to read the header file comments and try calling
// ON_IntersectLineLine.
bool rc = false;
double M_zero_tol = 0.0;
int i, rank;
double pr_tolerance, pivot, X[2], Y[2];
ON_3dVector A = lineA.Direction();
ON_3dVector B = lineB.Direction();
ON_3dVector C = lineB[0] - lineA[0];
ON_Matrix M(2,2);
M[0][0] = ON_DotProduct( A, A );
M[1][1] = ON_DotProduct( B, B );
M[0][1] = M[1][0] = -ON_DotProduct( A, B );
// this swap done to get row+col pivot accuracy
if ( M[0][0] < M[1][1] ) {
M.SwapCols(0,1);
i = 1;
}
else {
i = 0;
}
pr_tolerance = fabs(M[1][1])*ON_SQRT_EPSILON;
M_zero_tol = fabs(M[1][1])*ON_EPSILON;
Y[0] = ON_DotProduct( A, C );
Y[1] = -ON_DotProduct( B, C );
rank = M.RowReduce( M_zero_tol, Y, &pivot );
if ( rank == 2 )
{
// 19 November 2003 Dale Lear and Chuck
// Added lineA.from/to == lineB.from/to tests
// so exact answer gets returned when people
// expect it.
rc = true;
if ( lineA.from == lineB.from )
{
if ( lineA_parameter )
*lineA_parameter = 0.0;
if ( lineB_parameter )
*lineB_parameter = 0.0;
}
else if ( lineA.from == lineB.to )
{
if ( lineA_parameter )
*lineA_parameter = 0.0;
if ( lineB_parameter )
*lineB_parameter = 1.0;
}
else if ( lineA.to == lineB.from )
{
if ( lineA_parameter )
*lineA_parameter = 1.0;
if ( lineB_parameter )
*lineB_parameter = 0.0;
}
else if ( lineA.to == lineB.to )
{
if ( lineA_parameter )
*lineA_parameter = 1.0;
if ( lineB_parameter )
*lineB_parameter = 1.0;
}
else
{
rc = M.BackSolve( 0.0, 2, Y, X );
if ( rc )
{
if ( lineA_parameter )
*lineA_parameter = X[i];
if ( lineB_parameter )
*lineB_parameter = X[1-i];
if ( fabs(pivot) <= pr_tolerance )
{
// test answer because matrix was close to singular
// (This test is slow but it is rarely used.)
ON_3dPoint pA = lineA.PointAt(X[i]);
ON_3dPoint pB = lineB.PointAt(X[1-i]);
double d = pA.DistanceTo(pB);
if ( d > pr_tolerance && d > ON_ZERO_TOLERANCE ) {
ON_3dPoint qA = lineA.ClosestPointTo(pB);
ON_3dPoint qB = lineB.ClosestPointTo(pA);
double dA = pA.DistanceTo(qB);
double dB = pB.DistanceTo(qA);
if ( 1.1*dA < d ) {
rc = false;
}
else if ( 1.1*dB < d ) {
rc = false;
}
}
}
}
}
}
return rc;
}
bool ON_Mesh::EvaluatePoint( const class ON_ObjRef& objref, ON_3dPoint& P ) const
{
// virtual function default
P = ON_UNSET_POINT;
ON_COMPONENT_INDEX ci = objref.m_component_index;
switch ( ci.m_type )
{
case ON_COMPONENT_INDEX::mesh_vertex:
if ( ci.m_index >= 0 && ci.m_index < m_V.Count() )
P = m_V[ci.m_index];
break;
case ON_COMPONENT_INDEX::meshtop_vertex:
if ( ci.m_index >= 0 && ci.m_index < m_top.m_topv.Count() )
{
const ON_MeshTopologyVertex& topv = m_top.m_topv[ci.m_index];
if ( topv.m_v_count > 0 && topv.m_vi )
{
int vi = topv.m_vi[0];
if ( vi >= 0 && vi < m_V.Count() )
P = m_V[vi];
}
}
break;
case ON_COMPONENT_INDEX::meshtop_edge:
if ( 5 == objref.m_evp.m_t_type
&& fabs(objref.m_evp.m_t[0] + objref.m_evp.m_t[1] - 1.0) <= ON_SQRT_EPSILON )
{
ON_Line L = m_top.TopEdgeLine(ci.m_index);
if ( L.IsValid() )
{
P = L.PointAt(objref.m_evp.m_t[0]);
}
}
break;
case ON_COMPONENT_INDEX::mesh_face:
if ( 4 == objref.m_evp.m_t_type
&& fabs(objref.m_evp.m_t[0] + objref.m_evp.m_t[1] + objref.m_evp.m_t[2] + objref.m_evp.m_t[3] - 1.0) <= ON_SQRT_EPSILON )
{
if ( ci.m_index >= 0 && ci.m_index < m_F.Count() )
{
const int* fvi = m_F[ci.m_index].vi;
if ( fvi[0] < 0 || fvi[0] >= m_V.Count() )
break;
if ( fvi[1] < 0 || fvi[1] >= m_V.Count() )
break;
if ( fvi[2] < 0 || fvi[2] >= m_V.Count() )
break;
if ( fvi[3] < 0 || fvi[3] >= m_V.Count() )
break;
ON_3dPoint V[4];
V[0] = m_V[fvi[0]];
V[1] = m_V[fvi[1]];
V[2] = m_V[fvi[2]];
V[3] = m_V[fvi[3]];
P = objref.m_evp.m_t[0]*V[0] + objref.m_evp.m_t[1]*V[1] + objref.m_evp.m_t[2]*V[2] + objref.m_evp.m_t[3]*V[3];
}
}
break;
default:
// intentionally skipping other ON_COMPONENT_INDEX::TYPE enum values
break;
}
return P.IsValid();
}
bool ON_Mesh::CollapseEdge( int topei )
{
ON_Mesh& mesh = *this;
ON__MESHEDGE me;
memset(&me,0,sizeof(me));
const ON_MeshTopology& top = mesh.Topology();
const int F_count = mesh.m_F.Count();
const int V_count = mesh.m_V.Count();
const int topv_count = top.m_topv.Count();
//const int tope_count = top.m_tope.Count();
if ( topei < 0 || topei >= top.m_tope.Count() )
{
return false;
}
const ON_MeshTopologyEdge& tope = top.m_tope[topei];
if ( tope.m_topf_count < 1
|| tope.m_topvi[0] == tope.m_topvi[1]
|| tope.m_topvi[0] < 0
|| tope.m_topvi[1] < 0
|| tope.m_topvi[0] >= topv_count
|| tope.m_topvi[1] >= topv_count )
{
return false;
}
const ON_MeshTopologyVertex& topv0 = top.m_topv[tope.m_topvi[0]];
const ON_MeshTopologyVertex& topv1 = top.m_topv[tope.m_topvi[1]];
if ( topv0.m_v_count < 1 || topv1.m_v_count < 1 )
{
return false;
}
if ( topv0.m_vi[0] < 0 || topv0.m_vi[0] >= V_count )
{
return false;
}
if ( topv1.m_vi[0] < 0 || topv1.m_vi[0] >= V_count )
{
return false;
}
// create a ON__MESHEDGE for each face (usually one or two) that uses the edge
ON__MESHEDGE* me_list = (ON__MESHEDGE*)alloca(tope.m_topf_count*sizeof(me_list[0]));
int me_list_count = 0;
int efi;
for ( efi = 0; efi < tope.m_topf_count; efi++ )
{
int fi = tope.m_topfi[efi];
if ( fi < 0 || fi >= F_count )
continue;
const ON_MeshFace& f = mesh.m_F[fi];
if ( !f.IsValid(V_count) )
continue;
me.vi1 = f.vi[3];
me.topvi1 = top.m_topv_map[me.vi1];
int fvi;
for ( fvi = 0; fvi < 4; fvi++ )
{
me.vi0 = me.vi1;
me.topvi0 = me.topvi1;
me.vi1 = f.vi[fvi];
me.topvi1 = top.m_topv_map[me.vi1];
if ( me.vi0 != me.vi1 )
{
if ( (me.topvi0 == tope.m_topvi[0] && me.topvi1 == tope.m_topvi[1])
|| (me.topvi0 == tope.m_topvi[1] && me.topvi1 == tope.m_topvi[0]) )
{
if ( me.vi0 > me.vi1 )
{
int i = me.vi0; me.vi0 = me.vi1; me.vi1 = i;
i = me.topvi0; me.topvi0 = me.topvi1; me.topvi1 = i;
}
me_list[me_list_count++] = me;
break;
}
}
}
}
if (me_list_count<1)
{
return false;
}
// Sort me_list[] so edges using same vertices are adjacent
// to each other in the list. This is needed so that non-manifold
// crease edges will be properly collapsed.
ON_qsort(me_list,me_list_count,sizeof(me_list[0]),(QSORTCMPFUNC)CompareMESHEDGE);
// create new vertex or vertices that edge will be
// collapsed to.
mesh.m_C.Destroy();
mesh.m_K.Destroy();
int mei;
bool bHasVertexNormals = mesh.HasVertexNormals();
bool bHasTextureCoordinates = mesh.HasTextureCoordinates();
bool bHasFaceNormals = mesh.HasFaceNormals();
if ( topv0.m_v_count == 1 || topv1.m_v_count == 1 )
{
// a single new vertex
ON_Line Vline(ON_origin,ON_origin);
ON_Line Tline(ON_origin,ON_origin);
ON_3dVector N0(0,0,0);
ON_3dVector N1(0,0,0);
ON_3dPoint P;
int vi, tvi, cnt;
int newvi = topv0.m_vi[0];
cnt = 0;
for ( tvi = 0; tvi < topv0.m_v_count; tvi++ )
{
vi = topv0.m_vi[tvi];
if ( vi < 0 || vi > V_count )
continue;
if ( vi < newvi )
newvi = vi;
cnt++;
P = mesh.m_V[vi];
Vline.from += P;
if ( bHasVertexNormals )
{
N0 += ON_3dVector(mesh.m_N[vi]);
}
if ( bHasTextureCoordinates )
{
P = mesh.m_T[vi];
Tline.from += P;
}
}
if (cnt > 1)
{
double s = 1.0/((double)cnt);
Vline.from.x *= s;
Vline.from.y *= s;
Vline.from.z *= s;
Tline.from.x *= s;
Tline.from.y *= s;
Tline.from.z *= s;
N0 = s*N0;
}
cnt = 0;
for ( tvi = 0; tvi < topv1.m_v_count; tvi++ )
{
vi = topv1.m_vi[tvi];
if ( vi < 0 || vi > V_count )
continue;
if ( vi < newvi )
newvi = vi;
cnt++;
P = mesh.m_V[vi];
Vline.to += P;
if ( bHasVertexNormals )
{
N1 += ON_3dVector(mesh.m_N[vi]);
}
if ( bHasTextureCoordinates )
{
P = mesh.m_T[vi];
Tline.to += P;
}
}
if (cnt > 1)
{
double s = 1.0/((double)cnt);
Vline.to.x *= s;
Vline.to.y *= s;
Vline.to.z *= s;
Tline.to.x *= s;
Tline.to.y *= s;
Tline.to.z *= s;
N1 = s*N1;
}
ON_3fPoint newV(Vline.PointAt(0.5));
ON_3fVector newN;
ON_2fPoint newT;
if ( bHasVertexNormals )
{
N0.Unitize();
N1.Unitize();
ON_3dVector N = N0+N1;
if ( !N.Unitize() )
{
N = (topv0.m_v_count == 1) ? mesh.m_N[topv0.m_vi[0]] :mesh.m_N[topv1.m_vi[0]];
}
newN = N;
}
if ( bHasTextureCoordinates )
{
newT = Tline.PointAt(0.5);
}
for ( mei = 0; mei < me_list_count; mei++ )
{
me_list[mei].newvi = newvi;
me_list[mei].newV = newV;
me_list[mei].newN = newN;
me_list[mei].newT = newT;
}
}
else
{
// collapsing a "crease" edge - attempt to preserve
// the crease.
memset(&me,0,sizeof(me));
me.vi0 = -1;
me.vi1 = -1;
for ( mei = 0; mei < me_list_count; mei++ )
{
if ( 0 == mei && CompareMESHEDGE(&me,me_list+mei) )
{
// cook up new vertex
me_list[mei].newvi = mesh.m_V.Count();
me = me_list[mei];
ON_Line line;
line.from = mesh.m_V[me.vi0];
line.to = mesh.m_V[me.vi1];
me.newV = line.PointAt(0.5);
if ( bHasVertexNormals )
{
ON_3dVector N0(mesh.m_N[me.vi0]);
ON_3dVector N1(mesh.m_N[me.vi1]);
ON_3dVector N = N0 + N1;
if ( !N.Unitize() )
N = N0;
me.newN = N;
}
if ( bHasTextureCoordinates )
{
line.from = mesh.m_T[me.vi0];
line.to = mesh.m_T[me.vi1];
me.newT = line.PointAt(0.5);
}
me.newvi = (me.vi0 < me.vi1) ? me.vi0 : me.vi1;
}
else
{
me_list[mei].newvi = me.newvi;
me_list[mei].newV = me.newV;
me_list[mei].newN = me.newN;
me_list[mei].newT = me.newT;
}
}
}
// We are done averaging old mesh values.
// Change values in mesh m_V[], m_N[] and m_T[] arrays.
for ( mei = 0; mei < me_list_count; mei++ )
{
mesh.m_V[me_list[mei].vi0] = me_list[mei].newV;
mesh.m_V[me_list[mei].vi1] = me_list[mei].newV;
if ( bHasVertexNormals )
{
mesh.m_N[me_list[mei].vi0] = me_list[mei].newN;
mesh.m_N[me_list[mei].vi1] = me_list[mei].newN;
}
if ( bHasTextureCoordinates )
{
mesh.m_T[me_list[mei].vi0] = me_list[mei].newT;
mesh.m_T[me_list[mei].vi1] = me_list[mei].newT;
}
}
// make a map of old to new
int old2new_map_count = 0;
ON__NEWVI* old2new_map = (ON__NEWVI*)alloca(2*me_list_count*sizeof(old2new_map[0]));
for ( mei = 0; mei < me_list_count; mei++ )
{
old2new_map[old2new_map_count].oldvi = me_list[mei].vi0;
old2new_map[old2new_map_count].newvi = me_list[mei].newvi;
old2new_map_count++;
old2new_map[old2new_map_count].oldvi = me_list[mei].vi1;
old2new_map[old2new_map_count].newvi = me_list[mei].newvi;
old2new_map_count++;
}
// sort old2new_map[] so we can use a fast bsearch() call
// to update faces.
ON_qsort(old2new_map,old2new_map_count,sizeof(old2new_map[0]),(QSORTCMPFUNC)CompareNEWVI);
// count faces that use the vertices that are being changed
int bad_fi_count = 0;
int topv_end, vei, fi, fvi23, fvi;
ON__NEWVI nvi;
for ( topv_end = 0; topv_end < 2; topv_end++ )
{
const ON_MeshTopologyVertex& topv = (topv_end) ? topv1 : topv0;
for ( vei = 0; vei < topv.m_tope_count; vei++ )
{
topei = topv.m_topei[vei];
if ( topei < 0 && topei >= top.m_tope.Count() )
continue;
bad_fi_count += top.m_tope[topei].m_topf_count;
}
}
int* bad_fi = (int*)alloca(bad_fi_count*sizeof(*bad_fi));
bad_fi_count = 0;
// Go through all the faces that use the vertices at the
// ends of the edge and update the vi[] values to use the
// new vertices.
for ( topv_end = 0; topv_end < 2; topv_end++ )
{
const ON_MeshTopologyVertex& topv = (topv_end) ? topv1 : topv0;
for ( vei = 0; vei < topv.m_tope_count; vei++ )
{
topei = topv.m_topei[vei];
if ( topei < 0 && topei >= top.m_tope.Count() )
continue;
const ON_MeshTopologyEdge& e = top.m_tope[topei];
for ( efi = 0; efi < e.m_topf_count; efi++ )
{
fi = e.m_topfi[efi];
if ( fi < 0 || fi >= F_count )
continue;
bool bChangedFace = false;
ON_MeshFace& f = mesh.m_F[fi];
for ( fvi = 0; fvi < 4; fvi++ )
{
nvi.oldvi = f.vi[fvi];
ON__NEWVI* p = (ON__NEWVI*)bsearch(&nvi,old2new_map,old2new_map_count,sizeof(old2new_map[0]),(QSORTCMPFUNC)CompareNEWVI);
if ( 0 != p && p->oldvi != p->newvi)
{
f.vi[fvi] = p->newvi;
bChangedFace = true;
}
}
if ( bChangedFace )
{
if ( !f.IsValid(V_count) )
{
if ( f.vi[3] == f.vi[0] )
{
f.vi[0] = f.vi[1];
f.vi[1] = f.vi[2];
f.vi[2] = f.vi[3];
}
else if ( f.vi[0] == f.vi[1] )
{
fvi23 = f.vi[0];
f.vi[0] = f.vi[2];
f.vi[1] = f.vi[3];
f.vi[2] = fvi23;
f.vi[3] = fvi23;
}
else if ( f.vi[1] == f.vi[2] )
{
fvi23 = f.vi[1];
f.vi[1] = f.vi[0];
f.vi[0] = f.vi[3];
f.vi[2] = fvi23;
f.vi[3] = fvi23;
}
if ( f.vi[0] == f.vi[1] || f.vi[1] == f.vi[2] || f.vi[2] == f.vi[0] || f.vi[2] != f.vi[3] )
{
bad_fi[bad_fi_count++] = fi;
}
}
if ( bHasFaceNormals )
{
// invalid faces are removed below
ON_3fVector a, b, n;
a = mesh.m_V[f.vi[2]] - mesh.m_V[f.vi[0]];
b = mesh.m_V[f.vi[3]] - mesh.m_V[f.vi[1]];
n = ON_CrossProduct( a, b );
n.Unitize();
mesh.m_FN[fi] = n;
}
}
}
}
}
if ( bad_fi_count > 0 )
{
// remove collapsed faces
ON_qsort(bad_fi,bad_fi_count,sizeof(bad_fi[0]),CompareInt);
int bfi = 1;
int dest_fi = bad_fi[0];
for ( fi = dest_fi+1; fi < F_count && bfi < bad_fi_count; fi++ )
{
if ( fi == bad_fi[bfi] )
{
bfi++;
}
else
{
mesh.m_F[dest_fi++] = mesh.m_F[fi];
}
}
while (fi<F_count)
{
mesh.m_F[dest_fi++] = mesh.m_F[fi++];
}
mesh.m_F.SetCount(dest_fi);
if ( bHasFaceNormals )
{
bfi = 1;
dest_fi = bad_fi[0];
for ( fi = dest_fi+1; fi < F_count && bfi < bad_fi_count; fi++ )
{
if ( fi == bad_fi[bfi] )
{
bfi++;
}
else
{
mesh.m_FN[dest_fi++] = mesh.m_FN[fi];
}
}
while (fi<F_count)
{
mesh.m_FN[dest_fi++] = mesh.m_FN[fi++];
}
mesh.m_FN.SetCount(dest_fi);
}
}
mesh.Compact();
mesh.DestroyTopology();
mesh.DestroyPartition();
return true;
}
CRhinoCommand::result CCommandSampleCageEdit::RunCommand( const CRhinoCommandContext& context )
{
ON_Workspace ws;
CRhinoCommand::result rc = CRhinoCommand::success;
// Get the captive object
CRhinoGetObject go;
go.SetCommandPrompt( L"Select captive surface or polysurface" );
go.SetGeometryFilter( CRhinoGetObject::surface_object | CRhinoGetObject::polysrf_object );
go.GetObjects( 1, 1 );
rc = go.CommandResult();
if( CRhinoCommand::success != rc )
return rc;
const CRhinoObject* captive = go.Object(0).Object();
if( 0 == captive )
return CRhinoCommand::failure;
// Define the control line
ON_Line line;
CArgsRhinoGetLine args;
rc = RhinoGetLine( args, line );
if( CRhinoCommand::success != rc )
return rc;
// Get the curve parameters
int degree = 3;
int cv_count = 4;
for(;;)
{
CRhinoGetOption gl;
gl.SetCommandPrompt( L"NURBS Parameters" );
gl.AcceptNothing();
int d_opt = gl.AddCommandOptionInteger( RHCMDOPTNAME(L"Degree"), °ree, L"Curve degree", 1.0, 100.0 );
int p_opt = gl.AddCommandOptionInteger( RHCMDOPTNAME(L"PointCount"), &cv_count, L"Number of control points", 2.0, 100.0 );
gl.GetOption();
rc = gl.CommandResult();
if( CRhinoCommand::success != rc )
return rc;
if( CRhinoGet::nothing == gl.Result() )
break;
if( cv_count <= degree )
{
if( CRhinoGet::option != gl.Result() )
continue;
const CRhinoCommandOption* opt = go.Option();
if( 0 == opt )
continue;
if( d_opt == opt->m_option_index )
cv_count = degree + 1;
else
degree = cv_count - 1;
}
}
// Set up morph control
ON_MorphControl* control = new ON_MorphControl();
control->m_varient = 1; // 1= curve
// Specify the source line curve
control->m_nurbs_curve0.Create( 3, false, 2, 2 );
control->m_nurbs_curve0.MakeClampedUniformKnotVector();
control->m_nurbs_curve0.SetCV( 0, line.from );
control->m_nurbs_curve0.SetCV( 1, line.to );
// Specify the destination NURBS curve
control->m_nurbs_curve.Create( 3, false, degree + 1, cv_count );
control->m_nurbs_curve.MakeClampedUniformKnotVector();
double* g = ws.GetDoubleMemory( control->m_nurbs_curve.m_cv_count );
control->m_nurbs_curve.GetGrevilleAbcissae( g );
ON_Interval d = control->m_nurbs_curve.Domain();
double s = 0.0;
int i;
for( i = 0; i < control->m_nurbs_curve.m_cv_count; i++ )
{
s = d.NormalizedParameterAt( g[i] );
control->m_nurbs_curve.SetCV( i, line.PointAt(s) );
}
// Make sure domains match
s = line.Length();
if( s > ON_SQRT_EPSILON )
control->m_nurbs_curve0.SetDomain( 0.0, s );
d = control->m_nurbs_curve0.Domain();
control->m_nurbs_curve.SetDomain( d[0], d[1] );
// Create the morph control object
CRhinoMorphControl* control_object = new CRhinoMorphControl();
control_object->SetControl( control );
context.m_doc.AddObject( control_object );
// Set up the capture
RhinoCaptureObject( control_object, const_cast<CRhinoObject*>(captive) );
// Clean up display
context.m_doc.UnselectAll();
// Turn on the control grips
control_object->EnableGrips( true );
context.m_doc.Redraw( CRhinoView::mark_display_hint );
return rc;
}
bool ON_Line::IsFartherThan( double d, const ON_Line& L ) const
{
ON_3dPoint A, B;
double a, b, t, x;
bool bCheckA, bCheckB;
a = from.x; if (to.x < a) {b=a; a = to.x;} else b = to.x;
if ( b+d < L.from.x && b+d < L.to.x )
return true;
if ( a-d > L.from.x && a-d > L.to.x )
return true;
a = from.y; if (to.y < a) {b=a; a = to.y;} else b = to.y;
if ( b+d < L.from.y && b+d < L.to.y )
return true;
if ( a-d > L.from.y && a-d > L.to.y )
return true;
a = from.z; if (to.z < a) {b=a; a = to.z;} else b = to.z;
if ( b+d < L.from.z && b+d < L.to.z )
return true;
if ( a-d > L.from.z && a-d > L.to.z )
return true;
if ( !ON_Intersect(*this,L,&a,&b) )
{
// lines are parallel or anti parallel
if ( Direction()*L.Direction() >= 0.0 )
{
// lines are parallel
a = 0.0;
L.ClosestPointTo(from,&b);
// If ( b >= 0.0), then this->from and L(b) are a pair of closest points.
if ( b < 0.0 )
{
// Othersise L.from and this(a) are a pair of closest points.
b = 0.0;
ClosestPointTo(L.from,&a);
}
}
else
{
// lines are anti parallel
a = 1.0;
L.ClosestPointTo(to,&b);
// If ( b >= 0.0), then this->to and L(b) are a pair of closest points.
if ( b < 0.0 )
{
// Othersise L.to and this(a) are a pair of closest points.
b = 0.0;
ClosestPointTo(L.from,&a);
}
}
}
A = PointAt(a);
B = L.PointAt(b);
x = A.DistanceTo(B);
if (x > d)
return true;
bCheckA = true;
if ( a < 0.0) a = 0.0; else if (a > 1.0) a = 1.0; else bCheckA=false;
if (bCheckA )
{
A = PointAt(a);
L.ClosestPointTo(A,&t);
if (t<0.0) t = 0.0; else if (t > 1.0) t = 1.0;
x = L.PointAt(t).DistanceTo(A);
}
bCheckB = true;
if ( b < 0.0) b = 0.0; else if (b > 1.0) b = 1.0; else bCheckB=false;
if ( bCheckB )
{
B = L.PointAt(b);
ClosestPointTo(B,&t);
if (t<0.0) t = 0.0; else if (t > 1.0) t = 1.0;
t = PointAt(t).DistanceTo(B);
if ( bCheckA )
{
if ( t<x ) x = t;
}
else
{
x = t;
}
}
return (x > d);
}