public override void Decode(byte[] buffer, int offset, int length)
{
using (var reader = new RawReader(new MemoryStream(buffer, offset, length, false), false))
{
var decode = BEncodedValue.Decode <BEncodedDictionary>(reader);
BEncodedValue val;
if (decode.TryGetValue(MessageTypeKey, out val))
{
_messageType = (eMessageType)((BEncodedNumber)val).Number;
}
if (decode.TryGetValue(PieceKey, out val))
{
Piece = (int)((BEncodedNumber)val).Number;
}
if (decode.TryGetValue(TotalSizeKey, out val))
{
var totalSize = (int)((BEncodedNumber)val).Number;
MetadataPiece = new byte[Math.Min(totalSize - Piece * BlockSize, BlockSize)];
reader.Read(MetadataPiece, 0, MetadataPiece.Length);
}
}
}
protected override IBitmap <short> LoadMapGranulate(int lat, int lon)
{
string bitmapPath = string.Format(InputPath, MapGranulateName(lat, lon));
var bitmapEntry = _zipArchive.GetEntry(bitmapPath);
if (bitmapEntry == null)
{
return(_oceanBitmap);
}
Console.WriteLine($"Found: {bitmapPath}");
var rawReader = new RawReader(new BufferedStream(bitmapEntry.Open(), 1024 * 1024));
var bitmap = rawReader.ReadBitmap <short>(BitmapWidth, BitmapHeight);
bitmap = bitmap.Convert((p) =>
{
return((short)(((p >> 8) & 0xff) | ((p << 8) & 0xff00)));
});
_rawReaders.Add(rawReader);
return(bitmap);
}
//------------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------------
/*
* //Создание изображения из файла
* public static WriteableBitmap CreateWriteableBitmapFromFile( string fileName, double dpiX, double dpiY ) {
* System.Drawing.Bitmap bitmap = new System.Drawing.Bitmap( fileName );
*
* //System.Windows.Media.PixelFormat targetPixelFormat = PixelFormats.Rgba64;
* System.Windows.Media.PixelFormat targetPixelFormat = PixelFormats.Pbgra32;
*
* WriteableBitmap writeableBitmap =
* new WriteableBitmap( bitmap.Width, bitmap.Height, dpiX, dpiY, targetPixelFormat, null );
*
* //WriteableBitmap writeableBitmap =
* // new WriteableBitmap( bitmap.Width, bitmap.Height, dpiX, dpiY, PixelFormats.Rgba64, null );
*
* System.Drawing.Rectangle rect = new System.Drawing.Rectangle( 0, 0, bitmap.Width, bitmap.Height );
* System.Drawing.Imaging.ImageLockMode lockMode = System.Drawing.Imaging.ImageLockMode.ReadOnly;
*
* System.Drawing.Imaging.PixelFormat pixelFormat = System.Drawing.Imaging.PixelFormat.Format32bppArgb;
* //System.Drawing.Imaging.PixelFormat pixelFormat = System.Drawing.Imaging.PixelFormat.Format64bppArgb;
* //System.Drawing.Imaging.PixelFormat pixelFormat = System.Drawing.Imaging.PixelFormat.Format16bppGrayScale;
*
* System.Drawing.Imaging.BitmapData bitmapData = bitmap.LockBits( rect, lockMode, pixelFormat );
* Int32Rect int32Rect = new System.Windows.Int32Rect( 0, 0, bitmapData.Width, bitmapData.Height );
*
* writeableBitmap.WritePixels
* ( int32Rect, bitmapData.Scan0, bitmapData.Stride * bitmapData.Height, bitmapData.Stride );
* bitmap.UnlockBits( bitmapData );
* bitmap.Dispose();
*
* return writeableBitmap;
* }
*/
//------------------------------------------------------------------------------------------------
public static ExtraImageInfo CreateWriteableBitmapFromFile(string fileName, double dpiX, double dpiY)
{
//public static WriteableBitmap CreateWriteableBitmapFromFile( string fileName, double dpiX, double dpiY ) {
/*
* if ( fileName.ToUpper().EndsWith( "CR2" ) ) {
*
* MagickImage magicImage = new MagickImage( fileName );
*
* int width = magicImage.Width;
* int height = magicImage.Height;
* PixelFormat pixelFormat = PixelFormats.Bgra32;
*
* WriteableBitmap resultWriteableBitmap =
* WriteableBitmapCreator.CreateWriteableBitmap( width, height, (int)dpiX, (int)dpiY, pixelFormat );
* WriteableBitmapWrapper imageWrapper = WriteableBitmapWrapper.Create( resultWriteableBitmap );
*
* PixelCollection pixelCollection = magicImage.GetPixels();
*
* Interval<double> interval1 = new Interval<double>( 0, ushort.MaxValue );
* Interval<double> interval2 = new Interval<double>( 0, byte.MaxValue );
* RealIntervalTransform intervalTransform = new RealIntervalTransform( interval1, interval2 );
*
* RealMatrix redMatrix = new RealMatrix( height, width );
*
* for ( int x = 0; x < width; x++ ) {
* for ( int y = 0; y < height; y++ ) {
* Pixel pixel = pixelCollection.GetPixel(x, y);
* MagickColor magicColor = pixel.ToColor();
*
* redMatrix[ y, x ] = intervalTransform.TransformToFinishIntervalValue(magicColor.R);
*
* byte a = Convert.ToByte( intervalTransform.TransformToFinishIntervalValue( magicColor.A ) );
* byte r = Convert.ToByte( intervalTransform.TransformToFinishIntervalValue( magicColor.R ) );
* byte g = Convert.ToByte( intervalTransform.TransformToFinishIntervalValue( magicColor.G ) );
* byte b = Convert.ToByte( intervalTransform.TransformToFinishIntervalValue( magicColor.B ) );
*
* Color color = Color.FromArgb( a, r, g, b );
*
* imageWrapper.SetPixelColor( x, y, color );
* }
* }
*
* ExtraImageInfo extraImageInfo = new ExtraImageInfo();
* extraImageInfo.RedMatrix = redMatrix;
* extraImageInfo.Image = resultWriteableBitmap;
*
* //return resultWriteableBitmap;
* return extraImageInfo;
*
* }
*/
/*
* if ( fileName.ToUpper().EndsWith( "CR2" ) ) {
*
*
* //System.GC.Collect();
*
* //BitmapDecoder bitmapDecoder =
* // BitmapDecoder.Create( new Uri( fileName ),
* // BitmapCreateOptions.PreservePixelFormat, BitmapCacheOption.None );
*
* //BitmapFrame frame = bitmapDecoder.Frames[ 0 ];
*
* //WriteableBitmap bitmap = new WriteableBitmap( frame );
* //WriteableBitmapWrapper wrapper = WriteableBitmapWrapper.Create( bitmap );
*
* //Color c = wrapper.GetPixelColor( 300, 300 );
*
*
* System.GC.Collect();
*
* uint error;
*
* IntPtr imgRef;
* //Open image
* IntPtr inStream;
* error = EDSDK.EdsCreateFileStream(fileName, EDSDK.EdsFileCreateDisposition.OpenExisting, EDSDK.EdsAccess.Read, out inStream);
* EDSDK.EdsCreateImageRef(inStream, out imgRef);
* EDSDK.EdsRelease(inStream);
*
* string convertedFileName = Path.ChangeExtension(fileName, "TIFF");
*
* //Save image
* IntPtr outStream;
* var settings = new EDSDK.EdsSaveImageSetting();
* error = EDSDK.EdsCreateFileStream(convertedFileName, EDSDK.EdsFileCreateDisposition.CreateAlways, EDSDK.EdsAccess.Write, out outStream);
* error = EDSDK.EdsSaveImage(imgRef, EDSDK.EdsTargetImageType.TIFF16, settings, outStream);
* EDSDK.EdsRelease(outStream);
*
* ExtraImageInfo extraImageInfo = new ExtraImageInfo();
* return extraImageInfo;
*
* }
*/
if (fileName.ToUpper().EndsWith("CR2"))
{
Interval <double> finishInterval = new Interval <double>(0, 255);
IntegerMatrix matrix = RawReader.ReadImageFromFile(fileName);
//matrix = matrix.GetSubMatrix(0, 2640 - 1, matrix.RowCount - 1, matrix.ColumnCount - 1);
int min = matrix.GetMinValue();
int max = matrix.GetMaxValue();
IntegerMatrix redMatrix = InterpolationHelper.GetRedMatrix(matrix);
int minRed = redMatrix.GetMinValue();
int maxRed = redMatrix.GetMaxValue();
IntegerMatrix greenMatrix = InterpolationHelper.GetGreenMatrix(matrix);
int minGreen = greenMatrix.GetMinValue();
int maxGreen = greenMatrix.GetMaxValue();
IntegerMatrix blueMatrix = InterpolationHelper.GetBlueMatrix(matrix);
int minBlue = blueMatrix.GetMinValue();
int maxBlue = blueMatrix.GetMaxValue();
int minValue = (new int[] { minRed, minGreen, minBlue }).Min();
int maxValue = (new int[] { maxRed, maxGreen, maxBlue }).Max();
RealIntervalTransform redIntervalTransform =
new RealIntervalTransform(new Interval <double>(minValue, maxValue), finishInterval);
IntegerMatrix resRedMatrix =
IntegerMatrixValuesTransform.TransformMatrixValues(redMatrix, redIntervalTransform);
RealIntervalTransform greenIntervalTransform =
new RealIntervalTransform(new Interval <double>(minValue, maxValue), finishInterval);
IntegerMatrix resGreenMatrix =
IntegerMatrixValuesTransform.TransformMatrixValues(greenMatrix, greenIntervalTransform);
RealIntervalTransform blueIntervalTransform =
new RealIntervalTransform(new Interval <double>(minValue, maxValue), finishInterval);
IntegerMatrix resBlueMatrix =
IntegerMatrixValuesTransform.TransformMatrixValues(blueMatrix, blueIntervalTransform);
WriteableBitmap resImage =
WriteableBitmapCreator.CreateWriteableBitmapFromMatricesRGB
(resRedMatrix, resGreenMatrix, resBlueMatrix, OS.OS.IntegerSystemDpiX, OS.OS.IntegerSystemDpiY);
/*
* IntegerMatrix resMatrix =
* IntegerMatrixValuesTransform.TransformMatrixValuesToFinishIntervalValues(matrix, finishInterval);
*
* WriteableBitmap resImage =
* WriteableBitmapCreator.CreateGrayScaleWriteableBitmapFromMatrix
* (resMatrix, OS.OS.IntegerSystemDpiX, OS.OS.IntegerSystemDpiY);
*/
ExtraImageInfo extraImageInfo = new ExtraImageInfo();
extraImageInfo.Image = resImage;
return(extraImageInfo);
}
else
{
Stream imageStreamSource = new FileStream(fileName, FileMode.Open, FileAccess.Read, FileShare.Read);
BitmapDecoder decoder = BitmapDecoder.Create(imageStreamSource, BitmapCreateOptions.PreservePixelFormat, BitmapCacheOption.Default);
BitmapSource bitmapSource = decoder.Frames[0];
WriteableBitmap resultWriteableBitmap = new WriteableBitmap(bitmapSource);
ExtraImageInfo extraImageInfo = new ExtraImageInfo();
extraImageInfo.Image = resultWriteableBitmap;
return(extraImageInfo);
}
}
public async Task <bool> Flush()
{
var rawReader = new RawReader();
IRegHive hiveRegistry = null;
IRegHive hiveUser = null;
IRegHive hiveUserClasses = null;
if (File.Exists(this.fileRegistry))
{
hiveRegistry = await rawReader.Open(this.fileRegistry).ConfigureAwait(false);
}
if (File.Exists(this.fileUser))
{
hiveUser = await rawReader.Open(this.fileUser).ConfigureAwait(false);
}
if (File.Exists(this.fileUserClasses))
{
hiveUserClasses = await rawReader.Open(this.fileUserClasses).ConfigureAwait(false);
}
if (hiveUserClasses == null && hiveRegistry == null && hiveUser == null)
{
return(false);
}
var foundAnythingRegistry = false;
var foundAnythingUser = false;
var foundAnythingUserClasses = false;
using (hiveRegistry)
{
using (hiveUser)
{
using (hiveUserClasses)
{
foreach (var key in this.deletedKeys)
{
var msix = RegistryPathConverter.ToMsixRegistryPath(key);
if (hiveRegistry != null)
{
using var foundKey = this.GetExistingRegistryKey(hiveRegistry.Root, msix);
if (foundKey != null)
{
foundAnythingRegistry = true;
RemoveRecurse(foundKey);
}
}
if (hiveUser != null)
{
using var foundKey = this.GetExistingRegistryKey(hiveUser.Root, msix);
if (foundKey != null)
{
foundAnythingUser = true;
RemoveRecurse(foundKey);
}
}
if (hiveUserClasses != null)
{
using var foundKey = this.GetExistingRegistryKey(hiveUserClasses.Root, msix);
if (foundKey != null)
{
foundAnythingUserClasses = true;
RemoveRecurse(foundKey);
}
}
}
if (foundAnythingRegistry)
{
await hiveRegistry.Save(this.fileRegistry).ConfigureAwait(false);
}
if (foundAnythingUser)
{
await hiveUser.Save(this.fileUser).ConfigureAwait(false);
}
if (foundAnythingUserClasses)
{
await hiveUserClasses.Save(this.fileUserClasses).ConfigureAwait(false);
}
}
}
}
this.deletedKeys.Clear();
return(foundAnythingRegistry || foundAnythingUser || foundAnythingUserClasses);
}
public async Task <bool> Flush()
{
var reader = new RawReader();
if (this.msixRegistryFacade.Registry.Any())
{
IRegHive hive;
if (!File.Exists(this.fileRegistry))
{
if (!Directory.Exists(Path.GetDirectoryName(this.fileRegistry)))
{
// ReSharper disable once AssignNullToNotNullAttribute
Directory.CreateDirectory(Path.GetDirectoryName(this.fileRegistry));
}
hive = await reader.Create().ConfigureAwait(false);
}
else
{
hive = await reader.Open(this.fileRegistry).ConfigureAwait(false);
}
using (hive)
{
this.CommitEntries(hive.Root, this.msixRegistryFacade.Registry);
await hive.Save(this.fileRegistry).ConfigureAwait(false);
}
}
if (this.msixRegistryFacade.User.Any())
{
IRegHive hive;
if (!File.Exists(this.fileUser))
{
if (!Directory.Exists(Path.GetDirectoryName(this.fileUser)))
{
// ReSharper disable once AssignNullToNotNullAttribute
Directory.CreateDirectory(Path.GetDirectoryName(this.fileUser));
}
hive = await reader.Create().ConfigureAwait(false);
}
else
{
hive = await reader.Open(this.fileUser).ConfigureAwait(false);
}
using (hive)
{
this.CommitEntries(hive.Root, this.msixRegistryFacade.User);
await hive.Save(this.fileUser).ConfigureAwait(false);
}
}
if (this.msixRegistryFacade.UserClasses.Any())
{
IRegHive hive;
if (!File.Exists(this.fileUserClasses))
{
if (!Directory.Exists(Path.GetDirectoryName(this.fileUserClasses)))
{
// ReSharper disable once AssignNullToNotNullAttribute
Directory.CreateDirectory(Path.GetDirectoryName(this.fileUserClasses));
}
hive = await reader.Create().ConfigureAwait(false);
}
else
{
hive = await reader.Open(this.fileUserClasses).ConfigureAwait(false);
}
using (hive)
{
this.CommitEntries(hive.Root, this.msixRegistryFacade.UserClasses);
await hive.Save(this.fileUserClasses).ConfigureAwait(false);
}
}
var hasChanges = this.msixRegistryFacade.Registry.Any() || this.msixRegistryFacade.User.Any() || this.msixRegistryFacade.UserClasses.Any();
this.msixRegistryFacade.Registry.Clear();
this.msixRegistryFacade.User.Clear();
this.msixRegistryFacade.UserClasses.Clear();
return(hasChanges);
}
public override List <IsobaricItem> ReadFromFile(string fileName)
{
var result = new List <IsobaricItem>();
RawReader.Open(fileName);
try
{
int startScan = RawReader.GetFirstSpectrumNumber();
int endScan = RawReader.GetLastSpectrumNumber();
Progress.SetRange(startScan, endScan);
for (int scan = startScan; scan <= endScan; scan++)
{
if (Progress.IsCancellationPending())
{
throw new UserTerminatedException();
}
Progress.SetPosition(scan);
if (2 == RawReader.GetMsLevel(scan))
{
string scanMode = RawReader.GetScanMode(scan);
if (string.IsNullOrEmpty(scanMode))
{
AppendScan(result, scan, "UNKNOWN");
continue;
}
scanMode = scanMode.ToLower();
if (scanMode.Equals("pqd"))
{
AppendScan(result, scan, "PQD");
}
else if (scanMode.Equals("cid"))
{
//如果上一个scan是pqd，那么，现在这个cid的结果从该pqd读取。
if (result.Count > 0 && result[result.Count - 1].RawPeaks.ScanTimes[0].Scan == scan - 1 && result[result.Count - 1].RawPeaks.ScanMode == "PQD")
{
var lastItem = result[result.Count - 1];
var item = new IsobaricItem(lastItem);
item.Scan = RawReader.GetScanTime(scan);
item.ScanMode = "CID";
result.Add(item);
}
else//否则，从自己的peaklist中读取。
{
AppendScan(result, scan, "CID");
}
}
else
{
Console.WriteLine("Scan {0} is skipped with mode {1}", scan, scanMode);
}
}
}
}
finally
{
RawReader.Close();
}
return(result);
}
public override void Decode(byte[] buffer, int offset, int length)
{
using (var reader = new RawReader(new MemoryStream(buffer, offset, length, false), false))
{
var decode = BEncodedValue.Decode<BEncodedDictionary>(reader);
BEncodedValue val;
if (decode.TryGetValue(MessageTypeKey, out val))
_messageType = (eMessageType) ((BEncodedNumber) val).Number;
if (decode.TryGetValue(PieceKey, out val))
Piece = (int) ((BEncodedNumber) val).Number;
if (decode.TryGetValue(TotalSizeKey, out val))
{
var totalSize = (int) ((BEncodedNumber) val).Number;
MetadataPiece = new byte[Math.Min(totalSize - Piece*BlockSize, BlockSize)];
reader.Read(MetadataPiece, 0, MetadataPiece.Length);
}
}
}
public void Init(IXRawfile5 rawConnect, RawReader rawReader)
{
_rawConnect = rawConnect;
_rawReader = rawReader;
}
public virtual List <IsobaricItem> ReadFromFile(string fileName)
{
var result = new List <IsobaricItem>();
var askedScanMode = GetScanMode();
var lowerScanMode = new HashSet <string>(from a in askedScanMode
select a.ToLower());
RawReader.Open(fileName);
try
{
FirstScan = RawReader.GetFirstSpectrumNumber();
EndScan = RawReader.GetLastSpectrumNumber();
DoAfterFileOpen();
var firstIsolationWidth = 0.0;
var icount = 0;
for (int scan = FirstScan; scan <= EndScan; scan++)
{
if (!RawReader.IsScanValid(scan))
{
continue;
}
if (this.MsLevel == RawReader.GetMsLevel(scan))
{
firstIsolationWidth = RawReader.GetIsolationWidth(scan);
if (firstIsolationWidth > 0 && firstIsolationWidth < 5)
{
break;
}
icount++;
if (icount > 10)
{
break;
}
}
}
if (firstIsolationWidth == 0.0)
{
firstIsolationWidth = defaultIsolationWidth;
}
Progress.SetMessage("Reading channel information ...");
Progress.SetRange(FirstScan, EndScan);
for (int scan = FirstScan; scan <= EndScan; scan++)
{
if (Progress.IsCancellationPending())
{
throw new UserTerminatedException();
}
if (!RawReader.IsScanValid(scan))
{
continue;
}
Progress.SetPosition(scan);
if (this.MsLevel == RawReader.GetMsLevel(scan))
{
string scanMode = RawReader.GetScanMode(scan).ToLower();
if (string.IsNullOrEmpty(scanMode))
{
AppendScan(result, scan, "UNKNOWN", firstIsolationWidth);
}
else if (lowerScanMode.Count == 0 || lowerScanMode.Contains(scanMode))
{
AppendScan(result, scan, scanMode.ToUpper(), firstIsolationWidth);
}
else
{
Console.WriteLine("Scan {0} is skipped with mode {1}", scan, scanMode);
}
}
}
}
finally
{
RawReader.Close();
}
return(result);
}
static void Main(string[] args)
{
Console.CancelKeyPress += CancelKeyPress;
var stopwatch = new Stopwatch();
try
{
Console.WriteLine();
CompressionMode compressMode;
FileInfo inFile, outFile;
ParseCmdLineParams(args, out inFile, out outFile, out compressMode);
WorkerPool workerPool = new WorkerPool();
BaseReader reader = null;
stopwatch.Start();
Console.WriteLine("Start");
Console.WriteLine();
if (compressMode == CompressionMode.Compress)
{
_writer = new CompressedWriter();
_writer.StartWrite(outFile, workerPool.OutQueue);
workerPool.Start <CompressWorker>();
reader = new RawReader();
reader.StartRead(inFile, workerPool.InQueue);
}
else if (compressMode == CompressionMode.Decompress)
{
_writer = new RawWriter();
_writer.StartWrite(outFile, workerPool.OutQueue);
workerPool.Start <DecompressWorker>();
reader = new CompressedReader();
reader.StartRead(inFile, workerPool.InQueue);
}
while (!_canceled && !Logger.ErrorFixed)
{
_writer.BlockWrittenEvent.WaitOne(TimeSpan.FromSeconds(1));
if (reader.Done && reader.BlocksRead == _writer.BlocksWritten)
{
break;
}
else if (_writer.BlockWrittenEvent.WaitOne(0))
{
_writer.BlockWrittenEvent.Reset();
}
}
}
catch (Exception ex)
{
Logger.TraceError(string.Format("Global error: {0}", ex.ToString()));
}
if (_canceled || Logger.ErrorFixed)
{
Logger.DisableOutput();
if (_writer != null)
{
_writer.Cancel();
}
}
PrintFooter(stopwatch);
Environment.Exit(0);
}
public async Task ConvertFromRegToDat(string regFile, string file, RegistryRoot?root = null)
{
var regParser = new RegFileParser();
var parsedKeys = regParser.Parse(regFile);
IEnumerable <RegistryEntry> parsedFilteredKeys;
if (root == null)
{
parsedFilteredKeys = parsedKeys;
}
else
{
parsedFilteredKeys = parsedKeys.Where(r => r.Root == root.Value);
}
var reader = new RawReader();
using (var hive = await reader.Create())
{
var mustSave = false;
foreach (var item in parsedFilteredKeys)
{
var key = PrepareRegistryKey(item);
mustSave = true;
var k = this.EnsureRegistryKey(hive.Root, key);
if (!string.IsNullOrEmpty(item.Name))
{
switch (item.Type)
{
case ValueType.Default:
break;
case ValueType.String:
k.SetValue(item.Name, this.Tokenize((string)item.Value));
break;
case ValueType.DWord:
var val = (long)Convert.ChangeType(item.Value, typeof(long));
if (val > int.MaxValue)
{
k.SetValue(item.Name, val);
}
else
{
k.SetValue(item.Name, (int)val);
}
break;
case ValueType.QWord:
k.SetValue(item.Name, (long)Convert.ChangeType(item.Value, typeof(long)));
break;
case ValueType.Multi:
k.SetValue(item.Name, this.Tokenize((string[])item.Value));
break;
case ValueType.Expandable:
k.SetValue(item.Name, this.Tokenize((string)item.Value));
break;
case ValueType.Binary:
k.SetValue(item.Name, (byte[])item.Value);
break;
case ValueType.DWordBigEndian:
k.SetValue(item.Name, (int)Convert.ChangeType(item.Value, typeof(int)));
break;
}
}
}
if (mustSave)
{
await hive.Save(file);
}
}
}
public ThermoRawSpectrumReader()
{
rawConnect = new MSFileReader_XRawfile() as IXRawfile5;
rawReader = new RawReader();
}
