cmtkParametricPlane.h

Go to the documentation of this file.

/*
//
//  Copyright 1997-2009 Torsten Rohlfing
//
//  Copyright 2004-2011 SRI International
//
//  This file is part of the Computational Morphometry Toolkit.
//
//  http://www.nitrc.org/projects/cmtk/
//
//  The Computational Morphometry Toolkit is free software: you can
//  redistribute it and/or modify it under the terms of the GNU General Public
//  License as published by the Free Software Foundation, either version 3 of
//  the License, or (at your option) any later version.
//
//  The Computational Morphometry Toolkit is distributed in the hope that it
//  will be useful, but WITHOUT ANY WARRANTY; without even the implied
//  warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU General Public License for more details.
//
//  You should have received a copy of the GNU General Public License along
//  with the Computational Morphometry Toolkit.  If not, see
//  <http://www.gnu.org/licenses/>.
//
//  $Revision: 2752 $
//
//  $LastChangedDate: 2011-01-17 11:33:31 -0800 (Mon, 17 Jan 2011) $
//
//  $LastChangedBy: torstenrohlfing $
//
*/

#ifndef __cmtkParametricPlane_h_included_
#define __cmtkParametricPlane_h_included_

#include <cmtkconfig.h>

#include <Base/cmtkMacros.h>
#include <Base/cmtkVector.h>
#include <Base/cmtkAffineXform.h>
#include <Base/cmtkMathUtil.h>
#include <Base/cmtkUnits.h>

namespace
cmtk
{


class ParametricPlane 
{
public:
  typedef ParametricPlane Self;

  typedef SmartPointer<Self> SmartPtr;

  typedef FixedVector<3,Types::Coordinate> CoordinateVectorType;

  ParametricPlane();

  cmtkGetSetMacro(Self::CoordinateVectorType,Origin);

  void SetRho( const Types::Coordinate rho ) 
  {
    Rho = rho; this->Update();
  }
  
  Types::Coordinate GetRho() const 
  { 
    return Rho; 
  }
  
  void SetTheta( const Units::Degrees& theta ) 
  {
    Theta = theta; this->Update();
  }
  
  const Units::Degrees GetTheta() const
  { 
    return Theta; 
  }
  
  void SetPhi( const Units::Degrees& phi ) 
  {
    Phi = phi; this->Update();
  }
  
  const Units::Degrees GetPhi() const 
  { 
    return Phi; 
  }

  void SetNormal( const Self::CoordinateVectorType& normal );

  void GetParameters( CoordinateVector& v ) const 
  {
    v.SetDim( 6 );
    v[0] = Rho; v[1] = Theta.Value(); v[2] = Phi.Value();
    v[3] = this->m_Origin[0]; v[4] = this->m_Origin[1]; v[5] = this->m_Origin[2];
  }
  
  void SetParameters( const CoordinateVector& v ) 
  {
    Rho = v[0]; Theta = Units::Degrees( v[1] ); Phi = Units::Degrees( v[2] ); 
    this->m_Origin[0] = v[3]; this->m_Origin[1] = v[4]; this->m_Origin[2] = v[5];
    this->Update();
  }

  char GetWhichSide( const Self::CoordinateVectorType& point ) const 
  {
    // move given origin to coordinate origin
    Self::CoordinateVectorType p = point;
    p -= this->m_Origin;
    
    // compute line parameter of orthogonal projection of "point" onto this plane
    const Types::Coordinate intersect = Normal*p - Rho;
    return (intersect < 0) ? -1 : (intersect > 0) ? 1 : 0;
  }
  
  void Mirror( Self::CoordinateVectorType& toPoint, const Self::CoordinateVectorType& fromPoint ) const 
  {
    toPoint = fromPoint;
    this->MirrorInPlace( toPoint );
  }
  
  void MirrorInPlace( Self::CoordinateVectorType& point ) const 
  {
    // move given origin to coordinate origin
    point -= this->m_Origin;
    
    // compute line parameter of orthogonal projection of "point" onto
    // this plane and multiply by two to get parameter of mirrored point
    const Types::Coordinate intersect = 2 * (( Normal * point - Rho ) / SquareNormal);
    
    // compute mirrored point
    for ( int dim = 0; dim < 3; ++dim )
      point[dim] -= intersect * Normal[dim];

    // move given origin back to its given location
    point += this->m_Origin;
  }

  void Project( Self::CoordinateVectorType& toPoint, const Self::CoordinateVectorType& fromPoint ) const 
  {
    toPoint = fromPoint;
    this->ProjectInPlace( toPoint );
  }

  void ProjectInPlace( Self::CoordinateVectorType& point ) const 
  {
    // move given origin to coordinate origin
    point -= this->m_Origin;
    
    // compute line parameter of orthogonal projection of "point" onto
    // this plane
    const Types::Coordinate intersect = ( Normal * point - Rho ) / SquareNormal;
    
    // compute projected point
    for ( int dim = 0; dim < 3; ++dim )
      point[dim] -= intersect * Normal[dim];
    
    // move given origin back to its given location
    point += this->m_Origin;
  }

  AffineXform* GetAlignmentXform( const byte normalAxis = 0 ) const;

  AffineXform::MatrixType GetMirrorXformMatrix() const;

  const Self::CoordinateVectorType& GetNormal() const { return Normal; }

private:
  Types::Coordinate Rho;

  Units::Degrees Theta;

  Units::Degrees Phi;

  Self::CoordinateVectorType Normal;

  Types::Coordinate SquareNormal;

  void Update();
};


} // namespace cmtk

#endif // #ifndef __cmtkParametricPlane_h_included_