예제 #1
0
파일: fuse.cpp 프로젝트: 13221325403/openbr
    float compare(const Template &a, const Template &b) const
    {
        if (a.size() != distances.size() ||
            b.size() != distances.size())
            return -std::numeric_limits<float>::max();

        QList<float> scores;
        for (int i=0; i<distances.size(); i++) {
            float weight;
            weights.isEmpty() ? weight = 1. : weight = weights[i];
            if (weight != 0)
                scores.append(weight*distances[i]->compare(Template(a.file, a[i]),Template(b.file, b[i])));
        }

        switch (operation) {
          case Mean:
            return std::accumulate(scores.begin(),scores.end(),0.0)/(float)scores.size();
            break;
          case Sum:
            return std::accumulate(scores.begin(),scores.end(),0.0);
            break;
          case Min:
            return *std::min_element(scores.begin(),scores.end());
            break;
          case Max:
            return *std::max_element(scores.begin(),scores.end());
            break;
          default:
            qFatal("Invalid operation.");
        }
        return 0;
    }
예제 #2
0
파일: GML.cpp 프로젝트: berendeanicolae/gml
int  main(int argc, char* argv[])
{
	if (argc<=1)
		return ShowHelp();
	// run
	if (GML::Utils::GString::Equals(argv[1],"run",true))
	{
		if (argc!=3)
			return Error("run command requare a parameter (a template file)");
		return Run(argv[2]);
	}
	// info
	if (GML::Utils::GString::Equals(argv[1],"info",true))
	{
		if (argc!=3)
			return Error("info command requare a parameter (a name for a an Algorithm, Conector, DataBase or Notifier)");
		return Info(argv[2]);
	}
	// desc
	if (GML::Utils::GString::Equals(argv[1],"desc",true))
	{
		if (argc!=4)
			return Error("desc command requare two parameters (a name for a an Algorithm, Conector, DataBase or Notifier and a property)");
		return Desc(argv[2],argv[3]);
	}
	// template
	if (GML::Utils::GString::Equals(argv[1],"template",true))
	{
		if ((argc!=4) && (argc!=3))
			return Error("template command requares a name for a an Algorithm, Conector, DataBase or Notifier");
		if (argc==3)
			return Template(argv[2],NULL);
		else
			return Template(argv[2],argv[3]);
	}
	// pytemplate
	if (GML::Utils::GString::Equals(argv[1],"pytemplate",true))
	{
		if (argc!=3)
			return Error("pytemplate command requares one parameter (a name for a an Algorithm, Conector, DataBase or Notifier)");
		return PyTemplate(argv[2]);
	}
	// algorithms
	if (GML::Utils::GString::Equals(argv[1],"algorithms",true))
		return ShowObjects(ALGORITHM_FOLDER,ALGORITHM_EXT);
	// connectors
	if (GML::Utils::GString::Equals(argv[1],"connectors",true))
		return ShowObjects(CONNECTOR_FOLDER,CONNECTOR_EXT);
	// notifiers
	if (GML::Utils::GString::Equals(argv[1],"notifiers",true))
		return ShowObjects(NOTIFYER_FOLDER,NOTIFYER_EXT);
	// databases
	if (GML::Utils::GString::Equals(argv[1],"databases",true))
		return ShowObjects(DATABASE_FOLDER,DATABASE_EXT);

	printf("[ERROR] Unknwon command : %s \n",argv[1]);
	return -1;
}
예제 #3
0
//CImg* Template(int nTempH, int nTempW, int nTempMY, int nTempMX,double *pfArray, double fCoef,CImg *pImg);
CImg* CDimageView::Sobel(CImg *pImg)
{
	CImg* mImg1= new CImg(*pImg);
	CImg* mImg2= new CImg(*pImg);
	int width=pImg->GetWidthPixel();
	int height=pImg->GetHeight();

	mImg1 = Template(3, 3, 1, 1, Template_HSobel, 1, pImg);
	mImg2 = Template(3, 3, 1, 1, Template_VSobel, 1, pImg);

	//CImg* mImg = new CImg((*mImg1)+(*mImg2));
	CImg* mImg = new CImg((*mImg1)+(*mImg2));
	return mImg;
}
예제 #4
0
CImg* CDimageView::PrewittEdge(CImg* pImg,int index)
{
	double cfPrewittH[9] = {
		-1, -2, -1,
		 0,  0,  0,
		 1,  2,  1 };
	// 垂直边缘
	double cfPrewittV[9] = {
		-1,  0,  1,
		-2,  0,  2,
		-1,  0,  1 };
	// 45度边缘
	double cfPrewittCW[9] = {
		-2, -1,  0,
		-1,  0,  1,
		 0,  1,  2 };
	// 135度边缘
	double cfPrewittCCW[9] = {
		 0,  1,  2,
		-1,  0,  1,
		-2, -1,  0 };

	CImg* mImg1= new CImg(*pImg);
	CImg* mImg2= new CImg(*pImg);
	CImg* mImg3= new CImg(*pImg);	
	CImg* mImg4= new CImg(*pImg);

	int width=pImg->GetWidthPixel();
	int height=pImg->GetHeight();

	mImg1 = Template(3, 3, 1, 1, cfPrewittH, 1, pImg);
	mImg2 = Template(3, 3, 1, 1, cfPrewittV, 1, pImg);
	mImg3 = Template(3, 3, 1, 1, cfPrewittCW, 1, pImg);
	mImg4 = Template(3, 3, 1, 1, cfPrewittCCW, 1, pImg);

	CImg* nImg = new CImg((*mImg1)+(*mImg2)+(*mImg3)+(*mImg4));
//	CImg* mImg = new CImg((*mImg2));
	
    CImg* mImg= Autothres (nImg);
	switch(index)
	{
		case 0:return mImg;
		case 1:return Autothres (mImg1);
		case 2:return Autothres (mImg2);
		case 3:return Autothres (mImg3);
		case 4:return Autothres (mImg4);
	}
}
예제 #5
0
extern "C" __declspec(dllexport) void CBMENUENTRY(CBTYPE cbType, PLUG_CB_MENUENTRY* info)
{
    switch(info->hEntry)
    {
    case MENU_TEMPLATE: // edit this
        Template();
        break;
    }
}
예제 #6
0
void CDimageView::OnenSmoothf()
{
	// TODO: 在此添加命令处理程序代码
	CDimageDoc* pDoc= GetDocument();
	if(!pDoc->m_Img->IsValidate())
		return;
	if(pDoc->m_OImg->IsValidate())
	{
		delete []pDoc->m_OImg;
		pDoc->m_OImg=NULL;
	}
	pDoc->m_OImg= new CImg(*pDoc->m_Img);
	
	
	int	nTempH;	// 模板高度
	int	nTempW; // 模板宽度
	double fTempC;// 模板系数
	int	nTempMX;// 模板中心元素X坐标
	int	nTempMY;// 模板中心元素Y坐标
	
	// 模板元素数组赋初值(默认为平均模板)
	double aValue[9] = {1.0, 1.0, 1.0, 
						1.0, 1.0, 1.0, 
						1.0, 1.0, 1.0,};
	
	// 创建对话框
	DlgSmooth dlg;
	
	// 初始化对话框变量值
	dlg.m_intType = 0;
	dlg.m_iTempH  = 3;
	dlg.m_iTempW  = 3;
	dlg.m_iTempMX = 1;
	dlg.m_iTempMY = 1;
	dlg.m_fTempC  = (double) (1.0 / 9.0);
	dlg.m_fpArray = aValue;
	
	// 显示对话框,提示用户设定参数
	if (dlg.DoModal() != IDOK)
	{
		// 返回
		return;
	}
	
	// 获取用户设定的参数
	nTempH  = dlg.m_iTempH;
	nTempW  = dlg.m_iTempW;
	nTempMX = dlg.m_iTempMX;
	nTempMY = dlg.m_iTempMY;
	fTempC  = dlg.m_fTempC;

		
	delete []pDoc->m_Img;
	pDoc->m_Img = Template(nTempH, nTempW, nTempMY, nTempMX, aValue, fTempC, pDoc->m_OImg);
	Invalidate(1);
}
예제 #7
0
CImg* CDimageView::SobelEdge(CImg* pImg)
{
	double cfSobelH[9] = {
		-1, -1, -1,
		 0,  0,  0,
		 1,  1,  1 };
	// 垂直边缘
	double cfSobelV[9] = {
		-1,  0,  1,
		-1,  0,  1,
		-1,  0,  1 };
	// 45度边缘
	double cfSobelCW[9] = {
		-1, -1,  0,
		-1,  0,  1,
		 0,  1,  1 };
	// 135度边缘
	double cfSobelCCW[9] = {
		 0,  1,  1,
		-1,  0,  1,
		-1, -1,  0 };

	CImg* mImg1= new CImg(*pImg);
	CImg* mImg2= new CImg(*pImg);
	CImg* mImg3= new CImg(*pImg);
	CImg* mImg4= new CImg(*pImg);

	int width=pImg->GetWidthPixel();
	int height=pImg->GetHeight();

	mImg1 = Template(3, 3, 1, 1, cfSobelH, 1, pImg);
	mImg2 = Template(3, 3, 1, 1, cfSobelV, 1, pImg);
	mImg3 = Template(3, 3, 1, 1, cfSobelCW, 1, pImg);
	mImg4 = Template(3, 3, 1, 1, cfSobelCCW, 1, pImg);

	CImg* nImg = new CImg((*mImg1)+(*mImg2)+(*mImg3)+(*mImg4));
//	CImg* nImg = new CImg((*mImg1)+(*mImg2));
//	CImg* mImg = new CImg((*mImg2));
	
    CImg* mImg= Autothres (nImg);
	return mImg;
}
예제 #8
0
CImg* CDimageView::RobertEdge(CImg* pImg)
{
	double cfRobertCW[4]={-1 , 0, 0 , 1};
	double cfRobertCCW[4]={0 , -1, 1 , 0};

	CImg* mImg1= new CImg(*pImg);
	CImg* mImg2= new CImg(*pImg);

	int width=pImg->GetWidthPixel();
	int height=pImg->GetHeight();

	mImg1 = Template(2, 2, 0, 0, cfRobertCW, 1, pImg);
	mImg2 = Template(2, 2, 0, 0, cfRobertCCW, 1, pImg);

	CImg* nImg = new CImg((*mImg1)+(*mImg2));
//	CImg* mImg = new CImg((*mImg2));
	
    CImg* mImg= Autothres (nImg);
	return mImg;
}
예제 #9
0
// Return false if the entity is to be destroyed
bool CAmmoEntity::Update(TFloat32 updateTime)
{

	if (!landed)
	{
		Position().y -= m_FallSpeed * updateTime;

		if (Position().y < m_Height)
		{
			landed = true;
		}
	}
	else
	{
		m_SinWave += updateTime;
		Position().y = m_Height + sin(m_SinWave);
		// Rotate on the spot and bob up and down (for effect)
		Matrix().RotateY((kfPi / 3) * updateTime);

	}

	//TODO: Collision detection
	TInt32 enumID;
	EntityManager.BeginEnumEntities(enumID, "", "", "Tank");
	CTankEntity* theTank = dynamic_cast<CTankEntity*> (EntityManager.EnumEntity(enumID));
	while (theTank)
	{
		float radius = Template()->Mesh()->BoundingRadius();
		if (Length(Position() - theTank->Position()) < (theTank->GetRadius() + radius))	//If distance between the ammo and the tank is less than the tank's radius
		{
			EntityManager.EndEnumEntities(enumID);
			// Hit the tank, send the hit message and destroy the bullet
			SMessage theCollectMessage;
			theCollectMessage.from = GetUID();
			theCollectMessage.type = Msg_Ammo;
			theCollectMessage.intParam = m_RefillSize;
			Messenger.SendMessageA(theTank->GetUID(), theCollectMessage);
			return false;
		}


		theTank = dynamic_cast<CTankEntity*> (EntityManager.EnumEntity(enumID));
	}

	EntityManager.EndEnumEntities(enumID);

	return true;
}
예제 #10
0
NQInt NQInt::operator*(NQInt A)
{//ЭТО УМНОЖЕНИЕ!
	
	NQList<int> Resulted;
	int incr = 0;
	for (int i = -underValueLeng; i < valueLeng; i++)
		for (int j = -A.underValueLeng; j < A.valueLeng; j++)
		{//идем с двух сторон
			unsigned long long Value;
			if (i >= -underValueLeng && i < valueLeng && j >= -A.underValueLeng && j < A.valueLeng)//проверка была не знаю зачем - удалить!
			{
				Value =((unsigned long long)THIS[i])*(unsigned long long)A[j] +(unsigned long long)incr;
				//берется произведение, высчитывается инкремент следующих разрядов
				incr = Value / Notation;
				Value -= ((unsigned long long)incr)*((unsigned long long)Notation);//Сокращение длины 
				
				if (i+j + underValueLeng + A.underValueLeng >= Resulted.Count()) Resulted.addLast(Value);//добавление нового если необходимо
				else 
				{//морока с разрядами =)
					unsigned long long Val = (unsigned long long)Resulted[i+j+underValueLeng+A.underValueLeng] + Value;
					int Dincr = Val / Notation;
					Val -= ((unsigned long long)Dincr)*((unsigned long long)Notation);
					Resulted[i+j+underValueLeng+A.underValueLeng] =  Val;
					incr += Dincr;				
				}

				if (incr)
				if (i+j + underValueLeng + A.underValueLeng+1 >= Resulted.Count()) Resulted.addLast(incr);
				else 
				{//перевод разрядов
						Resulted[i+j+underValueLeng+A.underValueLeng + 1] += incr;
				}

				incr = 0;
				for (int k = i+j+underValueLeng+A.underValueLeng; k < Resulted.Count()-1 && Resulted[k] >= Notation; k++)
				{
					int D = Resulted[k] / Notation;
					Resulted[k] -= D*Notation;
					Resulted[k+1] += D;
				}
			
			}
		
		}
		NQInt Template(underValueLeng+A.underValueLeng,((A.Positive && Positive)||(!A.Positive && !Positive)),Resulted); 
		return Template;
}
예제 #11
0
//Разница чисел
NQInt NQInt::operator-(NQInt A)
{//Разность
	//переход с одной функции на другую
	if (Positive && !A.Positive)
	{
		A.Positive = true;
		return THIS + A;
	}
	if (!Positive && A.Positive)
	{
		A.Positive = false;
		return THIS + A;
	}

	int max = valueLeng> A.valueLeng?valueLeng:A.valueLeng;//положительная максимальня
	int min = underValueLeng>A.underValueLeng?underValueLeng:A.underValueLeng;//минимальная максимальная отрицательная
	NQList<int> Resulted;//накопитель
	int incr = 0;
	int CompareResult = Compare(A);
	if (CompareResult)
	for (int i =-min; i<max; i++)
	{//подсчет разницы, с переносом инкриментов
		long long Value = 0;
		if (i >= -underValueLeng && i<valueLeng)
			Value += THIS[i]*(CompareResult);
		if (i >= -A.underValueLeng && i<A.valueLeng)
			Value -= A[i]*(CompareResult);
		Value += incr;
		incr = 0;
		if (Value < 0) 
		{
			Value = Notation + Value;
			incr = -1;
		}
		Resulted.addLast(Value);
	}
	else
	{//Если числа равны?
		char *Temp = new char[2];
		Temp[0] = '0';
		Temp[1] = 0;
		return Temp;
	}
	NQInt Template(min,(CompareResult+1),Resulted);
	return Template;
	
}
void CDlgTemplate::OnRadio8()
{
    // TODO: Add your control notification handler code here
    aver = (float)(1.0/8.0);
    int smoothg[9] = {1,1,1,1,0,1,1,1,1};
    for(int k=0; k<9; k++)
    {
        smooth[k]=smoothg[k];
    }
    if(Tbitmap!=NULL)
    {
        DeleteObject(Tbitmap);
        Tbitmap=NULL;
    }
    Tbitmap=Template(m_dib.newpcol,m_dib.newbm,m_dib.NEWRGB32BITMAPINFO);
    ((CStatic *)GetDlgItem(IDC_STATIC2))->SetBitmap(Tbitmap);
}
BOOL CDlgTemplate::OnInitDialog()
{
    CMainDlg::OnInitDialog();
    ((CButton *)GetDlgItem(IDC_RADIO4))->SetCheck(1);
    ((CStatic *)GetDlgItem(IDC_STATIC1))->SetBitmap(m_dib.newbmp);
//	((CStatic *)GetDlgItem(IDC_STATIC2))->SetBitmap(m_dib.newbmp);
    if(Tbitmap!=NULL)
    {
        DeleteObject(Tbitmap);
        Tbitmap=NULL;
    }
    Tbitmap=Template(m_dib.newpcol,m_dib.newbm,m_dib.NEWRGB32BITMAPINFO);
    ((CStatic *)GetDlgItem(IDC_STATIC2))->SetBitmap(Tbitmap);
    // TODO: Add extra initialization here

    return TRUE;  // return TRUE unless you set the focus to a control
    // EXCEPTION: OCX Property Pages should return FALSE
}
예제 #14
0
void CChildView::OnGass() 
{
	// TODO: Add your command handler code here
   
	//设定模板参数
	double tem[9]={1,2,1,
		           2,4,2,
				   1,2,1};

    //设定模板系数
    double  xishu = 0.0625;   

    //进行模板操作
	m_hDIB =Template(m_hDIB,tem ,3,3, xishu);

	//显示图像
	CDC* pDC=GetDC();
	DisplayDIB(pDC,m_hDIB);
}
예제 #15
0
CImg* CDimageView::LogEdge(CImg* pImg)
{
	double cfLog[25]={0, 0, -1, 0, 0,
						0, -1, -2, -1, 0,
						-1, -2, 16, -2, -1,
						0, -1, -2, -1, 0,
						0, 0, -1, 0, 0};

	CImg* mImg1= new CImg(*pImg);

	int width=pImg->GetWidthPixel();
	int height=pImg->GetHeight();

	mImg1 = Template(5, 5, 2, 2, cfLog, 1, pImg);

//	CImg* mImg = new CImg((*mImg2));
	
    CImg* mImg= Autothres (mImg1);
	return mImg;
}
예제 #16
0
void CDimageView::OnenLapaces()
{
	// TODO: 在此添加命令处理程序代码
	CDimageDoc* pDoc= GetDocument();
	if(!pDoc->m_Img->IsValidate())
		return;
	if(pDoc->m_OImg->IsValidate())
	{
		delete []pDoc->m_OImg;
		pDoc->m_OImg=NULL;
	}
	pDoc->m_OImg= new CImg(*pDoc->m_Img);

	int nTempW = 3;
	int nTempH = 3;
	double fCoef = 1.0;
	int nTempMX = 1;
	int nTempMY = 1;
	delete []pDoc->m_Img;
	pDoc->m_Img=Template(nTempH, nTempW, nTempMY, nTempMX, Template_Laplace, fCoef, pDoc->m_OImg);
	Invalidate(0);
}
예제 #17
0
BOOL CmyWord::CreateDocument()  
{  
    if (!m_wdDocs.m_lpDispatch)   
    {  
        AfxMessageBox(_T("Documents为空!"), MB_OK|MB_ICONWARNING);  
        return FALSE;  
    }  
  
    COleVariant varTrue(short(1),VT_BOOL),vOptional((long)DISP_E_PARAMNOTFOUND, VT_ERROR);  
    CComVariant Template(_T(""));    //没有使用WORD的文档模板  
    CComVariant NewTemplate(false),DocumentType(0),Visible;  
  
    m_wdDocs.Add(&Template,&NewTemplate,&DocumentType,&Visible);      
  
    //得到document变量  
    m_wdDoc = m_wdApp.GetActiveDocument();  
    if (!m_wdDoc.m_lpDispatch)   
    {  
        AfxMessageBox(_T("Document获取失败!"), MB_OK|MB_ICONWARNING);  
        return FALSE;  
    }  
    //得到selection变量  
    m_wdSel = m_wdApp.GetSelection();  
    if (!m_wdSel.m_lpDispatch)   
    {  
        AfxMessageBox(_T("Select获取失败!"), MB_OK|MB_ICONWARNING);  
        return FALSE;  
    }  
    //得到Range变量  
    m_wdRange = m_wdDoc.Range(vOptional,vOptional);  
    if(!m_wdRange.m_lpDispatch)  
    {  
        AfxMessageBox(_T("Range获取失败!"), MB_OK|MB_ICONWARNING);  
        return FALSE;  
    }  
  
    return TRUE;  
}  
예제 #18
0
namespace SuperStatsBros {

static const unsigned int FRAME_SKIP = 10;

static const cv::Size GAME_RES(640, 480);
static const double LOCALIZE_THRESHOLD = 0.85;
static const double TEMPLATE_CONTOUR_THRESHOLD = 0.55;
static const double STOCK_MATCH_THRESHOLD = 0.50;

static const LocalizationParams LOCALIZE_CHAR_SELECT(Template("assets/text/back.png", 1.2), cv::Point(520, 17));
static const LocalizationParams LOCALIZE_STAGE_SELECT(Template("assets/text/stage_select.png", 0.9, 0.95), cv::Point(342, 400));
static const LocalizationParams LOCALIZE_IN_GAME(Template("assets/text/ready_italic.png", 0.8), cv::Point(138, 151));
static const LocalizationParams LOCALIZE_PAUSED(Template("assets/text/combo.png", 0.928, 1), cv::Point(461, 397));
static const LocalizationParams LOCALIZE_END_GAME(Template("assets/text/game.png", 0.928, 0.88), cv::Point(89, 149));
static const LocalizationParams LOCALIZE_SCORE_SCREEN(Template("assets/text/winner.png", 0.95, 2), cv::Point(25, 48));

static const double STAGE_NAME_SCALE_X = 0.65;
static const double STAGE_NAME_SCALE_Y = 0.73;
static const double STAGE_NAME_ROTATION = -10.0;

static const unsigned int STOCK_ORIGIN_X[] = { 25, 177, 329, 481 };
static const unsigned int STOCK_ORIGIN_Y = 362;
static const cv::Size STOCK_SIZE(26, 23);
static const unsigned int NUM_PLAYERS = 4;
static const unsigned int MAX_STOCKS = 5;

static const unsigned int DMG_THRESHOLD = 200;
static const unsigned int MIN_CONFIDENCE = 90;
static const unsigned int DMG_ORIGIN_Y = 405;
static const cv::Size DMG_SIZE(102, 39);

static const double STATE_MISMATCH_DELAY = 0.5;
static const double UNPAUSE_SECONDS_DELAY = 1.0;
static const double START_GAME_SECONDS_DELAY = 4.0;

} /* SuperStatsBros */
예제 #19
0
void csWrappedDocumentNode::ProcessSingleWrappedNode (
  NodeProcessingState* state, iDocumentNode* node)
{
  CS_ASSERT(globalState);

  if (ProcessTemplate (node, state)) return;
  if (ProcessStaticIf (state, node))
  {
    // Template invokation has precedence over dropping nodes...
    TempString<> tokenStr, args; 
    if (SplitNodeValue (node->GetValue(), tokenStr, args))
    {
      Template::Params params;
      if (!args.IsEmpty())
      {
        ParseTemplateArguments (args, params, false);
      }
      InvokeTemplate (tokenStr, node, state, params);
    }
    return;
  }

  csRefArray<iDocumentNode>& currentWrapper = state->currentWrapper;
  bool handled = false;
  if (node->GetType() == CS_NODE_UNKNOWN)
  {
    TempString<> replaceScratch;
    const char* nodeValue = ReplaceEntities (node->GetValue(),
      replaceScratch);
    if ((nodeValue != 0) && (*nodeValue == '?') && 
      (*(nodeValue + strlen (nodeValue) - 1) == '?'))
    {
      const char* valStart = nodeValue + 1;
      if ((*valStart == '!') || (*valStart == '#'))
      {
	/* Discard PIs beginning with ! and #. This allows comments, e.g.
	 * <?! some comment ?>
	 * The difference to XML comments is that the PI comments do not
	 * appear in the final document after processing, hence are useful
	 * if some PIs themselves are to be commented, but it is undesireable
	 * to have an XML comment in the result. */
	return;
      }

      while (*valStart == ' ') valStart++;
      CS_ASSERT (*valStart != 0);
      size_t valLen = strlen (valStart) - 1;
      if (valLen == 0)
      {
	Report (syntaxErrorSeverity, node,
	  "Empty processing instruction");
      }
      else
      {
	while (*(valStart + valLen - 1) == ' ') valLen--;
	const char* space = strchr (valStart, ' ');
	/* The rightmost spaces were skipped and don't interest us
	    any more. */
	if (space >= valStart + valLen) space = 0;
	size_t cmdLen;
	if (space != 0)
	{
	  cmdLen = space - valStart;
	}
	else
	{
	  cmdLen = valLen;
	}

	TempString<> tokenStr; tokenStr.Replace (valStart, cmdLen);
	csStringID tokenID = shared->pitokens.Request (tokenStr);
	switch (tokenID)
	{
	  case csWrappedDocumentNodeFactory::PITOKEN_INCLUDE:
            if (shared->plugin->do_verbose)
            {
              Report (CS_REPORTER_SEVERITY_WARNING, node,
                "Deprecated syntax, please use %s",
		CS::Quote::Single ("Include"));
            }
            // Fall through
	  case csWrappedDocumentNodeFactory::PITOKEN_INCLUDE_NEW:
	    {
	      bool okay = true;
	      TempString<> filename;
	      const char* space = strchr (valStart, ' ');
	      /* The rightmost spaces were skipped and don't interest us
	       * any more. */
	      if (space != 0)
	      {
		filename.Replace (space + 1, valLen - cmdLen - 1);
		filename.Trim ();
	      }
	      if ((space == 0) || (filename.IsEmpty ()))
	      {
		Report (syntaxErrorSeverity, node,
		  "%s without filename", CS::Quote::Single ("Include"));
		okay = false;
	      }
	      if (okay)
	      {
		ProcessInclude (filename, state, node);
	      }
	      handled = true;
	    }
	    break;
	  case csWrappedDocumentNodeFactory::PITOKEN_TEMPLATE:
            if (shared->plugin->do_verbose)
            {
              Report (CS_REPORTER_SEVERITY_WARNING, node,
                "Deprecated syntax, please use %s",
		CS::Quote::Single ("Template"));
            }
            // Fall through
          case csWrappedDocumentNodeFactory::PITOKEN_TEMPLATE_NEW:
	  case csWrappedDocumentNodeFactory::PITOKEN_TEMPLATEWEAK:
            {
              TempString<> args (valStart + cmdLen, valLen - cmdLen);
              args.LTrim();
              ProcessInstrTemplate (state, node, args, 
                tokenID == csWrappedDocumentNodeFactory::PITOKEN_TEMPLATEWEAK);
	      handled = true;
            }
	    break;
	  case csWrappedDocumentNodeFactory::PITOKEN_ENDTEMPLATE:
            if (shared->plugin->do_verbose)
            {
              Report (CS_REPORTER_SEVERITY_WARNING, node,
                "Deprecated syntax, please use %s",
		CS::Quote::Single ("Endtemplate"));
	      handled = true;
            }
            // Fall through
	  case csWrappedDocumentNodeFactory::PITOKEN_ENDTEMPLATE_NEW:
	    {
	      Report (syntaxErrorSeverity, node,
		"%s without %s",
		CS::Quote::Single ("Endtemplate"),
		CS::Quote::Single ("Template"));
              // ProcessTemplate() would've handled it otherwise
	      handled = true;
	    }
	    break;
          case csWrappedDocumentNodeFactory::PITOKEN_GENERATE:
            {
	      bool okay = true;
              Template::Params args;
	      if (space != 0)
	      {
		TempString<> pStr (space + 1, valLen - cmdLen - 1);
		ParseTemplateArguments (pStr, args, false);
	      }
              if ((args.GetSize() < 3) || (args.GetSize() > 4))
              {
                okay = false;
	        Report (syntaxErrorSeverity, node,
		  "%s expects 3 or 4 arguments, got %zu",
		  CS::Quote::Single ("Generate"), args.GetSize());
              }
              if (okay)
              {
                state->generateVar = args[0];

                int start, end, step;
                char dummy;
                if (sscanf (args[1], "%d%c", &start, &dummy) != 1)
                {
	          Report (syntaxErrorSeverity, node,
		    "Argument %s is not an integer", CS::Quote::Single (args[1].GetData()));
                  okay = false;
                }
                if (okay && sscanf (args[2], "%d%c", &end, &dummy) != 1)
                {
	          Report (syntaxErrorSeverity, node,
		    "Argument %s is not an integer", CS::Quote::Single (args[2].GetData()));
                  okay = false;
                }
                if (okay)
                {
                  if (args.GetSize() == 4)
                  {
                    if (sscanf (args[3], "%d%c", &step, &dummy) != 1)
                    {
	              Report (syntaxErrorSeverity, node,
		        "Argument %s is not an integer", CS::Quote::Single (args[3].GetData()));
                      okay = false;
                    }
                  }
                  else
                  {
                    step = (end < start) ? -1 : 1;
                  }
                }
                if (okay)
                {
                  state->generateActive = true;
		              state->generateNestLevel = 1;
                  if (((start > end) && (step >= 0))
                    || ((end >= start) && (step <= 0)))
                  {
	                  Report (syntaxErrorSeverity, node,
		                  "Can't reach end value %d starting from %d with step %d", 
                      end, start, step);
                    state->generateValid = false;
                  }
                  else
                  {
                    state->generateValid = true;
                    state->generateStart = start;
                    state->generateEnd = end;
                    state->generateStep = step;
                    state->templ = Template();
                  }
                }
              }
	      handled = true;
            }
            break;
	  case csWrappedDocumentNodeFactory::PITOKEN_ENDGENERATE:
	    {
	      Report (syntaxErrorSeverity, node,
		"%s without %s",
		CS::Quote::Single ("Endgenerate"),
		CS::Quote::Single ("Generate"));
              // ProcessTemplate() would've handled it otherwise
	    }
	    break;
	  case csWrappedDocumentNodeFactory::PITOKEN_DEFINE:
            {
              TempString<> args (valStart + cmdLen, valLen - cmdLen);
              args.LTrim();
              ProcessDefine (state, node, args);
	      handled = true;
            }
	    break;
	  case csWrappedDocumentNodeFactory::PITOKEN_UNDEF:
            {
              TempString<> args (valStart + cmdLen, valLen - cmdLen);
              args.LTrim();
              ProcessUndef (state, node, args);
	      handled = true;
            }
	    break;
	  case csWrappedDocumentNodeFactory::PITOKEN_STATIC_IFDEF:
	  case csWrappedDocumentNodeFactory::PITOKEN_STATIC_IFNDEF:
            {
              TempString<> args (valStart + cmdLen, valLen - cmdLen);
              args.LTrim();
              ProcessStaticIfDef (state, node, args,
                tokenID == csWrappedDocumentNodeFactory::PITOKEN_STATIC_IFNDEF);
	      handled = true;
            }
            break;
          case csWrappedDocumentNodeFactory::PITOKEN_STATIC_ELSIFDEF:
          case csWrappedDocumentNodeFactory::PITOKEN_STATIC_ELSIFNDEF:
          case csWrappedDocumentNodeFactory::PITOKEN_STATIC_ELSE:
          case csWrappedDocumentNodeFactory::PITOKEN_STATIC_ENDIF:
            {
	      Report (syntaxErrorSeverity, node,
		"%s without %s",
		CS::Quote::Single (shared->pitokens.Request (tokenID)),
		CS::Quote::Single ("SIfDef"));
              // ProcessStaticIf() would've handled it otherwise
	      handled = true;
            }
            break;
	  default:
	    {
	      Template::Params params;
	      if (space != 0)
	      {
		TempString<> pStr (space + 1, valLen - cmdLen - 1);
		ParseTemplateArguments (pStr, params, false);
	      }
	      if (InvokeTemplate (tokenStr, node, state, params))
	      {
            handled = true;
	      }
	      // If it's neither a template nor a recognized command, pass through
	    }
	}
      }
    }
  }
  if (!handled)
  {
    csRef<iDocumentNode> newWrapper;
    newWrapper.AttachNew (new csWrappedDocumentNode (this,
      node, shared, globalState));
    currentWrapper.Push (newWrapper);
  }
}
void DtwPsClassifier::addTemplate() {
    templateBank.push_back(Template());
}
예제 #21
0
    void compare(File targetGallery, File queryGallery, File output)
    {
        qDebug("Comparing %s and %s%s", qPrintable(targetGallery.flat()),
               qPrintable(queryGallery.flat()),
               output.isNull() ? "" : qPrintable(" to " + output.flat()));

        // Escape hatch for distances that need to operate directly on the gallery files
        if (distance->compare(targetGallery, queryGallery, output))
            return;

        // Are we comparing the same gallery against itself?
        bool selfCompare = targetGallery == queryGallery;

        // Should we use multiple processes to do enrollment/comparison? If not, we just do multi-threading.
        bool multiProcess = Globals->file.getBool("multiProcess", false);

        // In comparing two galleries, we will keep the smaller one in memory, and load the larger one
        // incrementally. If the gallery set is larger than the probe set, we operate in transpose mode
        // i.e. we must transpose our output, to still write the output matrix in row-major order.
        bool transposeMode = false;

        // Is the larger gallery already enrolled? If not, we will enroll those images in-line with their
        // comparison against the smaller gallery (which will be enrolled, and stored in memory).
        bool needEnrollRows = false;

        if (output.exists() && output.get<bool>("cache", false)) return;
        if (queryGallery == ".") queryGallery = targetGallery;

        // To decide which gallery is larger, we need to read both, but at this point we just want the
        // metadata, and don't need the enrolled matrices.
        FileList targetMetadata;
        FileList queryMetadata;

        // Emptyread reads a gallery, and discards any matrices present, keeping only the metadata.
        targetMetadata = FileList::fromGallery(targetGallery, true);
        queryMetadata  = FileList::fromGallery(queryGallery, true);


        // Is the target or query set larger? We will use the larger as the rows of our comparison matrix (and transpose the output if necessary)
        transposeMode = targetMetadata.size() > queryMetadata.size();

        File rowGallery = queryGallery;
        File colGallery = targetGallery;
        qint64 rowSize;

        Gallery * temp;
        if (transposeMode)
        {
            rowGallery = targetGallery;
            colGallery = queryGallery;
            temp = Gallery::make(targetGallery);
        }
        else
        {
            temp = Gallery::make(queryGallery);
        }
        rowSize = temp->totalSize();
        delete temp;

        // Is the column gallery already enrolled? We keep the enrolled column gallery in memory, and in multi-process
        // mode, every worker process retains a copy of this gallery in memory. When not in multi-process mode, we can
        // simple make sure the enrolled data is stored in a memGallery, but in multi-process mode we save the enrolled
        // data to disk (as a .gal file) so that each worker process can read it without re-doing enrollment.
        File colEnrolledGallery = colGallery;
        QString targetExtension = multiProcess ? "gal" : "mem";

        // If the column gallery is not already of the appropriate type, we need to do something
        if (colGallery.suffix() != targetExtension)
        {
            // Build the name of a gallery containing the enrolled data, of the appropriate type.
            colEnrolledGallery = colGallery.baseName() + colGallery.hash() + (multiProcess ? ".gal" : ".mem");

            // Check if we have to do real enrollment, and not just convert the gallery's type.
            if (!(QStringList() << "gal" << "template" << "mem").contains(colGallery.suffix()))
            {
                enroll(colGallery, colEnrolledGallery);
            }
            // If the gallery does have enrolled templates, but is not the right type, we do a simple
            // type conversion for it.
            else
            {
                QScopedPointer<Gallery> readColGallery(Gallery::make(colGallery));
                TemplateList templates = readColGallery->read();
                QScopedPointer<Gallery> enrolledColOutput(Gallery::make(colEnrolledGallery));
                enrolledColOutput->writeBlock(templates);
            }
        }

        // We have handled the column gallery, now decide whehter or not we have to enroll the row gallery.
        if (selfCompare)
        {
            // For self-comparisons, we just use the already enrolled column set.
            rowGallery = colEnrolledGallery;
        }
        // Otherwise, we will need to enroll the row set. Since the actual comparison is defined via a transform
        // which compares incoming templates against a gallery, we will handle enrollment of the row set by simply
        // building a transform that does enrollment (using the current algorithm), then does the comparison in one
        // step. This way, we don't have to retain the complete enrolled row gallery in memory, or on disk.
        else if(!(QStringList() << "gal" << "mem" << "template").contains(rowGallery.suffix()))
        {
            needEnrollRows = true;
        }

        // At this point, we have decided how we will structure the comparison (either in transpose mode, or not), 
        // and have the column gallery enrolled, and have decided whether or not we need to enroll the row gallery.
        // From this point, we will build a single algorithm that (optionally) does enrollment, then does comparisons
        // and output, optionally using ProcessWrapper to do the enrollment and comparison in separate processes.
        //
        // There are two main components to this algorithm. The first is the (optional) enrollment and then the
        // comparison step (built from a GalleryCompare transform), and the second is the sequential matrix output and
        // progress counting step.
        // After the base algorithm is built, the whole thing will be run in a stream, so that I/O can be handled sequentially.

        // The actual comparison step is done by a GalleryCompare transform, which has a Distance, and a gallery as data.
        // Incoming templates are compared against the templates in the gallery, and the output is the resulting score
        // vector.
        QString compareRegionDesc = "Pipe([GalleryCompare("+Globals->algorithm + "," + colEnrolledGallery.flat() + ")])";


        QScopedPointer<Transform> compareRegion;
        // If we need to enroll the row set, we add the current algorithm's enrollment transform before the
        // GalleryCompare in a pipe.
        if (needEnrollRows)
        {
            if (!multiProcess)
            {
                compareRegionDesc = compareRegionDesc;
                compareRegion.reset(Transform::make(compareRegionDesc,NULL));
                CompositeTransform * downcast = dynamic_cast<CompositeTransform *> (compareRegion.data());
                if (downcast == NULL)
                    qFatal("Pipe downcast failed in compare");

                downcast->transforms.prepend(this->transform.data());
                downcast->init();
            }
            else
            {
                compareRegionDesc = "ProcessWrapper(" + this->transformString + "+" + compareRegionDesc + ")";
                compareRegion.reset(Transform::make(compareRegionDesc, NULL));
            }
        }
        else {
            if (multiProcess)
                compareRegionDesc = "ProcessWrapper(" + compareRegionDesc + ")";
            compareRegion.reset(Transform::make(compareRegionDesc,NULL));
        }

        // At this point, compareRegion is a transform, which optionally does enrollment, then compares the row
        // set against the column set. If in multi-process mode, the enrollment and comparison are wrapped in a 
        // ProcessWrapper transform, and will be transparently run in multiple processes.
        compareRegion->init();


        // We also need to add Output and progress counting to the algorithm we are building, so we will assign them to
        // two stages of a pipe.
        QString joinDesc = "Pipe()";
        QScopedPointer<Transform> join(Transform::make(joinDesc, NULL));

        // The output transform takes the metadata memGalleries we set up previously as input, along with the
        // output specification we were passed. Gallery metadata is necessary for some Outputs to function correctly.
        QString outputString = output.flat().isEmpty() ? "Empty" : output.flat();
        QString outputRegionDesc = "Output("+ outputString +"," + targetGallery.flat() +"," + queryGallery.flat() + ","+ QString::number(transposeMode ? 1 : 0) + ")";
        // The ProgressCounter transform will simply provide a display about the number of rows completed.
        outputRegionDesc += "+ProgressCounter("+QString::number(rowSize)+")+Discard";
        QScopedPointer<Transform> outputTform(Transform::make(outputRegionDesc, NULL));

        // Assign the comparison transform we previously built, and the output transform  we just built to
        // two stages of a pipe.
        CompositeTransform * downcast = dynamic_cast<CompositeTransform *> (join.data());
        downcast->transforms.append(compareRegion.data());
        downcast->transforms.append(outputTform.data());

        // With this, we have set up a transform which (optionally) enrolls templates, compares them
        // against a gallery, and outputs them.
        join->init();

        // Now, we will give that base transform to a stream, which will incrementally read the row gallery
        // and pass the transforms it reads through the base algorithm.
        QString streamDesc = "Stream(readMode=StreamGallery)";
        QScopedPointer<Transform> streamBase(Transform::make(streamDesc, NULL));
        WrapperTransform * streamWrapper = dynamic_cast<WrapperTransform *> (streamBase.data());
        streamWrapper->transform = join.data();

        // The transform we will use is now complete.
        streamWrapper->init();

        // We set up a template containing the rowGallery we want to compare. 
        TemplateList rowGalleryTemplate;
        rowGalleryTemplate.append(Template(rowGallery));
        TemplateList outputGallery;

        // Set up progress counting variables
        Globals->currentStep = 0;
        Globals->totalSteps = rowSize;
        Globals->startTime.start();

        // Do the actual comparisons
        streamWrapper->projectUpdate(rowGalleryTemplate, outputGallery);
    }
예제 #22
0
		static Template parse(const dotX39::Node& node, const std::vector<Ressource>& ressourceList)
		{
			auto tmp = Template();
			tmp.qualifier = node.getName();

#pragma region Argument Parsing
			for (int i = 0; i < node.getArgumentCount(); i++)
			{
				const dotX39::Data* arg = node.getArgument(i);
				if (arg->getName().compare("path") == 0)
				{
					if (arg->getType() != dotX39::DataTypes::STRING)
					{
						std::cerr << std::string("the nodes '").append(tmp.qualifier).append("' 'path' argument should be STRING") << std::endl;
						throw Exceptions::InvalidTypeStructureException();
					}
					tmp.filePath = std::string(Globals::getInstance().basePath.templates).append(static_cast<const dotX39::DataString*>(arg)->getDataAsString());
				}
				else if (arg->getName().compare("fileName") == 0)
				{
					if (arg->getType() != dotX39::DataTypes::STRING)
					{
						std::cerr << std::string("the nodes '").append(tmp.qualifier).append("' 'fileName' argument should be STRING") << std::endl;
						throw Exceptions::InvalidTypeStructureException();
					}
					tmp.outputFileName = std::string(static_cast<const dotX39::DataString*>(arg)->getDataAsString());
				}
				else if (arg->getName().compare("fileExtension") == 0)
				{
					if (arg->getType() != dotX39::DataTypes::STRING)
					{
						std::cerr << std::string("the nodes '").append(tmp.qualifier).append("' 'fileExtension' argument should be STRING") << std::endl;
						throw Exceptions::InvalidTypeStructureException();
					}
					tmp.outputFileExtension = std::string(static_cast<const dotX39::DataString*>(arg)->getDataAsString());
				}
				else 
				{
					if (Globals::getInstance().verbosity)
						std::cout << std::string("the node '").append(tmp.qualifier).append("' contains the unknown argument '").append(arg->getName()).append("', ignored.") << std::endl;
				}
			}
#pragma endregion
#pragma region Data Parsing
			for (int i = 0; i < node.getDataCount(); i++)
			{
				const dotX39::Data* data = node.getData(i);
				if (data->getName().compare("ressources") == 0)
				{
					if (data->getType() != dotX39::DataTypes::ARRAY)
					{
						std::cerr << std::string("the nodes '").append(tmp.qualifier).append("' 'ressources' argument should be ARRAY") << std::endl;
						throw Exceptions::InvalidTypeStructureException();
					}
					auto tmpDataArray = static_cast<const dotX39::DataArray*>(data);
					//We want to validate ALL ressources here so lets create an error counter instead of throwing an exception instantly
					size_t errCount = 0;
					for (int j = 0; j < tmpDataArray->getDataCount(); j++)
					{
						auto data = tmpDataArray->getDataElement(j);
						if (data->getType() != dotX39::DataTypes::STRING)
						{
							std::cerr << std::string("the nodes '").append(tmp.qualifier).append("' 'ressource' argument should be ARRAY with just STRINGs") << std::endl;
							throw Exceptions::InvalidTypeStructureException();
						}
						//Find the ressource in available ressources and push it to the templates ressource list
						bool flag = false;
						auto ressourceName = static_cast<const dotX39::DataString*>(data)->getDataAsString();
						for (auto& it : ressourceList)
						{
							if (it.getQualifier().compare(ressourceName) == 0)
							{
								tmp.ressources.push_back(it);
								flag = true;
								break;
							}
						}
						if (!flag)
						{
							errCount++;
							std::cerr << "Ressource '" << ressourceName << "' is not existing (template: '" << tmp.qualifier << "')" << std::endl;
						}
					}
					//if we did found errors, throw the invalid_argument exception
					if (errCount > 0)
						throw std::invalid_argument("Some Ressources are not existing for a Template");
				}
				else 
				{
					if (Globals::getInstance().verbosity)
						std::cout << std::string("the node '").append(tmp.qualifier).append("' contains the unknown argument '").append(data->getName()).append("', ignored.") << std::endl;
				}
			}
#pragma endregion
#pragma region Node Parsing
			for (int i = 0; i < node.getNodeCount(); i++)
			{
				auto subnode = node.getNode(i);
				if (subnode->getName().compare("templateKeywords") == 0)
				{
					for (int j = 0; j < subnode->getDataCount(); j++)
					{
						auto data = subnode->getData(j);
						if (data->getType() != dotX39::DataTypes::STRING)
						{
							std::cerr << std::string("the nodes '").append(tmp.qualifier).append("' subnodes '").append(subnode->getName()).append("' data datatypes should be STRING") << std::endl;
							throw Exceptions::InvalidTypeStructureException();
						}
						auto templateKeyword = TemplateKeyword::parse(*static_cast<const dotX39::DataString*>(data));
						tmp.keywords.templates.push_back(templateKeyword);
					}
				}
				else if (subnode->getName().compare("replacementKeywords") == 0)
				{
					for (int j = 0; j < subnode->getDataCount(); j++)
					{
						auto data = subnode->getData(j);
						if (data->getType() != dotX39::DataTypes::ARRAY)
						{
							std::cerr << std::string("the nodes '").append(tmp.qualifier).append("' subnodes '").append(subnode->getName()).append("' data datatypes should be ARRAY") << std::endl;
							throw Exceptions::InvalidTypeStructureException();
						}
						tmp.keywords.replacements.push_back(ReplacementKeyword::parse(*static_cast<const dotX39::DataArray*>(data)));
					}
				}
				else
				{
					if (Globals::getInstance().verbosity)
						std::cout << std::string("the node '").append(tmp.qualifier).append("' contains the unknown node '").append(subnode->getName()).append("', ignored.") << std::endl;
				}
			}
#pragma endregion

			if (tmp.filePath.empty())
			{
				std::cerr << std::string("the node '").append(tmp.getQualifier()).append("' has no path argument provided") << std::endl;
				exit(-1);
			}
			std::ifstream stream = std::ifstream(std::string(tmp.filePath).c_str());
			if (!stream.is_open() || !stream.good())
			{
				auto errMsg = std::string("Could not read file: ").append(tmp.filePath);
				std::cerr << errMsg << std::endl;
				throw std::runtime_error(errMsg);
			}
			char s[256];
			while (!stream.eof())
			{
				memset(s, 0, sizeof(s));
				stream.read(s, 255);
				tmp.fileData.append(s);
			}
			stream.close();
			return tmp;
		}
예제 #23
0
BOOL WINAPI GaussDIB(LPSTR lpDIBBits, LONG lWidth, LONG lHeight)
{
	
	// 指向缓存图像的指针
	LPSTR	lpDst1;
	LPSTR	lpDst2;
	
	// 指向缓存DIB图像的指针
	LPSTR	lpNewDIBBits1;
	HLOCAL	hNewDIBBits1;
	LPSTR	lpNewDIBBits2;
	HLOCAL	hNewDIBBits2;

	// 模板高度
	int		iTempH;
	
	// 模板宽度
	int		iTempW;
	
	// 模板系数
	FLOAT	fTempC;
	
	// 模板中心元素X坐标
	int		iTempMX;
	
	// 模板中心元素Y坐标
	int		iTempMY;
	
	//模板数组
	FLOAT aTemplate[25];

	// 暂时分配内存,以保存新图像
	hNewDIBBits1 = LocalAlloc(LHND, lWidth * lHeight);

	if (hNewDIBBits1 == NULL)
	{
		// 分配内存失败
		return FALSE;
	}
	
	// 锁定内存
	lpNewDIBBits1 = (char * )LocalLock(hNewDIBBits1);

	// 暂时分配内存,以保存新图像
	hNewDIBBits2 = LocalAlloc(LHND, lWidth * lHeight);

	if (hNewDIBBits2 == NULL)
	{
		// 分配内存失败
		return FALSE;
	}
	
	// 锁定内存
	lpNewDIBBits2 = (char * )LocalLock(hNewDIBBits2);

	// 拷贝源图像到缓存图像中
	lpDst1 = (char *)lpNewDIBBits1;
	memcpy(lpNewDIBBits1, lpDIBBits, lWidth * lHeight);
	lpDst2 = (char *)lpNewDIBBits2;
	memcpy(lpNewDIBBits2, lpDIBBits, lWidth * lHeight);


	// 设置Gauss模板参数
	iTempW = 5;
	iTempH = 5;
	fTempC = 1.0;
	iTempMX = 3;
	iTempMY = 3;
	aTemplate[0] = -2.0;
	aTemplate[1] = -4.0;
	aTemplate[2] = -4.0;
	aTemplate[3] = -4.0;
	aTemplate[4] = -2.0;
	aTemplate[5] = -4.0;
	aTemplate[6] = 0.0;
	aTemplate[7] = 8.0;
	aTemplate[8] = 0.0;
	aTemplate[9] = -4.0;
	aTemplate[10] = -4.0;
	aTemplate[11] = 8.0;
	aTemplate[12] = 24.0;
	aTemplate[13] = 8.0;
	aTemplate[14] = -4.0;
	aTemplate[15] = -4.0;
	aTemplate[16] = 0.0;
	aTemplate[17] = 8.0;
	aTemplate[18] = 0.0;
	aTemplate[19] = -4.0;
	aTemplate[20] = -2.0;
	aTemplate[21] = -4.0;
	aTemplate[22] = -4.0;
	aTemplate[23] = -4.0;
	aTemplate[24] = -2.0;

	// 调用Template()函数
	if (!Template(lpNewDIBBits1, lWidth, lHeight, 
		iTempH, iTempW, iTempMX, iTempMY, aTemplate, fTempC))
	{
		return FALSE;
	}

	// 复制经过模板运算后的图像到源图像
	memcpy(lpDIBBits, lpNewDIBBits1, lWidth * lHeight);

	// 释放内存
	LocalUnlock(hNewDIBBits1);
	LocalFree(hNewDIBBits1);

	LocalUnlock(hNewDIBBits2);
	LocalFree(hNewDIBBits2);
	// 返回
	return TRUE;
}
예제 #24
0
bool TemplateGroup::Refresh()
{
	CString line;
	CStdioFile file;

	// Check the date and time stamp.
	CFileStatus fileStatus;
	if (!CFile::GetStatus(m_filename, fileStatus))
	{
		return false;
	}
	if (m_timeStamp == fileStatus.m_mtime)
	{
		// Matches... don't reload.
		return false;
	}

	// Destroy the old stuff.
	for (size_t i = 0; i < m_templates.GetCount(); i++)
		delete m_templates[i];
	m_templates.RemoveAll();

	// Open the file.
	if (!file.Open(m_filename, CFile::modeRead))
	{
		return false;
	}

	// Assign as the new time stamp.
	m_timeStamp = fileStatus.m_mtime;

	// Possible states.
	enum State
	{
		FINDTEMPLATE,
		PARSETEMPLATE,
		PARSECODE,
		PARSEMEMO,
		PARSEDIALOG,
		PARSEPARAMS,
		PARSEKEY,
	};

	State state = FINDTEMPLATE;
	Template* curTemplate = NULL;
	CString* curDialog = NULL;
	
	// Read the template file name.
	file.ReadString(m_name);
	int lineNumber = 1;

	// Go until we're through.
	while (true)
	{
		// Read a line.
		lineNumber++;
		if (!file.ReadString(line))
		{
			// End of file.
			break;
		}

TopState:
		// Check the state.
		if (state == FINDTEMPLATE)
		{
			// Find the block.
			if (line.GetLength() >= 1  &&  line[0] == '[')
			{
				if (line[line.GetLength() - 1] == ']')
				{
					state = PARSETEMPLATE;

					curTemplate = WNEW Template(*this);
					curTemplate->m_lineNumber = lineNumber;
					m_templates.Add(curTemplate);
					curTemplate->m_name = line.Mid(1, line.GetLength() - 2);
				}
			}
		}

		///////////////////////////////////////////////////////////////////////
		// Template parsing.
		///////////////////////////////////////////////////////////////////////
		else if (state == PARSETEMPLATE)
		{
			ASSERT(curTemplate);

			// Did we find a new block?
			if (line.GetLength() >= 1  &&  line[0] == '[')
			{
				curTemplate = NULL;
				state = FINDTEMPLATE;
				goto TopState;
			}

			// Search for the template sub-type to process.
			if (line.CompareNoCase("!!code") == 0)
			{
				state = PARSECODE;
				continue;
			}
			else if (line.CompareNoCase("!!memo") == 0)
			{
				state = PARSEMEMO;
				continue;
			}
			else if (line.CompareNoCase("!!dialog") == 0)
			{
				state = PARSEDIALOG;
				continue;
			}
			else if (line.CompareNoCase("!!params") == 0)
			{
				state = PARSEPARAMS;
				continue;
			}
			else if (line.CompareNoCase("!!key") == 0)
			{
				state = PARSEKEY;
				continue;
			}
		}

		///////////////////////////////////////////////////////////////////////
		// Code parsing
		///////////////////////////////////////////////////////////////////////
		else if (state == PARSECODE)
		{
			if (line.CompareNoCase("!!end") == 0)
			{
				state = PARSETEMPLATE;
				continue;
			}

			// Add the line to our list.
			Template::OffsetInfo offsetInfo;
			offsetInfo.m_offset = curTemplate->m_code.GetLength();
			offsetInfo.m_line = lineNumber;
			curTemplate->m_codeOffsets.Add(offsetInfo);
			curTemplate->m_code += line;
			curTemplate->m_code += "\n";
		}

		///////////////////////////////////////////////////////////////////////
		// Memo parsing
		///////////////////////////////////////////////////////////////////////
		else if (state == PARSEMEMO)
		{
			if (line.CompareNoCase("!!end") == 0)
			{
				state = PARSETEMPLATE;
				continue;
			}

			// Add the line to our list.
			curTemplate->m_memo += line;
			curTemplate->m_memo += " ";
		}

		///////////////////////////////////////////////////////////////////////
		// Dialog parsing
		///////////////////////////////////////////////////////////////////////
		else if (state == PARSEDIALOG)
		{
			if (line.CompareNoCase("!!end") == 0)
			{
				curDialog = NULL;
				state = PARSETEMPLATE;
				continue;
			}

			if (!curDialog  ||  line.CompareNoCase("!!next") == 0)
			{
				int index = curTemplate->m_pages.Add(CString(""));
				curDialog = &curTemplate->m_pages[index];
				if (line.CompareNoCase("!!next") == 0)
					continue;
			}
			
			if (line.IsEmpty())
			{
				line = "<br>";
			}

			// Add the line to our list.
			*curDialog += line;
			*curDialog += " ";
		}

		///////////////////////////////////////////////////////////////////////
		// Default parameters parsing
		///////////////////////////////////////////////////////////////////////
		else if (state == PARSEPARAMS)
		{
			if (line.CompareNoCase("!!end") == 0)
			{
				state = PARSETEMPLATE;
				continue;
			}

			// Add the line to our list.
			LPCTSTR ptr = (LPCTSTR)line;
			CharArray buffer;
			CString param = ParseToken(ptr, NULL);

			while (*ptr != 0  &&  *ptr == ' ')
				ptr++;

			if (*ptr == 0)
			{
				// Error!!!
			}

			Template::DefaultInfo info;
			info.m_entry = param;
			info.m_value = ptr;
			curTemplate->m_defaults.AddTail(info);
		}

		///////////////////////////////////////////////////////////////////////
		// Default parameters parsing
		///////////////////////////////////////////////////////////////////////
		else if (state == PARSEKEY)
		{
			state = PARSETEMPLATE;

			// Get the keys.
			LPCTSTR ptr = (LPCTSTR)line;
			CharArray buffer;
			CString param = ParseToken(ptr, NULL);

			curTemplate->m_key = param;
		}
	}
	
	// Close the template file.	
	file.Close();

	return true;
}
HBITMAP CDlgTemplate::PicTemplate()
{
    return Template(m_dib.pcol,m_dib.bm,m_dib.RGB32BITSBITMAPINFO);
}
예제 #26
0
CValue CValueText::Method(int iName,CValue **p)
{

	CValue Ret;
	switch(iName)
	{
		case enLinesCnt:
			Ret=aText.GetSize();
			break;
		case enClear:
			aText.RemoveAll();
			break;
		case enGetLine:
			{
				DEF_N_LINE()
				Ret=String(aText[n]);
				break;
			}
		case enAddLine:
			if (nTemplate)
				aText.Add(Template(p[0]->GetString()));
			else
				aText.Add(p[0]->GetString());
			break;
		case enReplaceLine:
			{
				DEF_N_LINE()
				if (nTemplate)
					aText[n]=Template(p[1]->GetString());
				else
					aText[n]=p[1]->GetString();
				break;
			}
		case enDeleteLine:
			{
				DEF_N_LINE()
				aText.RemoveAt(n);
				break;
			}
		case enInsertLine:
			{
				DEF_N_LINE()
				if (nTemplate)
					aText.InsertAt(n,Template(p[1]->GetString()));
				else
					aText.InsertAt(n,p[1]->GetString());
				break;
			}

		case enOpen:
			{
				CString csName=p[0]->GetString();
				if(!FileExist(csName))
					Error(CString("Файл ")+csName+" не найден");
				aText.RemoveAll();
				csTitle=csName;

				int nSize=0;
				char *buf=LoadFromFileBin(csName,nSize);
				if (!nSize)
					break;
				if(buf)
				{
					CString Str;
					Str.GetBuffer(10000);
					for(int i=0;i<nSize;i++)
					{
						if(buf[i]==0x0D&&buf[i+1]==0x0A)
						{
							if (nTemplate)
								aText.Add(Template(Str));
							else
								aText.Add(Str);
							Str="";
							i++;
							//i++;
						}
						else
						{
							Str+=buf[i];
						}
					}
					if (nTemplate)
						aText.Add(Template(Str));
					else
						aText.Add(Str);
					Str.ReleaseBuffer();
					delete []buf;
				}
				break;
			}
		case enShow:
			{
				if(!pDoc)
					pDoc=(CModuleDoc*)OpenFormMDI("Модуль",1);
				pDoc->SetPathName(csTitle,0);
				pDoc->SetTitle(csTitle);
				pDoc->SetText(GetStr());
				pDoc->m_xTextBuffer.SetReadOnly(bReadOnly);
				break;
			}
		case enWrite:
			{
				CString csName=p[0]->GetString();
				csTitle=csName;

				extern void WritoToFileText(CString csCFile,CString Str);
				WritoToFileText(csName,GetStr());

				break;
			}
		case enReadOnly:
			{
				Ret=bReadOnly;
				bReadOnly=p[0]->GetNumber();
				if(pDoc)
					pDoc->m_xTextBuffer.SetReadOnly(bReadOnly);

				break;
			}
		case enCodePage:
			{
				Ret=nCodePage;
				if (p[0]->nType)
				nCodePage=p[0]->GetNumber();
				break;
			}
		case enTemplate:
			{
				Ret=nTemplate;
				if (p[0]->nType)
					nTemplate=p[0]->GetNumber();
				break;
			}
		case enFixTemplate:
			{
				Ret=nFixTemplate;
				if (p[0]->nType)
					nFixTemplate=p[0]->GetNumber();
				break;
			}
		case enGetText:
			Ret=String(GetStr());
			break;
	}
	return Ret;
}
예제 #27
0
BOOL WINAPI KirschDIB(LPSTR lpDIBBits, LONG lWidth, LONG lHeight)
{
	
	// 指向缓存图像的指针
	LPSTR	lpDst1;
	LPSTR	lpDst2;
	
	// 指向缓存DIB图像的指针
	LPSTR	lpNewDIBBits1;
	HLOCAL	hNewDIBBits1;
	LPSTR	lpNewDIBBits2;
	HLOCAL	hNewDIBBits2;

	//循环变量
	long i;
	long j;

	// 模板高度
	int		iTempH;
	
	// 模板宽度
	int		iTempW;
	
	// 模板系数
	FLOAT	fTempC;
	
	// 模板中心元素X坐标
	int		iTempMX;
	
	// 模板中心元素Y坐标
	int		iTempMY;
	
	//模板数组
	FLOAT aTemplate[9];

	// 暂时分配内存,以保存新图像
	hNewDIBBits1 = LocalAlloc(LHND, lWidth * lHeight);

	if (hNewDIBBits1 == NULL)
	{
		// 分配内存失败
		return FALSE;
	}
	
	// 锁定内存
	lpNewDIBBits1 = (char * )LocalLock(hNewDIBBits1);

	// 暂时分配内存,以保存新图像
	hNewDIBBits2 = LocalAlloc(LHND, lWidth * lHeight);

	if (hNewDIBBits2 == NULL)
	{
		// 分配内存失败
		return FALSE;
	}
	
	// 锁定内存
	lpNewDIBBits2 = (char * )LocalLock(hNewDIBBits2);

	// 拷贝源图像到缓存图像中
	lpDst1 = (char *)lpNewDIBBits1;
	memcpy(lpNewDIBBits1, lpDIBBits, lWidth * lHeight);
	lpDst2 = (char *)lpNewDIBBits2;
	memcpy(lpNewDIBBits2, lpDIBBits, lWidth * lHeight);


	// 设置Kirsch模板1参数
	iTempW = 3;
	iTempH = 3;
	fTempC = 1.0;
	iTempMX = 1;
	iTempMY = 1;
	aTemplate[0] = 5.0;
	aTemplate[1] = 5.0;
	aTemplate[2] = 5.0;
	aTemplate[3] = -3.0;
	aTemplate[4] = 0.0;
	aTemplate[5] = -3.0;
	aTemplate[6] = -3.0;
	aTemplate[7] = -3.0;
	aTemplate[8] = -3.0;

	// 调用Template()函数
	if (!Template(lpNewDIBBits1, lWidth, lHeight, 
		iTempH, iTempW, iTempMX, iTempMY, aTemplate, fTempC))
	{
		return FALSE;
	}

	// 设置Kirsch模板2参数
	aTemplate[0] = -3.0;
	aTemplate[1] = 5.0;
	aTemplate[2] = 5.0;
	aTemplate[3] = -3.0;
	aTemplate[4] = 0.0;
	aTemplate[5] = 5.0;
	aTemplate[6] = -3.0;
	aTemplate[7] = -3.0;
	aTemplate[8] = -3.0;

	// 调用Template()函数
	if (!Template(lpNewDIBBits2, lWidth, lHeight, 
		iTempH, iTempW, iTempMX, iTempMY, aTemplate, fTempC))
	{
		return FALSE;
	}

	//求两幅缓存图像的最大值
	for(j = 0; j <lHeight; j++)
	{
		for(i = 0;i <lWidth-1; i++)
		{

			// 指向缓存图像1倒数第j行,第i个象素的指针			
			lpDst1 = (char *)lpNewDIBBits1 + lWidth * j + i;

			// 指向缓存图像2倒数第j行,第i个象素的指针			
			lpDst2 = (char *)lpNewDIBBits2 + lWidth * j + i;
			
			if(*lpDst2 > *lpDst1)
				*lpDst1 = *lpDst2;
		
		}
	}

	// 拷贝源图像到缓存图像中
	memcpy(lpNewDIBBits2, lpDIBBits, lWidth * lHeight);

	// 设置Kirsch模板3参数
	aTemplate[0] = -3.0;
	aTemplate[1] = -3.0;
	aTemplate[2] = 5.0;
	aTemplate[3] = -3.0;
	aTemplate[4] = 0.0;
	aTemplate[5] = 5.0;
	aTemplate[6] = -3.0;
	aTemplate[7] = -3.0;
	aTemplate[8] = 5.0;

	// 调用Template()函数
	if (!Template(lpNewDIBBits2, lWidth, lHeight, 
		iTempH, iTempW, iTempMX, iTempMY, aTemplate, fTempC))
	{
		return FALSE;
	}

	//求两幅缓存图像的最大值
	for(j = 0; j <lHeight; j++)
	{
		for(i = 0;i <lWidth-1; i++)
		{

			// 指向缓存图像1倒数第j行,第i个象素的指针			
			lpDst1 = (char *)lpNewDIBBits1 + lWidth * j + i;

			// 指向缓存图像2倒数第j行,第i个象素的指针			
			lpDst2 = (char *)lpNewDIBBits2 + lWidth * j + i;
			
			if(*lpDst2 > *lpDst1)
				*lpDst1 = *lpDst2;
		
		}
	}

	// 拷贝源图像到缓存图像中
	memcpy(lpNewDIBBits2, lpDIBBits, lWidth * lHeight);
	
	// 设置Kirsch模板4参数
	aTemplate[0] = -3.0;
	aTemplate[1] = -3.0;
	aTemplate[2] = -3.0;
	aTemplate[3] = -3.0;
	aTemplate[4] = 0.0;
	aTemplate[5] = 5.0;
	aTemplate[6] = -3.0;
	aTemplate[7] = 5.0;
	aTemplate[8] = 5.0;

	// 调用Template()函数
	if (!Template(lpNewDIBBits2, lWidth, lHeight, 
		iTempH, iTempW, iTempMX, iTempMY, aTemplate, fTempC))
	{
		return FALSE;
	}

	//求两幅缓存图像的最大值
	for(j = 0; j <lHeight; j++)
	{
		for(i = 0;i <lWidth-1; i++)
		{

			// 指向缓存图像1倒数第j行,第i个象素的指针			
			lpDst1 = (char *)lpNewDIBBits1 + lWidth * j + i;

			// 指向缓存图像2倒数第j行,第i个象素的指针			
			lpDst2 = (char *)lpNewDIBBits2 + lWidth * j + i;
			
			if(*lpDst2 > *lpDst1)
				*lpDst1 = *lpDst2;
		
		}
	}

	// 拷贝源图像到缓存图像中
	memcpy(lpNewDIBBits2, lpDIBBits, lWidth * lHeight);
	
	// 设置Kirsch模板5参数
	aTemplate[0] = -3.0;
	aTemplate[1] = -3.0;
	aTemplate[2] = -3.0;
	aTemplate[3] = -3.0;
	aTemplate[4] = 0.0;
	aTemplate[5] = -3.0;
	aTemplate[6] = 5.0;
	aTemplate[7] = 5.0;
	aTemplate[8] = 5.0;

	// 调用Template()函数
	if (!Template(lpNewDIBBits2, lWidth, lHeight, 
		iTempH, iTempW, iTempMX, iTempMY, aTemplate, fTempC))
	{
		return FALSE;
	}

	// 拷贝源图像到缓存图像中
	memcpy(lpNewDIBBits2, lpDIBBits, lWidth * lHeight);
	//求两幅缓存图像的最大值
	for(j = 0; j <lHeight; j++)
	{
		for(i = 0;i <lWidth-1; i++)
		{

			// 指向缓存图像1倒数第j行,第i个象素的指针			
			lpDst1 = (char *)lpNewDIBBits1 + lWidth * j + i;

			// 指向缓存图像2倒数第j行,第i个象素的指针			
			lpDst2 = (char *)lpNewDIBBits2 + lWidth * j + i;
			
			if(*lpDst2 > *lpDst1)
				*lpDst1 = *lpDst2;
		
		}
	}

	// 拷贝源图像到缓存图像中
	memcpy(lpNewDIBBits2, lpDIBBits, lWidth * lHeight);
	
	// 设置Kirsch模板6参数
	aTemplate[0] = -3.0;
	aTemplate[1] = -3.0;
	aTemplate[2] = -3.0;
	aTemplate[3] = 5.0;
	aTemplate[4] = 0.0;
	aTemplate[5] = -3.0;
	aTemplate[6] = 5.0;
	aTemplate[7] = 5.0;
	aTemplate[8] = -3.0;

	// 调用Template()函数
	if (!Template(lpNewDIBBits2, lWidth, lHeight, 
		iTempH, iTempW, iTempMX, iTempMY, aTemplate, fTempC))
	{
		return FALSE;
	}

	//求两幅缓存图像的最大值
	for(j = 0; j <lHeight; j++)
	{
		for(i = 0;i <lWidth-1; i++)
		{

			// 指向缓存图像1倒数第j行,第i个象素的指针			
			lpDst1 = (char *)lpNewDIBBits1 + lWidth * j + i;

			// 指向缓存图像2倒数第j行,第i个象素的指针			
			lpDst2 = (char *)lpNewDIBBits2 + lWidth * j + i;
			
			if(*lpDst2 > *lpDst1)
				*lpDst1 = *lpDst2;
		
		}
	}

	// 拷贝源图像到缓存图像中
	memcpy(lpNewDIBBits2, lpDIBBits, lWidth * lHeight);
	
	// 设置Kirsch模板7参数
	aTemplate[0] = 5.0;
	aTemplate[1] = -3.0;
	aTemplate[2] = -3.0;
	aTemplate[3] = 5.0;
	aTemplate[4] = 0.0;
	aTemplate[5] = -3.0;
	aTemplate[6] = 5.0;
	aTemplate[7] = -3.0;
	aTemplate[8] = -3.0;

	// 调用Template()函数
	if (!Template(lpNewDIBBits2, lWidth, lHeight, 
		iTempH, iTempW, iTempMX, iTempMY, aTemplate, fTempC))
	{
		return FALSE;
	}

	//求两幅缓存图像的最大值
	for(j = 0; j <lHeight; j++)
	{
		for(i = 0;i <lWidth-1; i++)
		{

			// 指向缓存图像1倒数第j行,第i个象素的指针			
			lpDst1 = (char *)lpNewDIBBits1 + lWidth * j + i;

			// 指向缓存图像2倒数第j行,第i个象素的指针			
			lpDst2 = (char *)lpNewDIBBits2 + lWidth * j + i;
			
			if(*lpDst2 > *lpDst1)
				*lpDst1 = *lpDst2;
		
		}
	}

	// 拷贝源图像到缓存图像中
	memcpy(lpNewDIBBits2, lpDIBBits, lWidth * lHeight);
	
	// 设置Kirsch模板8参数
	aTemplate[0] = 5.0;
	aTemplate[1] = 5.0;
	aTemplate[2] = -3.0;
	aTemplate[3] = 5.0;
	aTemplate[4] = 0.0;
	aTemplate[5] = -3.0;
	aTemplate[6] = -3.0;
	aTemplate[7] = -3.0;
	aTemplate[8] = -3.0;

	// 调用Template()函数
	if (!Template(lpNewDIBBits2, lWidth, lHeight, 
		iTempH, iTempW, iTempMX, iTempMY, aTemplate, fTempC))
	{
		return FALSE;
	}

	//求两幅缓存图像的最大值
	for(j = 0; j <lHeight; j++)
	{
		for(i = 0;i <lWidth-1; i++)
		{

			// 指向缓存图像1倒数第j行,第i个象素的指针			
			lpDst1 = (char *)lpNewDIBBits1 + lWidth * j + i;

			// 指向缓存图像2倒数第j行,第i个象素的指针			
			lpDst2 = (char *)lpNewDIBBits2 + lWidth * j + i;
			
			if(*lpDst2 > *lpDst1)
				*lpDst1 = *lpDst2;
		
		}
	}

	// 复制经过模板运算后的图像到源图像
	memcpy(lpDIBBits, lpNewDIBBits1, lWidth * lHeight);

	// 释放内存
	LocalUnlock(hNewDIBBits1);
	LocalFree(hNewDIBBits1);

	LocalUnlock(hNewDIBBits2);
	LocalFree(hNewDIBBits2);
	// 返回
	return TRUE;
}