예제 #1
0
파일: ImageWindow.cs 프로젝트: poles-p/SARA
 /// <summary>
 /// Show image.
 /// </summary>
 /// <param name="image">
 /// Image to show.
 /// </param>
 public void ShowImage(FloatMatrix image)
 {
     if (_imgForm == null || _imgForm.IsClosed)
         _imgForm = ImageForm.ShowImage(image);
     else
         _imgForm.SetImage(image);
 }
예제 #2
0
파일: ImageForm.cs 프로젝트: poles-p/SARA
        /// <summary>
        /// Creates new <see cref="ImageForm"/> to show specified image. Form use another thread,
        /// so program is not blocked.
        /// </summary>
        /// <param name="image"></param>
        /// <returns></returns>
        public static ImageForm ShowImage(FloatMatrix image)
        {
            ImageForm form = new ImageForm(image);

            Thread thread = new Thread(new ThreadStart(form.ThreadFunction));
            thread.Start();

            return form;
        }
예제 #3
0
        /// <summary>
        /// Calculate master flat of specified flat sequence. Function subtract bias from every flat image,
        /// and returns normed sum of obtained images.
        /// </summary>
        /// <param name="flatSequence">
        /// Sequence of flat images.
        /// </param>
        /// <param name="bias">
        /// master bias for flat.
        /// </param>
        /// <returns>
        /// Calculated master flat.
        /// </returns>
        public static FloatMatrix MasterFlat(IEnumerable<FloatMatrix> flatSequence, FloatMatrix bias)
        {
            FloatMatrix result = SequenceMean(flatSequence);
            result.Subtract(bias);

            // Norm flat
            float pixMean = 0.0f;
            foreach (float v in result.Data)
                pixMean += v;

            result.Divide(pixMean / (float)result.Size);

            return result;
        }
예제 #4
0
        /// <summary>
        /// Convert <see cref="FloatMatrix"/> to <see cref="Bitmap"/>. Only for 2D matrices.
        /// </summary>
        /// <param name="matrix">
        /// Matrix to convert.
        /// </param>
        /// <returns>
        /// <see cref="Bitmap"/> that represents specified matrix.
        /// </returns>
        public Bitmap ToBitmap(FloatMatrix matrix)
        {
            if (matrix.Dimensions.Length != 2)
                throw new ArgumentException("Expected 2D matrix");

            int xSize = matrix.Dimensions[0];
            int ySize = matrix.Dimensions[1];

            int[] tmpArray = new int[xSize * ySize];
            Bitmap result;

            float c = 255.0f / (_max - _min);

            unsafe
            {
                fixed (int* dstPtr = tmpArray)
                {
                    fixed (float* srcPtr = matrix.Data)
                    {
                        int pos = 0;
                        for (int y = 0; y < ySize; y++)
                        {
                            int rowPos = (ySize - y - 1) * xSize;
                            for (int x = 0; x < xSize; x++)
                            {
                                float ftmp = (srcPtr[pos] - _min) * c;
                                int itmp = (ftmp < 0.0f) ? 0 : (ftmp > 255.0f) ? 255 : (int)ftmp;
                                dstPtr[rowPos] = itmp | (itmp << 8) | (itmp << 16);
                                pos++;
                                rowPos++;
                            }
                        }
                    }
                    result = new Bitmap(matrix.Dimensions[0],
                            matrix.Dimensions[1],
                            matrix.Dimensions[0] * 4,
                            System.Drawing.Imaging.PixelFormat.Format32bppRgb,
                            new IntPtr(dstPtr));
                    result = result.Clone(new Rectangle(new Point(0, 0), result.Size), System.Drawing.Imaging.PixelFormat.Format24bppRgb);
                }
            }

            return result;
        }
예제 #5
0
        /// <summary>
        /// Calculate mean image of sequene (every pixel contains mean of corresponding pixels values from sequence).
        /// </summary>
        /// <param name="sequecne">
        /// Sequence to calculate mean. Every images have to have same dimensions.
        /// </param>
        /// <returns>
        /// Mean of sequence.
        /// </returns>
        public static FloatMatrix SequenceMean(IEnumerable<FloatMatrix> sequecne)
        {
            FloatMatrix result = new FloatMatrix(new DataMatrix<float>(sequecne.First().Dimensions));
            int num = 0;

            foreach (FloatMatrix bias in sequecne)
            {
                result.Add(bias);
                num++;
            }
            result.Divide((float)num);

            return result;
        }
예제 #6
0
파일: ImageForm.cs 프로젝트: poles-p/SARA
        /// <summary>
        /// Create <see cref="ImageForm"/> that contains specified image.
        /// </summary>
        /// <param name="image">
        /// Image drawed on form.
        /// </param>
        /// <remarks>
        /// To simple show image use <see cref="ShowImage"/>.
        /// </remarks>
        public ImageForm(FloatMatrix image)
        {
            SetImage(image);

            SetStyle(ControlStyles.AllPaintingInWmPaint | ControlStyles.UserPaint | ControlStyles.DoubleBuffer, true);
        }
예제 #7
0
파일: AutoFoto0.cs 프로젝트: poles-p/SARA
        private IEnumerable<FloatMatrix> Debias2(IEnumerable<FloatMatrix> source, int length, FloatMatrix bias1, FloatMatrix bias2)
        {
            if (length <= 1)
            {
                FloatMatrix bias = bias1 * 0.5f;
                bias.Add(bias2 * 0.5f);

                foreach (FloatMatrix image in source)
                {
                    yield return image - bias;
                }
            }
            else
            {
                float a = 1.0f / (float)(length - 1);
                int n = 0;

                foreach (FloatMatrix image in source)
                {
                    float c = (float)n;

                    FloatMatrix bias = bias2 * c;
                    bias.Add(bias1 * (1.0f - c));

                    yield return image - bias;
                }
            }
        }
예제 #8
0
파일: AutoFoto0.cs 프로젝트: poles-p/SARA
        private IEnumerable<FloatMatrix> Deflat2(IEnumerable<FloatMatrix> source, int length, FloatMatrix flat1, FloatMatrix flat2)
        {
            if (length <= 1)
            {
                FloatMatrix flat = flat1 * 0.5f;
                flat.Add(flat2 * 0.5f);

                foreach (FloatMatrix image in source)
                {
                    yield return image / flat;
                }
            }
            else
            {
                float a = 1.0f / (float)(length - 1);
                int n = 0;

                foreach (FloatMatrix image in source)
                {
                    float c = (float)n;

                    FloatMatrix flat = flat2 * c;
                    flat.Add(flat1 * (1.0f - c));

                    yield return image / flat;
                }
            }
        }
예제 #9
0
파일: ImageForm.cs 프로젝트: poles-p/SARA
        /// <summary>
        /// Set image to draw on form. New image will cover previous, and window will be resized to new image.
        /// </summary>
        /// <param name="image">
        /// New image to draw on form.
        /// </param>
        public void SetImage(FloatMatrix image)
        {
            float min = image.Data[0];
            float max = min;

            for (int i = 0; i < image.DataMatrix.Size; i++)
            {
                if (min > image.Data[i])
                    min = image.Data[i];
                else if (max < image.Data[i])
                    max = image.Data[i];
            }

            LinearMatrixDrawer drawer = new LinearMatrixDrawer(min, max);
            _bitmap = drawer.ToBitmap(image);

            ClientSize = _bitmap.Size;

            Refresh();
        }
예제 #10
0
 /// <summary>
 /// Debias data. Subtract master bias from every image in sequence.
 /// </summary>
 /// <param name="dataSequence">
 /// Data to debias.
 /// </param>
 /// <param name="masterBias">
 /// Master bias for specified data.
 /// </param>
 /// <returns>
 /// Sequence of debiased data.
 /// </returns>
 public static IEnumerable<FloatMatrix> Debias(IEnumerable<FloatMatrix> dataSequence, FloatMatrix masterBias)
 {
     return from m in dataSequence select m - masterBias;
 }
예제 #11
0
 /// <summary>
 /// Deflat data. Divide every image in sequence by master flat.
 /// </summary>
 /// <param name="dataSequence">
 /// Data to daflat.
 /// </param>
 /// <param name="masterFlat">
 /// Master flat for specified data.
 /// </param>
 /// <returns>
 /// Sequence of deflated data.
 /// </returns>
 public static IEnumerable<FloatMatrix> Deflat(IEnumerable<FloatMatrix> dataSequence, FloatMatrix masterFlat)
 {
     return from m in dataSequence select m / masterFlat;
 }
예제 #12
0
파일: AutoFoto0.cs 프로젝트: poles-p/SARA
        private FloatMatrix CalcMeanAndShow(IEnumerable<FloatMatrix> source, string title)
        {
            FloatMatrix result = new FloatMatrix(new DataMatrix<float>(source.First().Dimensions));
            int n = 0;

            foreach (FloatMatrix image in source)
            {
                n++;
                _imageWindow.ShowImage(image);
                _imageWindow.ImgForm.Text = title + " " + n.ToString();

                result.Add(image);

                Wait(_waitOnCalibrationSource);
            }

            result.Divide((float)n);

            return result;
        }
예제 #13
0
        /// <summary>
        /// Calculate sum of images in sequene (every pixel contains sum of corresponding pixels values from sequence).
        /// </summary>
        /// <param name="sequecne">
        /// Sequence to calculate sum. Every images have to have same dimensions.
        /// </param>
        /// <returns>
        /// Sum of sequence.
        /// </returns>
        public static FloatMatrix SequenceSum(IEnumerable<FloatMatrix> sequecne)
        {
            FloatMatrix result = new FloatMatrix(new DataMatrix<float>(sequecne.First().Dimensions));

            foreach (FloatMatrix bias in sequecne)
                result.Add(bias);

            return result;
        }
예제 #14
0
 /// <summary>
 /// Debias and deflat data.
 /// </summary>
 /// <param name="dataSequence">
 /// Data to reduct.
 /// </param>
 /// <param name="masterBias">
 /// Master bias for specified data.
 /// </param>
 /// <param name="masterFlat">
 /// Master flat for specified data.
 /// </param>
 /// <returns>
 /// Reducted data.
 /// </returns>
 public static IEnumerable<FloatMatrix> Reduct(IEnumerable<FloatMatrix> dataSequence, FloatMatrix masterBias, FloatMatrix masterFlat)
 {
     return from m in dataSequence select (m - masterBias) / masterFlat;
 }
예제 #15
0
        /// <summary>
        /// Norm image. Create new image from specified image, where mean value of pixels is 1. Function does not change source image.
        /// </summary>
        /// <param name="image">
        /// Image to norm.
        /// </param>
        /// <returns>
        /// Normed image.
        /// </returns>
        public static FloatMatrix NormImage(FloatMatrix image)
        {
            float pixMean = 0.0f;
            foreach (float v in image.Data)
            {
                pixMean += v;
            }

            return image / (pixMean / image.Size);
        }
예제 #16
0
        /// <summary>
        /// Track star method
        /// </summary>
        /// <remarks>
        /// Find selected star on image. Updates Position property, when Movable flag is set, and Reference is not null, 
        /// also updates RelPosition property.
        /// </remarks>
        /// <param name="image">
        /// An image to find selected star.
        /// </param>
        /// <exception cref="System.ArgumentException">
        /// Thrown when specified image is not 2D matrix.
        /// </exception>
        /// <exception cref="SARA.Astrometry.StarEscapedException">
        /// Thrown when field where star is looking for is completly out of image.
        /// </exception>
        public void Track(FloatMatrix image)
        {
            if (image.Dimensions.Length != 2)
                throw new ArgumentException("Expected 2D matrix");

            if (_reference != null)
                _position = _reference.Position + _relPosition;

            int minX = (int)(_position.X - _tolerance);
            int maxX = (int)(_position.X + _tolerance);
            int minY = (int)(_position.Y - _tolerance);
            int maxY = (int)(_position.Y + _tolerance);

            if (maxX < 0 || maxY < 0 || minX >= image.Dimensions[0] || minY >= image.Dimensions[1])
                throw new StarEscapedException("Star escaped");

            if (minX < 0) minX = 0;
            if (minY < 0) minY = 0;
            if (maxX >= image.Dimensions[0]) maxX = image.Dimensions[0] - 1;
            if (maxY >= image.Dimensions[1]) maxY = image.Dimensions[1] - 1;

            int pos0 = minY * image.Dimensions[0];
            _position = new Vector2D((float)minX, (float)minY);
            float best = image.Data[pos0 + minX];

            for (int y = minY; y <= maxY; y++)
            {
                for (int x = minX; x <= maxX; x++)
                {
                    if (best < image.Data[pos0 + x])
                    {
                        best = image.Data[pos0 + x];
                        _position = new Vector2D((float)x, (float)y);
                    }
                }
                pos0 += image.Dimensions[0];
            }

            if (_reference != null && _movable)
                _relPosition = _position - _reference.Position;
        }
예제 #17
0
        /// <summary>
        /// Get frame from AVI as 2-dimensional black and white<see cref="SARA.Core.FloatMatrix"/>
        /// </summary>
        /// <remarks>
        /// This function losts information of pixel colors.
        /// </remarks>
        /// <param name="frameId">
        /// Id of requested frame.
        /// </param>
        /// <returns>
        /// <see cref="SARA.Core.FloatMatrix"/> with requested frame or null.
        /// </returns>
        public FloatMatrix GetFloatMatrix(int frameId)
        {
            IntPtr frameDBI = AviFil32.AVIStreamGetFrame(_getFrameObj, frameId - (int)_streamInfo.dwStart);
            if (frameDBI == IntPtr.Zero)
                throw new AviException("GetFrame returned null frame.");

            FloatMatrix result;

            unsafe
            {
                int* header = (int*)frameDBI.ToPointer();

                result = new FloatMatrix(new DataMatrix<float>(new int[] { header[1], header[2] }));
                byte *bitmapData = (byte*)(frameDBI.ToInt32() + header[0]);

                int size = result.DataMatrix.Size;
                fixed (float* destData = result.Data)
                {
                    for (int i = 0; i < size; i++)
                    {
                        destData[i] = (float)(bitmapData[0]) + (float)(bitmapData[1]) + (float)(bitmapData[2]);
                        bitmapData += 3;
                    }
                }
            }

            return result;
        }
예제 #18
0
파일: AutoFoto0.cs 프로젝트: poles-p/SARA
        private void ShowMaster(FloatMatrix image, string title)
        {
            if (_showCalibrationImages)
            {
                _imageWindow.ShowImage(image);
                _imageWindow.ImgForm.Text = title;

                Wait(_waitOnCalibrationImages);
            }
        }