bool XmlWorldPartReader::ReadEdgeShape(
	const DOMNode *shapeNode, b2EdgeShape *dest
) {
	DOMXPathNSResolver *resolver = doc->createNSResolver(shapeNode);
	if (resolver == nullptr) {
		return nullptr;
	}

	DOMXPathResult *result;
	YPT::XmlString str;

	b2Vec2 vec1, vec2;

	result = doc->evaluate(
		YPT::XmlString("./vertex1"), shapeNode, resolver,
		DOMXPathResult::ORDERED_NODE_SNAPSHOT_TYPE,
		NULL
	);
	if (result == nullptr) {
		return false;
	}
	if (result->getSnapshotLength() == 0) {
		// 値が存在しない
		result->release();
		return false;
	}
	str = result->getNodeValue()->getTextContent();
	result->release();
	if (!YPT::ConvertStrToVec2(std::string(str), &vec1)) {
		// 値が正しい形式で書かれていない
		return false;
	}

	result = doc->evaluate(
		YPT::XmlString("./vertex2"), shapeNode, resolver,
		DOMXPathResult::ORDERED_NODE_SNAPSHOT_TYPE,
		NULL
	);
	if (result == nullptr) {
		return false;
	}
	if (result->getSnapshotLength() == 0) {
		// 値が存在しない
		result->release();
		return false;
	}
	str = result->getNodeValue()->getTextContent();
	result->release();
	if (!YPT::ConvertStrToVec2(std::string(str), &vec2)) {
		// 値が正しい形式で書かれていない
		return false;
	}

	dest->m_vertex1 = vec1;
	dest->m_vertex2 = vec2;

	return true;
}
bool XmlWorldPartReader::ReadCircleShape(
	const DOMNode *shapeNode, b2CircleShape *dest
) {
	DOMXPathNSResolver *resolver = doc->createNSResolver(shapeNode);
	if (resolver == nullptr) {
		return nullptr;
	}

	DOMXPathResult *result;
	YPT::XmlString str;

	b2Vec2 center(0.0f, 0.0f);
	float32 radius;

	result = doc->evaluate(
		YPT::XmlString("./center"), shapeNode, resolver,
		DOMXPathResult::ORDERED_NODE_SNAPSHOT_TYPE,
		NULL
	);
	if (result != nullptr) {
		if (result->getSnapshotLength() >= 1) {
			str = result->getNodeValue()->getTextContent();
			YPT::ConvertStrToVec2(std::string(str), &center);
		}
		result->release();
	}

	result = doc->evaluate(
		YPT::XmlString("./radius"), shapeNode, resolver,
		DOMXPathResult::ORDERED_NODE_SNAPSHOT_TYPE,
		NULL
	);
	if (result == nullptr) {
		return false;
	}
	if (result->getSnapshotLength() == 0) {
		// 値が存在しない
		result->release();
		return false;
	}
	str = result->getNodeValue()->getTextContent();
	if (!YPT::ConvertStrToFloat(std::string(str), &radius)) {
		// 値が正しい形式で書かれていない
		return false;
	}
	result->release();

	dest->m_p = center;
	dest->m_radius = radius;

	return true;
}
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;
}
bool SignatureSetImporter::execute(PlugInArgList* pInArgList, PlugInArgList* OutArgList)
{
   VERIFY(pInArgList != NULL);
   Progress* pProgress = pInArgList->getPlugInArgValue<Progress>(Executable::ProgressArg());
   ProgressTracker progress(pProgress, "Loading spectral signature library", "spectral", "7B21EE8A-D2E1-4325-BB9F-F4E521BFD5ED");

   SignatureSet* pSignatureSet = pInArgList->getPlugInArgValue<SignatureSet>(Importer::ImportElementArg());
   VERIFY(pSignatureSet != NULL);
   DataDescriptor* pDataDescriptor = pSignatureSet->getDataDescriptor();
   VERIFY(pDataDescriptor != NULL);
   FileDescriptor* pFileDescriptor = pDataDescriptor->getFileDescriptor();
   VERIFY(pFileDescriptor != NULL);
   const string& filename = pFileDescriptor->getFilename().getFullPathAndName();

   progress.getCurrentStep()->addProperty("signature set", pSignatureSet->getName());
   progress.getCurrentStep()->addProperty("dataset location", pFileDescriptor->getDatasetLocation());

   // locate the spot in the tree for this dataset
   try
   {
      string expr;
      vector<string> parts = StringUtilities::split(pFileDescriptor->getDatasetLocation(), '/');
      for (vector<string>::iterator part = parts.begin(); part != parts.end(); ++part)
      {
         if (!part->empty())
         {
            expr += "/signature_set[metadata/@name='Name' and metadata/@value='" + *part + "']";
         }
      }
      expr += "/signature";
      loadDoc(filename);
      DOMXPathResult* pResult = mXml[filename]->query(expr, DOMXPathResult::SNAPSHOT_RESULT_TYPE);
      VERIFY(pResult != NULL);
      int nodeTotal = pResult->getSnapshotLength();
      for (int nodeNum = 0; nodeNum < nodeTotal; ++nodeNum)
      {
         if (isAborted())
         {
            progress.report("Aborted file " + pFileDescriptor->getFilename().getFullPathAndName(), 0, WARNING, true);
            progress.report("User aborted the operation.", 0, ABORT, true);
            return false;
         }
         int percent = static_cast<int>(100.0 * nodeNum / nodeTotal);
         progress.report("Importing signature library", percent, NORMAL);
         if (!pResult->snapshotItem(nodeNum) || !pResult->isNode())
         {
            continue;
         }
         const DOMElement* pElmnt = static_cast<const DOMElement*>(pResult->getNodeValue());
         string filename = A(pElmnt->getAttribute(X("filename")));
         if (filename.empty() == false)
         {
            string path = pFileDescriptor->getFilename().getPath();

            QString tempFilename = QString::fromStdString(filename);
            if (tempFilename.startsWith("./") == true)
            {
               tempFilename.replace(0, 1, QString::fromStdString(path));
               filename = tempFilename.toStdString();
            }
            else
            {
               QFileInfo fileInfo(tempFilename);
               if (fileInfo.isRelative() == true)
               {
                  filename = path + SLASH + filename;
               }
            }
         }

         // don't pass progress to importer - the individual signature imports are rapid and passing progress will
         // cause isAborted() to not function properly.
         ImporterResource importer("Auto Importer", filename, NULL);
         if (importer->getPlugIn() == NULL)
         {
            progress.report("The \"Auto Importer\" is not available and is required to import signature sets.", 0, ERRORS, true);
            return false;
         }
         if (importer->execute())
         {
            vector<DataElement*> elements = importer->getImportedElements();
            vector<Signature*> sigs(elements.size(), NULL);
            for (vector<DataElement*>::iterator element = elements.begin(); element != elements.end(); ++element)
            {
               Signature* pSig = dynamic_cast<Signature*>(*element);
               if (pSig != NULL)
               {
                  pSignatureSet->insertSignature(pSig);
                  // reparent the signature
                  Service<ModelServices>()->setElementParent(pSig, pSignatureSet);
               }
            }
         }
         else
         {
            progress.report("Unable to import signature " + filename, percent, WARNING, true);
         }
      }
   }
   catch(DOMException &exc)
   {
      progress.report(A(exc.getMessage()), 0, ERRORS, true);
      return false;
   }
   SignatureSet* pParent = dynamic_cast<SignatureSet*>(pSignatureSet->getParent());
   if (pParent != NULL && pParent->getFilename() == pSignatureSet->getFilename())
   {
      pParent->insertSignature(pSignatureSet);
   }

   progress.report("Spectral signature library loaded", 100, NORMAL);
   progress.upALevel();
   return true;
}
bool XmlWorldPartReader::ReadChainShape(
	const DOMNode *shapeNode, b2ChainShape *dest
) {
	DOMXPathNSResolver *resolver = doc->createNSResolver(shapeNode);
	if (resolver == nullptr) {
		return nullptr;
	}

	DOMXPathResult *result;
	YPT::XmlString str;

	int vertexCount;
	b2Vec2 vertices[b2_maxPolygonVertices];

	result = doc->evaluate(
		YPT::XmlString("./vertexCount"), shapeNode, resolver,
		DOMXPathResult::ORDERED_NODE_SNAPSHOT_TYPE,
		NULL
	);
	if (result == nullptr) {
		return false;
	}
	if (result->getSnapshotLength() == 0) {
		// 値が存在しない
		result->release();
		return false;
	}
	str = result->getNodeValue()->getTextContent();
	result->release();
	if (!YPT::ConvertStrToInt(std::string(str), &vertexCount)
		|| vertexCount <= 0 || vertexCount > b2_maxPolygonVertices
	) {
		// 値が正しい形式で書かれていない
		return false;
	}

	for (int i = 0; i < vertexCount; ++i) {
		std::string iStr = YPT::ConvertIntToStr(i+1);
		result = doc->evaluate(
			YPT::XmlString((
				"./vertices/vertex" + iStr + "|./vertices/v" + iStr
			).c_str()), shapeNode, resolver,
			DOMXPathResult::ORDERED_NODE_SNAPSHOT_TYPE,
			NULL
		);
		if (result == nullptr) {
			return false;
		}
		const XMLSize_t len = result->getSnapshotLength();
		if (len == 0) {
			// 値が存在しない
			result->release();
			return false;
		}
		str = result->getNodeValue()->getTextContent();
		result->release();
		if (!YPT::ConvertStrToVec2(std::string(str), &vertices[i])) {
			 // 値が正しい形式で書かれていない
			 return false;
		}
	}
	dest->CreateChain(vertices, vertexCount);

	return true;
}
b2Body *XmlWorldPartReader::ReadBody(
	b2World &world, const DOMNode *bodyNode,
	const std::vector< b2FixtureDef *> &fixtureDefs
) {
	DOMXPathNSResolver *resolver = doc->createNSResolver(bodyNode);
	if (resolver == nullptr) {
		return nullptr;
	}

	b2BodyDef bodyDef;
	bodyDef.position.SetZero();
	bodyDef.angle = 0.0f;
	bodyDef.fixedRotation = false;
	bodyDef.type = b2_dynamicBody;
	bodyDef.gravityScale = 1.0f;

	DOMXPathResult *result;
	YPT::XmlString str;

	// position
	result = doc->evaluate(
		YPT::XmlString("./position"), bodyNode, resolver,
		DOMXPathResult::ORDERED_NODE_SNAPSHOT_TYPE,
		NULL
	);
	if (result != nullptr) {
		if (result->getSnapshotLength() >= 1) {
			str = result->getNodeValue()->getTextContent();
			YPT::ConvertStrToVec2(std::string(str), &bodyDef.position);
		}
		result->release();
	}

	// angle
	result = doc->evaluate(
		YPT::XmlString("./angle"), bodyNode, resolver,
		DOMXPathResult::ORDERED_NODE_SNAPSHOT_TYPE,
		NULL
	);
	if (result != nullptr) {
		if (result->getSnapshotLength() >= 1) {
			str = result->getNodeValue()->getTextContent();
			float temp;
			if (YPT::ConvertStrToFloat(std::string(str), &temp)) {
				// 度からラジアンへ変換
				bodyDef.angle = temp * YPT::PI / 180;
			}
		}
		result->release();
	}

	// fixedRotation
	result = doc->evaluate(
		YPT::XmlString("./fixedRotation"), bodyNode, resolver,
		DOMXPathResult::ORDERED_NODE_SNAPSHOT_TYPE,
		NULL
	);
	if (result != nullptr) {
		if (result->getSnapshotLength() >= 1) {
			str = result->getNodeValue()->getTextContent();
			YPT::ConvertStrToBool(std::string(str), &bodyDef.fixedRotation);
		}
		result->release();
	}

	// type
	result = doc->evaluate(
		YPT::XmlString("./type"), bodyNode, resolver,
		DOMXPathResult::ORDERED_NODE_SNAPSHOT_TYPE,
		NULL
	);
	if (result != nullptr) {
		if (result->getSnapshotLength() >= 1) {
			str = result->getNodeValue()->getTextContent();
			if (str == "dynamic") {
				bodyDef.type = b2_dynamicBody;
			} else if (str == "static") {
				bodyDef.type = b2_staticBody;
			} else if (str == "kinematic") {
				bodyDef.type = b2_kinematicBody;
			} else {
				// 未対応
			}
		}
		result->release();
	}

	// gravityScale
	result = doc->evaluate(
		YPT::XmlString("./gravityScale"), bodyNode, resolver,
		DOMXPathResult::ORDERED_NODE_SNAPSHOT_TYPE,
		NULL
	);
	if (result != nullptr) {
		if (result->getSnapshotLength() >= 1) {
			str = result->getNodeValue()->getTextContent();
			YPT::ConvertStrToFloat(std::string(str), &bodyDef.gravityScale);
		}
		result->release();
	}

	b2Body *body = world.CreateBody(&bodyDef);
	if (body == NULL) {
		return NULL;
	}

	for (std::vector< b2FixtureDef *>::const_iterator it
		= fixtureDefs.begin(); it != fixtureDefs.end(); ++it)
	{
		if (*it != NULL)
			body->CreateFixture(*it);
	}

	return body;
}
bool XmlWorldPartReader::ReadFixture(const DOMNode *fixtureNode,
	b2Shape *shape, b2FixtureDef *dest)
{
	DOMXPathNSResolver *resolver = doc->createNSResolver(fixtureNode);
	if (resolver == nullptr) {
		return nullptr;
	}

	DOMXPathResult *result;
	YPT::XmlString str;

	b2FixtureDef fixtureDef;
	fixtureDef.friction = 0.5f;
	fixtureDef.restitution = 0.5f;
	fixtureDef.density = 1.0f;

	// shape
	fixtureDef.shape = shape;

	// friction
	result = doc->evaluate(
		YPT::XmlString("./friction"), fixtureNode, resolver,
		DOMXPathResult::ORDERED_NODE_SNAPSHOT_TYPE,
		NULL
	);
	if (result != nullptr) {
		if (result->getSnapshotLength() >= 1) {
			str = result->getNodeValue()->getTextContent();
			YPT::ConvertStrToFloat(std::string(str), &fixtureDef.friction);
		}
		result->release();
	}

	// restitution
	result = doc->evaluate(
		YPT::XmlString("./restitution"), fixtureNode, resolver,
		DOMXPathResult::ORDERED_NODE_SNAPSHOT_TYPE,
		NULL
	);
	if (result != nullptr) {
		if (result->getSnapshotLength() >= 1) {
			str = result->getNodeValue()->getTextContent();
			YPT::ConvertStrToFloat(std::string(str), &fixtureDef.restitution);
		}
		result->release();
	}

	// density
	result = doc->evaluate(
		YPT::XmlString("./density"), fixtureNode, resolver,
		DOMXPathResult::ORDERED_NODE_SNAPSHOT_TYPE,
		NULL
	);
	if (result != nullptr) {
		if (result->getSnapshotLength() >= 1) {
			str = result->getNodeValue()->getTextContent();
			YPT::ConvertStrToFloat(std::string(str), &fixtureDef.density);
		}
		result->release();
	}

	*dest = fixtureDef;

	return true;
}
Example #8
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;
}