自学教程：C++ Filter函数代码示例

void DynConfig::Init(){	s_sDataPath     = Filter(Utils::GetStringBetween(NETRIPPER_SETTINGS, "<data_path>", "</data_path>"));	s_sPlainText    = Filter(Utils::GetStringBetween(NETRIPPER_SETTINGS, "<plaintext>", "</plaintext>"));	s_sDataLimit    = Filter(Utils::GetStringBetween(NETRIPPER_SETTINGS, "<datalimit>", "</datalimit>"));	s_sStringFinder = Filter(Utils::GetStringBetween(NETRIPPER_SETTINGS, "<stringfinder>", "</stringfinder>"));}

bool CglList::KeyPressed(unsigned short k, bool isRepeat){	if (k == SDLK_ESCAPE) {		if (cancelPlace >= 0) {			place = cancelPlace;			Select();			return true;		}	} else if (k == SDLK_UP) {		UpOne();		return true;	} else if (k == SDLK_DOWN) {		DownOne();		return true;	} else if (k == SDLK_PAGEUP) {		UpPage();		return true;	} else if (k == SDLK_PAGEDOWN) {		DownPage();		return true;	} else if (k == SDLK_RETURN) {		Select();		return true;	} else if (k == SDLK_BACKSPACE) {		query = query.substr(0, query.length() - 1);		return Filter(true);	} else if ((k & ~0xFF) != 0) {		// This prevents isalnum from asserting on msvc debug crt		// We don't actually need to process the key tho;)	} else if (isalnum(k)) {		query += tolower(k);		return Filter(false);	}	return false;}

ILboolean ILAPIENTRY iluEdgeDetectP(){	ILubyte		*HPass, *VPass;	ILuint		i;	ILboolean	Palette = IL_FALSE, Converted = IL_FALSE;	ILenum		Type = 0;	iluCurImage = ilGetCurImage();	if (iluCurImage == NULL) {		ilSetError(ILU_ILLEGAL_OPERATION);		return IL_FALSE;	}	if (iluCurImage->Format == IL_COLOUR_INDEX) {		Palette = IL_TRUE;		ilConvertImage(ilGetPalBaseType(iluCurImage->Pal.PalType), IL_UNSIGNED_BYTE);	}	else if (iluCurImage->Type > IL_UNSIGNED_BYTE) {		Converted = IL_TRUE;		Type = iluCurImage->Type;		ilConvertImage(iluCurImage->Format, IL_UNSIGNED_BYTE);	}	HPass = Filter(iluCurImage, filter_h_prewitt, filter_h_prewitt_scale, filter_h_prewitt_bias);	VPass = Filter(iluCurImage, filter_v_prewitt, filter_v_prewitt_scale, filter_v_prewitt_bias);	if (!HPass || !VPass) {		ifree(HPass);		ifree(VPass);		return IL_FALSE;	}	// Combine the two passes	//	Optimization by Matt Denham	for (i = 0; i < iluCurImage->SizeOfData; i++) {		if (HPass[i] == 0)			iluCurImage->Data[i] = VPass[i];		else if (VPass[i] == 0)			iluCurImage->Data[i] = HPass[i];		else			iluCurImage->Data[i] = (ILubyte)sqrt(HPass[i]*HPass[i]+VPass[i]*VPass[i]);	}	/*for (i = 0; i < iluCurImage->SizeOfData; i++) {		iluCurImage->Data[i] = (ILubyte)sqrt(HPass[i]*HPass[i]+VPass[i]*VPass[i]);	}*/		ifree(HPass);	ifree(VPass);	if (Palette)		ilConvertImage(IL_COLOUR_INDEX, IL_UNSIGNED_BYTE);	else if (Converted)		ilConvertImage(iluCurImage->Format, Type);	return IL_TRUE;}

void List::RefreshQuery() {	if (query != "") {		int t = topIndex;		std::string q = query;		Filter(true);		query = q;		Filter(false);		topIndex = t;	}}

void CglList::KeyPress(int k){	if (k == SDLK_BACKSPACE) {		query = query.substr(0, query.length() - 1);		Filter(true);	} else if (isalnum(k)) {		query += tolower(k);		Filter(false);	}}

void preProcess(IplImage *prv,IplImage *cur,IplImage *nxt,IplImage *wrt){    	// 	//cvSub(cur,prv,pImagePool[0]);	//Detect(pImagePool[0],wrt,Robert);	switch ( whichKernel)	{	case 0:		// diff two img		cvSub(cur,prv,wrt);		break;	case 1:		Detect(wrt, cur,Robert);		break;	case 2:		Detect(wrt, cur,Prewitt);		break;	case 3:		Detect(wrt, cur,LapLas);		break;	case 4:		histogramNormalize(wrt, cur);		break;	case 5:		histogramNormalize(pImagePool[0], cur);		Detect(wrt,pImagePool[0],Prewitt);		break;	case 6:		{			imgDFT(wrt, cur);		}		break;	case 7:		{			Detect(wrt, cur,FreiChen);			break;		}	case 8:		{			Filter(wrt, cur);			break;		}	case 9:		{			transRGB2Gray( pImagePool[0], cur);			Filter(wrt, pImagePool[0],averageFilter);		}	default:		break;	}}

static void Rec(int index){    if (index == 7)        return;    Filter();    Rec(index + 1);    Number[index] = 100;    Filter();    Rec(index + 1);    Number[index] = 0;}

void Filters::init() {	list.clear();	// Video	list["noise"] = Filter(tr("add noise"), "noise", "9ah:5ah");	list["deblock"] = Filter(tr("deblock"), "pp", "vb/hb");	list["denoise_normal"] = Filter(tr("normal denoise"), "hqdn3d");	list["denoise_soft"] = Filter(tr("soft denoise"), "hqdn3d", "2:1:2");	// Audio	list["volnorm"] = Filter(tr("volume normalization"), "volnorm", "1");}

/* Function: SetExtSerialPacket ================================================ * Abstract: *  Sets (sends) the contents of an ExtSerialPacket on the comm line.  This *  includes the packet's buffer as well as all serial communication overhead *  associated with the packet. * *  EXT_NO_ERROR is returned on success, EXT_ERROR on failure. */PUBLIC boolean_T SetExtSerialPacket(ExtSerialPacket *pkt, ExtSerialPort *portDev){    uint32_T  i;    uint32_T  newByteCnt   = 0; /* Num bytes after filtering. */    boolean_T error        = EXT_NO_ERROR;    char Buffer[sizeof(uint32_T)*2]; /* Local buffer for converting escape chars. */    /* If not connected, return immediately. */    if (!portDev->fConnected) return false;    /* Initialize some fields of the packet. */    pkt->head[0]      = packet_head;    pkt->head[1]      = packet_head;    pkt->tail[0]      = packet_tail;    pkt->tail[1]      = packet_tail;    pkt->state        = ESP_NoPacket;    pkt->cursor       = 0;    pkt->DataCount    = 0;    pkt->inQuote      = false;    /* Send the packet header. */    error = ExtSerialPortSetData(portDev, pkt->head, HEAD_SIZE);    if (error != EXT_NO_ERROR) goto EXIT_POINT;    /* Send the packet type. */    newByteCnt = Filter(Buffer, &(pkt->PacketType), PACKET_TYPE_SIZE);    error = ExtSerialPortSetData(portDev, Buffer, newByteCnt);    if (error != EXT_NO_ERROR) goto EXIT_POINT;    /* Send the size of the packet buffer. */    newByteCnt = Num2String(Buffer, pkt->size, true, portDev->isLittleEndian);    error = ExtSerialPortSetData(portDev, Buffer, newByteCnt);    if (error != EXT_NO_ERROR) goto EXIT_POINT;    /* Send the variable-sized packet buffer data. */    for (i=0; i<pkt->size; i++)    {        newByteCnt = Filter(Buffer, &(pkt->Buffer[i]), 1);        error = ExtSerialPortSetData(portDev, Buffer, newByteCnt);        if (error != EXT_NO_ERROR) goto EXIT_POINT;    }    /* Send the packet tail. */    error = ExtSerialPortSetData(portDev, pkt->tail, TAIL_SIZE);    if (error != EXT_NO_ERROR) goto EXIT_POINT;   EXIT_POINT:    return error;} /* end SetExtSerialPacket */

void CheckDir( GtkWidget * list,char * directory ){ struct stat     fs; int             i; glob_t          gg; if ( !fsFilter[0] ) return; gtk_widget_hide( list ); gtk_clist_clear( GTK_CLIST( list ) ); clist_append_fname(list, ".",  dpixmap, dmask); clist_append_fname(list, "..", dpixmap, dmask); glob( "*",0,NULL,&gg ); for(  i=0;(unsigned)i<gg.gl_pathc;i++ )  {   stat( gg.gl_pathv[i],&fs );   if( !S_ISDIR( fs.st_mode ) ) continue;   clist_append_fname(list, gg.gl_pathv[i], dpixmap, dmask);  } globfree( &gg ); if ( strchr( fsFilter,',' ) )  {   char tmp[8];   int  i,c,glob_param = 0;   for ( i=0,c=0;i<(int)strlen( fsFilter ) + 1;i++,c++ )    {     tmp[c]=fsFilter[i];     if ( ( tmp[c] == ',' )||( tmp[c] == '/0' ) )      {       tmp[c]=0; c=-1;       glob( Filter( tmp ),glob_param,NULL,&gg );       glob_param=GLOB_APPEND;      }    }  } else glob( Filter( fsFilter ),0,NULL,&gg ); for(  i=0;(unsigned)i<gg.gl_pathc;i++ )  {   stat( gg.gl_pathv[i],&fs );   if(  S_ISDIR( fs.st_mode ) ) continue;   clist_append_fname(list, gg.gl_pathv[i], fpixmap, fmask);  } globfree( &gg ); gtk_clist_set_column_width( GTK_CLIST( list ),0,17 ); gtk_clist_select_row( GTK_CLIST( list ),0,1 ); gtk_widget_show( list );}

void Filterer::Plot(ChannelEvent *event_){	///The limits of the vertical axis	static float axisMin, axisMax;	// Draw the trace	if(event_->size != x_vals.size()){ // The length of the trace has changed.		resetGraph_ = true;	}	if (resetGraph_) {		ResetGraph(event_->size);		axisMax = 0;		axisMin = 1E9;	}		// Run the fast filter (trigger) on the trace.	Filter(event_->yvals, event_->size, fast_filter_y, trig_rise, trig_flat);		// Run the slow filter (energy) on the trace.	Filter(event_->yvals, event_->size, slow_filter_y, energy_rise, energy_flat);		for (size_t i = 0; i < event_->size ; i++) {		graph->SetPoint(i, x_vals[i], event_->yvals[i]);		f_fast->SetPoint(i, x_vals[i], fast_filter_y[i]);		f_slow->SetPoint(i, x_vals[i], slow_filter_y[i]);	}	if (graph->GetYaxis()->GetXmax() > axisMax) axisMax = graph->GetYaxis()->GetXmax(); 	if (graph->GetYaxis()->GetXmin() < axisMin) axisMin = graph->GetYaxis()->GetXmin(); 		if (f_fast->GetYaxis()->GetXmax() > axisMax) axisMax = f_fast->GetYaxis()->GetXmax(); 	if (f_fast->GetYaxis()->GetXmin() < axisMin) axisMin = f_fast->GetYaxis()->GetXmin(); 		if (f_slow->GetYaxis()->GetXmax() > axisMax) axisMax = f_slow->GetYaxis()->GetXmax(); 	if (f_slow->GetYaxis()->GetXmin() < axisMin) axisMin = f_slow->GetYaxis()->GetXmin(); 		graph->GetYaxis()->SetLimits(axisMin, axisMax);	graph->GetYaxis()->SetRangeUser(axisMin, axisMax);	graph->Draw("APL");	f_fast->Draw("LSAME");	f_slow->Draw("LSAME");	canvas->Update();	num_displayed++;	num_traces++;}

		bool initializeFilterCallBack(laser_package::update_filter::Request &req, laser_package::update_filter::Response &res)		{ 			Eigen::MatrixXd initial_state(5,1);						initial_state << req.initial_x, req.initial_x_velocity, req.initial_y, req.initial_y_velocity, req.initial_turn_rate;			filter_1 = Filter(initial_state, req.sampling_interval, noise_data[FILTER_1], UM);			filter_2 = Filter(initial_state, req.sampling_interval, noise_data[FILTER_2], CT);			updateStateMessage(&filter_1, &state_msg_1, req);			updateStateMessage(&filter_2, &state_msg_2, req);			state_pub_1.publish(state_msg_1);			state_pub_2.publish(state_msg_2);			ROS_INFO("Filter initialized");					}

Factory::Factory() {	this->m_filters.append(Filter(			QString::fromStdString(CurvatureProvider::getTitle()),			QString::fromStdString(CurvatureProvider::getName())));	this->m_filters.append(Filter(			QString::fromStdString(GeodesicProvider::getTitle()),			QString::fromStdString(GeodesicProvider::getName())));	this->m_filters.append(Filter(			QString::fromStdString(HarmonicProvider::getTitle()),			QString::fromStdString(HarmonicProvider::getName())));	this->m_filters.append(Filter(			QString::fromStdString(HeatKernelProvider::getTitle()),			QString::fromStdString(HeatKernelProvider::getName())));	this->m_filters.append(Filter(			QString::fromStdString(MidedgeProvider::getTitle()),			QString::fromStdString(MidedgeProvider::getName())));	this->m_filters.append(Filter(			QString::fromStdString(PartawareProvider::getTitle()),			QString::fromStdString(PartawareProvider::getName())));	this->m_filters.append(Filter(			QString::fromStdString(SamplingProvider::getTitle()),			QString::fromStdString(SamplingProvider::getName())));	this->m_filters.append(Filter(			QString::fromStdString(ThinPlateProvider::getTitle()),			QString::fromStdString(ThinPlateProvider::getName())));}

//*****************************************************************************//// Function : FMeter tick; called each time the OS tick timer is called//// Arguments: none//// Result   : none////*****************************************************************************void FMeterTick (void){	if (FMeterInitialized != 0)	{		if (FMeterMeasurementRunning == 1)		{			if (FMeterTickCounter == 0)			{				// Timer1 & Timer3 start counting now				TCCR1B = 7; // external pin is the source, rising edge				TCCR3B = 7;				EIMSK |= (1<<INT4);			}			else			{				// do nothing			}				FMeterTickCounter++;			if (FMeterTickCounter == (MEASUREMENT_TICKS + 1))			{				// Timer1 & Timer3 stop counting now				TCCR1B = 0; // Timer is stopped				TCCR3B = 0;					EIMSK &= ~(1<<INT4);				FMeterMeasurementRunning = 0;				FMeterMeasurementComplete = 1;								//Filter measurement values								FMeterTimerResult1 = Filter(TCNT1, FREQ1);				FMeterTimerResult3 = Filter(TCNT3, FREQ3);				FMeterTimerResultS = Filter(SpeedCounter, FREQS);				DetermineSpeed(FMeterTimerResultS);				FMeterStartMeasurement();			}					}	}}

void CServerBrowserFilter::CServerFilter::Sort(){	// create filtered list	Filter();	// sort	switch(g_Config.m_BrSort)	{	case IServerBrowser::SORT_NAME:		std::stable_sort(m_pSortedServerlist, m_pSortedServerlist+m_NumSortedServers, SortWrap(this, &CServerBrowserFilter::CServerFilter::SortCompareName));		break;	case IServerBrowser::SORT_PING:		std::stable_sort(m_pSortedServerlist, m_pSortedServerlist+m_NumSortedServers, SortWrap(this, &CServerBrowserFilter::CServerFilter::SortComparePing));		break;	case IServerBrowser::SORT_MAP:		std::stable_sort(m_pSortedServerlist, m_pSortedServerlist+m_NumSortedServers, SortWrap(this, &CServerBrowserFilter::CServerFilter::SortCompareMap));		break;	case IServerBrowser::SORT_NUMPLAYERS:		std::stable_sort(m_pSortedServerlist, m_pSortedServerlist+m_NumSortedServers, SortWrap(this,					(m_SortHash&IServerBrowser::FILTER_SPECTATORS) ? &CServerBrowserFilter::CServerFilter::SortCompareNumPlayers : &CServerBrowserFilter::CServerFilter::SortCompareNumClients));		break;	case IServerBrowser::SORT_GAMETYPE:		std::stable_sort(m_pSortedServerlist, m_pSortedServerlist+m_NumSortedServers, SortWrap(this, &CServerBrowserFilter::CServerFilter::SortCompareGametype));	}	m_SortHash = GetSortHash();}

void InfoPane::ResetText(){	try	{		file_info_.Clear();		if (photo_)		{			try			{				photo_->CompleteInfo(GetImageDataBase(true, true), file_info_);			}			catch (...)			{				ASSERT(false);			}		}		Filter(bar_.FilterText(), bar_.IsUnknownHidden());		if (img_preview_)			InvalidateRect(GetPreviewRect());	}	CATCH_ALL}

void DocDir::SaveDir(const String& package) const{	CreateDocDir(package);	FileOut out(DocFile(package, "dir.h"));	int q = dir.Find(package);	if(q >= 0) {		const ArrayMap<DocKey, Entry>& p = dir[q];		for(int i = 0; i < p.GetCount(); i++) {			const Entry& w = p[i];			if(w.type == NORMAL || w.type == EXTERNAL) {				const DocKey& k = p.GetKey(i);				out << "#ifdef INCLUDE_NAMESPACE_" <<				       Filter(k.nameing, CharFilterNameing) << "/r/n";				out << "//" << k.item << "/r/n";				out << "//" << k.nesting << "/r/n";				out << "//" << k.nameing << "/r/n";				out << "#include /"doc.dpp/";				out << w.text;				out << "/" //";				if(w.type == EXTERNAL)					out << "*";				out << LNGAsText(k.lang) << "/r/n";				out << "#endif/r/n/r/n";			}		}	}	SaveLinks(package);}

LRESULT CFileDiffDlg::OnDiffFinished(WPARAM, LPARAM){	CString sFilterText;	m_cFilter.GetWindowText(sFilterText);	m_cFileList.SetRedraw(false);	Filter(sFilterText);	if (!m_arFileList.IsEmpty())	{		// Highlight first entry in file list		m_cFileList.SetSelectionMark(0);		m_cFileList.SetItemState(0, LVIS_SELECTED, LVIS_SELECTED);	}	int mincol = 0;	int maxcol = m_cFileList.GetHeaderCtrl()->GetItemCount() - 1;	int col;	for (col = mincol; col <= maxcol; ++col)	{		m_cFileList.SetColumnWidth(col, LVSCW_AUTOSIZE_USEHEADER);	}	m_cFileList.ClearText();	if (m_arFileList.IsEmpty())		m_cFileList.ShowText(CString(MAKEINTRESOURCE(IDS_COMPAREREV_NODIFF)));	m_cFileList.SetRedraw(true);	InvalidateRect(NULL);	RefreshCursor();	EnableInputControl(true);	return 0;}

bool Gdb_MI2::SetBreakpoint(const String& filename, int line, const String& bp){	String file = Filter(host->GetHostPath(NormalizePath(filename)), CharFilterReSlash2);		// gets all breakpoints	MIValue bps = GetBreakpoints();		// line should start from 1...	line++;		// check wether we've got already a breakpoint here	// and remove it	MIValue brk = pick(bps.FindBreakpoint(file, line));	if(!brk.IsEmpty())		if(!MICmd(Format("break-delete %s", brk["number"].Get())))		{			Exclamation(t_("Couldn't remove breakpoint"));			return false;		}		if(bp.IsEmpty())		return true;	else if(bp[0] == 0xe)		return MICmd(Format("break-insert %s:%d", file, line));	else		return MICmd(Format("break-insert -c /"%s/" %s:%d", bp, file, line));}

int main(int argc, const char *argv[]){  const char *name = DEFAULT_NAME;  char buf[256];  if (argc>1)    {      name = argv[1];    }  sprintf(buf, "%s/i:img", name);  in_img.Register(buf);  sprintf(buf, "%s/o:img", name);  out_img.Register(buf);  sprintf(buf, "%s/i:mix", name);  in_mix.Register(buf);  sprintf(buf, "%s/o:box", name);  out_data.Register(buf);    box_thread.Begin();    while(1)    {      in_img.Read();      YARPImageOf<YarpPixelBGR> in;      YARPImageOf<YarpPixelBGR> out;      in.Refer(in_img.Content());      out_img.Content().SetID(YARP_PIXEL_BGR);      SatisfySize(in,out_img.Content());      out.Refer(out_img.Content());      Filter(in,out);      out_img.Write();//      YARPTime::DelayInSeconds(1000000);    }  return 0;}

void LayerConv::Backward(Layer *prev_layer) {  StartTimer();  prev_layer->deriv_mat_.resize(prev_layer->batchsize_, prev_layer->length_);  #if COMP_REGIME != 2    std::vector< std::vector<Mat> > prev_deriv, filters, deriv;    InitMaps(prev_layer->deriv_mat_, prev_layer->mapsize_, prev_deriv);     InitMaps(weights_.get(), filtersize_, filters);    InitMaps(deriv_mat_, mapsize_, deriv);    std::vector<size_t> padding_der(numdim_);    for (size_t i = 0; i < numdim_; ++i) {      padding_der[i] = filtersize_[i] - 1 - padding_[i];    }    prev_layer->deriv_mat_.assign(0);        #if COMP_REGIME == 1      #pragma omp parallel for num_threads(12) schedule(static,10)    #endif      for (int k = 0; k < batchsize_; ++k) {      #if COMP_REGIME == 1      //#pragma omp parallel for      #endif      for (size_t i = 0; i < outputmaps_; ++i) {              for (size_t j = 0; j < prev_layer->outputmaps_; ++j) {                                  Mat der_mat(prev_layer->mapsize_);          Filter(deriv[k][i], filters[i][j], padding_der, true, der_mat);          prev_deriv[k][j] += der_mat;                }            }            }  #else // GPU           ImgActs(deriv_mat_, weights_.get(), prev_layer->deriv_mat_,             prev_layer->mapsize_, filtersize_[0], padding_[0], !unshared_);          #endif  prev_layer->deriv_mat_.Validate();  MeasureTime("Backwards Conv Layer",1);}

void DAS(void){   int index;  static int i = 0;  unsigned short input;  static unsigned long LastTime;  // time at previous ADC sample    unsigned long thisTime;         // time at current ADC sample  long jitter;                    // time between measured and expected    if(NumSamples < RUNLENGTH){   // finite time run	//	GPIO_B0 ^= 0x01;      input = ADC_In(1);    	  thisTime = OS_Time();       // current time, 20 ns      DASoutput = Filter(input);      FilterWork++;        // calculation finished      if(FilterWork>1){    // ignore timing of first interrupt        jitter = ((OS_TimeDifference(thisTime,LastTime)-PERIOD)*CLOCK_PERIOD)/1000;  // in usec        if(jitter > MaxJitter){          MaxJitter = jitter;        }        if(jitter < MinJitter){          MinJitter = jitter;        }        // jitter should be 0        index = jitter+JITTERSIZE/2;   // us units        if(index<0)index = 0;        if(index>=JitterSize)index = JITTERSIZE-1;        JitterHistogram[index]++;       }      LastTime = thisTime; 	      }}

void MultidimensionalFilter::initialize(std::vector<float> initData, bool useButterworth, int dataSize){	inputDataSize = dataSize;	filters.resize(dataSize);	for (int i = 0; i < dataSize; i++){		filters[i] = Filter(initData[i], useButterworth);	}}

/* Function: Num2String ======================================================== * Abstract: *  Translates unsigned long values into strings and returns the size of the *  string. */PRIVATE uint32_T Num2String(char *dest,                            uint32_T value,                            boolean_T doFilter,                            boolean_T endianess){    char c[sizeof(uint32_T)];    unsigned int i;    unsigned int j;    numString temp;    temp.num = value;    if (!endianess) { /* big endian */        i = sizeof(uint32_T);        j = 0;        while (j<sizeof(uint32_T))        {            c[j] = temp.string[i-1];            j++;            i--;        };        memcpy(temp.string, c, sizeof(uint32_T));    }    if (doFilter) {        return Filter(dest, temp.string, sizeof(uint32_T));    }    else {        memcpy(dest, temp.string, sizeof(uint32_T));        return sizeof(uint32_T);    }} /* end Num2String */

//移动一个棋子严格到(fx,fy)-(jx,jy)线段上，以达到将军或者躲将的目的void MoveToFuckOrAvoid::Segment::    Fuck(int id, bool red, int fx, int fy, int jx, int jy){    //red表示当前是走红还是走黑，(fx, fy)表示车，(jx, jy)表示将    string str = red? "JCMPXSB" : "jcmpxsb";    for(int i = 0; i < nrow; i++){        for(int j = 0; j < ncol; j++){            if(!red && !isBlack(id, i, j)) continue;            else if(red && !isRed(id, i, j)) continue;            char c = d[id].At(i, j);            int dx[5], dy[5], n = 0;            if(c == str[1]) Che_segment(id, i, j, fx, fy, jx, jy, dx, dy, n);            else if(c == str[2]) Ma_segment(id, i, j, fx, fy, jx, jy, dx, dy, n);            else if(c == str[3]) Che_segment(id, i, j, fx, fy, jx, jy, dx, dy, n);//没错            else if(c == str[4]) Xiang_segment(id, i, j, fx, fy, jx, jy, dx, dy, n);            else if(c == str[5]) Shi_segment(id, i, j, fx, fy, jx, jy, dx, dy, n);            else if(c == str[6]) Bin_segment(id, red, i, j, fx, fy, jx, jy, dx, dy, n);            for(int k = 0; k < n; k++){                if(d[id].At(dx[k], dy[k]) != '_') continue;                if(red) Newd(id, fx, fy, i, j, dx[k], dy[k]);                else Newd(id, -1, -1, i, j, dx[k], dy[k]);                Filter(red);            }        }    }}

void CServerBrowser::Sort(bool IgnoreLazy){	int i;	// create filtered list	Filter();	if(!IgnoreLazy && g_Config.m_BrLazySorting && IsRefreshing() && LoadingProgression() < 90)		return;	// sort	if(g_Config.m_BrSort == IServerBrowser::SORT_NAME)		std::stable_sort(m_pSortedServerlist, m_pSortedServerlist+m_NumSortedServers, SortWrap(this, &CServerBrowser::SortCompareName));	else if(g_Config.m_BrSort == IServerBrowser::SORT_PING)		std::stable_sort(m_pSortedServerlist, m_pSortedServerlist+m_NumSortedServers, SortWrap(this, &CServerBrowser::SortComparePing));	else if(g_Config.m_BrSort == IServerBrowser::SORT_MAP)		std::stable_sort(m_pSortedServerlist, m_pSortedServerlist+m_NumSortedServers, SortWrap(this, &CServerBrowser::SortCompareMap));	else if(g_Config.m_BrSort == IServerBrowser::SORT_NUMPLAYERS)		std::stable_sort(m_pSortedServerlist, m_pSortedServerlist+m_NumSortedServers, SortWrap(this,					g_Config.m_BrFilterSpectators ? &CServerBrowser::SortCompareNumPlayers : &CServerBrowser::SortCompareNumClients));	else if(g_Config.m_BrSort == IServerBrowser::SORT_GAMETYPE)		std::stable_sort(m_pSortedServerlist, m_pSortedServerlist+m_NumSortedServers, SortWrap(this, &CServerBrowser::SortCompareGametype));	// set indexes	for(i = 0; i < m_NumSortedServers; i++)		m_ppServerlist[m_pSortedServerlist[i]]->m_Info.m_SortedIndex = i;	str_copy(m_aFilterGametypeString, g_Config.m_BrFilterGametype, sizeof(m_aFilterGametypeString));	str_copy(m_aFilterString, g_Config.m_BrFilterString, sizeof(m_aFilterString));	m_Sorthash = SortHash();}

String MakeBuild::OutDir(const Index<String>& cfg, const String& package, const VectorMap<String, String>& bm,                   bool use_target){	Index<String> excl;	excl.Add(bm.Get("BUILDER", "GCC"));	excl.Add("MSC");	LocalHost().AddFlags(excl);	Vector<String> x;	bool dbg = cfg.Find("DEBUG_FULL") >= 0 || cfg.Find("DEBUG_MINIMAL") >= 0;	if(cfg.Find("DEBUG") >= 0) {		excl.Add("BLITZ");		if(cfg.Find("BLITZ") < 0)			x.Add("NOBLITZ");	}	else		if(dbg)			x.Add("RELEASE");	if(use_target)		excl.Add("MAIN");	for(int i = 0; i < cfg.GetCount(); i++)		if(excl.Find(cfg[i]) < 0)			x.Add(cfg[i]);	Sort(x);	for(int i = 0; i < x.GetCount(); i++)		x[i] = InitCaps(x[i]);	String outdir = GetVar("OUTPUT");	if(output_per_assembly)		outdir = AppendFileName(outdir, GetVarsName());	if(!use_target)		outdir = AppendFileName(outdir, package);	outdir = AppendFileName(outdir, GetFileTitle(method) + "." + Join(x, "."));	outdir = Filter(outdir, CharFilterSlash);	return outdir;}