imageview.cpp

BCAM 1394 Driver

    nHandle == CRectTracker::hitTop ||
    nHandle == CRectTracker::hitTopRight )
  {
    int height = m_SizeInc.cy * ( rc.Height() / m_SizeInc.cy );

    rc.top = rc.bottom - height;
    if ( rc.top < 0 )
    {
      rc.top = 0;
      rc.bottom = m_SizeInc.cy * ( rc.bottom / m_SizeInc.cy );
    }
  }
  
  if ( nHandle == CRectTracker::hitBottomLeft ||
    nHandle == CRectTracker::hitBottom ||
    nHandle == CRectTracker::hitBottomRight )
  {
    int height = m_SizeInc.cy * ( rc.Height() / m_SizeInc.cy );

    rc.bottom = rc.top + height;
    if ( rc.bottom > rcLimits.bottom )
    {
      rc.bottom = rcLimits.bottom;
      rc.top = max(0, rc.bottom - m_SizeInc.cy * ( rc.Height() / m_SizeInc.cy ));
    }
  }

  if ( nHandle == CRectTracker::hitMiddle)
  { 
    int width = rc.Width();
    int height = rc.Height();

    rc.left = max(0, ( rc.left / m_PosInc.cx ) * m_PosInc.cx);
    rc.top = max(0, ( rc.top / m_PosInc.cy ) * m_PosInc.cy );
    rc.right = rc.left + ( width / m_SizeInc.cx ) * m_SizeInc.cx;
    rc.bottom = rc.top + ( height / m_SizeInc.cy ) * m_SizeInc.cy;
    if ( rc.right > rcLimits.right )
    {
      rc.right = rcLimits.right;
      rc.left = max(0, rc.right - ( width / m_SizeInc.cx ) * m_SizeInc.cx );
    }
    if ( rc.bottom > rcLimits.bottom )
    {
      rc.bottom = rcLimits.bottom;
      rc.top = max(0, rc.bottom - ( height / m_SizeInc.cy ) * m_SizeInc.cy );
    }
  }  

#ifdef DEBUG
    assert ( rc.left % m_PosInc.cx == 0 );
    assert ( rc.top % m_PosInc.cy == 0 );
    assert ( rc.Width() % m_SizeInc.cx == 0 );
    assert ( rc.Height() % m_SizeInc.cy == 0 );
    assert ( rc.right <= rcLimits.right );
    assert ( rc.left <= rcLimits.right );
    assert ( rc.Width() % 4 == 0 );
#endif

  // copy result back
  *lpRect = rc;
  
}

void CImageView::AdjustPoint(LPPOINT lpPoint)
{
  lpPoint->x = m_PosInc.cx * ( lpPoint->x / m_PosInc.cx);
  lpPoint->y = m_PosInc.cy * ( lpPoint->y / m_PosInc.cy);
}


LRESULT CImageView::OnLButtonDown(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM lParam, BOOL& bHandled)
{

  SetFocus();
  if ( m_bScalable )
  {
    assert( ! m_RectTracker.IsTracking() );

    CPoint Point = CPoint(GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam));
    
    CPoint tmp = Point;
    DPtoLP(&tmp);
    
    if (HitTestTrackerBorder())
    {
      m_RectTracker.Track(*this, Point, FALSE);
    }
    else
    {
      if ( m_SensorRect.PtInRect(tmp) )
      {
        m_RectTracker.TrackRubberBand(*this, Point, FALSE);
      }
    }

    if ( m_RectTracker.IsTracking() )
      StartTimer();
  }

  return 0;
}

void CImageView::SetNewAOI()
{

  try
  {
    m_pCamera->SetAOI(m_RectTracker.m_rect);
  }
  CATCH_REPORT();

}
  
  LRESULT CImageView::OnSetCursor(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM lParam, BOOL& bHandled)
  {

  bHandled = FALSE;

  if ( LOWORD(lParam) == HTCLIENT )
  {
    assert ( m_pCamera != NULL );

    ShowAOISize();

    if ( ! ShowCursorPos() )
    {
      m_MainFrame.m_Sbar.SetPaneText(ID_POS_PANE, "");
    }

    if (HitTestTrackerBorder() && m_RectTracker.SetCursor(m_hWnd, LOWORD(lParam)) )
    {
      // Handled.
      bHandled = TRUE;
    }

    // Set crosshair cursor and show pixel value
    CBcamBitmap* pBitmap = m_pCamera->GetBitmap();
    if ( pBitmap != 0 )
    {
      CPoint pt;
      GetLogicalCursorPos(pt);
      if ( pBitmap->GetRect().PtInRect(pt) )
      {
        if ( ! bHandled ) 
        {
          SetCursor(m_hCursor);
          bHandled = TRUE;
        }
      }
      if ( ! ShowPixelValue(pBitmap) )
      {
        m_MainFrame.m_Sbar.SetPaneText(ID_VALUE_PANE, "");
      }
    } 
  } 
  return 0;
}

bool CImageView::ShowCursorPos()
{
  CPoint pt;
  GetLogicalCursorPos(pt);

  if ( m_SensorRect.PtInRect(pt)  )
  {
    CString str;
    str.Format(" ( %d, %3d )", pt.x, pt.y);
    m_MainFrame.m_Sbar.SetPaneText(ID_POS_PANE, str);
    return true;
  }
  return false;
}

// Show pixel value under the cursor.
bool CImageView::ShowPixelValue(CBcamBitmap* pBitmap)
{
  if ( pBitmap == NULL )
    pBitmap = m_pCamera->GetBitmap();

  if ( pBitmap != NULL )
  {
    CPoint pt;
    GetLogicalCursorPos(pt);
    if ( m_RectTracker.GetTrackerHandle() == CRectTracker::hitNothing && pBitmap->GetRect().PtInRect(pt) )
    {
      CPoint origin = pBitmap->GetOrigin();
      CString str;
      RGBTRIPLE rgb = (*pBitmap)(pt.x - origin.x, pt.y - origin.y);
      str.Format("R: %-3u G: %-3u B: %-3u", (long) rgb.rgbtRed, (long) rgb.rgbtGreen, (long) rgb.rgbtBlue );
      m_MainFrame.m_Sbar.SetPaneText(ID_VALUE_PANE, str);
      return true;
    }
  }
  return false;
}

void CImageView::ShowAOISize()
{
  if ( ! m_bActiveChild )
    return;

  CSize size;
  if ( m_VideoFormat != DCS_Format7 )
  {
    size = m_SensorSize;
  }
  else
  {
    size = m_RectTracker.m_rect.Size();
  }

  CString str;
  if ( m_VideoFormat != DCS_Format7)
  {
    str.Format(" Image Size: %d x %d", size.cx, size.cy );
  }
  else
  {
    str.Format(" AOI: (%d, %d): %d x %d", m_RectTracker.m_rect.left, m_RectTracker.m_rect.top, size.cx, size.cy);
  }
  m_MainFrame.m_Sbar.SetPaneText(ID_AOI_PANE, str);
}


void CImageView::StartTimer()
{
  m_nIdEvent = SetTimer(1, s_dwDragTimerInterval);
  ATLASSERT(m_nIdEvent);
}

void CImageView::StopTimer()
{
  KillTimer(m_nIdEvent);
}

LRESULT CImageView::OnTimer(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*/, BOOL& bHandled)
{
  // Ensure tracker visibility.

  CRect rcClient;
  GetClientRect(rcClient);

  CPoint ptCursor;
  GetCursorPos(&ptCursor);
  ScreenToClient(&ptCursor);

  if (!rcClient.PtInRect(ptCursor))
  {
    CSize offset;
    offset.cx = lcm(m_PosInc.cx, m_SizeInc.cx);
    offset.cy = lcm(m_PosInc.cy, m_SizeInc.cy);
    int ScrollCodeX = -1;
    int ScrollCodeY = -1;

    if (ptCursor.x > rcClient.right && m_ptOffset.x < m_sizeAll.cx - rcClient.Width())
    {
      ScrollCodeX = SB_LINEDOWN;
    }

    if (ptCursor.y > rcClient.bottom && m_ptOffset.y < m_sizeAll.cy - rcClient.Height())
    {
      ScrollCodeY = SB_LINEDOWN;
    }

    if (ptCursor.x < rcClient.left&& m_ptOffset.x > 0 )
    {
      ScrollCodeX = SB_LINEUP;
    }

    if (ptCursor.y < rcClient.top && m_ptOffset.y > 0)
    {
      ScrollCodeY = SB_LINEUP;
    }

    if ( ScrollCodeX != -1 || ScrollCodeY != -1 )
    {
      m_RectTracker.AdjustRect(m_RectTracker.GetTrackerHandle(), m_RectTracker.m_rect);
      if ( ScrollCodeX != -1 )
        DoScroll(SB_HORZ, ScrollCodeX, (int&) m_ptOffset.x, m_sizeAll.cx, m_sizePage.cx, m_sizeLine.cx );
      if ( ScrollCodeY != -1 )
        DoScroll(SB_VERT, ScrollCodeY, (int&) m_ptOffset.y, m_sizeAll.cy, m_sizePage.cy, m_sizeLine.cy );
      // Actualize rubbar band. This is done by sending a WM_MOUSEMOVE message, which will be processed by
      // the message loop of the TrackHandle function
      CRect rect;
      GetClientRect(&rect);
      CPoint pt;
      GetCursorPos(&pt);
      ScreenToClient(&pt);
      pt.x = max(pt.x, rect.left);
      pt.x = min(pt.x, rect.right);
      pt.y = max(pt.y, rect.top);
      pt.y = min(pt.y, rect.bottom);
      PostMessage(WM_MOUSEMOVE, MK_LBUTTON, pt.x + ( pt.y << 16 ) );
    } 

  }

  ShowAOISize();
  ShowCursorPos();

  bHandled = FALSE;

  return 0;

}


bool CImageView::SaveLayout()
{

  if ( m_pCamera == NULL )
  {
    assert(false);
    return false;
  }

  bool closeCamera = false;

  bool ret = false;

  try
  {

    if ( ! m_pCamera->IsOpen() )
    {
      m_pCamera->Activate();
      closeCamera = true;
    }

    CString keyName = APPLICATION_KEY + m_pCamera->Info.NodeId();
    CPropertyBagPtr ptrRootBag;
    try
    {
      ptrRootBag = CRegistryPropertyBag::Open(keyName);
    }
    catch ( BcamException& e)
    {
      if ( e.Error() == BCAM_E_BAG_DOES_NOT_EXIST )
        ptrRootBag = CRegistryPropertyBag::Create(keyName);
      else
        throw e;
    }

    CPropertyBagPtr ptrWindowBag;
    try
    {
      ptrWindowBag = ptrRootBag->GetBag("ImageView");
    }
    catch ( BcamException& e)
    {
      if ( e.Error() == BCAM_E_BAG_DOES_NOT_EXIST )
        ptrWindowBag = ptrRootBag->CreateBag("ImageView");
      else
        throw e;
    }


    WINDOWPLACEMENT p;
    ret =  ( ::GetWindowPlacement(GetParent(), &p) == TRUE );
    CPoint center = GetLogicalCenter();
    if ( ret )
    {
      ptrWindowBag->WriteLong("left", p.rcNormalPosition.left);
      ptrWindowBag->WriteLong("bottom", p.rcNormalPosition.bottom);
      ptrWindowBag->WriteLong("top", p.rcNormalPosition.top);
      ptrWindowBag->WriteLong("right", p.rcNormalPosition.right);
      ptrWindowBag->WriteLong("showCmd", p.showCmd);
      ptrWindowBag->WriteFloat("zoom", GetZoomLevel());
      ptrWindowBag->WriteBool("fit", IsZoomedToFit());
      ptrWindowBag->WriteLong("scrollx", center.x);
      ptrWindowBag->WriteLong("scrolly", center.y);
    }
  }
  catch(BcamException&  e )
  {
    e = e;
    ATLTRACE("Exception occured when saving window layout: %d (%s)\n", e.Error(), e.Description());
    ret = false;
  }

  if ( closeCamera )
  {
    try
    {
      m_pCamera->Deactivate();
    }
    catch(BcamException& e )
    {
      e = e;
      ATLTRACE("Exception occured when closing the device: %d (%s)\n", e.Error(), e.Description());
    }
  }

  return ret;

}



bool CImageView::RestoreLayout()
{
  bool ret = false;
  bool closeCamera = false;

  if ( m_pCamera == NULL )
  {
    assert(false);
    return false;
  }

  try
  {


    if ( ! m_pCamera->IsOpen() )
    {
      m_pCamera->Activate();
      closeCamera = true;
    }

    CString keyName = APPLICATION_KEY + m_pCamera->Info.NodeId();
    CPropertyBagPtr ptrBag = CRegistryPropertyBag::Open(keyName)->GetBag("ImageView");

    WINDOWPLACEMENT p;
    ZeroMemory(&p, sizeof(p));
    p.length = sizeof(p);
    p.rcNormalPosition.left = ptrBag->ReadLong("left");
    p.rcNormalPosition.right = ptrBag->ReadLong("right");
    p.rcNormalPosition.bottom = ptrBag->ReadLong("bottom");
    p.rcNormalPosition.top = ptrBag->ReadLong("top");
    p.showCmd = ptrBag->ReadLong("showCmd");
    double  zoom = ptrBag->ReadFloat("zoom");

    bool zoomToFit = ptrBag->ReadBool("fit");
    ::SetWindowPlacement(GetParent(), &p);

    if ( ! zoomToFit )
    {
      SetZoomLevel(zoom);
      long spx = 0;
      long spy = 0;
      try
      {
        spx = ptrBag->ReadLong("scrollx");
        spy = ptrBag->ReadLong("scrolly");
      }
      catch ( BcamException& )
      {
        /* NOP */
      }
      UpdateViewPort(&CPoint(spx, spy));

    }
    if ( zoomToFit )
      ZoomToFit();


  }
  catch(BcamException& e )
  {
    e = e;
    ATLTRACE("Exception occured when restoring window layout: %d (%s)", e.Error(), e.Description());
    ret = false;
  }

  if ( closeCamera )
  {
    try
    {
      m_pCamera->Deactivate();
    }
    catch(BcamException& e )
    {
      e = e;
      ATLTRACE("Exception occured when closing the device: %d (%s)", e.Error(), e.Description());
    }
  }

  return ret;
}