segmenterms.cpp

这是一个分水岭程序

					nauto_loop(final_T, selected, my_class,&my_contor);
					mean_s(my_contor, _p, selected, _data, final_T);
					L = T[rect][0] - final_T[0]; 
					U = T[rect][1] - final_T[1];
					V = T[rect][2] - final_T[2]; 
					RAD2 = L*L + U*U + V*V; 					
					if(RAD2<0.1)
					{
						break;
					}else
					{
						T[rect][0] = final_T[0];
						T[rect][1] = final_T[1];
						T[rect][2] = final_T[2];
					} 
				} // end of set auto_segm
			}
		} //end of while(gen_contor++<how_many)
		
		if(auto_segm)
		{
			if(option==0) test_neigh(my_class, selected, &my_contor,2);
			else if(option==1) test_neigh(my_class, selected, &my_contor,1);
			else if(option==2) test_neigh(my_class, selected, &my_contor,0);
		}      
#ifdef TRACE   
		printf("my_contor = %d contor_trials = %d",my_contor,contor_trials);  
#endif	
		if(!auto_segm)
		{
			if(test_same_cluster(rect,T))
			{
				delete [] my_class; delete [] sel_col; delete [] selected;
				continue;
			}
		}
		if(auto_segm && my_contor<act_threshold)
		{
			delete [] my_class; delete [] sel_col; delete [] selected;
			if(contor_trials++<MAX_TRIAL) goto MS;
			else                          break;
		}
		
		if(auto_segm) my_actual(my_class);
		
		my_convert(selects, final_T, TI[rect]);  
		for ( k=0; k<_ro_col; k++ )
		{
			if(my_class[k])
			{
				gen_class[k]=rect;
			}
		}
		
		delete [] my_class; delete [] sel_col; delete [] selected;
    } //end of for ( rect = 0; rect < n_rects; rect++ )
	
	n_rects = rect;
	Octet** isegment = new Octet*[3];	
	register int j;
	for ( j=0; j<3; j++ )
    {
		isegment[j] = new Octet[_ro_col];
		memset( isegment[j], 0, _ro_col );
    }
	Octet *isegment0=isegment[0]; Octet *isegment1=isegment[1];
	Octet *isegment2=isegment[2];
	
	if (auto_segm)
    {
		Octet *my_class = new Octet[_ro_col];
		for ( k=0; k<_ro_col; k++ )
		{
			if(gen_class[k]==255)
			{
				gen_class[k]=n_rects;
			}
		}
		
		Octet inv_map[Max_rects];
		for(k=0;k<n_rects;k++)
		{
			inv_map[k]=k;
		}
		
		if(option==0)  conn_comp(my_class,&n_rects,inv_map,T,10,0);
		else if(option==1) conn_comp(my_class,&n_rects,inv_map,T,20,0); 
		else conn_comp(my_class,&n_rects,inv_map,T,act_threshold,0);
		
		optimize(T, n_rects);
		
		for(k=0; k<n_rects; k++)
		{
			my_convert(selects, T[k], TI[k]);
		}
		
		// Postprocessing
		if(option==1 || option ==2)
		{
			for(k=2; k<10; k+=2) 
			{
				conn_comp(my_class,&n_rects,inv_map,T,k,1);
			}
		}
#ifdef TRADE
		printf("\nTime = %d seconds\n",time(0)-t);
#endif 
		register Octet my_max_ind; 
		for ( k=0; k<_ro_col; k++ )
		{
			my_max_ind = gen_class[k];
			if ( my_max_ind != n_rects )
			{
				int *ti = TI[my_max_ind];
				isegment0[k]=ti[0]; 
				isegment1[k]=ti[1]; 
				isegment2[k]=ti[2];
			} 
		}
		
		// Save the borders
		memset(my_class,255,_ro_col); 
		for ( k=0; k<_ro_col; k++ )
		{
			int pres_class=gen_class[k];
			int pos_colms=k%_colms;
			
			if ( pos_colms==0 || pos_colms==(_colms-1) ||
				k<(_colms-1) || k>(_ro_col-_colms) )
			{
				my_class[k] = 0;
			}
			else
			{
				for (j=1; j<8; j+=2)
				{
					int u=k+my_neigh[j];
					if(u>=0 && u<_ro_col &&  (pres_class<gen_class[u]))
					{
						my_class[k] = 0; break;
					}
				}
			}
		}// end of for ( k = 0; k < _ro_col; k++ ) 
		
		my_write_Contour_file( "debug\\result.jpg", my_class, _rows, _colms);
		SaveContour2Buf(my_class, _rows, _colms);
		delete [] my_class;
    }else  // if not auto_segmentation
    {
		optimize(T,n_rects);
		for(k=0;k<n_rects;k++)
		{
    		my_convert(selects, T[k], TI[k]);
		}
		register int temp_class;
		for (k=0; k<_ro_col; k++)
		{
			temp_class = gen_class[k];
            if( temp_class<n_rects )
			{
				isegment0[k] = /*TI[temp_class][0];*/pic->chdata(0)[k];
				isegment1[k] = /*TI[temp_class][1];*/pic->chdata(1)[k];
				isegment2[k] = /*TI[temp_class][2];*/pic->chdata(2)[k];
			}
		} 
	} 
	
	if(auto_segm)
	{
		delete [] _m_col_remain; 
		delete [] _col_remain;
		delete [] gen_remain;
	}
	delete [] gen_class;
	delete [] _col_index;
	delete [] _col0; delete [] _col1; delete [] _col2; 
	delete [] _col_all;
	
	XfRaster::Info	info;
	pic->raster_info(info);
	result_ras_ = new RasterIpChannels( info, 3, eDATA_OCTET,
		isegment, true );
	cerr << endl << "Original Colors: " << _n_colors << endl;
	cerr << "Segment. Colors: " << n_rects << endl;
	
	return true;  
}

void SegmenterMS::SaveContour2Buf(Octet* signal, int _rows, int _colms)
//保存结果轮廓
{
	INT w = _colms;
	INT h = _rows;
	
	if (result_contour!=NULL)
	{
		delete [] result_contour; result_contour = NULL;
	}
	result_contour = new BOOL[w*h];
	
	for (INT y=0; y<h; y++)
	{
		INT lstart = y * w;
		for (INT x=0; x<w; x++)
		{
			INT pos = lstart + x;
			if (signal[pos]>0)
			{
				result_contour[pos] = TRUE;
			}else
			{
				result_contour[pos] = FALSE;
			}
		}
	}	
	
}

Boolean SegmenterMS::my_write_Contour_file( CString outfname, Octet* signal,int _rows, int _colms )
//输出结果轮廓图像；
{
/* by dzj;
ofstream fp( fname, ios::out );
if ( fp.fail() )
return false;

  fp << "P5\n" << _colms << ' ' << _rows<< "\n255" << endl;
  fp.write(signal,_rows*_colms);
  fp.close( );
	*/
	CImageObject myresult;
	INT w = _colms;
	INT h = _rows;
	BYTE* resultdata = new BYTE[w*h*3];
	for (INT y=0; y<h; y++)
	{
		INT lstart = y * w;
		for (INT x=0; x<w; x++)
		{
			INT pos = lstart + x;
			resultdata[pos*3] = (BYTE) signal[pos];
			resultdata[pos*3+1] = (BYTE) signal[pos];
			resultdata[pos*3+2] = (BYTE) signal[pos];
		}
	}
	myresult.CreateDIBFromBits( w, h, resultdata);
	myresult.SaveToFile(outfname);
	return true;
}

Boolean SegmenterMS::write_Result_file( CString outfname, RasterIpChannels* signal )
{
	Octet *temp0 = signal->chdata_[0];
	Octet *temp1 = signal->chdata_[1];
	Octet *temp2 = signal->chdata_[2]; 
	int width = signal->columns_;
	int height = signal->rows_;
	
	BYTE* imagedata = new BYTE[width*height*3];
	for (int y=0; y<height; y++)
	{
		int lstart = y * width;
		for (int x=0; x<width; x++)
		{
			int orgpos = (lstart + x);
			int outpos = orgpos * 3;
			imagedata[outpos] = temp2[orgpos];
			imagedata[outpos+1] = temp1[orgpos];
			imagedata[outpos+2] = temp0[orgpos];
		}
	}
	
	CImageObject* myimage = new CImageObject;
	myimage->CreateDIBFromBits(width, height, imagedata);
	myimage->SaveToFile(outfname);
	return true;
}

//add by dzj;
RasterIpChannels* SegmenterMS::read_IMG_file( CString filename )
{
	Octet**	datain = new Octet*[p_max];
	int	w, h;
    CImageObject* myimage = new CImageObject(filename);
	w = myimage->GetWidth();
	h = myimage->GetHeight();
	BYTE* imagedata = new BYTE[w*h*3];
	myimage->LoadDIBToBuf(imagedata);
	
	for ( INT i = 0; i < p_max; i++ ) 
	{
		datain[i] = new Octet[w * h];
	}
	
	for ( int j = 0; j < h; j++ ) 
	{
		int lstart = j*w;
		for ( int i = 0; i < w; i++ ) 
		{
			int lpos = (lstart + i);
			datain[0][lpos] = imagedata[lpos*3+2];
			datain[1][lpos] = imagedata[lpos*3+1];
			datain[2][lpos] = imagedata[lpos*3];
		}
	}
	
	delete [] imagedata; imagedata = NULL;
	delete myimage; myimage = NULL;
	
	XfRaster::Info	info;
	info.rows = h;
	info.columns = w;
	info.origin_x = 0;
	info.origin_y = 0;
	return (new RasterIpChannels( info, p_max, eDATA_OCTET,
				    datain, true ) );
}

// Class constructor
// The `data' may be taken away from the caller in order to
// avoid time-consuming copying of the data.  However,
// the caller has to give explicit permission for this.
RasterIpChannels::RasterIpChannels(
								   const XfRaster::Info& info, const int n_channels,
								   const DataType dtype, Octet* data[], const Boolean do_take
								   ) {
    rows_ = info.rows;
    columns_ = info.columns;
    dtype_ = dtype;
    clipf_ = false;
    n_channels_ = n_channels;
    if (n_channels_ == 0) {
		n_channels_ = 1;
    }
    size_t size = (size_t)(rows_ * columns_);
    chdata_ = new Octet*[n_channels_];
    for (int channel = 0; channel < n_channels_; channel++) {
		if ( do_take == true ) {	// take over the data from the caller
			chdata_[channel] = (Octet* )data[channel];
			data[channel] = nil;
		} else {
			if ( dtype_ == eDATA_FLOAT )	    size *= sizeof(float);
			chdata_[channel] = new Octet[size];
			if (data != nil && data[channel] != nil) {
				memmove( chdata_[channel], data[channel], size );
			} else {
				memset( chdata_[channel], 0, size );
			}
		}
    }
	delete [] data;     
}

RasterIpChannels::~RasterIpChannels() {
    for (int channel = 0; channel < n_channels_; channel++) {
		if (chdata_[channel])   delete [] chdata_[channel];
		chdata_[channel] = nil;
    }
    delete [] chdata_;
}

// RANGE forces `a' to be in the range [b..c] (inclusive)
inline void RANGE( int& a, const int b, const int c )
{
	if ( a < b ) {
		a = b;
	} else if ( a > c ) {
		a = c;
	}
}

void RasterIpChannels::raster_info(Info& i) {
    i.rows = rows_;
    i.columns = columns_;
    i.origin_x = 0;
    i.origin_y = 0;
}

// Move floating point array to Octet array, i.e. to [0..255]
// The result is either scaled to the range [0..255] or
// clipped to this range, depending on the flag `clipf'.
// Note:  Handles only 1-Octet per pixel pictures
// (i.e. mono/pseudo color pictures)
Octet** RasterIpChannels::raster_float_to_Octet(
												RasterIpChannels& ras
												) {
    assert( ras.dtype() == eDATA_FLOAT );
	
    float	maxv = (float) -1.0e38;
    XfRaster::Info	info;
    ras.raster_info(info);
    size_t	size = (size_t)(info.rows * info.columns);
	
    Octet**	data = ras.chdata();
    int			channels = ras.n_channels();
    Octet**	picRes = new Octet*[channels];
    int			i;
    for ( i = 0; i < channels; i++ )
		picRes[i] = new Octet[ size ];
	
    if ( ras.clipf() == true ) {  // clip the values outside the range [0..255]
		int	p;
		for ( i = 0; i < channels; i++ ) {
			register float*		ptr1 = (float* )data;
			register Octet*	ptr2 = picRes[i];
			for ( register int off = 0; off < size; off++, ptr1++, ptr2++ ) {
				p = int(*ptr1);
				RANGE( p, 0, 255 );
				*ptr2 = Octet(p);
			}
		}
    } else {			// scale the values to the range [0..255]
		for ( i = 0; i < channels; i++ ) {
			float			minv = (float) 1.e38;
			float			maxv = (float) -1.e38;
			register float*		ptr1 = (float* ) data[i];
			register Octet*	ptr2 = picRes[i];
			register int	off;
			for ( off = 0; off < size; off++, ptr1++ ) {
				if ( *ptr1 < minv )   minv = *ptr1;
				if ( *ptr1 > maxv )   maxv = *ptr1;
			}
			ptr1 = (float* ) data[i];
			float	ratio = (float) 255.0 / (maxv - minv);
			for ( off = 0; off < size; off++, ptr1++, ptr2++ )
				*ptr2 = Octet( (*ptr1 - minv) * ratio );
		}
    }
    return ( picRes );
}