#include "xml_function.h"

SystemConfigXmlStruct SystemConfigXmlStruct::instance_;

SystemConfigXmlStruct::SystemConfigXmlStruct()
{
	TiXmlDocument xml;
	XmlParser xml_function;
	xml_function.generateXml(xml);
	instance_.xml_data_ = xml;
}

XmlParser::XmlParser()
{

}

XmlParser::~XmlParser()
{

}

int XmlParser::add_enum_feature_with_selected(TiXmlElement* root, std::string name, std::string display_name, std::string space, std::string toolTip,
	std::string descrioption, std::string access, std::string value,
	std::vector<std::string> value_list, std::vector<std::string> display_list, std::vector<std::string>tip_list, std::vector<std::string>description_list,
	std::vector<std::string> selected_list)
{
	if (tip_list.size() != description_list.size())
	{
		return -1;
	}

	TiXmlElement* feature = new TiXmlElement("Enumeration");
	feature->SetAttribute("Name", name.c_str());
	feature->SetAttribute("NameSpace", space.c_str());

	//{
	TiXmlElement* tool = new TiXmlElement("ToolTip");
	TiXmlText* text = new TiXmlText(toolTip.c_str());
	tool->LinkEndChild(text);
	feature->LinkEndChild(tool);

	TiXmlElement* description = new TiXmlElement("Description");
	text = new TiXmlText(descrioption.c_str());
	description->LinkEndChild(text);
	feature->LinkEndChild(description);

	TiXmlElement* display = new TiXmlElement("DisplayName");
	text = new TiXmlText(display_name.c_str());
	display->LinkEndChild(text);
	feature->LinkEndChild(display);

	TiXmlElement* visibility = new TiXmlElement("Visibility");
	text = new TiXmlText("Beginner");
	visibility->LinkEndChild(text);
	feature->LinkEndChild(visibility);

	TiXmlElement* imposed = new TiXmlElement("ImposedAccessMode");
	text = new TiXmlText(access.c_str());
	imposed->LinkEndChild(text);
	feature->LinkEndChild(imposed);

	for (int i = 0; i < value_list.size(); i++)
	{
		TiXmlElement* element = new TiXmlElement("EnumEntry");

		tool = new TiXmlElement("ToolTip");
		TiXmlText* text = new TiXmlText(tip_list[i].c_str());
		tool->LinkEndChild(text);
		element->LinkEndChild(tool);


		description = new TiXmlElement("Description");
		text = new TiXmlText(description_list[i].c_str());
		description->LinkEndChild(text);
		element->LinkEndChild(description);

		display = new TiXmlElement("DisplayName");
		text = new TiXmlText(display_list[i].c_str());
		display->LinkEndChild(text);
		element->LinkEndChild(display);

		TiXmlElement* value_e = new TiXmlElement("Value");

		text = new TiXmlText(std::to_string(i).c_str());
		value_e->LinkEndChild(text);
		element->LinkEndChild(value_e);

		feature->LinkEndChild(element);
	}

	for (int s_i = 0; s_i < selected_list.size(); s_i++)
	{
		TiXmlElement* element = new TiXmlElement("pSelected");
		TiXmlText* text = new TiXmlText(selected_list[s_i].c_str());
		element->LinkEndChild(text);
		feature->LinkEndChild(element);
	}

	TiXmlElement* value_e = new TiXmlElement("Value");
	text = new TiXmlText(value.c_str());
	value_e->LinkEndChild(text);
	feature->LinkEndChild(value_e);

	root->LinkEndChild(feature);


	return 0;

}

int XmlParser::add_enum_feature(TiXmlElement* root, std::string name, std::string display_name, std::string space, std::string toolTip,
	std::string descrioption, std::string access, std::string value,
	std::vector<std::string> value_list, std::vector<std::string> display_list, std::vector<std::string>tip_list, std::vector<std::string>description_list)
{

	if (tip_list.size() != description_list.size())
	{
		return -1;
	}

	TiXmlElement* feature = new TiXmlElement("Enumeration");
	feature->SetAttribute("Name", name.c_str());
	feature->SetAttribute("NameSpace", space.c_str());

	//{
	TiXmlElement* tool = new TiXmlElement("ToolTip");
	TiXmlText* text = new TiXmlText(toolTip.c_str());
	tool->LinkEndChild(text);
	feature->LinkEndChild(tool);

	TiXmlElement* description = new TiXmlElement("Description");
	text = new TiXmlText(descrioption.c_str());
	description->LinkEndChild(text);
	feature->LinkEndChild(description);

	TiXmlElement* display = new TiXmlElement("DisplayName");
	text = new TiXmlText(display_name.c_str());
	display->LinkEndChild(text);
	feature->LinkEndChild(display);

	TiXmlElement* visibility = new TiXmlElement("Visibility");
	text = new TiXmlText("Beginner");
	visibility->LinkEndChild(text);
	feature->LinkEndChild(visibility);

	TiXmlElement* imposed = new TiXmlElement("ImposedAccessMode");
	text = new TiXmlText(access.c_str());
	imposed->LinkEndChild(text);
	feature->LinkEndChild(imposed);

	for (int i = 0; i < value_list.size(); i++)
	{
		TiXmlElement* element = new TiXmlElement("EnumEntry");

		tool = new TiXmlElement("ToolTip");
		TiXmlText* text = new TiXmlText(tip_list[i].c_str());
		tool->LinkEndChild(text);
		element->LinkEndChild(tool);


		description = new TiXmlElement("Description");
		text = new TiXmlText(description_list[i].c_str());
		description->LinkEndChild(text);
		element->LinkEndChild(description);

		display = new TiXmlElement("DisplayName");
		text = new TiXmlText(display_list[i].c_str());
		display->LinkEndChild(text);
		element->LinkEndChild(display);

		TiXmlElement* value_e = new TiXmlElement("Value");

		text = new TiXmlText(std::to_string(i).c_str());
		value_e->LinkEndChild(text);
		element->LinkEndChild(value_e);

		feature->LinkEndChild(element);
	}


	TiXmlElement* value_e = new TiXmlElement("Value");
	text = new TiXmlText(value.c_str());
	value_e->LinkEndChild(text);
	feature->LinkEndChild(value_e);

	root->LinkEndChild(feature);


	return 0;
}

int XmlParser::add_command_feature(TiXmlElement* root, std::string name, std::string display_name, std::string space, std::string toolTip,
	std::string descrioption, std::string access, std::string value, std::string command_value)
{
	TiXmlElement* feature = new TiXmlElement("Command");
	feature->SetAttribute("Name", name.c_str());
	feature->SetAttribute("NameSpace", space.c_str());

	//{
	TiXmlElement* tool = new TiXmlElement("ToolTip");
	TiXmlText* text = new TiXmlText(toolTip.c_str());
	tool->LinkEndChild(text);
	feature->LinkEndChild(tool);

	TiXmlElement* description = new TiXmlElement("Description");
	text = new TiXmlText(descrioption.c_str());
	description->LinkEndChild(text);
	feature->LinkEndChild(description);

	TiXmlElement* display = new TiXmlElement("DisplayName");
	text = new TiXmlText(display_name.c_str());
	display->LinkEndChild(text);
	feature->LinkEndChild(display);

	TiXmlElement* visibility = new TiXmlElement("Visibility");
	text = new TiXmlText("Beginner");
	visibility->LinkEndChild(text);
	feature->LinkEndChild(visibility);

	TiXmlElement* imposed = new TiXmlElement("ImposedAccessMode");
	text = new TiXmlText(access.c_str());
	imposed->LinkEndChild(text);
	feature->LinkEndChild(imposed);

	TiXmlElement* value_e = new TiXmlElement("Value");
	text = new TiXmlText(value.c_str());
	value_e->LinkEndChild(text);
	feature->LinkEndChild(value_e);

	TiXmlElement* value_ce = new TiXmlElement("CommandValue");
	text = new TiXmlText(command_value.c_str());
	value_ce->LinkEndChild(text);
	feature->LinkEndChild(value_ce);


	root->LinkEndChild(feature);


	return 0;
}


int XmlParser::add_int_reg_feature(TiXmlElement *root, std::string name, std::string display_name, std::string space, std::string toolTip,
		std::string descrioption, std::string access, std::vector<int> value_list, std::string max, std::string min, std::string unit)
{

	TiXmlElement* feature = new TiXmlElement("IntReg");
	feature->SetAttribute("Name", name.c_str());
	feature->SetAttribute("NameSpace", space.c_str());

	//{
	TiXmlElement* tool = new TiXmlElement("ToolTip");
	TiXmlText* text = new TiXmlText(toolTip.c_str());
	tool->LinkEndChild(text);
	feature->LinkEndChild(tool);

	TiXmlElement* description = new TiXmlElement("Description");
	text = new TiXmlText(descrioption.c_str());
	description->LinkEndChild(text);
	feature->LinkEndChild(description);

	TiXmlElement* display = new TiXmlElement("DisplayName");
	text = new TiXmlText(display_name.c_str());
	display->LinkEndChild(text);
	feature->LinkEndChild(display);

	TiXmlElement* visibility = new TiXmlElement("Visibility");
	text = new TiXmlText("Beginner");
	visibility->LinkEndChild(text);
	feature->LinkEndChild(visibility);

	TiXmlElement* imposed = new TiXmlElement("ImposedAccessMode");
	text = new TiXmlText(access.c_str());
	imposed->LinkEndChild(text);
	feature->LinkEndChild(imposed);

	TiXmlElement* address = new TiXmlElement("Address");
	text = new TiXmlText("0x00");
	address->LinkEndChild(text);
	feature->LinkEndChild(address);

	TiXmlElement* length = new TiXmlElement("Length");
	text = new TiXmlText(std::to_string(value_list.size()).c_str());
	length->LinkEndChild(text);
	feature->LinkEndChild(length);


	std::string vale_str = "";

	for(int i= 0;i< value_list.size();i++)
	{
		vale_str += std::to_string(value_list[i]);
		if(i != value_list.size()-1)
		{
			vale_str += ",";
		}
	}

	TiXmlElement* value_e = new TiXmlElement("Value");
	text = new TiXmlText(vale_str.c_str());
	value_e->LinkEndChild(text);
	feature->LinkEndChild(value_e);

	TiXmlElement* value_max = new TiXmlElement("Max");
	text = new TiXmlText(max.c_str());
	value_max->LinkEndChild(text);
	feature->LinkEndChild(value_max);

	TiXmlElement* value_min = new TiXmlElement("Min");
	text = new TiXmlText(min.c_str());
	value_min->LinkEndChild(text);
	feature->LinkEndChild(value_min);

	if (!unit.empty())
	{
		TiXmlElement* value_unit = new TiXmlElement("Unit");
		text = new TiXmlText(unit.c_str());
		value_unit->LinkEndChild(text);
		feature->LinkEndChild(value_unit);
	}


	root->LinkEndChild(feature);


	return 0;

}




int XmlParser::add_int_feature(TiXmlElement* root, std::string name, std::string display_name, std::string space, std::string toolTip,
	std::string descrioption, std::string access, std::string value, std::string max, std::string min, std::string unit)
{
	TiXmlElement* feature = new TiXmlElement("Integer");
	feature->SetAttribute("Name", name.c_str());
	feature->SetAttribute("NameSpace", space.c_str());

	//{
	TiXmlElement* tool = new TiXmlElement("ToolTip");
	TiXmlText* text = new TiXmlText(toolTip.c_str());
	tool->LinkEndChild(text);
	feature->LinkEndChild(tool);

	TiXmlElement* description = new TiXmlElement("Description");
	text = new TiXmlText(descrioption.c_str());
	description->LinkEndChild(text);
	feature->LinkEndChild(description);

	TiXmlElement* display = new TiXmlElement("DisplayName");
	text = new TiXmlText(display_name.c_str());
	display->LinkEndChild(text);
	feature->LinkEndChild(display);

	TiXmlElement* visibility = new TiXmlElement("Visibility");
	text = new TiXmlText("Beginner");
	visibility->LinkEndChild(text);
	feature->LinkEndChild(visibility);

	TiXmlElement* imposed = new TiXmlElement("ImposedAccessMode");
	text = new TiXmlText(access.c_str());
	imposed->LinkEndChild(text);
	feature->LinkEndChild(imposed);

	TiXmlElement* value_e = new TiXmlElement("Value");
	text = new TiXmlText(value.c_str());
	value_e->LinkEndChild(text);
	feature->LinkEndChild(value_e);

	TiXmlElement* value_max = new TiXmlElement("Max");
	text = new TiXmlText(max.c_str());
	value_max->LinkEndChild(text);
	feature->LinkEndChild(value_max);

	TiXmlElement* value_min = new TiXmlElement("Min");
	text = new TiXmlText(min.c_str());
	value_min->LinkEndChild(text);
	feature->LinkEndChild(value_min);

	if (!unit.empty())
	{
		TiXmlElement* value_unit = new TiXmlElement("Unit");
		text = new TiXmlText(unit.c_str());
		value_unit->LinkEndChild(text);
		feature->LinkEndChild(value_unit);
	}


	root->LinkEndChild(feature);


	return 0;
}

int XmlParser::add_int_feature(TiXmlElement* root, std::string name, std::string display_name, std::string space, std::string toolTip,
	std::string descrioption, std::string access, std::string value, std::string unit)
{

	TiXmlElement* feature = new TiXmlElement("Integer");
	feature->SetAttribute("Name", name.c_str());
	feature->SetAttribute("NameSpace", space.c_str());

	//{
	TiXmlElement* tool = new TiXmlElement("ToolTip");
	TiXmlText* text = new TiXmlText(toolTip.c_str());
	tool->LinkEndChild(text);
	feature->LinkEndChild(tool);

	TiXmlElement* description = new TiXmlElement("Description");
	text = new TiXmlText(descrioption.c_str());
	description->LinkEndChild(text);
	feature->LinkEndChild(description);

	TiXmlElement* display = new TiXmlElement("DisplayName");
	text = new TiXmlText(display_name.c_str());
	display->LinkEndChild(text);
	feature->LinkEndChild(display);

	TiXmlElement* visibility = new TiXmlElement("Visibility");
	text = new TiXmlText("Beginner");
	visibility->LinkEndChild(text);
	feature->LinkEndChild(visibility);

	TiXmlElement* imposed = new TiXmlElement("ImposedAccessMode");
	text = new TiXmlText(access.c_str());
	imposed->LinkEndChild(text);
	feature->LinkEndChild(imposed);

	TiXmlElement* value_e = new TiXmlElement("Value");
	text = new TiXmlText(value.c_str());
	value_e->LinkEndChild(text);
	feature->LinkEndChild(value_e);

	if (!unit.empty())
	{
		TiXmlElement* value_unit = new TiXmlElement("Unit");
		text = new TiXmlText(unit.c_str());
		value_unit->LinkEndChild(text);
		feature->LinkEndChild(value_unit);
	}


	root->LinkEndChild(feature);


	return 0;
}

int XmlParser::add_bool_feature_width_selected(TiXmlElement* root, std::string name, std::string display_name, std::string space, std::string toolTip,
	std::string descrioption, std::string access, std::string value, std::vector<std::string> selected_list)
{
	TiXmlElement* feature = new TiXmlElement("Boolean");
	feature->SetAttribute("Name", name.c_str());
	feature->SetAttribute("NameSpace", space.c_str());

	//{
	TiXmlElement* tool = new TiXmlElement("ToolTip");
	TiXmlText* text = new TiXmlText(toolTip.c_str());
	tool->LinkEndChild(text);
	feature->LinkEndChild(tool);

	TiXmlElement* description = new TiXmlElement("Description");
	text = new TiXmlText(descrioption.c_str());
	description->LinkEndChild(text);
	feature->LinkEndChild(description);

	TiXmlElement* display = new TiXmlElement("DisplayName");
	text = new TiXmlText(display_name.c_str());
	display->LinkEndChild(text);
	feature->LinkEndChild(display);

	TiXmlElement* visibility = new TiXmlElement("Visibility");
	text = new TiXmlText("Beginner");
	visibility->LinkEndChild(text);
	feature->LinkEndChild(visibility);

	TiXmlElement* imposed = new TiXmlElement("ImposedAccessMode");
	text = new TiXmlText(access.c_str());
	imposed->LinkEndChild(text);
	feature->LinkEndChild(imposed);

	TiXmlElement* value_e = new TiXmlElement("Value");
	text = new TiXmlText(value.c_str());
	value_e->LinkEndChild(text);
	feature->LinkEndChild(value_e);

	for (int s_i = 0; s_i < selected_list.size(); s_i++)
	{
		TiXmlElement* element = new TiXmlElement("pSelected");
		TiXmlText* text = new TiXmlText(selected_list[s_i].c_str());
		element->LinkEndChild(text);
		feature->LinkEndChild(element);
	}

	root->LinkEndChild(feature);


	return 0;
}

int XmlParser::add_string_feature(TiXmlElement* root, std::string name, std::string display_name, std::string space, std::string toolTip,
	std::string descrioption, std::string access, std::string value)
{
	TiXmlElement* feature = new TiXmlElement("String");
	feature->SetAttribute("Name", name.c_str());
	feature->SetAttribute("NameSpace", space.c_str());

	//{
	TiXmlElement* tool = new TiXmlElement("ToolTip");
	TiXmlText* text = new TiXmlText(toolTip.c_str());
	tool->LinkEndChild(text);
	feature->LinkEndChild(tool);

	TiXmlElement* description = new TiXmlElement("Description");
	text = new TiXmlText(descrioption.c_str());
	description->LinkEndChild(text);
	feature->LinkEndChild(description);

	TiXmlElement* display = new TiXmlElement("DisplayName");
	text = new TiXmlText(display_name.c_str());
	display->LinkEndChild(text);
	feature->LinkEndChild(display);

	TiXmlElement* visibility = new TiXmlElement("Visibility");
	text = new TiXmlText("Beginner");
	visibility->LinkEndChild(text);
	feature->LinkEndChild(visibility);

	TiXmlElement* imposed = new TiXmlElement("ImposedAccessMode");
	text = new TiXmlText(access.c_str());
	imposed->LinkEndChild(text);
	feature->LinkEndChild(imposed);

	TiXmlElement* value_e = new TiXmlElement("Value");
	text = new TiXmlText(value.c_str());
	value_e->LinkEndChild(text);
	feature->LinkEndChild(value_e);


	root->LinkEndChild(feature);


	return 0;
}

int XmlParser::add_float_feature(TiXmlElement* root, std::string name, std::string display_name, std::string space, std::string toolTip,
	std::string descrioption, std::string access, std::string value, std::string max, std::string min, std::string unit)
{
	TiXmlElement* feature = new TiXmlElement("Float");
	feature->SetAttribute("Name", name.c_str());
	feature->SetAttribute("NameSpace", space.c_str());

	//{
	TiXmlElement* tool = new TiXmlElement("ToolTip");
	TiXmlText* text = new TiXmlText(toolTip.c_str());
	tool->LinkEndChild(text);
	feature->LinkEndChild(tool);

	TiXmlElement* description = new TiXmlElement("Description");
	text = new TiXmlText(descrioption.c_str());
	description->LinkEndChild(text);
	feature->LinkEndChild(description);

	TiXmlElement* display = new TiXmlElement("DisplayName");
	text = new TiXmlText(display_name.c_str());
	display->LinkEndChild(text);
	feature->LinkEndChild(display);

	TiXmlElement* visibility = new TiXmlElement("Visibility");
	text = new TiXmlText("Beginner");
	visibility->LinkEndChild(text);
	feature->LinkEndChild(visibility);

	TiXmlElement* imposed = new TiXmlElement("ImposedAccessMode");
	text = new TiXmlText(access.c_str());
	imposed->LinkEndChild(text);
	feature->LinkEndChild(imposed);

	TiXmlElement* value_e = new TiXmlElement("Value");
	text = new TiXmlText(value.c_str());
	value_e->LinkEndChild(text);
	feature->LinkEndChild(value_e);

	TiXmlElement* value_max = new TiXmlElement("Max");
	text = new TiXmlText(max.c_str());
	value_max->LinkEndChild(text);
	feature->LinkEndChild(value_max);

	TiXmlElement* value_min = new TiXmlElement("Min");
	text = new TiXmlText(min.c_str());
	value_min->LinkEndChild(text);
	feature->LinkEndChild(value_min);

	if (!unit.empty())
	{
		TiXmlElement* value_unit = new TiXmlElement("Unit");
		text = new TiXmlText(unit.c_str());
		value_unit->LinkEndChild(text);
		feature->LinkEndChild(value_unit);
	}

	root->LinkEndChild(feature);


	return 0;
}

int XmlParser::add_float_feature(TiXmlElement* root, std::string name, std::string display_name, std::string space, std::string toolTip,
	std::string descrioption, std::string access, std::string value, std::string unit)
{

	TiXmlElement* feature = new TiXmlElement("Float");
	feature->SetAttribute("Name", name.c_str());
	feature->SetAttribute("NameSpace", space.c_str());

	//{
	TiXmlElement* tool = new TiXmlElement("ToolTip");
	TiXmlText* text = new TiXmlText(toolTip.c_str());
	tool->LinkEndChild(text);
	feature->LinkEndChild(tool);

	TiXmlElement* description = new TiXmlElement("Description");
	text = new TiXmlText(descrioption.c_str());
	description->LinkEndChild(text);
	feature->LinkEndChild(description);

	TiXmlElement* display = new TiXmlElement("DisplayName");
	text = new TiXmlText(display_name.c_str());
	display->LinkEndChild(text);
	feature->LinkEndChild(display);

	TiXmlElement* visibility = new TiXmlElement("Visibility");
	text = new TiXmlText("Beginner");
	visibility->LinkEndChild(text);
	feature->LinkEndChild(visibility);

	TiXmlElement* imposed = new TiXmlElement("ImposedAccessMode");
	text = new TiXmlText(access.c_str());
	imposed->LinkEndChild(text);
	feature->LinkEndChild(imposed);

	TiXmlElement* value_e = new TiXmlElement("Value");
	text = new TiXmlText(value.c_str());
	value_e->LinkEndChild(text);
	feature->LinkEndChild(value_e);

	if (!unit.empty())
	{
		TiXmlElement* value_unit = new TiXmlElement("Unit");
		text = new TiXmlText(unit.c_str());
		value_unit->LinkEndChild(text);
		feature->LinkEndChild(value_unit);
	}

	root->LinkEndChild(feature);


	return 0;
}


void XmlParser::add_sub_category(TiXmlElement*& root)
{
	TiXmlElement* sub_root_group = new TiXmlElement("Group");
	sub_root_group->SetAttribute("Comment", "SubCategories");

	/*TiXmlElement* device_control_category = new TiXmlElement("Category");
	device_control_category->SetAttribute("Name", "DeviceControl");
	device_control_category->SetAttribute("NameSpace", "Standard");


	TiXmlElement* feature = new TiXmlElement("DisplayName");
	TiXmlText* text = new TiXmlText("Device Control");
	feature->LinkEndChild(text);
	device_control_category->LinkEndChild(feature);

	feature = new TiXmlElement("Visibility");
	text = new TiXmlText("Beginner");
	feature->LinkEndChild(text);
	device_control_category->LinkEndChild(feature);


	feature = new TiXmlElement("ImposedAccessMode");
	text = new TiXmlText("RO");
	feature->LinkEndChild(text);
	device_control_category->LinkEndChild(feature);

	feature = new TiXmlElement("pFeature");
	text = new TiXmlText("DeviceType");
	feature->LinkEndChild(text);
	device_control_category->LinkEndChild(feature);

	feature = new TiXmlElement("pFeature");
	text = new TiXmlText("DeviceScanType");
	feature->LinkEndChild(text);
	device_control_category->LinkEndChild(feature);

	feature = new TiXmlElement("pFeature");
	text = new TiXmlText("DeviceVendorName");
	feature->LinkEndChild(text);
	device_control_category->LinkEndChild(feature);


	feature = new TiXmlElement("pFeature");
	text = new TiXmlText("DeviceModelName");
	feature->LinkEndChild(text);
	device_control_category->LinkEndChild(feature);

	*/

	TiXmlElement* image_format_control_category = new TiXmlElement("Category");
	image_format_control_category->SetAttribute("Name", "ImageFormatControl");
	image_format_control_category->SetAttribute("NameSpace", "Custom");


	TiXmlElement* feature = new TiXmlElement("DisplayName");
	TiXmlText* text = new TiXmlText("Image Format Control");
	feature->LinkEndChild(text);
	image_format_control_category->LinkEndChild(feature);

	feature = new TiXmlElement("Visibility");
	text = new TiXmlText("Beginner");
	feature->LinkEndChild(text);
	image_format_control_category->LinkEndChild(feature);


	feature = new TiXmlElement("ImposedAccessMode");
	text = new TiXmlText("RO");
	feature->LinkEndChild(text);
	image_format_control_category->LinkEndChild(feature);


	feature = new TiXmlElement("pFeature");
	text = new TiXmlText("SensorWidth");
	feature->LinkEndChild(text);
	image_format_control_category->LinkEndChild(feature);

	feature = new TiXmlElement("pFeature");
	text = new TiXmlText("SensorHeight");
	feature->LinkEndChild(text);
	image_format_control_category->LinkEndChild(feature);

	feature = new TiXmlElement("pFeature");
	text = new TiXmlText("SensorName");
	feature->LinkEndChild(text);
	image_format_control_category->LinkEndChild(feature);

	feature = new TiXmlElement("pFeature");
	text = new TiXmlText("ImageSelector");
	feature->LinkEndChild(text);
	image_format_control_category->LinkEndChild(feature);

	feature = new TiXmlElement("pFeature");
	text = new TiXmlText("ImagePixelSize");
	feature->LinkEndChild(text);
	image_format_control_category->LinkEndChild(feature);

	feature = new TiXmlElement("pFeature");
	text = new TiXmlText("ImageTransmission");
	feature->LinkEndChild(text);
	image_format_control_category->LinkEndChild(feature);

	feature = new TiXmlElement("pFeature");
	text = new TiXmlText("PatternsSelector");
	feature->LinkEndChild(text);
	image_format_control_category->LinkEndChild(feature); 

	feature = new TiXmlElement("pFeature");
	text = new TiXmlText("PatternsNumber");
	feature->LinkEndChild(text);
	image_format_control_category->LinkEndChild(feature); 
	
	feature = new TiXmlElement("pFeature");
	text = new TiXmlText("PatternsPixelSize");
	feature->LinkEndChild(text);
	image_format_control_category->LinkEndChild(feature);

	feature = new TiXmlElement("pFeature");
	text = new TiXmlText("PatternsMaxPixelValue");
	feature->LinkEndChild(text);
	image_format_control_category->LinkEndChild(feature);

	feature = new TiXmlElement("pFeature");
	text = new TiXmlText("PatternsExposureModel");
	feature->LinkEndChild(text);
	image_format_control_category->LinkEndChild(feature);

	feature = new TiXmlElement("pFeature");
	text = new TiXmlText("ReconstructBaseCache");
	feature->LinkEndChild(text);
	image_format_control_category->LinkEndChild(feature);

	// feature = new TiXmlElement("pFeature");
	// text = new TiXmlText("OffsetX3D");
	// feature->LinkEndChild(text);
	// image_format_control_category->LinkEndChild(feature);

	// feature = new TiXmlElement("pFeature");
	// text = new TiXmlText("OffsetY3D");
	// feature->LinkEndChild(text);
	// image_format_control_category->LinkEndChild(feature);

	// feature = new TiXmlElement("pFeature");
	// text = new TiXmlText("Width3D");
	// feature->LinkEndChild(text);
	// image_format_control_category->LinkEndChild(feature);

	// feature = new TiXmlElement("pFeature");
	// text = new TiXmlText("Height3D");
	// feature->LinkEndChild(text);
	// image_format_control_category->LinkEndChild(feature);


	// feature = new TiXmlElement("pFeature");
	// text = new TiXmlText("PixelFormat");
	// feature->LinkEndChild(text);
	// image_format_control_category->LinkEndChild(feature);

	// feature = new TiXmlElement("pFeature");
	// text = new TiXmlText("PixelFormatInfoSelector");
	// feature->LinkEndChild(text);
	// image_format_control_category->LinkEndChild(feature);

	
	sub_root_group->LinkEndChild(image_format_control_category);
	/*************************************************************************************************/

	TiXmlElement* acquisition_control_category = new TiXmlElement("Category");
	acquisition_control_category->SetAttribute("Name", "AcquisitionControl");
	acquisition_control_category->SetAttribute("NameSpace", "Standard");


	

	feature = new TiXmlElement("DisplayName");
	text = new TiXmlText("Acquisition Control");
	feature->LinkEndChild(text);
	acquisition_control_category->LinkEndChild(feature);

	feature = new TiXmlElement("ToolTip");
	text = new TiXmlText("Acquisition Control");
	feature->LinkEndChild(text);
	acquisition_control_category->LinkEndChild(feature);

	feature = new TiXmlElement("Description");
	text = new TiXmlText("Acquisition Control");
	feature->LinkEndChild(text);
	acquisition_control_category->LinkEndChild(feature);

	feature = new TiXmlElement("Visibility");
	text = new TiXmlText("Beginner");
	feature->LinkEndChild(text);
	acquisition_control_category->LinkEndChild(feature);


	feature = new TiXmlElement("ImposedAccessMode");
	text = new TiXmlText("RO");
	feature->LinkEndChild(text);
	acquisition_control_category->LinkEndChild(feature);

  
	feature = new TiXmlElement("pFeature");
	text = new TiXmlText("TriggerMode");
	feature->LinkEndChild(text);
	acquisition_control_category->LinkEndChild(feature);

	feature = new TiXmlElement("pFeature");
	text = new TiXmlText("TriggerSource");
	feature->LinkEndChild(text);
	acquisition_control_category->LinkEndChild(feature);

	feature = new TiXmlElement("pFeature");
	text = new TiXmlText("TriggerSoftware");
	feature->LinkEndChild(text);
	acquisition_control_category->LinkEndChild(feature);

	sub_root_group->LinkEndChild(acquisition_control_category);
	/*************************************************************************************************/



	TiXmlElement* analog_control_category = new TiXmlElement("Category");
	analog_control_category->SetAttribute("Name", "AnalogControl");
	analog_control_category->SetAttribute("NameSpace", "Standard");

	feature = new TiXmlElement("ToolTip");
	text = new TiXmlText("Analog Control");
	feature->LinkEndChild(text);
	analog_control_category->LinkEndChild(feature);

	feature = new TiXmlElement("Description");
	text = new TiXmlText("Analog Control");
	feature->LinkEndChild(text);
	analog_control_category->LinkEndChild(feature);

	feature = new TiXmlElement("DisplayName");
	text = new TiXmlText("Analog Control");
	feature->LinkEndChild(text);
	analog_control_category->LinkEndChild(feature);

	feature = new TiXmlElement("Visibility");
	text = new TiXmlText("Beginner");
	feature->LinkEndChild(text);
	analog_control_category->LinkEndChild(feature);


	feature = new TiXmlElement("ImposedAccessMode");
	text = new TiXmlText("RO");
	feature->LinkEndChild(text);
	analog_control_category->LinkEndChild(feature);

	feature = new TiXmlElement("pFeature");
	text = new TiXmlText("Gain");
	feature->LinkEndChild(text);
	analog_control_category->LinkEndChild(feature);

	feature = new TiXmlElement("pFeature");
	text = new TiXmlText("Gamma");
	feature->LinkEndChild(text);
	analog_control_category->LinkEndChild(feature);

	/*************************************************************************************************/

	//sub_root_group->LinkEndChild(device_control_category);
	//sub_root_group->LinkEndChild(image_format_control_category);
	//sub_root_group->LinkEndChild(acquisition_control_category);
	//sub_root_group->LinkEndChild(analog_control_category);


	TiXmlElement* custom_sub_categories = new TiXmlElement("Group");
	custom_sub_categories->SetAttribute("Comment", "DexSubCategories");


	//TiXmlElement* engine_control_category = new TiXmlElement("Category");
	//engine_control_category->SetAttribute("Name", "EngineControl");
	//engine_control_category->SetAttribute("NameSpace", "Custom");

	//feature = new TiXmlElement("DisplayName");
	//text = new TiXmlText("Engine Control");
	//feature->LinkEndChild(text);
	//engine_control_category->LinkEndChild(feature);

	//feature = new TiXmlElement("Visibility");
	//text = new TiXmlText("Beginner");
	//feature->LinkEndChild(text);
	//engine_control_category->LinkEndChild(feature);


	//feature = new TiXmlElement("ImposedAccessMode");
	//text = new TiXmlText("RO");
	//feature->LinkEndChild(text);
	//engine_control_category->LinkEndChild(feature);

	//feature = new TiXmlElement("pFeature");
	//text = new TiXmlText("EngineControl");
	//feature->LinkEndChild(text);
	//engine_control_category->LinkEndChild(feature);
	//   
	//sub_root_group->LinkEndChild(engine_control_category);
	/*************************************************************************************************/


	TiXmlElement* exposure3d_control_category = new TiXmlElement("Category");
	exposure3d_control_category->SetAttribute("Name", "HdrControl");
	exposure3d_control_category->SetAttribute("NameSpace", "Custom");

	feature = new TiXmlElement("ToolTip");
	text = new TiXmlText("Hdr Control");
	feature->LinkEndChild(text);
	exposure3d_control_category->LinkEndChild(feature);

	feature = new TiXmlElement("Description");
	text = new TiXmlText("Hdr Control");
	feature->LinkEndChild(text);
	exposure3d_control_category->LinkEndChild(feature);

	feature = new TiXmlElement("DisplayName");
	text = new TiXmlText("Hdr Control");
	feature->LinkEndChild(text);
	exposure3d_control_category->LinkEndChild(feature);

	feature = new TiXmlElement("Visibility");
	text = new TiXmlText("Beginner");
	feature->LinkEndChild(text);
	exposure3d_control_category->LinkEndChild(feature);

	feature = new TiXmlElement("ImposedAccessMode");
	text = new TiXmlText("RO");
	feature->LinkEndChild(text);
	exposure3d_control_category->LinkEndChild(feature);

	feature = new TiXmlElement("pFeature");
	text = new TiXmlText("HdrNumber");
	feature->LinkEndChild(text);
	exposure3d_control_category->LinkEndChild(feature);

	// feature = new TiXmlElement("pFeature");
	// text = new TiXmlText("HdrGroupSelector");
	// feature->LinkEndChild(text);
	// exposure3d_control_category->LinkEndChild(feature);

	// feature = new TiXmlElement("pFeature");
	// text = new TiXmlText("HdrExposureTime");
	// feature->LinkEndChild(text);
	// exposure3d_control_category->LinkEndChild(feature);

	// feature = new TiXmlElement("pFeature");
	// text = new TiXmlText("HdrLedCurrent");
	// feature->LinkEndChild(text);
	// exposure3d_control_category->LinkEndChild(feature);

	feature = new TiXmlElement("pFeature");
	text = new TiXmlText("HdrExposureEntry0");
	feature->LinkEndChild(text);
	exposure3d_control_category->LinkEndChild(feature);

	feature = new TiXmlElement("pFeature");
	text = new TiXmlText("HdrExposureEntry1");
	feature->LinkEndChild(text);
	exposure3d_control_category->LinkEndChild(feature);

	feature = new TiXmlElement("pFeature");
	text = new TiXmlText("HdrExposureEntry2");
	feature->LinkEndChild(text);
	exposure3d_control_category->LinkEndChild(feature);

	feature = new TiXmlElement("pFeature");
	text = new TiXmlText("HdrExposureEntry3");
	feature->LinkEndChild(text);
	exposure3d_control_category->LinkEndChild(feature);

	feature = new TiXmlElement("pFeature");
	text = new TiXmlText("HdrExposureEntry4");
	feature->LinkEndChild(text);
	exposure3d_control_category->LinkEndChild(feature);

	feature = new TiXmlElement("pFeature");
	text = new TiXmlText("HdrExposureEntry5");
	feature->LinkEndChild(text);
	exposure3d_control_category->LinkEndChild(feature);

	feature = new TiXmlElement("pFeature");
	text = new TiXmlText("HdrLedEntry0");
	feature->LinkEndChild(text);
	exposure3d_control_category->LinkEndChild(feature);

	feature = new TiXmlElement("pFeature");
	text = new TiXmlText("HdrLedEntry1");
	feature->LinkEndChild(text);
	exposure3d_control_category->LinkEndChild(feature);

	feature = new TiXmlElement("pFeature");
	text = new TiXmlText("HdrLedEntry2");
	feature->LinkEndChild(text);
	exposure3d_control_category->LinkEndChild(feature); 

	feature = new TiXmlElement("pFeature");
	text = new TiXmlText("HdrLedEntry3");
	feature->LinkEndChild(text);
	exposure3d_control_category->LinkEndChild(feature); 

	feature = new TiXmlElement("pFeature");
	text = new TiXmlText("HdrLedEntry4");
	feature->LinkEndChild(text);
	exposure3d_control_category->LinkEndChild(feature); 

	feature = new TiXmlElement("pFeature");
	text = new TiXmlText("HdrLedEntry5");
	feature->LinkEndChild(text);
	exposure3d_control_category->LinkEndChild(feature);

	sub_root_group->LinkEndChild(exposure3d_control_category);

	/*************************************************************************************************/

	TiXmlElement* basic_3d_control_category = new TiXmlElement("Category");
	basic_3d_control_category->SetAttribute("Name", "Basic3DControl");
	basic_3d_control_category->SetAttribute("NameSpace", "Custom");

	feature = new TiXmlElement("ToolTip");
	text = new TiXmlText("Basic 3D Control");
	feature->LinkEndChild(text);
	basic_3d_control_category->LinkEndChild(feature);

	feature = new TiXmlElement("Description");
	text = new TiXmlText("Basic 3D Control");
	feature->LinkEndChild(text);
	basic_3d_control_category->LinkEndChild(feature);

	feature = new TiXmlElement("DisplayName");
	text = new TiXmlText("Basic 3D Control");
	feature->LinkEndChild(text);
	basic_3d_control_category->LinkEndChild(feature);

	feature = new TiXmlElement("Visibility");
	text = new TiXmlText("Beginner");
	feature->LinkEndChild(text);
	basic_3d_control_category->LinkEndChild(feature);

	feature = new TiXmlElement("ImposedAccessMode");
	text = new TiXmlText("RO");
	feature->LinkEndChild(text);
	basic_3d_control_category->LinkEndChild(feature);

	feature = new TiXmlElement("pFeature");
	text = new TiXmlText("EngineModel");
	feature->LinkEndChild(text);
	basic_3d_control_category->LinkEndChild(feature);

	feature = new TiXmlElement("pFeature");
	text = new TiXmlText("ExposureModel");
	feature->LinkEndChild(text);
	basic_3d_control_category->LinkEndChild(feature);

	feature = new TiXmlElement("pFeature");
	text = new TiXmlText("ExposureTime3D");
	feature->LinkEndChild(text);
	basic_3d_control_category->LinkEndChild(feature);

	feature = new TiXmlElement("pFeature");
	text = new TiXmlText("Gain3D");
	feature->LinkEndChild(text);
	basic_3d_control_category->LinkEndChild(feature);

	feature = new TiXmlElement("pFeature");
	text = new TiXmlText("Led");
	feature->LinkEndChild(text);
	basic_3d_control_category->LinkEndChild(feature);
 
	feature = new TiXmlElement("pFeature");
	text = new TiXmlText("RepeatedNumber");
	feature->LinkEndChild(text);
	basic_3d_control_category->LinkEndChild(feature);


	sub_root_group->LinkEndChild(basic_3d_control_category);

	/*************************************************************************************************/

	TiXmlElement* correction_control_category = new TiXmlElement("Category");
	correction_control_category->SetAttribute("Name", "CorrectionControl");
	correction_control_category->SetAttribute("NameSpace", "Custom");

	feature = new TiXmlElement("ToolTip");
	text = new TiXmlText("Correction Control");
	feature->LinkEndChild(text);
	correction_control_category->LinkEndChild(feature);

	feature = new TiXmlElement("Description");
	text = new TiXmlText("Correction Control");
	feature->LinkEndChild(text);
	correction_control_category->LinkEndChild(feature);

	feature = new TiXmlElement("DisplayName");
	text = new TiXmlText("Correction Control");
	feature->LinkEndChild(text);
	correction_control_category->LinkEndChild(feature);

	feature = new TiXmlElement("Visibility");
	text = new TiXmlText("Beginner");
	feature->LinkEndChild(text);
	correction_control_category->LinkEndChild(feature);

	feature = new TiXmlElement("ImposedAccessMode");
	text = new TiXmlText("RO");
	feature->LinkEndChild(text);
	correction_control_category->LinkEndChild(feature);

	feature = new TiXmlElement("pFeature");
	text = new TiXmlText("Smooth");
	feature->LinkEndChild(text);
	correction_control_category->LinkEndChild(feature);

	feature = new TiXmlElement("pFeature");
	text = new TiXmlText("SmoothLevel");
	feature->LinkEndChild(text);
	correction_control_category->LinkEndChild(feature);
	
	feature = new TiXmlElement("pFeature");
	text = new TiXmlText("PhaseCorrect");
	feature->LinkEndChild(text);
	correction_control_category->LinkEndChild(feature); 

	feature = new TiXmlElement("pFeature");
	text = new TiXmlText("PhaseCorrectLevel");
	feature->LinkEndChild(text);
	correction_control_category->LinkEndChild(feature);

	// feature = new TiXmlElement("pFeature");
	// text = new TiXmlText("ThermalDriftCorrection");
	// feature->LinkEndChild(text);
	// correction_control_category->LinkEndChild(feature);

	sub_root_group->LinkEndChild(correction_control_category);
	/*************************************************************************************************/

	TiXmlElement* exposure_control_category = new TiXmlElement("Category");
	exposure_control_category->SetAttribute("Name", "Image2DControl");
	exposure_control_category->SetAttribute("NameSpace", "Custom");

	feature = new TiXmlElement("ToolTip");
	text = new TiXmlText("Image 2D Control");
	feature->LinkEndChild(text);
	exposure_control_category->LinkEndChild(feature);

	feature = new TiXmlElement("Description");
	text = new TiXmlText("Image 2D Control");
	feature->LinkEndChild(text);
	exposure_control_category->LinkEndChild(feature);

	feature = new TiXmlElement("DisplayName");
	text = new TiXmlText("Image 2D Control");
	feature->LinkEndChild(text);
	exposure_control_category->LinkEndChild(feature);

	feature = new TiXmlElement("Visibility");
	text = new TiXmlText("Beginner");
	feature->LinkEndChild(text);
	exposure_control_category->LinkEndChild(feature);

	feature = new TiXmlElement("ImposedAccessMode");
	text = new TiXmlText("RO");
	feature->LinkEndChild(text);
	exposure_control_category->LinkEndChild(feature);

	feature = new TiXmlElement("pFeature");
	text = new TiXmlText("IlluminatedModel");
	feature->LinkEndChild(text);
	exposure_control_category->LinkEndChild(feature);

	feature = new TiXmlElement("pFeature");
	text = new TiXmlText("ExposureModel2D");
	feature->LinkEndChild(text);
	exposure_control_category->LinkEndChild(feature);

	
	feature = new TiXmlElement("pFeature");
	text = new TiXmlText("Gain2D");
	feature->LinkEndChild(text);
	exposure_control_category->LinkEndChild(feature);

	feature = new TiXmlElement("pFeature");
	text = new TiXmlText("ExposureTime2D");
	feature->LinkEndChild(text);
	exposure_control_category->LinkEndChild(feature);

	feature = new TiXmlElement("pFeature");
	text = new TiXmlText("HdrNumber2D");
	feature->LinkEndChild(text);
	exposure_control_category->LinkEndChild(feature);

	// feature = new TiXmlElement("pFeature");
	// text = new TiXmlText("HdrGroupSelector2D");
	// feature->LinkEndChild(text);
	// exposure_control_category->LinkEndChild(feature);

	// feature = new TiXmlElement("pFeature");
	// text = new TiXmlText("HdrExposureTime2D");
	// feature->LinkEndChild(text);
	// exposure_control_category->LinkEndChild(feature);

	feature = new TiXmlElement("pFeature");
	text = new TiXmlText("HdrExposure2DEntry0");
	feature->LinkEndChild(text);
	exposure_control_category->LinkEndChild(feature);

	feature = new TiXmlElement("pFeature");
	text = new TiXmlText("HdrExposure2DEntry1");
	feature->LinkEndChild(text);
	exposure_control_category->LinkEndChild(feature);

	feature = new TiXmlElement("pFeature");
	text = new TiXmlText("HdrExposure2DEntry2");
	feature->LinkEndChild(text);
	exposure_control_category->LinkEndChild(feature);

	feature = new TiXmlElement("pFeature");
	text = new TiXmlText("HdrExposure2DEntry3");
	feature->LinkEndChild(text);
	exposure_control_category->LinkEndChild(feature);

	feature = new TiXmlElement("pFeature");
	text = new TiXmlText("HdrExposure2DEntry4");
	feature->LinkEndChild(text);
	exposure_control_category->LinkEndChild(feature);

	feature = new TiXmlElement("pFeature");
	text = new TiXmlText("HdrExposure2DEntry5");
	feature->LinkEndChild(text);
	exposure_control_category->LinkEndChild(feature);

	feature = new TiXmlElement("pFeature");
	text = new TiXmlText("HdrExposure2DEntry6");
	feature->LinkEndChild(text);
	exposure_control_category->LinkEndChild(feature);

	feature = new TiXmlElement("pFeature");
	text = new TiXmlText("HdrExposure2DEntry7");
	feature->LinkEndChild(text);
	exposure_control_category->LinkEndChild(feature);

	feature = new TiXmlElement("pFeature");
	text = new TiXmlText("HdrExposure2DEntry8");
	feature->LinkEndChild(text);
	exposure_control_category->LinkEndChild(feature);

	feature = new TiXmlElement("pFeature");
	text = new TiXmlText("HdrExposure2DEntry9");
	feature->LinkEndChild(text);
	exposure_control_category->LinkEndChild(feature);


	sub_root_group->LinkEndChild(exposure_control_category);
	/*************************************************************************************************/


	TiXmlElement* filter_control_category = new TiXmlElement("Category");
	filter_control_category->SetAttribute("Name", "FilterControl");
	filter_control_category->SetAttribute("NameSpace", "Custom");

	feature = new TiXmlElement("ToolTip");
	text = new TiXmlText("Filter Control");
	feature->LinkEndChild(text);
	filter_control_category->LinkEndChild(feature);

	feature = new TiXmlElement("Description");
	text = new TiXmlText("Filter Control");
	feature->LinkEndChild(text);
	filter_control_category->LinkEndChild(feature);

	feature = new TiXmlElement("DisplayName");
	text = new TiXmlText("Filter Control");
	feature->LinkEndChild(text);
	filter_control_category->LinkEndChild(feature);

	feature = new TiXmlElement("Visibility");
	text = new TiXmlText("Beginner");
	feature->LinkEndChild(text);
	filter_control_category->LinkEndChild(feature);


	feature = new TiXmlElement("ImposedAccessMode");
	text = new TiXmlText("RO");
	feature->LinkEndChild(text);
	filter_control_category->LinkEndChild(feature);



	feature = new TiXmlElement("pFeature");
	text = new TiXmlText("ConfidenceFilter");
	feature->LinkEndChild(text);
	filter_control_category->LinkEndChild(feature);

	feature = new TiXmlElement("pFeature");
	text = new TiXmlText("ConfidenceThreshold");
	feature->LinkEndChild(text);
	filter_control_category->LinkEndChild(feature);

	feature = new TiXmlElement("pFeature");
	text = new TiXmlText("RadiusFilter");
	feature->LinkEndChild(text);
	filter_control_category->LinkEndChild(feature);

	feature = new TiXmlElement("pFeature");
	text = new TiXmlText("RadiusFilterRadius");
	feature->LinkEndChild(text);
	filter_control_category->LinkEndChild(feature);

	feature = new TiXmlElement("pFeature");
	text = new TiXmlText("RadiusFilterNumber");
	feature->LinkEndChild(text);
	filter_control_category->LinkEndChild(feature);

	feature = new TiXmlElement("pFeature");
	text = new TiXmlText("RadiusFilterIteration");
	feature->LinkEndChild(text);
	filter_control_category->LinkEndChild(feature);

	feature = new TiXmlElement("pFeature");
	text = new TiXmlText("DepthFilter");
	feature->LinkEndChild(text);
	filter_control_category->LinkEndChild(feature);

	feature = new TiXmlElement("pFeature");
	text = new TiXmlText("DepthFilterThreshold");
	feature->LinkEndChild(text);
	filter_control_category->LinkEndChild(feature);

	feature = new TiXmlElement("pFeature");
	text = new TiXmlText("FisherFilter");
	feature->LinkEndChild(text);
	filter_control_category->LinkEndChild(feature);

	feature = new TiXmlElement("pFeature");
	text = new TiXmlText("FisherFilterThreshold");
	feature->LinkEndChild(text);
	filter_control_category->LinkEndChild(feature);

	feature = new TiXmlElement("pFeature");
	text = new TiXmlText("MonotonicityFilter");
	feature->LinkEndChild(text);
	filter_control_category->LinkEndChild(feature);

	feature = new TiXmlElement("pFeature");
	text = new TiXmlText("MonotonicityFilterThreshold");
	feature->LinkEndChild(text);
	filter_control_category->LinkEndChild(feature);

	sub_root_group->LinkEndChild(filter_control_category);
	/*************************************************************************************************/


	TiXmlElement* calib_control_category = new TiXmlElement("Category");
	calib_control_category->SetAttribute("Name", "CalibParam");
	calib_control_category->SetAttribute("NameSpace", "Custom");

	feature = new TiXmlElement("ToolTip");
	text = new TiXmlText("Calib Param");
	feature->LinkEndChild(text);
	calib_control_category->LinkEndChild(feature);

	feature = new TiXmlElement("Description");
	text = new TiXmlText("Calib Param");
	feature->LinkEndChild(text);
	calib_control_category->LinkEndChild(feature);

	feature = new TiXmlElement("DisplayName");
	text = new TiXmlText("Calib Param");
	feature->LinkEndChild(text);
	calib_control_category->LinkEndChild(feature);

	feature = new TiXmlElement("Visibility");
	text = new TiXmlText("Beginner");
	feature->LinkEndChild(text);
	calib_control_category->LinkEndChild(feature);

	feature = new TiXmlElement("ImposedAccessMode");
	text = new TiXmlText("RO");
	feature->LinkEndChild(text);
	calib_control_category->LinkEndChild(feature);

	feature = new TiXmlElement("pFeature");
	text = new TiXmlText("Intrinsic");
	feature->LinkEndChild(text);
	calib_control_category->LinkEndChild(feature);

	feature = new TiXmlElement("pFeature");
	text = new TiXmlText("Extrinsic");
	feature->LinkEndChild(text);
	calib_control_category->LinkEndChild(feature);

	feature = new TiXmlElement("pFeature");
	text = new TiXmlText("Distortion");
	feature->LinkEndChild(text);
	calib_control_category->LinkEndChild(feature);

	sub_root_group->LinkEndChild(calib_control_category);

	root->LinkEndChild(sub_root_group);
}


void XmlParser::add_root_category(TiXmlElement*& root)
{

	TiXmlElement* root_group = new TiXmlElement("Group");
	root_group->SetAttribute("Comment", "RootCategory");

	TiXmlElement* root_category = new TiXmlElement("Category");
	root_category->SetAttribute("Name", "Root");
	root_category->SetAttribute("NameSpace", "Standard");

	//{
	TiXmlElement* feature = new TiXmlElement("DisplayName");
	TiXmlText* text = new TiXmlText("Root");
	feature->LinkEndChild(text);
	root_category->LinkEndChild(feature);

	feature = new TiXmlElement("Visibility");
	text = new TiXmlText("Beginner");
	feature->LinkEndChild(text);
	root_category->LinkEndChild(feature);


	//feature = new TiXmlElement("pFeature");
	//text = new TiXmlText("DeviceControl");
	//feature->LinkEndChild(text);
	//root_category->LinkEndChild(feature);



	feature = new TiXmlElement("pFeature");
	text = new TiXmlText("AnalogControl");
	feature->LinkEndChild(text);
	root_category->LinkEndChild(feature);

	feature = new TiXmlElement("pFeature");
	text = new TiXmlText("AcquisitionControl");
	feature->LinkEndChild(text);
	root_category->LinkEndChild(feature);

	feature = new TiXmlElement("pFeature");
	text = new TiXmlText("DigitalIOControl");
	feature->LinkEndChild(text);
	root_category->LinkEndChild(feature);

	feature = new TiXmlElement("pFeature");
	text = new TiXmlText("Scan3dControl");
	feature->LinkEndChild(text);
	root_category->LinkEndChild(feature);
	//}


	root_group->LinkEndChild(root_category);


	TiXmlElement* dex_category = new TiXmlElement("Category");
	dex_category->SetAttribute("Name", "Root");
	dex_category->SetAttribute("NameSpace", "Custom");

	feature = new TiXmlElement("DisplayName");
	text = new TiXmlText("Custom");
	feature->LinkEndChild(text);
	dex_category->LinkEndChild(feature);

	feature = new TiXmlElement("Visibility");
	text = new TiXmlText("Beginner");
	feature->LinkEndChild(text);
	dex_category->LinkEndChild(feature);


	feature = new TiXmlElement("pFeature");
	text = new TiXmlText("Basic3DControl");
	feature->LinkEndChild(text);
	dex_category->LinkEndChild(feature);

	//feature = new TiXmlElement("pFeature");
	//text = new TiXmlText("EngineControl");
	//feature->LinkEndChild(text);
	//dex_category->LinkEndChild(feature);

	feature = new TiXmlElement("pFeature");
	text = new TiXmlText("ImageFormatControl");
	feature->LinkEndChild(text);
	dex_category->LinkEndChild(feature);

	feature = new TiXmlElement("pFeature");
	text = new TiXmlText("HdrControl");
	feature->LinkEndChild(text);
	dex_category->LinkEndChild(feature);


	feature = new TiXmlElement("pFeature");
	text = new TiXmlText("Image2DControl");
	feature->LinkEndChild(text);
	dex_category->LinkEndChild(feature);

	feature = new TiXmlElement("pFeature");
	text = new TiXmlText("CorrectionControl");
	feature->LinkEndChild(text);
	dex_category->LinkEndChild(feature);


	feature = new TiXmlElement("pFeature");
	text = new TiXmlText("FilterControl");
	feature->LinkEndChild(text);
	dex_category->LinkEndChild(feature);


	feature = new TiXmlElement("pFeature");
	text = new TiXmlText("CalibParam");
	feature->LinkEndChild(text);
	dex_category->LinkEndChild(feature);


	root_group->LinkEndChild(dex_category);

	root->LinkEndChild(root_group);
}

void XmlParser::add_xml_head(TiXmlElement*& root)
{
	TiXmlElement* root_e = new TiXmlElement("RegisterDescription");
	root_e->SetAttribute("xmlns", "http://www.genicam.org/GenApi/Version_1_1");
	root_e->SetAttribute("xmlns:xsi", "http://www.w3.org/2001/XMLSchema-instance");
	root_e->SetAttribute("xsi:schemaLocation", "http://www.genicam.org/GenApi/Version_1_1 http://www.genicam.org/GenApi/GenApiSchema_Version_1_1.xsd");
	root_e->SetAttribute("ModelName", "XEMA");
	root_e->SetAttribute("VendorName", "Dexforce");
	root_e->SetAttribute("ToolTip", "Reference SFNC camera XML (autogenerated)");
	root_e->SetAttribute("StandardNameSpace", "None");
	root_e->SetAttribute("SchemaMajorVersion", "1");
	root_e->SetAttribute("SchemaMinorVersion", "1");
	root_e->SetAttribute("SchemaSubMinorVersion", "0");
	root_e->SetAttribute("MajorVersion", "2");
	root_e->SetAttribute("MinorVersion", "0");
	root_e->SetAttribute("SubMinorVersion", "0");
	root_e->SetAttribute("ProductGuid", "11111111-2222-3333-4444-555555555555");
	root_e->SetAttribute("VersionGuid", "AAAAAAAA-BBBB-CCCC-DDDD-EEEEEEEEEEEE");


	root = root_e;
}


void XmlParser::add_device_control_category(TiXmlElement* root)
{

	TiXmlElement* group = new TiXmlElement("Group");
	group->SetAttribute("Comment", "DeviceControl");



}


void XmlParser::add_correction_control_category(TiXmlElement* root)
{
	TiXmlElement* group = new TiXmlElement("Group");
	group->SetAttribute("Comment", "CorrectionControl");

	std::vector<std::string> select_feature;
	select_feature.clear();
	select_feature.push_back("SmoothLevel");
	add_bool_feature_width_selected(group, "Smooth", "Smooth", "Custom", "", "", "RW", "1", select_feature);
	add_int_feature(group, "SmoothLevel", "Level", "Custom", "", "", "RW", "1.0", "5", "1");
 
	select_feature.clear();
	select_feature.push_back("PhaseCorrectLevel");
	add_bool_feature_width_selected(group, "PhaseCorrect", "Phase Correct", "Custom", "", "", "RW", "0", select_feature);
	add_int_feature(group, "PhaseCorrectLevel", "Phase Correct Level", "Custom", "", "", "RW", "40", "100", "0");


	root->LinkEndChild(group);
}

void XmlParser::add_filter_control_category(TiXmlElement* root)
{
	TiXmlElement* group = new TiXmlElement("Group");
	group->SetAttribute("Comment", "FilterControl");

	std::vector<std::string> select_feature;

	select_feature.push_back("RadiusFilterRadius");
	select_feature.push_back("RadiusFilterNumber");
	select_feature.push_back("RadiusFilterIteration");
	add_bool_feature_width_selected(group, "RadiusFilter", "Radius Filter", "Custom", "", "", "RW", "0", select_feature);

	add_float_feature(group, "RadiusFilterRadius", "Radius", "Custom", "", "", "RW", "2.5", "100", "0");
	add_int_feature(group, "RadiusFilterNumber", "Number", "Custom", "", "", "RW", "8", "100", "2");
	add_int_feature(group, "RadiusFilterIteration", "Iteration", "Custom", "", "", "RW", "1",  "10", "1");



	select_feature.clear();
	select_feature.push_back("DepthFilterThreshold");
	add_bool_feature_width_selected(group, "DepthFilter", "Depth Filter", "Custom", "", "", "RW", "0", select_feature);
	add_float_feature(group, "DepthFilterThreshold", "Threshold", "Custom", "", "", "RW", "33.0", "100" ,"0");

	select_feature.clear();
	select_feature.push_back("ConfidenceThreshold");
	add_bool_feature_width_selected(group, "ConfidenceFilter", "Confidence Filter", "Custom", "", "", "RW", "0", select_feature);
	add_float_feature(group, "ConfidenceThreshold", "Threshold", "Custom", "", "", "RW", "3.0", "100", "0");

	select_feature.clear();
	select_feature.push_back("FisherFilterThreshold");
	add_bool_feature_width_selected(group, "FisherFilter", "Fisher Filter", "Custom", "", "", "RW", "0", select_feature);
	add_float_feature(group, "FisherFilterThreshold", "Threshold", "Custom", "", "", "RW", "30.0", "100", "0");

	select_feature.clear();
	select_feature.push_back("MonotonicityFilterThreshold");
	add_bool_feature_width_selected(group, "MonotonicityFilter", "Monotonicity Filter", "Custom", "", "", "RW", "0", select_feature);
	add_float_feature(group, "MonotonicityFilterThreshold", "Threshold", "Custom", "", "", "RW", "30.0", "100", "0");


	root->LinkEndChild(group);
}

void XmlParser::add_calib_param_category(TiXmlElement* root)
{
	TiXmlElement* group = new TiXmlElement("Group");
	group->SetAttribute("Comment", "CalibParam");

	add_string_feature(group, "Intrinsic", "Intrinsic", "Custom", "", "", "RW", "1,0,0,0,1,0,0,0,1");
	add_string_feature(group, "Extrinsic", "Extrinsic", "Custom", "", "", "RW", "1,0,0,0,0,1,0,0,0,0,0,1");
	add_string_feature(group, "Distortion", "Distortion", "Custom", "", "", "RW", "0,0,0,0,0");



	root->LinkEndChild(group);
}

void XmlParser::add_image_2d_control_category(TiXmlElement* root)
{
	TiXmlElement* group = new TiXmlElement("Group");
	group->SetAttribute("Comment", "Image2DControl");

	std::vector<std::string> value_list;
	std::vector<std::string> display_list;
	std::vector<std::string> tips_list;
	std::vector<std::string> description_list;

	value_list.push_back("Default");
	display_list.push_back("Default");
	tips_list.push_back("");
	description_list.push_back("");

	value_list.push_back("Illuminated");
	display_list.push_back("Illuminated");
	tips_list.push_back("");
	description_list.push_back("");

	value_list.push_back("NotIlluminated");
	display_list.push_back("NotIlluminated");
	tips_list.push_back("");
	description_list.push_back("");


	add_enum_feature(group, "IlluminatedModel", "Illuminated Model", "Custom", "", "", "RW","0",
		value_list, display_list, tips_list, description_list);

	value_list.clear();
	tips_list.clear();
	description_list.clear();
	display_list.clear();

	value_list.push_back("SingleExposure2D");
	display_list.push_back("Single Exposure");
	tips_list.push_back("");
	description_list.push_back("");

	value_list.push_back("HdrExposure2D");
	display_list.push_back("Hdr Exposure");
	tips_list.push_back("");
	description_list.push_back("");


	add_enum_feature(group, "ExposureModel2D", "Exposure Model", "Custom", "", "", "RW", "0",
		value_list, display_list, tips_list, description_list);

	value_list.clear();
	tips_list.clear();
	description_list.clear();
	display_list.clear();


	// for (int i = 0; i < 10; i++)
	// {
	// 	std::string str = "Group " + std::to_string(i);
	// 	display_list.push_back(str);
	// 	value_list.push_back(str);
	// 	tips_list.push_back("");
	// 	description_list.push_back("");

	// }

	// std::vector<std::string> select_list;
	// select_list.push_back("HdrExposureTime2D");


	// add_enum_feature_with_selected(group, "HdrGroupSelector2D", "Selector", "Custom", "", "", "RW", "0",
	// 	value_list, display_list, tips_list, description_list, select_list);


	value_list.clear();
	tips_list.clear();
	description_list.clear();
	

	add_int_feature(group, "HdrNumber2D", "Number", "Custom", "", "", "RW", "2", "10" ,"2");
	// add_int_feature(group, "HdrExposureTime2D", "Exposure List", "Custom", "", "", "RW", "12000", "1000000", "100", "us");
	add_int_feature(group, "ExposureTime2D", "Exposure", "Custom", "", "", "RW", "12000","1000000", "100", "us");
	add_float_feature(group, "Gain2D", "Gain", "Custom", "", "", "RW", "0", "24", "0", "db");
 
	
	add_int_feature(group, "HdrExposure2DEntry0", "Exposure List 0", "Custom", "", "", "RW", "12000", "1000000", "100", "us");
	add_int_feature(group, "HdrExposure2DEntry1", "Exposure List 1", "Custom", "", "", "RW", "36000", "1000000", "100", "us");
	add_int_feature(group, "HdrExposure2DEntry2", "Exposure List 2", "Custom", "", "", "RW", "24000", "1000000", "100", "us");
	add_int_feature(group, "HdrExposure2DEntry3", "Exposure List 3", "Custom", "", "", "RW", "48000", "1000000", "100", "us");
	add_int_feature(group, "HdrExposure2DEntry4", "Exposure List 4", "Custom", "", "", "RW", "60000", "1000000", "100", "us");
	add_int_feature(group, "HdrExposure2DEntry5", "Exposure List 5", "Custom", "", "", "RW", "100000", "1000000", "100", "us");
	add_int_feature(group, "HdrExposure2DEntry6", "Exposure List 6", "Custom", "", "", "RW", "200000", "1000000", "100", "us");
	add_int_feature(group, "HdrExposure2DEntry7", "Exposure List 7", "Custom", "", "", "RW", "400000", "1000000", "100", "us");
	add_int_feature(group, "HdrExposure2DEntry8", "Exposure List 8", "Custom", "", "", "RW", "800000", "1000000", "100", "us");
	add_int_feature(group, "HdrExposure2DEntry9", "Exposure List 9", "Custom", "", "", "RW", "1000000", "1000000", "100", "us");

	root->LinkEndChild(group);
}

void XmlParser::add_hdr_control_category(TiXmlElement* root)
{
	TiXmlElement* group = new TiXmlElement("Group");
	group->SetAttribute("Comment", "HdrControl");

	std::vector<std::string> value_list;
	std::vector<std::string> display_list;
	std::vector<std::string> tips_list;
	std::vector<std::string> description_list;

	// for (int i = 0; i < 6; i++)
	// {
	// 	std::string str = "Group " + std::to_string(i);
	// 	value_list.push_back(str);
	// 	display_list.push_back(str);
	// 	tips_list.push_back("");
	// 	description_list.push_back("");
	// }

	// std::vector<std::string> select_list;
	// select_list.push_back("HdrExposureTime");
	// select_list.push_back("HdrLedCurrent");


	// add_enum_feature_with_selected(group, "HdrGroupSelector", "Selector", "Custom", "", "", "RW", "0",
	// 	value_list, display_list, tips_list, description_list, select_list);


	value_list.clear();
	tips_list.clear();
	description_list.clear(); 
	
 
	add_int_feature(group, "HdrNumber", "Number", "Custom", "", "", "RW", "2", "6", "2");

	// add_int_feature(group, "HdrExposureTime", "Exposure List", "Custom", "", "", "RW", "12000", "100000", "1700", "us");
	// add_int_feature(group, "HdrLedCurrent", "Led List", "Custom", "", "", "RW", "1023", "1023", "0", "Level");

	add_int_feature(group, "HdrExposureEntry0", "Exposure List 0", "Custom", "", "", "RW", "12000", "100000", "1700", "us");
	add_int_feature(group, "HdrExposureEntry1", "Exposure List 1", "Custom", "", "", "RW", "24000", "100000", "1700", "us");
	add_int_feature(group, "HdrExposureEntry2", "Exposure List 2", "Custom", "", "", "RW", "36000", "100000", "1700", "us");
	add_int_feature(group, "HdrExposureEntry3", "Exposure List 3", "Custom", "", "", "RW", "48000", "100000", "1700", "us");
	add_int_feature(group, "HdrExposureEntry4", "Exposure List 4", "Custom", "", "", "RW", "60000", "100000", "1700", "us");
	add_int_feature(group, "HdrExposureEntry5", "Exposure List 5", "Custom", "", "", "RW", "100000", "100000", "1700", "us");

	add_int_feature(group, "HdrLedEntry0", "Led List 0", "Custom", "", "", "RW", "1023", "1023", "0", "Level");
	add_int_feature(group, "HdrLedEntry1", "Led List 1", "Custom", "", "", "RW", "1023", "1023", "0", "Level");
	add_int_feature(group, "HdrLedEntry2", "Led List 2", "Custom", "", "", "RW", "1023", "1023", "0", "Level");
	add_int_feature(group, "HdrLedEntry3", "Led List 3", "Custom", "", "", "RW", "1023", "1023", "0", "Level");
	add_int_feature(group, "HdrLedEntry4", "Led List 4", "Custom", "", "", "RW", "1023", "1023", "0", "Level");
	add_int_feature(group, "HdrLedEntry5", "Led List 5", "Custom", "", "", "RW", "1023", "1023", "0", "Level");

	// std::vector<int> exposure_list = { 12000, 20000, 30000, 40000, 50000, 60000 };
	// std::vector<int> led_list = { 1023, 1023, 1023, 1023, 1023, 1023 }; 
	// add_int_reg_feature(group, "HdrExposureTimeEntry", "Exposure Entry", "Custom", "", "", "RW",exposure_list,  "100000", "1700", "us");
	// add_int_reg_feature(group, "HdrLedCurrentEntry", "Led Entry", "Custom", "", "", "RW", led_list, "1023", "0", "Level");

	root->LinkEndChild(group);
}

void XmlParser::add_basic_3d_control_category(TiXmlElement* root)
{
	TiXmlElement* group = new TiXmlElement("Group");
	group->SetAttribute("Comment", "Basic3DControl");

	std::vector<std::string> value_list;
	std::vector<std::string> display_list;
	std::vector<std::string> tips_list;
	std::vector<std::string> description_list;

	value_list.push_back("NormalModel");
	display_list.push_back("Normal Model");
	tips_list.push_back("");
	description_list.push_back("");

	// value_list.push_back("ReflectModel");
	// display_list.push_back("Reflect Model");
	// tips_list.push_back("");
	// description_list.push_back("");

	// value_list.push_back("BlackModel");
	// display_list.push_back("Black Model");
	// tips_list.push_back("");
	// description_list.push_back("");

	add_enum_feature(group, "EngineModel", "Engine", "Custom", "", "", "RW", "0",
		value_list, display_list, tips_list, description_list);


	value_list.clear();
	tips_list.clear();
	description_list.clear();
	display_list.clear();

	value_list.push_back("SingleModel");
	display_list.push_back("Single Model");
	tips_list.push_back("");
	description_list.push_back("");

	value_list.push_back("HdrModel");
	display_list.push_back("Hdr Model");
	tips_list.push_back("");
	description_list.push_back("");

	value_list.push_back("RepeatedModel");
	display_list.push_back("Repeated Model");
	tips_list.push_back("");
	description_list.push_back("");

	add_enum_feature(group, "ExposureModel", "Exposure Model", "Custom", "", "", "RW", "1",
		value_list, display_list, tips_list, description_list);

	add_float_feature(group, "Gain3D", "Gain", "Custom", "", "", "RW", "0", "24","0","db");
	// add_float_feature(group, "Gamma3D", "Gamma", "Custom", "", "", "RW", "1.0", "4", "0");

	add_int_feature(group, "ExposureTime3D", "Exposure", "Custom", "", "", "RW", "12000", "100000" ,"1700", "us");

	add_int_feature(group, "Led", "Led", "Custom", "", "", "RW", "1023", "1023", "0", "level");
 
	add_int_feature(group, "RepeatedNumber", "Repeated Number", "Custom", "", "", "RW", "2", "10", "2");

	root->LinkEndChild(group);
}

void XmlParser::add_engine_control_category(TiXmlElement* root)
{
	TiXmlElement* group = new TiXmlElement("Group");
	group->SetAttribute("Comment", "EngineControl");

	std::vector<std::string> value_list;
	std::vector<std::string> display_list;
	std::vector<std::string> tips_list;
	std::vector<std::string> description_list;

	value_list.push_back("NormalModel");
	display_list.push_back("Normal Model");
	tips_list.push_back("");
	description_list.push_back("");

	value_list.push_back("ReflectModel");
	display_list.push_back("Reflect Model");
	tips_list.push_back("");
	description_list.push_back("");

	value_list.push_back("BlackModel");
	display_list.push_back("Black Model");
	tips_list.push_back("");
	description_list.push_back("");

	add_enum_feature(group, "EngineControl", "Engine Control", "Custom", "", "", "RW", "1",
		value_list, display_list, tips_list, description_list);


	root->LinkEndChild(group);
}


void XmlParser::add_image_format_control_category(TiXmlElement* root)
{
	TiXmlElement* group = new TiXmlElement("Group");
	group->SetAttribute("Comment", "ImageFormatControl");
 
	add_int_feature(group, "SensorWidth", "Sensor Width", "Custom", "", "", "RO", "1920", "100000" ,"0");
	add_int_feature(group, "SensorHeight", "Sensor Height", "Custom", "", "", "RO", "1200", "100000" ,"0");
	add_string_feature(group,"SensorName","Sensor Name","Custom","","","RO","XEMA");

	std::vector<std::string> value_list;
	std::vector<std::string> display_list;
	std::vector<std::string> tips_list;
	std::vector<std::string> description_list;

	value_list.push_back("Brightness");
	display_list.push_back("Brightness");
	tips_list.push_back("");
	description_list.push_back("");

	value_list.push_back("Depth");
	display_list.push_back("Depth");
	tips_list.push_back("");
	description_list.push_back("");


	std::vector<std::string> select_list;
	select_list.push_back("ImagePixelSize"); 
	select_list.push_back("ImageTransmission");
 
	add_enum_feature_with_selected(group, "ImageSelector", "Image Selector", "Standard", "", "", "RW", "0",
		value_list, display_list, tips_list, description_list,select_list);

		 

	value_list.clear();
	display_list.clear();
	tips_list.clear();
	description_list.clear();

	value_list.push_back("Bpp8");
	display_list.push_back("Bpp8");
	tips_list.push_back("8 bits per pixel.");
	description_list.push_back("8 bits per pixel.");

	value_list.push_back("Bpp16");
	display_list.push_back("Bpp16");
	tips_list.push_back("16 bits per pixel.");
	description_list.push_back("16 bits per pixel.");

	value_list.push_back("Bpp24");
	display_list.push_back("Bpp24");
	tips_list.push_back("24 bits per pixel.");
	description_list.push_back("24 bits per pixel.");
 
	value_list.push_back("Bpp32");
	display_list.push_back("Bpp32");
	tips_list.push_back("32 bits per pixel.");
	description_list.push_back("32 bits per pixel.");

	value_list.push_back("Bpp48");
	display_list.push_back("Bpp48");
	tips_list.push_back("48 bits per pixel.");
	description_list.push_back("48 bits per pixel.");

	value_list.push_back("Bpp96");
	display_list.push_back("Bpp96");
	tips_list.push_back("96 bits per pixel.");
	description_list.push_back("96 bits per pixel.");


	add_enum_feature(group, "ImagePixelSize", "Image Pixel Size", "Standard", "", "", "RO", "0",
		value_list, display_list, tips_list, description_list);
	
	  
	std::vector<std::string> select_feature;
	select_feature.clear(); 
	add_bool_feature_width_selected(group, "ImageTransmission", "Image Transmission", "Custom", "", "", "RW", "1", select_feature); 

	value_list.clear();
	display_list.clear();
	tips_list.clear();
	description_list.clear();

	value_list.push_back("Raw02");
	display_list.push_back("Raw02");
	tips_list.push_back("Raw02.");
	description_list.push_back("Raw02."); 
	
	value_list.push_back("Raw04");
	display_list.push_back("Raw04");
	tips_list.push_back("Raw04.");
	description_list.push_back("Raw04."); 

	value_list.push_back("Raw06");
	display_list.push_back("Raw06");
	tips_list.push_back("Raw06.");
	description_list.push_back("Raw06."); 

	select_list.clear();
	select_list.push_back("PatternsNumber"); 
 
	add_enum_feature_with_selected(group, "PatternsSelector", "Patterns Selector", "Standard", "", "", "RW", "2",
		value_list, display_list, tips_list, description_list,select_list);
  
	add_int_feature(group, "PatternsNumber", "Patterns Number", "Custom", "", "", "RO", "16", "999" ,"1");



	value_list.clear();
	display_list.clear();
	tips_list.clear();
	description_list.clear();

	value_list.push_back("Bpp8");
	display_list.push_back("Bpp8");
	tips_list.push_back("8 bits per pixel.");
	description_list.push_back("8 bits per pixel.");

	value_list.push_back("Bpp16");
	display_list.push_back("Bpp16");
	tips_list.push_back("16 bits per pixel.");
	description_list.push_back("16 bits per pixel."); 

	add_enum_feature(group, "PatternsPixelSize", "Patterns Pixel Size", "Standard", "", "", "RO", "0",
		value_list, display_list, tips_list, description_list); 
		
	add_int_feature(group, "PatternsMaxPixelValue", "Patterns Max Pixel Value", "Custom", "", "", "RO", "255", "99999" ,"1");

	value_list.clear();
	tips_list.clear();
	description_list.clear();
	display_list.clear();

	value_list.push_back("SingleModel");
	display_list.push_back("Single Model");
	tips_list.push_back("");
	description_list.push_back("");

	value_list.push_back("HdrModel");
	display_list.push_back("Hdr Model");
	tips_list.push_back("");
	description_list.push_back("");

	value_list.push_back("RepeatedModel");
	display_list.push_back("Repeated Model");
	tips_list.push_back("");
	description_list.push_back("");

	add_enum_feature(group, "PatternsExposureModel", "Patterns Exposure Model", "Custom", "", "", "RW", "0",
		value_list, display_list, tips_list, description_list);

	add_command_feature(group, "ReconstructBaseCache", "Reconstruct Base Cache", "Standard", "", "", "RW", "0", "0");

/*

	feature = new TiXmlElement("pFeature");
	text = new TiXmlText("ImageSelector");
	feature->LinkEndChild(text);
	image_format_control_category->LinkEndChild(feature);

	feature = new TiXmlElement("pFeature");
	text = new TiXmlText("ImagePixelSize");
	feature->LinkEndChild(text);
	image_format_control_category->LinkEndChild(feature);

	feature = new TiXmlElement("pFeature");
	text = new TiXmlText("ImageTransmission");
	feature->LinkEndChild(text);
	image_format_control_category->LinkEndChild(feature);

	*/

	root->LinkEndChild(group);
}

void XmlParser::add_acquisition_control_category(TiXmlElement* root)
{
	TiXmlElement* group = new TiXmlElement("Group");
	group->SetAttribute("Comment", "AcquisitionControl");

	std::vector<std::string> value_list;
	std::vector<std::string> display_list;
	std::vector<std::string> tips_list;
	std::vector<std::string> description_list;

	value_list.push_back("Off");
	display_list.push_back("Off");
	tips_list.push_back("");
	description_list.push_back("");

	value_list.push_back("On");
	display_list.push_back("On");
	tips_list.push_back("");
	description_list.push_back("");

	add_enum_feature(group, "TriggerMode", "Trigger Mode", "Standard", "", "", "RW", "0",
		value_list, display_list, tips_list, description_list);


	value_list.clear();
	display_list.clear();
	tips_list.clear();
	description_list.clear();

	value_list.push_back("Software");
	display_list.push_back("Software");
	tips_list.push_back("");
	description_list.push_back("");

	add_enum_feature(group, "TriggerSource", "Trigger Source", "Standard", "", "", "RW", "0",
		value_list, display_list, tips_list, description_list);
 
	add_command_feature(group, "TriggerSoftware", "Generate Software Trigger", "Standard", "", "", "RW", "0", "0");


	root->LinkEndChild(group);
}

void XmlParser::add_analog_control_category(TiXmlElement* root)
{
	TiXmlElement* group = new TiXmlElement("Group");
	group->SetAttribute("Comment", "AnalogControl");

	add_float_feature(group, "Gain", "Gain", "Standard",
		"Controls the selected gain as an absolute physical value.",
		"Controls the selected gain as an absolute physical value. This is an amplification factor applied to the video signal.",
		"RW", "0", "24", "0");


	add_float_feature(group, "Gamma", "Gamma", "Standard",
		"Controls the gamma correction of pixel intensity.",
		"Controls the gamma correction of pixel intensity. This is typically used to compensate for non-linearity of the display system (such as CRT).",
		"RW", "0", "4", "0");

	root->LinkEndChild(group);

	//TiXmlElement* gain_feature = new TiXmlElement("Float");
	//gain_feature->SetAttribute("Name", "Root");
	//gain_feature->SetAttribute("NameSpace", "Standard");

	////{
	//TiXmlElement* tool = new TiXmlElement("ToolTip");
	//TiXmlText* text = new TiXmlText("Controls the selected gain as an absolute physical value.");
	//tool->LinkEndChild(text);
	//gain_feature->LinkEndChild(tool);

	//TiXmlElement* description= new TiXmlElement("Description");
	//text = new TiXmlText("Controls the selected gain as an absolute physical value. This is an amplification factor applied to the video signal.");
	//description->LinkEndChild(text);
	//gain_feature->LinkEndChild(description);


	//TiXmlElement* display = new TiXmlElement("DisplayName");
	//text = new TiXmlText("Gain");
	//display->LinkEndChild(text);
	//gain_feature->LinkEndChild(display);

	//TiXmlElement* visibility = new TiXmlElement("Visibility");
	//text = new TiXmlText("Beginner");
	//visibility->LinkEndChild(text);
	//gain_feature->LinkEndChild(visibility);

	//TiXmlElement* imposed = new TiXmlElement("ImposedAccessMode");
	//text = new TiXmlText("RW");
	//imposed->LinkEndChild(text);
	//gain_feature->LinkEndChild(imposed);

	//TiXmlElement* value = new TiXmlElement("Value");
	//text = new TiXmlText("0");
	//value->LinkEndChild(text);
	//gain_feature->LinkEndChild(value);



}


int XmlParser::generateXml(TiXmlDocument& xml)
{
	TiXmlDocument doc;
	TiXmlDeclaration* decl = new TiXmlDeclaration("1.0", "UTF-8", "");

	TiXmlElement* root;
	add_xml_head(root);

	add_root_category(root);
	add_sub_category(root);

	/*************************************************************************************************/


	doc.LinkEndChild(decl);
	doc.LinkEndChild(root);

	/*************************************************************************************************/ 

	add_acquisition_control_category(root); 
	add_image_format_control_category(root); 
	add_basic_3d_control_category(root);
	add_hdr_control_category(root);
	add_image_2d_control_category(root);
	add_calib_param_category(root);
	add_filter_control_category(root);
	add_correction_control_category(root);

	/***********************************************************************************************/
 

	xml = doc;

	return 0;
}

int XmlParser::generateXml(std::string path,TiXmlDocument& xml)
{
	TiXmlDocument doc; 
	generateXml(doc);
 
	doc.SaveFile(path.c_str());

	xml = doc;

	return 0;
}

int XmlParser::generateXml(std::string path)
{

	TiXmlDocument doc; 
	generateXml(doc);  
	doc.SaveFile(path.c_str());
  
	return 0;
}
//
//int XmlParser::generate_xml(std::string path)
//{
//	TiXmlDocument doc;
//	TiXmlDeclaration* decl = new TiXmlDeclaration("1.0", "UTF-8", "");
//
//	TiXmlElement* root;
//	add_xml_head(root);
//
//	add_root_category(root);
//	add_sub_category(root);
//
//	/*************************************************************************************************/
//	  
//
//	doc.LinkEndChild(decl);
//	doc.LinkEndChild(root);
//
//	/*************************************************************************************************/
//	//add_analog_control_category(root);
//	//add_acquisition_control_category(root);
//
//	add_basic_3d_control_category(root);
//	add_hdr_control_category(root);
//	add_image_2d_control_category(root);
//	add_calib_param_category(root);
//	add_filter_control_category(root);
//	add_correction_control_category(root);
//
//	/***********************************************************************************************/
//
//
//	doc.SaveFile(path.c_str());
//
//	return 0;
//}


int XmlParser::getFeatureElement(TiXmlDocument xml_data, std::string name, std::string type, std::string& value)
{
	TiXmlElement* root = xml_data.RootElement(); // ��ȡ��Ԫ��  
	if (root == NULL)
	{
		std::cerr << "No root element." << std::endl; // ����޸�Ԫ�أ����������Ϣ  
		return -2;
	}

	for (TiXmlElement* group_elem = root->FirstChildElement(); group_elem != NULL; group_elem = group_elem->NextSiblingElement())
	{
		std::string elemName = group_elem->Value(); 
		 
		for (TiXmlElement* category_elem = group_elem->FirstChildElement(); category_elem != NULL; category_elem = category_elem->NextSiblingElement())
		{
			std::string category_elemName = category_elem->Value();
			std::string category_name = category_elem->Attribute("Name");

			//if (category_name == name)
			//{
			//	for (TiXmlElement* item_elem = category_elem->FirstChildElement(); item_elem != NULL; item_elem = item_elem->NextSiblingElement())
			//	{
			//		std::string elemName = item_elem->Value();

			//		if (type == elemName)
			//		{
			//			std::string text = item_elem->GetText();
			//			value = text;
			//			return 0;
			//		}
			//	}
			//}
			//else
			//{
				for (TiXmlElement* feature_elem = category_elem->FirstChildElement(); feature_elem != NULL; feature_elem = feature_elem->NextSiblingElement())
				{

					std::string feature_name = feature_elem->Value();

					if (feature_name == name)
					{
						for (TiXmlElement* item_elem = feature_elem->FirstChildElement(); item_elem != NULL; item_elem = item_elem->NextSiblingElement())
						{
							std::string elemName = item_elem->Value();

							if (type == elemName)
							{
								std::string text = item_elem->GetText();
								value = text;
								return 0;
							}
						}
					}
				}
			//}

		}
	}


	/****************************************************************************************************************/



	return -1;
}

int XmlParser::setFeatureValue(TiXmlDocument &xml_data, std::string name, std::string type, std::string value)
{
	TiXmlElement *root = xml_data.RootElement(); // ��ȡ��Ԫ��
	if (root == NULL)
	{
		std::cerr << "No root element." << std::endl; // ����޸�Ԫ�أ����������Ϣ
		return -2;
	}

	for (TiXmlElement *group_elem = root->FirstChildElement(); group_elem != NULL; group_elem = group_elem->NextSiblingElement())
	{
		std::string elemName = group_elem->Value();
		// std::string attr = group_elem->Attribute("Comment"); // ��YourAttributeName�������������
		// std::cout << "Value of " << elemName << " is: " << attr << std::endl;

		for (TiXmlElement *category_elem = group_elem->FirstChildElement(); category_elem != NULL; category_elem = category_elem->NextSiblingElement())
		{
			std::string category_elemName = category_elem->Value();
			std::string category_name = category_elem->Attribute("Name");

			if (category_name == name)
			{
				for (TiXmlElement *item_elem = category_elem->FirstChildElement(); item_elem != NULL; item_elem = item_elem->NextSiblingElement())
				{
					std::string elemName = item_elem->Value();

					if (type == elemName)
					{
						item_elem->Clear(); 
						TiXmlText *text = new TiXmlText(value.c_str()); 
						item_elem->LinkEndChild(text);
						return 0;
					}
				}
			}
			else
			{
				for (TiXmlElement *feature_elem = category_elem->FirstChildElement(); feature_elem != NULL; feature_elem = feature_elem->NextSiblingElement())
				{

					std::string feature_name = feature_elem->Value();

					if (feature_name == name)
					{
						for (TiXmlElement *item_elem = feature_elem->FirstChildElement(); item_elem != NULL; item_elem = item_elem->NextSiblingElement())
						{
							std::string elemName = item_elem->Value();

							if (type == elemName)
							{
								item_elem->Clear();
								TiXmlText *text = new TiXmlText(value.c_str()); 
								item_elem->LinkEndChild(text); 
								return 0;
							}
						}
					}
				}
			}
		}
	}

	/****************************************************************************************************************/

	return -1;
}

int XmlParser::getFeature(TiXmlDocument xml_data, std::string name, std::string type, std::string& value)
{
	TiXmlElement* root = xml_data.RootElement(); // ��ȡ��Ԫ��  
	if (root == NULL)
	{
		std::cerr << "No root element." << std::endl; // ����޸�Ԫ�أ����������Ϣ  
		return -2;
	}

	for (TiXmlElement* group_elem = root->FirstChildElement(); group_elem != NULL; group_elem = group_elem->NextSiblingElement())
	{
		std::string elemName = group_elem->Value();
		//std::string attr = group_elem->Attribute("Comment"); // ��YourAttributeName�������������  
		//std::cout << "Value of " << elemName << " is: " << attr << std::endl;


		for (TiXmlElement* category_elem = group_elem->FirstChildElement(); category_elem != NULL; category_elem = category_elem->NextSiblingElement())
		{
			std::string category_elemName = category_elem->Value();
			std::string category_name = category_elem->Attribute("Name");

			if (category_name == name)
			{
				for (TiXmlElement* item_elem = category_elem->FirstChildElement(); item_elem != NULL; item_elem = item_elem->NextSiblingElement())
				{
					std::string elemName = item_elem->Value();

					if (type == elemName)
					{
						std::string text = item_elem->GetText();
						value = text;
						return 0;
					}
				}
			}
			else
			{
				for (TiXmlElement* feature_elem = category_elem->FirstChildElement(); feature_elem != NULL; feature_elem = feature_elem->NextSiblingElement())
				{

					std::string feature_name = feature_elem->Value();

					if (feature_name == name)
					{
						for (TiXmlElement* item_elem = feature_elem->FirstChildElement(); item_elem != NULL; item_elem = item_elem->NextSiblingElement())
						{
							std::string elemName = item_elem->Value();

							if (type == elemName)
							{
								std::string text = item_elem->GetText();
								value = text;
								return 0;
							}
						}
					}
				}
			}

		}
	}


	/****************************************************************************************************************/



	return -1;
}

int XmlParser::get_feature(TiXmlDocument xml_data, std::string name, std::string type, std::string& value)
{
	TiXmlElement* root = xml_data.RootElement(); // ��ȡ��Ԫ��  
	if (root == NULL)
	{
		std::cerr << "No root element." << std::endl; // ����޸�Ԫ�أ����������Ϣ  
		return -2;
	}

	for (TiXmlElement* group_elem = root->FirstChildElement(); group_elem != NULL; group_elem = group_elem->NextSiblingElement())
	{
		std::string elemName = group_elem->Value();  
		//std::string attr = group_elem->Attribute("Comment"); // ��YourAttributeName�������������  
		//std::cout << "Value of " << elemName << " is: " << attr << std::endl;
 

		for (TiXmlElement* category_elem = group_elem->FirstChildElement(); category_elem != NULL; category_elem = category_elem->NextSiblingElement())
		{
			std::string category_elemName = category_elem->Value();
			std::string category_name = category_elem->Attribute("Name");

			if (category_name == name)
			{
				for (TiXmlElement* item_elem = category_elem->FirstChildElement(); item_elem != NULL; item_elem = item_elem->NextSiblingElement())
				{ 
					std::string elemName = item_elem->Value();

					if (type == elemName)
					{
						std::string text = item_elem->GetText();
						value = text;
						return 0;
					}
				} 
			} 
			else
			{
				for (TiXmlElement* feature_elem = category_elem->FirstChildElement(); feature_elem != NULL; feature_elem = feature_elem->NextSiblingElement())
				{

					std::string feature_name = feature_elem->Value();

					if (feature_name == name)
					{
						for (TiXmlElement* item_elem = feature_elem->FirstChildElement(); item_elem != NULL; item_elem = item_elem->NextSiblingElement())
						{
							std::string elemName = item_elem->Value();

							if (type == elemName)
							{
								std::string text = item_elem->GetText();
								value = text;
								return 0;
							}
						} 
					}
				}
			}

		} 
	}

	 
		/****************************************************************************************************************/
 


	return -1;
}

 
int XmlParser::getFeatureEnumEntry(TiXmlDocument xml_data, std::string name, std::string type, std::string child_type, std::vector<std::string>& value_list)
{
	TiXmlElement* root = xml_data.RootElement(); // ��ȡ��Ԫ��  
	if (root == NULL)
	{
		std::cerr << "No root element." << std::endl; // ����޸�Ԫ�أ����������Ϣ  
		return -2;
	}

	for (TiXmlElement* group_elem = root->FirstChildElement(); group_elem != NULL; group_elem = group_elem->NextSiblingElement())
	{
		std::string elemName = group_elem->Value();
		//std::string attr = group_elem->Attribute("Comment"); // ��YourAttributeName�������������  
		//std::cout << "Value of " << elemName << " is: " << attr << std::endl;


		for (TiXmlElement* category_elem = group_elem->FirstChildElement(); category_elem != NULL; category_elem = category_elem->NextSiblingElement())
		{
			std::string category_elemName = category_elem->Value();
			std::string category_name = category_elem->Attribute("Name");

			if (category_name == name)
			{
				for (TiXmlElement* item_elem = category_elem->FirstChildElement(); item_elem != NULL; item_elem = item_elem->NextSiblingElement())
				{
					std::string elemName = item_elem->Value();

					//if (type == elemName)
					//{
	 
						if ("EnumEntry" == elemName)
						{
							for (TiXmlElement* value_elem = item_elem->FirstChildElement(); value_elem != NULL; value_elem = value_elem->NextSiblingElement())
							{

								std::string value_name = value_elem->Value();

								if (child_type == value_name)
								{
									std::string value = value_elem->GetText();
									value_list.push_back(value);
								}
							}


						}
					//}
				}
			}
			else
			{
				for (TiXmlElement* feature_elem = category_elem->FirstChildElement(); feature_elem != NULL; feature_elem = feature_elem->NextSiblingElement())
				{

					std::string feature_name = feature_elem->Value();

					if (feature_name == name)
					{
						for (TiXmlElement* item_elem = feature_elem->FirstChildElement(); item_elem != NULL; item_elem = item_elem->NextSiblingElement())
						{
							std::string elemName = item_elem->Value();

							if (type == elemName)
							{
								for (TiXmlElement* entry_elem = feature_elem->FirstChildElement(); entry_elem != NULL; entry_elem = entry_elem->NextSiblingElement())
								{

									std::string elemName = entry_elem->Value();

									if ("EnumEntry" == elemName)
									{
										for (TiXmlElement* value_elem = entry_elem->FirstChildElement(); value_elem != NULL; value_elem = value_elem->NextSiblingElement())
										{

											std::string value_name = value_elem->Value();

											if (child_type == value_name)
											{
												std::string value = value_elem->GetText();
												value_list.push_back(value); 
											}
										}

									}
								}
								// if (!value_list.empty())
								// {
								// 	return 0;
								// }
							}
						}
					}
				}
			}

		}
	}


	/****************************************************************************************************************/

	if (!value_list.empty())
	{
		return 0;
	}

	return -1;
}


int XmlParser::getFeatureSelected(TiXmlDocument xml_data, std::string feature, std::vector<std::string>& value_list)
{
	TiXmlElement* root = xml_data.RootElement(); // ��ȡ��Ԫ��  
	if (root == NULL)
	{
		std::cerr << "No root element." << std::endl; // ����޸�Ԫ�أ����������Ϣ  
		return -2;
	}

	for (TiXmlElement* group_elem = root->FirstChildElement(); group_elem != NULL; group_elem = group_elem->NextSiblingElement())
	{
		std::string elemName = group_elem->Value(); 
		 

		for (TiXmlElement* category_elem = group_elem->FirstChildElement(); category_elem != NULL; category_elem = category_elem->NextSiblingElement())
		{
			std::string category_elemName = category_elem->Value();
			std::string category_name = category_elem->Attribute("Name");

			if (category_name == feature)
			{
				for (TiXmlElement* item_elem = category_elem->FirstChildElement(); item_elem != NULL; item_elem = item_elem->NextSiblingElement())
				{
					std::string elemName = item_elem->Value();
					 
					if ("pSelected" == elemName)
					{ 

							std::string value = item_elem->GetText();
							value_list.push_back(value);  
					} 
				}
			}
			else
			{
				for (TiXmlElement* feature_elem = category_elem->FirstChildElement(); feature_elem != NULL; feature_elem = feature_elem->NextSiblingElement())
				{

					std::string feature_name = feature_elem->Value();

					if (feature_name == feature)
					{
						for (TiXmlElement* item_elem = feature_elem->FirstChildElement(); item_elem != NULL; item_elem = item_elem->NextSiblingElement())
						{
							std::string elemName = item_elem->Value();

							//if (type == elemName)
							//{
								for (TiXmlElement* entry_elem = feature_elem->FirstChildElement(); entry_elem != NULL; entry_elem = entry_elem->NextSiblingElement())
								{

									std::string elemName = entry_elem->Value();

									if ("pSelected" == elemName)
									{
											std::string value = entry_elem->GetText();
											value_list.push_back(value);
									}
								}
						}
					}
				}
			}

		}
	}

	/****************************************************************************************************************/

	if (!value_list.empty())
	{
		return 0;
	}

	return -1;
}


int XmlParser::getFeatureEnumEntry(TiXmlDocument xml_data, std::string feature, std::vector<std::string>& value_list)
{
	TiXmlElement* root = xml_data.RootElement(); // ��ȡ��Ԫ��  
	if (root == NULL)
	{
		std::cerr << "No root element." << std::endl; // ����޸�Ԫ�أ����������Ϣ  
		return -2;
	}


	for (TiXmlElement* elem = root->FirstChildElement(); elem != NULL; elem = elem->NextSiblingElement())
	{
		std::string elemName = elem->Value();
		//const char* attr;

		std::string attr = elem->Attribute("Comment"); // ��YourAttributeName�������������  
		//std::cout << "Value of " << elemName << " is: " << attr << std::endl;


			std::string feature_name = feature;
			std::vector<std::string> feature_selected;

			for (TiXmlElement* feature_elem = elem->FirstChildElement(); feature_elem != NULL; feature_elem = feature_elem->NextSiblingElement())
			{
				std::string group_elemName = feature_elem->Value();
				std::string name = feature_elem->Attribute("Name");

				if (feature_name == name)
				{

					if ("Enumeration" == group_elemName)
					{
						for (TiXmlElement* entry_elem = feature_elem->FirstChildElement(); entry_elem != NULL; entry_elem = entry_elem->NextSiblingElement())
						{

							std::string elemName = entry_elem->Value();

							if ("EnumEntry" == elemName)
							{
								for (TiXmlElement* value_elem = entry_elem->FirstChildElement(); value_elem != NULL; value_elem = value_elem->NextSiblingElement())
								{

									std::string value_name = value_elem->Value();

									if ("DisplayName" == value_name)
									{
										std::string value = value_elem->GetText();
										value_list.push_back(value);
										std::cout << "EnumEntry: " << value;
									}
								}

							}
						}
					}
				}

			}


		/****************************************************************************************************************/

	}


	return 0;
}

int XmlParser::getFeatureEnumEntry(TiXmlDocument xml_data, std::string category, std::string feature, std::vector<std::string>& value_list)
{

	TiXmlElement* root = xml_data.RootElement(); // ��ȡ��Ԫ��  
	if (root == NULL)
	{
		std::cerr << "No root element." << std::endl; // ����޸�Ԫ�أ����������Ϣ  
		return -2;
	}


	for (TiXmlElement* elem = root->FirstChildElement(); elem != NULL; elem = elem->NextSiblingElement())
	{
		std::string elemName = elem->Value();
		//const char* attr;

		std::string attr = elem->Attribute("Comment"); // ��YourAttributeName�������������  
		//std::cout << "Value of " << elemName << " is: " << attr << std::endl;

		if ("Group" == elemName && attr == category)
		{  
	 
				std::string feature_name = feature;
				std::vector<std::string> feature_selected;

				for (TiXmlElement* feature_elem = elem->FirstChildElement(); feature_elem != NULL; feature_elem = feature_elem->NextSiblingElement())
				{
					std::string group_elemName = feature_elem->Value();
					std::string name = feature_elem->Attribute("Name");

					if (feature_name == name)
					{

						if ("Enumeration" == group_elemName)
						{
							for (TiXmlElement* entry_elem = feature_elem->FirstChildElement(); entry_elem != NULL; entry_elem = entry_elem->NextSiblingElement())
							{

								std::string elemName = entry_elem->Value();

								if ("EnumEntry" == elemName)
								{
									for (TiXmlElement* value_elem = entry_elem->FirstChildElement(); value_elem != NULL; value_elem = value_elem->NextSiblingElement())
									{

										std::string value_name = value_elem->Value();

										if ("DisplayName" == value_name)
										{
											std::string value = value_elem->GetText();
											value_list.push_back(value);
											std::cout << "EnumEntry: " << value;
										}
									}
				 
								}
							}
						}
			 
						

					}






				}

	 


		}


		/****************************************************************************************************************/

	}


	return 0;
}

int XmlParser::getFeatureType(TiXmlDocument xml_data, std::vector<std::string> category,
	std::vector<std::vector<std::string>> features, std::vector<std::vector<std::string>>& features_type,
	std::vector < std::vector<std::vector<std::string>>>& selected_features)
{
	TiXmlElement* root = xml_data.RootElement(); // ��ȡ��Ԫ��  
	if (root == NULL)
	{
		std::cerr << "Failed to load file: No root element." << std::endl; // ����޸�Ԫ�أ����������Ϣ  
		return -2;
	}

	for (int iter_category = 0; iter_category < category.size(); iter_category++)
	{
		std::string category_name = category[iter_category];

		std::vector<std::string> feature_type_list;
		std::vector<std::vector<std::string>> feature_selected_list;

		// ����XML�ļ�  
		for (TiXmlElement* elem = root->FirstChildElement(); elem != NULL; elem = elem->NextSiblingElement())
		{
			std::string elemName = elem->Value();
			//const char* attr;

			std::string attr = elem->Attribute("Comment"); // ��YourAttributeName�������������  
			//std::cout << "Value of " << elemName << " is: " << attr << std::endl;

			if (category_name == attr)
			{
				std::vector<std::string> feature_list = features[iter_category];

				for (int iter_feature = 0; iter_feature < feature_list.size(); iter_feature++)
				{
					std::string feature_name = feature_list[iter_feature];

					std::vector<std::string> feature_selected;

					for (TiXmlElement* feature_elem = elem->FirstChildElement(); feature_elem != NULL; feature_elem = feature_elem->NextSiblingElement())
					{
						std::string group_elemName = feature_elem->Value();
						std::string value = feature_elem->Attribute("Name");

						if (feature_name == value)
						{
							feature_type_list.push_back(group_elemName);
							std::cout << "Value of " << feature_name << " is: " << group_elemName << std::endl;

							for (TiXmlElement* selected_elem = feature_elem->FirstChildElement(); selected_elem != NULL; selected_elem = selected_elem->NextSiblingElement())
							{

								std::string elemName = selected_elem->Value();

								if ("pSelected" == elemName)
								{

									std::string value = selected_elem->GetText();
									std::cout << "pSelected of " << feature_name << " is: " << value << std::endl;

									feature_selected.push_back(value);
								}
							}

						}
						 

					}

					feature_selected_list.push_back(feature_selected);

				}


			}


			/****************************************************************************************************************/

		}


		features_type.push_back(feature_type_list);
		selected_features.push_back(feature_selected_list);
	}

	for (int c_i = 0; c_i < category.size(); c_i++)
	{
		if (features[c_i].size() != features_type[c_i].size())
		{
			LOG(ERROR)<<"size of feature != size of features type " << category[c_i];
			return -1;
		}
	}


	return 0;
}
//
//int XmlParser::getFeatureType(TiXmlDocument xml_data, std::vector<std::string> category,
//	std::vector<std::vector<std::string>> features, std::vector<std::vector<std::string>>& features_type,
//	std::vector<std::vector<std::vector<std::string>>>& selected_features)
//{
//
//	TiXmlElement* root = xml_data.RootElement(); // ��ȡ��Ԫ��  
//	if (root == NULL)
//	{
//		std::cerr << "Failed to load file: No root element." << std::endl; // ����޸�Ԫ�أ����������Ϣ  
//		return -2;
//	}
//
//	for (int iter_category = 0; iter_category < category.size(); iter_category++)
//	{
//		std::string category_name = category[iter_category];
//
//		std::vector<std::string> feature_type_list;
//		std::vector<std::vector<std::string>> feature_selected_list;
//
//		// ����XML�ļ�  
//		for (TiXmlElement* elem = root->FirstChildElement(); elem != NULL; elem = elem->NextSiblingElement())
//		{
//			std::string elemName = elem->Value();
//			//const char* attr;
//
//			std::string attr = elem->Attribute("Comment"); // ��YourAttributeName�������������  
//			//std::cout << "Value of " << elemName << " is: " << attr << std::endl;
//
//			if (category_name == attr)
//			{
//				std::vector<std::string> feature_list = features[iter_category];
//
//				for (int iter_feature = 0; iter_feature < feature_list.size(); iter_feature++)
//				{
//					std::string feature_name = feature_list[iter_feature];
//
//					std::vector<std::string> feature_selected;
//
//					for (TiXmlElement* feature_elem = elem->FirstChildElement(); feature_elem != NULL; feature_elem = feature_elem->NextSiblingElement())
//					{
//						std::string group_elemName = feature_elem->Value();
//						std::string value = feature_elem->Attribute("Name");
//
//						if (feature_name == value)
//						{
//							feature_type_list.push_back(group_elemName);
//							std::cout << "Value of " << feature_name << " is: " << group_elemName << std::endl;
//
//							for (TiXmlElement* selected_elem = feature_elem->FirstChildElement(); selected_elem != NULL; selected_elem = selected_elem->NextSiblingElement())
//							{
//
//								std::string elemName = selected_elem->Value();
//
//								if ("pSelected" == elemName)
//								{
//
//									std::string value = selected_elem->GetText();
//									std::cout << "pSelected of " << feature_name << " is: " << value << std::endl;
//
//									feature_selected.push_back(value);
//								}
//							}
//
//						}
//						
//
//
//
//
//
//					}
//
//					feature_selected_list.push_back(feature_selected);
//					
//				}
//
//
//			}
//
//			 
//			/****************************************************************************************************************/
//
//		}
//
//
//		features_type.push_back(feature_type_list);
//		selected_features.push_back(feature_selected_list);
//	}
//
//	 
//	return 0;
//
//}


int XmlParser::readXmlFile(std::string path, TiXmlDocument& xml)
{
	TiXmlDocument doc(path.c_str()); // �������xml�ļ���Ϊtest.xml  
	if (!doc.LoadFile())
	{ 
		LOG(INFO) << doc.ErrorDesc();
		return -1;
	}

	xml = doc;
	xml_data_ = xml; 
	return 0;
}



int XmlParser::getFeatures(TiXmlDocument xml, std::vector<std::string>& category, std::vector<std::vector<std::string>>& features)
{
	std::vector<std::string> standard_category;
	std::vector<std::string> custom_category;
	 
	std::vector<std::vector<std::string>> standard_features;
	std::vector<std::vector<std::string>> custom_features;

	TiXmlElement* root = xml.RootElement(); // ��ȡ��Ԫ��  
	if (root == NULL)
	{
		LOG(ERROR) << "Failed to load file: No root element." << std::endl; // ����޸�Ԫ�أ����������Ϣ  
		return -2;
	}

	std::vector<std::string> feature_catory_list;

	// ����XML�ļ�  
	for (TiXmlElement* elem = root->FirstChildElement(); elem != NULL; elem = elem->NextSiblingElement())
	{
		std::string elemName = elem->Value();
		//const char* attr;

		std::string attr = elem->Attribute("Comment"); // ��YourAttributeName�������������  
		std::cout << "Value of " << elemName << " is: " << attr << std::endl;

		if ("RootCategory" == attr)
		{
			for (TiXmlElement* category_elem = elem->FirstChildElement(); category_elem != NULL; category_elem = category_elem->NextSiblingElement())
			{
				std::string group_elemName = category_elem->Value();

				if ("Category" == group_elemName)
				{

					std::string name = category_elem->Attribute("Name");
					std::string space = category_elem->Attribute("NameSpace");

					if ("Root" == name && "Standard" == space)
					{
						for (TiXmlElement* feature_elem = category_elem->FirstChildElement(); feature_elem != NULL; feature_elem = feature_elem->NextSiblingElement())
						{

							std::string group_elemName = feature_elem->Value();

							if ("pFeature" == group_elemName)
							{

								std::string value = feature_elem->GetText();
								//std::cout << "Value: " << value << std::endl;
								standard_category.push_back(value);
								  
							}

						}

					}

					if ("Root" == name && "Custom" == space)
					{
						for (TiXmlElement* feature_elem = category_elem->FirstChildElement(); feature_elem != NULL; feature_elem = feature_elem->NextSiblingElement())
						{

							std::string group_elemName = feature_elem->Value();

							if ("pFeature" == group_elemName)
							{

								std::string value = feature_elem->GetText();
								//std::cout << "Value: " << value << std::endl;
								custom_category.push_back(value);

							}

						}

					}
				}

			}
		}

		custom_features.resize(custom_category.size());
		standard_features.resize(standard_category.size());


		/***************************************************************************************************************/


		if ("SubCategories" == attr)
		{
			for (TiXmlElement* category_elem = elem->FirstChildElement(); category_elem != NULL; category_elem = category_elem->NextSiblingElement())
			{
				std::string group_elemName = category_elem->Value();

				if ("Category" == group_elemName)
				{

					std::string name = category_elem->Attribute("Name");
					std::string space = category_elem->Attribute("NameSpace");



					if ("Standard" == space)
					{
						int position = -1;
						std::vector<std::string> features;


						auto it = std::find(standard_category.begin(), standard_category.end(), name);
						if (it != standard_category.end())
						{
							std::cout << "Found " << name << " at position " << it - standard_category.begin() << std::endl;
							position = it - standard_category.begin();
						}
						else
						{
							std::cout << "Did not find " << name << std::endl;
						}


						for (TiXmlElement* feature_elem = category_elem->FirstChildElement(); feature_elem != NULL; feature_elem = feature_elem->NextSiblingElement())
						{

							std::string group_elemName = feature_elem->Value();

							if ("pFeature" == group_elemName)
							{

								std::string value = feature_elem->GetText();
								//std::cout << "Value: " << value << std::endl;
								features.push_back(value);

							}

						}


						if (-1 != position)
						{
							standard_features[position] = features;
						}
					}

					if ("Custom" == space)
					{

						int position = -1;
						std::vector<std::string> features;

						auto it = std::find(custom_category.begin(), custom_category.end(), name);
						if (it != custom_category.end())
						{
							std::cout << "Found " << name << " at position " << it - custom_category.begin() << std::endl;
							position = it - custom_category.begin();
						}
						else
						{
							std::cout << "Did not find " << name << std::endl;
						}

						for (TiXmlElement* feature_elem = category_elem->FirstChildElement(); feature_elem != NULL; feature_elem = feature_elem->NextSiblingElement())
						{

							std::string group_elemName = feature_elem->Value();

							if ("pFeature" == group_elemName)
							{

								std::string value = feature_elem->GetText();
								//std::cout << "Value: " << value << std::endl;
								features.push_back(value);

							}

						}

						if (-1 != position)
						{
							custom_features[position] = features;
						}

					}
				}

			}
		}





		/****************************************************************************************************************/

	}

	for (int i = 0; i < standard_category.size(); i++)
	{
		if (standard_features[i].size() > 0)
		{
			category.push_back(standard_category[i]);
			features.push_back(standard_features[i]);
		}
	}

	for (int i = 0; i < custom_category.size(); i++)
	{
		if (custom_features[i].size() > 0)
		{
			category.push_back(custom_category[i]);
			features.push_back(custom_features[i]);
		}
	}

 


	return 0;
}

int XmlParser::readFeature(std::string path, TiXmlDocument& xml_data, std::vector<std::string>& standard_category,
	std::vector<std::vector<std::string>>& standard_features,
	std::vector<std::string>& custom_category,
	std::vector<std::vector<std::string>>& custom_features)
{

	std::vector<std::string> standard_category_list;
	std::vector<std::string> custom_category_list;

	std::vector<std::vector<std::string>> feature_list;
	std::vector<std::vector<std::string>> standard_feature_list;
	std::vector<std::vector<std::string>> custom_feature_list;

	TiXmlDocument doc(path.c_str()); // �������xml�ļ���Ϊtest.xml  
	if (!doc.LoadFile())
	{
		std::cerr << doc.ErrorDesc() << std::endl; // ������ܼ����ļ��������������  
		return -1;
	}

	xml_data = doc;
	xml_data_ = xml_data;

	TiXmlElement* root = doc.RootElement(); // ��ȡ��Ԫ��  
	if (root == NULL)
	{
		std::cerr << "Failed to load file: No root element." << std::endl; // ����޸�Ԫ�أ����������Ϣ  
		doc.Clear();
		return -2;
	}

	std::vector<std::string> feature_catory_list;

	// ����XML�ļ�  
	for (TiXmlElement* elem = root->FirstChildElement(); elem != NULL; elem = elem->NextSiblingElement())
	{
		std::string elemName = elem->Value();
		//const char* attr;

		std::string attr = elem->Attribute("Comment"); // ��YourAttributeName�������������  
		std::cout << "Value of " << elemName << " is: " << attr << std::endl;

		if ("RootCategory" == attr)
		{
			for (TiXmlElement* category_elem = elem->FirstChildElement(); category_elem != NULL; category_elem = category_elem->NextSiblingElement())
			{
				std::string group_elemName = category_elem->Value();

				if ("Category" == group_elemName)
				{

					std::string name = category_elem->Attribute("Name");
					std::string space = category_elem->Attribute("NameSpace");

					if ("Root" == name && "Standard" == space)
					{
						for (TiXmlElement* feature_elem = category_elem->FirstChildElement(); feature_elem != NULL; feature_elem = feature_elem->NextSiblingElement())
						{

							std::string group_elemName = feature_elem->Value();

							if ("pFeature" == group_elemName)
							{

								std::string value = feature_elem->GetText();
								//std::cout << "Value: " << value << std::endl;
								standard_category.push_back(value);

							}

						}

					}

					if ("Root" == name && "Custom" == space)
					{
						for (TiXmlElement* feature_elem = category_elem->FirstChildElement(); feature_elem != NULL; feature_elem = feature_elem->NextSiblingElement())
						{

							std::string group_elemName = feature_elem->Value();

							if ("pFeature" == group_elemName)
							{

								std::string value = feature_elem->GetText();
								//std::cout << "Value: " << value << std::endl;
								custom_category.push_back(value);

							}

						}

					}
				}

			}
		}

		custom_features.resize(custom_category.size());
		standard_features.resize(standard_category.size());


		/***************************************************************************************************************/


		if ("SubCategories" == attr)
		{
			for (TiXmlElement* category_elem = elem->FirstChildElement(); category_elem != NULL; category_elem = category_elem->NextSiblingElement())
			{
				std::string group_elemName = category_elem->Value();

				if ("Category" == group_elemName)
				{

					std::string name = category_elem->Attribute("Name");
					std::string space = category_elem->Attribute("NameSpace");



					if ("Standard" == space)
					{
						int position = -1;
						std::vector<std::string> features;


						auto it = std::find(standard_category.begin(), standard_category.end(), name);
						if (it != standard_category.end())
						{
							std::cout << "Found " << name << " at position " << it - standard_category.begin() << std::endl;
							position = it - standard_category.begin();
						}
						else
						{
							std::cout << "Did not find " << name << std::endl;
						}


						for (TiXmlElement* feature_elem = category_elem->FirstChildElement(); feature_elem != NULL; feature_elem = feature_elem->NextSiblingElement())
						{

							std::string group_elemName = feature_elem->Value();

							if ("pFeature" == group_elemName)
							{

								std::string value = feature_elem->GetText();
								//std::cout << "Value: " << value << std::endl;
								features.push_back(value);

							}

						}


						if (-1 != position)
						{
							standard_features[position] = features;
						}
					}

					if ("Custom" == space)
					{

						int position = -1;
						std::vector<std::string> features;

						auto it = std::find(custom_category.begin(), custom_category.end(), name);
						if (it != custom_category.end())
						{
							std::cout << "Found " << name << " at position " << it - custom_category.begin() << std::endl;
							position = it - custom_category.begin();
						}
						else
						{
							std::cout << "Did not find " << name << std::endl;
						}

						for (TiXmlElement* feature_elem = category_elem->FirstChildElement(); feature_elem != NULL; feature_elem = feature_elem->NextSiblingElement())
						{

							std::string group_elemName = feature_elem->Value();

							if ("pFeature" == group_elemName)
							{

								std::string value = feature_elem->GetText();
								//std::cout << "Value: " << value << std::endl;
								features.push_back(value);

							}

						}

						if (-1 != position)
						{
							custom_features[position] = features;
						}

					}
				}

			}
		}





		/****************************************************************************************************************/

	}




	return 0;
} 

//
//
//int generate_xml(std::string path)
//{
//	TiXmlDocument doc; 
//	TiXmlDeclaration* decl = new TiXmlDeclaration("1.0", "UTF-8", "");
//
//	TiXmlElement* root; 
//	add_xml_head(root);
//
//	add_root_category(root); 
//	add_sub_category(root);
//
//	/*************************************************************************************************/
//
//	 
//
//
//
//	doc.LinkEndChild(decl);
//	doc.LinkEndChild(root);
//
//	/*************************************************************************************************/
//	add_analog_control_category(root);
//	add_acquisition_control_category(root);
//
//	add_basic_3d_control_category(root);
//	add_hdr_control_category(root);
//	add_image_2d_control_category(root);
//	add_calib_param_category(root);
//	add_filter_control_category(root);
//	add_correction_control_category(root);
//	
///***********************************************************************************************/
//
//
//	doc.SaveFile(path.c_str());
//
//	return 0;
//}
//
//



int XmlParser::get_feature(std::string path, std::vector<std::string>& standard_category, std::vector<std::vector<std::string>>& standard_features,
	std::vector<std::string>& custom_category, std::vector<std::vector<std::string>>& custom_features)
{


	std::vector<std::string> standard_category_list;
	std::vector<std::string> custom_category_list;

	std::vector<std::vector<std::string>> feature_list;
	std::vector<std::vector<std::string>> standard_feature_list;
	std::vector<std::vector<std::string>> custom_feature_list;

	TiXmlDocument doc(path.c_str()); // �������xml�ļ���Ϊtest.xml  
	if (!doc.LoadFile())
	{
		std::cerr << doc.ErrorDesc() << std::endl; // ������ܼ����ļ��������������  
		return -1;
	}

	TiXmlElement* root = doc.RootElement(); // ��ȡ��Ԫ��  
	if (root == NULL)
	{
		std::cerr << "Failed to load file: No root element." << std::endl; // ����޸�Ԫ�أ����������Ϣ  
		doc.Clear();
		return -2;
	}

	std::vector<std::string> feature_catory_list;

	// ����XML�ļ�  
	for (TiXmlElement* elem = root->FirstChildElement(); elem != NULL; elem = elem->NextSiblingElement())
	{
		std::string elemName = elem->Value();
		//const char* attr;
 
		std::string attr = elem->Attribute("Comment"); // ��YourAttributeName�������������  
		std::cout << "Value of " << elemName << " is: " << attr << std::endl;

		if ("RootCategory" == attr)
		{
			for (TiXmlElement* category_elem = elem->FirstChildElement(); category_elem != NULL; category_elem = category_elem->NextSiblingElement())
			{ 
				std::string group_elemName = category_elem->Value();

				if ("Category" == group_elemName)
				{ 
					
					std::string name = category_elem->Attribute("Name");
					std::string space = category_elem->Attribute("NameSpace");

					if ("Root" == name && "Standard" == space)
					{ 
						for (TiXmlElement* feature_elem = category_elem->FirstChildElement(); feature_elem != NULL; feature_elem = feature_elem->NextSiblingElement())
						{
	 
							std::string group_elemName = feature_elem->Value();

							if ("pFeature" == group_elemName)
							{

								std::string value = feature_elem->GetText();
								//std::cout << "Value: " << value << std::endl;
								standard_category.push_back(value);

							}

						}

					}

					if ("Root" == name && "Custom" == space)
					{
						for (TiXmlElement* feature_elem = category_elem->FirstChildElement(); feature_elem != NULL; feature_elem = feature_elem->NextSiblingElement())
						{

							std::string group_elemName = feature_elem->Value();

							if ("pFeature" == group_elemName)
							{

								std::string value = feature_elem->GetText();
								//std::cout << "Value: " << value << std::endl;
								custom_category.push_back(value);

							}

						}

					}
				}

			}
		}

		custom_features.resize(custom_category.size());
		standard_features.resize(standard_category.size());


		/***************************************************************************************************************/


		if ("SubCategories" == attr)
		{
			for (TiXmlElement* category_elem = elem->FirstChildElement(); category_elem != NULL; category_elem = category_elem->NextSiblingElement())
			{
				std::string group_elemName = category_elem->Value();

				if ("Category" == group_elemName)
				{

					std::string name = category_elem->Attribute("Name");
					std::string space = category_elem->Attribute("NameSpace");

				

					if ("Standard" == space)
					{
						int position = -1;
						std::vector<std::string> features;


						auto it = std::find(standard_category.begin(), standard_category.end(), name);
						if (it != standard_category.end())
						{
							std::cout << "Found "<< name <<" at position " << it - standard_category.begin() << std::endl;
							position = it - standard_category.begin();
						}
						else
						{
							std::cout << "Did not find " << name << std::endl;
						}
						 

						for (TiXmlElement* feature_elem = category_elem->FirstChildElement(); feature_elem != NULL; feature_elem = feature_elem->NextSiblingElement())
						{

							std::string group_elemName = feature_elem->Value();

							if ("pFeature" == group_elemName)
							{

								std::string value = feature_elem->GetText();
								//std::cout << "Value: " << value << std::endl;
								features.push_back(value);

							}

						}


						if(-1 != position)
						{
							standard_features[position] = features;
						}
					}

					if ("Custom" == space)
					{

						int position = -1;
						std::vector<std::string> features;

						auto it = std::find(custom_category.begin(), custom_category.end(), name);
						if (it != custom_category.end())
						{
							std::cout << "Found " << name << " at position " << it - custom_category.begin() << std::endl;
							position = it - custom_category.begin();
						}
						else
						{
							std::cout << "Did not find " << name << std::endl;
						}

						for (TiXmlElement* feature_elem = category_elem->FirstChildElement(); feature_elem != NULL; feature_elem = feature_elem->NextSiblingElement())
						{

							std::string group_elemName = feature_elem->Value();

							if ("pFeature" == group_elemName)
							{

								std::string value = feature_elem->GetText();
								//std::cout << "Value: " << value << std::endl;
								features.push_back(value);

							}

						}

						if (-1 != position)
						{
							custom_features[position] = features;
						}

					}
				}

			}
		}





		/****************************************************************************************************************/

		//for (TiXmlElement* g_elem = elem->FirstChildElement(); g_elem != NULL; g_elem = g_elem->NextSiblingElement())
		//{
		//	if (g_elem == NULL)
		//	{
		//		break;
		//	}
		//	std::string group_elemName = g_elem->Value();
		//	 
		//	std::string group_elemText = g_elem->Attribute("Name");
		//	std::string group_namespace = g_elem->Attribute("NameSpace");

		//	if ("Category" == group_elemName)
		//	{
		//		std::cout << "Value of " << group_elemName << " is: " << group_elemText << " namespace: " << group_namespace << std::endl;

		//		std::vector<std::string> features;

		//		for (TiXmlElement* feature_elem = g_elem->FirstChildElement(); feature_elem != NULL; feature_elem = feature_elem->NextSiblingElement())
		//		{
		//			if (feature_elem == NULL)
		//			{
		//				break;
		//			}
		//			std::string group_elemName = feature_elem->Value();

		//			if ("pFeature" == group_elemName)
		//			{

		//				std::string value = feature_elem->GetText();
		//				//std::cout << "Value: " << value << std::endl;
		//				features.push_back(value);

		//			}

		//		}

		//		feature_list.push_back(features);

		//		if ("Standard" == group_namespace)
		//		{
		//			standard_category_list.push_back(group_elemText);
		//			standard_feature_list.push_back(features);
		//		}
		//		else if ("Custom" == group_namespace)
		//		{
		//			custom_category_list.push_back(group_elemText);
		//			custom_feature_list.push_back(features);
		//		}
		//	}

  

			//if ("Root" == group_elemText)
			//{

			//	for (TiXmlElement* feature_elem = g_elem->FirstChildElement(); feature_elem != NULL; feature_elem = feature_elem->NextSiblingElement())
			//	{
			//		if (feature_elem == NULL)
			//		{
			//			break;
			//		}
			//		std::string feature_elemName = feature_elem->Value();

			//		if ("pFeature" == feature_elemName)
			//		{
			//			std::string text = feature_elem->GetText();
			//			//std::cout << "Value of " << feature_elemName << " is: " << text << std::endl; 
			//			feature_catory_list.push_back(text);

			//		}


			//	}

			//}

		}


  

	return 0;
}