testdistance.cpp

《3D游戏引擎设计》的源码

        ostr << "sampled = " << fR << ' ' << fS << ' ' << fT << ' '
             << fMin0 << endl;

        fMin1 = MgcDistance(kLine,kTri,&fR,&fS,&fT);
        ostr << "analytic = " << fR << ' ' << fS << ' ' << fT << ' '
             << fMin1 << endl;

        ostr << "diff = " << fMin1-fMin0 << endl;

        if ( fMin1-fMin0 > fMaxDiff )
            fMaxDiff = fMin1-fMin0;

        ostr << endl;
    }

    ostr << "max diff = " << fMaxDiff << endl;
}
//----------------------------------------------------------------------------
void TestDistRay3Tri3 ()
{
    ofstream ostr("data.txt");

    MgcTriangle3 kTri;
    MgcRay3 kRay;
    MgcVector3 kP, kQ, kDiff;
    MgcReal fR, fS, fT, fR0, fS0, fT0, fMin0, fMin1, fDist;
    MgcReal fMaxDiff = 0.0;

    for (int i = 0; i < 128; i++)
    {
        kTri.Origin() = MgcVector3(RAND,RAND,RAND);
        kTri.Edge0() = MgcVector3(RAND,RAND,RAND);
        kTri.Edge1() = MgcVector3(RAND,RAND,RAND);

        kRay.Origin() = MgcVector3(RAND,RAND,RAND);
        if ( i % 2 )
        {
            // non-parallel segment and triangle
            kRay.Direction() = MgcVector3(RAND,RAND,RAND);
        }
        else
        {
            // segment is parallel to triangle
            kRay.Direction() = RAND*kTri.Edge0()+RAND*kTri.Edge1();
        }

        MgcVector3 kUnit = kRay.Direction();
        kUnit.Unitize();

        fMin0 = MgcMath::INFINITY;
        int iXMax = 32, iYMax = 32, iZMax = 1024;
        for (int iZ = 0; iZ <= iZMax; iZ++)
        {
            fR0 = 8.0*iZ/MgcReal(iZMax);
            kP = kRay.Origin()+fR0*kUnit;
            for (int iY = 0; iY <= iYMax; iY++)
            {
                fS0 = iY/MgcReal(iYMax);
                for (int iX = 0; iX+iY <= iXMax; iX++)
                {
                    fT0 = iX/MgcReal(iXMax);
                    kQ = kTri.Origin()+fS0*kTri.Edge0()+fT0*kTri.Edge1();
                    
                    kDiff = kP-kQ;
                    fDist = kDiff.Length();
                    if ( fDist < fMin0 )
                    {
                        fMin0 = fDist;
                        fR = fR0;
                        fS = fS0;
                        fT = fT0;
                    }
                }
            }
        }
        ostr << "i = " << i << endl;
        ostr << "sampled = " << fR << ' ' << fS << ' ' << fT << ' '
             << fMin0 << endl;

        fMin1 = MgcDistance(kRay,kTri,&fR,&fS,&fT);
        ostr << "analytic = " << fR << ' ' << fS << ' ' << fT << ' '
             << fMin1 << endl;

        ostr << "diff = " << fMin1-fMin0 << endl;

        if ( fMin1-fMin0 > fMaxDiff )
            fMaxDiff = fMin1-fMin0;

        ostr << endl;
    }

    ostr << "max diff = " << fMaxDiff << endl;
}
//----------------------------------------------------------------------------
void TestDistVec3Frustum ()
{
    ofstream ostr("data.txt");
    MgcFrustum kFrustum;

    kFrustum.Origin() = MgcVector3::ZERO;
    kFrustum.LVector() = MgcVector3::UNIT_X;
    kFrustum.UVector() = MgcVector3::UNIT_Y;
    kFrustum.DVector() = MgcVector3::UNIT_Z;
    kFrustum.LBound() = 1.0;
    kFrustum.UBound() = 2.0;
    kFrustum.DMin() = 1.0;
    kFrustum.DMax() = 2.0;
    kFrustum.Update();

    MgcReal fDDelta = kFrustum.DMax() - kFrustum.DMin();

    // generate points in [-8,8]^3
    const int jMax = 16;
    MgcVector3 kPoint;
    MgcReal fMaxDelta = 0.0;
    MgcReal fMinDelta = MgcMath::INFINITY;
    for (int jZ = 0; jZ <= jMax; jZ++)
    {
        kPoint.z = 4.0*jZ/jMax;
    for (int jY = 0; jY <= jMax; jY++)
    {
        kPoint.y = 4.0*jY/jMax;
    for (int jX = 0; jX <= jMax; jX++)
    {
        kPoint.x = 4.0*jX/jMax;

        // compute distance
        MgcVector3 kClosest;
        MgcReal fSqrDist = MgcSqrDistance(kPoint,kFrustum,&kClosest);

        // compute approximate distance
        MgcReal fMinSqrDist = MgcMath::INFINITY;
        MgcVector3 kMinClosest;
        const int iMax = 64;
        for (int iY = 0; iY <= iMax; iY++)
        {
            MgcReal fY = (2.0*iY/iMax - 1.0)*kFrustum.UBound();
            for (int iX = 0; iX <= iMax; iX++)
            {
                MgcReal fX = (2.0*iX/iMax - 1.0)*kFrustum.LBound();
                for (int iT = 0; iT <= iMax; iT++)
                {
                    MgcReal fT = 1.0 + (kFrustum.GetDRatio()-1.0)*iT/iMax;
                    MgcVector3 kFPoint = fT*MgcVector3(fX,fY,kFrustum.DMin());

                    MgcVector3 kDiff = kPoint - kFPoint;
                    MgcReal fFSqrDist = kDiff.SquaredLength();
                    if ( fFSqrDist < fMinSqrDist )
                    {
                        fMinSqrDist = fFSqrDist;
                        kMinClosest = kFPoint;
                    }
                }
            }
        }

        MgcReal fDelta = fSqrDist - fMinSqrDist;
        if ( fDelta > fMaxDelta )
            fMaxDelta = fDelta;
        if ( fDelta < fMinDelta )
            fMinDelta = fDelta;

        ostr << "x = " << jX << " y = " << jY << " z = " << jZ << endl;
        ostr << "sampled  = " << kMinClosest.x << ' ' << kMinClosest.y
            << ' ' << kMinClosest.z << " : " << fMinSqrDist << endl;
        ostr << "analytic = " << kClosest.x << ' ' << kClosest.y << ' '
            << kClosest.z << " : " << fSqrDist << endl;
        ostr << "difference = ";
        ostr << fDelta << endl << endl;
    }
    }
    }

    ostr << "min diff = " << fMinDelta << endl;
    ostr << "max diff = " << fMaxDelta << endl;
}
//----------------------------------------------------------------------------
void TestDistVec3Box3 ()
{
    ofstream ostr("data.txt");
    MgcBox3 kBox;
    MgcVector3 kP, kQ, kDiff;
    MgcReal fR, fS, fT, fR0, fS0, fT0, fMin0, fMin1, fDist;
    MgcReal fMaxDiff = 0.0;

    for (int i = 0; i < 128; i++)
    {
        kBox.Center() = MgcVector3(RAND,RAND,RAND);
        kBox.Axis(2) = MgcVector3(RAND,RAND,RAND);
        MgcVector3::GenerateOrthonormalBasis(kBox.Axis(0),kBox.Axis(1),
            kBox.Axis(2),false);
        kBox.Extent(0) = 0.5*(RAND+1);
        kBox.Extent(1) = 0.5*(RAND+1);
        kBox.Extent(2) = 0.5*(RAND+1);
        kP = MgcVector3(RAND,RAND,RAND);

        fMin0 = MgcMath::INFINITY;
        int iMax = 32;
        for (int iZ = -iMax; iZ <= iMax; iZ++)
        {
            fT0 = kBox.Extent(2)*iZ/MgcReal(iMax);
            for (int iY = -iMax; iY <= iMax; iY++)
            {
                fS0 = kBox.Extent(1)*iY/MgcReal(iMax);
                for (int iX = -iMax; iX <= iMax; iX++)
                {
                    fR0 = kBox.Extent(0)*iX/MgcReal(iMax);
                    kQ = kBox.Center() + fR0*kBox.Axis(0) + fS0*kBox.Axis(1) +
                        fT0*kBox.Axis(2);
                    kDiff = kP - kQ;
                    fDist = kDiff.Length();
                    if ( fDist < fMin0 )
                    {
                        fMin0 = fDist;
                        fR = fR0;
                        fS = fS0;
                        fT = fT0;
                    }
                }
            }
        }
        ostr << "sampled = " << fR << ' ' << fS << ' ' << fT << ' '
             << fMin0 << endl;

        MgcReal fBP0, fBP1, fBP2;
        fMin1 = MgcDistance(kP,kBox,&fBP0,&fBP1,&fBP2);
        MgcVector3 kClosest = kBox.Center() + fBP0*kBox.Axis(0) +
            fBP1*kBox.Axis(1) + fBP2*kBox.Axis(2);
        ostr << "analytic = " << kClosest.x << ' ' << kClosest.y << ' '
             << kClosest.z << ' ' << fMin1 << endl;
        ostr << "diff = " << fMin1 - fMin0 << endl;
        if ( fMin1-fMin0 > fMaxDiff )
            fMaxDiff = fMin1-fMin0;
        ostr << endl;
    }

    ostr << "max diff = " << fMaxDiff << endl;
    ostr << endl;
}
//----------------------------------------------------------------------------
void TestDistLin3Box3 ()
{
    ofstream ostr("data.txt");
    MgcBox3 kBox;
    MgcLine3 kLine;
    MgcVector3 kP, kClosest, kSampleMin;
    MgcReal fMin0, fMin1, fDist, fLParam, fBP0, fBP1, fBP2;
    MgcReal fMaxDiff = 0.0;

    for (int i = 0; i < 1024; i++)
    {
        kBox.Center() = MgcVector3(RAND,RAND,RAND);
        kBox.Axis(2) = MgcVector3(RAND,RAND,RAND);
        MgcVector3::GenerateOrthonormalBasis(kBox.Axis(0),kBox.Axis(1),
            kBox.Axis(2),false);
        kBox.Extent(0) = 0.5*(RAND+1);
        kBox.Extent(1) = 0.5*(RAND+1);
        kBox.Extent(2) = 0.5*(RAND+1);

        kLine.Origin() = MgcVector3(RAND,RAND,RAND);
        kLine.Direction() = MgcVector3(RAND,RAND,RAND);
        kLine.Direction().Unitize();

        fMin0 = MgcMath::INFINITY;
        const int jmax = 32;
        for (int j = -jmax; j <= jmax; j++)
        {
            float fT = 4.0*j/jmax;
            kP = kLine.Origin() + fT*kLine.Direction();
            fDist = MgcDistance(kP,kBox,&fBP0,&fBP1,&fBP2);
            if ( fDist < fMin0 )
            {
                fMin0 = fDist;
                kSampleMin = kBox.Center() + fBP0*kBox.Axis(0) +
                    fBP1*kBox.Axis(1) + fBP2*kBox.Axis(2);
            }
        }

        ostr << "sampled = " << kSampleMin.x << ' ' << kSampleMin.y << ' '
             << kSampleMin.z << ' ' << fMin0 << endl;

        fMin1 = MgcDistance(kLine,kBox,&fLParam,&fBP0,&fBP1,&fBP2);
        kClosest = kBox.Center() + fBP0*kBox.Axis(0) + fBP1*kBox.Axis(1) +
            fBP2*kBox.Axis(2);
        ostr << "analytic = " << kClosest.x << ' ' << kClosest.y << ' '
             << kClosest.z << ' ' << fMin1 << endl;
        ostr << "diff = " << fMin1 - fMin0 << endl;
        if ( fMin1-fMin0 > fMaxDiff )
            fMaxDiff = fMin1-fMin0;
        ostr << endl;
    }

    ostr << "max diff = " << fMaxDiff << endl;
    ostr << endl;
}
//----------------------------------------------------------------------------
void Test ()
{
    MgcBox3 kBox;
    MgcLine3 kLine;
    MgcVector3 kClosest, kSampleMin;
    MgcReal fLParam, fBP0, fBP1, fBP2;

    kBox.Center() = MgcVector3::ZERO;
    kBox.Axis(0) = MgcVector3::UNIT_X;
    kBox.Axis(1) = MgcVector3::UNIT_Y;
    kBox.Axis(2) = MgcVector3::UNIT_Z;
    kBox.Extent(0) = 1.0;
    kBox.Extent(1) = 1.0;
    kBox.Extent(2) = 1.0;

    kLine.Origin() = MgcVector3(0.0,-8.0,-8.0);
    kLine.Direction() = MgcVector3(1.0,0.5,0.5);

    float fMin0 = MgcMath::INFINITY;
    const int jmax = 1024;
    for (int j = -jmax; j <= jmax; j++)
    {
        float fT = 64.0*j/jmax;
        MgcVector3 kP = kLine.Origin() + fT*kLine.Direction();
        float fDist = MgcDistance(kP,kBox,&fBP0,&fBP1,&fBP2);
        if ( fDist < fMin0 )
        {
            fMin0 = fDist;
            kSampleMin = kBox.Center() + fBP0*kBox.Axis(0) +
                fBP1*kBox.Axis(1) + fBP2*kBox.Axis(2);
        }
    }

    float fMin1 = MgcDistance(kLine,kBox,&fLParam,&fBP0,&fBP1,&fBP2);
}
//----------------------------------------------------------------------------
int main ()
{
    //TestDistVec3Tri3();
    //TestDistVec3Pgm3();
    //TestDistVec3Rct3();
    //TestDistVec3Cir3();
    //TestDistVec2Qdr2();
    //TestDistVec3Qdr3();
    //TestDistLin3Seg3();
    //TestDistRay3Seg3();
    //TestDistSeg3Seg3();
    //TestDistLin3Tri3();
    //TestDistSeg3Tri3();
    //TestDistRay3Tri3();

    //TestDistSeg3Pgm3();
    //TestDistSeg3Rct3();

    //TestDistTri3Tri3();
    //TestDistTri3Pgm3();
    //TestDistTri3Rct3();

    //TestDistPgm3Pgm3();
    //TestDistRct3Rct3();

    TestDistVec3Frustum();
    //TestDistVec3Box3();

    //TestDistLin3Box3();

    //Test();

    return 0;
}
//----------------------------------------------------------------------------