/*****************************************************************************/

// Copyright 2006-2008 Adobe Systems Incorporated

// All Rights Reserved.

//

// NOTICE:  Adobe permits you to use, modify, and distribute this file in

// accordance with the terms of the Adobe license agreement accompanying it.

/*****************************************************************************/

/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_matrix.h#2 $ */ 

/* $DateTime: 2012/07/31 22:04:34 $ */

/* $Change: 840853 $ */

/* $Author: tknoll $ */

/** \file

 * Matrix and vector classes, including specialized 3x3 and 4x3 versions as

 * well as length 3 vectors.

 */

/*****************************************************************************/

#ifndef __dng_matrix__

#define __dng_matrix__

/*****************************************************************************/

#include "dng_sdk_limits.h"

#include "dng_types.h"

/*****************************************************************************/

/// \brief Class to represent 2D matrix up to kMaxColorPlanes x kMaxColorPlanes

/// in size.

class dng_matrix

  {

  protected:

    uint32 fRows;

    uint32 fCols;

    real64 fData [kMaxColorPlanes] [kMaxColorPlanes];

  public:

    dng_matrix ();

    dng_matrix (uint32 rows,

          uint32 cols);

    dng_matrix (const dng_matrix &m);

    virtual ~dng_matrix ()

      {

      }

    void Clear ();

    void SetIdentity (uint32 count);

    uint32 Rows () const

      {

      return fRows;

      }

    uint32 Cols () const

      {

      return fCols;

      }

    real64 * operator [] (uint32 row)

      {

      return fData [row];

      }

    const real64 * operator [] (uint32 row) const

      {

      return fData [row];

      }

    bool operator== (const dng_matrix &m) const;

    bool operator!= (const dng_matrix &m) const

      {

      return !(*this == m);

      }

    bool IsEmpty () const

      {

      return fRows == 0 || fCols == 0;

      }

    bool NotEmpty () const

      {

      return !IsEmpty ();

      }

    bool IsDiagonal () const;

    real64 MaxEntry () const;

    real64 MinEntry () const;

    void Scale (real64 factor);

    void Round (real64 factor);

    void SafeRound (real64 factor);

  };

/*****************************************************************************/

/// \brief A 3x3 matrix.

class dng_matrix_3by3: public dng_matrix

  {

  public:

    dng_matrix_3by3 ();

    dng_matrix_3by3 (const dng_matrix &m);

    dng_matrix_3by3 (real64 a00, real64 a01, real64 a02,

                 real64 a10, real64 a11, real64 a12,

                 real64 a20, real64 a21, real64 a22);

    dng_matrix_3by3 (real64 a00, real64 a11, real64 a22);

  };

/*****************************************************************************/

/// \brief A 4x3 matrix. Handy for working with 4-color cameras.

class dng_matrix_4by3: public dng_matrix

  {

  public:

    dng_matrix_4by3 ();

    dng_matrix_4by3 (const dng_matrix &m);

    dng_matrix_4by3 (real64 a00, real64 a01, real64 a02,

                 real64 a10, real64 a11, real64 a12,

                 real64 a20, real64 a21, real64 a22,

                 real64 a30, real64 a31, real64 a32);

  };

/*****************************************************************************/

/// \brief Class to represent 1-dimensional vector with up to kMaxColorPlanes

/// components.

class dng_vector

  {

  protected:

    uint32 fCount;

    real64 fData [kMaxColorPlanes];

  public:

    dng_vector ();

    dng_vector (uint32 count);

    dng_vector (const dng_vector &v);

    virtual ~dng_vector ()

      {

      }

    void Clear ();

    void SetIdentity (uint32 count);

    uint32 Count () const

      {

      return fCount;

      }

    real64 & operator [] (uint32 index)

      {

      return fData [index];

      }

    const real64 & operator [] (uint32 index) const

      {

      return fData [index];

      }

    bool operator== (const dng_vector &v) const;

    bool operator!= (const dng_vector &v) const

      {

      return !(*this == v);

      }

    bool IsEmpty () const

      {

      return fCount == 0;

      }

    bool NotEmpty () const

      {

      return !IsEmpty ();

      }

    real64 MaxEntry () const;

    real64 MinEntry () const;

    void Scale (real64 factor);

    void Round (real64 factor);

    dng_matrix AsDiagonal () const;

    dng_matrix AsColumn () const;

  };

/*****************************************************************************/

/// \brief A 3-element vector.

class dng_vector_3: public dng_vector

  {

  public:

    dng_vector_3 ();

    dng_vector_3 (const dng_vector &v);

    dng_vector_3 (real64 a0,

            real64 a1,

            real64 a2);

  };

/*****************************************************************************/

/// \brief A 4-element vector.

class dng_vector_4: public dng_vector

  {

  public:

    dng_vector_4 ();

    dng_vector_4 (const dng_vector &v);

    dng_vector_4 (real64 a0,

            real64 a1,

            real64 a2,

            real64 a3);

  };

/*****************************************************************************/

dng_matrix operator* (const dng_matrix &A,

            const dng_matrix &B);

dng_vector operator* (const dng_matrix &A,

            const dng_vector &B);

dng_matrix operator* (real64 scale,

            const dng_matrix &A);

dng_vector operator* (real64 scale,

            const dng_vector &A);

/*****************************************************************************/

dng_matrix operator+ (const dng_matrix &A,

            const dng_matrix &B);

/*****************************************************************************/

dng_matrix Transpose (const dng_matrix &A);

/*****************************************************************************/

dng_matrix Invert (const dng_matrix &A);

dng_matrix Invert (const dng_matrix &A,

           const dng_matrix &hint);

/*****************************************************************************/

inline real64 MaxEntry (const dng_matrix &A)

  {

  return A.MaxEntry ();

  }

inline real64 MaxEntry (const dng_vector &A)

  {

  return A.MaxEntry ();

  }

/*****************************************************************************/

inline real64 MinEntry (const dng_matrix &A)

  {

  return A.MinEntry ();

  }

inline real64 MinEntry (const dng_vector &A)

  {

  return A.MinEntry ();

  }

/*****************************************************************************/

#endif

/*****************************************************************************/