//private void CreateAggregatedFile(string aggregatedFile, params string[] sourceFilesNames)
//{
// using (var aggregateStream = File.Open(aggregatedFile, FileMode.OpenOrCreate, FileAccess.Write, FileShare.ReadWrite))
// {
// List<Files.LocatorFile> sourceFiles = new List<Files.LocatorFile>(sourceFilesNames.Length);
// foreach (var filePath in sourceFilesNames.OrderBy(x => x))
// {
// var fileProp = new Files.FileProperties(filePath);
// var header = Factories.Header.Abstract.HeaderFactory.GetFactory(fileProp).Create(filePath);
// var file = Factories.File.Abstract.FileFactory.GetFactory(fileProp).Create(fileProp, header, null);
// sourceFiles.Add(file);
// }
// int index = 0;
// foreach (var file in sourceFiles)
// {
// using (var sourceStream = File.Open(file.Properties.FilePath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
// {
// byte[] dataString = new byte[file.Width * file.Header.BytesPerSample + file.Header.FileHeaderLength];
// while (sourceStream.Position != sourceStream.Length)
// {
// sourceStream.CopyTo(aggregateStream);
// OnProgressReport((int)(++index / (float)sourceFiles.Count * 100));
// if (OnCancelWorker())
// {
// return;
// }
// }
// }
// }
// }
//}
private void CreateAggregatedFile(string aggregatedFile, params string[] sourceFilesNames)
{
using (var aggregateStream = File.Open(aggregatedFile, FileMode.OpenOrCreate, FileAccess.Write, FileShare.ReadWrite))
{
List<Files.LocatorFile> sourceFiles = new List<Files.LocatorFile>(sourceFilesNames.Length);
foreach (var filePath in sourceFilesNames)
{
var fileProp = new Files.FileProperties(filePath);
var header = Factories.Header.Abstract.HeaderFactory.GetFactory(fileProp).Create(filePath);
var file = Factories.File.Abstract.FileFactory.GetFactory(fileProp).Create(fileProp, header, null);
sourceFiles.Add(file);
}
float totalLines = sourceFiles.Select(x => x.Height).Sum();
int index = 0;
foreach (var file in sourceFiles)
{
using (var sourceStream = File.Open(file.Properties.FilePath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
{
byte[] dataString = new byte[file.Width * file.Header.BytesPerSample + file.Header.FileHeaderLength];
while (sourceStream.Position != sourceStream.Length)
{
sourceStream.Read(dataString, 0, dataString.Length);
aggregateStream.Write(dataString, 0, dataString.Length);
OnProgressReport((int)(index / totalLines * 100));
if (OnCancelWorker())
{
return;
}
index++;
}
}
}
}
}
private async void FillDataGrid()
{
List<HeaderInfoOutput> headerInfos = new List<HeaderInfoOutput>();
string[] files = null;
try
{
files = Directory.GetFiles(treeView1.SelectedNode == null ? GetFullName(treeView1.Nodes[0])
: GetFullName(treeView1.SelectedNode));
}
catch (IOException)
{
return;
}
var locatorFiles = await GetLocatorFiles(files);
foreach (var file in locatorFiles)
{
try
{
var props = new Files.FileProperties(file);
var header = (props.Type == FileType.raw) ? null :
Factories.Header.Abstract.HeaderFactory.GetFactory(props).Create(file);
headerInfos.Add(Factories.FilePreview.Abstract.FilePreviewFactory.GetFactory(props)
.Create(file, header).GetPreview());
}
catch (Exception ex)
{
Logging.Logger.Log(Logging.SeverityGrades.Internal, string.Format("Error in file preview: {0}", ex));
}
}
dataGridView1.Rows.Clear();
for (int i = 0; i < headerInfos.Count; i++)
{
dataGridView1.Rows.Add();
dataGridView1.Rows[i].Cells[0].Value = Path.GetFileNameWithoutExtension(headerInfos[i].HeaderName);
dataGridView1.Rows[i].Cells[1].Value = Path.GetExtension(headerInfos[i].HeaderName);
for (int j = 1; j < headerInfos[i].Params.Count(); j++)
{
dataGridView1.Rows[i].Cells[j + 1].Value = headerInfos[i].Params.ToArray()[j].Item2;
}
}
}
private DocX PrepareReport(string reportFilePath, string locatorFilePath, ReporterSettings reporterSettings)
{
DocX document = DocX.Create(reportFilePath);
var prop = new Files.FileProperties(locatorFilePath);
var fileHeader = Factories.Header.Abstract.HeaderFactory.GetFactory(prop)
.Create(locatorFilePath);
var file = Factories.File.Abstract.FileFactory.GetFactory(prop)
.Create(prop, fileHeader, null);
Paragraph p = document.InsertParagraph();
p.Alignment = Alignment.center;
p.Append(System.IO.Path.GetFileName(locatorFilePath)).Bold().FontSize(20)
.Append(Environment.NewLine)
.Append(Environment.NewLine);
if (reporterSettings.AddArea)
{
p.Append(string.Format("Площадь засвеченной поверхности: {0}км2",
(Factories.AreaSizeCalc.Abstract.AreaSizeCalcFactory.GetFactory(file
.Properties).Create(file.Header).CalculateArea(file.Width, file.Height) / 1000 / 1000)
.ToString(".################################")))
.Append(Environment.NewLine);
}
var cornerCoord = Factories.CornerCoords.Abstract.CornerCoordFactory
.GetFactory(file.Properties)
.Create(file, reporterSettings.FirstLineOffset, reporterSettings.LastLineOffset, reporterSettings.ReadToEnd);
if (reporterSettings.AddTimes)
{
Paragraph timesParagraph = document.InsertParagraph();
timesParagraph.Alignment = Alignment.left;
foreach (var entry in cornerCoord.GetZoneStartAndEndTimes())
{
timesParagraph.Append(string.Format("{0}: {1}", entry.Item1, entry.Item2));
timesParagraph.Append(Environment.NewLine);
}
}
if (reporterSettings.AddCenter)
{
Paragraph cornersParagraph = document.InsertParagraph();
cornersParagraph.Alignment = Alignment.left;
foreach (var entry in cornerCoord.GetCenterCoordinates())
{
cornersParagraph.Append(string.Format("{0}: {1}", entry.Item1, entry.Item2));
cornersParagraph.Append(Environment.NewLine);
}
}
if (reporterSettings.AddCorners)
{
Paragraph cornersParagraph = document.InsertParagraph();
cornersParagraph.Alignment = Alignment.left;
foreach (var entry in cornerCoord.GetCoornerCoordinates())
{
cornersParagraph.Append(string.Format("{0}: {1}", entry.Item1, entry.Item2));
cornersParagraph.Append(Environment.NewLine);
}
}
if (reporterSettings.AddParametersTable)
{
foreach (var subHeaderInfo in file.Header.HeaderInfo)
{
var headerTable = PrepareHeaderInfoTable(document, subHeaderInfo);
headerTable.AutoFit = AutoFit.Window;
document.InsertTable(headerTable);
}
}
return document;
}
private void loaderWorker_InitFile(object sender, System.ComponentModel.DoWorkEventArgs e)
{
try
{
_properties = new Files.FileProperties((string)e.Argument);
_header = Factories.Header.Abstract.HeaderFactory.GetFactory(_properties).Create(_properties.FilePath);
_navi = Factories.NavigationContainer.Abstract.NavigationContainerFactory.GetFactory(_properties).Create(_properties, _header);
_navi.Report += (s, pe) => ProgressReporter(pe.Percent);
_navi.CancelJob += (s, ce) => ce.Cancel = _navi.Cancelled;
_navi.ReportName += (s, tne) => ThreadHelper.ThreadSafeUpdateToolStrip<ToolStripStatusLabel>(_form.StatusLabel, lbl => { lbl.Text = tne.Name; });
_cancellableAction = _navi;
_navi.GetNavigation();
}
catch (OperationCanceledException)
{
e.Cancel = true;
return;
}
_file = FileFactory.GetFactory(_properties).Create(_properties, _header, _navi);
_ruler = new Behaviors.Ruler.RulerProxy(_file);
_saver = SaverFactory.GetFactory(_properties).Create(_file);
_searcher = Factories.NavigationSearcher.Abstract.PointFinderFactory.GetFactory(_file.Properties).Create(_file);
_analyzer = new Behaviors.Analyzing.SampleAnalyzer();
_pointSelector = new Behaviors.PointSelector.PointSelector();
_areaSelector = new Behaviors.AreaSelector.AreaSelector(_file);
_areaAligningWrapper = new Behaviors.AreaSelector.AreaSelectorsAlignerContainer();
if (_pointSharer != null)
{
_pointSharer.DataReceived -= (s, gde) => CrossAppDataReceivedCallback(s, gde);
_pointSharer.Dispose();
}
_pointSharer = Factories.PointSharer.Abstract.PointSharerFactory.GetFactory(_file.Properties).Create(_file,
new Behaviors.CrossAppCommunication.UdpExchange(_settings.MulticastEp, Behaviors.CrossAppCommunication.CommunicationType.Multicast),
System.Diagnostics.Process.GetCurrentProcess().Id);
_pointSharer.DataReceived += (s, gde) => CrossAppDataReceivedCallback(s, gde);
}
private void loaderWorker_AlignImageCompleted(object sender, System.ComponentModel.RunWorkerCompletedEventArgs e)
{
_aligner.Report -= (s, pe) => ProgressReporter(pe.Percent);
_aligner.CancelJob -= (s, ce) => ce.Cancel = _aligner.Cancelled;
if (e.Cancelled)
{
Logging.Logger.Log(Logging.SeverityGrades.Info, string.Format("Image aligning cancelled"));
}
else if (e.Error != null)
{
Logging.Logger.Log(Logging.SeverityGrades.Blocking, string.Format("Error occured while aligning image: {0}", e.Error.Message));
Forms.FormsHelper.ShowErrorMsg("Unable to align image");
}
else
{
var fileName = Path.GetFullPath((string)e.Result);
fileName = Path.ChangeExtension(fileName, "brl4");
var type = new Files.FileProperties(fileName).Type;
if (type != FileType.raw && type != FileType.r)
{
EmbedNavigation(fileName, false);
}
Logging.Logger.Log(Logging.SeverityGrades.Info,
string.Format("Image aligning completed, new file saved at: {0}", fileName));
}
InitProgressControls(false);
}
private void EmbedNavigation(string rliFileName, bool forced = true)
{
var fileToChangeProp = new Files.FileProperties(rliFileName);
var fileToChangeHeader = Factories.Header.Abstract.HeaderFactory.GetFactory(fileToChangeProp).Create(rliFileName);
var fileToChange = Factories.File.Abstract.FileFactory.GetFactory(fileToChangeProp).Create(fileToChangeProp, fileToChangeHeader, null);
if (!forced)
{
if (!Behaviors.Navigation.NavigationChanger.Abstract.NavigationChanger.HasBaRhgSource(fileToChange))
{
Logging.Logger.Log(Logging.SeverityGrades.Info, @"Aligned image doesn't have .ba file as its source, navigation embedding process stopped.
Consider using manual embedding");
return;
}
}
Behaviors.Navigation.NavigationChanger.Abstract.NavigationChanger naviChanger = null;
using (var ofd = new OpenFileDialog() { Title = "Выберите исходный файл РГГ", Filter = Resources.NaviEmbeddingFilterSource })
{
if (ofd.ShowDialog() == DialogResult.OK)
{
try
{
var sourceFileProp = new Files.FileProperties(ofd.FileName);
var sourceFileHeader = Factories.Header.Abstract.HeaderFactory.GetFactory(sourceFileProp).Create(ofd.FileName);
var sourceFile = Factories.File.Abstract.FileFactory.GetFactory(sourceFileProp).Create(sourceFileProp, sourceFileHeader, null);
naviChanger = Factories.NavigationChanger.Abstract.NavigationChangerFactory.GetFactory(fileToChangeProp).Create(fileToChange, sourceFile);
naviChanger.ChangeFlightTime();
naviChanger.ChangeNavigation();
Logging.Logger.Log(Logging.SeverityGrades.Info,
string.Format("Successfully applied navigation to {0}", rliFileName));
}
catch (Exception ex)
{
Logging.Logger.Log(Logging.SeverityGrades.Error,
string.Format("Unable to embed new navigation: {0}", ex.Message));
Forms.FormsHelper.ShowErrorMsg("Не удалось вшить навигацию");
}
}
}
}
