public ResolutionAnalyzer(Files.LocatorFile file,
     int interpolationRange, int analyzedSamples)
 {         
     _file = file;
     _interpolationRange = interpolationRange;
     _analyzedSamples = analyzedSamples;
 }

        public IRestApiType GetFiles()
        {
            try
            {
                RestApiHelper client = new RestApiHelper()
                {
                    EndPoint = _GETUri,
                    Method = RestApiHelper.HttpVerb.GET,
                    GrantedToken = this.GrantedToken,
                    Parameters = "?list=true"
                };
                var json = client.SendRequest();
                var obj = JsonHelper.ParseJson<DropboxRestApiType.File>(json);

                // Convert DropboxRest File.Contents type to RestApi.Files type (IRestApiType)
                Files files = new Files();
                foreach (var f in obj.Contents)
                {
                    files.files.Add(
                        new RestApi.File()
                        {
                            id = f.Revision,
                            filename = f.Path.Replace("/", ""),
                            path = f.Path,
                            size = f.Size
                        }
                    );
                } 
                return files;
            }
            catch (Exception ex)
            {
                throw new Exception("Fail to get all documents, error: " + ExceptionHelper.ExtractAll(ex));
            }
        }

        protected void Page_Load(object sender, EventArgs e)
        {
            try
            {
                FilesBLL bll = new FilesBLL();
                Files f = new Files();
                int id;
                string filePath;
                string fileName;
                id = Convert.ToInt32(Request.QueryString["id"]);
                f.FUrl = bll.GetFileById(id).FUrl;
                f.FRName = bll.GetFileById(id).FRName;
                filePath = Server.MapPath(f.FUrl);//路径
                fileName = f.FRName;//客户端保存的文件名
                FileStream fs = new FileStream(filePath, FileMode.Open);
                byte[] bytes = new byte[(int)fs.Length];
                //以字符流的形式下载文件
                fs.Read(bytes, 0, bytes.Length);
                fs.Close();
                Response.ContentType = "application/octet-stream";
                //通知浏览器下载文件而不是打开
                Response.AddHeader("Content-Disposition", "attachment; filename=" + HttpUtility.UrlEncode(fileName, System.Text.Encoding.UTF8));
                Response.BinaryWrite(bytes);
                Response.Flush();
                Response.End();

            }
            catch (IOException)
            {

                throw;
            }
        }

 public override Behaviors.CrossAppCommunication.PointSharer.MulticastPointSharer Create(Files.LocatorFile file,
     Behaviors.CrossAppCommunication.ICrossAppExchange server, int guid)
 {
     var header = (Headers.Concrete.Rl8.Rl8Header)file.Header;
     return new Behaviors.CrossAppCommunication.PointSharer.MulticastPointSharer(server, guid,
         header.HeaderStruct.rlParams.sx, header.HeaderStruct.rlParams.sy);
 }

 public Aligning(Files.LocatorFile file, PointSelector.CompressedPointSelectorWrapper selector,
     Behaviors.ImageAligning.IInterpolationProvider rcsProvider,
     Behaviors.ImageAligning.Surfaces.SurfaceType surfaceType, int baseRadius, int layers, double lambda)
 {
     _file = file;
     _selector = selector;
     _surface = Factories.Surface.SurfaceFactory.CreateSurface(_selector, rcsProvider, surfaceType, baseRadius, layers, lambda);
 }

        private static bool CheckBaExt(Files.LocatorFile file)
        {
            var rliInfo = file.Header.HeaderInfo.Where(x => x.HeaderName == "РГГ")
                .FirstOrDefault();

            string rhgName = rliInfo.Params.Where(x => x.Item1 == "Имя файла").FirstOrDefault().Item2;

            return Path.GetExtension(rhgName) == ".ba";
        }

        /// <summary>
        /// Checks if RLI has .ba RHG as its source
        /// </summary>
        /// <param name="rliFile">Rli to check</param>
        /// <returns></returns>
        public static bool HasBaRhgSource(Files.LocatorFile rliFile)
        {
            if (rliFile == null)
            {
                return false;
            }

            return CheckBaExt(rliFile);
        }

        public StatisticsForm(Files.LocatorFile file, Behaviors.AreaSelector.AreaSelector areaSelector)
        {
            InitializeComponent();
         
            var dgv = FormsHelper.GetDataGrid(this, "Параметр", "Значение");
            this.Controls.Add(dgv);

            var statsInfo = GetStatistics(file, areaSelector);
            ShowInfo(statsInfo, dgv);
        }

        public static bool Open(Files file)
        {
            if (File.Exists(file.ToString() + ".pdf"))
            {
                Process.Start(file.ToString() + ".pdf");
                return true;
            }

            return false;
        }

        void CopyScript(string rootPath, Files.File scriptFile)
        {
            var target = rootPath + scriptFile;
            var script = scriptFile.ReadAllText();
				//File.ReadAllText(scriptFile);

            var dir = Path.GetDirectoryName(target);
            if (!Directory.Exists(dir))
                Directory.CreateDirectory(dir);

            File.WriteAllText(target, script, Encoding.ASCII);
        }

 public static void AddLogMessage(DataType dataType, Files.FileOperationResult fileResult, bool isSave)
 {
     //自動バックアップを開始します
     //[読込]config : 成功 (2015/6/1 13:12:05)
     //[保存]config : 成功 (2015/6/1 13:12:07)
     //[保存]Material : 失敗 ErrorReason (2015/6/1 13:12:75)
     string mode = isSave ? "保存" : "読込";
     string issuccess = fileResult.IsSuccess ? "成功" : "失敗";
     string str = string.Format("[{0}]{1} : {2} {3} ({4})",
         mode, dataType.ToString(), issuccess,
         fileResult.ErrorReason, DateTime.Now.ToString());
     LogMessage.Add(str);
 }

        public override byte[] ResampleImage(Files.LocatorFile file, System.Drawing.Rectangle area)
        {
            float[] image = new float[area.Width * area.Height];

            float[] imageArea = file.GetArea(area).ToArea<float>(file.Header.BytesPerSample);

            int toInclusiveX = area.Location.X + area.Width;
            toInclusiveX = toInclusiveX > file.Width ? file.Width : toInclusiveX;

            int toInclusiveY = area.Location.Y + area.Height;
            toInclusiveY = toInclusiveY > file.Height ? file.Height : toInclusiveY;
            int counter = 0;

            var rcsSolution = GetRcsSolution(area);
            var amplitudeSolution = GetAmplitudeSolution(area);

            Parallel.For(area.Location.X, toInclusiveX, (i, loopState) =>
            {
                for (int j = area.Location.Y; j < toInclusiveY; j++)
                {

                    var oldAmplVal = imageArea[(j - area.Y) * area.Width + (i - area.X)];
                    var newAmplVal = (float)amplitudeSolution[i - area.X, j - area.Y];
                    var newRcsVal = (float)rcsSolution[i - area.X, j - area.Y];
                    var diff = oldAmplVal / newAmplVal * newRcsVal;

                    diff = diff < 0 ? 0 : diff;
                    image[(j - area.Location.Y) * area.Width + (i - area.Location.X)] = diff;
                }

                System.Threading.Interlocked.Increment(ref counter);
                OnProgressReport((int)(counter / Math.Ceiling((double)(toInclusiveX - area.Location.X)) * 100));

                if (OnCancelWorker())
                {
                    loopState.Break();
                }

            });

            if (Cancelled)
            {
                return null;
            }

            byte[] imageB = new byte[image.Length * 4];

            Buffer.BlockCopy(image, 0, imageB, 0, imageB.Length);

            return imageB;
        }

 public static Behaviors.ImageMirroring.Abstract.ImageMirrorer Create(Files.LocatorFile sourceFile)
 {
     switch (sourceFile.Properties.Type)
     {
         case FileType.brl4:
             return new Behaviors.ImageMirroring.Concrete.Brl4ImageMirrorer(sourceFile);
         case FileType.rl4:
             return new Behaviors.ImageMirroring.Concrete.Rl4ImageMirrorer(sourceFile);
         case FileType.rl8:
             return new Behaviors.ImageMirroring.Concrete.Rl8ImageMirrorer(sourceFile);
         default:
             throw new NotImplementedException("Image mirrorer");
     }
 }

        private IEnumerable<Tuple<string, string>> GetStatistics(Files.LocatorFile file, Behaviors.AreaSelector.AreaSelector areaSelector)
        {
            var maxSample = file.GetMaxSample(
                            new Rectangle(areaSelector.Area.Location.X, areaSelector.Area.Location.Y,
                            areaSelector.Area.Width, areaSelector.Area.Height));

            var minSample = file.GetMinSample(
                    new Rectangle(areaSelector.Area.Location.X, areaSelector.Area.Location.Y,
                    areaSelector.Area.Width, areaSelector.Area.Height));

            var maxSampleLoc = file.GetMaxSampleLocation(
                new Rectangle(areaSelector.Area.Location.X, areaSelector.Area.Location.Y,
                    areaSelector.Area.Width, areaSelector.Area.Height));

            var minSampleLoc = file.GetMinSampleLocation(
                new Rectangle(areaSelector.Area.Location.X, areaSelector.Area.Location.Y,
                    areaSelector.Area.Width, areaSelector.Area.Height));

            var avgSample = file.GetAvgSample(
                new Rectangle(areaSelector.Area.Location.X, areaSelector.Area.Location.Y,
                    areaSelector.Area.Width, areaSelector.Area.Height));


            List<Tuple<string, string>> statistics = new List<Tuple<string, string>>()
                {
                    new Tuple<string, string>("Имя файла", System.IO.Path.GetFileName(file.Properties.FilePath)),
                    new Tuple<string, string>("X1", areaSelector.Area.Location.X.ToString()),
                    new Tuple<string, string>("Y1", areaSelector.Area.Location.Y.ToString()),
                    new Tuple<string, string>("X2", (areaSelector.Area.Location.X + areaSelector.Area.Width).ToString()),
                    new Tuple<string, string>("Y2", (areaSelector.Area.Location.Y + areaSelector.Area.Height).ToString()),
                    new Tuple<string, string>("Ширина фрагмента", areaSelector.Area.Width.ToString()),
                    new Tuple<string, string>("Высота фрагмента", areaSelector.Area.Height.ToString()),
                    new Tuple<string, string>("Максимальная амплитуда", maxSample.ToString()),
                    new Tuple<string, string>("Xmax", maxSampleLoc.X.ToString()),
                    new Tuple<string, string>("Ymax", maxSampleLoc.Y.ToString()),
                    new Tuple<string, string>("Минимальная амплитуда", minSample.ToString()),
                    new Tuple<string, string>("Xmin", minSampleLoc.X.ToString()),
                    new Tuple<string, string>("Ymin", minSampleLoc.Y.ToString()),
                    new Tuple<string, string>("Средняя амплитуда", avgSample.ToString())
                };

            return statistics;
        }

 public static AreaSizeCalcFactory GetFactory(Files.FileProperties properties)
 {
     switch (properties.Type)
     {
         case FileType.brl4:
             return new Concrete.Brl4SizeCalcFactory();
         case FileType.rl4:
             return new Concrete.Rl4SizeCalcFactory();
         case FileType.raw:
             return new Concrete.RawSizeCalcFactory();
         case FileType.r:
             return new Concrete.RSizeCalcFactory();
         case FileType.k:
             return new Concrete.KSizeCalcFactory();
         case FileType.rl8:
             return new Concrete.Rl8SizeCalcFactory();
         default:
             throw new NotSupportedException("Unsupported file format");
     }
 }

        public LuceneSearch.FileToIndex AddFile(string name, int dis, string auth, string tags, string comm)
        {
            var file = new Files
            {
                Path = Repository.Path,
                Size = Repository.Size
            };
            db.Files.Add(file);
            db.SaveChanges();

            var work = new Work
            {
                Date = DateTime.Now,
                Descipline = dis + 1,
                Hashtags = tags,
                Documet = file.Id,
                Authors = auth,
                Uploader = Repository.User.Login,
                University = Repository.User.University,
                Name = name,
                Description = comm

            };
            db.Work.Add(work);
            db.SaveChanges();

            var disc = db.Discipline.Where(c => c.Id == dis + 1).Select(c => c.Name);

            return new LuceneSearch.FileToIndex
            {
                Id = work.Id,
                Text = GetDocText(Path.GetFullPath(file.Path)),
                Description = comm,
                Authors = auth,
                Title = name,
                Hashtags = tags,
                Discipline = disc.ToArray()[0]

            };
        }

        public string Create(string filePath, string fileName, int cID, int fileclass)
        {
            int fID = db.Files.AsEnumerable().Select(x => x.FileID).DefaultIfEmpty(0).Max(x => x) + 1;
            string ret = "false";
            try
            {
                Files file = new Files();
                file.CID = cID;
                file.Class = fileclass;
                file.FileID = fID;
                file.FileAddr = filePath;
                file.FileName = fileName;

                db.Files.Add(file);
                db.SaveChanges();
                ret = "true";
            }
            catch
            {
            }
            return ret;
        }

        public Stream GetFileStream(Files.Core.File file, long offset)
        {
            //NOTE: id here is not converted!
            var fileToDownload = GetFileById(file.ID);
            //Check length of the file
            if (fileToDownload == null)
                throw new ArgumentNullException("file", Web.Files.Resources.FilesCommonResource.ErrorMassage_FileNotFound);

            //if (fileToDownload.Length > SetupInfo.AvailableFileSize)
            //{
            //    throw FileSizeComment.FileSizeException;
            //}

            var fileStream = fileToDownload.GetDataTransferAccessor().GetDownloadStream();

            if (fileStream.CanSeek)
                file.ContentLength = fileStream.Length; // hack for google drive

            if (offset > 0)
                fileStream.Seek(offset, SeekOrigin.Begin);

            return fileStream;
        }

 //修改图片信息
 //protected void photos_save_Click(object sender, EventArgs e)
 //{
 //    PhotosBLL bll = new PhotosBLL();
 //    Photos photos = new Photos();
 //    photos.P_Info = photos_info.Text;
 //    photos.P_Url = Common.photoid;
 //    if (bll.Modify(photos))
 //    {
 //        Response.Redirect(HttpUtility.UrlDecode(Request.QueryString["url"].ToString()));
 //    }
 //    else
 //    {
 //        ClientScript.RegisterStartupScript(GetType(), "", "alert('修改失败');", true);
 //    }
 //}
 /// <summary>
 /// 上传文件
 /// </summary>
 /// <param name="sender"></param>
 /// <param name="e"></param>
 protected void btnfileload_Click(object sender, EventArgs e)
 {
     if (FileUpload.HasFile)
     {
         try
         {
             FilesBLL bll = new FilesBLL();
             Files file = new Files();
             string serverPath = Server.MapPath("/FileSave");
             if (!Directory.Exists(serverPath))
             {
                 Directory.CreateDirectory(serverPath);
             }
             string fileName = FileUpload.FileName;
             string newPath = serverPath + "\\" + fileName;
             file.FRName = fileName;
             FileUpload.SaveAs(newPath);
             file.FUrl = "FileSave/" + fileName;
             file.FSize = Convert.ToInt32(FileUpload.FileContent.Length / 1000);
             file.FUserId = Convert.ToInt32(cookieRead("id"));
             file.FName = file_info.Text;
             if (file.FName.Equals(""))
             {
                 file.FName = fileName;
             }
             bll.AddFiles(file);
             tagContent5.Style["display"] = "block";
             tagContent0.Style["display"] = "none";
             ClientScript.RegisterStartupScript(GetType(), "", "alert('上传成功');", true);
         }
         catch (Exception)
         {
             ClientScript.RegisterStartupScript(GetType(), "", "alert('上传失败');", true);
         }
     }
 }

        //Generic procedure to read and parse Standardization.DB (&others..soon)
        public int SQLAccess(string cmd)
        {
            //var DB_Path = txt_DBFolder.Text + "\\Files.mdb;";
            //Files[] files = new Files[10000];

            var MaximumSize = 0;

            //rtxt_StatisticsOnReadDLCs.Text += "\n  ee= ";
            try
            {
            MessageBox.Show(DB_Path);
            using (OleDbConnection cnn = new OleDbConnection("Provider=Microsoft.Jet.OLEDB.12.0;Data Source=" + DB_Path))
            {
                DataSet dus = new DataSet();
                OleDbDataAdapter dax = new OleDbDataAdapter(cmd, cnn); //WHERE id=253
                dax.Fill(dus, "Standardization");

                var i = 0;
                //rtxt_StatisticsOnReadDLCs.Text += "\n  54= " +dus.Tables[0].Rows.Count;
                MaximumSize = dus.Tables[0].Rows.Count;
                foreach (DataRow dataRow in dus.Tables[0].Rows)
                {
                    files[i] = new Files();

                    //rtxt_StatisticsOnReadDLCs.Text += "\n  a= " + i + MaximumSize+dataRow.ItemArray[0].ToString();
                    files[i].ID = dataRow.ItemArray[0].ToString();
                    files[i].Artist = dataRow.ItemArray[2].ToString();
                    files[i].Artist_Correction = dataRow.ItemArray[3].ToString();
                    files[i].Album = dataRow.ItemArray[4].ToString();
                    files[i].Album_Correction = dataRow.ItemArray[5].ToString();
                    files[i].AlbumArtPath_Correction = dataRow.ItemArray[6].ToString();
                    i++;
                }
                //Closing Connection
                dax.Dispose();
                cnn.Close();
                //rtxt_StatisticsOnReadDLCs.Text += i;
                //var ex = 0;
            }
            }
            catch (System.IO.FileNotFoundException ee)
            {
            MessageBox.Show(ee.Message + "Can not open Standardization DB connection ! ");
            //MessageBox.Show(ee.Message, MESSAGEBOX_CAPTION, MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
            //rtxt_StatisticsOnReadDLCs.Text += "\n  max rows" + MaximumSize;
            return MaximumSize;//files[10000];
        }