testdistance.cpp

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

                    fV0 = iY/MgcReal(iMax);
                    for (int iX = 0; iX+iY <= iMax; iX++)
                    {
                        fU0 = iX/MgcReal(iMax);
                        kQ = kTri1.Origin() + fU0*kTri1.Edge0() +
                            fV0*kTri1.Edge1();
                        kDiff = kP-kQ;
                        fDist = kDiff.Length();
                        if ( fDist < fMin0 )
                        {
                            fMin0 = fDist;
                            fS = fS0;
                            fT = fT0;
                            fU = fU0;
                            fV = fV0;
                        }
                    }
                }
            }
        }
        ostr << "i = " << i << endl;
        ostr << "sampled = " << fS << ' ' << fT << ' ' << fU << ' '
             << fV << ' ' << fMin0 << endl;

        fMin1 = MgcDistance(kTri0,kTri1,&fS,&fT,&fU,&fV);
        ostr << "analytic = " << fS << ' ' << fT << ' ' << fU << ' '
             << fV << ' ' << fMin1 << endl;

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

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

        ostr << endl;
    }

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

    MgcTriangle3 kTri;
    MgcParallelogram3 kPgm;
    MgcVector3 kP, kQ, kDiff;
    MgcReal fU, fV, fS, fT, fU0, fV0, 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);
        kPgm.Origin() = MgcVector3(RAND,RAND,RAND);
        kPgm.Edge0() = MgcVector3(RAND,RAND,RAND);
        kPgm.Edge1() = MgcVector3(RAND,RAND,RAND);

        fMin0 = MgcMath::INFINITY;
        int iMax = 32;
        for (int iW = 0; iW <= iMax; iW++)
        {
            fT0 = iW/MgcReal(iMax);
            for (int iZ = 0; iW+iZ <= iMax; iZ++)
            {
                fS0 = iZ/MgcReal(iMax);
                kP = kTri.Origin()+fS0*kTri.Edge0()+fT0*kTri.Edge1();
                for (int iY = 0; iY <= iMax; iY++)
                {
                    fV0 = iY/MgcReal(iMax);
                    for (int iX = 0; iX <= iMax; iX++)
                    {
                        fU0 = iX/MgcReal(iMax);
                        kQ = kPgm.Origin()+fU0*kPgm.Edge0()+fV0*kPgm.Edge1();
                        kDiff = kP-kQ;
                        fDist = kDiff.Length();
                        if ( fDist < fMin0 )
                        {
                            fMin0 = fDist;
                            fS = fS0;
                            fT = fT0;
                            fU = fU0;
                            fV = fV0;
                        }
                    }
                }
            }
        }
        ostr << "i = " << i << endl;
        ostr << "sampled = " << fS << ' ' << fT << ' ' << fU << ' ' << fV
             << ' ' << fMin0 << endl;

        fMin1 = MgcDistance(kTri,kPgm,&fS,&fT,&fU,&fV);
        ostr << "analytic = " << fS << ' ' << fT << ' ' << fU << ' ' << fV
             << ' ' << fMin1 << endl;

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

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

        ostr << endl;
    }

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

    MgcParallelogram3 kPgm0, kPgm1;
    MgcVector3 kP, kQ, kDiff;
    MgcReal fU, fV, fS, fT, fU0, fV0, fS0, fT0, fMin0, fMin1, fDist;
    MgcReal fMaxDiff = 0.0;

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

        fMin0 = MgcMath::INFINITY;
        int iMax = 32;
        for (int iW = 0; iW <= iMax; iW++)
        {
            fT0 = iW/MgcReal(iMax);
            for (int iZ = 0; iZ <= iMax; iZ++)
            {
                fS0 = iZ/MgcReal(iMax);
                kP = kPgm0.Origin()+fS0*kPgm0.Edge0()+fT0*kPgm0.Edge1();
                for (int iY = 0; iY <= iMax; iY++)
                {
                    fV0 = iY/MgcReal(iMax);
                    for (int iX = 0; iX <= iMax; iX++)
                    {
                        fU0 = iX/MgcReal(iMax);
                        kQ = kPgm1.Origin() + fU0*kPgm1.Edge0() +
                            fV0*kPgm1.Edge1();
                        kDiff = kP-kQ;
                        fDist = kDiff.Length();
                        if ( fDist < fMin0 )
                        {
                            fMin0 = fDist;
                            fS = fS0;
                            fT = fT0;
                            fU = fU0;
                            fV = fV0;
                        }
                    }
                }
            }
        }
        ostr << "i = " << i << endl;
        ostr << "sampled = " << fS << ' ' << fT << ' ' << fU << ' ' << fV
             << ' ' << fMin0 << endl;

        fMin1 = MgcDistance(kPgm0,kPgm1,&fS,&fT,&fU,&fV);
        ostr << "analytic = " << fS << ' ' << fT << ' ' << fU << ' ' << fV
             << ' ' << fMin1 << endl;

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

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

        ostr << endl;
    }

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

    MgcRectangle3 kRct0, kRct1;
    MgcVector3 kP, kQ, kDiff;
    MgcReal fU, fV, fS, fT, fU0, fV0, fS0, fT0, fMin0, fMin1, fDist;
    MgcReal fMaxDiff = 0.0;

    for (int i = 0; i < 128; i++)
    {
        kRct0.Origin() = MgcVector3(RAND,RAND,RAND);
        kRct0.Edge0() = MgcVector3(RAND,RAND,RAND);
        MgcVector3::GenerateOrthonormalBasis(kP,kQ,kRct0.Edge0(),false);
        kRct0.Edge1() = kP;
        kRct1.Origin() = MgcVector3(RAND,RAND,RAND);
        kRct1.Edge0() = MgcVector3(RAND,RAND,RAND);
        MgcVector3::GenerateOrthonormalBasis(kP,kQ,kRct1.Edge0(),false);
        kRct1.Edge1() = kP;

        fMin0 = MgcMath::INFINITY;
        int iMax = 32;
        for (int iW = 0; iW <= iMax; iW++)
        {
            fT0 = iW/MgcReal(iMax);
            for (int iZ = 0; iZ <= iMax; iZ++)
            {
                fS0 = iZ/MgcReal(iMax);
                kP = kRct0.Origin()+fS0*kRct0.Edge0()+fT0*kRct0.Edge1();
                for (int iY = 0; iY <= iMax; iY++)
                {
                    fV0 = iY/MgcReal(iMax);
                    for (int iX = 0; iX <= iMax; iX++)
                    {
                        fU0 = iX/MgcReal(iMax);
                        kQ = kRct1.Origin() + fU0*kRct1.Edge0() +
                            fV0*kRct1.Edge1();
                        kDiff = kP-kQ;
                        fDist = kDiff.Length();
                        if ( fDist < fMin0 )
                        {
                            fMin0 = fDist;
                            fS = fS0;
                            fT = fT0;
                            fU = fU0;
                            fV = fV0;
                        }
                    }
                }
            }
        }
        ostr << "i = " << i << endl;
        ostr << "sampled = " << fS << ' ' << fT << ' ' << fU << ' ' << fV
             << ' ' << fMin0 << endl;

        fMin1 = MgcDistance(kRct0,kRct1,&fS,&fT,&fU,&fV);
        ostr << "analytic = " << fS << ' ' << fT << ' ' << fU << ' ' << fV
             << ' ' << fMin1 << endl;

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

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

        ostr << endl;
    }

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

    MgcTriangle3 kTri;
    MgcRectangle3 kRct;
    MgcVector3 kP, kQ, kDiff;
    MgcReal fU, fV, fS, fT, fU0, fV0, 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);
        kRct.Origin() = MgcVector3(RAND,RAND,RAND);
        kRct.Edge0() = MgcVector3(RAND,RAND,RAND);
        MgcVector3::GenerateOrthonormalBasis(kP,kQ,kRct.Edge0(),false);
        kRct.Edge1() = kP;

        fMin0 = MgcMath::INFINITY;
        int iMax = 32;
        for (int iW = 0; iW <= iMax; iW++)
        {
            fT0 = iW/MgcReal(iMax);
            for (int iZ = 0; iW+iZ <= iMax; iZ++)
            {
                fS0 = iZ/MgcReal(iMax);
                kP = kTri.Origin()+fS0*kTri.Edge0()+fT0*kTri.Edge1();
                for (int iY = 0; iY <= iMax; iY++)
                {
                    fV0 = iY/MgcReal(iMax);
                    for (int iX = 0; iX <= iMax; iX++)
                    {
                        fU0 = iX/MgcReal(iMax);
                        kQ = kRct.Origin()+fU0*kRct.Edge0()+fV0*kRct.Edge1();
                        kDiff = kP-kQ;
                        fDist = kDiff.Length();
                        if ( fDist < fMin0 )
                        {
                            fMin0 = fDist;
                            fS = fS0;
                            fT = fT0;
                            fU = fU0;
                            fV = fV0;
                        }
                    }
                }
            }
        }
        ostr << "i = " << i << endl;
        ostr << "sampled = " << fS << ' ' << fT << ' ' << fU << ' ' << fV
             << ' ' << fMin0 << endl;

        fMin1 = MgcDistance(kTri,kRct,&fS,&fT,&fU,&fV);
        ostr << "analytic = " << fS << ' ' << fT << ' ' << fU << ' ' << fV
             << ' ' << fMin1 << endl;

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

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

        ostr << endl;
    }

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

    MgcTriangle3 kTri;
    MgcLine3 kLine;
    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);

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

        fMin0 = MgcMath::INFINITY;
        int iMax = 32;
        for (int iZ = 0; iZ <= 16*iMax; iZ++)
        {
            fR0 = -4.0 + 8.0*iZ/MgcReal(iMax);
            kP = kLine.Origin()+fR0*kLine.Direction();
            for (int iY = 0; iY <= iMax; iY++)
            {
                fS0 = iY/MgcReal(iMax);
                for (int iX = 0; iX+iY <= iMax; iX++)
                {
                    fT0 = iX/MgcReal(iMax);
                    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;