SymMatrix.h

// SYMMATRIX.h: interface for the CSymMatrix class.
//
//////////////////////////////////////////////////////////////////////
 
#if !defined(AFX_SYMMATRIX_H__BB3D80EA_003C_11D2_A0E3_000000000000__INCLUDED_)
#define AFX_SYMMATRIX_H__BB3D80EA_003C_11D2_A0E3_000000000000__INCLUDED_
 
#ifdef _MSC_VER
#pragma once
#endif // _MSC_VER
 
BEGIN_MOOTOOLS_NAMESPACE
 
#ifdef PLY_SMALL_FACES
#define SYMMATRIX_INCLUDE_AREA
#ifndef _DEBUG
#pragma message("************************************************")
#pragma message("SymMatrix : SYMMATRIX_INCLUDE_AREA is defined\n")
#pragma message("************************************************")
#endif
#endif
 
// double is used because it gives a very very better optimization...
// It is also faster (15/04/2008)
class DLLFUNCTION CSymMatrix
{
public:
    double matrix[10];
 
public:
    void Init();
     CSymMatrix();
 
    void ComputeErrorQuadric(const C4DVectorD& plane);
    void operator *=(double);
    void OldMult(C3DVector& resvect, const C3DVector& vector) const;
    void Mult(C3DVectorD& resvect, const C3DVectorD& vector) const;
    bool operator==(const CSymMatrix&);
 
    inline CSymMatrix& operator=(const CSymMatrix& refmatrix)
    {
        memcpy(matrix, refmatrix.matrix, sizeof(double[10]));
#ifdef SYMMATRIX_INCLUDE_AREA
        area = refmatrix.area;
#endif
        return *this;
    }
 
    inline double operator()(int i, int j) const
    {
        switch (i)
        {
            case 0:
                switch (j)
                {
                    case 0:
                        return matrix[0];
                    case 1:
                        return matrix[1];
                    case 2:
                        return matrix[2];
                    case 3:
                        return matrix[3];
                }
                break;
 
            case 1:
                switch (j)
                {
                    case 0:
                        return matrix[1];
                    case 1:
                        return matrix[4];
                    case 2:
                        return matrix[5];
                    case 3:
                        return matrix[6];
                }
                break;
 
            case 2:
                switch (j)
                {
                    case 0:
                        return matrix[2];
                    case 1:
                        return matrix[5];
                    case 2:
                        return matrix[7];
                    case 3:
                        return matrix[8];
                }
                break;
 
            case 3:
                switch (j)
                {
                    case 0:
                        return matrix[3];
                    case 1:
                        return matrix[6];
                    case 2:
                        return matrix[8];
                    case 3:
                        return matrix[9];
                }
                break;
 
            default:
                XASSERT(0);
        }
 
        return 0.0;
    }
 
    void operator-= (const CSymMatrix& submatrix);
    void operator+= (const CSymMatrix& matrix);
    CSymMatrix(bool);
    ~CSymMatrix(); // Avoid virtual. It adds one point on the C3DExtPointSize
 
#ifdef _DEBUG
    void Dump();
#endif
 
#ifdef SYMMATRIX_INCLUDE_AREA
    double area;
 
    inline void SetArea(double area)
    {
        this->area = area;
    }
 
    inline double GetArea() const
    {
        return area;
    }
#endif
};
 
END_MOOTOOLS_NAMESPACE
 
#endif // !defined(AFX_SYMMATRIX_H__BB3D80EA_003C_11D2_A0E3_000000000000__INCLUDED_)