//-----------------------------------------------------------------------------------------------
        //Расшифровка интерферограммы
        public InterferogramDecodingResult DecodeInterferogram(
            RealMatrix[] interferograms, double[] phaseShifts, BitMask2D bitMask
            )
        {
            RealVector cosVector = this.GetCosVector(phaseShifts);
            RealVector sinVector = this.GetSinVector(phaseShifts);

            int        width       = interferograms[0].ColumnCount;
            int        height      = interferograms[0].RowCount;
            RealMatrix phaseMatrix = new RealMatrix(height, width);

            for (int x = 0; x < width; x++)
            {
                for (int y = 0; y < height; y++)
                {
                    if (bitMask[y, x])
                    {
                        double[]   intensities                 = this.CreateIntensitiesAtPoint(x, y, interferograms);
                        RealVector intensitiesVector           = new RealVector(intensities);
                        RealVector orthogonalIntensitiesVector = intensitiesVector.GetOrthogonalVector();
                        double     phase =
                            this.CalculatePhase(orthogonalIntensitiesVector, sinVector, cosVector);
                        phaseMatrix[y, x] = phase;
                    }
                    else
                    {
                        phaseMatrix[y, x] = this.DefaultPhaseValue;
                    }
                }
            }
            InterferogramDecodingResult decodingResult = new InterferogramDecodingResult(phaseMatrix);

            return(decodingResult);
        }
        //---------------------------------------------------------------------------------------------
        //---------------------------------------------------------------------------------------------
        public InterferogramDecodingResult DecodeInterferogram(
            BitMask2D bitMask, params RealMatrix[] interferograms
            )
        {
            //Выбранные точки изображения
            Point[] selectedImagePoints = bitMask.GetTruePoints();

            double[] phaseShifts = this.GetRandomPhaseShifts(interferograms.Length);
            GenericInterferogramDecoder genericInterferogramDecoder = new GenericInterferogramDecoder();

            double[] numerators = genericInterferogramDecoder.GetDecodingFormulaNumerators
                                      (interferograms, phaseShifts, bitMask);
            double[] denominators = genericInterferogramDecoder.GetDecodingFormulaDenominators
                                        (interferograms, phaseShifts, bitMask);

            Point2D[] points2D = PlaneManager.CreatePoints2D(numerators, denominators);

            if (this.ExecutePointsCorrecting)
            {
                points2D = this.GetTransformedPoints(points2D);
            }
            int        sizeX        = interferograms[0].ColumnCount;
            int        sizeY        = interferograms[0].RowCount;
            RealMatrix resultMatrix =
                this.CalculatePhaseMatrix(points2D, selectedImagePoints, sizeX, sizeY);
            InterferogramDecodingResult decodingResult = new InterferogramDecodingResult(resultMatrix);

            return(decodingResult);
        }
        //---------------------------------------------------------------------------------------------
        public InterferogramDecodingResult DecodeInterferogram(
            BitMask2D bitMask, params RealMatrix[] interferograms
            )
        {
            //Выбранные точки изображения
            Point[] selectedImagePoints = bitMask.GetTruePoints();

            //3D точки в плоскости, параллельной плоскости XY
            Point3D[] points3D =
                this.GetParallelToCoordinatePlanePoints3D(interferograms, selectedImagePoints);

            Point2D[] points2D = SpaceManager.GetProjectionXY(points3D);
            this.ProjectionPoints = points2D;
            points2D = PlaneManager.DisplacePointsToFirstQuadrant(points2D);

            Point2D[] transformedPoints = this.GetTransformedPoints(points2D);
            int       sizeX             = interferograms[0].ColumnCount;
            int       sizeY             = interferograms[0].RowCount;

            RealMatrix phaseMatrix =
                this.CalculatePhaseMatrix(transformedPoints, selectedImagePoints, sizeX, sizeY);

            InterferogramDecodingResult decodingResult = new InterferogramDecodingResult(phaseMatrix);

            return(decodingResult);
        }
        //---------------------------------------------------------------------------------------------
        public InterferogramDecodingResult DecodeInterferogram(RealMatrix[] interferograms, BitMask2D bitMask)
        {
            //double gamma = 2;
            //interferograms = MatricesManager.GetGammaCorrectedMatrices( gamma, interferograms );
            //interferograms = GetNormalizedMatrices( interferograms );

            //Выбранные точки изображения
            Point[]   selectedImagePoints = bitMask.GetTruePoints();
            Point3D[] points3D            =
                this.GetParallelToCoordinatePlanePoints3D(interferograms, selectedImagePoints);
            this.TrajectoryPoints = points3D;

            Point2D[] points2D = SpaceManager.GetProjectionXY(points3D);
            this.ProjectionPoints = points2D;

            EllipseDescriptor ellipseDescriptor = this.GetEllipseDescriptor(points2D);
            Point2D           ellipseCentre     = ellipseDescriptor.GetCentre();
            Point3D           pointsCentre      = new Point3D(ellipseCentre.X, ellipseCentre.Y, points3D[0].Z);

            RealVector cylinderGuidLine           = this.GetCylinderGuidLine(ellipseDescriptor);
            RealVector normalizedCylinderGuidLine = cylinderGuidLine.GetNormalizedVector();

            /*
             * this.CalculateCirclePointsDispersion( cylinderGuidLine, points3D, pointsCentre );
             * double cylinderGuidLineOptimalAngle = this.GetCylinderGuidLineOptimalAngle();
             * cylinderGuidLine = this.GetRotatedInPlaneCylinderGuidLine
             *  ( cylinderGuidLine, cylinderGuidLineOptimalAngle );
             */

            Point3D[] circlePoints = this.GetCirclePoints(points3D, normalizedCylinderGuidLine);
            this.CirclePoints = circlePoints;
            Point3D circlePointsCentre =
                this.GetCorrectedCirclePoint(pointsCentre, normalizedCylinderGuidLine);

            //Поворот точек
            RealMatrix rotationMatrix = this.GetRotationMatrix(circlePoints);

            //rotationMatrix.WriteToTextFile( @"d:\!!\RotationMatrix.txt" ); // debug

            Point3D[] rotatedCirclePoints = this.RotatePoints(circlePoints, rotationMatrix);
            this.RotatedCirclePoints = rotatedCirclePoints;

            Point3D rotatedCirclePointsCentre = PlaneManager.RotateVector
                                                    (new RealVector(circlePointsCentre), rotationMatrix).ToPoint3D();

            Point3D[] correctedPoints =
                this.DisplacePoints(rotatedCirclePoints, rotatedCirclePointsCentre);

            int sizeX = interferograms[0].ColumnCount;
            int sizeY = interferograms[0].RowCount;

            RealMatrix phaseMatrix = this.CalculatePhaseMatrixByCirclePoints
                                         (correctedPoints, selectedImagePoints, sizeX, sizeY);

            InterferogramDecodingResult decodingResult = new InterferogramDecodingResult(phaseMatrix);

            return(decodingResult);
        }
Exemple #5
0
        //--------------------------------------------------------------------------------------------------------
        public InterferogramDecodingResult DecodeInterferogram(RealMatrix[] interferograms)
        {
            RealMatrix firstInterferogram = interferograms[0];

            int width  = firstInterferogram.ColumnCount;
            int height = firstInterferogram.RowCount;

            RealMatrix resultMatrix = new RealMatrix(height, width);

            int firstPointCoordinateX = 0;
            int firstPointCoordinateY = 0;

            FourierTransform fourierTransform = new FourierTransform();

            double[] firstPointIntensities =
                this.CreateIntensitiesAtPoint(firstPointCoordinateX, firstPointCoordinateY, interferograms);
            Complex firstPointFirstHarmonic = fourierTransform.GetFirstHarmonic(firstPointIntensities);

            double C1 = firstPointFirstHarmonic.Real;
            double S1 = firstPointFirstHarmonic.Imaginary;

            for (int x = 0; x < width; x++)
            {
                for (int y = 0; y < height; y++)
                {
                    double[] intensities   = this.CreateIntensitiesAtPoint(x, y, interferograms);
                    Complex  firstHarmonic = fourierTransform.GetFirstHarmonic(intensities);
                    double   C2            = firstHarmonic.Real;
                    double   S2            = firstHarmonic.Imaginary;

                    resultMatrix[y, x] = GetPhase(C1, C2, S1, S2);
                }
            }

            InterferogramDecodingResult decodingResult = new InterferogramDecodingResult(resultMatrix);

            return(decodingResult);
        }
Exemple #6
0
        //---------------------------------------------------------------------------------------------------
        //Расшифровка интерферограммы
        public InterferogramDecodingResult DecodeInterferogram(
            RealMatrix[] interferograms, double[] phaseShifts, BitMask2D bitMask
            )
        {
            bool validateArraySizes =
                this.ValidateArraySize(interferograms) &&
                this.ValidateArraySize(phaseShifts);

            if (!validateArraySizes)
            {
                throw new InterferogramDecodingException();
            }

            int width  = interferograms[0].ColumnCount;
            int height = interferograms[0].RowCount;

            RealMatrix resultMatrix = new RealMatrix(height, width);

            for (int x = 0; x < width; x++)
            {
                for (int y = 0; y < height; y++)
                {
                    if (bitMask[y, x] == true)
                    {
                        double[] intensities = this.CreateIntensitiesAtPoint(x, y, interferograms);
                        double   phase       = this.Decode(intensities, phaseShifts);
                        resultMatrix[y, x] = phase;
                    }
                    else
                    {
                        resultMatrix[y, x] = this.DefaultPhaseValue;
                    }
                }
            }
            InterferogramDecodingResult decodingResult = new InterferogramDecodingResult(resultMatrix);

            return(decodingResult);
        }
Exemple #7
0
        //---------------------------------------------------------------------------------------------
        public InterferogramDecodingResult DecodeInterferogram(RealMatrix[] interferograms, BitMask2D bitMask)
        {
            //Выбранные точки изображения
            Point[] selectedImagePoints = bitMask.GetTruePoints();

            //Ортогональные векторы
            RealVector[] orthogonalVectors = this.GetOrthogonalVectors(interferograms, selectedImagePoints);

            RandomNumberGenerator randomNumberGenerator = new RandomNumberGenerator();

            int indexVector1 = randomNumberGenerator.GetNextInteger(orthogonalVectors.Length - 1);
            int indexVector2 = randomNumberGenerator.GetNextInteger(orthogonalVectors.Length - 1);

            RealVector vector1 = orthogonalVectors[indexVector1];
            RealVector vector2 = orthogonalVectors[indexVector2];

            RealVector normalY;
            RealVector normalX;

            RealMatrix rotMatrixY;
            RealMatrix rotMatrixX;
            RealMatrix rotMatrix;

            double alfa;
            double beta;

            normalY    = SpaceManager.GetVectorsCrossProduct(vector1, vector2);
            alfa       = Math.Atan(-(normalY[0] / normalY[2]));
            rotMatrixY = SpaceManager.GetRotationMatrixAroundAxisY(alfa);

            normalX    = SpaceManager.RotateVector(normalY, rotMatrixY);
            beta       = Math.Atan(-(normalX[1] / normalX[2]));
            rotMatrixX = SpaceManager.GetRotationMatrixAroundAxisX(beta);

            rotMatrix = rotMatrixX * rotMatrixY;

            RealVector[] rotVectors = SpaceManager.RotateVectors(orthogonalVectors, rotMatrix);
            Point3D[]    points3D   = this.GetPoints3D(rotVectors);

            //this.OrthogonalVectorsPoints = points3D;

            Point2D[] points2D = SpaceManager.GetProjectionXY(points3D);
            this.PlaneXYPoints = points2D;

            RealMatrix covariationMatrix = Statistician.GetCovariationMatrix(points2D);
            double     a11 = covariationMatrix[0, 0];
            double     a22 = covariationMatrix[1, 1];
            double     a12 = covariationMatrix[0, 1];

            double[] eigenValues   = MathHelper.GetEigenValuesMatrix2x2(covariationMatrix);
            double   minEigenValue = eigenValues.Min();
            double   maxEigenValue = eigenValues.Max();

            RealVector eigenVector1 = new RealVector
                                      (
                1, -((a11 + a12 - minEigenValue) / (a12 + a22 - minEigenValue))
                                      );

            RealVector eigenVector2 = new RealVector
                                      (
                1, -((a11 + a12 - maxEigenValue) / (a12 + a22 - maxEigenValue))
                                      );

            Complex complex = new Complex(eigenVector1[0], eigenVector1[1]);
            double  omega   = complex.Phase;

            double     a  = Math.Sqrt(minEigenValue);
            double     b  = Math.Sqrt(maxEigenValue);
            double     h  = a / Math.Sqrt(b * b - a * a);
            RealVector Nc = new RealVector(Math.Cos(omega), -Math.Sin(omega), h);

            Point3D[] circlePoints = this.GetCirclePoints(points3D, Nc);
            //this.OrthogonalVectorsPoints = circlePoints;

            RealVector[] circlePointsVectors = new RealVector[circlePoints.Length];
            for (int index = 0; index < circlePoints.Length; index++)
            {
                circlePointsVectors[index] = new RealVector(circlePoints[index]);
            }

            indexVector1 = randomNumberGenerator.GetNextInteger(circlePointsVectors.Length - 1);
            indexVector2 = randomNumberGenerator.GetNextInteger(circlePointsVectors.Length - 1);

            vector1 = circlePointsVectors[indexVector1];
            vector2 = circlePointsVectors[indexVector2];

            normalY    = SpaceManager.GetVectorsCrossProduct(vector1, vector2);
            alfa       = Math.Atan(-(normalY[0] / normalY[2]));
            rotMatrixY = SpaceManager.GetRotationMatrixAroundAxisY(alfa);

            normalX    = SpaceManager.RotateVector(normalY, rotMatrixY);
            beta       = Math.Atan(-(normalX[1] / normalX[2]));
            rotMatrixX = SpaceManager.GetRotationMatrixAroundAxisX(beta);

            rotMatrix = rotMatrixX * rotMatrixY;

            rotVectors = SpaceManager.RotateVectors(circlePointsVectors, rotMatrix);
            points3D   = this.GetPoints3D(rotVectors);
            points2D   = SpaceManager.GetProjectionXY(points3D);

            this.OrthogonalVectorsPoints = points3D;

            RealMatrix phaseMatrix = new RealMatrix(interferograms[0].RowCount, interferograms[0].ColumnCount);

            for (int index = 0; index < selectedImagePoints.Length; index++)
            {
                Point2D circlePoint = points2D[index];
                int     x           = selectedImagePoints[index].X;
                int     y           = selectedImagePoints[index].Y;

                phaseMatrix[y, x] = Math.PI + Math.Atan2(circlePoint.Y, circlePoint.X);
            }


            this.EigenVector1 =
                new RealVector(eigenVector1[0] / eigenVector1.Length, eigenVector1[1] / eigenVector1.Length);

            this.EigenVector2 =
                new RealVector(eigenVector2[0] / eigenVector2.Length, eigenVector2[1] / eigenVector2.Length);



            InterferogramDecodingResult decodingResult = new InterferogramDecodingResult(phaseMatrix);

            return(decodingResult);
        }