Esempio n. 1
0
void SummaryCommand :: RecordSizes( const CSVRow & row, SizeMap & sm ) {
	for ( unsigned int i = 0; i < row.size(); i++ ) {
		int sz = row[i].size();
		SizeMap::iterator pos = sm.find( i );
		if ( pos == sm.end() ) {
			sm[ i ] = std::make_pair( INT_MAX, 0 );
		}
		sm[i].first = std::min( sm[i].first, sz );
		sm[i].second = std::max( sm[i].second, sz );
	}
}
Esempio n. 2
0
void CSVIO::read(std::vector<std::vector<double> >& out){
	CSVRow row;
	std::vector<string> rowStr;
	row.read(ifs);
	rowStr = row.getData();
	std::vector<double> tVec(rowStr.size());
	int rowindex = 0;

	while(!ifs.fail() && !ifs.eof() && (rowindex < nrow)){
		row.read(ifs);
		rowStr = row.getData();

		for(int i = 0; i < rowStr.size(); i++){
			tVec[i] =  std::stof(rowStr.at(i));
		}
		out.push_back(tVec);
		++rowindex;
		rowStr.clear();

	}
}
Esempio n. 3
0
void AsciiTableCommand :: AddRow( const CSVRow & row ) {
	unsigned int n = row.size();
	while( mWidths.size() < n ) {
		mWidths.push_back( 0 );
	}
	for ( unsigned int i = 0; i < n ; i++ ) {
		if ( mWidths[i] < row[i].size() ) {
			mWidths[i] = row[i].size();
		}
	}
	mRows.push_back( row );
}
Esempio n. 4
0
int TruncPadBase :: Execute( ALib::CommandLine & cmd ) {

	GetSkipOptions( cmd );
	string ps = cmd.GetValue( FLAG_PAD );
	ALib::CommaList padding( ps );
	unsigned int ncols = padding.Size();

	bool ncolspec = false;	// use explicit size or not

	if ( ncols == 0 || cmd.HasFlag( FLAG_NUM ) ) {
		if ( ! cmd.HasFlag( FLAG_NUM ) ) {
			CSVTHROW( "Need -n flag to specify field count" );
		}
		ncolspec = true;
		string nv = cmd.GetValue( FLAG_NUM );
		if ( ALib::ToInteger( nv, "-n flag needs integer value" ) < 0 ) {
			CSVTHROW( FLAG_NUM << " needs value greater or equal to zero" );
		}
		ncols = ALib::ToInteger( nv );
	}

	IOManager io( cmd );
	CSVRow row;

	while( io.ReadCSV( row ) ) {

		if ( Skip( io, row ) ) {
			continue;
		}

		if ( ! Pass( io, row ) ) {
			unsigned int nc = ncolspec ? ncols : row.size() + padding.Size();
			ProcessRow( row, nc, padding );
		}

		io.WriteRow( row );
	}

	return 0;
}
Esempio n. 5
0
string JoinCommand :: MakeKey( const CSVRow & row, bool first ) {
	string key;
	for ( unsigned int i = 0; i < mJoinSpecs.size(); i++ ) {
		unsigned int col = first ? mJoinSpecs[i].first
								 : mJoinSpecs[i].second;
		if ( col >= row.size() ) {
			continue;
		}
		key += mIgnoreCase ? ALib::Upper( row[col] ) : row[col];
		key += '\0';		// key element separator
	}
	return key;
}
Esempio n. 6
0
int CallCommand :: CallOnFields( CSVRow & row, char * buffer ) {
	string fields;
	int fc = 0;
	for ( unsigned int i = 0; i < row.size(); i++ ) {
		if ( mFields.size() == 0 || ALib::Contains( mFields, i ) ) {
			fields += row[i];
			fields += '\0';
			fc++;
		}
	}
	int ofc = 0;
	int rv = mFunc( fc, fields.c_str(), &ofc, buffer, mOutBufSize );
	if ( rv == 0  ) {
		int pos = 0;
		while( ofc-- ) {
			string field = ExtractField( buffer, pos );
			pos++;
			row.push_back( field );
		}
	}
	return rv;
}
Esempio n. 7
0
int FileInfoCommand :: Execute( ALib::CommandLine & cmd ) {

	GetSkipOptions( cmd );
	mTwoCols = cmd.HasFlag( FLAG_TWOC );
	mBasename = cmd.HasFlag( FLAG_BASEN );

	IOManager io( cmd );

	CSVRow row;
	while( io.ReadCSV( row ) ) {
		if ( Skip( io, row ) ) {
			continue;
		}
		if ( Pass( io, row ) ) {
			io.WriteRow( row );
			continue;
		}

		string fname = mBasename
						? ALib::Filename( io.CurrentFileName() ).Base()
						: io.CurrentFileName();

		CSVRow outrow;
		if ( mTwoCols ) {
			outrow.push_back( fname );
			outrow.push_back( ALib::Str( io.CurrentLine() ));
		}
		else {
			outrow.push_back( fname + " ("
				+ ALib::Str( io.CurrentLine() ) + ")"
			);
		}
		ALib::operator+=( outrow, row );
		io.WriteRow( outrow );
	}

	return 0;
}
Esempio n. 8
0
void AsciiTableCommand :: OutputHeadings( std::ostream & os,
											const CSVRow & row ) {
	os << "|";
	for ( unsigned int i = 0; i < mWidths.size() ; i++ ) {
		if ( i < row.size() ) {
			os << " "  << ALib::Centre( row[i], mWidths[i] ) << " |";
		}
		else {
			os << " " << ALib::RightPad( "", mWidths[i] ) << " |";
		}
	}
	os << "\n";
	os << MakeSep() << "\n";
}
Esempio n. 9
0
void ExcludeCommand :: Exclude(  CSVRow & r ) const {

	CSVRow out;

	if ( mReverse ) {
		std::reverse( r.begin(), r.end() );
	}

	for ( unsigned int i = 0; i < r.size(); i++ ) {
		if ( ! ALib::Contains( mFields, i ) ) {
			out.push_back( r.at( i ) );
		}
	}

	if ( mReverse ) {
		std::reverse( out.begin(), out.end() );
	}

	r.swap( out );
}
Esempio n. 10
0
string WriteFixedCommand :: MakeFixedOutput( const CSVRow & row ) {

	string s;

	for ( unsigned int i = 0; i < mFields.size(); i++ ) {
		string val = mFields[i].first > row.size()
						? ""
						: row[ mFields[i].first - 1 ];
		unsigned int width = mFields[i].second;

		s += ALib::RightPad( val, width );
	}

	return s;
}
Esempio n. 11
0
void AsciiTableCommand :: OutputRow( std::ostream & os, const CSVRow & row ) {
	os << "|";
	for ( unsigned int i = 0; i < mWidths.size() ; i++ ) {
		if ( i < row.size() ) {
			if ( ALib::Contains( mRightAlign, i ) ) {
				os << " "  << ALib::LeftPad( row[i], mWidths[i] ) << " |";
			}
			else {
				os << " "  << ALib::RightPad( row[i], mWidths[i] ) << " |";
			}
		}
		else {
			os << " " << ALib::RightPad( "", mWidths[i] ) << " |";
		}
	}
	os << "\n";
}
Esempio n. 12
0
void ShuffleCommand ::ShuffleFields( CSVRow & row  ) {
    std::vector <string> f;
    for( unsigned int i = 0; i < mFields.size(); i++ ) {
        unsigned int fi = mFields[i];
        if ( fi >= row.size() ) {
            CSVTHROW( "Invalid field index: " << fi + 1 );
        }
        else {
            f.push_back( row[fi] );
        }
    }
    std::random_shuffle( f.begin(), f.end() );
    unsigned int ri = 0;
    for( unsigned int i = 0; i < mFields.size(); i++ ) {
        unsigned int fi = mFields[i];
        row[fi] = f[ri++];
    }
}
Esempio n. 13
0
void TemplateCommand :: HandleSpecialChars( const string & tplate,
											char c, unsigned int & pos,
											const CSVRow & row,
											string & out ) {
	char t = tplate[ pos++ ];
	if ( c == '\\' ) {
		switch( t ) {
			case '\n':
			case '\r':	CSVTHROW( "Invalid escape at end of line" );
			case 'n':	out += '\n'; break;
			case 't':	out += '\t'; break;
			default:	out += t;
		}
	}
	else {		// its a brace
		string ns;
		while( t != POUTRO) {
			if ( t == '\n' || t == '\r' ) {
				CSVTHROW( "Missing closing brace" );
			}
			ns += t;
			t = tplate[ pos++ ];
		}

		if( ns.size() && ns[0] == EVALCHR ) {    // it's an expression
			out += Eval( row, ns );
			return;
		}

		if ( ! ALib::IsInteger( ns ) ) {
			CSVTHROW( "Invalid placeholder: " << "{" << ns << "}" );
		}

		int n =  ALib::ToInteger( ns ) - 1;		// to zero based
		if ( n < 0 ) {
			CSVTHROW( "Invalid placeholder: " << "{" << ns << "}" );
		}

		if ( (unsigned int) n < row.size() ) {
			out += row[ n ];
		}
	}
}
Esempio n. 14
0
void TrimCommand :: Trim( CSVRow & row ) {
    for ( unsigned int i = 0; i < row.size(); i++ ) {
        if ( mFields.size() == 0 || ALib::Contains( mFields, i ) ) {
            if ( mTrimLead && mTrimTrail ) {
                row[i] = ALib::Trim( row[i] );
            }
            else if ( mTrimLead ) {
                row[i] = ALib::LTrim( row[i] );
            }
            else {
                row[i] = ALib::RTrim( row[i] );
            }
        }

        if (  mWidths.size() ) {
            if ( mFields.size() == 0 || ALib::Contains( mFields, i ) ) {
                Chop( row, i );
            }
        }
    }
}
Esempio n. 15
0
string SQLInsertCommand :: CreateValues( const CSVRow & row ) const {

	string vals = "";

	for ( unsigned int i = 0; i < DataCols().size(); i++ ) {
		unsigned int fi = DataCols().at(i).mField;
		if ( fi >= row.size() ) {
			CSVTHROW( "Required field " << fi + 1 << " missing from input" );
		}
		if ( vals != "" ) {
			vals += ", ";
		}

		string field = EmptyToNull( row[fi] );
		vals += ( DoSQLQuote( i ) && ! NoNullQuote( field ) )
					? ALib::SQuote( ALib::SQLQuote( field ) )
					: field;
	}

	return " VALUES( " + vals + ")";
}
Esempio n. 16
0
void RemoveNewlineCommand :: RemoveNewlines( CSVRow & row ) {

	for ( unsigned int i = 0; i < row.size(); i++ ) {
		if ( (mFields.size() == 0 || ALib::Contains( mFields, i ) )
				&& row[i].find_first_of( "\n" ) != std::string::npos ) {
			string s;
			for ( unsigned int j = 0; j < row[i].size(); j++ ) {
				if ( row[i][j] == '\n' ) {
					if ( mExcludeAfter ) {
						break;
					}
					else {
						s += mSep;
					}
				}
				else {
					s += row[i][j];
				}
			}
			row[i] = s;
		}
	}
}
Esempio n. 17
0
void TrimCommand :: Chop( CSVRow & row, unsigned int  i ) {
    if ( mFields.size() == 0 ) {
        if ( i < mWidths.size()  && i < row.size() ) {
            if ( mWidths.at(i) >= 0 ) {
                row.at(i) = row.at(i).substr( 0, mWidths.at(i) );
            }
        }
    }
    else {
        int idx =  ALib::IndexOf( mFields, i );
        if ( idx >= 0 ) {
            if ( idx < (int) mWidths.size()  && i < row.size() ) {
                if ( mWidths.at(idx) >= 0 ) {
                    row.at(i) = row.at(i).substr( 0, mWidths.at(idx) );
                }
            }
        }
    }
}
int32_t main(int32_t argc, char **argv)
{
    uint32_t retVal = 0;
    int recIndex=1;
    bool log=false;
    
    if((argc != 2 && argc != 3 && argc != 4) || (argc==4 && string(argv[1]).compare("-l")!=0))
    {
        errorMessage(string(argv[0]));
        retVal = 1;
    }
    else if(argc==2 && string(argv[1]).compare("-h")==0)
    {
        helpMessage(string(argv[0]));
        retVal = 0;
    }
    else
    {
        // if -l option is set
        if(argc==4 || (argc==3 && string(argv[1]).compare("-l")==0))
        {
            ++recIndex;
            log=true;
        }
        
        // Use command line parameter as file for playback;
        string recordingFile(argv[recIndex]);
        stringstream recordingFileUrl;
        recordingFileUrl << "file://" << recordingFile;

        // Location of the recording file.
        URL url(recordingFileUrl.str());

        // Do we want to rewind the stream on EOF?
        const bool AUTO_REWIND = false;

        // Size of the memory buffer that should fit at least the size of one frame.
        const uint32_t MEMORY_SEGMENT_SIZE = 1024 * 768;

        // Number of memory segments (one is enough as we are running sychronously).
        const uint32_t NUMBER_OF_SEGMENTS = 1;

        // Run player in synchronous mode without data caching in background.
        const bool THREADING = false;

        // Construct the player.
        Player player(url, AUTO_REWIND, MEMORY_SEGMENT_SIZE, NUMBER_OF_SEGMENTS, THREADING);

        // The next container from the recording.
        Container nextContainer;

        // Using OpenCV's IplImage data structure to simply playback the data.
        IplImage *image = NULL;

        // Create the OpenCV playback window.
        cvNamedWindow("CaroloCup-CameraPlayback", CV_WINDOW_AUTOSIZE);

        // This flag indicates whether we have attached already to the shared
        // memory containing the sequence of captured images.
        bool hasAttachedToSharedImageMemory = false;

        // Using this variable, we will access the captured images while
        // also having convenient automated system resource management.
        SharedPointer<SharedMemory> sharedImageMemory;

        ifstream file(argv[recIndex+1]);
        CSVRow row;
        // read out the header row
        row.readNextRow(file);
        uint32_t frameNumber=1, csvFN;
        int32_t VPx,VPy,BLx,BLy,BRx,BRy,TLx,TLy,TRx,TRy;
        stringstream frameMessage;
        stringstream VPMessage;
        frameMessage.str(string());
        VPMessage.str(string());
        bool fbf=false;
        
        // Main data processing loop.
        while (player.hasMoreData()) {
            // Read next entry from recording.
            nextContainer = player.getNextContainerToBeSent();

            // Data type SHARED_IMAGE contains a SharedImage data structure that
            // provides meta-information about the captured image.
            if (nextContainer.getDataType() == Container::SHARED_IMAGE) {
                // Read the data structure to retrieve information about the image.
                SharedImage si = nextContainer.getData<SharedImage>();

                // Check if we have already attached to the shared memory.
                if (!hasAttachedToSharedImageMemory) {
                    sharedImageMemory = SharedMemoryFactory::attachToSharedMemory(si.getName());

                    // Toggle the flag as we have now attached to the shared memory.
                    hasAttachedToSharedImageMemory = true;
                }

                // Check if we could successfully attach to the shared memory.
                if (sharedImageMemory->isValid()) {
                    // Using a scoped lock to get exclusive access.
                    {
                        Lock l(sharedImageMemory);
                        if (image == NULL) {
                            // Create the IplImage header data and access the shared memory for the actual image data. 
                            image = cvCreateImageHeader(cvSize(si.getWidth(), si.getHeight()), IPL_DEPTH_8U, si.getBytesPerPixel());

                            // Let the IplImage point to the shared memory containing the captured image.
                            image->imageData = static_cast<char*>(sharedImageMemory->getSharedMemory());
                        }
                    }

                    // Show the image using OpenCV.
                    
                    // if csv parameter is set
                    if(argc==4 || (argc==3 && string(argv[1]).compare("-l")!=0))
                    {
                        if(! row.readNextRow(file)) break;
                        while(row[0].compare("")==0)
                            if(! row.readNextRow(file)) break;
                        
                        sscanf(row[0].c_str(), "%d", &csvFN);
                        
                        if(frameNumber==csvFN)
                        {
                            Mat img = cvarrToMat(image);
                            
                        
                            frameMessage.str(string());
                            VPMessage.str(string());
                            sscanf(row[9].c_str(), "%d", &VPx);
                            sscanf(row[10].c_str(), "%d", &VPy);
                            
                            frameMessage<<"Frame "<<frameNumber;
                            VPMessage<<"Vanishing Point ("<<VPx<<","<<VPy<<")";
                            
                            setLabel(img, frameMessage.str(), cvPoint(30,45));
                            setLabel(img, VPMessage.str(), cvPoint(30,60));
                            
                            if(log)
                                cout << frameNumber << ", " << VPx << ", " << VPy <<endl;
                            
                            // print support points and lines
                            sscanf(row[1].c_str(), "%d", &BLx);
                            sscanf(row[2].c_str(), "%d", &BLy);BLy+=60;
                            sscanf(row[3].c_str(), "%d", &TLx);
                            sscanf(row[4].c_str(), "%d", &TLy);TLy+=60;
                            sscanf(row[5].c_str(), "%d", &TRx);
                            sscanf(row[6].c_str(), "%d", &TRy);TRy+=60;
                            sscanf(row[7].c_str(), "%d", &BRx);
                            sscanf(row[8].c_str(), "%d", &BRy);BRy+=60;
                            
                            circle(img, Point(BLx,BLy), 5, CV_RGB(255, 255, 255), CV_FILLED);
                            circle(img, Point(TLx,TLy), 5, CV_RGB(255, 255, 255), CV_FILLED);
                            circle(img, Point(TRx,TRy), 5, CV_RGB(255, 255, 255), CV_FILLED);
                            circle(img, Point(BRx,BRy), 5, CV_RGB(255, 255, 255), CV_FILLED);
                            
                            double slope1 = static_cast<double>(TLy-BLy)/static_cast<double>(TLx-BLx);
                            double slope2 = static_cast<double>(TRy-BRy)/static_cast<double>(TRx-BRx);
                            Point p1(0,0), q1(img.cols,img.rows);
                            Point p2(0,0), q2(img.cols,img.rows);
                            p1.y = -(BLx-p1.x) * slope1 + BLy;
                            q1.y = -(TLx-q1.x) * slope1 + TLy;
                            p2.y = -(BRx-p2.x) * slope2 + BRy;
                            q2.y = -(TRx-q2.x) * slope2 + TRy;
                            
                            line(img,p1,q1,CV_RGB(255, 255, 255),1,CV_AA);
                            line(img,p2,q2,CV_RGB(255, 255, 255),1,CV_AA);
                            
                            imshow("CaroloCup-CameraPlayback", img);
                        }
                    }
                    else
                        cvShowImage("CaroloCup-CameraPlayback", image);

                    // Let the image render before proceeding to the next image.
                    char c = cvWaitKey(10);
                    // Check if the user wants to stop the replay by pressing ESC or pause it by pressing SPACE (needed also to go frame-by-frame).
                    if (static_cast<uint8_t>(c) == 27) break;
                    else if (static_cast<uint8_t>(c) == 32 || fbf) {
                        do
                        {
                            c = cvWaitKey();
                        }while(c!='n' && static_cast<uint8_t>(c) != 32 && static_cast<uint8_t>(c) != 27);
                        
                        if (static_cast<uint8_t>(c) == 27) break; // ESC
                        else if (static_cast<uint8_t>(c) == 32) fbf=false; // SPACE -> continue
                        else if (c=='n') fbf=true; // pressed 'n' -> next frame
                    }
                    
                    ++frameNumber;
                }
            }
        }

        // maybe print EOF message && wait for user input?

        // Release IplImage data structure.
        cvReleaseImage(&image);

        // Close playback window.
        cvDestroyWindow("CaroloCup-CameraPlayback");

        // The shared memory will be automatically released.
    }

    // Return error code.
    return retVal;
}
Esempio n. 19
0
void GMCWriter::applyGMCVariantForTDD(TDDTable * tdd, GMCDocument * doc,
                                  std::string type, std::string hz, std::string frameConf, std::string specSubfConf )
{
    // Find column
    int columnIndex = -1;
    std::string cellType = type == "Indoor" ? "very_small" : "small";
    CSVRow * cellTypeRow = tdd->getParameterRowByName("cellType");
    CSVRow * hzRow = tdd->getParameterRowByName("chBw (MHz)");
    CSVRow * frameConfRow = tdd->getParameterRowByName("tddFrameConf");
    CSVRow * specSubfConfRow = tdd->getParameterRowByName("tddSpecSubfConf");

    if ( cellTypeRow == NULL || hzRow == NULL || frameConfRow == NULL || specSubfConfRow == NULL )
        return;

    int cellsCount = cellTypeRow->getCells().size();

    for ( int i = 1; i < cellsCount; i ++ )
    {
        if ( cellTypeRow->getCell(i) == cellType &&
             hzRow->getCell(i) == hz &&
             frameConfRow->getCell(i) == frameConf &&
             specSubfConfRow->getCell(i) == specSubfConf)
        {
            columnIndex = i;
            break;
        }
    }
    if ( columnIndex == -1 )
        return;

    // Apply changes to LNCEL
    vector<GMCManagedObject*> mocs = doc->getMocsByClassName("LNCEL");
    for ( vector<GMCManagedObject*>::iterator it = mocs.begin(); it != mocs.end(); it ++ )
    {
        vector<CSVRow*> parameterRows = tdd->getParameterRows();
        for ( vector<CSVRow*>::iterator itParRow = parameterRows.begin(); itParRow != parameterRows.end(); itParRow ++ )
        {
            GMCManagedObject * m = *it;
            CSVRow * parRow = *itParRow;
            GMCManagedObjectParameter * p = m->getParameterByName(parRow->getCell(0));
            if ( p != NULL )
            {
                modifyParameterSimpleTypeFromSameGmc(doc, p, parRow->getCell(columnIndex));
            }
        }
    }

}
Esempio n. 20
0
string PivotCommand :: GetFact( const CSVRow & row ) const {
    if ( mFact >= row.size() ) {
        CSVTHROW( "Invalid fact index: " << mFact );
    }
    return row[mFact];
}
Esempio n. 21
0
void GMCWriter::applyGMCVariantForFDDOutdoor(FDDOutdoorTable * fdd, GMCDocument * doc, std::string hz )
{
    // Find column
    int columnIndex = -1;
    CSVRow * hzRow = fdd->getParameterRowByName("dlChBw");

    if ( hzRow == NULL  )
        return;

    int cellsCount = hzRow->getCells().size();

    for ( int i = 1; i < cellsCount; i ++ )
    {
        if ( hzRow->getCell(i) == hz )
        {
            columnIndex = i;
            break;
        }
    }
    if ( columnIndex == -1 )
        return;

    // Apply changes to LNCEL
    vector<GMCManagedObject*> mocs = doc->getMocsByClassName("LNCEL");
    for ( vector<GMCManagedObject*>::iterator it = mocs.begin(); it != mocs.end(); it ++ )
    {
        vector<CSVRow*> parameterRows = fdd->getParameterRows();
        for ( vector<CSVRow*>::iterator itParRow = parameterRows.begin(); itParRow != parameterRows.end(); itParRow ++ )
        {
            GMCManagedObject * m = *it;
            CSVRow * parRow = *itParRow;
            GMCManagedObjectParameter * p = m->getParameterByName(parRow->getCell(3));
            if ( p != NULL )
            {
                if ( parRow->getCell(3) != "earfcnDL" && parRow->getCell(3) != "earfcnUL" )
                {
                    if ( parRow->getCell(1) != "" )
                    {
                        GMCManagedObjectParameter * compPar = m->getParameterByName(parRow->getCell(1));
                        if ( compPar != NULL )
                            modifyParameterComplexTypeFromSameGmc(doc, compPar, parRow->getCell(3), parRow->getCell(columnIndex));
                    }
                    else
                    {
                        if ( XmlElementReader::getName(p->getElement()) == "p" )
                            modifyParameterSimpleTypeFromSameGmc(doc, p, parRow->getCell(columnIndex));
                    }
                }
            }
        }
    }
}
Esempio n. 22
0
void printRow(const CSVRow& row) {
	printf("[%d:%lu] ", row.getIndex(), row.getCount(true));
	UnicodeString temp;
	CSVFormatter::formatRow(row, temp, sepchar);
	std::cout<<temp<<std::endl;
}
void DataRecorder::Record(CSVRow row, std::string identifier)
{
	assert(row.m_cellData.size() == m_streams[identifier]->m_columns);

	m_streams[identifier]->m_stream << row.GetRow();
}