rnr::WinCvIoI Class Reference

#include <WinCvIoI.h>

Public Member Functions
	WinCvIoI (cv::Size &sizeIoI, cv::Size &sizeTgt, RotOp eOpRot, AlignOp eOpAlign, bool bCropToFit)
	Image of Interest class initialization constructor. More...
virtual	~WinCvIoI ()
	Destructor.
void	setTransformParams (cv::Size &sizeIoI, cv::Rect &rectRoIIoI, cv::Size &sizeTgt, RotOp eOpRot, AlignOp eOpAlign, bool bCropToFit)
	Set Image of Interest transfromation parameters. More...
virtual void	transform (cv::Mat &imgIoI, cv::Mat &imgTgt)
	Transform Image of Interest into the target image. More...
cv::Point	mapPoint (cv::Point &ptDisplay)
	Map display pixel coordinates to Image of Interest pixel coordinates. More...
cv::Size	getOriginalSize ()
cv::Size	getTransformedSize ()
	Get the transformed target size. More...
cv::Size	calcMaxFit43 (cv::Size &sizeSrc, cv::Size &sizeTgt)
	Calculate the maximal size the source can fit into the target size while keeping a 4:3 aspect ratio. More...

Protected Attributes
cv::Size	m_sizeIoI
	image native size
cv::Rect	m_rectRoIIoI
	image of interest region of interest
cv::Size	m_sizeTgt
	target workspace size
cv::Rect	m_rectRoITgt
	target workspace region of interest
RotOp	m_eOpRot
	image rotation operator
cv::Mat	m_matRot
	2x3 transformation matrix
cv::Size	m_sizeRotated
	rotated image size
bool	m_bOpRotate
	do [not] apply rotation operation
bool	m_bOpScale
	do [not] apply resize operation
cv::Size	m_sizeScaled
	scaled image size
bool	m_bOpCrop
	do [not] apply crop operation
cv::Rect	m_rectRoICropped
	cropped region of interest
AlignOp	m_eOpAlign
	image alignment operator

Detailed Description

Window OpenCV Image of Interest (IoI) Class.

An IoI is typically at a higher resolution the what can be showed on a display. Moreover, the display of IoI may require rotation and alignment.

Definition at line 81 of file WinCvIoI.h.

Constructor & Destructor Documentation

WinCvIoI::WinCvIoI	(	cv::Size &	sizeIoI,
		cv::Size &	sizeTgt,
		RotOp	eOpRot,
		AlignOp	eOpAlign,
		bool	bCropToFit
	)

Image of Interest class initialization constructor.

Initialize the transformations needed to place a IoI in the window.

Parameters

sizeIoI	Size of hi-res Image of Interest.
sizeTgt	Size of target workspace, oriented at 0 degrees.
eOpRot	Target image rotation operation. See rnmpwin_rot.
eOpAlign	Target image alignment operation. See rnmpwin_align.
bCropToFit	If true, the transformed image is cropped to fit into target size. Otherwise the transformed image is scaled to fit.

Definition at line 82 of file WinCvIoI.cxx.

{
  Rect rectRoIIoI(0, 0, sizeIoI.width, sizeIoI.height);

  setTransformParams(sizeIoI, rectRoIIoI, sizeTgt,
                     eOpRot, eOpAlign, bCropToFit);
}

Member Function Documentation

Size WinCvIoI::calcMaxFit43	(	cv::Size &	sizeSrc,
		cv::Size &	sizeTgt
	)

Calculate the maximal size the source can fit into the target size while keeping a 4:3 aspect ratio.

Parameters

sizeSrc	Source size.
sizeTgt	Target size.

Returns

Maximum size.

Definition at line 365 of file WinCvIoI.cxx.

References rnr::ar43height(), and rnr::ar43width().

Referenced by getTransformedSize().

{
  Size  sizeScaled = sizeSrc;

  // fit width into target size
  if( sizeSrc.width > sizeTgt.width )
  {
    sizeScaled = ar43width(sizeTgt);
  }

  // fit scaled-by-width height into target size
  if( sizeScaled.height > sizeTgt.height )
  {
    sizeScaled    = ar43height(sizeTgt);
  }

  return sizeScaled;
}

cv::Size rnr::WinCvIoI::getOriginalSize ( )

inline

Get the IoI original size.

Returns

Size.

Definition at line 157 of file WinCvIoI.h.

References m_sizeIoI.

    {
      return cv::Size(m_sizeIoI.width, m_sizeIoI.height);
    }

cv::Size rnr::WinCvIoI::getTransformedSize ( )

inline

Get the transformed target size.

Returns

Size.

Definition at line 167 of file WinCvIoI.h.

References calcMaxFit43(), and m_rectRoITgt.

    {
      return cv::Size(m_rectRoITgt.width, m_rectRoITgt.height);
    }

Point WinCvIoI::mapPoint

(

cv::Point &

ptDisplay

)

Map display pixel coordinates to Image of Interest pixel coordinates.

Parameters

ptDisplay

Point in display coordinates.

Returns

Cooresponding point in target IoI.

Definition at line 302 of file WinCvIoI.cxx.

References rnr::RotOp0, rnr::RotOp180, rnr::RotOp270, and rnr::RotOp90.

Referenced by ~WinCvIoI().

{
  Point   pt;
  int     t;
  double  fScaleX;
  double  fScaleY;

  // adjust of image offset
  pt.x = ptDisplay.x - m_rectRoITgt.x; 
  pt.y = ptDisplay.y - m_rectRoITgt.y; 

  // point not within target image of interest
  if( (pt.x < 0) || (pt.x >= m_rectRoITgt.width) ||
      (pt.y < 0) || (pt.y >= m_rectRoITgt.height) )
  {
    pt.x = pt.y = -1;
    return pt;
  }

  // remap x,y relative to image of interest origin (ulc)
  switch( m_eOpRot )
  {
    case RotOp270:
      t = pt.x;
      pt.x = pt.y + m_rectRoICropped.y;
      pt.y = m_rectRoITgt.width - (t - m_rectRoICropped.x) - 1;
      fScaleX = (double)(m_rectRoIIoI.width) / (double)(m_rectRoITgt.height);
      fScaleY = (double)(m_rectRoIIoI.height) / (double)(m_rectRoITgt.width);
      break;

    case RotOp180:
      pt.x = m_rectRoITgt.width - pt.x - 1;
      pt.y = m_rectRoITgt.height - pt.y - 1;
      fScaleX = (double)(m_rectRoIIoI.width) / (double)(m_rectRoITgt.width);
      fScaleY = (double)(m_rectRoIIoI.height) / (double)(m_rectRoITgt.height);
      break;

    case RotOp90:
      t = pt.x;
      pt.x = m_rectRoITgt.height - pt.y - m_rectRoICropped.y - 1;
      pt.y = t + m_rectRoICropped.x;
      fScaleX = (double)(m_rectRoIIoI.width) / (double)(m_rectRoITgt.height);
      fScaleY = (double)(m_rectRoIIoI.height) / (double)(m_rectRoITgt.width);
      break;

    case RotOp0:
    default:
      fScaleX = (double)(m_rectRoIIoI.width) / (double)(m_rectRoITgt.width);
      fScaleY = (double)(m_rectRoIIoI.height) / (double)(m_rectRoITgt.height);
      break;
  }

  // scale coordinate to match image of interest real size
  pt.x = (int)((double)(pt.x) * fScaleX);
  pt.y = (int)((double)(pt.y) * fScaleY);

  // adjust of target image of interest ROI
  pt.x += m_rectRoIIoI.x;
  pt.y += m_rectRoIIoI.y;

  return pt;
}

void WinCvIoI::setTransformParams	(	cv::Size &	sizeIoI,
		cv::Rect &	rectRoIIoI,
		cv::Size &	sizeTgt,
		RotOp	eOpRot,
		AlignOp	eOpAlign,
		bool	bCropToFit
	)

Set Image of Interest transfromation parameters.

Initialize the transformations needed to place a IoI in the window.

Parameters

sizeIoI	Size of hi-res Image of Interest.
rectRoIIoI	Region of Interest within Image of Interest.
sizeTgt	Size of target workspace, oriented at 0 degrees.
eOpRot	Target image rotation operation. See rnmpwin_rot.
eOpAlign	Target image alignment operation. See rnmpwin_align.
bCropToFit	If true, the transformed image is cropped to fit into target size. Otherwise the transformed image is scaled to fit.

Definition at line 94 of file WinCvIoI.cxx.

References rnr::AlignOpCenter, rnr::AlignOpDefault, rnr::AlignOpLeft, rnr::AlignOpRight, rnr::RotOp0, rnr::RotOp180, rnr::RotOp270, and rnr::RotOp90.

Referenced by ~WinCvIoI().

{
  Point2f   center;           // rotation axis
  Size      sizeScaled;       // size of rotated and resized image
  int       x, y;             // working coordinates
  int       width, height;    // working dimensions

  m_sizeIoI     = sizeIoI;
  m_rectRoIIoI  = rectRoIIoI;
  m_sizeTgt     = sizeTgt;
  m_eOpRot      = eOpRot;
  m_bOpRotate   = false;
  m_eOpAlign    = eOpAlign;
  m_bOpScale    = false;
  m_bOpCrop     = false;

  // rotate about upper left corner (makes translation calculations easier)
  center.x = 0;
  center.y = 0;

  //
  // Rotation and resized images
  //
  switch( eOpRot )
  {
    // 270 degree rotation = -90 degrees
    case RotOp270:
      // set 2x3 rotation matrix
      m_matRot = getRotationMatrix2D(center, -90.0, 1.0);

      // translate
      cvSetReal2D(&m_matRot, 0, 2, sizeIoI.height);
      cvSetReal2D(&m_matRot, 1, 2, 0);

      // rotated IoI
      m_sizeRotated = Size(rectRoIIoI.height, rectRoIIoI.width);
      m_bOpRotate   = true;

      break;

    // 180 degree rotation
    case RotOp180:
      // set 2x3 rotation matrix
      m_matRot = getRotationMatrix2D(center, 180.0, 1.0);

      // translate
      cvSetReal2D(&m_matRot, 0, 2, sizeIoI.width);
      cvSetReal2D(&m_matRot, 1, 2, sizeIoI.height);

      // rotated IoI
      m_sizeRotated = cvSize(rectRoIIoI.width, rectRoIIoI.height);
      m_bOpRotate   = true;

      break;

    // 90 degree rotation
    case RotOp90:
      // set 2x3 rotation matrix
      m_matRot = getRotationMatrix2D(center, 90.0, 1.0);

      // translate
      cvSetReal2D(&m_matRot, 0, 2, 0);
      cvSetReal2D(&m_matRot, 1, 2, sizeIoI.width);

      // rotated IoI
      m_sizeRotated = cvSize(rectRoIIoI.height, rectRoIIoI.width);
      m_bOpRotate   = true;

      break;

    // 0 degree rotation = no rotations
    case RotOp0:
    default:
      // set 2x3 rotation matrix
      m_matRot = getRotationMatrix2D(center, 0.0, 1.0);

      // rotated IoI
      m_sizeRotated = cvSize(rectRoIIoI.width, rectRoIIoI.height);
      m_bOpRotate   = false;

      break;
  }

  //
  // Crop image to fit
  //
  if( bCropToFit )
  {
    // initialize
    x         = 0;
    y         = 0;
    width     = m_sizeRotated.width;
    height    = m_sizeRotated.height;
    m_bOpCrop = false;

    if( m_sizeRotated.width > sizeTgt.width )
    {
      x         = (m_sizeRotated.width - sizeTgt.width) / 2;
      width     = sizeTgt.width;
      m_bOpCrop = true;
    }
    if( m_sizeRotated.height > sizeTgt.height )
    {
      y         = (m_sizeRotated.height - sizeTgt.height) / 2;
      height    = sizeTgt.height;
      m_bOpCrop = true;
    }

    if( m_bOpCrop )
    {
      m_rectRoICropped = Rect(x, y, width, height);
    }
  }

  //
  // Scale image to fit
  // 
  else
  {
    // initialize
    m_bOpScale = false;

    // best fit in a 4:3 aspect ratio 
    // RDK TODO allow for other aspect ratios
    sizeScaled = calcMaxFit43(m_sizeRotated, sizeTgt);

    if( (sizeScaled.width  < m_sizeRotated.width) || 
        (sizeScaled.height < m_sizeRotated.height) )
    {
      m_sizeScaled  = sizeScaled;
      m_bOpScale    = true;
    }

    width   = sizeScaled.width;
    height  = sizeScaled.height;
  }

  //
  // Alignment ROI
  //
  switch( eOpAlign )
  {
    // align center
    case AlignOpCenter:
      x = (sizeTgt.width - width) / 2;
      y = (sizeTgt.height - height) / 2;
      m_rectRoITgt = cvRect(x, y, width, height);
      break;

    // align right
    case AlignOpRight:
      x = (sizeTgt.width - width) / 2;
      y = sizeTgt.height - 1;
      m_rectRoITgt = cvRect(x, y, width, height);
      break;

    // align left
    case AlignOpLeft:
    case AlignOpDefault:
    default:
      x = 0;
      y = (sizeTgt.height - height) / 2;
      m_rectRoITgt = cvRect(x, y, width, height);
      break;
  }
}

void WinCvIoI::transform ( cv::Mat &  imgIoI, cv::Mat &  imgTgt  )

virtual

Transform Image of Interest into the target image.

Parameters

	imgIoI	Image of Interest.
[in,out]

Definition at line 266 of file WinCvIoI.cxx.

Referenced by ~WinCvIoI().

{
  Mat     img;
  Size    dsize;

  img = Mat(imgIoI, m_rectRoIIoI);

  //
  // Rotate IoI
  //
  if( m_bOpRotate )
  {
    warpAffine(img, imgTgt, m_matRot, m_sizeRotated, INTER_LINEAR);
  }
  else
  {
    imgTgt = img;
  }

  //
  // Scale IoI
  //
  if( m_bOpScale )
  {
    resize(imgTgt, imgTgt, m_sizeScaled, 0.0, 0.0, INTER_LINEAR);
  }

  //
  // Crop IoI
  //
  if( m_bOpCrop )
  {
    imgTgt = Mat(imgTgt, m_rectRoICropped);
  }
}

---

The documentation for this class was generated from the following files:

• include/rnr/appkit/WinCvIoI.h
• sw/librnr_win/WinCvIoI.cxx