Esempio n. 1
0
    private bool _NextToken(XmlReader reader)
    {
        while (!reader.EOF && reader.Read() && !reader.IsStartElement())
            ;

        return !reader.EOF;
    }
Esempio n. 2
0
        internal static void ThrowFaultException(XmlReader reader, WsWsaHeader header)
        {
            WsFaultType type    = WsFaultType.Exception;
            string      message = "";
            string      detail  = "";
            string      subcode;

            reader.ReadStartElement("Body", WsWellKnownUri.SoapNamespaceUri);
            reader.ReadStartElement("Fault", WsWellKnownUri.SoapNamespaceUri);

            while (true)
            {
                if (reader.IsStartElement("Code", WsWellKnownUri.SoapNamespaceUri))
                {
                    reader.ReadStartElement(); //<Code>

                    if (reader.IsStartElement("Value", WsWellKnownUri.SoapNamespaceUri))
                    {
                        reader.ReadElementString();
                    }
                    if (reader.IsStartElement("Subcode", WsWellKnownUri.SoapNamespaceUri))
                    {
                        reader.ReadStartElement();
                        subcode = reader.ReadElementString("Value", WsWellKnownUri.SoapNamespaceUri);

                        int idx = subcode.IndexOf(':');

                        if (idx != -1)
                        {
                            subcode = subcode.Substring(idx + 1);
                        }

                        switch (subcode)
                        {
                        case "ArgumentException":
                            type = WsFaultType.ArgumentException;
                            break;

                        case "ArgumentNullException":
                            type = WsFaultType.ArgumentNullException;
                            break;

                        case "Exception":
                            type = WsFaultType.Exception;
                            break;

                        case "InvalidOperationException":
                            type = WsFaultType.InvalidOperationException;
                            break;

                        case "XmlException":
                            type = WsFaultType.XmlException;
                            break;

                        case "InvalidMessageInformationHeader":
                            type = WsFaultType.WsaInvalidMessageInformationHeader;
                            break;

                        case "MessageInformationHeaderRequired":
                            type = WsFaultType.WsaMessageInformationHeaderRequired;
                            break;

                        case "DestinationUnreachable":
                            type = WsFaultType.WsaDestinationUnreachable;
                            break;

                        case "ActionNotSupported":
                            type = WsFaultType.WsaActionNotSupported;
                            break;

                        case "EndpointUnavailable":
                            type = WsFaultType.WsaEndpointUnavailable;
                            break;

                        case "DeliverModeRequestedUnavailable":
                            type = WsFaultType.WseDeliverModeRequestedUnavailable;
                            break;

                        case "InvalidExpirationTime":
                            type = WsFaultType.WseInvalidExpirationTime;
                            break;

                        case "UnsupportedExpirationType":
                            type = WsFaultType.WseUnsupportedExpirationType;
                            break;

                        case "FilteringNotSupported":
                            type = WsFaultType.WseFilteringNotSupported;
                            break;

                        case "FilteringRequestedUnavailable":
                            type = WsFaultType.WseFilteringRequestedUnavailable;
                            break;

                        case "EventSourceUnableToProcess":
                            type = WsFaultType.WseEventSourceUnableToProcess;
                            break;

                        case "UnableToRenew":
                            type = WsFaultType.WseUnableToRenew;
                            break;

                        case "InvalidMessage":
                            type = WsFaultType.WseInvalidMessage;
                            break;
                        }

                        reader.ReadEndElement();
                    }

                    reader.ReadEndElement(); // </Code>
                }

                if (reader.IsStartElement("Reason", WsWellKnownUri.SoapNamespaceUri))
                {
                    reader.ReadStartElement();

                    message = reader.ReadElementString("Text", WsWellKnownUri.SoapNamespaceUri);

                    reader.ReadEndElement();
                }

                if (reader.IsStartElement("Detail", WsWellKnownUri.SoapNamespaceUri))
                {
                    detail = reader.ReadElementString("Detail", WsWellKnownUri.SoapNamespaceUri);
                }

                if (!reader.IsStartElement())
                {
                    break;
                }
            }

            reader.ReadEndElement(); // </Fault>
            reader.ReadEndElement(); // </Body>

            throw new WsFaultException(header, type, message, detail);
        }
 public override bool CanDeserialize(XmlReader xmlReader)
 {
     return(xmlReader.IsStartElement("ClassMetadata", ""));
 }
Esempio n. 4
0
        public static string[,] XmlToArray(string XML)
        {
            List <string> ParameterNames  = new List <string>();
            List <string> ParameterValues = new List <string>();

            StringBuilder OutXml          = new StringBuilder();
            List <string> Paths           = new List <string>();
            StringReader  XMLStringReader = new StringReader(XML.Trim());
            XmlReader     Reader          = XmlReader.Create(XMLStringReader);
            int           ParameterCount  = 0;
            bool          Read            = true;
            bool          NextRead        = false;

            while (Read)
            {
                if (!NextRead)
                {
                    Read = Reader.Read();
                }
                NextRead = false;
                if (!Read)
                {
                    continue;
                }
                if (Reader.IsStartElement())
                {
                    Paths.Add(Reader.Name);
                    Read = Reader.Read();
                    if (Reader.NodeType == XmlNodeType.EndElement)
                    {
                        ParameterCount++;
                        string Value = "";
                        ParameterNames.Add(JoinPaths(Paths));
                        ParameterValues.Add(Value);
                        int C = Paths.Count;
                        if (C > 0)
                        {
                            Paths.RemoveAt(C - 1);
                        }
                    }
                    else
                    {
                        NextRead = true;
                    }
                }
                else
                {
                    if (Reader.NodeType == XmlNodeType.EndElement)
                    {
                        int C = Paths.Count;
                        if (C > 0)
                        {
                            Paths.RemoveAt(C - 1);
                        }
                    }
                    else
                    {
                        ParameterCount++;
                        string Value = Reader.Value.Trim();
                        ParameterNames.Add(JoinPaths(Paths));
                        ParameterValues.Add(Value);
                    }
                }
            }
            Reader.Close();
            string[,] InjectionPoints = new string[ParameterNames.Count, 2];
            for (int i = 0; i < ParameterNames.Count; i++)
            {
                InjectionPoints[i, 0] = ParameterNames[i];
                InjectionPoints[i, 1] = ParameterValues[i];
            }
            return(InjectionPoints);
        }
    /// <summary>
    /// Loads the trained Eigen Recogniser from specified location
    /// </summary>
    /// <param name="filename"></param>
    public void Load_Eigen_Recogniser(string filename)
    {
        //Lets get the recogniser type from the file extension
        string ext = Path.GetExtension(filename);

        switch (ext)
        {
        case (".LBPH"):
            Recognizer_Type = "EMGU.CV.LBPHFaceRecognizer";
            recognizer      = new LBPHFaceRecognizer(1, 14, 10, 10, 3000);//50
            break;

        case (".FFR"):
            Recognizer_Type = "EMGU.CV.FisherFaceRecognizer";
            recognizer      = new FisherFaceRecognizer(0, 3500);//4000
            break;

        case (".EFR"):
            Recognizer_Type = "EMGU.CV.EigenFaceRecognizer";
            recognizer      = new EigenFaceRecognizer(80, double.PositiveInfinity);
            break;
        }

        //introduce error checking
        recognizer.Load(filename);

        //Now load the labels
        string direct = Path.GetDirectoryName(filename);

        Names_List.Clear();
        if (File.Exists(direct + "/Labels.xml"))
        {
            FileStream filestream = File.OpenRead(direct + "/Labels.xml");
            long       filelength = filestream.Length;
            byte[]     xmlBytes   = new byte[filelength];
            filestream.Read(xmlBytes, 0, (int)filelength);
            filestream.Close();

            MemoryStream xmlStream = new MemoryStream(xmlBytes);

            using (XmlReader xmlreader = XmlTextReader.Create(xmlStream))
            {
                while (xmlreader.Read())
                {
                    if (xmlreader.IsStartElement())
                    {
                        switch (xmlreader.Name)
                        {
                        case "NAME":
                            if (xmlreader.Read())
                            {
                                Names_List.Add(xmlreader.Value.Trim());
                            }
                            break;
                        }
                    }
                }
            }
            ContTrain = NumLabels;
        }
        _IsTrained = true;
    }
Esempio n. 6
0
        private void ReadDocument(XmlReader reader)
        {
            ServiceDocument result = CreateDocumentInstance();

            try
            {
                SyndicationFeedFormatter.MoveToStartElement(reader);
                bool elementIsEmpty = reader.IsEmptyElement;
                if (reader.HasAttributes)
                {
                    while (reader.MoveToNextAttribute())
                    {
                        if (reader.LocalName == "lang" && reader.NamespaceURI == Atom10FeedFormatter.XmlNs)
                        {
                            result.Language = reader.Value;
                        }
                        else if (reader.LocalName == "base" && reader.NamespaceURI == Atom10FeedFormatter.XmlNs)
                        {
                            result.BaseUri = new Uri(reader.Value, UriKind.RelativeOrAbsolute);
                        }
                        else
                        {
                            string ns   = reader.NamespaceURI;
                            string name = reader.LocalName;
                            if (FeedUtils.IsXmlns(name, ns) || FeedUtils.IsXmlSchemaType(name, ns))
                            {
                                continue;
                            }

                            string val = reader.Value;
                            if (!TryParseAttribute(name, ns, val, result, Version))
                            {
                                result.AttributeExtensions.Add(new XmlQualifiedName(reader.LocalName, reader.NamespaceURI), reader.Value);
                            }
                        }
                    }
                }
                XmlBuffer           buffer    = null;
                XmlDictionaryWriter extWriter = null;

                reader.ReadStartElement();
                if (!elementIsEmpty)
                {
                    try
                    {
                        while (reader.IsStartElement())
                        {
                            if (reader.IsStartElement(App10Constants.Workspace, App10Constants.Namespace))
                            {
                                result.Workspaces.Add(ReadWorkspace(reader, result));
                            }
                            else if (!TryParseElement(reader, result, Version))
                            {
                                SyndicationFeedFormatter.CreateBufferIfRequiredAndWriteNode(ref buffer, ref extWriter, reader, _maxExtensionSize);
                            }
                        }
                        LoadElementExtensions(buffer, extWriter, result);
                    }
                    finally
                    {
                        extWriter?.Close();
                    }
                }

                reader.ReadEndElement();
            }
            catch (FormatException e)
            {
                throw new XmlException(FeedUtils.AddLineInfo(reader, SR.ErrorParsingDocument), e);
            }
            catch (ArgumentException e)
            {
                throw new XmlException(FeedUtils.AddLineInfo(reader, SR.ErrorParsingDocument), e);
            }

            SetDocument(result);
        }
Esempio n. 7
0
        private static void ReadReferencedCategories(XmlReader reader, ReferencedCategoriesDocument referencedCategories, Uri baseUri, Uri link, string version, int maxExtensionSize)
        {
            referencedCategories.BaseUri = baseUri;
            referencedCategories.Link    = link;
            if (reader.HasAttributes)
            {
                while (reader.MoveToNextAttribute())
                {
                    if (reader.LocalName == "base" && reader.NamespaceURI == Atom10FeedFormatter.XmlNs)
                    {
                        referencedCategories.BaseUri = FeedUtils.CombineXmlBase(referencedCategories.BaseUri, reader.Value);
                    }
                    else if (reader.LocalName == "lang" && reader.NamespaceURI == Atom10FeedFormatter.XmlNs)
                    {
                        referencedCategories.Language = reader.Value;
                    }
                    else if (reader.LocalName == App10Constants.Href && reader.NamespaceURI == string.Empty)
                    {
                        continue;
                    }
                    else
                    {
                        string ns   = reader.NamespaceURI;
                        string name = reader.LocalName;
                        if (FeedUtils.IsXmlns(name, ns) || FeedUtils.IsXmlSchemaType(name, ns))
                        {
                            continue;
                        }

                        string val = reader.Value;
                        if (!TryParseAttribute(name, ns, val, referencedCategories, version))
                        {
                            referencedCategories.AttributeExtensions.Add(new XmlQualifiedName(reader.LocalName, reader.NamespaceURI), reader.Value);
                        }
                    }
                }
            }

            reader.MoveToElement();
            bool isEmptyElement = reader.IsEmptyElement;

            reader.ReadStartElement();
            if (!isEmptyElement)
            {
                XmlBuffer           buffer    = null;
                XmlDictionaryWriter extWriter = null;
                try
                {
                    while (reader.IsStartElement())
                    {
                        if (!TryParseElement(reader, referencedCategories, version))
                        {
                            SyndicationFeedFormatter.CreateBufferIfRequiredAndWriteNode(ref buffer, ref extWriter, reader, maxExtensionSize);
                        }
                    }
                    LoadElementExtensions(buffer, extWriter, referencedCategories);
                }
                finally
                {
                    extWriter?.Close();
                }
                reader.ReadEndElement();
            }
        }
Esempio n. 8
0
        public void filterRegionsSeriallyXML(string input)
        {
            string       regionsFileName = resultsDirectory + OSseparator + outfileName + "_filtered_regions." + fileType;
            StreamWriter outputRegion    = new StreamWriter(@"" + regionsFileName);

            string       peaksInRegionsFileName = resultsDirectory + OSseparator + outfileName + "_filtered_regions_peaks." + fileType;
            StreamWriter outputPeak             = new StreamWriter(@"" + peaksInRegionsFileName);

            string            xmlFileName = resultsDirectory + OSseparator + outfileName + "_filtered_regions.xml";
            XmlWriterSettings settings    = new XmlWriterSettings();

            settings.Indent      = true;
            settings.IndentChars = "\t";
            XmlWriter writer = XmlWriter.Create(@"" + xmlFileName, settings);

            writer.WriteStartDocument();
            writer.WriteStartElement("regs");

            XmlReader reader = XmlReader.Create(@"" + inputFile);
            XmlReader sTree;
            XElement  regionElement;
            region    newRegion, previousRegion = null;
            int       elementCounter = 1, attributeCounter = 1, lineCounter = 2;

            while (reader.ReadToFollowing("reg"))
            {
                if (reader.IsStartElement())
                {
                    sTree         = reader.ReadSubtree();
                    regionElement = XElement.Load(sTree);

                    lineCounter++;
                    newRegion          = regionFromXML(regionElement, inputFile, elementCounter, lineCounter);
                    newRegion.peakList = new List <peak>();
                    attributeCounter   = 1;

                    foreach (XElement peakElement in regionElement.Descendants("pk"))
                    {
                        lineCounter++;
                        newRegion.peakList.Add(peakFromXML(peakElement, inputFile, elementCounter, attributeCounter, lineCounter));
                        attributeCounter++;
                    }
                    elementCounter++;
                    lineCounter++;

                    if (filterRegion(newRegion))
                    {
                        previousRegion = calculateStatisticData(newRegion, previousRegion);
                        printRegion(newRegion, outputRegion, outputPeak);
                        writeRegionInXML(writer, newRegion);
                    }
                }
                else
                {
                    break;
                }
            }

            outputRegion.Close();
            outputPeak.Close();
            writer.WriteEndElement();
            writer.WriteEndDocument();
            writer.Close();

            if (!peakFile)
            {
                File.Delete(@"" + peaksInRegionsFileName);
            }
            if (!xmlFile)
            {
                File.Delete(@"" + xmlFileName);
            }

            Console.WriteLine("done!");
        }
Esempio n. 9
0
 public override bool CanReadToken(XmlReader reader)
 => reader?.IsStartElement("BinarySecurityToken", WsSecurityConstants.WsSecurity10.Namespace) == true &&
 reader.GetAttribute("ValueType") == "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-x509-token-profile-1.0#X509v3" &&
 reader.GetAttribute("EncodingType") == "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-soap-message-security-1.0#Base64Binary"
 ;
Esempio n. 10
0
        private bool LoadTrainingData(string Folder_location)
        {
            if (File.Exists(Folder_location + "\\" + XmlVeriDosyasi))
            {
                try
                {
                    Names_List.Clear();
                    trainingImages.Clear();
                    FileStream filestream = File.OpenRead(Folder_location + "\\" + XmlVeriDosyasi);
                    long       filelength = filestream.Length;
                    byte[]     xmlBytes   = new byte[filelength];
                    filestream.Read(xmlBytes, 0, (int)filelength);
                    filestream.Close();

                    MemoryStream xmlStream = new MemoryStream(xmlBytes);

                    using (XmlReader xmlreader = XmlTextReader.Create(xmlStream))
                    {
                        while (xmlreader.Read())
                        {
                            if (xmlreader.IsStartElement())
                            {
                                switch (xmlreader.Name)
                                {
                                case "NAME":
                                    if (xmlreader.Read())
                                    {
                                        Names_List.Add(xmlreader.Value.Trim());
                                        NumLabels += 1;
                                    }
                                    break;

                                case "FILE":
                                    if (xmlreader.Read())
                                    {
                                        trainingImages.Add(new Image <Gray, byte>(Dizin + "\\" + xmlreader.Value.Trim()));
                                    }
                                    break;
                                }
                            }
                        }
                    }
                    ContTrain = NumLabels;

                    if (trainingImages.ToArray().Length != 0)
                    {
                        recognizer = new EigenObjectRecognizer(trainingImages.ToArray(),
                                                               Names_List.ToArray(), 5000, ref termCrit);
                        return(true);
                    }
                    else
                    {
                        return(false);
                    }
                }
                catch (Exception ex)
                {
                    Error = ex.ToString();
                    return(false);
                }
            }
            else
            {
                return(false);
            }
        }
        /// <summary>
        /// Generates a serializable continuation token from its XML representation.
        /// </summary>
        /// <param name="reader">The <see cref="T:System.Xml.XmlReader"/> stream from which the continuation token is deserialized.</param>
        public void ReadXml(XmlReader reader)
        {
            if (reader == null)
            {
                throw new ArgumentNullException("reader");
            }

            reader.MoveToContent();

            if (reader.IsEmptyElement)
            {
                reader.Skip();
            }
            else
            {
                reader.ReadStartElement();
                while (reader.IsStartElement())
                {
                    if (reader.IsEmptyElement)
                    {
                        reader.Skip();
                    }
                    else
                    {
                        switch (reader.Name)
                        {
                        case Constants.ContinuationConstants.VersionElement:
                            string version = reader.ReadElementContentAsString();
                            if (version != Constants.ContinuationConstants.CurrentVersion)
                            {
                                throw new XmlException(string.Format(CultureInfo.InvariantCulture, SR.UnexpectedElement, version));
                            }

                            break;

                        case Constants.ContinuationConstants.NextPartitionKeyElement:
                            this.NextPartitionKey = reader.ReadElementContentAsString();
                            break;

                        case Constants.ContinuationConstants.NextRowKeyElement:
                            this.NextRowKey = reader.ReadElementContentAsString();
                            break;

                        case Constants.ContinuationConstants.NextTableNameElement:
                            this.NextTableName = reader.ReadElementContentAsString();
                            break;

                        case Constants.ContinuationConstants.TypeElement:
                            string continuationType = reader.ReadElementContentAsString();
                            if (Constants.ContinuationConstants.TableType != continuationType)
                            {
                                throw new XmlException(SR.UnexpectedContinuationType);
                            }

                            break;

                        default:
                            throw new XmlException(string.Format(CultureInfo.InvariantCulture, SR.UnexpectedElement, reader.Name));
                        }
                    }
                }

                reader.ReadEndElement();
            }
        }
Esempio n. 12
0
        public static void AddEOSComp(XmlReader rdr, Computer compAttatchedTo, object osObj)
        {
            var os       = (OS)osObj;
            var compName = "Unregistered eOS Device";
            var str1     = compAttatchedTo.idName + "_eos";

            if (rdr.MoveToAttribute("name"))
            {
                compName = rdr.ReadContentAsString();
            }
            if (rdr.MoveToAttribute("id"))
            {
                str1 = rdr.ReadContentAsString();
            }
            var device = new Computer(compName, NetworkMap.generateRandomIP(), os.netMap.getRandomPosition(), 0, 5, os);

            device.idName = str1;
            var str2 = "ePhone";

            if (rdr.MoveToAttribute("icon"))
            {
                str2 = rdr.ReadContentAsString();
            }
            device.icon     = str2;
            device.location = compAttatchedTo.location +
                              Corporation.getNearbyNodeOffset(compAttatchedTo.location, Utils.random.Next(12), 12,
                                                              os.netMap);
            device.setAdminPassword("alpine");
            ComputerLoader.loadPortsIntoComputer("22,3659", device);
            device.portsNeededForCrack = 2;
            GenerateEOSFilesystem(device);
            rdr.Read();
            var folder1 = device.files.root.searchForFolder("eos");
            var folder2 = folder1.searchForFolder("notes");
            var folder3 = folder1.searchForFolder("mail");

            while (!(rdr.Name == "eosDevice") || rdr.IsStartElement())
            {
                if (rdr.Name.ToLower() == "note" && rdr.IsStartElement())
                {
                    string nameEntry = null;
                    if (rdr.MoveToAttribute("filename"))
                    {
                        nameEntry = rdr.ReadContentAsString();
                    }
                    var num       = (int)rdr.MoveToContent();
                    var dataEntry = rdr.ReadElementContentAsString().TrimStart();
                    if (nameEntry == null)
                    {
                        var length = dataEntry.IndexOf("\n");
                        if (length == -1)
                        {
                            length = dataEntry.IndexOf("\n");
                        }
                        if (length == -1)
                        {
                            length = dataEntry.Length;
                        }
                        nameEntry = dataEntry.Substring(0, length).Replace(" ", "_").ToLower().Trim() + ".txt";
                    }
                    var fileEntry = new FileEntry(dataEntry, nameEntry);
                    folder2.files.Add(fileEntry);
                }
                if (rdr.Name.ToLower() == "mail" && rdr.IsStartElement())
                {
                    string str3 = null;
                    string str4 = null;
                    if (rdr.MoveToAttribute("username"))
                    {
                        str3 = rdr.ReadContentAsString();
                    }
                    if (rdr.MoveToAttribute("pass"))
                    {
                        str4 = rdr.ReadContentAsString();
                    }
                    var dataEntry = "MAIL ACCOUNT : " + str3 + "\nAccount   :" + str3 + "\nPassword :"******"\nLast Sync :" + DateTime.Now + "\n\n" + Computer.generateBinaryString(512);
                    var nameEntry = str3 + ".act";
                    folder3.files.Add(new FileEntry(dataEntry, nameEntry));
                }
                rdr.Read();
                if (rdr.EOF)
                {
                    break;
                }
            }
            os.netMap.nodes.Add(device);
            ComputerLoader.postAllLoadedActions += () => device.links.Add(os.netMap.nodes.IndexOf(compAttatchedTo));
            if (compAttatchedTo.attatchedDeviceIDs != null)
            {
                compAttatchedTo.attatchedDeviceIDs += ",";
            }
            compAttatchedTo.attatchedDeviceIDs += device.idName;
        }
Esempio n. 13
0
        internal bool IsStartElement()
#endif
        {
            return(!isEndOfEmptyElement && reader.IsStartElement());
        }
 public override bool IsStartElement()
 {
     return(innerReader.IsStartElement());
 }
Esempio n. 15
0
        /// <summary>
        /// private helper file that will read the xml file and convert it into a saved spreadsheet
        /// the readFile method will also
        ///
        /// </summary>


        private string readFile(string filename, bool getVersioninfo)
        {
            if (ReferenceEquals(filename, null))
            {
                throw new SpreadsheetReadWriteException("filename is null");
            }
            if (filename.Equals(""))
            {
                throw new SpreadsheetReadWriteException("filename is empty");
            }

            try
            {
                using (XmlReader reader = XmlReader.Create(filename))
                {
                    string name    = "";
                    string content = "";
                    while (reader.Read())
                    {
                        if (reader.IsStartElement())
                        {
                            switch (reader.Name)
                            {
                            case "spreadsheet":
                                if (getVersioninfo)
                                {
                                    return(reader["version"]);
                                }
                                Version = reader["version"];
                                break;


                            case "name":
                                if (getVersioninfo)
                                {
                                    throw new SpreadsheetReadWriteException("file read error");
                                }
                                else
                                {
                                    reader.Read();
                                    name = reader.Value;
                                }

                                break;

                            case "cell":
                                if (getVersioninfo)
                                {
                                    throw new SpreadsheetReadWriteException("file read error");
                                }
                                break;

                            case "contents":
                                if (getVersioninfo)
                                {
                                    throw new SpreadsheetReadWriteException("file read error");
                                }
                                reader.Read();
                                content = reader.Value;
                                SetContentsOfCell(name, content);


                                break;
                            }
                        }
                    }
                }
            }
            catch (XmlException e)
            {
                throw new SpreadsheetReadWriteException(e.ToString());
            }
            catch (IOException e)
            {
                throw new SpreadsheetReadWriteException(e.ToString());
            }

            return(Version);
        }
Esempio n. 16
0
        public Spreadsheet(string path, Func <string, bool> isValid, Func <string, string> normalize, string FileVersion) : base(isValid, normalize, FileVersion)
        {
            bool openfile = true;

            XmlReaderSettings settings = new XmlReaderSettings();

            settings.IgnoreWhitespace = true;
            try
            {
                using (XmlReader reader = XmlReader.Create(path, settings))
                {
                    while (openfile)
                    {
                        //read the next element
                        if (reader.Read())
                        {
                            if (reader.IsStartElement())
                            {
                                //if spreadsheet get version
                                if (reader.Name == "spreadsheet")
                                {
                                    Version = reader.GetAttribute("version");
                                }
                                //if cell get name and contents
                                else if (reader.Name == "cell")
                                {
                                    string name     = "";
                                    string contents = "";
                                    reader.Read();

                                    if (reader.IsStartElement())
                                    {
                                        if (reader.Name == "name")
                                        {
                                            reader.Read();
                                            name = reader.Value;
                                            reader.Read();
                                            reader.ReadEndElement();
                                        }
                                        //if element isn't name, throw exception
                                        else
                                        {
                                            throw new SpreadsheetReadWriteException("Cell not written correctly");
                                        }
                                    }
                                    //if element doesn't exist, throw exception

                                    if (reader.IsStartElement())
                                    {
                                        if (reader.Name == "contents")
                                        {
                                            reader.Read();
                                            contents = reader.Value;
                                            reader.Read();
                                            reader.ReadEndElement();
                                        }
                                        //if element isn't contents, throw exception
                                        else
                                        {
                                            throw new SpreadsheetReadWriteException("Cell not written in correct order");
                                        }
                                    }
                                    //once we have the name and contents, set the contents of the cell
                                    SetContentsOfCell(name, contents);
                                }
                                else
                                {
                                    throw new SpreadsheetReadWriteException("Invalid element property");
                                }
                            }
                        }
                        else
                        {
                            openfile = false;
                        }
                    }
                    //if it's not a valid version number, throw exception
                    if (Version != FileVersion)
                    {
                        throw new SpreadsheetReadWriteException("Invalid Version Number");
                    }
                }

                Changed = false;
            }
            //catching the different SS exceptions and throwing them. otherwise, if it is a read write exception, throw that.
            catch (CircularException E)
            {
                throw E;
            }
            catch (InvalidNameException E)
            {
                throw E;
            }
            catch (SpreadsheetReadWriteException E)
            {
                throw E;
            }
            catch (Exception)
            {
                throw new SpreadsheetReadWriteException("Error reading or writing spreadsheet");
            }
        }
    private object ReadObject(string classname, List<object> list, XmlReader reader)
    {
        object res = null;
        int count = 0;
        string attribute = null;
        int fieldcount;

            if (classname == null)
            {
                reader.Read();
                if (reader.IsStartElement())
                    classname = XmlConvert.DecodeName(reader.Name);
                count = Convert.ToInt32(reader["count"]);
            }

            if (classname == null)
                return null;
        fieldcount = Convert.ToInt32(reader["fieldcount"]);
        attribute = reader["reference"];
        reader.Read();
        if (reader.IsStartElement() || reader.Value != null)
        {
            Type objtype = Type.GetType(classname);

            if (attribute != null)
            {
                //  string attribute = reader["reference"];
                if (attribute != null)
                {
                    res = list[Convert.ToInt32(attribute)];
                }
            }
            else if (objtype.IsPrimitive)
            {
                res = (object)objtype.InvokeMember("Parse",
                      BindingFlags.InvokeMethod | BindingFlags.Static | BindingFlags.Public,
                      null, null, new object[] { XmlConvert.DecodeName(reader.Value.Trim()) });
                list.Add(res);
            }
            else if (objtype.Equals(typeof(string)))
            {
                res = XmlConvert.DecodeName(reader.Value.Trim());
            }
            else
            {
                if (objtype.IsArray)
                {
                    //count = Convert.ToInt32(reader["count"]);
                    int index = 0;
                    res = Activator.CreateInstance(objtype, count);
                    list.Add(res);
                    while (index < count)
                    {
                        //reader.Read();
                        while(!reader.IsStartElement())
                            reader.Read();
                        string s = reader.Name;
                        ((System.Array)res).SetValue(ReadObject(s, list, reader), index++);
                    }
                }
                else
                {
                    res = Activator.CreateInstance(objtype);
                    list.Add(res);
                    int index = 0;
                    //count = Convert.ToInt32(reader["count"]);
                    while (index < fieldcount)
                    {
                        while (!reader.IsStartElement())
                            reader.Read();
                        index++;
                        string fieldname = reader.Name;
                        object fieldobject = ReadObject(null, list, reader);
                        FieldInfo fiendinf = objtype.GetField(fieldname, BindingFlags.GetField | BindingFlags.SetField | BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance);
                        if (fiendinf != null)
                            fiendinf.SetValue(res, fieldobject);
                    }

                }
            }
        } 
     return res;
    }
Esempio n. 18
0
        private static bool LoadTrainingData(String folder)
        {
            if (File.Exists(folder + "\\TrainedLabels.xml"))
            {
                countTrain = 0;
                labels.Clear();
                labelsID.Clear();
                trainingImages.Clear();

                FileStream filestream = File.OpenRead(folder + "\\TrainedLabels.xml");
                long       fileLength = filestream.Length;
                byte[]     xmlBytes   = new byte[fileLength];
                filestream.Read(xmlBytes, 0, (int)fileLength);
                filestream.Dispose();

                MemoryStream xmlStream = new MemoryStream(xmlBytes);
                using (XmlReader xmlReader = XmlTextReader.Create(xmlStream))
                {
                    while (xmlReader.Read())
                    {
                        if (xmlReader.IsStartElement())
                        {
                            switch (xmlReader.Name)
                            {
                            case "NAME":
                                if (xmlReader.Read())
                                {
                                    labelsID.Add(labels.Count);
                                    labels.Add(xmlReader.Value.Trim());
                                    countTrain += 1;
                                }
                                break;

                            case "FILE":
                                if (xmlReader.Read())
                                {
                                    trainingImages.Add(new Image <Gray, byte>(folder + "\\" + xmlReader.Value.Trim()));
                                }
                                break;
                            }
                        }
                    }
                }
                xmlStream.Dispose();
                filestream.Dispose();


                if (countTrain != 0)
                {
                    try
                    {
                        faceRecognizer.Train(trainingImages.ToArray(), labelsID.ToArray());
                    }
                    catch (Exception e)
                    {
                        MessageBox.Show(e.Message);
                    }
                }



                return(true);
            }
            else
            {
                return(false);
            }
        }
Esempio n. 19
0
        private static void ReadInlineCategories(XmlReader reader, InlineCategoriesDocument inlineCategories, Uri baseUri, string version, int maxExtensionSize)
        {
            inlineCategories.BaseUri = baseUri;
            if (reader.HasAttributes)
            {
                while (reader.MoveToNextAttribute())
                {
                    if (reader.LocalName == "base" && reader.NamespaceURI == Atom10FeedFormatter.XmlNs)
                    {
                        inlineCategories.BaseUri = FeedUtils.CombineXmlBase(inlineCategories.BaseUri, reader.Value);
                    }
                    else if (reader.LocalName == "lang" && reader.NamespaceURI == Atom10FeedFormatter.XmlNs)
                    {
                        inlineCategories.Language = reader.Value;
                    }
                    else if (reader.LocalName == App10Constants.Fixed && reader.NamespaceURI == string.Empty)
                    {
                        inlineCategories.IsFixed = (reader.Value == "yes");
                    }
                    else if (reader.LocalName == Atom10Constants.SchemeTag && reader.NamespaceURI == string.Empty)
                    {
                        inlineCategories.Scheme = reader.Value;
                    }
                    else
                    {
                        string ns   = reader.NamespaceURI;
                        string name = reader.LocalName;
                        if (FeedUtils.IsXmlns(name, ns) || FeedUtils.IsXmlSchemaType(name, ns))
                        {
                            continue;
                        }

                        string val = reader.Value;
                        if (!TryParseAttribute(name, ns, val, inlineCategories, version))
                        {
                            inlineCategories.AttributeExtensions.Add(new XmlQualifiedName(reader.LocalName, reader.NamespaceURI), reader.Value);
                        }
                    }
                }
            }
            SyndicationFeedFormatter.MoveToStartElement(reader);
            bool isEmptyElement = reader.IsEmptyElement;

            reader.ReadStartElement();
            if (!isEmptyElement)
            {
                XmlBuffer           buffer    = null;
                XmlDictionaryWriter extWriter = null;
                try
                {
                    while (reader.IsStartElement())
                    {
                        if (reader.IsStartElement(Atom10Constants.CategoryTag, Atom10Constants.Atom10Namespace))
                        {
                            SyndicationCategory category = CreateCategory(inlineCategories);
                            Atom10FeedFormatter.ReadCategory(reader, category, version, preserveAttributeExtensions: true, preserveElementExtensions: true, maxExtensionSize);
                            category.Scheme ??= inlineCategories.Scheme;
                            inlineCategories.Categories.Add(category);
                        }
                        else if (!TryParseElement(reader, inlineCategories, version))
                        {
                            SyndicationFeedFormatter.CreateBufferIfRequiredAndWriteNode(ref buffer, ref extWriter, reader, maxExtensionSize);
                        }
                    }
                    LoadElementExtensions(buffer, extWriter, inlineCategories);
                }
                finally
                {
                    extWriter?.Close();
                }
                reader.ReadEndElement();
            }
        }
Esempio n. 20
0
 public override bool CanDeserialize(XmlReader xmlReader)
 {
     return(xmlReader.IsStartElement("AutoAttendantSettings", string.Empty));
 }
Esempio n. 21
0
        private ResourceCollectionInfo ReadCollection(XmlReader reader, Workspace workspace)
        {
            ResourceCollectionInfo result = CreateCollection(workspace);

            result.BaseUri = workspace.BaseUri;
            if (reader.HasAttributes)
            {
                while (reader.MoveToNextAttribute())
                {
                    if (reader.LocalName == "base" && reader.NamespaceURI == Atom10FeedFormatter.XmlNs)
                    {
                        result.BaseUri = FeedUtils.CombineXmlBase(result.BaseUri, reader.Value);
                    }
                    else if (reader.LocalName == App10Constants.Href && reader.NamespaceURI == string.Empty)
                    {
                        result.Link = new Uri(reader.Value, UriKind.RelativeOrAbsolute);
                    }
                    else
                    {
                        string ns   = reader.NamespaceURI;
                        string name = reader.LocalName;
                        if (FeedUtils.IsXmlns(name, ns) || FeedUtils.IsXmlSchemaType(name, ns))
                        {
                            continue;
                        }

                        string val = reader.Value;
                        if (!TryParseAttribute(name, ns, val, result, Version))
                        {
                            result.AttributeExtensions.Add(new XmlQualifiedName(reader.LocalName, reader.NamespaceURI), reader.Value);
                        }
                    }
                }
            }

            XmlBuffer           buffer    = null;
            XmlDictionaryWriter extWriter = null;

            reader.ReadStartElement();
            try
            {
                while (reader.IsStartElement())
                {
                    if (reader.IsStartElement(Atom10Constants.TitleTag, Atom10Constants.Atom10Namespace))
                    {
                        result.Title = Atom10FeedFormatter.ReadTextContentFrom(reader, "//app:service/app:workspace/app:collection/atom:title[@type]", preserveAttributeExtensions: true);
                    }
                    else if (reader.IsStartElement(App10Constants.Categories, App10Constants.Namespace))
                    {
                        result.Categories.Add(ReadCategories(reader,
                                                             result.BaseUri,
                                                             () => CreateInlineCategories(result),
                                                             () => CreateReferencedCategories(result),
                                                             Version,
                                                             _maxExtensionSize));
                    }
                    else if (reader.IsStartElement(App10Constants.Accept, App10Constants.Namespace))
                    {
                        result.Accepts.Add(reader.ReadElementString());
                    }
                    else if (!TryParseElement(reader, result, Version))
                    {
                        SyndicationFeedFormatter.CreateBufferIfRequiredAndWriteNode(ref buffer, ref extWriter, reader, _maxExtensionSize);
                    }
                }
                LoadElementExtensions(buffer, extWriter, result);
            }
            finally
            {
                extWriter?.Close();
            }

            reader.ReadEndElement();
            return(result);
        }
Esempio n. 22
0
        /// <summary>
        /// Global eventing Subscribe stub.
        /// </summary>
        /// <param name="header">Header object.</param>
        /// <param name="reader">An XmlReader positioned at the begining of the Subscribe request body element.</param>
        /// <param name="serviceEndpoints">A Collection of serviceEndpoints used to determine what services contain the event source specified in the filter.</param>
        /// <returns>Byte array containing a Subscribe response.</returns>
        internal byte[] Subscribe(WsWsaHeader header, XmlReader reader, WsServiceEndpoints serviceEndpoints)
        {
            // Parse Subscribe Request
            /////////////////////////////
            DpwsWseEventSink eventSink = new DpwsWseEventSink();

            try
            {
                reader.ReadStartElement("Subscribe", WsWellKnownUri.WseNamespaceUri);

                if (reader.IsStartElement("EndTo", WsWellKnownUri.WseNamespaceUri))
                {
                    eventSink.EndTo = new WsWsaEndpointRef(reader);
                }

                reader.ReadStartElement("Delivery", WsWellKnownUri.WseNamespaceUri);
                if (reader.IsStartElement("NotifyTo", WsWellKnownUri.WseNamespaceUri))
                {
                    eventSink.NotifyTo = new WsWsaEndpointRef(reader);
                }
                else
                {
                    throw new WsFaultException(header, WsFaultType.WseDeliverModeRequestedUnavailable);
                }

                reader.ReadEndElement();

                if (reader.IsStartElement("Expires", WsWellKnownUri.WseNamespaceUri))
                {
                    long expires = new WsDuration(reader.ReadElementString()).DurationInSeconds;

                    if (expires > 0)
                    {
                        eventSink.Expires = expires;
                    }
                    else
                    {
                        throw new WsFaultException(header, WsFaultType.WseInvalidExpirationTime);
                    }
                }
                else
                {
                    // Never Expires
                    eventSink.Expires = -1;
                }

                if (reader.IsStartElement("Filter", WsWellKnownUri.WseNamespaceUri))
                {
                    if (reader.MoveToAttribute("Dialect") == false || reader.Value != "http://schemas.xmlsoap.org/ws/2006/02/devprof/Action")
                    {
                        throw new WsFaultException(header, WsFaultType.WseFilteringRequestedUnavailable);
                    }

                    reader.MoveToElement();

                    String filters = reader.ReadElementString();

                    if (filters != String.Empty)
                    {
                        eventSink.Filters = filters.Split(' ');
                    }
                }

                XmlReaderHelper.SkipAllSiblings(reader);

                reader.ReadEndElement(); // Subscribe
            }
            catch (XmlException e)
            {
                throw new WsFaultException(header, WsFaultType.WseInvalidMessage, e.ToString());
            }

            // Parse urn:uuid from the To address
            string endpointAddress = FixToAddress(header.To);

            // Build a temporary collection of device services that match the specified endpoint address.
            WsServiceEndpoints matchingServices = new WsServiceEndpoints();

            for (int i = 0; i < serviceEndpoints.Count; ++i)
            {
                if (serviceEndpoints[i].EndpointAddress == endpointAddress)
                {
                    matchingServices.Add(serviceEndpoints[i]);
                }
            }

            // For each service with a matching endpoint and event sources add an event sink to the
            // event source collection
            for (int i = 0; i < matchingServices.Count; ++i)
            {
                DpwsWseEventSources eventSources = ((DpwsHostedService)matchingServices[i]).EventSources;

                // Set the EventSinkID
                eventSink.ID = "urn:uuid:" + Guid.NewGuid().ToString();

                // If subscribing to all event sources
                if (eventSink.Filters == null)
                {
                    int count = eventSources.Count;
                    for (int ii = 0; i < count; i++)
                    {
                        DpwsWseEventSource eventSource = eventSources[ii];
                        eventSink.StartTime = DateTime.Now.Ticks;
                        eventSource.EventSinks.Add(eventSink);
                    }
                }
                else
                {
                    // If subscribing to a specific event based on an event filter.
                    DpwsWseEventSource eventSource;
                    string[]           filterList = eventSink.Filters;
                    int length = filterList.Length;
                    for (int ii = 0; i < length; i++)
                    {
                        if ((eventSource = eventSources[filterList[ii]]) != null)
                        {
                            eventSink.StartTime = DateTime.Now.Ticks;
                            eventSource.EventSinks.Add(eventSink);
                        }
                        else
                        {
                            throw new Exception("Event source " + filterList[ii] + " was not found.");
                        }
                    }
                }
            }

            // Generate Response
            //////////////////////////
            MemoryStream soapStream = new MemoryStream();
            XmlWriter    xmlWriter  = XmlWriter.Create(soapStream);

            WsWsaHeader responseHeader = new WsWsaHeader(
                WsWellKnownUri.WseNamespaceUri + "/SubscribeResponse",  // Action
                header.MessageID,                                       // RelatesTo
                header.ReplyTo.Address.AbsoluteUri,                     // To
                null, null, null);                                      // ReplyTo, From, Any

            WsSoapMessageWriter.WriteSoapMessageStart(xmlWriter,
                                                      WsSoapMessageWriter.Prefixes.Wse,                                                              // Prefix
                                                      null,                                                                                          // Additional Prefix
                                                      responseHeader,                                                                                // Header
                                                      new WsSoapMessageWriter.AppSequence(Device.AppSequence, Device.SequenceID, Device.MessageID)); // AppSequence

            // write body
            xmlWriter.WriteStartElement("wse", "SubscribeResponse", null);
            xmlWriter.WriteStartElement("wse", "SubscriptionManager", null);
            xmlWriter.WriteStartElement("wsa", "Address", null);
            // Create a uri. Use the path (by default will be a uuid) for the sub manager endpoint
            Uri subMgrUri = new Uri(((DpwsHostedService)matchingServices[0]).EndpointAddress);

            xmlWriter.WriteString("http://" + Device.IPV4Address + ":" + Device.Port + "/" + subMgrUri.AbsolutePath);
            xmlWriter.WriteEndElement(); // End Address
            xmlWriter.WriteStartElement("wsa", "ReferenceParameters", null);
            xmlWriter.WriteStartElement("wse", "Identifier", null);
            xmlWriter.WriteString(eventSink.ID);
            xmlWriter.WriteEndElement(); // End Identifier
            xmlWriter.WriteEndElement(); // End ReferenceParameters
            xmlWriter.WriteEndElement(); // End SubscriptionManager
            xmlWriter.WriteStartElement("wse", "Expires", null);
            xmlWriter.WriteString(new WsDuration(eventSink.Expires).DurationString);
            xmlWriter.WriteEndElement(); // End Expires
            xmlWriter.WriteEndElement(); // End SubscribeResponse

            WsSoapMessageWriter.WriteSoapMessageEnd(xmlWriter);

            // Flush and close writer. Return stream buffer
            xmlWriter.Flush();
            xmlWriter.Close();
            return(soapStream.ToArray());
        }
Esempio n. 23
0
        private Workspace ReadWorkspace(XmlReader reader, ServiceDocument document)
        {
            Workspace result = CreateWorkspace(document);

            result.BaseUri = document.BaseUri;
            if (reader.HasAttributes)
            {
                while (reader.MoveToNextAttribute())
                {
                    if (reader.LocalName == "base" && reader.NamespaceURI == Atom10FeedFormatter.XmlNs)
                    {
                        result.BaseUri = FeedUtils.CombineXmlBase(result.BaseUri, reader.Value);
                    }
                    else
                    {
                        string ns   = reader.NamespaceURI;
                        string name = reader.LocalName;
                        if (FeedUtils.IsXmlns(name, ns) || FeedUtils.IsXmlSchemaType(name, ns))
                        {
                            continue;
                        }

                        string val = reader.Value;
                        if (!TryParseAttribute(name, ns, val, result, Version))
                        {
                            result.AttributeExtensions.Add(new XmlQualifiedName(reader.LocalName, reader.NamespaceURI), reader.Value);
                        }
                    }
                }
            }

            XmlBuffer           buffer    = null;
            XmlDictionaryWriter extWriter = null;

            reader.ReadStartElement();
            try
            {
                while (reader.IsStartElement())
                {
                    if (reader.IsStartElement(Atom10Constants.TitleTag, Atom10Constants.Atom10Namespace))
                    {
                        result.Title = Atom10FeedFormatter.ReadTextContentFrom(reader, "//app:service/app:workspace/atom:title[@type]", preserveAttributeExtensions: true);
                    }
                    else if (reader.IsStartElement(App10Constants.Collection, App10Constants.Namespace))
                    {
                        result.Collections.Add(ReadCollection(reader, result));
                    }
                    else if (!TryParseElement(reader, result, Version))
                    {
                        SyndicationFeedFormatter.CreateBufferIfRequiredAndWriteNode(ref buffer, ref extWriter, reader, _maxExtensionSize);
                    }
                }
                LoadElementExtensions(buffer, extWriter, result);
            }
            finally
            {
                extWriter?.Close();
            }

            reader.ReadEndElement();
            return(result);
        }
Esempio n. 24
0
        /// <summary>
        /// Event renew stub.
        /// </summary>
        /// <param name="header">Header object.</param>
        /// <param name="reader">An XmlReader positioned at the begining of the Renew request body element.</param>
        /// <param name="serviceEndpoints">A Collection of serviceEndpoints used to determine what services contain the specified event.</param>
        /// <returns>Byte array containing an Renew response.</returns>
        /// <remarks>This method is used by the stack framework. Do not use this method.</remarks>
        public byte[] Renew(WsWsaHeader header, XmlReader reader, WsServiceEndpoints serviceEndpoints)
        {
            long   newExpiration = 0;
            String eventSinkId   = String.Empty;

            // Parse Renew request
            ////////////////////////////
            try
            {
                reader.ReadStartElement("Renew", WsWellKnownUri.WseNamespaceUri);

                if (reader.IsStartElement("Expires", WsWellKnownUri.WseNamespaceUri))
                {
                    newExpiration = new WsDuration(reader.ReadElementString()).DurationInSeconds;

                    if (newExpiration <= 0)
                    {
                        throw new WsFaultException(header, WsFaultType.WseInvalidExpirationTime);
                    }
                }
                else
                {
                    // Never Expires
                    newExpiration = -1;
                }

                eventSinkId = header.Any.GetNodeValue("Identifier", WsWellKnownUri.WseNamespaceUri);

                if (eventSinkId == null)
                {
                    throw new XmlException();
                }
            }
            catch (XmlException e)
            {
                throw new WsFaultException(header, WsFaultType.WseInvalidMessage, e.ToString());
            }

            // Parse urn:uuid from the To address
            string endpointAddress = FixToAddress(header.To);

            // Iterate the list of hosted services at the specified endpoint and renew each subscription
            // with and event source that matches the eventSinkID
            DpwsWseEventSink eventSink;
            bool             eventSinkFound = false;

            for (int i = 0; i < serviceEndpoints.Count; ++i)
            {
                if (serviceEndpoints[i].EndpointAddress == endpointAddress)
                {
                    if ((eventSink = GetEventSink(((DpwsHostedService)serviceEndpoints[i]).EventSources, eventSinkId)) != null)
                    {
                        eventSinkFound = true;

                        // Update event sink expires time
                        eventSink.Expires = newExpiration;
                    }
                }
            }

            // Generate Response
            if (eventSinkFound)
            {
                return(GetStatusResponse(header, newExpiration)); // It's just like the GetStatus Response
            }
            throw new WsFaultException(header, WsFaultType.WseEventSourceUnableToProcess, "Subscription was not found. ID=" + eventSinkId);
        }
    /// <summary>
    /// Loads the traing data given a (string) folder location
    /// </summary>
    /// <param name="Folder_location"></param>
    /// <returns></returns>
    private bool LoadTrainingData(string Folder_location)
    {
        if (File.Exists(Folder_location + "\\TrainedLabels.xml"))
        {
            try
            {
                //message_bar.Text = "";
                Names_List.Clear();
                Names_List_ID.Clear();
                trainingImages.Clear();
                FileStream filestream = File.OpenRead(Folder_location + "\\TrainedLabels.xml");
                long       filelength = filestream.Length;
                byte[]     xmlBytes   = new byte[filelength];
                filestream.Read(xmlBytes, 0, (int)filelength);
                filestream.Close();

                MemoryStream xmlStream = new MemoryStream(xmlBytes);

                using (XmlReader xmlreader = XmlTextReader.Create(xmlStream))
                {
                    while (xmlreader.Read())
                    {
                        if (xmlreader.IsStartElement())
                        {
                            switch (xmlreader.Name)
                            {
                            case "NAME":
                                if (xmlreader.Read())
                                {
                                    Names_List_ID.Add(Names_List.Count);     //0, 1, 2, 3....
                                    Names_List.Add(xmlreader.Value.Trim());
                                    NumLabels += 1;
                                }
                                break;

                            case "FILE":
                                if (xmlreader.Read())
                                {
                                    //PROBLEM HERE IF TRAININGG MOVED
                                    trainingImages.Add(new Image <Gray, byte>(Application.StartupPath + "\\TrainedFaces\\" + xmlreader.Value.Trim()));
                                }
                                break;
                            }
                        }
                    }
                }
                ContTrain = NumLabels;

                if (trainingImages.ToArray().Length != 0)
                {
                    //Eigen face recognizer
                    //Parameters:
                    //      num_components – The number of components (read: Eigenfaces) kept for this Prinicpal
                    //          Component Analysis. As a hint: There’s no rule how many components (read: Eigenfaces)
                    //          should be kept for good reconstruction capabilities. It is based on your input data,
                    //          so experiment with the number. Keeping 80 components should almost always be sufficient.
                    //
                    //      threshold – The threshold applied in the prediciton. This still has issues as it work inversly to LBH and Fisher Methods.
                    //          if you use 0.0 recognizer.Predict will always return -1 or unknown if you use 5000 for example unknow won't be reconised.
                    //          As in previous versions I ignore the built in threhold methods and allow a match to be found i.e. double.PositiveInfinity
                    //          and then use the eigen distance threshold that is return to elliminate unknowns.
                    //
                    //NOTE: The following causes the confusion, sinc two rules are used.
                    //--------------------------------------------------------------------------------------------------------------------------------------
                    //Eigen Uses
                    //          0 - X = unknown
                    //          > X = Recognised
                    //
                    //Fisher and LBPH Use
                    //          0 - X = Recognised
                    //          > X = Unknown
                    //
                    // Where X = Threshold value


                    switch (Recognizer_Type)
                    {
                    case ("EMGU.CV.LBPHFaceRecognizer"):
                        recognizer = new LBPHFaceRecognizer(1, 8, 8, 8, 100);    //50
                        break;

                    case ("EMGU.CV.FisherFaceRecognizer"):
                        recognizer = new FisherFaceRecognizer(0, 4000);    //4000
                        break;

                    case ("EMGU.CV.EigenFaceRecognizer"):
                    default:
                        recognizer = new EigenFaceRecognizer(80, double.PositiveInfinity);
                        break;
                    }

                    recognizer.Train(trainingImages.ToArray(), Names_List_ID.ToArray());
                    // Recognizer_Type = recognizer.GetType();
                    // string v = recognizer.ToString(); //EMGU.CV.FisherFaceRecognizer || EMGU.CV.EigenFaceRecognizer || EMGU.CV.LBPHFaceRecognizer

                    return(true);
                }
                else
                {
                    return(false);
                }
            }
            catch (Exception ex)
            {
                Error = ex.ToString();
                return(false);
            }
        }
        else
        {
            return(false);
        }
    }
Esempio n. 26
0
        public void ReadXml(XmlReader reader)
        {
            reader.MoveToContent();

            DisplayName = reader.GetAttribute("DisplayName");
            Guid guid;

            Guid.TryParse(reader.GetAttribute("ID"), out guid);
            ID = guid;
            Guid.TryParse(reader.GetAttribute("OriginalInstanceID"), out guid);
            OriginalInstanceID = guid;
            Guid.TryParse(reader.GetAttribute("ParentID"), out guid);
            ParentID = guid;
            Guid.TryParse(reader.GetAttribute("ServerID"), out guid);
            ServerID = guid;

            StateType state;

            Enum.TryParse(reader.GetAttribute("StateType"), out state);
            StateType = state;

            Guid.TryParse(reader.GetAttribute("SessionID"), out guid);
            SessionID = guid;

            while (reader.Read())
            {
                if (reader.IsStartElement("HasError"))
                {
                    var result = reader.ReadElementString("HasError");

                    bool boolean;
                    var  exists = bool.TryParse(result, out boolean);
                    HasError = exists && boolean;
                }

                if (reader.IsStartElement("ErrorMessage"))
                {
                    ErrorMessage = reader.ReadElementString("ErrorMessage");
                }

                if (reader.IsStartElement("Version"))
                {
                    Version = reader.ReadElementString("Version");
                }

                if (reader.IsStartElement("Name"))
                {
                    Name = reader.ReadElementString("Name");
                }

                if (reader.IsStartElement("ActivityType"))
                {
                    var result = reader.ReadElementString("ActivityType");

                    ActivityType activityType;
                    Enum.TryParse(result, out activityType);
                    ActivityType = activityType;
                }

                if (reader.IsStartElement("Duration"))
                {
                    DurationString = reader.ReadElementString("Duration");
                }

                if (reader.IsStartElement("StartTime"))
                {
                    var result = reader.ReadElementString("StartTime");

                    DateTime date;
                    DateTime.TryParse(result, out date);
                    StartTime = date;
                }

                if (reader.IsStartElement("EndTime"))
                {
                    var result = reader.ReadElementString("EndTime");

                    DateTime date;
                    DateTime.TryParse(result, out date);
                    EndTime = date;
                }


                if (reader.IsStartElement("Inputs"))
                {
                    Inputs = new List <IDebugItem>();
                    reader.ReadStartElement();
                    while (reader.MoveToContent() == XmlNodeType.Element && reader.LocalName == "DebugItem")
                    {
                        var item = new DebugItem();
                        item.ReadXml(reader);
                        Inputs.Add(item);
                    }
                    reader.ReadEndElement();
                }

                if (reader.IsStartElement("Outputs"))
                {
                    Outputs = new List <IDebugItem>();
                    reader.ReadStartElement();
                    while (reader.MoveToContent() == XmlNodeType.Element && reader.LocalName == "DebugItem")
                    {
                        var item = new DebugItem();
                        item.ReadXml(reader);
                        Outputs.Add(item);
                    }
                    reader.ReadEndElement();
                }

                if (reader.IsStartElement("ExecutionOrigin"))
                {
                    var result = reader.ReadElementString("ExecutionOrigin");

                    ExecutionOrigin origin;
                    var             exists = Enum.TryParse(result, out origin);
                    if (exists)
                    {
                        ExecutionOrigin = origin;
                    }
                }

                if (reader.IsStartElement("ExecutingUser"))
                {
                    ExecutingUser = reader.ReadElementString("ExecutingUser");
                }

                if (reader.IsStartElement("NumberOfSteps"))
                {
                    int numberOfSteps;
                    var success = int.TryParse(reader.ReadElementString("NumberOfSteps"), out numberOfSteps);
                    if (success)
                    {
                        NumberOfSteps = numberOfSteps;
                    }
                }

                if (reader.NodeType == XmlNodeType.EndElement && reader.Name == "DebugState")
                {
                    reader.ReadEndElement();
                    break;
                }
            }
        }
Esempio n. 27
0
        public static string InjectInXml(string XML, int InjectionPosition, string Payload)
        {
            //StringBuilder OutXml = new StringBuilder();
            StringReader XMLStringReader = new StringReader(XML.Trim());
            XmlReader    Reader          = XmlReader.Create(XMLStringReader);
            //XmlWriter Writer = XmlWriter.Create(OutXml);
            StringWriter  OutXml         = new StringWriter();
            XmlTextWriter Writer         = new XmlTextWriter(OutXml);
            int           ParameterCount = 0;
            bool          Read           = true;
            bool          NextRead       = false;

            while (Read)
            {
                if (!NextRead)
                {
                    Read = Reader.Read();
                }
                NextRead = false;
                if (!Read)
                {
                    continue;
                }
                if (Reader.IsStartElement())
                {
                    Writer.WriteStartElement(Reader.Name);
                    if (Reader.HasAttributes)
                    {
                        Writer.WriteAttributes(Reader, false);
                    }
                    Read = Reader.Read();
                    if (Reader.NodeType == XmlNodeType.EndElement)
                    {
                        if (ParameterCount == InjectionPosition)
                        {
                            Writer.WriteString(Payload);
                        }
                        else
                        {
                            Writer.WriteString("");
                        }
                        ParameterCount++;
                        Writer.WriteEndElement();
                    }
                    else
                    {
                        NextRead = true;
                    }
                }
                else
                {
                    if (Reader.NodeType == XmlNodeType.EndElement)
                    {
                        Writer.WriteEndElement();
                    }
                    else
                    {
                        if (ParameterCount == InjectionPosition)
                        {
                            Writer.WriteString(Payload);
                        }
                        else
                        {
                            Writer.WriteString(Reader.Value);
                        }
                        ParameterCount++;
                    }
                }
            }
            Reader.Close();
            Writer.Close();
            OutXml.Close();
            //string OutXmlString = OutXml.ToString().Split(new string[] { "?>" }, 2, StringSplitOptions.None)[1];
            return(OutXml.ToString());
        }
 public override bool CanDeserialize(XmlReader xmlReader)
 {
     return(xmlReader.IsStartElement("Root", "WorkingHours.xsd"));
 }
Esempio n. 29
0
        /// <summary>
        /// Loads a terrain into the scene from a file.
        /// <see cref="WorldManager.LoadAndGenerateMap"/> should be used unless additional custom modification will be used.
        /// This method only loads the data into memory and does not generate the world from the data.
        /// </summary>
        /// <param name="location">File to load</param>
        /// <remarks>
        /// <see cref="WorldManager.LoadAndGenerateMap"/> should be used instead of this method unless advanced custom work needs to be implimented.
        /// </remarks>
        public static void LoadTerrain(string location)
        {
            WorldManager worldManager = GameObject.FindObjectOfType <WorldManager>();

            if (worldManager == null)
            {
                Debug.LogError("WorldManager not found while attempting to load the game. \n Game load failed. ");
                return;
            }

            bool startedGen = false;

            using (XmlReader reader = XmlReader.Create(location + ".xml"))
            {
                while (reader.Read())
                {
                    if (reader.IsStartElement())
                    {
                        switch (reader.Name)
                        {
                        case "WorldManager":
                            worldManager.useCivGridCamera   = XmlConvert.ToBoolean(reader["useCivGridCamera"]);
                            worldManager.useWorldTypeValues = XmlConvert.ToBoolean(reader["usePresetWorldValue"]);
                            worldManager.worldType          = (WorldType)XmlConvert.ToInt32(reader["worldType"]);
                            worldManager.mapSize            = new Vector2(XmlConvert.ToInt32(reader["mapSizeX"]), XmlConvert.ToInt32(reader["mapSizeY"]));
                            worldManager.chunkSize          = XmlConvert.ToInt32(reader["chunkSize"]);
                            worldManager.hexRadiusSize      = (float)XmlConvert.ToDouble(reader["hexRadiusSize"]);
                            worldManager.mountainHeightMap  = FileUtility.LoadTexture("Base_Mountain_Map");
                            break;

                        case "CivGridCamera":

                            worldManager.civGridCamera.enableWrapping = XmlConvert.ToBoolean(reader["enableWrapping"]);
                            worldManager.civGridCamera.cameraHeight   = (float)XmlConvert.ToDouble(reader["cameraHeight"]);
                            worldManager.civGridCamera.cameraAngle    = (float)XmlConvert.ToDouble(reader["cameraAngle"]);
                            worldManager.civGridCamera.cameraSpeed    = (float)XmlConvert.ToDouble(reader["cameraSpeed"]);
                            break;

                        case "Chunk":
                            if (startedGen == false)
                            {
                                worldManager.GenerateNewMap(false);
                                startedGen = true;
                            }
                            break;

                        case "Hexagon":
                            Hex hex = worldManager.hexChunks[XmlConvert.ToInt32(reader["xParentChunk"]), XmlConvert.ToInt32(reader["yParentChunk"])].hexArray[XmlConvert.ToInt32(reader["xHexLoc"]), XmlConvert.ToInt32(reader["yHexLoc"])];

                            hex.terrainType    = worldManager.tileManager.TryGetTile(reader["type"]);
                            hex.terrainFeature = (Feature)XmlConvert.ToInt32(reader["feature"]);
                            hex.parentChunk    = worldManager.hexChunks[XmlConvert.ToInt32(reader["xParentChunk"]), XmlConvert.ToInt32(reader["yParentChunk"])];

                            //rectLocation
                            hex.currentRectLocation = new Rect((float)XmlConvert.ToDouble(reader["rLeft"]), (float)XmlConvert.ToDouble(reader["rTop"]), (float)XmlConvert.ToDouble(reader["rWidth"]), (float)XmlConvert.ToDouble(reader["rHeight"]));

                            hex.currentResource = worldManager.resourceManager.TryGetResource(reader["resource"]);

                            hex.currentImprovement = worldManager.improvementManager.TryGetImprovement(reader["improvement"]);
                            break;

                            #region VoidedManagers

                            /*
                             #region TileManager
                             * case "TileManager":
                             *  Debug.Log("opening tile manager");
                             *  break;
                             * case "Tiles":
                             *  Debug.Log("finding tiles");
                             *  break;
                             * case "NewTile":
                             *  Debug.Log("adding Tile: " + reader["name"]);
                             *  tileManager.AddTile(new Tile(reader["name"], XmlConvert.ToBoolean(reader["isShore"]), XmlConvert.ToBoolean(reader["isOcean"]), XmlConvert.ToBoolean(reader["isMountain"]), (float)XmlConvert.ToDouble(reader["bottomLongitude"]), (float)XmlConvert.ToDouble(reader["topLongitude"])));
                             *  break;
                             #endregion
                             #region ResourceManager
                             * case "ResourceManager":
                             *  Debug.Log("opening resource manager");
                             *  break;
                             * case "Resources":
                             *  Debug.Log("opening resources");
                             *  break;
                             * case "NewResource":
                             *  string loc1 = reader["meshToSpawn"];
                             *  string loc2 = reader["meshTexture"];
                             *
                             *  List<int> possibleTiles = new List<int>();
                             *  List<Feature> possibleFeatures = new List<Feature>();
                             *
                             *  for(int i = 0; i < XmlConvert.ToInt32(reader["numOfPossibleTiles"]); i++)
                             *  {
                             *      possibleTiles.Add(XmlConvert.ToInt32(reader["possibleTile" + i]));
                             *  }
                             *
                             *  for (int i = 0; i < XmlConvert.ToInt32(reader["numOfPossibleFeatures"]); i++)
                             *  {
                             *      possibleFeatures.Add((Feature)System.Enum.Parse(typeof(Feature), reader["possibleFeature" + i]));
                             *  }
                             *
                             *  resourceManager.resources.Add(new Resource(
                             *      reader["name"],
                             *      ((float)XmlConvert.ToDouble(reader["rarity"])),
                             *      XmlConvert.ToInt32(reader["spawnAmount"]),
                             *      ((Mesh)AssetDatabase.LoadAssetAtPath(loc1, typeof(Mesh))),
                             *      ((Texture2D)AssetDatabase.LoadAssetAtPath(loc2, typeof(Texture2D))),
                             *      XmlConvert.ToBoolean(reader["replaceGroundTexture"]), new ResourceRule(possibleTiles.ToArray(), possibleFeatures.ToArray())));
                             *  break;
                             #endregion
                             */
                            #endregion
                        default:
                            //Debug.Log("unhandled exception: " + reader.Name);
                            break;
                        }
                    }
                }
            }

            foreach (Chunk chunk in worldManager.hexChunks)
            {
                chunk.StartHexGeneration();
                foreach (Hex hex in chunk.hexArray)
                {
                    if (hex.currentResource.name != "None")
                    {
                        worldManager.resourceManager.SpawnResource(hex, hex.currentResource, true);
                    }
                    if (hex.currentImprovement.name != "None")
                    {
                        worldManager.improvementManager.AddImprovement(hex.currentImprovement);
                    }
                }
            }
        }
Esempio n. 30
0
        /// <summary>
        /// Creates an instance of a DpwsMetadata class.
        /// </summary>
        public DpwsMetadata(XmlReader reader)
        {
            reader.ReadStartElement("Metadata", WsWellKnownUri.WsxNamespaceUri);

            while (reader.IsStartElement("MetadataSection", WsWellKnownUri.WsxNamespaceUri))
            {
                reader.MoveToAttribute("Dialect");
                String dialect = reader.Value;
                reader.MoveToElement();
                reader.Read(); // MetadataSection

                if (dialect == WsWellKnownUri.WsdpNamespaceUri + "/ThisModel")
                {
#if DEBUG
                    int depth = reader.Depth;
#endif
                    this.ThisModel = new DpwsThisModel(reader);
#if DEBUG
                    Microsoft.SPOT.Debug.Assert(XmlReaderHelper.HasReadCompleteNode(depth, reader));
#endif
                }
                else if (dialect == WsWellKnownUri.WsdpNamespaceUri + "/ThisDevice")
                {
#if DEBUG
                    int depth = reader.Depth;
#endif
                    this.ThisDevice = new DpwsThisDevice(reader);
#if DEBUG
                    Microsoft.SPOT.Debug.Assert(XmlReaderHelper.HasReadCompleteNode(depth, reader));
#endif
                }
                else if (dialect == WsWellKnownUri.WsdpNamespaceUri + "/Relationship")
                {
#if DEBUG
                    int depth = reader.Depth;
#endif
                    if (this.Relationship == null)
                    {
                        this.Relationship = new DpwsRelationship(reader);
                    }
                    else
                    {
                        this.Relationship.Append(reader);
                    }

#if DEBUG
                    Microsoft.SPOT.Debug.Assert(XmlReaderHelper.HasReadCompleteNode(depth, reader));
#endif
                }
                else // known dialect
                {
                    reader.Skip();
                }

                reader.ReadEndElement(); // MetadataSection
            }

            if (this.ThisModel == null || this.ThisDevice == null || this.Relationship == null)
            {
                // Metadata must include ThisModel (R2038, R2012), ThisDevice(R2039, R2014),
                // at least one Relationship(R2040, R2029)
                throw new XmlException();
            }

            XmlReaderHelper.SkipAllSiblings(reader); // xs:any

            reader.ReadEndElement();                 // Metadata
        }
Esempio n. 31
0
 private bool _GetToken(XmlReader reader, out string strToken)
 {
     bool fResult = reader.IsStartElement();
     strToken = fResult ? reader.LocalName : null;
     return fResult;
 }
Esempio n. 32
0
        /// <summary>
        /// Load the DOM tree from the Open XML part.
        /// </summary>
        /// <param name="openXmlPart">The part this root element to be loaded from.</param>
        /// <param name="partStream">The stream of the part.</param>
        /// <returns>
        /// Returns true when the part stream is loaded successfully into this root element.
        /// Returns false when the part stream does not contain any xml element.
        /// </returns>
        /// <exception cref="InvalidDataException">Thrown when the part stream contains an incorrect root element.</exception>
        internal bool LoadFromPart(OpenXmlPart openXmlPart, Stream partStream)
        {
            Profiler.CommentMarkProfile(Profiler.MarkId.OpenXmlPartRootElement_LoadFromPart_In);

            if (partStream.Length < 4)
            {
                // The XmlReader.Read() method requires at least four bytes from the data stream in order to begin parsing.
                return(false);
            }

            // set MaxCharactersInDocument to limit the part size on loading DOM.
            this.OpenXmlElementContext.XmlReaderSettings.MaxCharactersInDocument = openXmlPart.MaxCharactersInPart;
            this.OpenXmlElementContext.XmlReaderSettings.DtdProcessing           = DtdProcessing.Prohibit; // set true explicitly for security fix

            using (XmlReader xmlReader = XmlConvertingReaderFactory.Create(partStream, this.OpenXmlElementContext.XmlReaderSettings, openXmlPart.OpenXmlPackage.StrictTranslation))
            {
                this.OpenXmlElementContext.MCSettings = openXmlPart.MCSettings;


                xmlReader.Read();

                if (xmlReader.NodeType == XmlNodeType.XmlDeclaration)
                {
                    string standaloneAttribute = xmlReader.GetAttribute("standalone");
                    if (standaloneAttribute != null)
                    {
                        this._standaloneDeclaration = standaloneAttribute.Equals("yes", StringComparison.OrdinalIgnoreCase);
                    }
                }

                if (!xmlReader.EOF)
                {
                    xmlReader.MoveToContent();
                }

                if (xmlReader.EOF ||
                    XmlNodeType.Element != xmlReader.NodeType ||
                    !xmlReader.IsStartElement())
                {
                    //the stream does NOT contains any xml element.
                    return(false);
                }

                byte nsId;

                if (!NamespaceIdMap.TryGetNamespaceId(xmlReader.NamespaceURI, out nsId) ||
                    nsId != this.NamespaceId ||
                    xmlReader.LocalName != this.LocalName)
                {
                    string elementQName = new XmlQualifiedName(xmlReader.LocalName, xmlReader.NamespaceURI).ToString();
                    string msg          = String.Format(System.Globalization.CultureInfo.CurrentUICulture, ExceptionMessages.Fmt_PartRootIsInvalid, elementQName, this.XmlQualifiedName.ToString());
                    throw new InvalidDataException(msg);
                }

                // remove all children and clear all attributes
                this.OuterXml = string.Empty;
                var mcContextPushed = this.PushMcContext(xmlReader);
                this.Load(xmlReader, this.OpenXmlElementContext.LoadMode);
                if (mcContextPushed)
                {
                    this.PopMcContext();
                }
            }

            Profiler.CommentMarkProfile(Profiler.MarkId.OpenXmlPartRootElement_LoadFromPart_Out);

            return(true);
        }
Esempio n. 33
0
 public override bool CanReadToken(XmlReader reader) => reader?.IsStartElement("UsernameToken", WsSecurityConstants.WsSecurity10.Namespace) == true;
 /* Method to extract the client specific parts of the config file */
 private bool ExtractClientConfig(XmlReader reader)
 {
     try {
         while (reader.Read()) {
             if (reader.IsStartElement()) {
                 if (reader.Name == "client") {
                     client_config.Add(new ClientConfig());
                     while (reader.MoveToNextAttribute()) {
                         if (reader.Name == "name")
                             client_config.Last().name.Add("short_name", reader.Value);
                         else if (reader.Name == "lname")
                             client_config.Last().name.Add("full_name", reader.Value);
                         else
                             Console.WriteLine("Unknown report configuration attribute: " + reader.Name);
                     }
                 }
                 else if (reader.Name == "project")
                     client_config.Last().projects.Add(reader.ReadString());
                 else if (reader.Name == "priority")
                     client_config.Last().priority.Add(reader.ReadString());
                 else if (reader.Name == "email")
                     client_config.Last().email.Add(reader.ReadString());
             }
         }
         return true;
     }
     catch (Exception ex) {
         Console.WriteLine("Exception when extracting client data from config XML: " + ex.Message);
         return false;
     }
 }