DOMLSParser* XQillaImplementation::createLSParser(const DOMImplementationLS::DOMImplementationLSMode mode,
const XMLCh* const schemaType,
MemoryManager* const manager,
XMLGrammarPool* const gramPool)
{
XMLGrammarPool *temp = 0;
bool adoptGramPool = false;
if(!gramPool) {
temp = new (manager) XQillaXMLGrammarPoolImpl(manager);
adoptGramPool = true;
}
else {
temp = gramPool;
}
if(mode == DOMImplementationLS::MODE_ASYNCHRONOUS)
throw DOMException(DOMException::NOT_SUPPORTED_ERR, 0);
DOMLSParser *tmp = new (manager) XQillaBuilderImpl(0, manager, temp, adoptGramPool);
#if _XERCES_VERSION >= 30000
tmp->getDomConfig()->setParameter(XMLUni::fgXercesParserUseDocumentFromImplementation, (void*)gXQilla);
tmp->getDomConfig()->setParameter(XMLUni::fgXercesCacheGrammarFromParse, true);
#else
tmp->setProperty(XMLUni::fgXercesParserUseDocumentFromImplementation, (void*)gXQilla);
tmp->setFeature(XMLUni::fgXercesCacheGrammarFromParse, true);
#endif
return tmp;
}
DOMLSParser* ObtainParser(DOMErrorHandler& errHandler) {
const XMLCh ls_id [] = {chLatin_L, chLatin_S, chNull};
// Get an implementation of the Load-Store (LS) interface.
//
DOMImplementation* impl(DOMImplementationRegistry::getDOMImplementation (ls_id));
DOMLSParser *parser (impl->createLSParser (DOMImplementationLS::MODE_SYNCHRONOUS, 0));
DOMConfiguration* conf (parser->getDomConfig ());
// Discard comment nodes in the document.
//
conf->setParameter (XMLUni::fgDOMComments, false);
// Enable datatype normalization.
//
conf->setParameter (XMLUni::fgDOMDatatypeNormalization, true);
// Do not create EntityReference nodes in the DOM tree. No
// EntityReference nodes will be created, only the nodes
// corresponding to their fully expanded substitution text
// will be created.
//
conf->setParameter (XMLUni::fgDOMEntities, false);
// Perform namespace processing.
//
conf->setParameter (XMLUni::fgDOMNamespaces, true);
// Do not include ignorable whitespace in the DOM tree.
//
conf->setParameter (XMLUni::fgDOMElementContentWhitespace, false);
// Enable/Disable validation.
//
conf->setParameter (XMLUni::fgDOMValidate, false);
conf->setParameter (XMLUni::fgXercesSchema, false);
conf->setParameter (XMLUni::fgXercesSchemaFullChecking, false);
// Xerces-C++ 3.1.0 is the first version with working multi import
// support.
//
#if _XERCES_VERSION >= 30100
conf->setParameter (XMLUni::fgXercesHandleMultipleImports, true);
#endif
// We will release the DOM document ourselves.
//
conf->setParameter (XMLUni::fgXercesUserAdoptsDOMDocument, true);
// Set error handler.
//
conf->setParameter (XMLUni::fgDOMErrorHandler, &errHandler);
return parser;
}
int main (int argC, char *argV[])
{
MemoryMonitor *staticMemMonitor = new MemoryMonitor();
// Initialize the XML4C system
try
{
XMLPlatformUtils::Initialize(XMLUni::fgXercescDefaultLocale, 0, 0, staticMemMonitor);
}
catch (const XMLException& toCatch)
{
char *msg = XMLString::transcode(toCatch.getMessage());
XERCES_STD_QUALIFIER cerr << "Error during initialization! :\n"
<< msg << XERCES_STD_QUALIFIER endl;
XMLString::release(&msg);
return 1;
}
// Check command line and extract arguments.
if (argC < 2)
{
usage();
return 1;
}
const char* xmlFile = 0;
AbstractDOMParser::ValSchemes domBuilderValScheme = AbstractDOMParser::Val_Auto;
bool doNamespaces = false;
bool doSchema = false;
bool schemaFullChecking = false;
bool doList = false;
int numReps =1;
int argInd;
for (argInd = 1; argInd < argC; argInd++)
{
// Break out on first parm not starting with a dash
if (argV[argInd][0] != '-')
break;
// Watch for special case help request
if (!strcmp(argV[argInd], "-?"))
{
usage();
return 2;
}
else if (!strncmp(argV[argInd], "-v=", 3)
|| !strncmp(argV[argInd], "-V=", 3))
{
const char* const parm = &argV[argInd][3];
if (!strcmp(parm, "never"))
domBuilderValScheme = AbstractDOMParser::Val_Never;
else if (!strcmp(parm, "auto"))
domBuilderValScheme = AbstractDOMParser::Val_Auto;
else if (!strcmp(parm, "always"))
domBuilderValScheme = AbstractDOMParser::Val_Always;
else
{
XERCES_STD_QUALIFIER cerr << "Unknown -v= value: " << parm << XERCES_STD_QUALIFIER endl;
return 2;
}
}
else if (!strcmp(argV[argInd], "-n")
|| !strcmp(argV[argInd], "-N"))
{
doNamespaces = true;
}
else if (!strcmp(argV[argInd], "-s")
|| !strcmp(argV[argInd], "-S"))
{
doSchema = true;
}
else if (!strcmp(argV[argInd], "-f")
|| !strcmp(argV[argInd], "-F"))
{
schemaFullChecking = true;
}
else if (!strcmp(argV[argInd], "-l")
|| !strcmp(argV[argInd], "-L"))
{
doList = true;
}
else if (!strncmp(argV[argInd], "-r=", 3)
|| !strncmp(argV[argInd], "-R=", 3))
{
const char* const numStr = &argV[argInd][3];
XMLCh* numXStr = XMLString::transcode(numStr);
numReps = XMLString::parseInt(numXStr);
XMLString::release(&numXStr);
}
else
{
XERCES_STD_QUALIFIER cerr << "Unknown option '" << argV[argInd]
<< "', ignoring it\n" << XERCES_STD_QUALIFIER endl;
}
}
//
// There should be only one and only one parameter left, and that
// should be the file name.
//
if (argInd != argC - 1)
{
usage();
return 1;
}
// Instantiate the DOM domBuilder with its memory manager.
MemoryMonitor *domBuilderMemMonitor = new MemoryMonitor();
static const XMLCh gLS[] = { chLatin_L, chLatin_S, chNull };
DOMImplementation *impl = DOMImplementationRegistry::getDOMImplementation(gLS);
DOMLSParser *domBuilder = ((DOMImplementationLS*)impl)->createLSParser(DOMImplementationLS::MODE_SYNCHRONOUS, 0, domBuilderMemMonitor);
DOMLSParserHandler domBuilderHandler;
domBuilder->getDomConfig()->setParameter(XMLUni::fgDOMErrorHandler, &domBuilderHandler);
// Instantiate the SAX2 parser with its memory manager.
MemoryMonitor *sax2MemMonitor = new MemoryMonitor();
SAX2XMLReader *sax2parser = XMLReaderFactory::createXMLReader(sax2MemMonitor);
SAXErrorHandler saxErrorHandler;
sax2parser->setErrorHandler(&saxErrorHandler);
// Instantiate the SAX 1 parser with its memory manager.
MemoryMonitor *sax1MemMonitor = new MemoryMonitor();
SAXParser *saxParser = new (sax1MemMonitor) SAXParser(0, sax1MemMonitor);
saxParser->setErrorHandler(&saxErrorHandler);
// set features
domBuilder->getDomConfig()->setParameter(XMLUni::fgDOMNamespaces, doNamespaces);
sax2parser->setFeature(XMLUni::fgSAX2CoreNameSpaces, doNamespaces);
saxParser->setDoNamespaces(doNamespaces);
domBuilder->getDomConfig()->setParameter(XMLUni::fgXercesSchema, doSchema);
sax2parser->setFeature(XMLUni::fgXercesSchema, doSchema);
saxParser->setDoSchema(doSchema);
domBuilder->getDomConfig()->setParameter(XMLUni::fgXercesHandleMultipleImports, true);
sax2parser->setFeature(XMLUni::fgXercesHandleMultipleImports, true);
saxParser->setHandleMultipleImports (true);
domBuilder->getDomConfig()->setParameter(XMLUni::fgXercesSchemaFullChecking, schemaFullChecking);
sax2parser->setFeature(XMLUni::fgXercesSchemaFullChecking, schemaFullChecking);
saxParser->setValidationSchemaFullChecking(schemaFullChecking);
if (domBuilderValScheme == AbstractDOMParser::Val_Auto)
{
domBuilder->getDomConfig()->setParameter(XMLUni::fgDOMValidateIfSchema, true);
sax2parser->setFeature(XMLUni::fgSAX2CoreValidation, true);
sax2parser->setFeature(XMLUni::fgXercesDynamic, true);
saxParser->setValidationScheme(SAXParser::Val_Auto);
}
else if (domBuilderValScheme == AbstractDOMParser::Val_Never)
{
domBuilder->getDomConfig()->setParameter(XMLUni::fgDOMValidate, false);
sax2parser->setFeature(XMLUni::fgSAX2CoreValidation, false);
saxParser->setValidationScheme(SAXParser::Val_Never);
}
else if (domBuilderValScheme == AbstractDOMParser::Val_Always)
{
domBuilder->getDomConfig()->setParameter(XMLUni::fgDOMValidate, true);
sax2parser->setFeature(XMLUni::fgSAX2CoreValidation, true);
sax2parser->setFeature(XMLUni::fgXercesDynamic, false);
saxParser->setValidationScheme(SAXParser::Val_Always);
}
// enable datatype normalization - default is off
domBuilder->getDomConfig()->setParameter(XMLUni::fgDOMDatatypeNormalization, true);
XERCES_STD_QUALIFIER ifstream fin;
bool more = true;
// the input is a list file
if (doList)
fin.open(argV[argInd]);
if (fin.fail()) {
XERCES_STD_QUALIFIER cerr <<"Cannot open the list file: " << argV[argInd] << XERCES_STD_QUALIFIER endl;
return 2;
}
while (more)
{
char fURI[1000];
//initialize the array to zeros
memset(fURI,0,sizeof(fURI));
if (doList) {
if (! fin.eof() ) {
fin.getline (fURI, sizeof(fURI));
if (!*fURI)
continue;
else {
xmlFile = fURI;
XERCES_STD_QUALIFIER cerr << "==Parsing== " << xmlFile << XERCES_STD_QUALIFIER endl;
}
}
else
break;
}
else {
xmlFile = argV[argInd];
more = false;
}
// parse numReps times (in case we need it for some reason)
for (int i=0; i<numReps; i++)
{
XERCES_CPP_NAMESPACE_QUALIFIER DOMDocument *doc = 0;
try
{
// reset document pool
domBuilder->resetDocumentPool();
doc = domBuilder->parseURI(xmlFile);
if(doc && doc->getDocumentElement())
{
XERCES_CPP_NAMESPACE_QUALIFIER DOMNodeList *list=NULL;
if(doNamespaces)
list=doc->getElementsByTagNameNS(doc->getDocumentElement()->getNamespaceURI(), doc->getDocumentElement()->getLocalName());
else
list=doc->getElementsByTagName(doc->getDocumentElement()->getNodeName());
if(list==NULL)
XERCES_STD_QUALIFIER cout << "getElementsByTagName didn't return a valid DOMNodeList." << XERCES_STD_QUALIFIER endl;
else if(list->item(0)!=doc->getDocumentElement())
XERCES_STD_QUALIFIER cout << "getElementsByTagName didn't find the root element." << XERCES_STD_QUALIFIER endl;
}
sax2parser->parse(xmlFile);
saxParser->parse(xmlFile);
}
catch (const OutOfMemoryException&)
{
XERCES_STD_QUALIFIER cerr << "OutOfMemoryException during parsing: '" << xmlFile << "'\n" << XERCES_STD_QUALIFIER endl;;
continue;
}
catch (const XMLException& toCatch)
{
char *msg = XMLString::transcode(toCatch.getMessage());
XERCES_STD_QUALIFIER cerr << "\nError during parsing: '" << xmlFile << "'\n"
<< "Exception message is: \n"
<< msg << "\n" << XERCES_STD_QUALIFIER endl;
XMLString::release(&msg);
continue;
}
catch (const DOMException& toCatch)
{
const unsigned int maxChars = 2047;
XMLCh errText[maxChars + 1];
XERCES_STD_QUALIFIER cerr << "\nDOM Error during parsing: '" << xmlFile << "'\n"
<< "DOMException code is: " << toCatch.code << XERCES_STD_QUALIFIER endl;
if (DOMImplementation::loadDOMExceptionMsg(toCatch.code, errText, maxChars))
{
char * msg = XMLString::transcode(errText);
XERCES_STD_QUALIFIER cerr << "Message is: " << msg << XERCES_STD_QUALIFIER endl;
continue;
}
}
catch (...)
{
XERCES_STD_QUALIFIER cerr << "\nUnexpected exception during parsing: '" << xmlFile << "'\n";
continue;
}
}
}
//
// Delete the domBuilder itself. Must be done prior to calling Terminate, below.
//
domBuilder->release();
delete sax2parser;
delete saxParser;
XERCES_STD_QUALIFIER cout << "At destruction, domBuilderMemMonitor has " << domBuilderMemMonitor->getTotalMemory() << " bytes." << XERCES_STD_QUALIFIER endl;
XERCES_STD_QUALIFIER cout << "At destruction, sax2MemMonitor has " << sax2MemMonitor->getTotalMemory() << " bytes." << XERCES_STD_QUALIFIER endl;
XERCES_STD_QUALIFIER cout << "At destruction, sax1MemMonitor has " << sax1MemMonitor->getTotalMemory() << " bytes." << XERCES_STD_QUALIFIER endl;
delete domBuilderMemMonitor;
delete sax2MemMonitor;
delete sax1MemMonitor;
XMLPlatformUtils::Terminate();
XERCES_STD_QUALIFIER cout << "At destruction, staticMemMonitor has " << staticMemMonitor->getTotalMemory() << " bytes." << XERCES_STD_QUALIFIER endl;
delete staticMemMonitor;
return 0;
}
bool XmlWorldReader::Read(const std::string &file) {
// ワールドを初期化
try {
initialize();
if (initFlag) {
initializeWorld();
}
} catch (...) {
return false;
}
// TODO: ファイルの有無を確認
// XMLファイルをパース
const XMLCh gLS[] = {chLatin_L, chLatin_S, chNull};
DOMImplementationLS *impl = DOMImplementationRegistry::getDOMImplementation(gLS);
DOMLSParser *parser = impl->createLSParser(
DOMImplementationLS::MODE_SYNCHRONOUS, NULL
);
DOMDocument *doc = parser->parseURI(file.c_str());
if (doc == nullptr) {
return false;
}
// rootノードを取得
DOMElement *worldElement = doc->getDocumentElement();
if (worldElement == nullptr) {
parser->release();
return false;
}
{
YPT::XmlString temp("world");
bool res = XMLString::equals(worldElement->getNodeName(), temp);
if (!res) {
parser->release();
return false;
}
}
// ロード用クラス作成
YPT::XmlWorldPartReader partReader(doc);
// XPathコンテキスト作成
DOMXPathNSResolver *resolver = doc->createNSResolver(worldElement);
if (resolver == nullptr) {
parser->release();
return false;
}
YPT::XmlString str, str2;
DOMXPathResult *result;
// --------------------------------------------------
// ワールド全体の設定
// --------------------------------------------------
// ワールド名
str = worldElement->getAttribute(YPT::XmlString("name"));
if (str != "") {
name = str;
}
// 重力ベクトル
result = doc->evaluate(
YPT::XmlString("./gravity"), worldElement, resolver,
DOMXPathResult::ORDERED_NODE_SNAPSHOT_TYPE,
NULL
);
if (result != nullptr) {
if (result->getSnapshotLength() >= 1) {
str = result->getNodeValue()->getTextContent();
b2Vec2 temp;
if (!YPT::ConvertStrToVec2(str.ToChar(), &temp)) {
world.SetGravity(temp);
}
}
result->release();
}
// --------------------------------------------------
// shapes
// --------------------------------------------------
result = doc->evaluate(
YPT::XmlString("./shape"), worldElement, resolver,
DOMXPathResult::ORDERED_NODE_SNAPSHOT_TYPE,
NULL
);
if (result != nullptr) {
const XMLSize_t len = result->getSnapshotLength();
for (XMLSize_t i = 0; i < len; ++i) {
result->snapshotItem(i);
DOMNode *node = result->getNodeValue();
if (node == nullptr) {
continue;
}
DOMNamedNodeMap *nodeMap = node->getAttributes();
if (nodeMap == nullptr) {
continue;
}
DOMNode *typeNode = nodeMap->getNamedItem(YPT::XmlString("type"));
if (typeNode == nullptr) {
continue;
}
str = typeNode->getNodeValue();
b2Shape::Type type;
int index;
if (str == "circle") {
type = b2Shape::e_circle;
b2CircleShape temp;
if (partReader.ReadCircleShape(node, &temp)) {
circleShapes.push_back(temp);
index = circleShapes.size()-1;
} else {
// 読み込み失敗
continue;
}
} else if (str == "edge") {
type = b2Shape::e_edge;
b2EdgeShape temp;
if (partReader.ReadEdgeShape(node, &temp)) {
edgeShapes.push_back(temp);
index = edgeShapes.size()-1;
} else {
// 読み込み失敗
continue;
}
} else if (str == "polygon") {
type = b2Shape::e_polygon;
b2PolygonShape temp;
if (partReader.ReadPolygonShape(node, &temp)) {
polygonShapes.push_back(temp);
index = polygonShapes.size()-1;
} else {
// 読み込み失敗
continue;
}
} else if (str == "chain") {
type = b2Shape::e_chain;
b2ChainShape temp;
if (partReader.ReadChainShape(node, &temp)) {
chainShapes.push_back(temp);
index = chainShapes.size()-1;
} else {
// 読み込み失敗
continue;
}
} else {
// 未対応
continue;
}
// nameプロパティがあれば保存
DOMNode *name = nodeMap->getNamedItem(YPT::XmlString("name"));
if (name != nullptr) {
str = name->getNodeValue();
shapes.insert(ShapesMap::value_type(
std::string(str),
std::make_pair(type, index)
));
}
}
result->release();
}
// --------------------------------------------------
// fixtures
// --------------------------------------------------
result = doc->evaluate(
YPT::XmlString("./fixture"), worldElement, resolver,
DOMXPathResult::ORDERED_NODE_SNAPSHOT_TYPE,
NULL
);
if (result != nullptr) {
const XMLSize_t len = result->getSnapshotLength();
for (XMLSize_t i = 0; i < len; ++i) {
result->snapshotItem(i);
DOMNode *node = result->getNodeValue();
if (node == nullptr) {
continue;
}
DOMXPathResult *result2 = doc->evaluate(
YPT::XmlString("./shape"), node, resolver,
DOMXPathResult::ORDERED_NODE_SNAPSHOT_TYPE,
NULL
);
if (result2 == nullptr) {
continue;
}
DOMNode *shapeNode = result2->getNodeValue();
if (shapeNode == nullptr) {
continue;
}
str = shapeNode->getTextContent();
result2->release();
ShapesMap::iterator found = shapes.find(std::string(str));
if (found == shapes.end()) {
continue;
}
// fixture読み込み
b2FixtureDef fixtureDef;
b2Shape *shape = NULL;
int index = found->second.second;
switch (found->second.first) {
case b2Shape::e_circle:
shape = &circleShapes[index];
break;
case b2Shape::e_edge:
shape = &edgeShapes[index];
break;
case b2Shape::e_polygon:
shape = &polygonShapes[index];
break;
case b2Shape::e_chain:
shape = &chainShapes[index];
break;
default:
// 未対応
break;
}
if (shape == NULL) {
continue;
}
if (partReader.ReadFixture(node, shape, &fixtureDef)) {
// 読み込み成功
// nameプロパティがあれば保存する
DOMNamedNodeMap *nodeMap = node->getAttributes();
if (nodeMap == nullptr) {
continue;
}
DOMNode *nameNode = nodeMap->getNamedItem(YPT::XmlString("name"));
if (nameNode == nullptr) {
continue;
}
str = nameNode->getNodeValue();
fixtures.insert(FixturesMap::value_type(
std::string(str), fixtureDef
));
}
}
result->release();
}
// --------------------------------------------------
// bodies
// --------------------------------------------------
result = doc->evaluate(
YPT::XmlString("./body"), worldElement, resolver,
DOMXPathResult::ORDERED_NODE_SNAPSHOT_TYPE,
NULL
);
if (result != nullptr) {
const XMLSize_t len = result->getSnapshotLength();
for (XMLSize_t i = 0; i < len; ++i) {
result->snapshotItem(i);
DOMNode *node = result->getNodeValue();
if (node == nullptr) {
continue;
}
DOMXPathResult *result2 = doc->evaluate(
YPT::XmlString("./fixtures/fixture"), node, resolver,
DOMXPathResult::ORDERED_NODE_SNAPSHOT_TYPE,
NULL
);
if (result2 == nullptr) {
continue;
}
std::vector< b2FixtureDef *> fixtureDefs;
const XMLSize_t fixturesLen = result2->getSnapshotLength();
for (XMLSize_t j = 0; j < fixturesLen; ++j) {
result2->snapshotItem(j);
DOMNode *fixtureNode = result2->getNodeValue();
if (fixtureNode == nullptr) {
continue;
}
str = fixtureNode->getTextContent();
FixturesMap::iterator found = fixtures.find(
std::string(str)
);
if (found != fixtures.end()) {
fixtureDefs.push_back(&found->second);
}
}
result2->release();
b2Body *body = partReader.ReadBody(world, node, fixtureDefs);
if (body != nullptr) {
// 読み込み成功
// nameプロパティがあれば保存する
DOMNamedNodeMap *nodeMap = node->getAttributes();
if (nodeMap == nullptr) {
continue;
}
DOMNode *nameNode = nodeMap->getNamedItem(YPT::XmlString("name"));
if (nameNode == nullptr) {
continue;
}
str = nameNode->getNodeValue();
bodies.insert(BodiesMap::value_type(
std::string(str), body
));
}
}
result->release();
}
// --------------------------------------------------
// 読み込み完了
// --------------------------------------------------
resolver->release();
parser->release();
return true;
}
// ---------------------------------------------------------------------------
//
// main
//
// ---------------------------------------------------------------------------
int main(int argC, char* argV[])
{
// Check command line and extract arguments.
if (argC < 2)
{
usage();
return 1;
}
const char* xmlFile = 0;
AbstractDOMParser::ValSchemes valScheme = AbstractDOMParser::Val_Auto;
bool doNamespaces = false;
bool doSchema = false;
bool schemaFullChecking = false;
bool disallowDoctype = false;
bool doList = false;
bool errorOccurred = false;
bool recognizeNEL = false;
bool printOutEncounteredEles = false;
char localeStr[64];
memset(localeStr, 0, sizeof localeStr);
int argInd;
for (argInd = 1; argInd < argC; argInd++)
{
// Break out on first parm not starting with a dash
if (argV[argInd][0] != '-')
break;
// Watch for special case help request
if (!strcmp(argV[argInd], "-?"))
{
usage();
return 2;
}
else if (!strncmp(argV[argInd], "-v=", 3)
|| !strncmp(argV[argInd], "-V=", 3))
{
const char* const parm = &argV[argInd][3];
if (!strcmp(parm, "never"))
valScheme = AbstractDOMParser::Val_Never;
else if (!strcmp(parm, "auto"))
valScheme = AbstractDOMParser::Val_Auto;
else if (!strcmp(parm, "always"))
valScheme = AbstractDOMParser::Val_Always;
else
{
XERCES_STD_QUALIFIER cerr << "Unknown -v= value: " << parm << XERCES_STD_QUALIFIER endl;
return 2;
}
}
else if (!strcmp(argV[argInd], "-n")
|| !strcmp(argV[argInd], "-N"))
{
doNamespaces = true;
}
else if (!strcmp(argV[argInd], "-s")
|| !strcmp(argV[argInd], "-S"))
{
doSchema = true;
}
else if (!strcmp(argV[argInd], "-f")
|| !strcmp(argV[argInd], "-F"))
{
schemaFullChecking = true;
}
else if (!strcmp(argV[argInd], "-l")
|| !strcmp(argV[argInd], "-L"))
{
doList = true;
}
else if (!strcmp(argV[argInd], "-d")
|| !strcmp(argV[argInd], "-D"))
{
disallowDoctype = true;
}
else if (!strcmp(argV[argInd], "-special:nel"))
{
// turning this on will lead to non-standard compliance behaviour
// it will recognize the unicode character 0x85 as new line character
// instead of regular character as specified in XML 1.0
// do not turn this on unless really necessary
recognizeNEL = true;
}
else if (!strcmp(argV[argInd], "-p")
|| !strcmp(argV[argInd], "-P"))
{
printOutEncounteredEles = true;
}
else if (!strncmp(argV[argInd], "-locale=", 8))
{
// Get out the end of line
strcpy(localeStr, &(argV[argInd][8]));
}
else
{
XERCES_STD_QUALIFIER cerr << "Unknown option '" << argV[argInd]
<< "', ignoring it\n" << XERCES_STD_QUALIFIER endl;
}
}
//
// There should be only one and only one parameter left, and that
// should be the file name.
//
if (argInd != argC - 1)
{
usage();
return 1;
}
// Initialize the XML4C system
try
{
if (strlen(localeStr))
{
XMLPlatformUtils::Initialize(localeStr);
}
else
{
XMLPlatformUtils::Initialize();
}
if (recognizeNEL)
{
XMLPlatformUtils::recognizeNEL(recognizeNEL);
}
}
catch (const XMLException& toCatch)
{
XERCES_STD_QUALIFIER cerr << "Error during initialization! :\n"
<< StrX(toCatch.getMessage()) << XERCES_STD_QUALIFIER endl;
return 1;
}
// Instantiate the DOM parser.
static const XMLCh gLS[] = { chLatin_L, chLatin_S, chNull };
DOMImplementation *impl = DOMImplementationRegistry::getDOMImplementation(gLS);
DOMLSParser *parser = ((DOMImplementationLS*)impl)->createLSParser(DOMImplementationLS::MODE_SYNCHRONOUS, 0);
DOMConfiguration *config = parser->getDomConfig();
config->setParameter(XMLUni::fgDOMNamespaces, doNamespaces);
config->setParameter(XMLUni::fgXercesSchema, doSchema);
config->setParameter(XMLUni::fgXercesHandleMultipleImports, true);
config->setParameter(XMLUni::fgXercesSchemaFullChecking, schemaFullChecking);
config->setParameter(XMLUni::fgDOMDisallowDoctype, disallowDoctype);
if (valScheme == AbstractDOMParser::Val_Auto)
{
config->setParameter(XMLUni::fgDOMValidateIfSchema, true);
}
else if (valScheme == AbstractDOMParser::Val_Never)
{
config->setParameter(XMLUni::fgDOMValidate, false);
}
else if (valScheme == AbstractDOMParser::Val_Always)
{
config->setParameter(XMLUni::fgDOMValidate, true);
}
// enable datatype normalization - default is off
config->setParameter(XMLUni::fgDOMDatatypeNormalization, true);
// And create our error handler and install it
DOMCountErrorHandler errorHandler;
config->setParameter(XMLUni::fgDOMErrorHandler, &errorHandler);
//
// Get the starting time and kick off the parse of the indicated
// file. Catch any exceptions that might propogate out of it.
//
unsigned long duration;
bool more = true;
XERCES_STD_QUALIFIER ifstream fin;
// the input is a list file
if (doList)
fin.open(argV[argInd]);
if (fin.fail()) {
XERCES_STD_QUALIFIER cerr <<"Cannot open the list file: " << argV[argInd] << XERCES_STD_QUALIFIER endl;
return 2;
}
while (more)
{
char fURI[1000];
//initialize the array to zeros
memset(fURI,0,sizeof(fURI));
if (doList) {
if (! fin.eof() ) {
fin.getline (fURI, sizeof(fURI));
if (!*fURI)
continue;
else {
xmlFile = fURI;
XERCES_STD_QUALIFIER cerr << "==Parsing== " << xmlFile << XERCES_STD_QUALIFIER endl;
}
}
else
break;
}
else {
xmlFile = argV[argInd];
more = false;
}
//reset error count first
errorHandler.resetErrors();
XERCES_CPP_NAMESPACE_QUALIFIER DOMDocument *doc = 0;
try
{
// reset document pool
parser->resetDocumentPool();
const unsigned long startMillis = XMLPlatformUtils::getCurrentMillis();
doc = parser->parseURI(xmlFile);
const unsigned long endMillis = XMLPlatformUtils::getCurrentMillis();
duration = endMillis - startMillis;
}
catch (const XMLException& toCatch)
{
XERCES_STD_QUALIFIER cerr << "\nError during parsing: '" << xmlFile << "'\n"
<< "Exception message is: \n"
<< StrX(toCatch.getMessage()) << "\n" << XERCES_STD_QUALIFIER endl;
errorOccurred = true;
continue;
}
catch (const DOMException& toCatch)
{
const unsigned int maxChars = 2047;
XMLCh errText[maxChars + 1];
XERCES_STD_QUALIFIER cerr << "\nDOM Error during parsing: '" << xmlFile << "'\n"
<< "DOMException code is: " << toCatch.code << XERCES_STD_QUALIFIER endl;
if (DOMImplementation::loadDOMExceptionMsg(toCatch.code, errText, maxChars))
XERCES_STD_QUALIFIER cerr << "Message is: " << StrX(errText) << XERCES_STD_QUALIFIER endl;
errorOccurred = true;
continue;
}
catch (...)
{
XERCES_STD_QUALIFIER cerr << "\nUnexpected exception during parsing: '" << xmlFile << "'\n";
errorOccurred = true;
continue;
}
//
// Extract the DOM tree, get the list of all the elements and report the
// length as the count of elements.
//
if (errorHandler.getSawErrors())
{
XERCES_STD_QUALIFIER cout << "\nErrors occurred, no output available\n" << XERCES_STD_QUALIFIER endl;
errorOccurred = true;
}
else
{
unsigned int elementCount = 0;
if (doc) {
elementCount = countChildElements((DOMNode*)doc->getDocumentElement(), printOutEncounteredEles);
// test getElementsByTagName and getLength
XMLCh xa[] = {chAsterisk, chNull};
if (elementCount != doc->getElementsByTagName(xa)->getLength()) {
XERCES_STD_QUALIFIER cout << "\nErrors occurred, element count is wrong\n" << XERCES_STD_QUALIFIER endl;
errorOccurred = true;
}
}
// Print out the stats that we collected and time taken.
XERCES_STD_QUALIFIER cout << xmlFile << ": " << duration << " ms ("
<< elementCount << " elems)." << XERCES_STD_QUALIFIER endl;
}
}
//
// Delete the parser itself. Must be done prior to calling Terminate, below.
//
parser->release();
// And call the termination method
XMLPlatformUtils::Terminate();
if (doList)
fin.close();
if (errorOccurred)
return 4;
else
return 0;
}
DOMDocument *CouchRunHttpServer::parsePrologue( std::string S_PrologueXMLFilename ){
bool recognizeNEL = false;
char localeStr[64];
memset(localeStr, 0, sizeof localeStr);
// Initialize the XML4C system
try {
if (strlen(localeStr)) {
XMLPlatformUtils::Initialize(localeStr);
}
else{
XMLPlatformUtils::Initialize();
}
if (recognizeNEL){
XMLPlatformUtils::recognizeNEL(recognizeNEL);
}
}
catch (const XMLException& toCatch){
XERCES_STD_QUALIFIER cerr << "Error during initialization! :\n"
<< StrX(toCatch.getMessage()) << XERCES_STD_QUALIFIER endl;
return NULL;
}
// Instantiate the DOM parser.
static const XMLCh gLS[] = { chLatin_L, chLatin_S, chNull };
DOMImplementation *impl =
DOMImplementationRegistry::getDOMImplementation(gLS);
DOMLSParser *parser =
((DOMImplementationLS*)impl)->createLSParser(DOMImplementationLS::MODE_SYNCHRONOUS, 0);
DOMConfiguration *config = parser->getDomConfig();
// enable datatype normalization - default is off
config->setParameter(XMLUni::fgDOMDatatypeNormalization, true);
// And create our error handler and install it
DOMCountErrorHandler errorHandler;
config->setParameter(XMLUni::fgDOMErrorHandler, &errorHandler);
//
// Get the starting time and kick off the parse of the indicated
// file. Catch any exceptions that might propogate out of it.
//
unsigned long duration;
const char *xmlFile = 0;
bool more = true;
XERCES_STD_QUALIFIER ifstream fin;
// Later possibly a list of prologue files rather than a single one
while (more){
xmlFile = S_PrologueXMLFilename.c_str();
more = false;
}
// Parse XML prologue file
// Reset error count first
errorHandler.resetErrors();
bool errorOccurred = false;
try{
// reset document pool
parser->resetDocumentPool();
const unsigned long startMillis = XMLPlatformUtils::getCurrentMillis();
XERCES_CPP_NAMESPACE_QUALIFIER DOMDocument *doc = parser->parseURI(xmlFile);
const unsigned long endMillis = XMLPlatformUtils::getCurrentMillis();
duration = endMillis - startMillis;
// Print out the stats that we collected and time taken.
XERCES_STD_QUALIFIER cout << "Parsed "
<< xmlFile << ": " << duration << " ms."
<< XERCES_STD_QUALIFIER endl;
return doc;
}
catch (const XMLException& toCatch){
XERCES_STD_QUALIFIER cerr << "\nError during parsing: '" << xmlFile << "'\n"
<< "Exception message is: \n"
<< StrX(toCatch.getMessage()) << "\n"
<< XERCES_STD_QUALIFIER endl;
errorOccurred = true;
// continue;
}
catch (const DOMException& toCatch){
const unsigned int maxChars = 2047;
XMLCh errText[maxChars + 1];
XERCES_STD_QUALIFIER cerr << "\nDOM Error during parsing: '"
<< xmlFile << "'\n"
<< "DOMException code is: "
<< toCatch.code
<< XERCES_STD_QUALIFIER endl;
if (DOMImplementation::loadDOMExceptionMsg(toCatch.code, errText, maxChars))
XERCES_STD_QUALIFIER cerr << "Message is: "
<< StrX(errText)
<< XERCES_STD_QUALIFIER endl;
errorOccurred = true;
// continue;
}
catch (...){
XERCES_STD_QUALIFIER cerr << "\nUnexpected exception during parsing: '" << xmlFile << "'\n";
errorOccurred = true;
// continue;
}
return NULL;
}
// ---------------------------------------------------------------------------
//
// main
//
// ---------------------------------------------------------------------------
int main(int argC, char* argV[])
{
char *testFileName;
char *outputFileName;
for (int argInd = 1; argInd < argC; argInd++)
{
if (!strcmp(argV[argInd], "-?") || !strcmp(argV[argInd], "-h"))
{
/* print help and exit */
usage();
return 2;
}
}
if (argC < 3){
usage();
return 2;
}
testFileName = argV[argC-2];
outputFileName = argV[argC-1];
// Initialize the XML4C system
try
{
XMLPlatformUtils::Initialize();
}
catch (const XMLException& toCatch)
{
XERCES_STD_QUALIFIER cerr << "Error during initialization! :\n"
<< StrX(toCatch.getMessage()) << XERCES_STD_QUALIFIER endl;
return 1;
}
//============================================================================
// Instantiate the DOM parser to use for the source documents
//============================================================================
static const XMLCh gLS[] = { chLatin_L, chLatin_S, chNull };
DOMImplementation *impl = DOMImplementationRegistry::getDOMImplementation(gLS);
DOMLSParser *parser = ((DOMImplementationLS*)impl)->createLSParser(DOMImplementationLS::MODE_SYNCHRONOUS, 0);
DOMConfiguration *config = parser->getDomConfig();
config->setParameter(XMLUni::fgDOMNamespaces, true);
config->setParameter(XMLUni::fgXercesSchema, true);
config->setParameter(XMLUni::fgXercesSchemaFullChecking, true);
if(config->canSetParameter(XMLUni::fgXercesDoXInclude, true)){
config->setParameter(XMLUni::fgXercesDoXInclude, true);
}
// enable datatype normalization - default is off
//config->setParameter(XMLUni::fgDOMDatatypeNormalization, true);
// And create our error handler and install it
XIncludeErrorHandler errorHandler;
config->setParameter(XMLUni::fgDOMErrorHandler, &errorHandler);
XERCES_CPP_NAMESPACE_QUALIFIER DOMDocument *doc = 0;
try
{
// load up the test source document
XERCES_STD_QUALIFIER cerr << "Parse " << testFileName << " in progress ...";
parser->resetDocumentPool();
doc = parser->parseURI(testFileName);
XERCES_STD_QUALIFIER cerr << " finished." << XERCES_STD_QUALIFIER endl;
}
catch (const XMLException& toCatch)
{
XERCES_STD_QUALIFIER cerr << "\nError during parsing: '" << testFileName << "'\n"
<< "Exception message is: \n"
<< StrX(toCatch.getMessage()) << "\n" << XERCES_STD_QUALIFIER endl;
}
catch (const DOMException& toCatch)
{
const unsigned int maxChars = 2047;
XMLCh errText[maxChars + 1];
XERCES_STD_QUALIFIER cerr << "\nDOM Error during parsing: '" << testFileName << "'\n"
<< "DOMException code is: " << toCatch.code << XERCES_STD_QUALIFIER endl;
if (DOMImplementation::loadDOMExceptionMsg(toCatch.code, errText, maxChars))
XERCES_STD_QUALIFIER cerr << "Message is: " << StrX(errText) << XERCES_STD_QUALIFIER endl;
}
catch (...)
{
XERCES_STD_QUALIFIER cerr << "\nUnexpected exception during parsing: '" << testFileName << "'\n";
}
if (!errorHandler.getSawErrors() && doc) {
DOMLSSerializer *writer = ((DOMImplementationLS*)impl)->createLSSerializer();
DOMLSOutput *theOutputDesc = ((DOMImplementationLS*)impl)->createLSOutput();
try {
// write out the results
XERCES_STD_QUALIFIER cerr << "Writing result to: " << outputFileName << XERCES_STD_QUALIFIER endl;
XMLFormatTarget *myFormTarget = new LocalFileFormatTarget(outputFileName);
theOutputDesc->setByteStream(myFormTarget);
writer->write(doc, theOutputDesc);
delete myFormTarget;
}
catch (const XMLException& toCatch)
{
XERCES_STD_QUALIFIER cerr << "\nXMLException during writing: '" << testFileName << "'\n"
<< "Exception message is: \n"
<< StrX(toCatch.getMessage()) << "\n" << XERCES_STD_QUALIFIER endl;
}
catch (const DOMException& toCatch)
{
const unsigned int maxChars = 2047;
XMLCh errText[maxChars + 1];
XERCES_STD_QUALIFIER cerr << "\nDOM Error during writing: '" << testFileName << "'\n"
<< "DOMException code is: " << toCatch.code << XERCES_STD_QUALIFIER endl;
if (DOMImplementation::loadDOMExceptionMsg(toCatch.code, errText, maxChars))
XERCES_STD_QUALIFIER cerr << "Message is: " << StrX(errText) << XERCES_STD_QUALIFIER endl;
}
catch (...)
{
XERCES_STD_QUALIFIER cerr << "\nUnexpected exception during writing: '" << testFileName << "'\n";
}
writer->release();
theOutputDesc->release();
}
//
// Delete the parser itself. Must be done prior to calling Terminate, below.
//
parser->release();
// And call the termination method
XMLPlatformUtils::Terminate();
return 0;
}
int main(int argc, char *argv[])
{
if (argc < 5)
{
cout << currentDateTime() << "Usage: GTTagging.exe video_path flag_roi(1=true, 0=false) flag_load(1=true, 0=false) flag_saveROI(1=true, 0=false)\n";
return 1;
}
/*serialize_video();*/
string outFilename = "output_video.xml";
serializeVideo(outFilename);
removeTrailingSpace(outFilename);
path video_path (argv[1]);
string video_name = video_path.filename().replace_extension("").string();
cout << "video_path filename: " << video_name << endl;
string base_name = video_path.filename().replace_extension("").string();
cout << "base_name: " << base_name << endl;
string base_path = video_path.remove_filename().string();
cout << "base_path: " << base_path << endl;
ostringstream codebook_paramters_path;
codebook_paramters_path << base_path << "\\" << base_name << "_cparameters.dat";
cout << "cparameters filename: " << codebook_paramters_path.str() << endl;
ostringstream xml_path;
xml_path << base_path << "\\" << base_name << ".xml";
cout << "xml filename: " << xml_path.str() << endl;
path gt_xml_path (xml_path.str());
try {
XMLPlatformUtils::Initialize();
XQillaPlatformUtils::initialize();
} catch (const XMLException& eXerces) {
cerr << "Error during Xerces-C initialisation.\n"
<< "Xerces exception message: "
<< UTF8(eXerces.getMessage()) << endl;
return 1;
}
try
{
if (!exists(gt_xml_path))
{
cout << currentDateTime() << "File: " << gt_xml_path << " doesn't exist!" << endl;
return 1;
}
if (!exists(video_path))
{
cout << currentDateTime() << "File: " << video_path << " doesn't exist!" << endl;
return 1;
}
cout << currentDateTime() << "Processing " << video_path << " ..." << endl;
DOMImplementation* xqillaImplementation = DOMImplementationRegistry::getDOMImplementation(X("XPath2 3.0"));
DOMLSParser* xmlParser = xqillaImplementation->createLSParser(DOMImplementationLS::MODE_SYNCHRONOUS, 0);
DOMConfiguration* dc_parser = xmlParser->getDomConfig();
dc_parser->setParameter(XMLUni::fgDOMNamespaces, true);
dc_parser->setParameter(XMLUni::fgXercesSchema, true);
dc_parser->setParameter(XMLUni::fgDOMValidate, true);
DOMDocument* document = xmlParser->parseURI(xml_path.str().c_str());
if(document == 0) {
cerr << "Document not found: " << xml_path.str().c_str() << endl;
return 1;
}
const DOMXPathNSResolver* resolver = document->createNSResolver(document->getDocumentElement());
XQillaNSResolver* xqillaResolver = (XQillaNSResolver*)resolver;
xqillaResolver->addNamespaceBinding(X("xs"), X("http://www.w3.org/2001/XMLSchema"));
xqillaResolver->addNamespaceBinding(X("fn"), X("http://www.w3.org/2005/xpath-functions"));
// Initialize Subsense
cv::VideoCapture oVideoInput;
cv::Mat oCurrInputFrame, oCurrSegmMask, oCurrReconstrBGImg;
oVideoInput.open(argv[1]);
oVideoInput >> oCurrInputFrame;
oVideoInput.set(CV_CAP_PROP_POS_FRAMES,0);
// create BGS Subsense object
BackgroundSubtractorSuBSENSE oBGSAlg;
// copy loadvars flag
if (strcmp(argv[3], "1") == 0) {
oBGSAlg.loadvars = true;
cout << currentDateTime() << "Pre-loading codebook ..." << endl;
} else {
oBGSAlg.loadvars = false;
cout << currentDateTime() << "Building codebook ..." << endl;
}
// check if open
if(!oVideoInput.isOpened() || oCurrInputFrame.empty()) {
printf("Could not open video file at '%s'.\n", argv[1]);
cv::waitKey();
return -1;
}
// Initialize Subsense variables
oCurrSegmMask.create(oCurrInputFrame.size(),CV_8UC1);
oCurrReconstrBGImg.create(oCurrInputFrame.size(),oCurrInputFrame.type());
// Depending on flag_roi load ROI or not
cv::Mat R;
if (strcmp(argv[2], "1") == 0) {
R = cv::imread("ROI.png",CV_8UC1);
} else {
R = cv::Mat(oCurrInputFrame.size(),CV_8UC1,cv::Scalar_<uchar>(255));
}
oBGSAlg.saveCodebookParametersPath(codebook_paramters_path.str());
oBGSAlg.initialize(oCurrInputFrame, R);
// create visualization windows
/*cv::namedWindow("input",cv::WINDOW_AUTOSIZE);
cv::namedWindow("segmentation mask",cv::WINDOW_AUTOSIZE);*/
int xml_roi_counter = 0;
int bgs_roi_counter = 0;
int frame_counter = 0;
//loop through video frames
while(1) {
try {
std::cout << "frame counter = " << frame_counter << std::endl;
oVideoInput >> oCurrInputFrame;
if(oCurrInputFrame.empty())
break;
//Process
oBGSAlg(oCurrInputFrame,oCurrSegmMask);
//oBGSAlg.getBackgroundImage(oCurrReconstrBGImg);
std::vector<F_state_struct> F_states;
// TODO Add function to static lib.
getRegions(oCurrSegmMask, F_states, pminArea);
std::ostringstream object_xpath_expression;
object_xpath_expression << "//object[../@id=\""<< frame_counter++ << "\"]";
cout << currentDateTime() << "object_xpath_expression: " << object_xpath_expression.str() << endl;
const DOMXPathExpression* parsedExpression = document->createExpression(X(object_xpath_expression.str().c_str()), resolver);
DOMXPathResult* iteratorResult = (DOMXPathResult*)parsedExpression->evaluate(document->getDocumentElement(), DOMXPathResult::ITERATOR_RESULT_TYPE, 0);
/*ostringstream xml_rois_path;
xml_rois_path << base_path << "\\" << base_name << "_xml_rois";
cout << "xml_rois_path filename: " << xml_rois_path.str() << endl;
path xml_rois_dir (xml_rois_path.str());
if(!exists(xml_rois_dir)) {
if (create_directories(xml_rois_dir)) {
cout << currentDateTime() << "xml_rois_dir created!" << endl;
} else {
cout << currentDateTime() << "Cannot create xml_rois_dir!" << endl;
return 1;
}
}*/
ostringstream bgs_rois_path;
bgs_rois_path << base_path << "\\" << base_name << "_bgs_rois";
cout << "bgs_rois_path filename: " << bgs_rois_path.str() << endl;
path bgs_rois_dir (bgs_rois_path.str());
if(!exists(bgs_rois_dir)) {
if (create_directories(bgs_rois_dir)) {
cout << currentDateTime() << "bgs_rois_dir created!" << endl;
} else {
cout << currentDateTime() << "Cannot create bgs_rois_dir!" << endl;
return 1;
}
}
int i = 0;
while(iteratorResult->iterateNext()) {
if(iteratorResult->isNode()) {
DOMNode* n (iteratorResult->getNodeValue ());
char * localName = XMLString::transcode(n->getLocalName());
//cout << currentDateTime() << "Localname: " << localName << endl;
DOMElement* resultElement = dynamic_cast<DOMElement*>(n);
if(strcmp( localName, "object") == 0) {
object* o = new object (*resultElement);
int w = o->w().get();
int h = o->h().get();
int x = o->x().get();
int y = o->y().get();
cout << currentDateTime() << "fish_species: " << o->fish_species().get() << endl;
cout << currentDateTime() << "h: " << h << endl;
cout << currentDateTime() << "w: " << w << endl;
cout << currentDateTime() << "x: " << x << endl;
cout << currentDateTime() << "y: " << y << endl;
try
{
ostringstream fish_specie_path;
fish_specie_path << base_path << "\\" << o->fish_species().get();
cout << "fish_specie_path filename: " << fish_specie_path.str() << endl;
path fish_specie_dir (fish_specie_path.str());
if(!exists(fish_specie_dir)) {
if (create_directories(fish_specie_dir)) {
cout << currentDateTime() << "bgs_rois_dir created!" << endl;
} else {
cout << currentDateTime() << "Cannot create fish_specie_dir!" << endl;
return 1;
}
}
std::cout << "XML ROI: " << x << " , " << y << " , " << x+w << " , " << y+h << std::endl;
Rect xml_roi_rectangle = Rect(Point(x, y), Point(x+w, y+h));
Mat xmlROI, xmlROI_bg;
Mat xmlROIMask = oCurrSegmMask(xml_roi_rectangle);
xml_roi_counter++;
oCurrInputFrame(xml_roi_rectangle).copyTo(xmlROI_bg);
sprintf(printf_buffer, "%s\\%s_roi%04d_bg.png", fish_specie_path.str().c_str(), base_name, xml_roi_counter);
cout << currentDateTime() << "Saving to: " << printf_buffer << endl;
imwrite(printf_buffer, xmlROI_bg);
cout << currentDateTime() << "Saved..." << endl;
oCurrInputFrame(xml_roi_rectangle).copyTo(xmlROI, xmlROIMask);
sprintf(printf_buffer, "%s\\%s_roi%04d.png\0", fish_specie_path.str().c_str(), base_name, xml_roi_counter);
cout << currentDateTime() << "Saving to: " << printf_buffer << endl;
imwrite(printf_buffer, xmlROI);
cout << currentDateTime() << "Saved..." << endl;
//rectangle( oCurrInputFrame, Point(x, y), Point(x+w, y+h), Scalar( 255, 9, 0 ), +3, 4 );
}
catch (exception& e)
{
cout << "Error: " << e.what() << '\n';
}
}
}
}
for(int i=0; i<F_states.size(); i++) {
std::cout << "BGS ROI: " << F_states.at(i).min_x << " , " << F_states.at(i).min_y << " , " << F_states.at(i).max_x << " , " << F_states.at(i).max_y << std::endl;
Rect bgs_roi_rectangle = Rect(Point(F_states.at(i).min_x, F_states.at(i).min_y), Point(F_states.at(i).max_x, F_states.at(i).max_y));
Mat bgsROI, bgsROI_bg;
Mat bgsROIMask = oCurrSegmMask(bgs_roi_rectangle);
bgs_roi_counter++;
oCurrInputFrame(bgs_roi_rectangle).copyTo(bgsROI_bg);
sprintf(printf_buffer, "%s\\roi%04d_bg.png", bgs_rois_path.str().c_str(), bgs_roi_counter);
cout << currentDateTime() << "Saving to: " << printf_buffer << endl;
imwrite(printf_buffer, bgsROI_bg);
cout << currentDateTime() << "Saved..." << endl;
oCurrInputFrame(bgs_roi_rectangle).copyTo(bgsROI, bgsROIMask);
sprintf(printf_buffer, "%s\\roi%04d.png\0", bgs_rois_path.str().c_str(), bgs_roi_counter);
cout << currentDateTime() << "Saving to: " << printf_buffer << endl;
imwrite(printf_buffer, bgsROI);
cout << currentDateTime() << "Saved..." << endl;
//rectangle( oCurrInputFrame, Point(F_states.at(i).min_x, F_states.at(i).min_y), Point(F_states.at(i).max_x, F_states.at(i).max_y), Scalar( 0, 55, 255 ), +3, 4 );
}
//Background Subtraction Visualization
/*imshow("input",oCurrInputFrame);
imshow("segmentation mask",oCurrSegmMask);*/
//imshow("reconstructed background",oCurrReconstrBGImg);
/*if(cv::waitKey(1)==27)
break;*/
//Save subsense codebooks and parameters
if (strcmp(argv[4], "1") == 0) {
oBGSAlg.saveVariables();
}
} catch(DOMXPathException &e) {
cerr << "DOMXPathException: " << UTF8(e.msg) << endl;
return 1;
} catch(DOMException &e) {
cerr << "DOMException: " << UTF8(e.getMessage()) << endl;
return 1;
}
}
} catch (const filesystem_error& ex) {
cout << currentDateTime() << ex.what() << '\n';
}
XQillaPlatformUtils::terminate();
XMLPlatformUtils::Terminate();
return 0;
}
