int main(int argc, char** argv) {
Timer* logTimer = new Timer();
QApplication app(argc, argv);
Logger logger("Main");
Logger::initialize(Logger::Level::TRACE,true, true, logTimer);
logger.trace("Logger initialized.");
PropertyReader* propReader;
Properties* settings;
if (argc > 1) {
propReader = new PropertyReader(argv[1]);
} else {
propReader = new PropertyReader("../src/settings/settings.txt");
}
// Set logging level
settings = propReader->load();
std::string loggingLevel = settings->getProperty("LOGGING_LEVEL");
if (loggingLevel == "OFF") {
Logger::setLoggingLevel(Logger::Level::OFF);
} else if (loggingLevel == "TRACE") {
Logger::setLoggingLevel(Logger::Level::TRACE);
} else if (loggingLevel == "INFO") {
Logger::setLoggingLevel(Logger::Level::INFO);
} else if (loggingLevel == "DEBUG") {
Logger::setLoggingLevel(Logger::Level::DEBUG);
} else if (loggingLevel == "WARN") {
Logger::setLoggingLevel(Logger::Level::WARN);
} else if (loggingLevel == "ERROR") {
Logger::setLoggingLevel(Logger::Level::ERROR);
}
// Set default HSV Filter values
if (!settings->getProperty("LOW_HUE").empty()) {
HSVFilter::defaultLowH = std::stoi(settings->getProperty("LOW_HUE"));
}
if (!settings->getProperty("HIGH_HUE").empty()) {
HSVFilter::defaultHighH = std::stoi(settings->getProperty("HIGH_HUE"));
}
if (!settings->getProperty("LOW_SATURATION").empty()) {
HSVFilter::defaultLowS = std::stoi(settings->getProperty("LOW_SATURATION"));
}
if (!settings->getProperty("HIGH_SATURATION").empty()) {
HSVFilter::defaultHighS = std::stoi(settings->getProperty("HIGH_SATURATION"));
}
if (!settings->getProperty("LOW_VALUE").empty()) {
HSVFilter::defaultLowV = std::stoi(settings->getProperty("LOW_VALUE"));
}
if (!settings->getProperty("HIGH_VALUE").empty()) {
HSVFilter::defaultHighV = std::stoi(settings->getProperty("HIGH_VALUE"));
}
std::string mode = settings->getProperty("MODE");
if (mode == "HSVTEST") {
VideoTesting vt(0); //camera id or file name
vt.run(1); //0 = video; 1 = webcam; 2 = image
} else {
init_signal_handler();
SubZeroFactory* subZeroFactory = new SubZeroFactory(settings);
Stage* mainStage = new Stage(NULL, subZeroFactory);
mainStage->setViewContent(mode);
mainStage->initialize();
delete propReader;
}
return app.exec();
}
static void initialize(Stage& s, PointTableRef table)
{
s.l_initialize(table);
s.initialize();
}
int Delta::execute()
{
Options sourceOptions;
{
sourceOptions.add<std::string>("filename", m_sourceFile);
sourceOptions.add<bool>("debug", isDebug());
sourceOptions.add<boost::uint32_t>("verbose", getVerboseLevel());
}
Stage* source = AppSupport::makeReader(sourceOptions);
source->initialize();
boost::uint32_t totalPointCount(source->getNumPoints());
PointBuffer source_data(source->getSchema(), totalPointCount);
StageSequentialIterator* source_iter = source->createSequentialIterator(source_data);
boost::uint32_t numRead = source_iter->read(source_data);
assert(numRead == source_data.getNumPoints());
delete source_iter;
delete source;
Options candidateOptions;
{
candidateOptions.add<std::string>("filename", m_candidateFile);
candidateOptions.add<bool>("debug", isDebug());
candidateOptions.add<boost::uint32_t>("verbose", getVerboseLevel());
}
Stage* candidate = AppSupport::makeReader(candidateOptions);
candidate->initialize();
IndexedPointBuffer candidate_data(candidate->getSchema(), totalPointCount);
StageSequentialIterator* candidate_iter = candidate->createSequentialIterator(candidate_data);
numRead = candidate_iter->read(candidate_data);
assert(numRead == candidate_data.getNumPoints());
delete candidate_iter;
if (source_data.getNumPoints() != candidate_data.getNumPoints())
{
std::cerr << "Source and candidate files do not have the same point count, testing each source point only!" << std::endl;
}
// m_summary_x(xd);
// m_summary_y(yd);
// m_summary_z(zd);
if (m_outputFileName.size())
{
m_outputStream = FileUtils::createFile(m_outputFileName);
}
candidate_data.build(m_3d);
boost::uint32_t count(std::min(source_data.getNumPoints(), candidate_data.getNumPoints()));
boost::scoped_ptr<std::map<Point, Point> > points(cumulatePoints(source_data, candidate_data));
if (m_OutputDetail)
{
outputDetail(source_data, candidate_data, points.get());
return 0;
}
std::map<Point, Point>::const_iterator i;
for(i = points->begin(); i != points->end(); ++i)
{
Point const& s = i->first;
Point const& c = i->second;
double xd = s.x - c.x;
double yd = s.y - c.y;
double zd = s.z - c.z;
m_summary_x(xd);
m_summary_y(yd);
m_summary_z(zd);
}
std::string headline("------------------------------------------------------------------------------------------");
std::cout << headline << std::endl;
std::cout << " Delta summary for source '" << m_sourceFile << "' and candidate '" << m_candidateFile <<"'" << std::endl;
std::cout << headline << std::endl;
std::cout << std::endl;
std::string thead("----------- --------------- --------------- --------------");
std::cout << thead << std::endl;
std::cout << " Dimension X Y Z " << std::endl;
std::cout << thead << std::endl;
boost::format fmt("%.4f");
double sminx = (boost::accumulators::min)(m_summary_x);
double sminy = (boost::accumulators::min)(m_summary_y);
double sminz = (boost::accumulators::min)(m_summary_z);
double smaxx = (boost::accumulators::max)(m_summary_x);
double smaxy = (boost::accumulators::max)(m_summary_y);
double smaxz = (boost::accumulators::max)(m_summary_z);
double smeanx = (boost::accumulators::mean)(m_summary_x);
double smeany = (boost::accumulators::mean)(m_summary_y);
double smeanz = (boost::accumulators::mean)(m_summary_z);
std::cout << " Min " << fmt % sminx << " " << fmt % sminy << " " << fmt % sminz<<std::endl;
std::cout << " Min " << fmt % smaxx << " " << fmt % smaxy << " " << fmt % smaxz<<std::endl;
std::cout << " Mean " << fmt % smeanx << " " << fmt % smeany << " " << fmt % smeanz<<std::endl;
std::cout << thead << std::endl;
return 0;
}