private void RunTest(Array pixels, Type type)
{
uint medianVal;
Type dataType;
bool hasNegPix;
int minValue;
uint maxValue;
int bz = 0;
FITSHelper2.Load16BitImageData(pixels, 3, 2, bz, 0, out medianVal, out dataType, out hasNegPix, out minValue, out maxValue);
Assert.AreEqual(type, dataType);
Assert.AreEqual(true, hasNegPix);
Assert.AreEqual(-13, minValue);
Assert.AreEqual(34, maxValue);
bz = -10;
FITSHelper2.Load16BitImageData(pixels, 3, 2, bz, 0, out medianVal, out dataType, out hasNegPix, out minValue, out maxValue);
Assert.AreEqual(-13, minValue);
Assert.AreEqual(24, maxValue);
bz = -14;
FITSHelper2.Load16BitImageData(pixels, 3, 2, bz, 0, out medianVal, out dataType, out hasNegPix, out minValue, out maxValue);
Assert.AreEqual(-13, minValue);
Assert.AreEqual(20, maxValue);
Assert.AreEqual(true, hasNegPix); // Zeroing out negative pixels doesn't change the fact that there are negative pixels
}
private Array GetFirstFramePixelArray()
{
return(FITSHelper2.GetPixelsFrom3DCube(
(Array)m_ImageHDU.Data.DataArray, 0,
FrameIndex, HeightIndex, WidthIndex,
m_ImageHDU.Axes[FrameIndex], m_ImageHDU.Axes[HeightIndex], m_ImageHDU.Axes[WidthIndex]));
}
private FITSFileSequenceStream(string[] fitsFiles, IFITSTimeStampReader timeStampReader, int firstFrame, int?bitBix, int negPixCorrection)
{
m_FitsFilesList.AddRange(fitsFiles);
var firstNumeredFrameNo = GetFirstImageNumberOfConsistentlyNamedFiles();
if (firstFrame == 0 && firstNumeredFrameNo.HasValue)
{
firstFrame = firstNumeredFrameNo.Value;
}
FirstFrame = firstFrame;
LastFrame = m_FitsFilesList.Count - 1 + firstFrame;
CountFrames = m_FitsFilesList.Count;
m_TimeStampReader = timeStampReader;
m_NegPixCorrection = negPixCorrection;
var fitsData = FITSHelper2.LoadFitsFile(m_FitsFilesList[0], m_TimeStampReader, m_NegPixCorrection);
m_MinPixelValueFirstImage = fitsData.PixelStats.MinPixelValue;
m_MaxPixelValueFirstImage = fitsData.PixelStats.MaxPixelValue;
Width = fitsData.Width;
Height = fitsData.Height;
BitPix = bitBix ?? fitsData.PixelStats.RawBitPix;
HasUTCTimeStamps = fitsData.Timestamp.HasValue;
VideoFileType = string.Format("FITS.{0}::SEQ", fitsData.PixelStats.RawBitPix);
}
public static SingleFITSFileFrameStream OpenFile(string fileName, out bool hasNegativePixels)
{
var fitsData = FITSHelper2.LoadFitsFile(fileName, null, 0);
TangraContext.Current.RenderingEngine = SINGLE_FITS_FILE_ENGINE;
hasNegativePixels = fitsData.PixelStats.HasNegativePixels;
return(new SingleFITSFileFrameStream(fitsData.PixelsFlat, fitsData.Width, fitsData.Height, fitsData.PixelStats.BitPix, fitsData.Exposure, fitsData.PixelStats.MinPixelValue, fitsData.PixelStats.MaxPixelValue, fitsData.Cards));
}
public Pixelmap GetPixelmap(int index)
{
var fitsData = FITSHelper2.LoadFitsFile(m_FitsFilesList[index - FirstFrame], m_TimeStampReader, m_NegPixCorrection);
if (Width != fitsData.Width || Height != fitsData.Height)
{
throw new ApplicationException(string.Format("Expected a {0}x{1} image but found {2}x{3} in '{4}'", Width, Height, fitsData.Width, fitsData.Height, m_FitsFilesList[index - FirstFrame]));
}
return(FitsStreamHelper.BuildFitsPixelmap(Width, Height, fitsData.PixelsFlat, BitPix, HasUTCTimeStamps, fitsData.Exposure, fitsData.Timestamp, fitsData.HDU, fitsData.Cards));
}
public Pixelmap GetPixelmap(int index)
{
if (index < 0 || index >= m_NumFrames)
{
return(null);
}
m_CurrentFrameIndex = index;
var frameData = FITSHelper2.GetPixelsFrom3DCube(m_ArrayData, index, m_FrameIndex, m_HeightIndex, m_WidthIndex, m_NumFrames, m_Height, m_Width);
if (frameData == null)
{
return(null);
}
uint[] pixelsFlat = FITSHelper2.Load16BitImageData(frameData, m_Height, m_Width, m_BZero - m_NegPixCorrection, 0);
DateTime timestamp = m_FirstFrameMidTime.AddSeconds(index * m_ExposureSeconds);
return(FitsStreamHelper.BuildFitsPixelmap(Width, Height, pixelsFlat, BitPix, true, m_ExposureSeconds, timestamp, m_ImageHDU, m_Cards));
}
private ThreeAxisFITSCubeFrameStream(
string fileName, Fits fitsFile, BufferedFile bufferedFile, BasicHDU imageHDU,
FITSTimeStampReader timeStampReader,
int widthIndex, int heightIndex, int frameIndex,
short minPixelValue, uint maxPixelValue, int bitPix, int negPixCorrection)
{
m_FileName = fileName;
bool isMidPoint;
double?exposureSecs;
var startExposure = timeStampReader.ParseExposure(null, imageHDU.Header, out isMidPoint, out exposureSecs);
if (startExposure.HasValue && exposureSecs.HasValue)
{
m_ExposureSeconds = exposureSecs.Value;
m_FirstFrameMidTime = startExposure.Value;
}
m_MinPixelValue = minPixelValue;
m_MaxPixelValue = maxPixelValue;
m_Bpp = bitPix;
m_FitsFile = fitsFile;
m_TimeStampReader = timeStampReader;
m_BufferedFile = bufferedFile;
m_ImageHDU = imageHDU;
m_HeightIndex = heightIndex;
m_WidthIndex = widthIndex;
m_FrameIndex = frameIndex;
m_NumFrames = m_ImageHDU.Axes[frameIndex];
m_Height = m_ImageHDU.Axes[heightIndex];
m_Width = m_ImageHDU.Axes[widthIndex];
m_ArrayData = (Array)m_ImageHDU.Data.DataArray;
m_BZero = FITSHelper2.GetBZero(m_ImageHDU);
m_NegPixCorrection = negPixCorrection;
m_Cards = new Dictionary <string, string>();
var cursor = m_ImageHDU.Header.GetCursor();
while (cursor.MoveNext())
{
HeaderCard card = m_ImageHDU.Header.FindCard((string)cursor.Key);
if (card != null && !string.IsNullOrWhiteSpace(card.Key) && card.Key != "END")
{
if (m_Cards.ContainsKey(card.Key))
{
m_Cards[card.Key] += "\r\n" + card.Value;
}
else
{
m_Cards.Add(card.Key, card.Value);
}
}
}
HasUTCTimeStamps = startExposure.HasValue;
VideoFileType = string.Format("FITS.{0}::Cube3D", bitPix);
}
private void frmSortFitsFiles_Shown(object sender, EventArgs e)
{
TimeStampReader = null;
if (m_FitsFiles.Length > 0)
{
var frm = new frmChooseTimeHeaders(m_FitsFiles[0], GetOrderedFitsFileHash(), m_VideoController);
if (frm.ShowDialog(this) == DialogResult.OK)
{
TimeStampReader = frm.TimeStampReader;
FlipVertically = frm.FlipVertically;
FlipHorizontally = frm.FlipHorizontally;
MinPixelValue = frm.MinPixelValue;
MaxPixelValue = frm.MaxPixelValue;
BitPix = frm.BitPix;
NegPixCorrection = frm.NegPixCorrection;
}
else
{
Array.Clear(m_FitsFiles, 0, m_FitsFiles.Length);
DialogResult = DialogResult.Cancel;
Close();
return;
}
}
m_FitsHeaders = new Header[m_FitsFiles.Length];
m_FitsTimestamps = new DateTime?[m_FitsFiles.Length];
pbar.Minimum = 0;
pbar.Maximum = m_FitsFiles.Length;
pbar.Value = 0;
var fileSizeInfo = new Dictionary <string, FitsFileFormatInfoRecord>();
for (int i = 0; i < m_FitsFiles.Length; i++)
{
try
{
using (BufferedFile bf = new BufferedFile(m_FitsFiles[i], FileAccess.Read, FileShare.ReadWrite))
{
Header hdr = Header.ReadHeader(bf);
m_FitsHeaders[i] = hdr;
int numAxis = -1;
int width = -1;
int height = -1;
int.TryParse(hdr.FindCard("NAXIS") != null ? hdr.FindCard("NAXIS").Value : "0", out numAxis);
int.TryParse(hdr.FindCard("NAXIS1") != null ? hdr.FindCard("NAXIS1").Value : "0", out width);
int.TryParse(hdr.FindCard("NAXIS2") != null ? hdr.FindCard("NAXIS2").Value : "0", out height);
string format = String.Format("{0} x {1}", width, height);
if (fileSizeInfo.ContainsKey(format))
{
fileSizeInfo[format].NumFiles++;
}
else
{
fileSizeInfo.Add(format, new FitsFileFormatInfoRecord {
FirstFile = Path.GetFileName(m_FitsFiles[i]), NumFiles = 1
});
}
bool isMidPoint;
double? fitsExposure = null;
DateTime?timestamp = null;
if (TimeStampReader != null)
{
try
{
timestamp = FITSHelper2.ParseExposure(m_FitsFiles[i], hdr, TimeStampReader, out isMidPoint, out fitsExposure);
}
catch (Exception ex)
{
Trace.WriteLine(ex.ToString());
}
}
m_FitsTimestamps[i] = timestamp;
if (timestamp != null && fitsExposure.HasValue)
{
m_FilesWithExposure++;
}
else
{
m_FilesWithoutExposure++;
}
}
}
catch (Exception ex)
{
throw new ApplicationException(string.Format("Error processing FITS files: {0}", m_FitsFiles[i]), ex);
}
pbar.Value = i;
Application.DoEvents();
}
pbar.Value = pbar.Minimum;
Application.DoEvents();
if (fileSizeInfo.Count > 1)
{
var errorInfo = new StringBuilder();
foreach (string key in fileSizeInfo.Keys)
{
if (fileSizeInfo[key].NumFiles > 1)
{
errorInfo.AppendFormat("'{1}' and {2} other files: {0}\r\n", key, fileSizeInfo[key].FirstFile, fileSizeInfo[key].NumFiles - 1);
}
else
{
errorInfo.AppendFormat("'{1}' (single file): {0}\r\n", key, fileSizeInfo[key].FirstFile);
}
}
ErrorMessage = string.Format("Cannot load FITS file sequence because there are files with different image dimentions:\r\n\r\n{0}\r\n\r\nPlease ensure that all files in the directory have the same dimention (number of axis).", errorInfo.ToString());
}
timer1.Enabled = true;
}
public frmChooseTimeHeaders(string fileName, string filesHash, VideoController videoController)
: this()
{
m_VideoController = videoController;
FITSData fitsData;
m_VideoController.SetCursor(Cursors.WaitCursor);
try
{
fitsData = FITSHelper2.LoadFitsFile(fileName, null, 0);
BZero = FITSHelper2.GetBZero(fitsData.HDU);
m_BelowZeroCorr = Math.Max(BZero, Math.Abs(fitsData.PixelStats.MinPixelValue) - BZero);
fitsData = FITSHelper2.LoadFitsFile(fileName, null, BZero - m_BelowZeroCorr);
}
finally
{
m_VideoController.SetCursor(Cursors.Default);
}
m_FilesHash = filesHash;
var hasher = new SHA1CryptoServiceProvider();
hasher.Initialize();
var orderedCardNames = new List <string>();
var cursor = fitsData.HDU.Header.GetCursor();
while (cursor.MoveNext())
{
var card = fitsData.HDU.Header.FindCard((string)cursor.Key);
if (card != null)
{
m_AllCards.Add(new HeaderEntry(card));
}
orderedCardNames.Add((string)cursor.Key);
}
orderedCardNames.Sort();
byte[] combinedCardNamesBytes = Encoding.UTF8.GetBytes(string.Join("|", orderedCardNames));
var hash = hasher.ComputeHash(combinedCardNamesBytes, 0, combinedCardNamesBytes.Length);
m_CardNamesHash = Convert.ToBase64String(hash);
cbxExposure.Items.AddRange(m_AllCards.ToArray());
cbxExposureUnits.Items.Clear();
cbxExposureUnits.Items.AddRange(Enum.GetNames(typeof(TangraConfig.ExposureUnit)));
cbxExposureUnits.SelectedIndex = 0;
m_TimeStampHelper = new FitsTimestampHelper(m_FilesHash, m_AllCards, UseRecentFITSConfig);
ucTimestampControl.Initialise(m_AllCards, m_FilesHash, m_CardNamesHash, m_TimeStampHelper);
ucTimestampControl2.Initialise(m_AllCards, m_FilesHash, m_CardNamesHash, m_TimeStampHelper);
ucTimestampControl2.SetTimeStampType(TangraConfig.TimeStampType.EndExposure, false);
m_TimeStampHelper.TryIdentifyPreviousConfigApplyingForCurrentFiles();
if (fitsData.PixelStats.HasNegativePixels)
{
NegPixCorrection = fitsData.PixelStats.MinPixelValue;
}
else
{
// No requirement to review the pixel mapping if there are no negative pixels
// We can go with the defaults
m_PixelMappingReviewed = true;
NegPixCorrection = 0;
}
Pixels = fitsData.PixelsFlat;
MinPixelValue = fitsData.PixelStats.MinPixelValue;
MaxPixelValue = fitsData.PixelStats.MaxPixelValue;
HasNegativePixels = fitsData.PixelStats.HasNegativePixels;
BitPix = fitsData.PixelStats.BitPix;
}
