void TCPBuffer::open(const TCPServer *server, size_t size) { close(); so = server->accept(); if(so == INVALID_SOCKET) return; _buffer(size); }
void TCPBuffer::open(const char *host, const char *service, size_t size) { struct addrinfo *list = Socket::query(host, service, SOCK_STREAM, 0); if(!list) return; so = Socket::create(list, SOCK_STREAM, 0); Socket::release(list); if(so == INVALID_SOCKET) return; _buffer(size); }
bool PngDecoder::readData( Mat& img ) { bool result = false; AutoBuffer<uchar*> _buffer(m_height); uchar** buffer = _buffer; int color = img.channels() > 1; uchar* data = img.data; int step = (int)img.step; if( m_png_ptr && m_info_ptr && m_end_info && m_width && m_height ) { png_structp png_ptr = (png_structp)m_png_ptr; png_infop info_ptr = (png_infop)m_info_ptr; png_infop end_info = (png_infop)m_end_info; if( setjmp( png_jmpbuf ( png_ptr ) ) == 0 ) { int y; if( img.depth() == CV_8U && m_bit_depth == 16 ) png_set_strip_16( png_ptr ); else if( !isBigEndian() ) png_set_swap( png_ptr ); if(img.channels() < 4) { /* observation: png_read_image() writes 400 bytes beyond * end of data when reading a 400x118 color png * "mpplus_sand.png". OpenCV crashes even with demo * programs. Looking at the loaded image I'd say we get 4 * bytes per pixel instead of 3 bytes per pixel. Test * indicate that it is a good idea to always ask for * stripping alpha.. 18.11.2004 Axel Walthelm */ png_set_strip_alpha( png_ptr ); } if( m_color_type == PNG_COLOR_TYPE_PALETTE ) png_set_palette_to_rgb( png_ptr ); if( m_color_type == PNG_COLOR_TYPE_GRAY && m_bit_depth < 8 ) #if (PNG_LIBPNG_VER_MAJOR*10000 + PNG_LIBPNG_VER_MINOR*100 + PNG_LIBPNG_VER_RELEASE >= 10209) || \ (PNG_LIBPNG_VER_MAJOR == 1 && PNG_LIBPNG_VER_MINOR == 0 && PNG_LIBPNG_VER_RELEASE >= 18) png_set_expand_gray_1_2_4_to_8( png_ptr ); #else png_set_gray_1_2_4_to_8( png_ptr ); #endif if( CV_MAT_CN(m_type) > 1 && color ) png_set_bgr( png_ptr ); // convert RGB to BGR else if( color ) png_set_gray_to_rgb( png_ptr ); // Gray->RGB else png_set_rgb_to_gray( png_ptr, 1, 0.299, 0.587 ); // RGB->Gray png_read_update_info( png_ptr, info_ptr ); for( y = 0; y < m_height; y++ ) buffer[y] = data + y*step; png_read_image( png_ptr, buffer ); png_read_end( png_ptr, end_info ); result = true; } } close(); return result; }
bool TiffEncoder::write( const Mat& img, const vector<int>& /*params*/) #endif { int channels = img.channels(); int width = img.cols, height = img.rows; int depth = img.depth(); if (depth != CV_8U && depth != CV_16U) return false; int bytesPerChannel = depth == CV_8U ? 1 : 2; int fileStep = width * channels * bytesPerChannel; WLByteStream strm; if( m_buf ) { if( !strm.open(*m_buf) ) return false; } else { #ifdef HAVE_TIFF return writeLibTiff(img, params); #else if( !strm.open(m_filename) ) return false; #endif } int rowsPerStrip = (1 << 13)/fileStep; if( rowsPerStrip < 1 ) rowsPerStrip = 1; if( rowsPerStrip > height ) rowsPerStrip = height; int i, stripCount = (height + rowsPerStrip - 1) / rowsPerStrip; if( m_buf ) m_buf->reserve( alignSize(stripCount*8 + fileStep*height + 256, 256) ); /*#if defined _DEBUG || !defined WIN32 int uncompressedRowSize = rowsPerStrip * fileStep; #endif*/ int directoryOffset = 0; AutoBuffer<int> stripOffsets(stripCount); AutoBuffer<short> stripCounts(stripCount); AutoBuffer<uchar> _buffer(fileStep+32); uchar* buffer = _buffer; int stripOffsetsOffset = 0; int stripCountsOffset = 0; int bitsPerSample = 8 * bytesPerChannel; int y = 0; strm.putBytes( fmtSignTiffII, 4 ); strm.putDWord( directoryOffset ); // write an image data first (the most reasonable way // for compressed images) for( i = 0; i < stripCount; i++ ) { int limit = y + rowsPerStrip; if( limit > height ) limit = height; stripOffsets[i] = strm.getPos(); for( ; y < limit; y++ ) { if( channels == 3 ) { if (depth == CV_8U) icvCvt_BGR2RGB_8u_C3R( img.data + img.step*y, 0, buffer, 0, cvSize(width,1) ); else icvCvt_BGR2RGB_16u_C3R( (const ushort*)(img.data + img.step*y), 0, (ushort*)buffer, 0, cvSize(width,1) ); } else { if( channels == 4 ) { if (depth == CV_8U) icvCvt_BGRA2RGBA_8u_C4R( img.data + img.step*y, 0, buffer, 0, cvSize(width,1) ); else icvCvt_BGRA2RGBA_16u_C4R( (const ushort*)(img.data + img.step*y), 0, (ushort*)buffer, 0, cvSize(width,1) ); } } strm.putBytes( channels > 1 ? buffer : img.data + img.step*y, fileStep ); } stripCounts[i] = (short)(strm.getPos() - stripOffsets[i]); /*assert( stripCounts[i] == uncompressedRowSize || stripCounts[i] < uncompressedRowSize && i == stripCount - 1);*/ } if( stripCount > 2 ) { stripOffsetsOffset = strm.getPos(); for( i = 0; i < stripCount; i++ ) strm.putDWord( stripOffsets[i] ); stripCountsOffset = strm.getPos(); for( i = 0; i < stripCount; i++ ) strm.putWord( stripCounts[i] ); } else if(stripCount == 2) { stripOffsetsOffset = strm.getPos(); for (i = 0; i < stripCount; i++) { strm.putDWord (stripOffsets [i]); } stripCountsOffset = stripCounts [0] + (stripCounts [1] << 16); } else { stripOffsetsOffset = stripOffsets[0]; stripCountsOffset = stripCounts[0]; } if( channels > 1 ) { int bitsPerSamplePos = strm.getPos(); strm.putWord(bitsPerSample); strm.putWord(bitsPerSample); strm.putWord(bitsPerSample); if( channels == 4 ) strm.putWord(bitsPerSample); bitsPerSample = bitsPerSamplePos; } directoryOffset = strm.getPos(); // write header strm.putWord( 9 ); /* warning: specification 5.0 of Tiff want to have tags in ascending order. This is a non-fatal error, but this cause warning with some tools. So, keep this in ascending order */ writeTag( strm, TIFF_TAG_WIDTH, TIFF_TYPE_LONG, 1, width ); writeTag( strm, TIFF_TAG_HEIGHT, TIFF_TYPE_LONG, 1, height ); writeTag( strm, TIFF_TAG_BITS_PER_SAMPLE, TIFF_TYPE_SHORT, channels, bitsPerSample ); writeTag( strm, TIFF_TAG_COMPRESSION, TIFF_TYPE_LONG, 1, TIFF_UNCOMP ); writeTag( strm, TIFF_TAG_PHOTOMETRIC, TIFF_TYPE_SHORT, 1, channels > 1 ? 2 : 1 ); writeTag( strm, TIFF_TAG_STRIP_OFFSETS, TIFF_TYPE_LONG, stripCount, stripOffsetsOffset ); writeTag( strm, TIFF_TAG_SAMPLES_PER_PIXEL, TIFF_TYPE_SHORT, 1, channels ); writeTag( strm, TIFF_TAG_ROWS_PER_STRIP, TIFF_TYPE_LONG, 1, rowsPerStrip ); writeTag( strm, TIFF_TAG_STRIP_COUNTS, stripCount > 1 ? TIFF_TYPE_SHORT : TIFF_TYPE_LONG, stripCount, stripCountsOffset ); strm.putDWord(0); strm.close(); if( m_buf ) { (*m_buf)[4] = (uchar)directoryOffset; (*m_buf)[5] = (uchar)(directoryOffset >> 8); (*m_buf)[6] = (uchar)(directoryOffset >> 16); (*m_buf)[7] = (uchar)(directoryOffset >> 24); } else {
bool TiffEncoder::writeLibTiff( const Mat& img, const vector<int>& /*params*/) { int channels = img.channels(); int width = img.cols, height = img.rows; int depth = img.depth(); int bitsPerChannel = -1; switch (depth) { case CV_8U: { bitsPerChannel = 8; break; } case CV_16U: { bitsPerChannel = 16; break; } default: { return false; } } const int bitsPerByte = 8; size_t fileStep = (width * channels * bitsPerChannel) / bitsPerByte; int rowsPerStrip = (int)((1 << 13)/fileStep); if( rowsPerStrip < 1 ) rowsPerStrip = 1; if( rowsPerStrip > height ) rowsPerStrip = height; // do NOT put "wb" as the mode, because the b means "big endian" mode, not "binary" mode. // http://www.remotesensing.org/libtiff/man/TIFFOpen.3tiff.html TIFF* pTiffHandle = TIFFOpen(m_filename.c_str(), "w"); if (!pTiffHandle) { return false; } // defaults for now, maybe base them on params in the future int compression = COMPRESSION_LZW; int predictor = PREDICTOR_HORIZONTAL; int colorspace = channels > 1 ? PHOTOMETRIC_RGB : PHOTOMETRIC_MINISBLACK; if ( !TIFFSetField(pTiffHandle, TIFFTAG_IMAGEWIDTH, width) || !TIFFSetField(pTiffHandle, TIFFTAG_IMAGELENGTH, height) || !TIFFSetField(pTiffHandle, TIFFTAG_BITSPERSAMPLE, bitsPerChannel) || !TIFFSetField(pTiffHandle, TIFFTAG_COMPRESSION, compression) || !TIFFSetField(pTiffHandle, TIFFTAG_PHOTOMETRIC, colorspace) || !TIFFSetField(pTiffHandle, TIFFTAG_SAMPLESPERPIXEL, channels) || !TIFFSetField(pTiffHandle, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG) || !TIFFSetField(pTiffHandle, TIFFTAG_ROWSPERSTRIP, rowsPerStrip) || !TIFFSetField(pTiffHandle, TIFFTAG_PREDICTOR, predictor) ) { TIFFClose(pTiffHandle); return false; } // row buffer, because TIFFWriteScanline modifies the original data! size_t scanlineSize = TIFFScanlineSize(pTiffHandle); AutoBuffer<uchar> _buffer(scanlineSize+32); uchar* buffer = _buffer; if (!buffer) { TIFFClose(pTiffHandle); return false; } for (int y = 0; y < height; ++y) { switch(channels) { case 1: { memcpy(buffer, img.data + img.step * y, scanlineSize); break; } case 3: { if (depth == CV_8U) icvCvt_BGR2RGB_8u_C3R( img.data + img.step*y, 0, buffer, 0, cvSize(width,1) ); else icvCvt_BGR2RGB_16u_C3R( (const ushort*)(img.data + img.step*y), 0, (ushort*)buffer, 0, cvSize(width,1) ); break; } case 4: { if (depth == CV_8U) icvCvt_BGRA2RGBA_8u_C4R( img.data + img.step*y, 0, buffer, 0, cvSize(width,1) ); else icvCvt_BGRA2RGBA_16u_C4R( (const ushort*)(img.data + img.step*y), 0, (ushort*)buffer, 0, cvSize(width,1) ); break; } default: { TIFFClose(pTiffHandle); return false; } } int writeResult = TIFFWriteScanline(pTiffHandle, buffer, y, 0); if (writeResult != 1) { TIFFClose(pTiffHandle); return false; } } TIFFClose(pTiffHandle); return true; }
bool TiffDecoder::readData( Mat& img ) { bool result = false; bool color = img.channels() > 1; uchar* data = img.data; int step = (int)img.step; if( img.depth() != CV_8U && img.depth() != CV_16U && img.depth() != CV_32F && img.depth() != CV_64F ) return false; if( m_tif && m_width && m_height ) { TIFF* tif = (TIFF*)m_tif; int tile_width0 = m_width, tile_height0 = 0; int x, y, i; int is_tiled = TIFFIsTiled(tif); int photometric; TIFFGetField( tif, TIFFTAG_PHOTOMETRIC, &photometric ); int bpp = 8, ncn = photometric > 1 ? 3 : 1; TIFFGetField( tif, TIFFTAG_BITSPERSAMPLE, &bpp ); TIFFGetField( tif, TIFFTAG_SAMPLESPERPIXEL, &ncn ); const int bitsPerByte = 8; int dst_bpp = (int)(img.elemSize1() * bitsPerByte); if(dst_bpp == 8) { char errmsg[1024]; if(!TIFFRGBAImageOK( tif, errmsg )) { close(); return false; } } if( (!is_tiled) || (is_tiled && TIFFGetField( tif, TIFFTAG_TILEWIDTH, &tile_width0 ) && TIFFGetField( tif, TIFFTAG_TILELENGTH, &tile_height0 ))) { if(!is_tiled) TIFFGetField( tif, TIFFTAG_ROWSPERSTRIP, &tile_height0 ); if( tile_width0 <= 0 ) tile_width0 = m_width; if( tile_height0 <= 0 ) tile_height0 = m_height; AutoBuffer<uchar> _buffer(tile_height0*tile_width0*8); uchar* buffer = _buffer; ushort* buffer16 = (ushort*)buffer; float* buffer32 = (float*)buffer; double* buffer64 = (double*)buffer; int tileidx = 0; for( y = 0; y < m_height; y += tile_height0, data += step*tile_height0 ) { int tile_height = tile_height0; if( y + tile_height > m_height ) tile_height = m_height - y; for( x = 0; x < m_width; x += tile_width0, tileidx++ ) { int tile_width = tile_width0, ok; if( x + tile_width > m_width ) tile_width = m_width - x; switch(dst_bpp) { case 8: { if( !is_tiled ) ok = TIFFReadRGBAStrip( tif, y, (uint32*)buffer ); else ok = TIFFReadRGBATile( tif, x, y, (uint32*)buffer ); if( !ok ) { close(); return false; } for( i = 0; i < tile_height; i++ ) if( color ) icvCvt_BGRA2BGR_8u_C4C3R( buffer + i*tile_width*4, 0, data + x*3 + step*(tile_height - i - 1), 0, cvSize(tile_width,1), 2 ); else icvCvt_BGRA2Gray_8u_C4C1R( buffer + i*tile_width*4, 0, data + x + step*(tile_height - i - 1), 0, cvSize(tile_width,1), 2 ); break; } case 16: { if( !is_tiled ) ok = (int)TIFFReadEncodedStrip( tif, tileidx, (uint32*)buffer, (tsize_t)-1 ) >= 0; else ok = (int)TIFFReadEncodedTile( tif, tileidx, (uint32*)buffer, (tsize_t)-1 ) >= 0; if( !ok ) { close(); return false; } for( i = 0; i < tile_height; i++ ) { if( color ) { if( ncn == 1 ) { icvCvt_Gray2BGR_16u_C1C3R(buffer16 + i*tile_width*ncn, 0, (ushort*)(data + step*i) + x*3, 0, cvSize(tile_width,1) ); } else if( ncn == 3 ) { icvCvt_RGB2BGR_16u_C3R(buffer16 + i*tile_width*ncn, 0, (ushort*)(data + step*i) + x*3, 0, cvSize(tile_width,1) ); } else { icvCvt_BGRA2BGR_16u_C4C3R(buffer16 + i*tile_width*ncn, 0, (ushort*)(data + step*i) + x*3, 0, cvSize(tile_width,1), 2 ); } } else { if( ncn == 1 ) { memcpy((ushort*)(data + step*i)+x, buffer16 + i*tile_width*ncn, tile_width*sizeof(buffer16[0])); } else { icvCvt_BGRA2Gray_16u_CnC1R(buffer16 + i*tile_width*ncn, 0, (ushort*)(data + step*i) + x, 0, cvSize(tile_width,1), ncn, 2 ); } } } break; } case 32: case 64: { if( !is_tiled ) ok = (int)TIFFReadEncodedStrip( tif, tileidx, buffer, (tsize_t)-1 ) >= 0; else ok = (int)TIFFReadEncodedTile( tif, tileidx, buffer, (tsize_t)-1 ) >= 0; if( !ok || ncn != 1 ) { close(); return false; } for( i = 0; i < tile_height; i++ ) { if(dst_bpp == 32) { memcpy((float*)(data + step*i)+x, buffer32 + i*tile_width*ncn, tile_width*sizeof(buffer32[0])); } else { memcpy((double*)(data + step*i)+x, buffer64 + i*tile_width*ncn, tile_width*sizeof(buffer64[0])); } } break; } default: { close(); return false; } } } } result = true; } } close(); return result; }
static void HoughLinesSDiv( const Mat& img, float rho, float theta, int threshold, int srn, int stn, std::vector<Vec2f>& lines, int linesMax, double min_theta, double max_theta ) { #define _POINT(row, column)\ (image_src[(row)*step+(column)]) int index, i; int ri, ti, ti1, ti0; int row, col; float r, t; /* Current rho and theta */ float rv; /* Some temporary rho value */ int fn = 0; float xc, yc; const float d2r = (float)(CV_PI / 180); int sfn = srn * stn; int fi; int count; int cmax = 0; std::vector<hough_index> lst; CV_Assert( img.type() == CV_8UC1 ); CV_Assert( linesMax > 0 ); threshold = MIN( threshold, 255 ); const uchar* image_src = img.ptr(); int step = (int)img.step; int w = img.cols; int h = img.rows; float irho = 1 / rho; float itheta = 1 / theta; float srho = rho / srn; float stheta = theta / stn; float isrho = 1 / srho; float istheta = 1 / stheta; int rn = cvFloor( std::sqrt( (double)w * w + (double)h * h ) * irho ); int tn = cvFloor( 2 * CV_PI * itheta ); lst.push_back(hough_index(threshold, -1.f, 0.f)); // Precalculate sin table std::vector<float> _sinTable( 5 * tn * stn ); float* sinTable = &_sinTable[0]; for( index = 0; index < 5 * tn * stn; index++ ) sinTable[index] = (float)cos( stheta * index * 0.2f ); std::vector<uchar> _caccum(rn * tn, (uchar)0); uchar* caccum = &_caccum[0]; // Counting all feature pixels for( row = 0; row < h; row++ ) for( col = 0; col < w; col++ ) fn += _POINT( row, col ) != 0; std::vector<int> _x(fn), _y(fn); int* x = &_x[0], *y = &_y[0]; // Full Hough Transform (it's accumulator update part) fi = 0; for( row = 0; row < h; row++ ) { for( col = 0; col < w; col++ ) { if( _POINT( row, col )) { int halftn; float r0; float scale_factor; int iprev = -1; float phi, phi1; float theta_it; // Value of theta for iterating // Remember the feature point x[fi] = col; y[fi] = row; fi++; yc = (float) row + 0.5f; xc = (float) col + 0.5f; /* Update the accumulator */ t = (float) fabs( cvFastArctan( yc, xc ) * d2r ); r = (float) std::sqrt( (double)xc * xc + (double)yc * yc ); r0 = r * irho; ti0 = cvFloor( (t + CV_PI*0.5) * itheta ); caccum[ti0]++; theta_it = rho / r; theta_it = theta_it < theta ? theta_it : theta; scale_factor = theta_it * itheta; halftn = cvFloor( CV_PI / theta_it ); for( ti1 = 1, phi = theta_it - (float)(CV_PI*0.5), phi1 = (theta_it + t) * itheta; ti1 < halftn; ti1++, phi += theta_it, phi1 += scale_factor ) { rv = r0 * std::cos( phi ); i = (int)rv * tn; i += cvFloor( phi1 ); assert( i >= 0 ); assert( i < rn * tn ); caccum[i] = (uchar) (caccum[i] + ((i ^ iprev) != 0)); iprev = i; if( cmax < caccum[i] ) cmax = caccum[i]; } } } } // Starting additional analysis count = 0; for( ri = 0; ri < rn; ri++ ) { for( ti = 0; ti < tn; ti++ ) { if( caccum[ri * tn + ti] > threshold ) count++; } } if( count * 100 > rn * tn ) { HoughLinesStandard( img, rho, theta, threshold, lines, linesMax, min_theta, max_theta ); return; } std::vector<uchar> _buffer(srn * stn + 2); uchar* buffer = &_buffer[0]; uchar* mcaccum = buffer + 1; count = 0; for( ri = 0; ri < rn; ri++ ) { for( ti = 0; ti < tn; ti++ ) { if( caccum[ri * tn + ti] > threshold ) { count++; memset( mcaccum, 0, sfn * sizeof( uchar )); for( index = 0; index < fn; index++ ) { int ti2; float r0; yc = (float) y[index] + 0.5f; xc = (float) x[index] + 0.5f; // Update the accumulator t = (float) fabs( cvFastArctan( yc, xc ) * d2r ); r = (float) std::sqrt( (double)xc * xc + (double)yc * yc ) * isrho; ti0 = cvFloor( (t + CV_PI * 0.5) * istheta ); ti2 = (ti * stn - ti0) * 5; r0 = (float) ri *srn; for( ti1 = 0; ti1 < stn; ti1++, ti2 += 5 ) { rv = r * sinTable[(int) (std::abs( ti2 ))] - r0; i = cvFloor( rv ) * stn + ti1; i = CV_IMAX( i, -1 ); i = CV_IMIN( i, sfn ); mcaccum[i]++; assert( i >= -1 ); assert( i <= sfn ); } } // Find peaks in maccum... for( index = 0; index < sfn; index++ ) { i = 0; int pos = (int)(lst.size() - 1); if( pos < 0 || lst[pos].value < mcaccum[index] ) { hough_index vi(mcaccum[index], index / stn * srho + ri * rho, index % stn * stheta + ti * theta - (float)(CV_PI*0.5)); lst.push_back(vi); for( ; pos >= 0; pos-- ) { if( lst[pos].value > vi.value ) break; lst[pos+1] = lst[pos]; } lst[pos+1] = vi; if( (int)lst.size() > linesMax ) lst.pop_back(); } } } } } for( size_t idx = 0; idx < lst.size(); idx++ ) { if( lst[idx].rho < 0 ) continue; lines.push_back(Vec2f(lst[idx].rho, lst[idx].theta)); } }
int main(int argc, char *argv[]) { // Signal settings. double rate = 1e6; double freq = 10e3; double fc = 150e3; // Modulation settings double gain = 1; double rel_fc = fc / rate; double rel_fs = freq / rate; boost::shared_ptr<SharedType<double> > fcr(new SharedType<double>(rel_fc)); // Specific Modulation Settings. AmDemod::SideBand sideBand = AmDemod::SideBand::DOUBLE; unsigned int constSize = 16; int supp_carrier = 1; double mod_index = 0.5; // Frame size and FFT size. size_t N = 2048; size_t frameSize = 384; /*************************************************************************************************** * Create stream object * **************************************************************************************************/ // AM Stream function. StreamFunction * _streamFunction = new AmFunction(new cosFunction(freq), mod_index, rel_fc, sideBand, supp_carrier); //StreamFunction * _streamFunction = new eFunction(freq); StreamFunction * _noisyStreamFunction = new AwgnFunction(_streamFunction, 0, 1e6, 1e6); // FM Stream Function //StreamFunction * _streamFunction = new FmFunction(new cosFunction(freq), mod_index, rel_fc); // MPSK Stream Function //StreamFunction * _streamFunction = new DigitalFunction(new MPskFunction(constSize), rel_fs, rel_fc); // ------------ Create Streamer Object ------------ // // UhdMock Object boost::scoped_ptr < Streamer > _dataStream(new UhdMock(_noisyStreamFunction, rate, gain, frameSize)); // UhdRead Object // boost::scoped_ptr < Streamer > _dataStream(new UhdRead(rate, freq, gain, frameSize)); /*************************************************************************************************** * Initialize utilities * **************************************************************************************************/ // Get shared buffer boost::shared_ptr < SharedBuffer<std::complex<double> > > _buffer(_dataStream->getBuffer()); // Create fft generator function. FFTGenerator _fftGen(_buffer, rate, N); AmcClassifier<double, AMC::ModType> * classifier = new AmcZnDecisionTree(); //classifier->load("test0"); std::string dir = "/home/jcq/git/Automatic-Modulation-Classification-ELEN4012/train-data/2015-10-12-3"; ClassifierTrainer ct(classifier,dir); ct.train(); ct.save("test0"); //AMC::FeatureExtractor _featureExtractor(_buffer, classifier, N, rate); AMC::FeatureExtractor _featureExtractor(_buffer, classifier, rate, fcr, N); AMC::FeatureExtractor _featureExtractor(_buffer, rate, fcr, bwr,N,1); /*************************************************************************************************** * Initialize GUI Objects * **************************************************************************************************/ // Initialize interface. QApplication _app(argc, argv); MainWindow _mainWindow(rate, N); _mainWindow.show(); _mainWindow.setData(_fftGen.getFreqVec(), _fftGen.getFftVec()); _mainWindow.setBuffer(_buffer); _mainWindow.setSharedModType(_featureExtractor.getSharedModType()); /*************************************************************************************************** * Start threads. * **************************************************************************************************/ _dataStream->startStream(); // _amcRecv.startDemod(); _fftGen.startFft(); _featureExtractor.start(AMC::FeatureExtractor::ExtractionMode::CLASSIFY); return _app.exec(); }
seg_err seg_symbol(seg_runtime *r, const char *str, uint64_t length, seg_object *out) { return _buffer(r, str, length, false, out); }
seg_err seg_string(seg_runtime *r, const char *str, uint64_t length, seg_object *out) { return _buffer(r, str, length, true, out); }
bool PxMEncoder::write( const Mat& img, const std::vector<int>& params ) { bool isBinary = true; int width = img.cols, height = img.rows; int _channels = img.channels(), depth = (int)img.elemSize1()*8; int channels = _channels > 1 ? 3 : 1; int fileStep = width*(int)img.elemSize(); int x, y; for( size_t i = 0; i < params.size(); i += 2 ) if( params[i] == CV_IMWRITE_PXM_BINARY ) isBinary = params[i+1] != 0; WLByteStream strm; if( m_buf ) { if( !strm.open(*m_buf) ) return false; int t = CV_MAKETYPE(img.depth(), channels); m_buf->reserve( alignSize(256 + (isBinary ? fileStep*height : ((t == CV_8UC1 ? 4 : t == CV_8UC3 ? 4*3+2 : t == CV_16UC1 ? 6 : 6*3+2)*width+1)*height), 256)); } else if( !strm.open(m_filename) ) return false; int lineLength; int bufferSize = 128; // buffer that should fit a header if( isBinary ) lineLength = width * (int)img.elemSize(); else lineLength = (6 * channels + (channels > 1 ? 2 : 0)) * width + 32; if( bufferSize < lineLength ) bufferSize = lineLength; AutoBuffer<char> _buffer(bufferSize); char* buffer = _buffer; // write header; sprintf( buffer, "P%c\n%d %d\n%d\n", '2' + (channels > 1 ? 1 : 0) + (isBinary ? 3 : 0), width, height, (1 << depth) - 1 ); strm.putBytes( buffer, (int)strlen(buffer) ); for( y = 0; y < height; y++ ) { uchar* data = img.data + img.step*y; if( isBinary ) { if( _channels == 3 ) { if( depth == 8 ) icvCvt_BGR2RGB_8u_C3R( (uchar*)data, 0, (uchar*)buffer, 0, cvSize(width,1) ); else icvCvt_BGR2RGB_16u_C3R( (ushort*)data, 0, (ushort*)buffer, 0, cvSize(width,1) ); } // swap endianness if necessary if( depth == 16 && !isBigEndian() ) { if( _channels == 1 ) memcpy( buffer, data, fileStep ); for( x = 0; x < width*channels*2; x += 2 ) { uchar v = buffer[x]; buffer[x] = buffer[x + 1]; buffer[x + 1] = v; } } strm.putBytes( (channels > 1 || depth > 8) ? buffer : (char*)data, fileStep ); } else { char* ptr = buffer; if( channels > 1 ) { if( depth == 8 ) { for( x = 0; x < width*channels; x += channels ) { sprintf( ptr, "% 4d", data[x + 2] ); ptr += 4; sprintf( ptr, "% 4d", data[x + 1] ); ptr += 4; sprintf( ptr, "% 4d", data[x] ); ptr += 4; *ptr++ = ' '; *ptr++ = ' '; } } else { for( x = 0; x < width*channels; x += channels ) { sprintf( ptr, "% 6d", ((ushort *)data)[x + 2] ); ptr += 6; sprintf( ptr, "% 6d", ((ushort *)data)[x + 1] ); ptr += 6; sprintf( ptr, "% 6d", ((ushort *)data)[x] ); ptr += 6; *ptr++ = ' '; *ptr++ = ' '; } } } else { if( depth == 8 ) { for( x = 0; x < width; x++ ) { sprintf( ptr, "% 4d", data[x] ); ptr += 4; } } else { for( x = 0; x < width; x++ ) { sprintf( ptr, "% 6d", ((ushort *)data)[x] ); ptr += 6; } } } *ptr++ = '\n'; strm.putBytes( buffer, (int)(ptr - buffer) ); } } strm.close(); return true; }
template <class TSum, class TSqsum> void IntegralSumSqsumTilted(const uint8_t * src, ptrdiff_t srcStride, size_t width, size_t height, TSum * sum, ptrdiff_t sumStride, TSqsum * sqsum, ptrdiff_t sqsumStride, TSum * tilted, ptrdiff_t tiltedStride) { memset(sum, 0, (width + 1)*sizeof(TSum)); sum += sumStride + 1; memset(sqsum, 0, (width + 1)*sizeof(TSqsum)); sqsum += sqsumStride + 1; memset(tilted, 0, (width + 1)*sizeof(TSum)); tilted += tiltedStride + 1; Buffer<TSum> _buffer(width + 1); TSum * buffer = _buffer.p; TSum s = 0; TSqsum sq = 0; sum[-1] = 0; tilted[-1] = 0; sqsum[-1] = 0; for(size_t col = 0; col < width; col++) { TSum value = src[col]; buffer[col] = value; tilted[col] = value; s += value; sq += value*value; sum[col] = s; sqsum[col] = sq; } if(width == 1) buffer[1] = 0; for(size_t row = 1; row < height; ++row) { src += srcStride; sum += sumStride; tilted += tiltedStride; sqsum += sqsumStride; TSum value = src[0]; TSum t0 = s = value; TSqsum tq0 = sq = value*value; sum[-1] = 0; sqsum[-1] = 0; tilted[-1] = tilted[-tiltedStride]; sum[0] = sum[-sumStride] + t0; sqsum[0] = sqsum[-sqsumStride] + tq0; tilted[0] = tilted[-tiltedStride] + t0 + buffer[1]; size_t col; for(col = 1; col < width - 1; ++col) { TSum t1 = buffer[col]; buffer[col - 1] = t1 + t0; t0 = value = src[col]; tq0 = value*value; s += t0; sq += tq0; sum[col] = sum[col - sumStride] + s; sqsum[col] = sqsum[col - sqsumStride] + sq; t1 += buffer[col + 1] + t0 + tilted[col - tiltedStride - 1]; tilted[col] = t1; } if(width > 1) { TSum t1 = buffer[col]; buffer[col - 1] = t1 + t0; t0 = value = src[col]; tq0 = value*value; s += t0; sq += tq0; sum[col] = sum[col - sumStride] + s; sqsum[col] = sqsum[col - sqsumStride] + sq; tilted[col] = t0 + t1 + tilted[col - tiltedStride - 1]; buffer[col] = t0; } } }
int main(int argc, char *argv[]) { // Signal settings. double rate = 1e6; double freq = 10e3; double fc = 150e3; // Modulation settings double gain = 1; double rel_fc = fc / rate; double rel_fs = freq / rate; // Specific Modulation Settings. AmDemod::SideBand sideBand = AmDemod::SideBand::DOUBLE; unsigned int constSize = 2; int supp_carrier = 0; double mod_index = 0.5; // Frame size and FFT size. size_t N = 2048; size_t frameSize = 384; /*************************************************************************************************** * Create stream object * **************************************************************************************************/ // AM Stream function. StreamFunction * _streamFunction = new AmFunction(new cosFunction(freq), mod_index, rel_fc, sideBand, supp_carrier); // FM Stream Function // StreamFunction * _streamFunction = new FmFunction(new cosFunction(freq), mod_index, rel_fc); // MPSK Stream Function // StreamFunction * _streamFunction = new DigitalFunction(new MPskFunction(constSize), rel_fs, rel_fc); // ------------ Create Streamer Object ------------ // // UhdMock Object boost::scoped_ptr < Streamer > _dataStream(new UhdMock(_streamFunction, rate, gain, frameSize)); // UhdRead Object // boost::scoped_ptr < Streamer > _dataStream(new UhdRead(rate, freq, gain, frameSize)); /*************************************************************************************************** * Initialize utilities * **************************************************************************************************/ // Get shared buffer boost::shared_ptr < SharedBuffer<std::complex<double> > > _buffer(_dataStream->getBuffer()); boost::shared_ptr < SharedType<double> > _fc(_dataStream->getFc()); boost::shared_ptr < SharedType<double> > _window(_dataStream->getWindow()); // Create fft generator function. FFTGenerator _fftGen(_buffer, rate, N); AmcClassifier<double, AMC::ModType> * classifier = new AmcCvDecisionTree(); AMC::FeatureExtractor _featureExtractor(_buffer, classifier, N, rate); boost::shared_ptr < SharedType<AMC::ModType> > _modType(_featureExtractor.getSharedModType()); /*************************************************************************************************** * Create Demodulator * **************************************************************************************************/ // Create demodulator object. AmcRecv _amcRecv(_buffer, N); _amcRecv.setFc(_fc); _amcRecv.setModType(_modType); // Am Demodulator. _amcRecv.setDemod(new AmDemod(mod_index, rel_fc, sideBand, supp_carrier)); // Fm Demodulator. // _amcRecv.setDemod(new FmDemod(mod_index, rel_fc)); // MPSK Demodulator // _amcRecv.setDemod(new DigitalDemod(new MPskDemod(constSize), rel_fc)); /*************************************************************************************************** * Initialize GUI Objects * **************************************************************************************************/ // Initialize interface. QApplication _app(argc, argv); MainWindow _mainWindow(rate, N); _mainWindow.show(); /*************************************************************************************************** * Share some buffers * **************************************************************************************************/ _fftGen.setFc(_fc); _mainWindow.setData(_fftGen.getFreqVec(), _fftGen.getFftVec()); _mainWindow.setBuffer(_buffer); _mainWindow.setSharedModType(_modType); _mainWindow.setFc(_fc); _mainWindow.setWindow(_window); /*************************************************************************************************** * Start threads. * **************************************************************************************************/ _dataStream->startStream(); _amcRecv.startDemod(); _fftGen.startFft(); _featureExtractor.start(AMC::FeatureExtractor::ExtractionMode::CLASSIFY); return _app.exec(); }
bool TiffDecoder::readData( Mat& img ) { bool result = false; bool color = img.channels() > 1; uchar* data = img.data; int step = img.step; if( m_tif && m_width && m_height ) { TIFF* tif = (TIFF*)m_tif; int tile_width0 = m_width, tile_height0 = 0; int x, y, i; int is_tiled = TIFFIsTiled(tif); if( (!is_tiled && TIFFGetField( tif, TIFFTAG_ROWSPERSTRIP, &tile_height0 )) || (is_tiled && TIFFGetField( tif, TIFFTAG_TILEWIDTH, &tile_width0 ) && TIFFGetField( tif, TIFFTAG_TILELENGTH, &tile_height0 ))) { if( tile_width0 <= 0 ) tile_width0 = m_width; if( tile_height0 <= 0 ) tile_height0 = m_height; AutoBuffer<uchar> _buffer(tile_height0*tile_width0*4); uchar* buffer = _buffer; for( y = 0; y < m_height; y += tile_height0, data += step*tile_height0 ) { int tile_height = tile_height0; if( y + tile_height > m_height ) tile_height = m_height - y; for( x = 0; x < m_width; x += tile_width0 ) { int tile_width = tile_width0, ok; if( x + tile_width > m_width ) tile_width = m_width - x; if( !is_tiled ) ok = TIFFReadRGBAStrip( tif, y, (uint32*)buffer ); else ok = TIFFReadRGBATile( tif, x, y, (uint32*)buffer ); if( !ok ) { close(); return false; } for( i = 0; i < tile_height; i++ ) if( color ) icvCvt_BGRA2BGR_8u_C4C3R( buffer + i*tile_width*4, 0, data + x*3 + step*(tile_height - i - 1), 0, cvSize(tile_width,1), 2 ); else icvCvt_BGRA2Gray_8u_C4C1R( buffer + i*tile_width*4, 0, data + x + step*(tile_height - i - 1), 0, cvSize(tile_width,1), 2 ); } } result = true; } } close(); return result; }
std::vector<char> QblZlib::decompress(std::vector<char> data) { int retval; std::vector<char> result; std::vector<char>::iterator begin, end; unsigned char in[CHUNK]; size_t current = 0; this->stream.next_in = Z_NULL; this->stream.avail_in = 0; retval = inflateInit2(&this->stream, windowBits | ENABLE_ZLIB_GZIP); if (retval < 0) { this->errorMessage(retval); } do { std::vector<char> in; size_t length; begin = data.begin(); begin += current; end = begin; if (data.size() - current > CHUNK) { length = CHUNK; } else { length = data.size() - current; } end += length; in.resize(length); in.insert(in.begin(), begin, end); this->stream.next_in = (unsigned char *)in.data(); this->stream.avail_in = length; do { int n, retval; unsigned char buffer[CHUNK]; this->stream.avail_out = CHUNK; this->stream.next_out = buffer; retval = inflate(&this->stream, Z_NO_FLUSH); if (retval != Z_STREAM_ERROR) { switch (retval) { case Z_NEED_DICT: retval = Z_DATA_ERROR; case Z_DATA_ERROR: case Z_MEM_ERROR: (void)inflateEnd(&this->stream); this->errorMessage(retval); } } n = CHUNK - this->stream.avail_out; std::vector<char> _buffer(buffer, buffer + n); result.insert(result.end(), _buffer.begin(), _buffer.end()); } while (this->stream.avail_out == 0); if (length < CHUNK) { break; } current += length; } while (retval != Z_STREAM_END); (void)inflateEnd(&this->stream); return (result); }