run.cpp

Intel开发的IPP库的应用例程

   return TRUE;
}

BOOL CRun::PickNext(CMyString& vectorName, UINT& pickID, UINT& grabID)
{
   if (!PickNextPos()) return FALSE;
   if (!PickSetID(vectorName, pickID, grabID)) return FALSE;
   if (PickMarkDocs() == 0)
      PickMessageUnexist(vectorName,pickID,m_Func);      
   return TRUE;
}

BOOL CRun::PickSetID(CMyString& vectorName, UINT& pickID, UINT& grabID)
{
   vectorName = GetVectorName(m_PickVecPos);
   return GetPickID(m_PickVecPos, pickID, grabID);
}

CMyString CRun::GetVectorName(int vecPos)
{
   if (vecPos == VEC_SRC) {
      if (m_Func.Inplace()) {
         if (m_UsedVectors & VEC_SRC2) {
            return _T("Src");
         } else {
            return _T("SrcDst");
         }
      } else if (m_UsedVectors & VEC_SRC2) {
         return _T("Src1");
      } else if (m_Func.OnlyDst()) {
         return _T("Dst");
      } else {
         return _T("Src");
      }
   } else if (vecPos == VEC_SRC2) {
      if (m_Func.Inplace()) {
         if (m_UsedVectors & VEC_SRC3) {
            return _T("Src2");
         } else {
            return _T("SrcDst");
         }
      } else {
         return _T("Src2");
      }
   } else if (vecPos == VEC_SRC3) {
      if (m_Func.Inplace()) {
         return _T("SrcDst");
      } else {
         return _T("Src3");
      }
   } else if (vecPos == VEC_MASK) {
      return _T("Mask");
   } else if (vecPos == VEC_DST) {
      if (m_UsedVectors & VEC_DST2) {
         return _T("Dst1");
      } else {
         return _T("Dst");
      }
   } else if (vecPos == VEC_DST2) {
      return _T("Dst2");
   } else {
      return _T("");
   }
}


BOOL CRun::GetPickID(int vecPos, UINT& pickID, UINT& grabID)
{
   if (vecPos == VEC_SRC2) {
      if (m_Func.Inplace() && !(m_UsedVectors & VEC_SRC3)) {
         pickID = IDC_CURSOR_PSD;
         grabID = IDC_CURSOR_SD;
      } else {
         pickID = IDC_CURSOR_PS2;
         grabID = IDC_CURSOR_S2;
      }
   } else if (vecPos == VEC_SRC3) {
      if (m_Func.Inplace()) {
         pickID = IDC_CURSOR_PSD;
         grabID = IDC_CURSOR_SD;
      } else {
         pickID = IDC_CURSOR_PS3;
         grabID = IDC_CURSOR_S3;
      }
   } else if (vecPos == VEC_MASK) {
      pickID = IDC_CURSOR_PM;
      grabID = IDC_CURSOR_M;
   } else if (vecPos == VEC_DST) {
      pickID = IDC_CURSOR_PD;
      grabID = IDC_CURSOR_D;
   } else {
      return FALSE;
   }
   return TRUE;
}

BOOL CRun::PickMaskAfter(int vecPos)
{
   if (!(m_UsedVectors & VEC_MASK)) return FALSE;
   if ((m_UsedVectors & VEC_SRC2) && !m_Func.Inplace()) 
      return vecPos == VEC_SRC2;
   return vecPos == VEC_SRC;
}

BOOL CRun::PickNextMaskPos()
{   
   if (PickMaskAfter(VEC_SRC)) {
      if (m_PickVecPos == VEC_SRC) {
         m_PickVecPos = VEC_MASK;
         return TRUE;
      }
      if (m_PickVecPos == VEC_MASK) {
         m_PickVecPos = VEC_SRC;
      }
   } else if (PickMaskAfter(VEC_SRC2)) {
      if (m_PickVecPos == VEC_SRC2) {
         m_PickVecPos = VEC_MASK;
         return TRUE;
      }
      if (m_PickVecPos == VEC_MASK) {
         m_PickVecPos = VEC_SRC2;
      }
   }
   return FALSE;
}

BOOL CRun::PickNextPos()
{   
   if (PickNextMaskPos()) return TRUE;
   if (SetNextPickPos(VEC_SRC2)) return TRUE;
   if (SetNextPickPos(VEC_SRC3)) return TRUE;
   if (SetNextPickPos(VEC_DST)) return TRUE;
   if (SetNextPickPos(VEC_DST2)) return TRUE;
   m_PickVecPos = -1;
   return FALSE;
}

BOOL CRun::SetNextPickPos(int vecFlag)
{   
   if (!DEMO_APP->GetPickDst() && (vecFlag >= VEC_DST))
      return FALSE;
   if (m_UsedVectors & vecFlag) {
      if (m_PickVecPos < vecFlag) {
         m_PickVecPos = vecFlag;
         return TRUE;
      }
   }
   return FALSE;
}

BOOL CRun::IsPickVecDst()
{
   return m_PickVecPos >= VEC_DST;
}

BOOL CRun::PickMarkDoc(CDemoDoc* pDoc)
{
   BOOL flag = m_Func.Valid(pDoc->GetVector(),GetPickVecPosToValid());
   pDoc->MayBePicked(flag);
   return flag ? TRUE : FALSE;
}

int CRun::PickMarkDocs()
{
   int count = 0;
   MY_POSITION pos = DEMO_APP->GetFirstDocPosition(); 
   while (pos) {
      CDemoDoc* pDoc = DEMO_APP->GetNextDoc(pos);
      count += PickMarkDoc(pDoc);
   }
   return count;
}

void CRun::PickRemarkDocs()
{
   MY_POSITION pos = DEMO_APP->GetFirstDocPosition(); 
   while (pos) {
      CDemoDoc* pDoc = DEMO_APP->GetNextDoc(pos);
      pDoc->MayBePicked(FALSE);
      pDoc->IsPicked(FALSE);
   }
}

void CRun::GrabDoc(CDemoDoc* pDoc)
{
   if (GetPickVecPos() == VEC_SRC2)
      m_pDocSrc2 = pDoc;
   else if (GetPickVecPos() == VEC_SRC3)
      m_pDocSrc3 = pDoc;
   else if (GetPickVecPos() == VEC_MASK)
      m_pDocMask = pDoc;
   else if (GetPickVecPos() == VEC_DST)
      m_pDocDst = pDoc;
   else 
      return;
   pDoc->IsPicked(TRUE);
}

void CRun::PickMessageUnexist(CString vectorName, UINT pickID, CFunc func)
{
   AfxMessageBox(
      vectorName + _T(" ") + VectorTerm() + _T(" for ") + func + _T(" isn't exist\n")
      _T("Open proper ") + VectorTerm() + _T(" or stop processing, please"));
}


void CRun::SetHistory()
{
   SetToHisto(m_pDocSrc , VEC_SRC );
   SetToHisto(m_pDocSrc2, VEC_SRC2);
   SetToHisto(m_pDocSrc3, VEC_SRC3);
   SetToHisto(m_pDocDst , VEC_DST );
   SetToHisto(m_pDocDst2, VEC_DST2);
}

void CRun::SetToHisto(CDemoDoc* pDoc, int vecPos)
{
   if (!pDoc) return;
   if (NoHistory(vecPos)) return;
//   if (vecPos == VEC_DST)
   pDoc->GetVector()->GetHisto()->LastFunc(m_Func);
   SetToHistoSrc(pDoc,vecPos);
   SetToHistoFunc(pDoc,vecPos);
   SetToHistoDst(pDoc,vecPos);
}

BOOL CRun::NoHistory(int vecPos) {
   switch (vecPos) {
   case VEC_SRC: 
      if (NoDst()) return FALSE;
      if (!m_Func.Inplace()) return TRUE;
      if (m_pDocSrc2) return TRUE;
      break;
   case VEC_SRC2: 
      if (NoDst()) return TRUE;
      if (!m_Func.Inplace()) return TRUE;
      if (m_pDocSrc3) return TRUE;
      break;
   case VEC_SRC3: 
      if (NoDst()) return TRUE;
      if (!m_Func.Inplace()) return TRUE;
      break;
   }
   return FALSE;
}

void CRun::SetToHistoSrc(CDemoDoc* pDoc, int vecPos)
{
   CHisto* pHisto = pDoc->GetVector()->GetHisto();
   CMyString title = pDoc->GetTitle();
   switch (vecPos) {
   case VEC_SRC: 
      if (m_pDocMask) 
         pHisto->AddTail(m_pDocMask->GetTitle());
      break;
   case VEC_SRC2: 
      if (NoDst()) return;
      if (!m_Func.Inplace()) return;
      pHisto->RemoveAll();
      pHisto->AddTail(m_pDocSrc->GetVector()->GetHisto());
      if (m_pDocMask) 
         pHisto->AddTail(m_pDocMask->GetTitle());
      pHisto->AddTail(title);
      break;
   case VEC_SRC3: 
      if (NoDst()) return;
      if (!m_Func.Inplace()) return;
      pHisto->RemoveAll();
      pHisto->AddTail(m_pDocSrc->GetVector()->GetHisto());
      pHisto->AddTail(m_pDocSrc2->GetTitle());
      if (m_pDocMask) 
         pHisto->AddTail(m_pDocMask->GetTitle());
      pHisto->AddTail(title);
      break;
   default: 
      pHisto->RemoveAll();
      pHisto->AddTail(m_pDocSrc->GetVector()->GetHisto());
      if (m_pDocSrc2) 
         pHisto->AddTail(m_pDocSrc2->GetTitle());
      if (m_pDocSrc3) 
         pHisto->AddTail(m_pDocSrc3->GetTitle());
      if (m_pDocMask) 
         pHisto->AddTail(m_pDocMask->GetTitle());
      break;
   }
}

void CRun::SetToHistoFunc(CDemoDoc* pDoc, int vecPos)
{
   CHisto* pHisto = pDoc->GetVector()->GetHisto();
   AddHistoFunc(pHisto);
}

void CRun::SetToHistoDst(CDemoDoc* pDoc, int vecPos)
{
   CHisto* pHisto = pDoc->GetVector()->GetHisto();
   CMyString title = pDoc->GetTitle();
   if (NoDst()) return;
   CString vecName = GetVecName(vecPos);
   if (!vecName.IsEmpty())  vecName = _T(" - ") + vecName;
   pHisto->AddTail(title + vecName);
   pDoc->UpdateFrameTitle(m_Func + vecName);
}

CString CRun::GetVecName(int vecPos)
{
   if (m_UsedVectors & VEC_DST2)
      return m_Func.VecName(vecPos,m_UsedVectors);
   else
      return _T("");
}

static CString getLibSuffix(int idx = 0)
{
   CString suffix;
   const IppLibraryVersion* libVer = DEMO_APP->GetLibVersion(idx);
   if (libVer) {
      suffix = libVer->Name;
      suffix = suffix.Right(2);
   }
   return suffix;
}

void CRun::AddHistoFunc(CHisto* pHisto, int vecPos)
{
   CString srcB;
   CString scale;
   CString parms = GetHistoryParms();
   CString info = GetHistoryInfo();
   CString funcParms;

   if (m_Func.Scale())
      scale.Format(_T("%d"),scaleFactor);
   if (NoDst() && (m_pDocSrc2))
      srcB = m_pDocSrc2->GetTitle();
   if (NoDst() && (m_pDocSrc3))
      srcB += _T(", ") + m_pDocSrc3->GetTitle();

   if (parms.Find(_T("..")) == -1) 
      funcParms += _T("..");
   if (!srcB.IsEmpty()) {
      if (!funcParms.IsEmpty()) funcParms += _T(", ");
      funcParms += srcB + _T(", ..");
   }
   if (!parms.IsEmpty()) {
      if (!funcParms.IsEmpty()) funcParms += _T(", ");
      funcParms += parms;
   }
   if (!scale.IsEmpty()) {
      if (!funcParms.IsEmpty()) funcParms += _T(", ");
      funcParms += scale;
   }
   if (funcParms == _T("..")) funcParms.Empty();

   pHisto->AddFuncString(m_Func, funcParms, info, 
                         m_Perf, 
// CLib                         DEMO_APP->GetLibSuffix(), 
                         getLibSuffix(),
                         m_PerfUnit);
}


BOOL CRun::NoDst()
{ 
   return !m_Func.Inplace() && !(m_UsedVectors & VEC_DST);
}