GenVisiblePoints.cpp

/* 
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
*/

#include "GenVisiblePoints.hh"
#include <Utils/ThreeDOut.hh>
#include <Geometry/ProjectionParametersPerspective.hh>
#include <Geometry/ProjectionParametersFactory.hh>

using namespace BIAS;
using namespace std;

void GenVisiblePoints::
GeneratePoints(const vector<ProjectionParametersBase*>& pp,
               const int numVisiblePointsPerCamera,
               const int numTries,
               const double minDistance,
               const double maxDistance,
               vector<HomgPoint3D>& points)
{
  _rand.Reset();
  
  // for each camera
  for (unsigned int i = 0; i < pp.size(); i++)
  {
    // count existing points visible by camera
    int numVisiblePoints = 0;
    for (unsigned int j = 0; j < points.size(); j++)
    {
      if (IsPointVisible(*pp[i], points[j]))
        numVisiblePoints++;
    }

    // try to add points not visible by any other camera
    int tries = 0;
    for (int j = 0; j < numTries; j++)
    {
      // enough points visible by this camera?
      if (numVisiblePoints >= numVisiblePointsPerCamera)
        break;

      HomgPoint3D point;
      GenerateVisiblePoint(*pp[i], minDistance, maxDistance, point);

      // check if point is visible by other camera
      bool visibleByOtherCamera = false;
      for (unsigned int k = 0; k < i; k++)
      {
        if (IsPointVisible(*pp[k], point))
        {
          visibleByOtherCamera = true;
          break;
        }
      }

      // add point to list if not visible by other camera
      if (!visibleByOtherCamera)
      {
        points.push_back(point);
        numVisiblePoints++;
      }
      tries++;
    }

    // if not enough points could be generated that are not visible
    // by other cameras, just add any points
    while (numVisiblePoints < numVisiblePointsPerCamera)
    {
      HomgPoint3D point;
      GenerateVisiblePoint(*pp[i], minDistance, maxDistance, point);

      points.push_back(point);
      numVisiblePoints++;
    }
  }
}


void GenVisiblePoints::
GenerateVisiblePoint(const ProjectionParametersBase& projection,
                     double minDistance, double maxDistance,
                     HomgPoint3D& point)
{
  unsigned int width, height;
  projection.GetImageSize(width, height);

  double x = _rand.GetUniformDistributed(0, width - 1);
  double y = _rand.GetUniformDistributed(0, height - 1);
  double d = _rand.GetUniformDistributed(minDistance, maxDistance);

  Vector3<double> dir, pos;
  projection.UnProjectToRay(HomgPoint2D(x, y), pos, dir);
  dir.Normalize();
  point = HomgPoint3D(projection.GetC() + d * dir);
}

bool GenVisiblePoints::
IsPointVisible(const ProjectionParametersBase& pp,
               const HomgPoint3D& point)
{
  HomgPoint3D p3d = point;
  p3d.Homogenize();
  HomgPoint2D p2d;
  return pp.DoesPointProjectIntoImage(p3d, p2d);
}