Vector SSurface::PointAtMaybeSwapped(double u, double v, bool swapped) {
if(swapped) {
return PointAt(v, u);
} else {
return PointAt(u, v);
}
}
ON_RevSurface* ON_Cylinder::RevSurfaceForm( ON_RevSurface* srf ) const
{
if ( srf )
srf->Destroy();
ON_RevSurface* pRevSurface = NULL;
if ( IsFinite() && IsValid() )
{
ON_Line line;
line.from = PointAt(0.0,height[0]);
line.to = PointAt(0.0,height[1]);
ON_Interval h(height[0],height[1]); // h = evaluation domain for line (must be increasing)
if ( h.IsDecreasing() )
h.Swap();
ON_LineCurve* line_curve = new ON_LineCurve( line, h[0], h[1] );
if ( srf )
pRevSurface = srf;
else
pRevSurface = new ON_RevSurface();
pRevSurface->m_angle.Set(0.0,2.0*ON_PI);
pRevSurface->m_t = pRevSurface->m_angle;
pRevSurface->m_curve = line_curve;
pRevSurface->m_axis.from = circle.plane.origin;
pRevSurface->m_axis.to = circle.plane.origin + circle.plane.zaxis;
pRevSurface->m_bTransposed = false;
ON_Circle c0(circle);
c0.Translate(height[0]*circle.plane.zaxis);
ON_Circle c1(circle);
c1.Translate(height[1]*circle.plane.zaxis);
pRevSurface->m_bbox = c0.BoundingBox();
pRevSurface->m_bbox.Union(c1.BoundingBox());
}
return pRevSurface;
}
int ON_LineCurve::GetNurbForm(
ON_NurbsCurve& c,
double tolerance,
const ON_Interval* subdomain
) const
{
int rc = 0;
if ( c.Create( m_dim==2?2:3, false, 2, 2 ) )
{
rc = 1;
double t0 = m_t[0];
double t1 = m_t[1];
if (subdomain )
{
if ( t0 < t1 )
{
const ON_Interval& sd = *subdomain;
double s0 = sd[0];
double s1 = sd[1];
if (s0 < t0) s0 = t0;
if (s1 > t1) s1 = t1;
if (s0 < s1)
{
t0 = s0;
t1 = s1;
}
else
rc = 0;
}
else
{
rc = 0;
}
}
if ( t0 < t1 )
{
c.m_knot[0] = t0;
c.m_knot[1] = t1;
c.SetCV( 0, PointAt(t0));
c.SetCV( 1, PointAt(t1));
}
else if ( t0 > t1 )
{
rc = 0;
c.m_knot[0] = t1;
c.m_knot[1] = t0;
c.SetCV( 0, PointAt(t1));
c.SetCV( 1, PointAt(t0));
}
else
{
rc = 0;
c.m_knot[0] = 0.0;
c.m_knot[1] = 1.0;
c.SetCV( 0, m_line.from );
c.SetCV( 1, m_line.to );
}
}
return rc;
}
void SBezier::MakePwlWorker(List<Vector> *l, double ta, double tb,
double chordTol)
{
Vector pa = PointAt(ta);
Vector pb = PointAt(tb);
// Can't test in the middle, or certain cubics would break.
double tm1 = (2*ta + tb) / 3;
double tm2 = (ta + 2*tb) / 3;
Vector pm1 = PointAt(tm1);
Vector pm2 = PointAt(tm2);
double d = max(pm1.DistanceToLine(pa, pb.Minus(pa)),
pm2.DistanceToLine(pa, pb.Minus(pa)));
double step = 1.0/SS.maxSegments;
if((tb - ta) < step || d < chordTol) {
// A previous call has already added the beginning of our interval.
l->Add(&pb);
} else {
double tm = (ta + tb) / 2;
MakePwlWorker(l, ta, tm, chordTol);
MakePwlWorker(l, tm, tb, chordTol);
}
}
ON_RevSurface* ON_Cone::RevSurfaceForm( ON_RevSurface* srf ) const
{
if ( srf )
srf->Destroy();
ON_RevSurface* pRevSurface = NULL;
if ( IsValid() )
{
ON_Line line;
ON_Interval line_domain;
if ( height >= 0.0 )
line_domain.Set(0.0,height);
else
line_domain.Set(height,0.0);
line.from = PointAt(0.0,line_domain[0]);
line.to = PointAt(0.0,line_domain[1]);
ON_LineCurve* line_curve = new ON_LineCurve( line, line_domain[0], line_domain[1] );
if ( srf )
pRevSurface = srf;
else
pRevSurface = new ON_RevSurface();
pRevSurface->m_angle.Set(0.0,2.0*ON_PI);
pRevSurface->m_t = pRevSurface->m_angle;
pRevSurface->m_curve = line_curve;
pRevSurface->m_axis.from = plane.origin;
pRevSurface->m_axis.to = plane.origin + plane.zaxis;
pRevSurface->m_bTransposed = FALSE;
pRevSurface->m_bbox.m_min = plane.origin;
pRevSurface->m_bbox.m_max = plane.origin;
pRevSurface->m_bbox.Union(CircleAt(height).BoundingBox());
}
return pRevSurface;
}
ON_RevSurface* ON_Cylinder::RevSurfaceForm( ON_RevSurface* srf ) const
{
if ( srf )
srf->Destroy();
ON_RevSurface* pRevSurface = NULL;
if ( IsFinite() && IsValid() )
{
ON_Line line;
line.from = PointAt(0.0,height[0]);
line.to = PointAt(0.0,height[1]);
ON_LineCurve* line_curve = new ON_LineCurve( line, height[0], height[1] );
if ( srf )
pRevSurface = srf;
else
pRevSurface = new ON_RevSurface();
pRevSurface->m_angle.Set(0.0,2.0*ON_PI);
pRevSurface->m_t = pRevSurface->m_angle;
pRevSurface->m_curve = line_curve;
pRevSurface->m_axis.from = circle.plane.origin;
pRevSurface->m_axis.to = circle.plane.origin + circle.plane.zaxis;
pRevSurface->m_bTransposed = FALSE;
ON_Circle c0(circle);
c0.Translate(height[0]*circle.plane.zaxis);
ON_Circle c1(circle);
c1.Translate(height[1]*circle.plane.zaxis);
pRevSurface->m_bbox = c0.BoundingBox();
pRevSurface->m_bbox.Union(c1.BoundingBox());
}
return pRevSurface;
}
void SBezier::ClosestPointTo(Vector p, double *t, bool converge) {
int i;
double minDist = VERY_POSITIVE;
*t = 0;
double res = (deg <= 2) ? 7.0 : 20.0;
for(i = 0; i < (int)res; i++) {
double tryt = (i/res);
Vector tryp = PointAt(tryt);
double d = (tryp.Minus(p)).Magnitude();
if(d < minDist) {
*t = tryt;
minDist = d;
}
}
Vector p0;
for(i = 0; i < (converge ? 15 : 5); i++) {
p0 = PointAt(*t);
if(p0.Equals(p, RATPOLY_EPS)) {
return;
}
Vector dp = TangentAt(*t);
Vector pc = p.ClosestPointOnLine(p0, dp);
*t += (pc.Minus(p0)).DivPivoting(dp);
}
if(converge) {
dbp("didn't converge (closest point on bezier curve)");
}
}
int
ON_PlaneSurface::GetNurbForm( // returns 0: unable to create NURBS representation
// with desired accuracy.
// 1: success - returned NURBS parameterization
// matches the surface's to wthe desired accuracy
// 2: success - returned NURBS point locus matches
// the surfaces's to the desired accuracy but, on
// the interior of the surface's domain, the
// surface's parameterization and the NURBS
// parameterization may not match to the
// desired accuracy.
ON_NurbsSurface& nurbs,
double tolerance
) const
{
ON_BOOL32 rc = IsValid();
if( !rc )
{
if ( m_plane.origin.x != ON_UNSET_VALUE
&& m_plane.xaxis.x != ON_UNSET_VALUE
&& m_plane.yaxis.x != ON_UNSET_VALUE
&& m_domain[0].IsIncreasing() && m_domain[1].IsIncreasing()
&& m_extents[0].Length() > 0.0 && m_extents[1].Length() > 0.0
)
{
ON_3dVector N = ON_CrossProduct(m_plane.xaxis,m_plane.yaxis);
if ( N.Length() <= 1.0e-4 )
{
ON_WARNING("ON_PlaneSurface::GetNurbForm - using invalid surface.");
rc = true;
}
}
}
if ( rc )
{
nurbs.m_dim = 3;
nurbs.m_is_rat = 0;
nurbs.m_order[0] = nurbs.m_order[1] = 2;
nurbs.m_cv_count[0] = nurbs.m_cv_count[1] = 2;
nurbs.m_cv_stride[1] = nurbs.m_dim;
nurbs.m_cv_stride[0] = nurbs.m_cv_stride[1]*nurbs.m_cv_count[1];
nurbs.ReserveCVCapacity(12);
nurbs.ReserveKnotCapacity(0,2);
nurbs.ReserveKnotCapacity(1,2);
nurbs.m_knot[0][0] = m_domain[0][0];
nurbs.m_knot[0][1] = m_domain[0][1];
nurbs.m_knot[1][0] = m_domain[1][0];
nurbs.m_knot[1][1] = m_domain[1][1];
nurbs.SetCV( 0, 0, PointAt( m_domain[0][0], m_domain[1][0] ));
nurbs.SetCV( 0, 1, PointAt( m_domain[0][0], m_domain[1][1] ));
nurbs.SetCV( 1, 0, PointAt( m_domain[0][1], m_domain[1][0] ));
nurbs.SetCV( 1, 1, PointAt( m_domain[0][1], m_domain[1][1] ));
}
return rc;
}
// ---------------------------------------------------------------------------------- RHTML_text_view - Draw -
void RHTMLtextview::Draw(BRect inRect)
{
BTextView::Draw(inRect);
if (fTarget->fNumView->Frame().top != fScrollView->ScrollBar(B_VERTICAL)->Value())
fTarget->fNumView->MoveTo(BPoint(0, 0 - fScrollView->ScrollBar(B_VERTICAL)->Value()));
if (fTarget->IsEnabled())
fTarget->fNumView->UpdateNum();
if (PointAt(TextLength() - 1).y + 50 > fTarget->fNumView->Bounds().bottom)
fTarget->fNumView->ResizeTo(fTarget->fNumView->Bounds().right, PointAt(TextLength() - 1).y + 50);
}
void SSurface::EdgeNormalsWithinSurface(Point2d auv, Point2d buv,
Vector *pt,
Vector *enin, Vector *enout,
Vector *surfn,
uint32_t auxA,
SShell *shell, SShell *sha, SShell *shb)
{
// the midpoint of the edge
Point2d muv = (auv.Plus(buv)).ScaledBy(0.5);
*pt = PointAt(muv);
// If this edge just approximates a curve, then refine our midpoint so
// so that it actually lies on that curve too. Otherwise stuff like
// point-on-face tests will fail, since the point won't actually lie
// on the other face.
hSCurve hc = { auxA };
SCurve *sc = shell->curve.FindById(hc);
if(sc->isExact && sc->exact.deg != 1) {
double t;
sc->exact.ClosestPointTo(*pt, &t, false);
*pt = sc->exact.PointAt(t);
ClosestPointTo(*pt, &muv);
} else if(!sc->isExact) {
SSurface *trimmedA = sc->GetSurfaceA(sha, shb),
*trimmedB = sc->GetSurfaceB(sha, shb);
*pt = trimmedA->ClosestPointOnThisAndSurface(trimmedB, *pt);
ClosestPointTo(*pt, &muv);
}
*surfn = NormalAt(muv.x, muv.y);
// Compute the edge's inner normal in xyz space.
Vector ab = (PointAt(auv)).Minus(PointAt(buv)),
enxyz = (ab.Cross(*surfn)).WithMagnitude(SS.ChordTolMm());
// And based on that, compute the edge's inner normal in uv space. This
// vector is perpendicular to the edge in xyz, but not necessarily in uv.
Vector tu, tv;
TangentsAt(muv.x, muv.y, &tu, &tv);
Point2d enuv;
enuv.x = enxyz.Dot(tu) / tu.MagSquared();
enuv.y = enxyz.Dot(tv) / tv.MagSquared();
// Compute the inner and outer normals of this edge (within the srf),
// in xyz space. These are not necessarily antiparallel, if the
// surface is curved.
Vector pin = PointAt(muv.Minus(enuv)),
pout = PointAt(muv.Plus(enuv));
*enin = pin.Minus(*pt),
*enout = pout.Minus(*pt);
}
void SSurface::TrimFromEdgeList(SEdgeList *el, bool asUv) {
el->l.ClearTags();
STrimBy stb = {};
for(;;) {
// Find an edge, any edge; we'll start from there.
SEdge *se;
for(se = el->l.First(); se; se = el->l.NextAfter(se)) {
if(se->tag) continue;
break;
}
if(!se) break;
se->tag = 1;
stb.start = se->a;
stb.finish = se->b;
stb.curve.v = se->auxA;
stb.backwards = se->auxB ? true : false;
// Find adjoining edges from the same curve; those should be
// merged into a single trim.
bool merged;
do {
merged = false;
for(se = el->l.First(); se; se = el->l.NextAfter(se)) {
if(se->tag) continue;
if(se->auxA != (int)stb.curve.v) continue;
if(( se->auxB && !stb.backwards) ||
(!se->auxB && stb.backwards)) continue;
if((se->a).Equals(stb.finish)) {
stb.finish = se->b;
se->tag = 1;
merged = true;
} else if((se->b).Equals(stb.start)) {
stb.start = se->a;
se->tag = 1;
merged = true;
}
}
} while(merged);
if(asUv) {
stb.start = PointAt(stb.start.x, stb.start.y);
stb.finish = PointAt(stb.finish.x, stb.finish.y);
}
// And add the merged trim, with xyz (not uv like the polygon) pts
trim.Add(&stb);
}
}
double SSurface::ChordToleranceForEdge(Vector a, Vector b) {
Vector as = PointAt(a.x, a.y), bs = PointAt(b.x, b.y);
double worst = VERY_NEGATIVE;
int i;
for(i = 1; i <= 3; i++) {
Vector p = a. Plus((b. Minus(a )).ScaledBy(i/4.0)),
ps = as.Plus((bs.Minus(as)).ScaledBy(i/4.0));
Vector pps = PointAt(p.x, p.y);
worst = max(worst, (pps.Minus(ps)).MagSquared());
}
return sqrt(worst);
}
bool World::Clicked(sf::Vector2i mouse_pos) {
Point p = PointAt(sf::Vector2f(mouse_pos.x, mouse_pos.y));
if(mPlayerActor->IsValidAddPoint(p, false))
return mPlayerActor->Clicked(p);
else
return false;
}
bool SSurface::ClosestPointNewton(Vector p, double *u, double *v, bool converge)
{
// Initial guess is in u, v; refine by Newton iteration.
Vector p0 = Vector::From(0, 0, 0);
for(int i = 0; i < (converge ? 25 : 5); i++) {
p0 = PointAt(*u, *v);
if(converge) {
if(p0.Equals(p, RATPOLY_EPS)) {
return true;
}
}
Vector tu, tv;
TangentsAt(*u, *v, &tu, &tv);
// Project the point into a plane through p0, with basis tu, tv; a
// second-order thing would converge faster but needs second
// derivatives.
Vector dp = p.Minus(p0);
double du = dp.Dot(tu), dv = dp.Dot(tv);
*u += du / (tu.MagSquared());
*v += dv / (tv.MagSquared());
}
if(converge) {
dbp("didn't converge");
dbp("have %.3f %.3f %.3f", CO(p0));
dbp("want %.3f %.3f %.3f", CO(p));
dbp("distance = %g", (p.Minus(p0)).Magnitude());
}
return false;
}
bool SSurface::PointIntersectingLine(Vector p0, Vector p1, double *u, double *v)
{
int i;
for(i = 0; i < 15; i++) {
Vector pi, p, tu, tv;
p = PointAt(*u, *v);
TangentsAt(*u, *v, &tu, &tv);
Vector n = (tu.Cross(tv)).WithMagnitude(1);
double d = p.Dot(n);
bool parallel;
pi = Vector::AtIntersectionOfPlaneAndLine(n, d, p0, p1, ¶llel);
if(parallel) break;
// Check for convergence
if(pi.Equals(p, RATPOLY_EPS)) return true;
// Adjust our guess and iterate
Vector dp = pi.Minus(p);
double du = dp.Dot(tu), dv = dp.Dot(tv);
*u += du / (tu.MagSquared());
*v += dv / (tv.MagSquared());
}
// dbp("didn't converge (surface intersecting line)");
return false;
}
ON_3dPoint ON_Box::ClosestPointTo( ON_3dPoint point ) const
{
// Do not validate - it is too slow.
double r,s,t;
ClosestPointTo(point,&r,&s,&t);
return PointAt(r,s,t);
}
ON_BOOL32 ON_ArcCurve::SetEndPoint(ON_3dPoint end_point)
{
if (IsCircle())
return false;
ON_BOOL32 rc = false;
if ( m_dim == 3 || end_point.z == 0.0 )
{
ON_3dPoint P;
ON_3dVector T;
double t = Domain()[0];
Ev1Der( t, P, T );
ON_Arc a;
rc = a.Create( P, T, end_point );
if ( rc )
{
m_arc = a;
}
else {
ON_3dPoint start_point = PointAt(Domain()[0]);
if (end_point.DistanceTo(start_point) < ON_ZERO_TOLERANCE*m_arc.Radius()){
//make arc into circle
m_arc.plane.xaxis = start_point - m_arc.Center();
m_arc.plane.xaxis.Unitize();
m_arc.plane.yaxis = ON_CrossProduct(m_arc.Normal(), m_arc.plane.xaxis);
m_arc.plane.yaxis.Unitize();
m_arc.SetAngleRadians(2.0*ON_PI);
rc = true;
}
}
}
return rc;
}
// returns point on circle that is arc to given point
ON_3dPoint ON_Arc::ClosestPointTo(
const ON_3dPoint& pt
) const
{
double t = m_angle[0];
ClosestPointTo( pt, &t );
return PointAt(t);
}
ON_BOOL32 ON_LineCurve::Trim( const ON_Interval& domain )
{
ON_BOOL32 rc = false;
if ( domain.IsIncreasing() )
{
ON_3dPoint p = PointAt( domain[0] );
ON_3dPoint q = PointAt( domain[1] );
if( p.DistanceTo(q)>0){ // 2 April 2003 Greg Arden A successfull trim
// should return an IsValid ON_LineCurve .
m_line.from = p;
m_line.to = q;
m_t = domain;
rc = true;
}
}
return rc;
}
ON_3dPoint ON_Polyline::ClosestPointTo( const ON_3dPoint& point ) const
{
double t;
ON_BOOL32 rc = ClosestPointTo( point, &t );
if ( !rc )
t = 0.0;
return PointAt(t);
}
// returns point on cylinder that is closest to given point
ON_3dPoint ON_Cylinder::ClosestPointTo(
ON_3dPoint point
) const
{
double s, t;
ClosestPointTo( point, &s, &t );
return PointAt( s, t );
}
/**
* This routine returns the next point in the micro-feature
* outline that is an extremity. The search starts after
* EdgePoint. The routine assumes that the outline being
* searched is not a degenerate outline (i.e. it must have
* 2 or more edge points).
* @param EdgePoint start search from this point
* @return Next extremity in the outline after EdgePoint.
* @note Globals: none
* @note Exceptions: none
* @note History: 7/26/89, DSJ, Created.
*/
MFOUTLINE NextExtremity(MFOUTLINE EdgePoint) {
EdgePoint = NextPointAfter(EdgePoint);
while (!PointAt(EdgePoint)->ExtremityMark)
EdgePoint = NextPointAfter(EdgePoint);
return (EdgePoint);
} /* NextExtremity */
void SSurface::TriangulateInto(SShell *shell, SMesh *sm) {
SEdgeList el = {};
MakeEdgesInto(shell, &el, AS_UV);
SPolygon poly = {};
if(el.AssemblePolygon(&poly, NULL, true)) {
int i, start = sm->l.n;
if(degm == 1 && degn == 1) {
// A surface with curvature along one direction only; so
// choose the triangulation with chords that lie as much
// as possible within the surface. And since the trim curves
// have been pwl'd to within the desired chord tol, that will
// produce a surface good to within roughly that tol.
//
// If this is just a plane (degree (1, 1)) then the triangulation
// code will notice that, and not bother checking chord tols.
poly.UvTriangulateInto(sm, this);
} else {
// A surface with compound curvature. So we must overlay a
// two-dimensional grid, and triangulate around that.
poly.UvGridTriangulateInto(sm, this);
}
STriMeta meta = { face, color };
for(i = start; i < sm->l.n; i++) {
STriangle *st = &(sm->l.elem[i]);
st->meta = meta;
st->an = NormalAt(st->a.x, st->a.y);
st->bn = NormalAt(st->b.x, st->b.y);
st->cn = NormalAt(st->c.x, st->c.y);
st->a = PointAt(st->a.x, st->a.y);
st->b = PointAt(st->b.x, st->b.y);
st->c = PointAt(st->c.x, st->c.y);
// Works out that my chosen contour direction is inconsistent with
// the triangle direction, sigh.
st->FlipNormal();
}
} else {
dbp("failed to assemble polygon to trim nurbs surface in uv space");
}
el.Clear();
poly.Clear();
}
D3DXVECTOR2 Line2D::Intersection(const Line2D &line) const {
float denom = direction_.x * line.direction_.y -
direction_.y * line.direction_.x;
float lambda = (-start_.x * line.direction_.y +
line.start_.x * line.direction_.y +
start_.y * line.direction_.x -
line.start_.y * line.direction_.x) / denom;
return PointAt(lambda);
}
//
// VarBinary::PointAt
//
// Setup/change to point to the var 'path', which MUST exist
//
void VarBinary::PointAt(const char *path, void *context)
{
// Get the requested item
VarSys::VarItem *i = VarSys::FindVarItem(path, context, TRUE);
// Item must exist
ASSERT(i)
PointAt(i);
}
ON_Line ON_Plane::IsoLine( // iso parametric line
int dir, // 0 first parameter varies and second parameter is constant
// e.g., line(t) = plane(t,c)
// 1 first parameter is constant and second parameter varies
// e.g., line(t) = plane(c,t)
double c // c = value of constant parameter
) const
{
ON_Line line;
if ( dir ) {
line.from = PointAt( 0.0, c );
line.to = PointAt( 1.0, c );
}
else {
line.from = PointAt( c, 0.0 );
line.to = PointAt( c, 1.0 );
}
return line;
}
/*---------------------------------------------------------------------------*/
void ConvertToPicoFeatures2(MFOUTLINE Outline, FEATURE_SET FeatureSet) {
/*
** Parameters:
** Outline outline to extract micro-features from
** FeatureSet set of features to add pico-features to
** Globals:
** classify_pico_feature_length
** length of features to be extracted
** Operation:
** This routine steps thru the specified outline and cuts it
** up into pieces of equal length. These pieces become the
** desired pico-features. Each segment in the outline
** is converted into an integral number of pico-features.
** Return: none (results are returned in FeatureSet)
** Exceptions: none
** History: 4/30/91, DSJ, Adapted from ConvertToPicoFeatures().
*/
MFOUTLINE Next;
MFOUTLINE First;
MFOUTLINE Current;
if (DegenerateOutline(Outline))
return;
First = Outline;
Current = First;
Next = NextPointAfter(Current);
do {
/* note that an edge is hidden if the ending point of the edge is
marked as hidden. This situation happens because the order of
the outlines is reversed when they are converted from the old
format. In the old format, a hidden edge is marked by the
starting point for that edge. */
if (!(PointAt(Next)->Hidden))
ConvertSegmentToPicoFeat (&(PointAt(Current)->Point),
&(PointAt(Next)->Point), FeatureSet);
Current = Next;
Next = NextPointAfter(Current);
}
while (Current != First);
} /* ConvertToPicoFeatures2 */
bool ON_Circle::IsInPlane( const ON_Plane& plane, double tolerance ) const
{
double d;
int i;
for ( i = 0; i < 8; i++ ) {
d = plane.plane_equation.ValueAt( PointAt(0.25*i*ON_PI) );
if ( fabs(d) > tolerance )
return false;
}
return true;
}
// ---------------------------------------------------------------------------------- RHTML_text_view - Undo -
void RHTMLtextview::Undo(BClipboard *clipboard)
{
fTarget->SetModify(true);
BString *oldtext=new BString(Text());
BString *newtext = 0;
BTextView::Undo(clipboard);
int32 c, d;
GetSelection(&c, &d);
fFileTypes->SetFontAndColor(oldtext, newtext = new BString(Text()), 0, c, d);
if (fUpdateTimer->IsActive())
fUpdateTimer->ResetTimer();
else
fUpdateTimer->StartTimer(fOptions->ReakcioIdo);
if (PointAt(TextLength() - 1).y + 50>fTarget->fNumView->Bounds().bottom)
fTarget->fNumView->ResizeTo(fTarget->fNumView->Bounds().right, PointAt(TextLength() - 1).y + 50);
delete oldtext;
delete newtext;
}
bool ON_PlaneSurface::GetClosestPoint( const ON_3dPoint& test_point,
double* s,double* t, // parameters of local closest point returned here
double maximum_distance,
const ON_Interval* sdomain, // first parameter sub_domain
const ON_Interval* tdomain // second parameter sub_domain
) const
{
double u = 0.0, v=0.0;
ON_Interval sdom = Domain(0);
ON_Interval tdom = Domain(1);
if(sdomain==NULL)
sdomain = &sdom;
if(tdomain==NULL)
tdomain = &tdom;
bool rc = m_plane.ClosestPointTo( test_point, &u, &v );
if ( rc )
{
// convert m_plane coordinates to ON_Surface coordinates
if ( m_domain[0] != m_extents[0] )
{
u = m_domain[0].ParameterAt( m_extents[0].NormalizedParameterAt(u) );
}
if ( m_domain[1] != m_extents[1] )
{
v = m_domain[1].ParameterAt( m_extents[1].NormalizedParameterAt(v) );
}
if ( u < sdomain->Min() )
u = sdomain->Min();
else if ( u > sdomain->Max() )
u = sdomain->Max();
if ( v < tdomain->Min() )
v = tdomain->Min();
else if ( v > tdomain->Max() )
v = tdomain->Max();
if ( s )
*s = u;
if ( t )
*t = v;
if (maximum_distance > 0.0)
{
ON_3dPoint pt = PointAt(u,v);
if ( test_point.DistanceTo(pt) > maximum_distance )
rc = false;
}
}
return rc;
}
