public static bool AddAviVideoFrame(Pixelmap pixmap, double addedGamma, int? adv16NormalisationValue) { int[,] pixels = new int[pixmap.Height, pixmap.Width]; bool usesGamma = Math.Abs(addedGamma - 1) > 0.01; bool needsBitPixConversion = pixmap.BitPixCamera > 8 || (adv16NormalisationValue != null && adv16NormalisationValue.Value > 0); double maxVal = pixmap.BitPixCamera.GetMaxValueForBitPix(); if (adv16NormalisationValue != null && adv16NormalisationValue.Value > 0) maxVal = adv16NormalisationValue.Value; if (Math.Abs(s_BitPixTableBitPixVal - pixmap.BitPixCamera) > 0.01 || Math.Abs(s_BitPixTableMaxVal - maxVal) > 0.01) { for (int i = 0; i <= maxVal; i++) { double convVal = 255.0 * i / maxVal; s_BitPixTable[i] = Math.Max(0, Math.Min(255, (int)Math.Round(convVal))); } s_BitPixTableBitPixVal = pixmap.BitPixCamera; s_BitPixTableMaxVal = maxVal; } if (Math.Abs(s_GammaTableGammaVal - addedGamma) > 0.01) { double gammaFactor = usesGamma ? (255.0 / Math.Pow(255.0, addedGamma)) : 0; for (int i = 0; i < 256; i++) { double convVal = gammaFactor * Math.Pow(i, addedGamma); s_GammaTable[i] = Math.Max(0, Math.Min(255, (int) Math.Round(convVal))); } s_GammaTableGammaVal = addedGamma; } for (int x = 0; x < pixmap.Width; x++) { for (int y = 0; y < pixmap.Height; y++) { uint conv8BitVal = pixmap.Pixels[x + y*pixmap.Width]; if (needsBitPixConversion) conv8BitVal = (uint)s_BitPixTable[conv8BitVal]; if (usesGamma) pixels[y, x] = s_GammaTable[conv8BitVal]; else pixels[y, x] = Math.Max(0, Math.Min(255, (int)conv8BitVal)); } } if (TangraAviFileAddFrame(pixels) != 0) { TraceLastNativeError(); return false; } return true; }
private static Pixelmap ConstructForLCFileAveragedFrame(uint[] data, int width, int height, int bitpixCamera, byte[] bytes) { Bitmap bmp = ConstructBitmapFromBitmapPixels(bytes, width, height); Pixelmap rv = new Pixelmap(width, height, bitpixCamera, data, bmp, bytes); return(rv); }
public static Pixelmap ConstructForLCFile32bppArgbAveragedFrame(byte[] bytes, int width, int height, int bitpixCamera) { Bitmap bmp = ConstructBitmapFrom32bppArgbBitmapPixels(bytes, width, height); Pixelmap rv = new Pixelmap(width, height, bitpixCamera, new uint[bytes.Length], bmp, bytes); return(rv); }
public Pixelmap CreatePixelmap(uint[] pixels) { byte[] displayBitmapBytes = new byte[m_AdvFile.Width * m_AdvFile.Height]; for (int y = 0; y < m_AdvFile.Height; y++) { for (int x = 0; x < m_AdvFile.Width; x++) { int index = x + y * m_AdvFile.Width; if (m_AdvFile.MaxPixelValue == 8) displayBitmapBytes[index] = (byte)((pixels[index] & 0xFF)); else if (m_AdvFile.DataBpp == 12) displayBitmapBytes[index] = (byte)((pixels[index] >> 4)); else if (m_AdvFile.DataBpp == 14) displayBitmapBytes[index] = (byte)((pixels[index] >> 6)); else if (m_AdvFile.DataBpp == 16) { if (m_AdvFile.MaxPixelValue > 0) displayBitmapBytes[index] = (byte)((255.0 * pixels[index] / m_AdvFile.MaxPixelValue)); else displayBitmapBytes[index] = (byte)((pixels[index] >> 8)); } else displayBitmapBytes[index] = (byte)((pixels[index] >> (m_AdvFile.DataBpp - 8))); } } Bitmap displayBitmap = Pixelmap.ConstructBitmapFromBitmapPixels(displayBitmapBytes, (int)m_AdvFile.Width, (int)m_AdvFile.Height); Pixelmap rv = new Pixelmap((int)m_AdvFile.Width, (int)m_AdvFile.Height, m_AdvFile.DataBpp, pixels, displayBitmap, displayBitmapBytes); return rv; }
public Pixelmap(int width, int height, int bitPix, uint[] pixels, Bitmap bmp, byte[] displayBitmapBytes) { Width = width; Height = height; BitPixCamera = bitPix; m_Pixels = pixels; m_DisplayBitmapPixels = displayBitmapBytes; if (bmp != null && bmp.PixelFormat != PixelFormat.Format24bppRgb) { if (m_DisplayBitmapPixels != null && m_DisplayBitmapPixels.Length == Width * Height) { m_Bitmap = Pixelmap.ConstructBitmapFromBitmapPixels(m_DisplayBitmapPixels, Width, Height); } else if (Width * Height > 0) { m_Bitmap = new Bitmap(Width, Height, PixelFormat.Format24bppRgb); using (Graphics g = Graphics.FromImage(m_Bitmap)) { g.DrawImage(bmp, 0, 0); } } else { m_Bitmap = null; } } else { m_Bitmap = bmp; } }
public static void AddVideoFrame(DateTime startTimeStamp, DateTime endTimeStamp, Pixelmap pixmap) { long timeStamp = WindowsTicksToAavTicks((startTimeStamp.Ticks + endTimeStamp.Ticks) / 2); uint exposureIn10thMilliseconds = (uint)(endTimeStamp.Ticks - startTimeStamp.Ticks) / 1000; if (s_FirstRecordedFrameTimestamp == 0) s_FirstRecordedFrameTimestamp = timeStamp; // since the first recorded frame was taken uint elapsedTimeMilliseconds = (uint)((timeStamp - s_FirstRecordedFrameTimestamp) * 0xFFFFFFFF); AdvLib.Obsolete.AdvVer1.BeginFrame(timeStamp, elapsedTimeMilliseconds, exposureIn10thMilliseconds); AdvLib.Obsolete.AdvVer1.FrameAddStatusTag16(STATUS_TAG_NUMBER_INTEGRATED_FRAMES, (ushort)s_IntegrationRate); ulong currentSystemTime = (ulong)WindowsTicksToAavTicks(DateTime.Now.Ticks); AdvLib.Obsolete.AdvVer1.FrameAddStatusTag64(STATUS_TAG_SYSTEM_TIME, currentSystemTime); AdvLib.Obsolete.AdvVer1.FrameAddStatusTag64(STATUS_TAG_NTP_START_TIMESTAMP, (ulong)WindowsTicksToAavTicks(startTimeStamp.Ticks)); AdvLib.Obsolete.AdvVer1.FrameAddStatusTag64(STATUS_TAG_NTP_END_TIMESTAMP, (ulong)WindowsTicksToAavTicks(endTimeStamp.Ticks)); AdvLib.Obsolete.AdvVer1.FrameAddStatusTag16(STATUS_TAG_NTP_TIME_ERROR, 320); AdvLib.Obsolete.AdvVer1.FrameAddStatusTag(STATUS_TAG_EXPOSURE, string.Format("x{0}", s_IntegrationRate * 2)); ushort[] pixels = new ushort[pixmap.Pixels.Length]; for (int i = 0; i < pixmap.Pixels.Length; i++) pixels[i] = (ushort)pixmap.Pixels[i]; AdvLib.Obsolete.AdvVer1.FrameAddImage(1, pixels, 16); AdvLib.Obsolete.AdvVer1.EndFrame(); }
public static void EnsureFullPreviewVisible(Pixelmap currFrame, Form parentForm) { lock(s_SyncRoot) { if (s_FullPreviewForm != null) { try { // This will test if the form has been disposed if (!s_FullPreviewForm.Visible && s_FullPreviewForm.Handle == IntPtr.Zero) s_FullPreviewForm = null; } catch(ObjectDisposedException) { s_FullPreviewForm = null; } } if (s_FullPreviewForm == null) { s_FullPreviewForm = new frmFullSizePreview(); s_FullPreviewForm.Width = currFrame.Width + (s_FullPreviewForm.Width - s_FullPreviewForm.pictureBox.Width); s_FullPreviewForm.Height = currFrame.Height + (s_FullPreviewForm.Height - s_FullPreviewForm.pictureBox.Height); s_FullPreviewForm.Top = parentForm.Top; s_FullPreviewForm.Left = parentForm.Right; s_FullPreviewForm.StartPosition = FormStartPosition.Manual; } s_FullPreviewForm.pictureBox.Image = GetPreviewImage(currFrame); if (!s_FullPreviewForm.Visible) s_FullPreviewForm.Show(parentForm); s_FullPreviewForm.Refresh(); } }
public bool ArePixelmapsTheSame(Pixelmap bmp1, Pixelmap bmp2) { if (bmp1 == null && bmp2 == null) return true; if (bmp1 == null || bmp2 == null) return false; int x = m_Randomizer.Next(bmp1.Width - 1); int y = m_Randomizer.Next(bmp1.Height - 1); if (bmp1[x, y] != bmp2[x, y]) return false; x = m_Randomizer.Next(bmp1.Width - 1); y = m_Randomizer.Next(bmp1.Height - 1); if (bmp1[x, y] != bmp2[x, y]) return false; // Check all pixels int width = bmp1.Width; int height = bmp1.Height; for (y = 0; y < height; ++y) { for (x = 0; x < width; ++x) { if (bmp1[x, y] != bmp2[x, y]) return false; } } return true; }
public bool AddAviVideoFrame(Pixelmap pixmap, double addedGamma, int? adv16NormalisationValue) { if (!TangraVideo.AddAviVideoFrame(pixmap, addedGamma, adv16NormalisationValue)) { MessageBox.Show("There was an error calling AddAviVideoFrame:\r\n\r\n" + TangraVideo.GetLastAviErrorMessage(), "Tangra", MessageBoxButtons.OK, MessageBoxIcon.Error); return false; } return true; }
public void OnPreProcess(Pixelmap newFrame) { if (m_PreProcessors.Count > 0) { foreach (IFramePreProcessor preProcessor in m_PreProcessors) { preProcessor.OnPreProcess(newFrame); } } }
public void OnPreProcess(Pixelmap newFrame) { if (m_PreProcessFrames && newFrame != null) { if (m_Filter == TangraConfig.PreProcessingFilter.LowPassFilter) BitmapFilter.LowPassFilter(newFrame); else if (m_Filter == TangraConfig.PreProcessingFilter.LowPassDifferenceFilter) BitmapFilter.LowPassDifference(newFrame); } }
public SingleBitmapFileFrameStream(LCFile lightCurveFile) { m_lcFile = lightCurveFile; if (lightCurveFile.LcFileFormatVersion < 4 && m_lcFile.Footer.AveragedFrameBytes.Length == 4 * m_lcFile.Footer.AveragedFrameWidth * m_lcFile.Footer.AveragedFrameHeight) m_Pixelmap = Pixelmap.ConstructForLCFile32bppArgbAveragedFrame(m_lcFile.Footer.AveragedFrameBytes, m_lcFile.Footer.AveragedFrameWidth, m_lcFile.Footer.AveragedFrameHeight, m_lcFile.Footer.AveragedFrameBpp); else m_Pixelmap = Pixelmap.ConstructForLCFileAveragedFrame(m_lcFile.Footer.AveragedFrameBytes, m_lcFile.Footer.AveragedFrameWidth, m_lcFile.Footer.AveragedFrameHeight, m_lcFile.Footer.AveragedFrameBpp); m_FirstFrame = (int)m_lcFile.Header.MinFrame; m_LastFrame = (int)m_lcFile.Header.MaxFrame; m_NumFrames = (int)m_lcFile.Header.MeasuredFrames; }
public static Bitmap ConstructBitmapFrom8BitPixelmap(Pixelmap image) { float background = 0; float range = 255; bool hasRangeChange = false; var bmp = new Bitmap(image.Width, image.Height, PixelFormat.Format24bppRgb); // GDI+ still lies to us - the return format is BGR, NOT RGB. BitmapData bmData = bmp.LockBits(new Rectangle(0, 0, bmp.Width, bmp.Height), ImageLockMode.ReadWrite, PixelFormat.Format24bppRgb); int stride = bmData.Stride; System.IntPtr Scan0 = bmData.Scan0; unsafe { byte *p = (byte *)(void *)Scan0; int nOffset = stride - bmp.Width * 3; for (int y = 0; y < bmp.Height; ++y) { for (int x = 0; x < bmp.Width; ++x) { byte color; if (hasRangeChange) { float displayValue = (image[x, y] - background) * 255.0f / range; color = (byte)Math.Max(0, Math.Min(255, Math.Round(displayValue))); } else { color = (byte)(image[x, y] & 0xFF); } p[0] = color; p[1] = color; p[2] = color; p += 3; } p += nOffset; } } bmp.UnlockBits(bmData); return(bmp); }
public MeasurementsHelper( int bitPix, TangraConfig.BackgroundMethod backgroundMethod, int subPixelSquare, uint saturationValue) { m_BitPix = bitPix; m_MaxPixelValue = Pixelmap.GetMaxValueForBitPix(m_BitPix); m_BackgroundMethod = backgroundMethod; m_SubPixelSquare = subPixelSquare; m_SaturationValue = saturationValue; m_TimesHigherPositionToleranceForFullyOccultedStars = TangraConfig.Settings.Special.TimesHigherPositionToleranceForFullyOccultedStars; }
public static void GenerateNoise(Pixelmap pixelmap, int[,] simulatedBackground, int mean, int stdDev) { uint maxSignalValue = pixelmap.MaxSignalValue; for (int y = 0; y < pixelmap.Height; ++y) { for (int x = 0; x < pixelmap.Width; ++x) { double bgPixel = Math.Min(maxSignalValue, Math.Max(0, simulatedBackground[x, y] + Math.Abs(Random(mean, stdDev)))); uint val = (uint)Math.Round(bgPixel); pixelmap[x, y] = val; } } }
public void PlateSolve(PlateSolveTesterConfig config) { var pixelMap = new Pixelmap(config.Width, config.Height, config.BitPix, config.Pixels, null, null); var image = new AstroImage(pixelMap); StarMap starMap = new StarMap( TangraConfig.Settings.Astrometry.PyramidRemoveNonStellarObject, TangraConfig.Settings.Astrometry.MinReferenceStarFWHM, TangraConfig.Settings.Astrometry.MaxReferenceStarFWHM, TangraConfig.Settings.Astrometry.MaximumPSFElongation, TangraConfig.Settings.Astrometry.LimitReferenceStarDetection); Rectangle excludeRect = new Rectangle(config.OSDRectToExclude.X, config.OSDRectToExclude.Y, config.OSDRectToExclude.Width, config.OSDRectToExclude.Height); Rectangle includeRect = new Rectangle(config.RectToInclude.X, config.RectToInclude.Y, config.RectToInclude.Width, config.RectToInclude.Height); starMap.FindBestMap( StarMapInternalConfig.Default, image, excludeRect, includeRect, config.LimitByInclusion); var facade = new StarCatalogueFacade(TangraConfig.Settings.StarCatalogue); var catalogueStars = facade.GetStarsInRegion( config.RADeg, config.DEDeg, (config.ErrFoVs + 1.0) * config.PlateConfig.GetMaxFOVInArcSec() / 3600.0, config.LimitMagn, config.Epoch); var distBasedMatcher = new DistanceBasedAstrometrySolver( new MockedOperationNotifier(), config.PlateConfig, TangraConfig.Settings.Astrometry, catalogueStars, config.DetermineAutoLimitMagnitude); distBasedMatcher.SetMinMaxMagOfStarsForAstrometry(config.PyramidMinMag, config.LimitMagn); distBasedMatcher.SetMinMaxMagOfStarsForPyramidAlignment(config.PyramidMinMag, config.PyramidMaxMag); distBasedMatcher.InitNewMatch(starMap, PyramidMatchType.PlateSolve, null); distBasedMatcher.InitNewFrame(starMap); distBasedMatcher.SetManuallyIdentifiedHints(new Dictionary<PSFFit, IStar>()); LeastSquareFittedAstrometry astrometricFit; PerformMatchResult result = distBasedMatcher.PerformMatch(out astrometricFit); }
public void OnPreProcess(Pixelmap newFrame) { Trace.Assert(newFrame.BitPixCamera <= 16); if (m_PreProcessFrames && newFrame != null) { for (int y = 0; y < newFrame.Height; ++y) { for (int x = 0; x < newFrame.Width; ++x) { newFrame[x, y] = m_MappedBytes[newFrame[x, y]]; } } } }
public Pixelmap(Pixelmap cloneFrom) { Width = cloneFrom.Width; Height = cloneFrom.Height; BitPixCamera = cloneFrom.m_BitPix; m_Pixels = cloneFrom.m_Pixels; m_DisplayBitmapPixels = cloneFrom.m_DisplayBitmapPixels; m_MaxSignalValue = cloneFrom.m_MaxSignalValue; try { m_Bitmap = cloneFrom.DisplayBitmap != null ? (Bitmap)cloneFrom.DisplayBitmap.Clone() : null; } catch (Exception ex) { Trace.WriteLine(ex); Trace.Assert(false); } }
public Pixelmap(Pixelmap cloneFrom) { Width = cloneFrom.Width; Height = cloneFrom.Height; BitPixCamera = cloneFrom.m_BitPix; m_Pixels = cloneFrom.m_Pixels; m_DisplayBitmapPixels = cloneFrom.m_DisplayBitmapPixels; m_MaxSignalValue = cloneFrom.m_MaxSignalValue; try { m_Bitmap = cloneFrom.DisplayBitmap != null ? (Bitmap) cloneFrom.DisplayBitmap.Clone() : null; } catch (Exception ex) { Trace.WriteLine(ex); Trace.Assert(false); } }
public FrameByteBrightnessContrast(int brigtness, int contrast, bool preProcessFrames, int bitPix) : base(preProcessFrames, bitPix) { m_Brigtness = brigtness; m_Contrast = (sbyte)contrast; uint maxPixelValue = bitPix.GetMaxValueForBitPix(); Trace.Assert(maxPixelValue <= int.MaxValue, "32bit images not supported."); Pixelmap image = new Pixelmap((int)maxPixelValue + 1, 1, bitPix, new uint[maxPixelValue + 1], null, null); { for (int i = 0; i <= maxPixelValue; i++) image[i, 0] = (uint)i; BitmapFilter.Brightness(image, m_Brigtness); BitmapFilter.Contrast(image, m_Contrast); for (int i = 0; i <= maxPixelValue; i++) m_MappedBytes[i] = image[i, 0]; } }
public SingleBitmapFileFrameStream(Bitmap bitmap) { try { m_Pixelmap = Pixelmap.ConstructFromBitmap(bitmap, TangraConfig.ColourChannel.Red); } catch (ArgumentException ex) { // If there is something wrong with the Bitmap, then create a blank(black) frame Trace.WriteLine(ex); m_Pixelmap = new Pixelmap( bitmap.Width, bitmap.Height, 8, new uint[bitmap.Width*bitmap.Height], new Bitmap(bitmap.Width, bitmap.Height, PixelFormat.Format24bppRgb), new byte[3 * bitmap.Width * bitmap.Height]); } m_FirstFrame = 0; m_LastFrame = 0; m_NumFrames = 1; }
internal ucCalibrationPanel(AstrometryController astrometryController, VideoController videoController, IPlateCalibrationTool configTool) { InitializeComponent(); m_AstrometryController = astrometryController; m_VideoController = videoController; m_CalibrationTool = configTool; m_CalibrationTool.AreaChanged += m_CalibrationTool_AreaChanged; pnlDebugFits.Visible = false; m_AstrometryController.RegisterCalibrationRunner(this); rbIdentify3Stars.Checked = true; UpdateEnabledStateOfScrollControls(); m_InitialPixelmap = m_VideoController.GetCurrentAstroImage(false).Pixelmap; m_VideoController.ApplyDisplayModeAdjustments(m_InitialPixelmap.DisplayBitmap, false, m_InitialPixelmap); m_CalibrationTool.ActivateOsdAreaSizing(); rbInclusion.Checked = TangraConfig.Settings.PlateSolve.SelectedScopeRecorderConfig.IsInclusionArea; }
public Pixelmap Rotate(double angleDegrees) { int newWidth = Width; int newHeight = Height; TangraModelCore.GetRotatedFrameDimentions(Width, Height, angleDegrees, ref newWidth, ref newHeight); uint[] pixels = new uint[newWidth * newHeight]; byte[] displayBitmapBytes = new byte[newWidth * newHeight]; byte[] rawBitmapBytes = new byte[GetBitmapBIRGBPixelArraySize(24, Width, Height) + 40 + 14 + 1]; TangraModelCore.RotateFrame(Width, Height, angleDegrees, m_Pixels, newWidth, newHeight, pixels, rawBitmapBytes, displayBitmapBytes, (short)m_BitPix, m_MaxSignalValue.HasValue ? m_MaxSignalValue.Value : 0); using (var memStr = new MemoryStream(rawBitmapBytes)) { Bitmap displayBitmap; try { displayBitmap = (Bitmap)Bitmap.FromStream(memStr); } catch (Exception ex) { Trace.WriteLine(ex.GetFullStackTrace()); displayBitmap = new Bitmap(newWidth, newHeight); } var rv = new Pixelmap(newWidth, newHeight, m_BitPix, pixels, displayBitmap, displayBitmapBytes); if (m_MaxSignalValue.HasValue) { rv.SetMaxSignalValue(m_MaxSignalValue.Value); } rv.FrameState = FrameState; return(rv); } }
private void ProcessCurrentImage() { if (m_CurrentIndex >= 0 && m_CurrentIndex < m_InputFiles.Count) { string fileName = m_InputFiles[m_CurrentIndex]; lblDisplayedFile.Text = fileName; m_CurrentImage = (Bitmap)Bitmap.FromFile(fileName); m_Pixelmap = Pixelmap.ConstructFromBitmap(m_CurrentImage, TangraConfig.ColourChannel.Red); using (Graphics g = Graphics.FromImage(m_CurrentImage)) { m_Processor.Process(m_Pixelmap.Pixels, m_Pixelmap.Width, m_Pixelmap.Height, g, m_CurrentIndex, m_CurrentIndex % 2 == 0); g.Flush(); } picField.Image = m_CurrentImage; picField.Update(); lblBlockWidth.Text = m_Processor.BlockWidth.ToString(); lblBlockHeight.Text = m_Processor.BlockHeight.ToString(); lblBlockXOffs.Text = m_Processor.BlockOffsetX.ToString(); if (m_Processor.BlockOffsetYOdd != m_Processor.BlockOffsetYEven) lblBlockYOffs.Text = string.Format("o:{0} e:{1}", m_Processor.BlockOffsetYOdd, m_Processor.BlockOffsetYEven); else lblBlockYOffs.Text = m_Processor.BlockOffsetYOdd.ToString(); PlotDigitPatterns(); if (string.IsNullOrEmpty(m_Processor.CurrentOcredString)) lblOcredText.Text = ""; else lblOcredText.Text = m_Processor.CurrentOcredString; } }
private void DisplayCurrentFrameInternal(MovementType movementType, Pixelmap currentPixelmap, string frameFileName) { if (m_VideoStream != null) { if (m_CurrentFrameIndex >= m_VideoStream.FirstFrame && m_CurrentFrameIndex <= m_VideoStream.LastFrame) { m_FrameRenderer.RenderFrame(m_CurrentFrameIndex, currentPixelmap, movementType, m_CurrentFrameIndex == m_VideoStream.LastFrame, 0, m_CurrentFrameIndex, frameFileName); m_LastDisplayedFrameIndex = m_CurrentFrameIndex; } } }
public Pixelmap GetPixelmap(int index) { if (index < FirstFrame) index = FirstFrame; if (index > LastFrame) index = LastFrame; uint[] pixels; uint[] originalPixels; Bitmap videoFrame; byte[] bitmapBytes; TangraVideo.GetFrame(index, out pixels, out originalPixels, out videoFrame, out bitmapBytes); var rv = new Pixelmap(Width, Height, 8, pixels, videoFrame, bitmapBytes); rv.UnprocessedPixels = originalPixels; return rv; }
public Pixelmap GetIntegratedFrame(int startFrameNo, int framesToIntegrate, bool isSlidingIntegration, bool isMedianAveraging) { if (startFrameNo < FirstFrame) startFrameNo = FirstFrame; if (startFrameNo > LastFrame) startFrameNo = LastFrame; uint[] pixels; uint[] originalPixels; Bitmap videoFrame; byte[] bitmapBytes; TangraVideo.GetIntegratedFrame(startFrameNo, framesToIntegrate, isSlidingIntegration, isMedianAveraging, out pixels, out originalPixels, out videoFrame, out bitmapBytes); var rv = new Pixelmap(Width, Height, 8, pixels, videoFrame, bitmapBytes); rv.UnprocessedPixels = originalPixels; return rv; }
public AstroImage(Pixelmap pixelmap, Rectangle processArea, bool useUnprocessedPixels = false) { if (useUnprocessedPixels) { m_Pixelmap = new Pixelmap(pixelmap.Width, pixelmap.Height, pixelmap.BitPixCamera, new uint[pixelmap.Pixels.Length], null, null); m_Pixelmap.SetMaxSignalValue(pixelmap.MaxSignalValue); for (int i = 0; i < pixelmap.Pixels.Length; i++) { m_Pixelmap.Pixels[i] = pixelmap.UnprocessedPixels[i]; } } else m_Pixelmap = pixelmap; m_Rect = processArea; m_Width = m_Pixelmap.Width; m_Height = m_Pixelmap.Height; m_BitPix = m_Pixelmap.BitPixCamera; if (m_Rect.Width > m_Width) m_Rect.Width = m_Width; if (m_Rect.Height > m_Height) m_Rect.Height = m_Height; }
private void GenerateFrame(Pixelmap pixmap, List<IStar> stars, ModelConfig modelConfig) { var mea = new MeasurementsHelper( pixmap.BitPixCamera, TangraConfig.BackgroundMethod.BackgroundMedian, TangraConfig.Settings.Photometry.SubPixelSquareSize, TangraConfig.Settings.Photometry.Saturation.GetSaturationForBpp(pixmap.BitPixCamera, pixmap.MaxSignalValue)); float apertureSize = APERTURE; float annulusInnerRadius = (GAP + APERTURE) / APERTURE; int annulusMinPixels = (int)(Math.PI * (Math.Pow(ANNULUS + GAP + APERTURE, 2) - Math.Pow(GAP + APERTURE, 2))); mea.SetCoreProperties(annulusInnerRadius, annulusMinPixels, CorePhotometrySettings.Default.RejectionBackgroundPixelsStdDev, 2 /* TODO: This must be configurable */); var measurements = new Dictionary<IStar, double>(); foreach (IStar star in stars) { double x, y; GetOnPlateCoordinates(star.RADeg, star.DEDeg, modelConfig, out x, out y); if (x < 0 || x > modelConfig.FrameWidth || y < 0 || y > modelConfig.FrameHeight) continue; float starMag = GetStarMag(star, modelConfig.PhotometricFilter); float iMax = ModelStarAmplitude(star, starMag, modelConfig, pixmap.BitPixCamera, pixmap.MaxSignalValue); if (!float.IsNaN(iMax)) { VideoModelUtils.GenerateStar(pixmap, (float)x, (float)y, (float)modelConfig.FWHM, iMax, 0 /*Use Gaussian */); if (modelConfig.CheckMagnitudes) { var image = new AstroImage(pixmap); uint[,] data = image.GetMeasurableAreaPixels((int)x, (int)y, 17); uint[,] backgroundPixels = image.GetMeasurableAreaPixels((int)x, (int)y, 35); PSFFit fit = new PSFFit((int)x, (int)y); fit.Fit(data); var result = mea.MeasureObject(new ImagePixel(x, y), data, backgroundPixels, pixmap.BitPixCamera, TangraConfig.PreProcessingFilter.NoFilter, TangraConfig.PhotometryReductionMethod.AperturePhotometry, TangraConfig.PsfQuadrature.NumericalInAperture, TangraConfig.PsfFittingMethod.DirectNonLinearFit, apertureSize, modelConfig.FWHM, (float)modelConfig.FWHM, new FakeIMeasuredObject(fit), null, null, false); if (result == NotMeasuredReasons.TrackedSuccessfully && !mea.HasSaturatedPixels) { // Add value for fitting measurements.Add(star, mea.TotalReading - mea.TotalBackground); } } } } if (modelConfig.CheckMagnitudes) CalculateGagnitudeFit(measurements, modelConfig.BVSlope); }
public Pixelmap GetPixelmap(int index) { byte[] displayBitmapBytes = new byte[m_Width * m_Height]; byte[] rawBitmapBytes = new byte[(m_Width * m_Height * 3) + 40 + 14 + 1]; uint[] flatPixelsCopy = new uint[m_FlatPixels.Length]; Array.Copy(m_FlatPixels, flatPixelsCopy, m_FlatPixels.Length); TangraCore.PreProcessors.ApplyPreProcessingPixelsOnly(flatPixelsCopy, m_Width, m_Height, m_Bpp, 0 /* No normal value for FITS files */, m_Exposure); TangraCore.GetBitmapPixels(m_Width, m_Height, flatPixelsCopy, rawBitmapBytes, displayBitmapBytes, true, (ushort)m_Bpp, 0); Bitmap displayBitmap = Pixelmap.ConstructBitmapFromBitmapPixels(displayBitmapBytes, m_Width, m_Height); Pixelmap rv = new Pixelmap(m_Width, m_Height, m_Bpp, flatPixelsCopy, displayBitmap, displayBitmapBytes); return rv; }
public Pixelmap GetPixelmap(int index) { if (index < FirstFrame) index = FirstFrame; if (index > LastFrame) index = LastFrame; uint[] pixels; uint[] originalPixels; Bitmap videoFrame; byte[] bitmapBytes; if (Mode == ReInterlaceMode.SwapFields) { TangraVideo.GetFrame(index, out pixels, out originalPixels, out videoFrame, out bitmapBytes); byte[] bitmapPixels = new byte[Width * Height * 3 + 40 + 14 + 1]; TangraCore.SwapVideoFields(pixels, originalPixels, Width, Height, bitmapPixels, bitmapBytes); videoFrame = Pixelmap.ConstructBitmapFromBitmapPixels(bitmapBytes, Width, Height); var rv = new Pixelmap(Width, Height, 8, pixels, videoFrame, bitmapBytes); rv.UnprocessedPixels = originalPixels; return rv; } else if (Mode == ReInterlaceMode.ShiftOneField || Mode == ReInterlaceMode.SwapAndShiftOneField) { uint[] pixels2; uint[] originalPixels2; Bitmap videoFrame2; byte[] bitmapBytes2; if (m_LastPrevFrameId == index) { pixels = m_LastPrevFramePixels; originalPixels = m_LastPrevFrameOriginalPixels; bitmapBytes = m_LastPrevFrameBitmapBytes; } else TangraVideo.GetFrame(index, out pixels, out originalPixels, out videoFrame, out bitmapBytes); TangraVideo.GetFrame(index + 1, out pixels2, out originalPixels2, out videoFrame2, out bitmapBytes2); m_LastPrevFrameId = index + 1; m_LastPrevFramePixels = pixels2; m_LastPrevFrameOriginalPixels = originalPixels2; m_LastPrevFrameBitmapBytes = bitmapBytes2; byte[] bitmapPixels = new byte[Width * Height * 3 + 40 + 14 + 1]; TangraCore.ShiftVideoFields(pixels, originalPixels, pixels2, originalPixels2, Width, Height, m_ShiftMode, bitmapPixels, bitmapBytes); videoFrame = Pixelmap.ConstructBitmapFromBitmapPixels(bitmapBytes, Width, Height); var rv = new Pixelmap(Width, Height, 8, pixels, videoFrame, bitmapBytes); rv.UnprocessedPixels = originalPixels; return rv; } else if (Mode == ReInterlaceMode.None) { return m_BaseStream.GetPixelmap(index); } else throw new NotSupportedException(); }
public static void GenerateStar(Pixelmap pixelmap, float x0, float y0, float fwhm, float iMax, int psfModel) { double r0 = fwhm / (2 * Math.Sqrt(Math.Log(2))); int maxPsfModelDist = (int)(6 * fwhm); uint maxSignalValue = pixelmap.MaxSignalValue; double fiveThirds = 5.0 / 3.0; for (int y = 0; y < pixelmap.Height; ++y) { for (int x = 0; x < pixelmap.Width; ++x) { if (Math.Abs(x - x0) < maxPsfModelDist && Math.Abs(y - y0) < maxPsfModelDist) { int counter = 0; double sum = 0; for (double dx = -0.5; dx < 0.5; dx += 0.1) { for (double dy = -0.5; dy < 0.5; dy += 0.1) { double modelVal = 0; if (psfModel == 0) modelVal = iMax * Math.Exp(-((x + dx - x0) * (x + dx - x0) + (y + dy - y0) * (y + dy - y0)) / (r0 * r0)); else if (psfModel == 1) modelVal = iMax * Math.Exp(-(Math.Pow((x + dx - x0), fiveThirds) + Math.Pow((y + dy - y0), fiveThirds)) / (r0 * r0)); double thisVal = Math.Min(maxSignalValue, Math.Max(0, modelVal)); sum += thisVal; counter++; } } long val = (long)Math.Round(sum / counter); val += (long)pixelmap[x, y]; pixelmap[x, y] = (uint)Math.Min(maxSignalValue, Math.Max(0, val)); } } } }
public static bool LowPassFilter(Pixelmap b) { return(Convolution.Conv3x3(b, LOW_PASS_FILTER_MATRIX)); }
private void GenerateAAVVideo(ModelConfig modelConfig, List<IStar> stars) { AavFileCreator.CloseFile(); AavFileCreator.StartNewFile(modelConfig.FileName, modelConfig.FrameWidth, modelConfig.FrameHeight, modelConfig.Integration); m_MagnitudeToPeakDict = null; try { //Pixelmap pixmap = new Pixelmap(modelConfig.FrameWidth, modelConfig.FrameHeight, bitPix, new uint[modelConfig.FrameWidth * modelConfig.FrameHeight], null, null); //AddOnScreenText(bmp, modelConfig, "The simulated video stars from the next frame"); //TangraVideo.AddAviVideoFrame(pixmap, modelConfig.Gamma, null); DateTime zeroFrameDT = DateTime.UtcNow; uint maxSignalValue = (uint)(255 * modelConfig.Integration); Random rndGen = new Random((int)DateTime.Now.Ticks); m_SimulatedDarkFrame = new int[modelConfig.FrameWidth, modelConfig.FrameHeight]; for (int x = 0; x < modelConfig.FrameWidth; x++) for (int y = 0; y < modelConfig.FrameHeight; y++) { if (modelConfig.DarkFrameMean > 0) { double randomPeak = rndGen.Next(0, 100) == 66 ? 255 : 0; double darkPixel = Math.Abs(VideoModelUtils.Random((modelConfig.DarkFrameMean + randomPeak) * modelConfig.Integration, 1)); double bgPixel = Math.Min(maxSignalValue, Math.Max(0, darkPixel)); m_SimulatedDarkFrame[x, y] = (int)bgPixel; } else m_SimulatedDarkFrame[x, y] = 0; } for (int i = 0; i <= modelConfig.TotalFrames; i++) { using (Pixelmap pixmap = new Pixelmap(modelConfig.FrameWidth, modelConfig.FrameHeight, 16, new uint[modelConfig.FrameWidth * modelConfig.FrameHeight], null, null)) { pixmap.SetMaxSignalValue(maxSignalValue); VideoModelUtils.GenerateNoise(pixmap, m_SimulatedDarkFrame, modelConfig.NoiseMean * modelConfig.Integration, modelConfig.NoiseStdDev * modelConfig.Integration); GenerateFrame(pixmap, stars, modelConfig); DateTime startDT = zeroFrameDT.AddMilliseconds(40 * modelConfig.Integration * i); if (Math.Abs(modelConfig.LinearityCoefficient - 1) > 0.0001) { uint maxVal = pixmap.MaxSignalValue; double gammaCoeff = maxVal / Math.Pow((double)maxVal, modelConfig.LinearityCoefficient); for (int x = 0; x < pixmap.Width; x++) { for (int y = 0; y < pixmap.Height; y++) { uint nonLinVal = (uint)Math.Round(gammaCoeff * Math.Pow(pixmap[x, y], modelConfig.LinearityCoefficient)); pixmap[x, y] = Math.Min(maxVal, Math.Max(0, nonLinVal)); } } } AavFileCreator.AddVideoFrame(startDT, startDT.AddMilliseconds(40 * modelConfig.Integration), pixmap); } InvokeUpdateUI(2, (int)(100.0 * i / modelConfig.TotalFrames), true); } } finally { AavFileCreator.CloseFile(); } }
private void GenerateAVIVideo(ModelConfig modelConfig, List<IStar> stars) { TangraVideo.CloseAviFile(); TangraVideo.StartNewAviFile(modelConfig.FileName, modelConfig.FrameWidth, modelConfig.FrameHeight, 8, 25, false); m_MagnitudeToPeakDict = null; try { //Pixelmap pixmap = new Pixelmap(modelConfig.FrameWidth, modelConfig.FrameHeight, bitPix, new uint[modelConfig.FrameWidth * modelConfig.FrameHeight], null, null); //AddOnScreenText(bmp, modelConfig, "The simulated video stars from the next frame"); //TangraVideo.AddAviVideoFrame(pixmap, modelConfig.Gamma, null); uint maxSignalValue = (uint)(255 * modelConfig.Integration); Random rndGen = new Random((int)DateTime.Now.Ticks); m_SimulatedDarkFrame = new int[modelConfig.FrameWidth, modelConfig.FrameHeight]; for (int x = 0; x < modelConfig.FrameWidth; x++) for (int y = 0; y < modelConfig.FrameHeight; y++) { if (modelConfig.DarkFrameMean > 0) { double randomPeak = rndGen.Next(0, 100) == 66 ? 255 : 0; double darkPixel = Math.Abs(VideoModelUtils.Random((modelConfig.DarkFrameMean + randomPeak)* modelConfig.Integration, 1)); double bgPixel = Math.Min(maxSignalValue, Math.Max(0, darkPixel)); m_SimulatedDarkFrame[x, y] = (int)bgPixel; } else m_SimulatedDarkFrame[x, y] = 0; } for (int i = 0; i <= modelConfig.TotalFrames; i++) { using (Pixelmap pixmap = new Pixelmap(modelConfig.FrameWidth, modelConfig.FrameHeight, 16, new uint[modelConfig.FrameWidth * modelConfig.FrameHeight], null, null)) { pixmap.SetMaxSignalValue(maxSignalValue); VideoModelUtils.GenerateNoise(pixmap, m_SimulatedDarkFrame, modelConfig.NoiseMean * modelConfig.Integration, modelConfig.NoiseStdDev * modelConfig.Integration); GenerateFrame(pixmap, stars, modelConfig); TangraVideo.AddAviVideoFrame(pixmap, modelConfig.LinearityCoefficient, (int)pixmap.MaxSignalValue); } InvokeUpdateUI(2, (int)(100.0 * i / modelConfig.TotalFrames), true); } } finally { TangraVideo.CloseAviFile(); } }
public static uint GetMedian(Pixelmap image) { List<uint> allPixels = new List<uint>(); for (int y = 0; y < image.Height; ++y) { for (int x = 0; x < image.Width; ++x) { allPixels.Add(image[x, y]); } } allPixels.Sort(); return allPixels[allPixels.Count / 2]; }
private void InitStarAmplitudeModelling(ModelConfig modelConfig, float accuracy, int bitPix, uint maxSignalValue) { if (m_MagnitudeToPeakDict != null) return; m_MagnitudeToPeakDict = new Dictionary<double, int>(); m_MagnitudeToPeakMags = new List<double>(); m_MagnitudeToPeakPeaks = new List<int>(); var mea = new MeasurementsHelper( bitPix, TangraConfig.BackgroundMethod.BackgroundMedian, TangraConfig.Settings.Photometry.SubPixelSquareSize, TangraConfig.Settings.Photometry.Saturation.GetSaturationForBpp(bitPix, maxSignalValue)); float apertureSize = APERTURE; float annulusInnerRadius = (GAP + APERTURE) / APERTURE; int annulusMinPixels = (int)(Math.PI * (Math.Pow(ANNULUS + GAP + APERTURE, 2) - Math.Pow(GAP + APERTURE, 2))); mea.SetCoreProperties(annulusInnerRadius, annulusMinPixels, CorePhotometrySettings.Default.RejectionBackgroundPixelsStdDev, 2 /* TODO: This must be configurable */); int peak = (int)(maxSignalValue - (modelConfig.NoiseMean + modelConfig.DarkFrameMean) * modelConfig.Integration); int TOTAL_STEPS = 100; double step = Math.Log10(peak) / TOTAL_STEPS; double zeroMag = double.NaN; for (int ii = 0; ii < TOTAL_STEPS; ii++) { int amplitude = (int)Math.Round(Math.Pow(10, Math.Log10(peak) - ii * step)); Pixelmap pixmap = new Pixelmap(64, 64, bitPix, new uint[64 * 64], null, null); VideoModelUtils.GenerateStar(pixmap, 32, 32, (float)modelConfig.FWHM, amplitude, 0 /* Gaussian */); PSFFit fit = new PSFFit(32, 32); AstroImage img = new AstroImage(pixmap); uint[,] data = img.GetMeasurableAreaPixels(32, 32, 17); uint[,] backgroundPixels = img.GetMeasurableAreaPixels(32, 32, 35); fit.Fit(data); var result = mea.MeasureObject(new ImagePixel(32, 32), data, backgroundPixels, pixmap.BitPixCamera, TangraConfig.PreProcessingFilter.NoFilter, TangraConfig.PhotometryReductionMethod.AperturePhotometry, TangraConfig.PsfQuadrature.NumericalInAperture, TangraConfig.PsfFittingMethod.DirectNonLinearFit, apertureSize, modelConfig.FWHM, (float)modelConfig.FWHM, new FakeIMeasuredObject(fit), null, null, false); if (result == NotMeasuredReasons.TrackedSuccessfully && !mea.HasSaturatedPixels) { // Add value for fitting double measurement = mea.TotalReading - mea.TotalBackground; if (double.IsNaN(zeroMag)) zeroMag = modelConfig.BrighestUnsaturatedStarMag + 2.5 * Math.Log10(measurement); double magnitude = -2.5 * Math.Log10(measurement) + zeroMag; m_MagnitudeToPeakDict[magnitude] = amplitude; m_MagnitudeToPeakMags.Add(magnitude); m_MagnitudeToPeakPeaks.Add(amplitude); } } }
public AstroImage(Pixelmap pixelmap, bool useUnprocessedPixels = false) : this(pixelmap, new Rectangle(0, 0, pixelmap.Width, pixelmap.Height), useUnprocessedPixels) { }