matrix.cpp

摄影测量专业。实现单像后方交会以及立体像对的前方交会。以文件形式读取控制点和像点坐标。

  bool Matrix::Inplace_Floor()
  {
    if( MTX_Floor( &m_Matrix ) )
    {
      return true;
    }
    else 
    {
      MTX_ERROR_MSG( "MTX_Floor returned false." );
      return false;
    }
  }

  bool Matrix::Inplace_Ceil()
  {
    if( MTX_Ceil( &m_Matrix ) )
    {
      return true;
    }
    else 
    {
      MTX_ERROR_MSG( "MTX_Ceil returned false." );
      return false;
    }
  }

  bool Matrix::Inplace_erf()
  {
    if( MTX_erf_Inplace( &m_Matrix ) )
    {
      return true;
    }
    else 
    {
      MTX_ERROR_MSG( "MTX_erf_Inplace returned false." );
      return false;
    }
  }

  bool Matrix::Inplace_erfinv()
  {
    if( MTX_erfinv_Inplace( &m_Matrix ) )
    {
      return true;
    }
    else 
    {
      MTX_ERROR_MSG( "MTX_erfinv_Inplace returned false." );
      return false;
    }
  }

  bool Matrix::Inplace_erfc()
  {
    if( MTX_erfc_Inplace( &m_Matrix ) )
    {
      return true;
    }
    else 
    {
      MTX_ERROR_MSG( "MTX_erfc_Inplace returned false." );
      return false;
    }
  }

  bool Matrix::Inplace_erfcinv()
  {
    if( MTX_erfcinv_Inplace( &m_Matrix ) )
    {
      return true;
    }
    else 
    {
      MTX_ERROR_MSG( "MTX_erfcinv_Inplace returned false." );
      return false;
    }
  }

  bool Matrix::Inplace_Fix()
  {
    if( MTX_Fix( &m_Matrix ) )
    {
      return true;
    }
    else 
    {
      MTX_ERROR_MSG( "MTX_Fix returned false." );
      return false;
    }
  }

  bool Matrix::Inplace_AddScalar( const double scalar )
  {
    if( MTX_Add_Scalar( &m_Matrix, scalar ) )
    {
      return true;
    }
    else 
    {
      MTX_ERROR_MSG( "MTX_Add_Scalar returned false." );
      return false;
    }
  }

  bool Matrix::Inplace_SubtractScalar( const double scalar )
  {
    if( MTX_Subtract_Scalar( &m_Matrix, scalar ) )
    {
      return true;
    }
    else 
    {
      MTX_ERROR_MSG( "MTX_Subtract_Scalar returned false." );
      return false;
    }
  }

  bool Matrix::Inplace_MultiplyScalar( const double scalar )
  {
    if( MTX_Multiply_Scalar( &m_Matrix, scalar ) )
    {
      return true;
    }
    else 
    {
      MTX_ERROR_MSG( "MTX_Multiply_Scalar returned false." );
      return false;
    }
  }

  bool Matrix::Inplace_DivideScalar( const double scalar )
  {
    if( MTX_Divide_Scalar( &m_Matrix, scalar ) )
    {
      return true;
    }
    else 
    {
      MTX_ERROR_MSG( "MTX_Divide_Scalar returned false." );
      return false;
    }
  }

  bool Matrix::Inplace_PowerScalar( const double scalar )
  {
    if( MTX_PowInplace( &m_Matrix, scalar, 0.0 ) ) 
    {
      return true;
    }
    else
    {
      MTX_ERROR_MSG( "MTX_PowInplace returned false." );
      return false;
    }
  }

  bool Matrix::Inplace_AddScalarComplex( const std::complex<double> cplx )
  {
    if( MTX_Add_ScalarComplex( &m_Matrix, cplx.real(), cplx.imag() ) )
    {
      return true;
    }
    else 
    {
      MTX_ERROR_MSG( "MTX_Add_ScalarComplex returned false." );
      return false;
    }
  }

  bool Matrix::Inplace_SubtractScalarComplex( const std::complex<double> cplx )
  {
    if( MTX_Subtract_ScalarComplex( &m_Matrix, cplx.real(), cplx.imag() ) )
    {
      return true;
    }
    else 
    {
      MTX_ERROR_MSG( "MTX_Subtract_ScalarComplex returned false." );
      return false;
    }
  }

  bool Matrix::Inplace_MultiplyScalarComplex( const std::complex<double> cplx )
  {
    if( MTX_Multiply_ScalarComplex( &m_Matrix, cplx.real(), cplx.imag() ) )
    {
      return true;
    }
    else 
    {
      MTX_ERROR_MSG( "MTX_Multiply_ScalarComplex returned false." );
      return false;
    }
  }

  bool Matrix::Inplace_DivideScalarComplex( const std::complex<double> cplx )
  {
    if( MTX_Divide_ScalarComplex( &m_Matrix,  cplx.real(), cplx.imag() ) )
    {
      return true;
    }
    else 
    {
      MTX_ERROR_MSG( "MTX_Divide_ScalarComplex returned false." );
      return false;
    }
  }

  bool Matrix::Inplace_PowerScalarComplex( const std::complex<double> cplx )
  {
    if( MTX_PowInplace( &m_Matrix, cplx.real(), cplx.imag() ) ) 
    {
      return true;
    }
    else
    {
      MTX_ERROR_MSG( "MTX_PowInplace returned false." );
      return false;
    }
  }

  bool Matrix::Inplace_Abs()
  {
    if( MTX_Abs( &m_Matrix ) )
    {
      return true;
    }
    else 
    {
      MTX_ERROR_MSG( "MTX_Abs returned false." );
      return false;
    }
  }

  bool Matrix::Inplace_acos()
  {
    if( MTX_acos( &m_Matrix ) )
    {
      return true;
    }
    else 
    {
      MTX_ERROR_MSG( "MTX_acos returned false." );
      return false;
    }
  }

  bool Matrix::Inplace_acosd()
  {
    if( MTX_acos( &m_Matrix ) )
    {
      if( MTX_Multiply_Scalar( &m_Matrix, RAD2DEG ) )
      {
        return true;
      }
      else
      {
        MTX_ERROR_MSG( "MTX_Multiply_Scalar returned false." );
        return false;
      }
    }
    else 
    {
      MTX_ERROR_MSG( "MTX_acos returned false." );
      return false;
    }
  }

  bool Matrix::Inplace_acosh()
  {
    if( MTX_acosh( &m_Matrix ) )
    {
      return true;
    }
    else 
    {
      MTX_ERROR_MSG( "MTX_acosh returned false." );
      return false;
    }
  }

  bool Matrix::Inplace_angle()
  {
    if( MTX_angle( &m_Matrix ) )
    {
      return true;
    }
    else
    {
      MTX_ERROR_MSG( "MTX_angle returned false." );
      return false;
    }
  }

  bool Matrix::Inplace_asin()
  {
    if( MTX_asin( &m_Matrix ) )
    {
      return true;
    }
    else 
    {
      MTX_ERROR_MSG( "MTX_asin returned false." );
      return false;
    }
  }

  bool Matrix::Inplace_asind()
  {
    if( MTX_asin( &m_Matrix ) )
    {
      if( MTX_Multiply_Scalar( &m_Matrix, RAD2DEG ) )
      {
        return true;
      }
      else
      {
        MTX_ERROR_MSG( "MTX_Multiply_Scalar returned false." );
        return false;
      }
    }
    else 
    {
      MTX_ERROR_MSG( "MTX_asin returned false." );
      return false;
    }
  }

  bool Matrix::Inplace_asinh()
  {
    if( MTX_asinh( &m_Matrix ) )
    {
      return true;
    }
    else 
    {
      MTX_ERROR_MSG( "MTX_asinh returned false." );
      return false;
    }
  }

  bool Matrix::Inplace_atan()
  {
    if( MTX_atan( &m_Matrix ) )
    {
      return true;
    }
    else
    {
      MTX_ERROR_MSG( "MTX_atan returned false." );
      return false;
    }
  }

  bool Matrix::Inplace_atand()
  {
    if( MTX_atan( &m_Matrix ) )
    {
      if( MTX_Multiply_Scalar( &m_Matrix, RAD2DEG ) )
      {
        return true;
      }
      else
      {
        MTX_ERROR_MSG( "MTX_Multiply_Scalar returned false." );
        return false;
      }
    }
    else 
    {
      MTX_ERROR_MSG( "MTX_atan returned false." );
      return false;
    }
  }

  bool Matrix::Inplace_atanh()
  {
    if( MTX_atanh( &m_Matrix ) )
    {
      return true;
    }
    else
    {
      MTX_ERROR_MSG( "MTX_atanh returned false." );
      return false;
    }
  }

  bool Matrix::Inplace_Sqr()
  {
    if( MTX_Sqr( &m_Matrix ) )
    {
      return true;
    }
    else 
    {
      MTX_ERROR_MSG( "MTX_Sqr returned false." );
      return false;
    }
  }

  bool Matrix::Inplace_Sqrt()
  {
    if( MTX_Sqrt( &m_Matrix ) )
    {
      return true;
    }
    else 
    {
      MTX_ERROR_MSG( "MTX_Sqrt returned false." );
      return false;
    }
  }

  bool Matrix::Inplace_Exp()
  {
    if( MTX_Exp( &m_Matrix ) )
    {
      return true;
    }
    else 
    {
      MTX_ERROR_MSG( "MTX_Exp returned false." );
      return false;
    }
  }

  bool Matrix::Inplace_Ln()
  {
    if( MTX_Ln( &m_Matrix ) )
    {
      return true;
    }
    else 
    {
      MTX_ERROR_MSG( "MTX_Ln returned false." );
      return false;
    }
  }

  bool Matrix::Inplace_Increment()
  {
    if( MTX_Increment( &m_Matrix ) )
    {
      return true;
    }
    else 
    {
      MTX_ERROR_MSG( "MTX_Increment returned false." );
      return false;
    }
  }

  bool Matrix::Inplace_Decrement()
  {
    if( MTX_Decrement( &m_Matrix ) )
    {
      return true;
    }
    else 
    {
      MTX_ERROR_MSG( "MTX_Decrement returned false." );
      return false;
    }
  }

  bool Matrix::Inplace_Add( const Matrix &B )
  {
    if( MTX_Add_Inplace( &m_Matrix, &B.m_Matrix ) )
    {
      return true;
    }
    else 
    {
      MTX_ERROR_MSG( "MTX_Add_Inplace returned false." );
      return false;
    }
  }

  bool Matrix::Inplace_Subtract( const Matrix &B )
  {
    if( MTX_Subtract_Inplace( &m_Matrix, &B.m_Matrix ) )
    {
      return true;
    }
    else 
    {
      MTX_ERROR_MSG( "MTX_Subtract_Inplace returned false." );
      return false;
    }
  }

  bool Matrix::Inplace_PreMultiply( const Matrix &B )
  {
    if( MTX_PreMultiply_Inplace( &m_Matrix, &B.m_Matrix ) )
    {
      return true;
    }
    else 
    {
      MTX_ERROR_MSG( "MTX_PreMultiply_Inplace returned false." );
      return false;
    }
  }

  bool Matrix::Inplace_TranposePreMultiply( const Matrix &B )
  {
    if( MTX_TransposePreMultiply_Inplace( &m_Matrix, &B.m_Matrix ) )
    {
      return true;
    }
    else 
    {
      MTX_ERROR_MSG( "MTX_TransposePreMultiply_Inplace returned false." );
      return false;
    }
  }

  bool Matrix::Inplace_PostMultiply( const Matrix &B )
  {
    if( MTX_PostMultiply_Inplace( &m_Matrix, &B.m_Matrix ) )
    {
      return true;
    }
    else 
    {
      MTX_ERROR_MSG( "MTX_PostMultiply_Inplace returned false." );
      return false;
    }
  }

  bool Matrix::Inplace_PostMultiplyTranspose( const Matrix &B )
  {
    if( MTX_PostMultiplyTranspose_Inplace( &m_Matrix, &B.m_Matrix ) )
    {
      return true;
    }
    else 
    {
      MTX_ERROR_MSG( "MTX_PostMultiplyTranspose_Inplace returned false." );
      return false;
    }
  }  

  bool Matrix::Inplace_DotMultiply( const Matrix &B )
  {
    if( MTX_DotMultiply_Inplace( &m_Matrix, &B.m_Matrix ) )
    {
      return true;
    }
    else 
    {
      MTX_ERROR_MSG( "MTX_DotMultiply_Inplace returned false." );
      return false;
    }
  }

  bool Matrix::Inplace_DotDivide( const Matrix &B )
  {
    if( MTX_DotDivide_Inplace( &m_Matrix, &B.m_Matrix ) )
    {
      return true;
    }
    else 
    {
      MTX_ERROR_MSG( "MTX_DotDivide_Inplace returned false." );
      return false;
    }
  }

  bool Matrix::Inplace_SortAscending()
  {
    if( MTX_SortAscending( &m_Matrix ) )
    {
      return true;
    }
    else 
    {
      MTX_ERROR_MSG( "MTX_SortAscending returned false." );
      return false;
    }
  }

  bool Matrix::Inplace_SortDescending()
  {
    if( MTX_SortDescending( &m_Matrix ) )
    {
      return true;
    }
    else 
    {
      MTX_ERROR_MSG( "MTX_SortDescending returned false." );
      return false;
    }
  }

  bool Matrix::Inplace_SortColumnAscending( const unsigned col )
  {
    if( MTX_SortColumnAscending( &m_Matrix, col ) )
    {
      return true;
    }
    else 
    {
      MTX_ERROR_MSG( "MTX_SortColumnAscending returned false." );
      return false;
    }
  }

  bool Matrix::Inplace_SortColumnDescending( const unsigned col )
  {
    if( MTX_SortColumnDescending( &m_Matrix, col ) )
    {
      return true;
    }
    else 
    {
      MTX_ERROR_MSG( "MTX_SortColumnDescending returned false." );
      return false;
    }