Пример #1
0
        public static DescriptionFile ParseFile(string path)
        {
            var res = new DescriptionFile();

            res.relativePath = path;
            using (FileStream headFileStream = new FileStream(path, FileMode.Open)) {
                if (!headFileStream.CanRead)
                {
                    throw new UnityException("Not existed file!");
                }
                var           LineReader = new StreamReader(headFileStream);
                string        line;
                List <string> volumeFile = new List <string>();
                bool          headOver   = false;
                int           lineNo     = 0;
                while ((line = LineReader.ReadLine()) != null)
                {
                    lineNo++;
                    if (!headOver)
                    {
                        if (parseHeadline(res, line, lineNo))
                        {
                            headOver = true;
                        }
                    }
                    else
                    {
                        volumeFile.Add(line);
                    }
                }
                res.volumeData = volumeFile.ToArray();
            }
            return(res);
        }
Пример #2
0
 protected override ThreadedReadTexture readTexture()
 {
     try {
         desc = DescriptionFile.ParseFile(_headFilePath);
         return(new AsyncReader(desc, this));
     } catch (Exception e) {
         throw new UnityException(e.Message);
     }
 }
Пример #3
0
        public override bool Execute()
        {
            if (null == DescriptionFile)
            {
                Log.LogError("DescriptionFile argument must be specified");
                return(false);
            }

            if (String.IsNullOrEmpty(PackageId))
            {
                Log.LogError("PackageId argument must be specified");
                return(false);
            }

            string descriptionPath = DescriptionFile.GetMetadata("FullPath");

            if (!File.Exists(descriptionPath))
            {
                Log.LogError("DescriptionFile '{0}' does not exist", descriptionPath);
                return(false);
            }

            Dictionary <string, string> descriptionTable = null;

            if (!s_descriptionCache.TryGetValue(descriptionPath, out descriptionTable))
            {
                // no cache, load it now.
                descriptionTable = LoadDescriptions(descriptionPath);

                s_descriptionCache[descriptionPath] = descriptionTable;
            }

            string description = null;

            if (descriptionTable != null)
            {
                descriptionTable.TryGetValue(PackageId, out description);
            }

            if (String.IsNullOrEmpty(description))
            {
                Log.LogError("Unable to find description for package {0}", PackageId);
            }

            Description = description;

            return(!Log.HasLoggedErrors);
        }
Пример #4
0
 /// <summary>
 ///
 /// </summary>
 /// <param name="filename"></param>
 public void LoadDescriptionSettings(string filename)
 {
     colName.Items.Clear();
     if (File.Exists(filename))
     {
         descriptionfile = Functions.DeserializeDescriptionFile(filename);
         if (descriptionfile != null)
         {
             foreach (DescriptionItem item in descriptionfile.Items)
             {
                 colName.Sorted = true;
                 colName.Items.Add(item.Name);
             }
         }
     }
 }
Пример #5
0
        public List <DescriptionFile> GetFiles(string sort)
        {
            using (var db = ApplicationDbContext.Create())
            {
                IQueryable <File> dataIP = db.Files;

                switch (sort)
                {
                case "Name":
                    dataIP = dataIP.OrderBy(l => l.Name);
                    break;

                case "NameDesc":
                    dataIP = dataIP.OrderByDescending(l => l.Name);
                    break;

                case "Page":
                    dataIP = dataIP.OrderBy(l => l.NominationPage);
                    break;

                case "PageDesc":
                    dataIP = dataIP.OrderByDescending(l => l.NominationPage);
                    break;

                default:
                    dataIP = dataIP.OrderBy(l => l.Id);
                    break;
                }

                var listIP = dataIP.ToList();
                if (listIP != null)
                {
                    var files = new List <DescriptionFile>();
                    foreach (var item in listIP)
                    {
                        var file = new DescriptionFile();
                        file.Name           = item.Name;
                        file.PathToFile     = item.Path;
                        file.NominationPage = item.NominationPage;
                        files.Add(file);
                    }
                    return(files);
                }
                return(null);
            }
        }
Пример #6
0
        /// <summary>
        /// Fold these in a generic
        /// </summary>
        /// <param name="filename"></param>
        /// <returns></returns>
        public static DescriptionFile DeserializeDescriptionFile(string filename)
        {
            DescriptionFile desc = null;

            if (File.Exists(filename))
            {
                XmlSerializer nser  = new XmlSerializer(typeof(DescriptionFile));
                TextReader    ntext = new StreamReader(filename);
                try {
                    desc = (DescriptionFile)nser.Deserialize(ntext);
                } finally {
                    ntext.Close();
                    ntext.Dispose();
                }
            }

            return(desc);
        }
Пример #7
0
        /// <summary>
        /// Fold these in a generic...
        /// </summary>
        /// <param name="filename"></param>
        /// <param name="descriptionfile"></param>
        /// <returns></returns>
        public static bool SerializeDescriptionFile(string filename, DescriptionFile descriptionfile)
        {
            bool b = false;

            XmlSerializer nser  = new XmlSerializer(typeof(DescriptionFile));
            TextWriter    ntext = new StreamWriter(filename);

            try {
                nser.Serialize(ntext, descriptionfile);
                ntext.Flush();
                b = true;
            } catch {
                b = false;
            } finally {
                ntext.Dispose();
            }

            return(b);
        }
Пример #8
0
        private static bool parseHeadline(DescriptionFile desc, string line, int lineNo)
        {
            var splitted = line.Split(new char[] { ':' }, 2);

            if (splitted.Length == 0)
            {
                return(false);         //nothing this line.
            }
            if (splitted[0][0] == '=') //divide line, means the following lines are all volume data.
            {
                return(true);
            }
            if (splitted[0][1] == '#')       //commment line
            {
                return(false);
            }
            var key = splitted[0].Trim().ToLower();   //key

            switch (key)
            {
            case "width":
                if (!int.TryParse(splitted[1].Trim(), out desc.width))
                {
                    throw new UnityException("Problem while parsing line " + lineNo);
                }
                break;

            case "height":
                if (!int.TryParse(splitted[1].Trim(), out desc.height))
                {
                    throw new UnityException("Problem while parsing line " + lineNo);
                }
                break;

            case "depth":
                if (!int.TryParse(splitted[1].Trim(), out desc.depth))
                {
                    throw new UnityException("Problem while parsing line " + lineNo);
                }
                break;

            case "bytecount":
                if (!int.TryParse(splitted[1].Trim(), out desc.byteCount))
                {
                    throw new UnityException("Problem while parsing line " + lineNo);
                }
                break;

            case "gradientscale":
                if (!float.TryParse(splitted[1].Trim(), out desc.gradientScale))
                {
                    throw new UnityException("Problem while parsing line " + lineNo);
                }
                break;

            case "albedo":
                desc.albedoTex = splitted[1].Trim();
                break;

            case "metallic":
                desc.metallicTex = splitted[1].Trim();
                break;

            default:
                break;
            }

            return(false);
        }
Пример #9
0
    public static VolumeDataInfo ReadFromFile(DescriptionFile desc, IAsyncReaderProgressNotifier notifier)
    {
        var twidth  = CeilToBinary(desc.width);
        var theight = CeilToBinary(desc.height);
        var tdepth  = CeilToBinary(desc.depth);

        var fileData = new int[twidth * theight * tdepth];

        FileStream currentFile = null;
        bool       flag        = false;

        int?minData         = null;
        int?maxData         = null;
        int volumeFileIndex = 0;

        for (int z = 0; z < desc.depth; z++)
        {
            if (flag)
            {
                break;
            }
            for (int y = 0; y < desc.height; y++)
            {
                if (flag)
                {
                    break;
                }
                for (int x = 0; x < desc.width; x++)
                {
                    if (currentFile == null)
                    {
                        if (volumeFileIndex < desc.volumeData.Length)   //we have next file
                        {
                            var nextFilePath = desc.volumeData[volumeFileIndex++];
                            currentFile = new FileStream(desc.relativePath + "/../" + nextFilePath, FileMode.Open);
                            if (notifier != null)
                            {
                                notifier.Notify("Reading file.. : " + nextFilePath);
                            }
                        }
                        else     //all input finished.

                        {
                            flag = true;
                            break;
                        }
                    }

                    //read it.
                    byte[] byData = new byte[desc.byteCount];
                    if (currentFile.Read(byData, 0, desc.byteCount) == 0)
                    {
                        x--;
                        currentFile.Close();
                        currentFile = null;
                        continue;
                    }
                    int data = 0;
                    for (int i = 0; i < desc.byteCount; i++)
                    {
                        data <<= 8;
                        data  += byData[i];
                    }
                    fileData[x + y * twidth + z * twidth * theight] = data;
                    if (minData == null)
                    {
                        minData = data;
                    }
                    else
                    {
                        minData = Mathf.Min(minData.Value, data);
                    }
                    if (maxData == null)
                    {
                        maxData = data;
                    }
                    else
                    {
                        maxData = Mathf.Max(maxData.Value, data);
                    }
                }
            }
        }

        var result = new VolumeDataInfo(twidth, theight, tdepth);

        for (int i = 0; i < twidth; i++)
        {
            notifier.Notify("Filling texture...(" + (int)((float)i / twidth * 100) + "%)");
            for (int j = 0; j < theight; j++)
            {
                for (int k = 0; k < tdepth; k++)
                {
                    var data = (float)fileData[i + j * twidth + k * theight * twidth] / (maxData.Value - minData.Value);
                    result[i, j, k] = new Color(data, data, data, data);
                }
            }
        }
        return(result);
    }
Пример #10
0
 public AsyncReader(DescriptionFile descFile, IAsyncReaderProgressNotifier notifier)
 {
     this.descFile = descFile;
     this.notifier = notifier;
 }
Пример #11
0
 public LogsViewModel()
 {
     ip = new ListIP();
     descriptionFile = new DescriptionFile();
 }