/* $NoKeywords: $ */
/*
//
// Copyright (c) 1993-2013 Robert McNeel & Associates. All rights reserved.
// OpenNURBS, Rhinoceros, and Rhino3D are registered trademarks of Robert
// McNeel & Associates.
//
// THIS SOFTWARE IS PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED WARRANTY.
// ALL IMPLIED WARRANTIES OF FITNESS FOR ANY PARTICULAR PURPOSE AND OF
// MERCHANTABILITY ARE HEREBY DISCLAIMED.
//				
// For complete openNURBS copyright information see <http://www.opennurbs.org>.
//
////////////////////////////////////////////////////////////////
*/

#include "opennurbs.h"

#if !defined(ON_COMPILING_OPENNURBS)
// This check is included in all opennurbs source .c and .cpp files to insure
// ON_COMPILING_OPENNURBS is defined when opennurbs source is compiled.
// When opennurbs source is being compiled, ON_COMPILING_OPENNURBS is defined 
// and the opennurbs .h files alter what is declared and how it is declared.
#error ON_COMPILING_OPENNURBS must be defined when compiling opennurbs
#endif

ON_AerialPhotoImage::ON_AerialPhotoImage()
: m_id(ON_nil_uuid)
, m_image_width_pixels(0)
, m_image_height_pixels(0)
{
}

void ON_AerialPhotoImage::Unset()
{
  m_name.Destroy();
  m_id = ON_nil_uuid;
  m_camera_position.Unset();
  m_image_frustum.Unset();
  m_image_file_name.Destroy();
  m_image_width_pixels = 0;
  m_image_height_pixels = 0;
}

void ON_AerialPhotoImage::SetName(
  const wchar_t* name
  )
{
  m_name = name;
}

void ON_AerialPhotoImage::GetName(
  ON_wString& name
  ) const
{
  name = m_name.Array();
}

void ON_AerialPhotoImage::SetId( ON_UUID id )
{
  m_id = id;
}

ON_UUID ON_AerialPhotoImage::Id() const
{
  return m_id;
}


bool ON_AerialPhotoImage::CameraPositionIsSet() const
{
  return m_camera_position.IsSet();
}

bool ON_AerialPhotoImage::CameraLocationIsSet() const
{
  return m_camera_position.LocationIsSet();
}

bool ON_AerialPhotoImage::CameraOrientationIsSet() const
{
  return m_camera_position.OrientationIsSet();
}


void ON_AerialPhotoImage::SetCameraPosition(
  ON_AerialPhotoCameraPosition camera_position
  )
{
  m_camera_position = camera_position;
}

void ON_AerialPhotoImage::GetCameraPosition(
  ON_AerialPhotoCameraPosition& camera_position
  ) const
{
  camera_position = m_camera_position;
}

void ON_AerialPhotoImage::UnsetCameraPosition()
{
  m_camera_position.Unset();
}
  
/////////////////////////////////////////////////////////
//
// Image frustum interface
//
bool ON_AerialPhotoImage::ImageFrustumIsSet() const
{
  return m_image_frustum.IsSet();
}

void ON_AerialPhotoImage::SetImageFrustum(
  ON_AerialPhotoImageFrustum image_frustum
  )
{
  m_image_frustum = image_frustum;
}

void ON_AerialPhotoImage::GetImageFrustum(
  ON_AerialPhotoImageFrustum& image_frustum
  ) const
{
  image_frustum = m_image_frustum;
}

void ON_AerialPhotoImage::UnsetImageFrustum()
{
  m_image_frustum.Unset();
}

bool ON_AerialPhotoImage::ImageFileNameIsSet() const
{
  return (m_image_file_name.Length() > 0);
}


bool ON_AerialPhotoImage::ImageSizeIsSet() const
{
  return (m_image_width_pixels > 0 && m_image_height_pixels > 0);
}

bool ON_AerialPhotoImage::SetImageSize(
  int image_width_pixels,
  int image_height_pixels
  )
{
  bool rc = false;
  if ( image_width_pixels > 0 && image_height_pixels > 0 )
  {
    m_image_width_pixels = image_width_pixels;
    m_image_height_pixels = image_height_pixels;
    rc = true;
  }
  else
    UnsetImageSize();

  return rc;
}


bool ON_AerialPhotoImage::GetImageSize(
  int* width_pixels,
  int* height_pixels
  ) const
{
  if ( 0 != width_pixels )
    *width_pixels = m_image_width_pixels;
  if ( 0 != height_pixels )
    *height_pixels = m_image_height_pixels;
  
  return ImageSizeIsSet();
}

void ON_AerialPhotoImage::UnsetImageSize()
{
  m_image_width_pixels = 0;
  m_image_height_pixels = 0;
}

void ON_AerialPhotoImage::SetImageFileName(
  const wchar_t* image_file_name
  )
{
  m_image_file_name = image_file_name;
}

void ON_AerialPhotoImage::GetImageFileName(
  ON_wString& image_file_name
  ) const
{
  // copy array
  const wchar_t* s = static_cast< const wchar_t* >(m_image_file_name);
  image_file_name = s;
}

void ON_AerialPhotoImage::UnsetImageFileName()
{
  m_image_file_name.Destroy();
}


ON_AerialPhotoImageFrustum::ON_AerialPhotoImageFrustum()
{
  Unset();
}

bool ON_AerialPhotoImageFrustum::IsSet() const
{
  return HeightIsSet() && CornersAreSet() && UnitSystemIsSet();
}

void ON_AerialPhotoImageFrustum::Unset()
{
  m_height = ON_UNSET_VALUE;
  m_corners[0] = ON_2dPoint::UnsetPoint;
  m_corners[1] = ON_2dPoint::UnsetPoint;
  m_corners[2] = ON_2dPoint::UnsetPoint;
  m_corners[3] = ON_2dPoint::UnsetPoint;
  m_unit_system = ON_UnitSystem::None;
}

bool ON_AerialPhotoImageFrustum::HeightIsSet() const
{
  return (m_height > 0.0 && ON_IsValid(m_height));
}

bool ON_AerialPhotoImageFrustum::CornersAreSet() const
{
  for(;;)
  {
    if ( !m_corners[0].IsValid() )
      break;
    if ( !m_corners[1].IsValid() )
      break;
    if ( !m_corners[2].IsValid() )
      break;
    if ( !m_corners[3].IsValid() )
      break;

    // corners must form a non-empty convex 2d region and
    // be in counter-clockwise order.  They can be a 
    // the corners of a 3 or 4 sided region.
    double max_z = 0.0;
    double z;
    ON_2dVector A, B;
    for ( int i = 0; i < 4; i++ )
    {
      A = m_corners[(i+3)%4] - m_corners[i];
      B = m_corners[(i+1)%4] - m_corners[i];
      z = B.x*A.y - A.x*B.y;
      if (z >= 0.0 && ON_IsValid(z))
      {
        if ( z > max_z )
          max_z = z;
        continue;
      }
      return false;
    }

    if ( max_z > 0.0 )
      return true;

    break;
  }

  return false;
}

bool ON_AerialPhotoImageFrustum::UnitSystemIsSet() const
{
  return (m_unit_system.IsSet());
}


ON_AerialPhotoCameraPosition::ON_AerialPhotoCameraPosition()
: m_status(0)
{
  Unset();
}

void ON_AerialPhotoCameraPosition::Unset()
{
  UnsetUnitSystem();
  UnsetLocation();
  UnsetOrientation();
}

bool ON_AerialPhotoCameraPosition::IsSet() const
{
  return UnitSystemIsSet() && LocationIsSet() && OrientationIsSet();
}


bool ON_AerialPhotoCameraPosition::UnitSystemIsSet() const
{
  return m_unit_system.IsSet();
}

bool ON_AerialPhotoCameraPosition::SetUnitSystem( ON::LengthUnitSystem unit_system )
{
  if (    ON::LengthUnitSystem::None != unit_system
       && ON::LengthUnitSystem::CustomUnits != unit_system
       && unit_system == ON::LengthUnitSystemFromUnsigned(static_cast<unsigned int>(unit_system))
     )
  {
    m_unit_system = ON_UnitSystem(unit_system);
  }
  else
    Unset();

  return UnitSystemIsSet();
}

bool ON_AerialPhotoCameraPosition::SetUnitSystem ( ON_UnitSystem unit_system )
{
  if ( unit_system.IsSet() )
    m_unit_system = unit_system;
  else
    Unset();

  return UnitSystemIsSet();
}

ON_UnitSystem ON_AerialPhotoCameraPosition::UnitSystem() const
{
  return m_unit_system;
}

bool ON_AerialPhotoCameraPosition::GetUnitSystem( ON_UnitSystem& unit_system ) const
{
  unit_system = m_unit_system;
  return UnitSystemIsSet();
}

void ON_AerialPhotoCameraPosition::UnsetUnitSystem()
{
  m_unit_system = ON_UnitSystem(ON::LengthUnitSystem::None);
}

bool ON_AerialPhotoCameraPosition::LocationIsSet() const
{
  return m_location.IsValid();
}

bool ON_AerialPhotoCameraPosition::SetLocation( 
  ON_3dPoint camera_location 
  )
{
  const bool rc = camera_location.IsValid();
  
  if (rc)
    m_location = camera_location;
  else
    UnsetLocation();

  return rc;
}

bool ON_AerialPhotoCameraPosition::GetLocation(
  ON_3dPoint& camera_location
  ) const
{
  camera_location = Location();
  return LocationIsSet();
}

ON_3dPoint ON_AerialPhotoCameraPosition::Location() const
{
  return m_location;
}

void ON_AerialPhotoCameraPosition::UnsetLocation()
{
  m_status &= 0xFE; // clear bit 1
  m_location = ON_3dPoint::UnsetPoint;
}

bool ON_AerialPhotoCameraPosition::OrientationIsSet() const
{
  return ( 0 != (m_status & 2) 
           && m_orientation_angles_radians.IsValid() 
           && m_orientation_angles_degrees.IsValid()
           && m_orientation_right.IsValid()
           && m_orientation_up.IsValid()
           && m_orientation_direction.IsValid()
           && m_orientation_rotation.IsValid()
         );
}

void ON_AerialPhotoCameraPosition::UnsetOrientation()
{
  m_status &= 0xFD; // clear bit 2

  m_orientation_angles_radians.Set(ON_UNSET_VALUE,ON_UNSET_VALUE,ON_UNSET_VALUE);
  m_orientation_angles_degrees.Set(ON_UNSET_VALUE,ON_UNSET_VALUE,ON_UNSET_VALUE);

  m_orientation_rotation = ON_Xform::Zero4x4;

  m_orientation_right = ON_3dVector::ZeroVector;
  m_orientation_up = ON_3dVector::ZeroVector;
  m_orientation_direction = ON_3dVector::ZeroVector;
}

bool ON_AerialPhotoCameraPosition::GetOrientationRotation(
  ON_Xform& camera_rotaion 
  ) const
{
  camera_rotaion = m_orientation_rotation;
  return (0 != (m_status & 2));
}

/*
Description:
  Get a right handed ortho normal camera frame.
Parameters:
  camera_X - [out]
    world coordinate unit vector pointing to the right in the camera image
    = OrientationRotation * (1,0,0)
  camera_Y - [out]
    world coordinate unit vector in the camera up direction.
    = OrientationRotation * (0,1,0)
  camera_Z - [out]
    world coordinate unit vector pointing into the cameara (from the
    image toward the camera).
    = OrientationRotation * (0,0,1)
*/
bool ON_AerialPhotoCameraPosition::GetOrientationFrame(
  ON_3dVector& camera_X,
  ON_3dVector& camera_Y,
  ON_3dVector& camera_Z
  ) const
{
  camera_X.x = m_orientation_rotation.m_xform[0][0];
  camera_X.y = m_orientation_rotation.m_xform[1][0];
  camera_X.z = m_orientation_rotation.m_xform[2][0];

  camera_Y.x = m_orientation_rotation.m_xform[0][1];
  camera_Y.y = m_orientation_rotation.m_xform[1][1];
  camera_Y.z = m_orientation_rotation.m_xform[2][1];

  camera_Z.x = m_orientation_rotation.m_xform[0][2];
  camera_Z.y = m_orientation_rotation.m_xform[1][2];
  camera_Z.z = m_orientation_rotation.m_xform[2][2];

  return (0 != (m_status & 2));
}


ON_Xform ON_AerialPhotoCameraPosition::OrientationRotation() const
{
  return m_orientation_rotation;
}


bool ON_AerialPhotoCameraPosition::SetOrientationVectors(
    ON_3dVector camera_up,
    ON_3dVector camera_right,
    ON_3dVector camera_direction
    )
{
  ON_3dVector X(camera_right);
  ON_3dVector Y(camera_up);
  ON_3dVector Z(-camera_direction);

  bool bHaveX = ( X.IsValid() && X.Unitize() );
  bool bHaveY = ( Y.IsValid() && Y.Unitize() );
  bool bHaveZ = ( Z.IsValid() && Z.Unitize() );
  
  if ( !bHaveX && bHaveY && bHaveZ )
  {
    X = ON_CrossProduct(Y,Z);
    bHaveX = X.Unitize();
    if ( bHaveX )
      camera_right = X;
  }
  else if ( !bHaveY && bHaveZ && bHaveX )
  {
    Y = ON_CrossProduct(Z,X);
    bHaveY = Y.Unitize();
    if ( bHaveY )
      camera_up = Y;
  }
  else if ( !bHaveZ && bHaveX && bHaveY )
  {
    Z = ON_CrossProduct(X,Y);
    bHaveZ = Z.Unitize();
    if ( bHaveZ )
      camera_direction = -Z;
  }

  bool rc = false;
  for (;;)
  {
    if ( !bHaveX || !bHaveY || !bHaveZ )
      break;

    double max_dot = 0.0;
    double d = fabs(X*Y);
    if ( d > max_dot )
      max_dot = d;
    d = fabs(Y*Z);
    if ( d > max_dot )
      max_dot = d;
    d = fabs(Z*X);
    if ( d > max_dot )
      max_dot = d;

    if ( max_dot > 1.0e-8 )
      break;

    d = Z*ON_CrossProduct(X,Y);
    if ( !(d > 0.0) )
      break;

    ON_Xform R;
    R.m_xform[0][0] = X.x; R.m_xform[0][1] = Y.x; R.m_xform[0][2] = Z.x; R.m_xform[0][3] = 0.0;
    R.m_xform[1][0] = X.y; R.m_xform[1][1] = Y.y; R.m_xform[1][2] = Z.y; R.m_xform[1][3] = 0.0;
    R.m_xform[2][0] = X.z; R.m_xform[2][1] = Y.z; R.m_xform[2][2] = Z.z; R.m_xform[2][3] = 0.0;
    R.m_xform[3][0] = 0.0; R.m_xform[3][1] = 0.0; R.m_xform[3][2] = 0.0; R.m_xform[3][3] = 1.0;

    rc = SetOrientationRotation(R);

    if (rc)
    {
      // preserve exact values of input parameters
      m_orientation_right = camera_right;
      m_orientation_up = camera_up;
      m_orientation_direction = camera_direction;
    }

    break;
  }

  if (!rc)
  {
    UnsetOrientation();
  }

  return rc;
}

bool ON_AerialPhotoCameraPosition::SetOrientationRotation(
    ON_Xform camera_rotation
    )
{
  m_orientation_rotation = camera_rotation;

  const ON_3dVector X(camera_rotation.m_xform[0][0],camera_rotation.m_xform[1][0],camera_rotation.m_xform[2][0]);
  const ON_3dVector Y(camera_rotation.m_xform[0][1],camera_rotation.m_xform[1][1],camera_rotation.m_xform[2][1]);
  const ON_3dVector Z(camera_rotation.m_xform[0][2],camera_rotation.m_xform[1][2],camera_rotation.m_xform[2][2]);

  m_orientation_right = X;
  m_orientation_up = Y;
  m_orientation_direction = -Z;

  double s1, c1, s2, c2, s3, c3;

  s2 = Z.x;
  double a = 1.0 - s2*s2;
  c2 = (a > 0.0) ? sqrt(a) : 0.0;
  if ( fabs(c2) <= ON_EPSILON || fabs(s2) >= 1.0-ON_EPSILON )
  {
    s2 = (s2 < 0.0) ? -1.0 : 1.0;
    c2 = 0.0;
  }
  else if ( fabs(s2) <= ON_EPSILON || fabs(c2) >= 1.0-ON_EPSILON )
  {
    c2 = (c2 < 0.0) ? -1.0 : 1.0;
    s2 = 0.0;
  }

  if ( c2 > 0.0 )
  {
    s1 = -Z.y/c2;
    c1 =  Z.z/c2;
    s3 = -Y.x/c2;
    c3 =  X.x/c2;
  }
  else
  {
    s1 = 0.0;
    c1 = 1.0;
    s3 = ( X.y ==  Y.z ) ? X.y : 0.5*(X.y + Y.z);
    c3 = ( Y.y == -X.z ) ? Y.y : 0.5*(Y.y - X.z);
  }

  m_orientation_angles_radians.x = atan2(s1,c1);
  m_orientation_angles_radians.y = atan2(s2,c2);
  m_orientation_angles_radians.z = atan2(s2,c3);

  m_orientation_angles_degrees.x = m_orientation_angles_radians.x*180.0/ON_PI;
  m_orientation_angles_degrees.y = m_orientation_angles_radians.y*180.0/ON_PI;
  m_orientation_angles_degrees.z = m_orientation_angles_radians.z*180.0/ON_PI;

  m_status |= 2;

  return true;
}

bool ON_AerialPhotoCameraPosition::SetOrientationAnglesDegrees(
    double omega_degrees, 
    double phi_degrees, 
    double kappa_degrees
    )
{
  bool rc = false;
  if ( ON_IsValid(omega_degrees) && ON_IsValid(phi_degrees) && ON_IsValid(kappa_degrees) )
  {
    rc = SetOrientationAnglesRadians(omega_degrees*ON_PI/180.0,phi_degrees*ON_PI/180.0,kappa_degrees*ON_PI/180.0);
    // Directly set m_camera_angles_degrees after SetCameraAnglesRadians()
    // so we don't loose a few bits of precision lost by converting to radians
    // and then converting back to degrees.
    m_orientation_angles_degrees.Set(omega_degrees,phi_degrees,kappa_degrees);
  }
  else
  {
    UnsetOrientation();
  }
  return rc;
}

bool ON_AerialPhotoCameraPosition::SetOrientationAnglesRadians(
    double omega_radians, 
    double phi_radians, 
    double kappa_radians
    )
{
  bool rc = false;

  if ( ON_IsValid(omega_radians) && ON_IsValid(phi_radians) && ON_IsValid(kappa_radians) )
  {
    m_orientation_angles_radians.Set(omega_radians,phi_radians,kappa_radians);
    m_orientation_angles_degrees.Set(omega_radians*180.0/ON_PI,phi_radians*180.0/ON_PI,kappa_radians*180.0/ON_PI);

    const double c1 = cos(omega_radians);
    const double s1 = sin(omega_radians);
  
    const double c2 = cos(phi_radians);
    const double s2 = sin(phi_radians);
  
    const double c3 = cos(kappa_radians);
    const double s3 = sin(kappa_radians);

    const ON_3dVector X( c3*c2,  s3*c1 + c3*s2*s1,  s3*s1 - c3*s2*c1);
    const ON_3dVector Y(-s3*c2,  c3*c1 - s3*s2*s1,  c3*s1 + s3*s2*c1);
    const ON_3dVector Z(    s2,            -c2*s1,             c2*c1);

    ON_Xform R;
    R.m_xform[0][0] = X.x; R.m_xform[0][1] = Y.x; R.m_xform[0][2] = Z.x; R.m_xform[0][3] = 0.0;
    R.m_xform[1][0] = X.y; R.m_xform[1][1] = Y.y; R.m_xform[1][2] = Z.y; R.m_xform[1][3] = 0.0;
    R.m_xform[2][0] = X.z; R.m_xform[2][1] = Y.z; R.m_xform[2][2] = Z.z; R.m_xform[2][3] = 0.0;
    R.m_xform[3][0] = 0.0; R.m_xform[3][1] = 0.0; R.m_xform[3][2] = 0.0; R.m_xform[3][3] = 1.0;

    m_orientation_rotation = R;

    m_orientation_right = X;
    m_orientation_up = Y;
    m_orientation_direction = -Z;

    m_status |= 2;

    rc = true;

    {
      // Debugging validation tests

      const ON_3dVector x0(1.0,0.0,0.0);
      const ON_3dVector y0(0.0,1.0,0.0);
      const ON_3dVector z0(0.0,0.0,1.0);

      const ON_3dVector x1 = x0;
      const ON_3dVector y1 =  c1*y0 + s1*z0;
      const ON_3dVector z1 = -s1*y0 + c1*z0;

      const ON_3dVector y2 = y1;
      const ON_3dVector z2 = s2*x1 + c2*z1;
      const ON_3dVector x2 = c2*x1 - s2*z1;

      const ON_3dVector z3 =  z2;
      const ON_3dVector x3 =  c3*x2 + s3*y2;
      const ON_3dVector y3 = -s3*x2 + c3*y2;

      /*
      const ON_3dVector x1 = x0;
      const ON_3dVector y1 = (0.0,  c1,  s1);
      const ON_3dVector z1 = (0.0, -s1,  c1);

      const ON_3dVector x2 = (c2,  s2*s1, -s2*c1); // c2*x1 - s2*z1;
      const ON_3dVector y2 = (0.0,    c1,     s1);
      const ON_3dVector z2 = (s2, -c2*s1,  c2*c1); // s2*x1 + c2*z1
      */


      ON_Xform r1;
      r1.Rotation(omega_radians,x0,ON_3dPoint::Origin);
      ON_3dVector r1y0 = r1*y0;

      ON_Xform r2;
      r2.Rotation(phi_radians,r1y0,ON_3dPoint::Origin);
      ON_3dVector r2r1z0 = r2*r1*z0;

      ON_Xform r3;
      r3.Rotation(kappa_radians,r2r1z0,ON_3dPoint::Origin);

      ON_Xform r321 = r3*r2*r1;


      ON_Xform zero = r321 - R;

      double a, b;
      double max_zero = 0.0;
      for ( int i = 0; i < 4; i++ ) for ( int j = 0; j < 4; j++ )
      {
        a = fabs(zero[i][j]);
        if (a > max_zero )
          max_zero = a;
      }
      b = fabs((x3-X).MaximumCoordinate());
      if ( b > max_zero )
        max_zero = b;
      b = fabs((y3-Y).MaximumCoordinate());
      if ( b > max_zero )
        max_zero = b;
      b = fabs((z3-Z).MaximumCoordinate());
      if ( b > max_zero )
        max_zero = b;


      if ( max_zero > 1.0e-15 )
        ON_ERROR("Transform trauma");
    }
  }
  else
  {
    UnsetOrientation();
  }

  return rc;
}

bool ON_AerialPhotoImage::GetViewProjection( 
  ON_BoundingBox target_bbox,
  ON_Viewport& viewport
  ) const
{
  viewport = ON_Viewport::DefaultTopViewYUp;

  if ( !this->ImageSizeIsSet() )
    return false;

  const int image_width_pixels   = m_image_width_pixels;
  const int image_height_pixels = m_image_height_pixels;

  const ON_AerialPhotoImageFrustum& pg_if( m_image_frustum );
  if ( !pg_if.IsSet() )
    return false;

  const ON_AerialPhotoCameraPosition& pg_cp( m_camera_position );
  if ( !pg_cp.LocationIsSet() )
    return false;
  if ( !pg_cp.OrientationIsSet() )
    return false;

  ON_3dPoint camera_location;
  if ( !pg_cp.GetLocation(camera_location) || !camera_location.IsValid() )
    return false;

  ON_Xform camera_rotation;
  if (    !pg_cp.GetOrientationRotation(camera_rotation) 
       || !camera_rotation.IsValid() 
     )
    return false;

  ON_Plane camera_plane;
  if (!pg_cp.GetOrientationFrame(camera_plane.xaxis,camera_plane.yaxis,camera_plane.zaxis))
    return false;
  camera_plane.origin = camera_location;
  camera_plane.UpdateEquation();

  const double frustum_to_position_unit_scale = ON::UnitScale( pg_if.m_unit_system, pg_cp.UnitSystem() );
  if (    !ON_IsValid(frustum_to_position_unit_scale) 
       || !(frustum_to_position_unit_scale > 0.0) 
     )
    return false;

  // The values of frus_near and frus_far are adjusted later
  // so the view's frustum contains the region in target_bbox.

  double frus_near = pg_if.m_height*frustum_to_position_unit_scale;
  if ( !ON_IsValid(frus_near) || !(frus_near > 0.0) )
    return false;

  double frus_far = 128.0*frus_near; 

  double frus_left, frus_right;
  double frus_bottom, frus_top;
  frus_left = frus_right = pg_if.m_corners[0].x;
  frus_bottom = frus_top = pg_if.m_corners[0].y;
  for ( size_t i = 1; i < sizeof(pg_if.m_corners)/sizeof(pg_if.m_corners[0]); i++ )
  {
    if ( pg_if.m_corners[i].x < frus_left )
      frus_left = pg_if.m_corners[i].x;
    else if ( pg_if.m_corners[i].x > frus_right )
      frus_right = pg_if.m_corners[i].x;
    if ( pg_if.m_corners[i].y < frus_bottom )
      frus_bottom = pg_if.m_corners[i].y;
    else if ( pg_if.m_corners[i].y > frus_top )
      frus_top = pg_if.m_corners[i].y;
  }
  frus_left   *= frustum_to_position_unit_scale;
  frus_right  *= frustum_to_position_unit_scale;
  frus_bottom *= frustum_to_position_unit_scale;
  frus_top    *= frustum_to_position_unit_scale;
  
  bool rc = false;

  ON_Viewport vp;
  for(;;)
  {
    if ( !vp.SetProjection( ON::perspective_view ) )
      break;
  
    if ( !vp.SetCameraLocation( pg_cp.Location() ) )
      break;
  
    if ( !vp.SetCameraDirection( -camera_plane.zaxis ) )
      break;
  
    if ( !vp.SetCameraUp( camera_plane.yaxis ) )
      break;

    if ( !vp.SetFrustum(frus_left,frus_right,frus_bottom,frus_top,frus_near,frus_far) )
      break;
    
    if ( !vp.SetScreenPort(0,image_width_pixels,0,image_height_pixels) )
      break;

    double bbox_near = ON_UNSET_VALUE;
    double bbox_far  = ON_UNSET_VALUE;
    if ( vp.GetBoundingBoxDepth(target_bbox,&bbox_near,&bbox_far,false) )
    {
      if ( frus_near > 0.0 && ON_IsValid(bbox_near) && frus_near < bbox_near )
      {
        double s = 1.0;
        while ( 2.0*s*frus_near <= bbox_near )
          s *= 2.0;

        if ( s >= 2.0 )
        {
          frus_near   *= s;
          frus_left   *= s;
          frus_right  *= s;
          frus_bottom *= s;
          frus_top    *= s;
          frus_far = 1.0625*frus_near;
        }
      }
            
      if ( ON_IsValid(bbox_far) && frus_far < bbox_far )
      {
        frus_far = 1.0625*bbox_far;
        const double max_frus_far = 67108864.0*frus_near; // 2^26 * frus_near
        if ( !(frus_far <= max_frus_far) )
          frus_far = max_frus_far;
      }

      if ( !vp.SetFrustum(frus_left,frus_right,frus_bottom,frus_top,frus_near,frus_far) )
        break;
    }

    rc = vp.IsValid() ? true : false;
    if ( rc )
      viewport = vp;

    break;
  }

  return rc;
}