Exemplo n.º 1
0
/*---------------------------------------------------------------------------
 *            FindBipResponder()
 *---------------------------------------------------------------------------
 *
 * Synopsis:  Return the BIP Responder channel given the ObexServerApp pointer.
 *
 * Return:    BipObexClient* or BipObexServer*
 */
void *FindBipResponder(void *app)
{
    I8 i;

    /* Go through the BIP server array. */
    for (i = 0; i < BIP_NUM_RESPONDERS; i++) {
        if (BIP(responder)[i] && &BIP(responder)[i]->primary.sApp == app) {
            return &(BIP(responder)[i]->primary);
        }
    }

    return 0;
}
Exemplo n.º 2
0
/*---------------------------------------------------------------------------
 *            FindBipInitiator()
 *---------------------------------------------------------------------------
 *
 * Synopsis:  Return the BIP Initiator channel given the ObexClientApp pointer.
 *
 * Return:    BipObexClient* or BipObexServer*
 */
void *FindBipInitiator(void *app)
{
    I8 i;

    /* Go through the BIP client array. */
    for (i = 0; i < BIP_NUM_INITIATORS; i++) {
        if (BIP(initiator)[i] && &BIP(initiator)[i]->primary.cApp == app) {
            return &(BIP(initiator)[i]->primary);
        }
    }

    return 0;
}
Exemplo n.º 3
0
//Color one blob for one thread
void ColorBlob( cv::Mat BinImPad, std::vector< std::pair<int,int> > *indices,
	const int &start, const int &end, unsigned char &current_index, unsigned char &replace_ind ){
  //Check the 8-connected neighborhood and set them if they are within bounds
  std::pair<int,int> CI = indices->back();
  indices->pop_back();
  if( (CI.second-1)>=start ){//Bounds checking for current thread
    for( int i=-1; i<2; ++i ) if( BIP((CI.first+i),(CI.second-1)) ==replace_ind ){
      BIP( (CI.first+i),(CI.second-1) ) = current_index;
      std::pair<int,int> PushInd( (CI.first+i),(CI.second-1) );
      indices->push_back( PushInd );
    }
  }
  if( (CI.second+1)<end ){//Bounds checking for next thread
    for( int i=-1; i<2; ++i ) if( BIP((CI.first+i),(CI.second+1)) ==replace_ind ){
      BIP( (CI.first+i),(CI.second+1) ) = current_index;
      std::pair<int,int> PushInd( (CI.first+i),(CI.second+1) );
      indices->push_back( PushInd );
    }
  }
  if( BIP((CI.first-1),(CI.second))==replace_ind ){
    BIP( (CI.first-1),(CI.second) ) = current_index;
    std::pair<int,int> PushInd( (CI.first-1),(CI.second) );
    indices->push_back( PushInd );

  }
  if( BIP((CI.first+1),(CI.second))==replace_ind ){
    BIP( (CI.first+1),(CI.second) ) = current_index;
    std::pair<int,int> PushInd( (CI.first+1),(CI.second) );
    indices->push_back( PushInd );
  }
  if(!indices->empty()){
    ColorBlob( BinImPad, indices, start, end, current_index, replace_ind );
  }
}
Exemplo n.º 4
0
/*---------------------------------------------------------------------------
 *            BipAppCallBack()
 *---------------------------------------------------------------------------
 *
 * Synopsis:  Call the application with the specified event.
 *
 * Return:    
 */
void BipAppCallBack(BipCallbackParms *parms, U16 status, BipEvent event)
{
    BipCallback     callback = 0;       /* Application callback function */

    parms->status = status;
    parms->event = event;
    parms->channel = parms->obex.client->channel;

    switch (parms->channel) {
#if BIP_NUM_INITIATORS > 0
    case BIPCH_INITIATOR_PRIMARY:
    case BIPCH_INITIATOR_SECONDARY:
    callback = BIP(initiatorCallback);
        break;
#endif

#if BIP_NUM_RESPONDERS > 0
    case BIPCH_RESPONDER_PRIMARY:
    case BIPCH_RESPONDER_SECONDARY:
    callback = BIP(responderCallback);
        break;
#endif

    default:
        break;
    }

    /* Copy the channel data pointer into parms */
    switch (parms->channel) {
    case BIPCH_INITIATOR_PRIMARY:
    case BIPCH_RESPONDER_SECONDARY:
        parms->data = parms->obex.client->data;
        break;

    case BIPCH_INITIATOR_SECONDARY:
    case BIPCH_RESPONDER_PRIMARY:
        parms->data = &parms->obex.server->request;
        break;

    default:
        break;
    }
    Assert(callback);
    callback(parms);
}
Exemplo n.º 5
0
//Computes the area and the centroid for a given label
bool GetStats(cv::Mat LabelIm, int i, int j, cv::Mat BinImPad, std::vector<int> &one_stat){
  //Seed with the first pixel
  std::pair<int,int> seed(i,j);
  std::vector< std::pair<int,int> > indices, queueue;
  indices.push_back(seed); queueue.push_back(seed);
  BIP(i,j) = 0;
  double x_men = 0, y_men = 0; //centroid

  //Find indices of all pixels with the same label
  while( !queueue.empty() ){
    std::pair<int, int> index = queueue.back();
    queueue.pop_back();
    //Check 8-neighborhood
    for( int k=-1; k<2; ++k )
      for( int l=-1; l<2; ++l )
	if( (k==0) && (l==0) ) continue;
	  else{
	    if( BIP( (index.first+k),(index.second+l) ) ){
	      std::pair<int,int> sed( (index.first+k),(index.second+l) );
	      queueue.push_back( sed );
	      indices.push_back( sed );
	      LabelIm.at<unsigned char>( sed.first, sed.second ) = BIP( sed.first,sed.second );
	      BIP( sed.first, sed.second ) = 0;
	      x_men += sed.first;
	      y_men += sed.second;
	    }
          }
  }
  x_men = round(x_men/((double)indices.size()));
  y_men = round(y_men/((double)indices.size()));
  one_stat[1] = indices.size();
  one_stat[2] = (int)x_men;
  one_stat[3] = (int)y_men;

  if( (indices.size())>=15 ){ return true; }
  else{
    std::vector< std::pair<int,int> >::iterator it;
    for( it=indices.begin() ; it < indices.end(); ++it )
      LabelIm.at<unsigned char>(it->first, it->second) = 0;
    return false;
  }
}
Exemplo n.º 6
0
//This function binarizes the nuclei in an image and colors connected components
void computebin(cv::Mat src, cv::Mat BinImPad, cv::Mat BinIm ){
  //Get Image Dimensions
  int thresh = GetThresh(src);
  int nthreads, tid;

  #pragma omp parallel private(tid,nthreads)
  {
    tid = omp_get_thread_num();
    nthreads = omp_get_num_threads();
    int start, end;
    start = tid*(rows/nthreads);
    end   = (tid+1)*(rows/nthreads);
    if( tid == (nthreads-1) ) end = rows;
    for( int j=start; j<rows; ++j )
      for( int i=0; i<cols; ++i )
	if( src.at<unsigned char>(i,j) > thresh  ){
	  BinIm.at<unsigned char>(i,j)  = 0;
	  BIP((i+1),(j+1))	 	= 0;
	}
	else{
	  BinIm.at<unsigned char>(i,j)	= 255;
	  BIP((i+1),(j+1)) 		= UCHAR_MAX;
	}
  }

  //Set the borders of the padded image
  for( int i=0; i<(cols+2); ++i ){
    BIP(i,0)		= 0;
    BIP(i,(rows+1))	= 0;
  }
  for( int i=1; i<(rows+2); ++i ){
    BIP(0,i)		= 0;
    BIP((cols+1),i)	= 0;
  }

  if(write_files){
    std::string out_str1 = "binary_" + file_open;
    cv::imwrite(out_str1.c_str(),BinIm);
  }
  std::cout<<"The threshold is: "<<thresh<<std::endl;
}
Exemplo n.º 7
0
int main(int argc, char *argv[])
{
	{
		libmaus2::lz::LineSplittingGzipOutputStream LSG("gzsplit",4,17);
		
		for ( uint64_t i = 0; i < 17; ++i )
			LSG << "line_" << i << "\n";		
	}

	{
		libmaus2::lz::LineSplittingGzipOutputStream LSG("nogzsplit",4,17);		
	}

	testGzip();
	testlz4();

	#if 0
	maskBamDuplicateFlag(std::cin,std::cout);
	return 0;
	#endif

	#if 0
	{
		libmaus2::lz::BgzfInflateDeflateParallel BIDP(std::cin,std::cout,Z_DEFAULT_COMPRESSION,32,128);
		libmaus2::autoarray::AutoArray<char> B(64*1024,false);
		int r;
		uint64_t t = 0;
		uint64_t last = std::numeric_limits<uint64_t>::max();
		uint64_t lcnt = 0;
		uint64_t const mod = 64*1024*1024;
		libmaus2::timing::RealTimeClock rtc; rtc.start();
		libmaus2::timing::RealTimeClock lrtc; lrtc.start();

		while ( (r = BIDP.read(B.begin(),B.size())) )
		{
			BIDP.write(B.begin(),r);
			
			lcnt += r;
			t += r;
			
			if ( t/mod != last/mod )
			{
				if ( isatty(STDERR_FILENO) )
					std::cerr 
						<< "\r" << std::string(60,' ') << "\r";

				std::cerr
						<< rtc.formatTime(rtc.getElapsedSeconds()) << " " << t/(1024*1024) << "MB, " << (lcnt/lrtc.getElapsedSeconds())/(1024.0*1024.0) << "MB/s";
				
				if ( isatty(STDERR_FILENO) )
					std::cerr << std::flush;
				else
					std::cerr << std::endl;
				
				lrtc.start();
				last = t;
				lcnt = 0;
			}
		}

		if ( isatty(STDERR_FILENO) )
			std::cerr 
				<< "\r" << std::string(60,' ') << "\r";

		std::cerr
				<< rtc.formatTime(rtc.getElapsedSeconds()) << " " << t/(1024*1024) << "MB, " << (t/rtc.getElapsedSeconds())/(1024.0*1024.0) << "MB/s";
				
		std::cerr << std::endl;

			
		return 0;
	}
	#endif                                                                                                                                                                            

	#if 0
	{
		::libmaus2::lz::BgzfDeflateParallel BDP(std::cout,32,128,Z_DEFAULT_COMPRESSION);
		
		while ( std::cin )
		{
			libmaus2::autoarray::AutoArray<char> B(16384);
			std::cin.read(B.begin(),B.size());
			int64_t const r = std::cin.gcount();
			
			BDP.write(B.begin(),r);
		}
		
		BDP.flush();
		std::cout.flush();
	}
	
	return 0;
	#endif

	#if 0
	{
		try
		{
			libmaus2::lz::BgzfInflateParallel BIP(std::cin /* ,4,16 */);
			uint64_t c = 0;
			uint64_t b = 0;
			uint64_t d = 0;
			libmaus2::timing::RealTimeClock rtc; rtc.start();
			libmaus2::autoarray::AutoArray<uint8_t> adata(64*1024,false);
		
			while ( (d=BIP.read(reinterpret_cast<char *>(adata.begin()),adata.size())) != 0 )
			{
				b += d;
				if ( ++c % (16*1024) == 0 )
				{
					std::cerr << c << "\t" << b/(1024.0*1024.0*1024.0) << "\t" << static_cast<double>(b)/(1024.0*1024.0*rtc.getElapsedSeconds()) << " MB/s" << std::endl;
				}
			}
		
			std::cerr << c << "\t" << b/(1024.0*1024.0*1024.0) << "\t" << static_cast<double>(b)/(1024.0*1024.0*rtc.getElapsedSeconds()) << " MB/s" << std::endl;
			std::cerr << "decoded " << b << " bytes in " << rtc.getElapsedSeconds() << " seconds." << std::endl;
		}
		catch(std::exception const & ex)
		{
			std::cerr << ex.what() << std::endl;
			return EXIT_FAILURE;
		}
	}

	return 0;
	#endif

	std::cerr << "Testing random data on bgzf...";
	testBgzfRandom();
	std::cerr << "done." << std::endl;

	std::cerr << "Testing mono...";	
	testBgzfMono();
	std::cerr << "done." << std::endl;

	::libmaus2::lz::BgzfDeflate<std::ostream> bdefl(std::cout);
	char const * str = "Hello, world.\n";
	bdefl.write(reinterpret_cast<char const *>(str),strlen(str));
	bdefl.flush();
	bdefl.write(reinterpret_cast<char const *>(str),strlen(str));
	bdefl.flush();
	bdefl.addEOFBlock();
	return 0;
	
	::libmaus2::lz::BgzfInflateStream SW(std::cin);

	::libmaus2::autoarray::AutoArray<char> BB(200,false);	
	while ( SW.read(BB.begin(),BB.size()) )
	{
	
	}

	if ( argc < 2 )
		return EXIT_FAILURE;
	
	
	return 0;
	
	#if 0
	::libmaus2::lz::GzipHeader GZH(argv[1]);
	return 0;
	#endif

	std::ostringstream ostr;
	::libmaus2::autoarray::AutoArray<uint8_t> message = ::libmaus2::util::GetFileSize::readFile(argv[1]);
	
	std::cerr << "Deflating message of length " << message.size() << "...";
	::libmaus2::lz::Deflate DEFL(ostr);
	DEFL.write ( reinterpret_cast<char const *>(message.begin()), message.size() );
	DEFL.flush();
	std::cerr << "done." << std::endl;
	
	std::cerr << "Checking output...";
	std::istringstream istr(ostr.str());
	::libmaus2::lz::Inflate INFL(istr);
	int c;
	uint64_t i = 0;
	while ( (c=INFL.get()) >= 0 )
	{
		assert ( c == message[i] );
		i++;
	}
	std::cerr << "done." << std::endl;
	
	// std::cerr << "Message size " << message.size() << std::endl;
	
	std::string testfilename = "test";
	::libmaus2::lz::BlockDeflate BD(testfilename);
	BD.write ( message.begin(), message.size() );
	BD.flush();
	
	uint64_t const decpos = message.size() / 3;
	::libmaus2::lz::BlockInflate BI(testfilename,decpos);
	::libmaus2::autoarray::AutoArray<uint8_t> dmessage (message.size(),false);
	uint64_t const red = BI.read(dmessage.begin()+decpos,dmessage.size());
	assert ( red == dmessage.size()-decpos );
	
	std::cerr << "(";
	for ( uint64_t i = decpos; i < message.size(); ++i )
		assert ( message[i] == dmessage[i] );
	std::cerr << ")\n";
	
	std::string shortmes1("123456789");
	std::string shortmes2("AA");
	std::string shortmes3("BB");
	std::string shortmes4("CC");
	
	std::string textfile1("test1");
	std::string textfile2("test2");
	std::string textfile3("test3");
	std::string textfile4("test4");
	
	::libmaus2::lz::BlockDeflate BD1(textfile1);
	BD1.write ( reinterpret_cast<uint8_t const *>(shortmes1.c_str()), shortmes1.size() );
	BD1.flush();

	::libmaus2::lz::BlockDeflate BD2(textfile2);
	BD2.write ( reinterpret_cast<uint8_t const *>(shortmes2.c_str()), shortmes2.size() );
	BD2.flush();

	::libmaus2::lz::BlockDeflate BD3(textfile3);
	BD3.write ( reinterpret_cast<uint8_t const *>(shortmes3.c_str()), shortmes3.size() );
	BD3.flush();

	::libmaus2::lz::BlockDeflate BD4(textfile4);
	BD4.write ( reinterpret_cast<uint8_t const *>(shortmes4.c_str()), shortmes4.size() );
	BD4.flush();
	
	std::vector < std::string > filenames;
	filenames.push_back(textfile1);
	filenames.push_back(textfile2);
	filenames.push_back(textfile3);
	filenames.push_back(textfile4);
	
	for ( uint64_t j = 0; j <= 15; ++j )
	{
		::libmaus2::lz::ConcatBlockInflate CBI(filenames,j);

		for ( uint64_t i = 0; i < j; ++i )
			std::cerr << ' ';
		for ( uint64_t i = 0; i < CBI.n-j; ++i )
			std::cerr << (char)CBI.get();
		std::cerr << std::endl;
	}
		
	return 0;
}
Exemplo n.º 8
0
void computeLabels(cv::Mat src, cv::Mat BinImPad){
  cv::Mat LabelIm  = cvCreateMat(cols,rows,src.type());
  for( int j=0; j<rows; ++j )
    for( int i=0; i<cols; ++i ) LabelIm.at<unsigned char>(i,j)=0;
  int nthreads, tid;
  //omp_set_num_threads(4);
  bool redo_coloring = true;
  #pragma omp parallel private(tid,nthreads)
  {
    //Color blob recursively as soon as a pixel in FG is found
    tid = omp_get_thread_num();
    nthreads = omp_get_num_threads();
    int end1;
    unsigned char start_index, label_index;
    label_index = UCHAR_MAX * tid / nthreads;
    ++label_index; start_index = label_index;
    const int start = tid*(rows/nthreads) + 1;
    end1 = (tid+1)*(rows/nthreads) + 1;
    if( tid==(nthreads-1) ) ++end1; ++end1;
    const int end = end1;
    for( int j=start; j<end; ++j )
      for( int i=1; i<=cols; ++i ){
	if( BIP(i,j)==UCHAR_MAX ){
	  std::vector< std::pair<int,int> > indices;
	  std::pair<int,int> one_index; one_index.first = i; one_index.second = j;
	  indices.push_back(one_index);
          BIP(i,j) = label_index;
	  unsigned char temp = UCHAR_MAX; 
	  ColorBlob( BinImPad, &indices, start, end, label_index, temp );
	  ++label_index;
	}
      }
    #pragma omp barrier
    //Re-color blob if the previous thread has assigned it
    //to a different color
    if( tid==0 && write_files ){
      std::string out_str1 = "label_intermediate.png";
      cv::imwrite(out_str1.c_str(),BinImPad);
    }
    while( redo_coloring ){
      #pragma omp barrier
      if( tid == 0 ) redo_coloring = false;
      for( int i=1; i<=cols; ++i ){
	if( (BIP((i-1),(start-1)) && BIP(i,start)) &&
	    (BIP((i-1),(start-1))!=BIP(i,start)) ){
	  redo_coloring = true;
	  unsigned char lund=BIP(i,start);
	  BIP(i,start)=BIP((i-1),(start-1));
	  std::pair<int,int> one_index; one_index.first = i; one_index.second = start;
	  std::vector< std::pair<int,int> > indices;
	  indices.push_back(one_index);
	  unsigned char temp = BIP(i,start);
	  ColorBlob( BinImPad, &indices, start, end, temp, lund );
	}
	else if( (BIP(i,(start-1)) && BIP(i,start)) &&
	    	(BIP(i,(start-1))!=BIP(i,start)) ){
	  redo_coloring = true;
	  unsigned char lund=BIP(i,start);
	  BIP(i,start)=BIP(i,(start-1));
	  std::pair<int,int> one_index; one_index.first = i; one_index.second = start;
	  std::vector< std::pair<int,int> > indices;
	  indices.push_back(one_index);
	  unsigned char temp = BIP(i,start);
	  ColorBlob( BinImPad, &indices, start, end, temp, lund );
	}
	else if( BIP((i+1),(start-1)) && BIP(i,start) &&
	   	 (BIP((i+1),(start-1))!=BIP(i,start)) ){
	  redo_coloring = true;
	  unsigned char lund=BIP(i,start);
	  BIP(i,start)=BIP((i+1),(start-1));
	  std::pair<int,int> one_index; one_index.first = i; one_index.second = start;
	  std::vector< std::pair<int,int> > indices;
	  indices.push_back(one_index);
	  unsigned char temp = BIP(i,start);
	  ColorBlob( BinImPad, &indices, start, end, temp, lund );
	}
      }
      #pragma omp barrier
      if( tid==0 && write_files ){
	std::string out_str1 = "label_intermediate1.png";
	cv::imwrite(out_str1.c_str(),BinImPad);
      }
    }
  }

  //Output the centroids and areas
  std::vector< std::vector<int> > statistics;
  for( int j=1; j<=rows; ++j )
    for( int i=1; i<=cols; ++i )
      if( ((int)BIP(i,j))>0){
	std::vector<int> one_stat(4); 
	one_stat[0] = BIP(i,j);
	bool bigEnough = GetStats(LabelIm,i,j,BinImPad,one_stat);
	if(bigEnough) statistics.push_back( one_stat );
	//else std::cout<<one_stat[0]<<"\t"<<one_stat[1]<<"\t"<<one_stat[2]<<"\t"<<one_stat[3]<<"\n";
      }

  std::string out_str1 = "label_final.png";
  cv::imwrite(out_str1.c_str(),LabelIm);
  out_str1 = "binary_" + file_open;
  IplImage *img = cvLoadImage(out_str1.c_str(), CV_LOAD_IMAGE_COLOR);
  CvFont font;
  cvInitFont(&font, CV_FONT_HERSHEY_SIMPLEX, 0.3, 0.3, 0, 1);
  std::vector< std::vector<int> >::iterator it; int i=1;
  for( it=statistics.begin() ; it < statistics.end(); ++it ){
    std::stringstream ss;
    ss<<i<<","<<it->at(1);++i;
    std::string sss=ss.str();
    cvPutText(img, sss.c_str(), cvPoint((it->at(3)),(it->at(2))), &font, cvScalar(255, 255, 100, 0));
    cvCircle(img, cvPoint((it->at(3)),(it->at(2))), 3, cvScalar(0,255,0), 1);
  }
  cvShowImage("Binary Image", img);

  out_str1 = "final.png";
  cvSaveImage(out_str1.c_str(),img);

  return;
}