ProjectionParametersOrthographic.hh

/*
This file is part of the BIAS library (Basic ImageAlgorithmS).

Copyright (C) 2003-2009    (see file CONTACT for details)
  Multimediale Systeme der Informationsverarbeitung
  Institut fuer Informatik
  Christian-Albrechts-Universitaet Kiel

BIAS is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version.

BIAS 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 Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License
along with BIAS; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/

#ifndef __BIAS_ProjectionParametersOrthographic_hh__
#define __BIAS_ProjectionParametersOrthographic_hh__

#include <math.h>

#include <bias_config.h>
#include <Base/Common/BIASpragmaStart.hh>
#include <Geometry/ProjectionParametersBase.hh>

namespace BIAS {
  /** @class ProjectionParametersOrthographic
 *  @ingroup g_geometry
 *  @brief Camera parameters which define the mapping between rays in the
 *  camera coordinate system and pixels in the image as well as external
 *  pose.
 *  @author Jung */
class BIASGeometry_EXPORT ProjectionParametersOrthographic: public ProjectionParametersBase{
  private:
    typedef ProjectionParametersBase PPB;
  public:
    ProjectionParametersOrthographic(Vector3<double> &rayDir,
      const unsigned int width=0, const unsigned int height=0,
      const double dX=1, const double dY=1)
    : PPB(width, height){
        BIASASSERT(rayDir.NormL2() > 1e-7);
        rayDir_ = rayDir.Normalize();
        dX_ = dX;
        dY_ = dY;
    }

    void SetParameters(Vector3<double>&rayDir, const double dX, const double dY,
    const unsigned int width, const unsigned int height){
      BIASASSERT(rayDir.NormL2() > 1e-7);
      rayDir_ = rayDir.Normalize();
      dX_ = dX;
      dY_ = dY;
      width_ = width;
      height_ = height;
    }

    ProjectionParametersOrthographic(const ProjectionParametersOrthographic &P){
      *this = P;
    }

    ProjectionParametersOrthographic& operator=(const ProjectionParametersOrthographic &P){
      PPB::operator=(P);
      dX_ = P.dX_;
      dY_ = P.dY_;
      return *this;
    }

    virtual ~ProjectionParametersOrthographic(){}

    virtual const bool DoIntrinsicsDiffer(const PPB *p) const;

    bool DoesPointProjectIntoImageLocal(const Vector3<double> &localP,
                                        HomgPoint2D &p,
                                        bool IgnoreDistortion = true) const;

    /** @brief map points from image onto unit diameter image plane in 3D.
     * Chosen is the rectangular image plane with ray distance 1 from the camera center. */
    HomgPoint3D UnProjectToImagePlane(const HomgPoint2D& pos,
    const double& depth = 1.0, bool IgnoreDistortion = true) const;

    /** @brief calculates the projection of a point in the camera coordinate system
        to a pixel in the image plane of the camera */
    virtual HomgPoint2D ProjectLocal(const Vector3<double> &point,
    bool IgnoreDistortion = true) const;

    /** @brief calculates the projection of a point in the local camera
        coordinate system to a pixel in the image plane of the camera. */
    virtual inline int ProjectLocal(const Vector3<double>& point, HomgPoint2D &p2d,
    bool IgnoreDistortion = true) const{
      p2d = ProjectLocal(point, IgnoreDistortion);
      return 0;
    }

    /** @brief covariant virtual copy constructor for use in Projection */
    virtual ProjectionParametersOrthographic* Clone() const{
      return new ProjectionParametersOrthographic(*this);
    }

    /** @brief Calculates a 3D point in a local camera coordinate system
        specified by camSystem, which belongs to the image position pos in
        cam with distance depth to the camera center cam. */
    virtual inline Vector3<double> UnProjectToPointLocal(const HomgPoint2D &pos,
    const double &depth, bool IgnoreDistortion = true) const{
      //  Distortion is not implemented for orthographic projections!
      BIASASSERT(IgnoreDistortion);
      Vector3<double> res(rayDir_);
      res.MultIP(depth);
      res[0] += (pos[0]-principalX_)*dX_;
      res[1] += (pos[1]-principalY_)*dY_;
      return res;
    }

    /** @brief calculates the direction of the viewing ray from the image plane,
        shifted into the camera center (in the camera coordinate system). The origin is
        the pixels position on the image plane, which is located in the camera center. */
    virtual inline void UnProjectLocal(const HomgPoint2D &pos, Vector3<double>& origin,
                                       Vector3<double>& direction,
                                       bool ignoreDistortion = true) const{
      //  Distortion is not implemented for orthographic projections!
      BIASASSERT(ignoreDistortion);
      direction = rayDir_;
      origin = Vector3<double>(pos[0], pos[1], 0.0);
    }

    virtual bool Distort(HomgPoint2D& point2d) const;

    virtual bool Undistort(HomgPoint2D& point2d) const;

    virtual void Rescale(double ratio, const double offset = 0.0){
      dX_ /= ratio;
      dY_ /= ratio;
      PPB::Rescale(ratio, offset);
    }

    virtual void Rescale(unsigned int width, unsigned int height){
      dX_ /= (double)width_/(double)width;
      dY_ /= (double)height_/(double)height;
      PPB::Rescale(width, height);
     }

    friend std::ostream&
      operator<<(std::ostream &os, const ProjectionParametersOrthographic& p);

#ifdef BIAS_HAVE_XML2
    /** @brief specialization of XML block name function */
    virtual int XMLGetClassName(std::string &TopLevelTag, double &Version) const;

    /** @brief specialization of XML write function */
    virtual int XMLOut(const xmlNodePtr Node, XMLIO &XMLObject) const;

    /** @brief specialization of XML read function */
    virtual int XMLIn(const xmlNodePtr Node, XMLIO &XMLObject);
#endif

  protected:
    double dX_;
    double dY_;
    Vector3<double> rayDir_;
};

///////// inline code ///////////////////
inline std::ostream& operator<<(std::ostream &os, const ProjectionParametersOrthographic& p){
  os << "ProjectionParametersOrthographic:" << std::endl;
  os << "- principalX_ = " << p.principalX_ << std::endl;
  os << "- principalY_ = " << p.principalY_ << std::endl;
  os << "- dX_ = " << p.dX_ << std::endl;
  os << "- dY_ = " << p.dY_ << std::endl;
  os << "- width_ = " << p.width_ << std::endl;
  os << "- height_ = " << p.height_ << std::endl << std::endl;
  return os;
}
} // end namespace

#include <Base/Common/BIASpragmaEnd.hh>

#endif