Пример #1
0
        public override bool SavePointCloud(string path, string fileName)
        {
            try
            {
                if (ColorMetaData == null || DepthMetaData == null)
                {
                    return(false);
                }

                //List<int> listToBeRemoved = new List<int>();
                PointCloud     pc    = MetaDataBase.ToPointCloud(this.ColorMetaData, this.DepthMetaData, this.BodyMetaData, this.coordinateMapper);
                List <Vector3> vList = new List <Vector3>();
                List <Vector3> cList = new List <Vector3>();;
                if (PointCloudScannerSettings.ShowFaceScanEllipse)
                {
                    for (int i = pc.Count - 1; i >= 0; i--)
                    {
                        bool add = true;
                        if (pc.Vectors[i].X > 0 && pc.Vectors[i].X > faceX)
                        {
                            add = false;
                        }
                        else if (pc.Vectors[i].X < 0 && pc.Vectors[i].X < -faceX)
                        {
                            add = false;
                        }
                        else if (pc.Vectors[i].Y > 0 && pc.Vectors[i].Y > faceY)
                        {
                            add = false;
                        }
                        else if (pc.Vectors[i].Y < 0 && pc.Vectors[i].Y < -faceY)
                        {
                            add = false;
                        }

                        if (add)
                        {
                            vList.Add(pc.Vectors[i]);
                            cList.Add(pc.Colors[i]);
                        }
                    }
                }
                PointCloud pcNew = new OpenTKExtension.PointCloud(vList, cList, null, null, null, null);

                //pc.RemovePoints(listToBeRemoved);
                return(UtilsPointCloudIO.ToObjFile_ColorInVertex(pcNew, path + "\\" + fileName));
            }
            catch (Exception err)
            {
                System.Windows.Forms.MessageBox.Show("SW Error - error saving Point cloud: " + err.Message);
                return(false);
            }
        }
Пример #2
0
        private void testClouds()
        {
            ICPLib.IterativeClosestPointTransform icp = new ICPLib.IterativeClosestPointTransform();

            pTarget = null;

            for (int i = 0; i < 10; i++)
            {
                //first iteration
                if (pTarget == null)
                {
                    pTarget = PointCloud.FromObjFile(GLSettings.Path + GLSettings.PathPointClouds, "Nick\\PointCloudSequence#" + (i).ToString() + ".obj");
                }



                pSource = PointCloud.FromObjFile(GLSettings.Path + GLSettings.PathPointClouds, "Nick\\PointCloudSequence#" + (i + 1).ToString() + ".obj");

                //------------------
                //ICP

                icp.Reset_RealData();
                //icp.ICPSettings.ThresholdMergedPoints = 0f;
                icp.ICPSettings.MaximumNumberOfIterations = 15;


                pTarget = icp.PerformICP(pSource, this.pTarget);
                System.Diagnostics.Debug.WriteLine("###### ICP for point cloud: " + pTarget.Name + " - points added: " + icp.PointsAdded.ToString());


                //   this.registrationMatrix = icp.Matrix;
                //   registrationMatrix.Save(GLSettings.Path + GLSettings.PathPointClouds, "registrationMatrix.txt");
            }
            GlobalVariables.ShowLastTimeSpan("--> Time for ICP ");

            SaveResultCloudAndShow(pTarget);
        }
Пример #3
0
        private static float CalculateScale_Umeyama(PointCloud pointsSourceShift, Vector3 eigenvalues, Matrix3 K2)
        {
            float sigmaSquared = 0f;

            for (int i = 0; i < pointsSourceShift.Vectors.Length; i++)
            {
                sigmaSquared += pointsSourceShift.Vectors[i].NormSquared();
            }

            sigmaSquared /= pointsSourceShift.Vectors.Length;

            float c = 0.0F;

            for (int i = 0; i < 3; i++)
            {
                c += eigenvalues[i];
            }
            if (K2[2, 2] < 0)
            {
                c -= 2 * eigenvalues[2];
            }
            c = c / sigmaSquared;
            return(c);
        }
Пример #4
0
        private static double CalculateScale_Umeyama(PointCloud pointsSourceShift, Vector3d eigenvalues, Matrix3d K2)
        {
            double sigmaSquared = 0f;

            for (int i = 0; i < pointsSourceShift.Count; i++)
            {
                sigmaSquared += pointsSourceShift.Vectors[i].NormSquared();
            }

            sigmaSquared /= pointsSourceShift.Count;

            double c = 0.0F;

            for (int i = 0; i < 3; i++)
            {
                c += eigenvalues[i];
            }
            if (K2[2, 2] < 0)
            {
                c -= 2 * eigenvalues[2];
            }
            c = c / sigmaSquared;
            return(c);
        }
Пример #5
0
        /// <summary>
        /// colors and indices are lost!!
        /// </summary>
        /// <param name="pc"></param>
        /// <returns></returns>
        public static PointCloud ResizeAndSort_Distance(PointCloud pc)
        {
            pc.ResizeTo1();

            List <Vertex> vList = new List <Vertex>();

            if (pc.Colors == null || pc.Colors.Length != pc.Vectors.Length)
            {
                pc.SetDefaultColors();
            }
            for (int i = 0; i < pc.Vectors.Length; i++)
            {
                Vertex v = new Vertex(pc.Vectors[i]);
                v.Color = pc.Colors[i];
                vList.Add(v);
            }


            vList.Sort(new Vector_Length());

            PointCloud pcNew = PointCloud.FromListVertices(vList);

            return(pcNew);
        }
Пример #6
0
        public static Matrix4d FindTransformationMatrix(PointCloud pointsSource, PointCloud pointsTarget, ICP_VersionUsed icpVersionUsed)
        {
            //shift points to the center of mass (centroid)
            Vector3 centroidTarget = pointsTarget.CentroidVector;
            //Vector3d centroidTarget_Double = new Vector3d(pointsTarget.CentroidVector.X, pointsTarget.CentroidVector.Y, pointsTarget.CentroidVector.Z);

            PointCloud pointsTargetTranslated = pointsTarget.Clone();

            pointsTargetTranslated.SubtractVector(centroidTarget);

            Vector3    centroidSource         = pointsSource.CentroidVector;
            PointCloud pointsSourceTranslated = pointsSource.Clone();

            pointsSourceTranslated.SubtractVector(centroidSource);

            Matrix3d R = FindRotationMatrix(pointsSourceTranslated, pointsTargetTranslated, icpVersionUsed);

            Vector3d T        = CalculateTranslation(centroidSource, centroidTarget, R);
            Matrix4d myMatrix = new Matrix4d();

            myMatrix = myMatrix.PutTheMatrix4dtogether(T, R);

            return(myMatrix);
        }
Пример #7
0
        /// <summary>
        /// calculates Matrix for alignment of sourceAxes and targetAxes; sets pointCloudResult
        /// </summary>
        /// <param name="i"></param>
        /// <param name="j"></param>
        /// <param name="bestResultMeanDistance"></param>
        /// <param name="meanDistance"></param>
        /// <param name="myMatrixBestResult"></param>
        /// <param name="sourceAxes"></param>
        private void SVD_ForTwoPointCloudAlignment_Double(int i, int j, ref float meanDistance, ref Matrix4 myMatrixBestResult, PointCloud sourceAxes)
        {
            PointCloud targetAxes = InvertAxes(pcTargetCentered, pcTargetCentered.PCAAxes, j);

            //Matrix4 myMatrix = SVD_Float.FindTransformationMatrix(sourceAxes, targetAxes, ICP_VersionUsed.Scaling_Umeyama);

            Matrix4d myMatrix4d = SVD.FindTransformationMatrix_WithoutCentroids(sourceAxes, targetAxes, ICP_VersionUsed.Umeyama);


            //CheckPCA(myMatrix4d, sourceAxes, targetAxes);


            PointCloud myResultPC = myMatrix4d.TransformPoints(pcSourceCentered);


            //--------------
            pcTreeResult = KDTree.FindClosestPointCloud_Parallel(myResultPC);
            meanDistance = KDTree.MeanDistance;


            //PointCloud myPointCloudTargetTemp = kdtree.FindNearest_Rednaxela(ref myPointsResultTemp, pointCloudTargetCentered, -1);


            System.Diagnostics.Debug.WriteLine("   in iteration: MeanDistance between orientations: " + i.ToString() + " : " + j.ToString() + " : " + meanDistance.ToString("G"));

            if (meanDistance < bestResultMeanDistance)
            {
                myMatrixBestResult     = myMatrix4d.ToMatrix4();
                bestResultMeanDistance = meanDistance;
                pcResultBest           = myResultPC;
            }



            pcResult = myResultPC;
        }
Пример #8
0
        public static void CreateOutliers(PointCloud pointCloud, int numberOfOutliers)
        {
            int            indexInPointCloud = pointCloud.Vectors.Length - 1;
            int            numberIterate     = 0;
            List <Vector3> listV             = new List <Vector3>(pointCloud.Vectors);

            for (int i = pointCloud.Vectors.Length - 1; i >= 0; i--)
            {
                //Vector3 p = vectors[i].Vector;
                Vector3 perturb = new Vector3(pointCloud.Vectors[i]);

                numberIterate++;
                if (numberIterate > numberOfOutliers)
                {
                    return;
                }


                if (i % 3 == 0)
                {
                    perturb.X *= 1.2f; perturb.Y *= 1.3f; perturb.Z *= 1.05f;
                }
                else if (i % 3 == 1)
                {
                    perturb.X *= 1.4f; perturb.Y *= 0.9f; perturb.Z *= 1.2f;
                }
                else
                {
                    perturb.X *= 0.9f; perturb.Y *= 1.2f; perturb.Z *= 1.1f;
                }
                indexInPointCloud++;
                listV.Add(perturb);
            }

            pointCloud.Vectors = listV.ToArray();
        }
Пример #9
0
        public static void ShuffleRandom(PointCloud pointCloud)
        {
            IList <Vector3> lNew = new List <Vector3>(pointCloud.Vectors);

            lNew.Shuffle();
        }
Пример #10
0
 public PointCloud Clone()
 {
     return(PointCloud.Clone(this));
 }
Пример #11
0
 public void AddPointCloud(string name, PointCloud pc)
 {
     this.OpenGL_UControl.AddPointCloud(name, pc);
 }
Пример #12
0
 public KDTreeKennell(PointCloud pc) : this()
 {
     Build(pc);
 }
Пример #13
0
 public void Update(List <Vector3> points)
 {
     this.pointCloud = new OpenTKExtension.PointCloud(points, null, null, null, null, null);
     FillPointCloud();
     FillIndexBuffer();
 }
Пример #14
0
 public static Vector3 ResetCentroid(PointCloud pc, bool centered)
 {
     return(pc.ResetCentroid(centered));
 }
Пример #15
0
        /// <summary>Generates a 3D PointCloud for a cuboid.</summary>
        /// <param name="Name">PointCloud name.</param>
        /// <param name="Radius">Cylinder radius.</param>
        /// <param name="Height">Cylinder height.</param>
        /// <param name="numPoints">Number of points for circular section.</param>
        /// <param name="Color">Color vector.</param>
        public static PointCloud CuboidEmpty(float xMax, float yMax, float zMax, int pointsMaxX, int pointsMaxY, int pointsMaxZ)
        {
            float stepX = xMax / pointsMaxX;
            float stepY = yMax / pointsMaxY;
            float stepZ = zMax / pointsMaxZ;

            PointCloud     pCloud     = new PointCloud();
            List <Vector3> pointsList = new List <Vector3>();

            List <uint> listIndices = new List <uint>();
            uint        ind         = 0;

            for (int i = 0; i <= pointsMaxX; i++)
            {
                for (int j = 0; j <= pointsMaxY; j++)
                {
                    if ((i == 0 || i == pointsMaxX) || (j == 0 || j == pointsMaxY))
                    {
                        for (int k = 0; k <= pointsMaxZ; k++)
                        {
                            Vector3 v = new Vector3(i * stepX, j * stepY, k * stepZ);
                            pointsList.Add(v);

                            if (pointsList.Count > 3)
                            {
                                ind++;
                                listIndices.Add(ind - 1);
                                listIndices.Add(ind);

                                listIndices.Add(ind - 2);
                                listIndices.Add(ind);

                                listIndices.Add(ind - 3);
                                listIndices.Add(ind);

                                listIndices.Add(ind - 4);
                                listIndices.Add(ind);
                            }
                            if (pointsList.Count > 2)
                            {
                                ind++;
                                listIndices.Add(ind - 1);
                                listIndices.Add(ind);

                                listIndices.Add(ind - 2);
                                listIndices.Add(ind);

                                listIndices.Add(ind - 3);
                                listIndices.Add(ind);
                            }
                            if (pointsList.Count > 1)
                            {
                                ind++;
                                listIndices.Add(ind - 1);
                                listIndices.Add(ind);

                                listIndices.Add(ind - 2);
                                listIndices.Add(ind);
                            }
                            if (pointsList.Count > 0)
                            {
                                listIndices.Add(ind);
                                listIndices.Add(ind++);
                            }
                        }
                    }

                    else
                    {
                        Vector3 v = new Vector3(i * stepX, j * stepY, 0);
                        pointsList.Add(v);


                        v = new Vector3(i * stepX, j * stepY, zMax);
                        pointsList.Add(v);
                    }
                }
            }
            pCloud.Vectors = pointsList.ToArray();
            pCloud.Indices = listIndices.ToArray();
            //pCloud.CreateIndicesDefault();
            return(pCloud);
        }
Пример #16
0
 public static PointCloud Cube_RegularGrid_Empty(float cubeSize, int numberOfPointsPerPlane)
 {
     return(PointCloud.FromListVector3(Cube_RegularGrid_Empty_List(cubeSize, numberOfPointsPerPlane)));
 }
Пример #17
0
 /// <summary>
 /// u - > v translation
 /// </summary>
 /// <param name="mat"></param>
 /// <param name="sourceV"></param>
 /// <param name="targetV"></param>
 /// <returns></returns>
 public static Matrix3 RotationCoordinateChange(this Matrix3 mat, PointCloud cloudOrigin, PointCloud target)
 {
     for (int i = 0; i < 3; i++)
     {
         cloudOrigin[i].Vector = cloudOrigin[i].Vector.NormalizeV();
         target[i].Vector      = target[i].Vector.NormalizeV();
     }
     for (int i = 0; i < 3; i++)
     {
         for (int j = 0; j < 3; j++)
         {
             //float angle = Vector3.CalculateAngle(u[j], v[i]);
             //float val = Math.Cos(angle);
             mat[i, j] = Vector3.Dot(cloudOrigin[i].Vector, target[j].Vector);
         }
     }
     //    mat.Transpose();
     //mat.Invert();
     //mat.Transpose();
     return(mat);
 }
Пример #18
0
        //other methods for SVD, for possible later usage
        //MathUtils.SingularValueDecomposition3x3(Harray, Uarray, warray, VTarray);
        //MathNet.Numerics.Providers.LinearAlgebra.Mkl.MklLinearAlgebraProvider svd = new MathNet.Numerics.Providers.LinearAlgebra.Mkl.MklLinearAlgebraProvider();
        //double[] a = MatrixUtilsNumerics.doubleFromArraydouble(Harray);
        //double[] u = MatrixUtilsNumerics.doubleFromArraydouble(Uarray);
        //double[] vt = MatrixUtilsNumerics.doubleFromArraydouble(Uarray);
        //double[] s = new double[3];
        //svd.SingularValueDecomposition(true, a, 3, 3, s, u, vt);
        private static Matrix3d CalculateRotationBySingularValueDecomposition(Matrix3d H, PointCloud pointsSourceTranslated, ICP_VersionUsed icpVersionUsed)
        {
            Eigenvalues_Helper(H);
            //gives R, the rotation matrix, U - the left eigenvectors, VT - right transposed eigenvectors, EV  - the eigenvalues



            //see article by Umeyama

            //if (H.Determinant < 0)
            //{
            //    R[2, 2] = -R[2, 2];
            //    //S[2, 2] = -1;
            //}

            //calculate the sign matrix for using the scale factor
            Matrix3d K2 = Matrix3d.Identity;

            //double check = U.Determinant * VT.Determinant;
            //if (check < 0 && Math.Abs(check) > 1E-3)
            //{
            //    K2[2, 2] = -1;
            //}


            double scale = CalculateScale_Umeyama(pointsSourceTranslated, EV, K2);

            R = Matrix3d.Mult(R, K2);
            if (icpVersionUsed == ICP_VersionUsed.Umeyama)
            {
                //R = Matrix3d.Mult(R, K2);
                R = R.MultiplyScalar(scale);
            }


            return(R);
        }
Пример #19
0
        public static Matrix4d FindTransformationMatrix_MinimumDistance(PointCloud pointsSource, PointCloud pointsTarget, ICP_VersionUsed icpVersionUsed, float minimumDistance)
        {
            minimumDistance *= minimumDistance * 2;
            List <Vector3> sourceList = new List <Vector3>();
            List <Vector3> targetList = new List <Vector3>();

            int numberOfVectorsNotTaken = 0;

            for (int i = 0; i < pointsSource.Vectors.Length; i++)
            {
                float distance = pointsSource.Vectors[i].DistanceSquared(pointsTarget.Vectors[i]);
                if (distance < minimumDistance)
                {
                    sourceList.Add(pointsSource.Vectors[i]);
                    targetList.Add(pointsTarget.Vectors[i]);
                }
                else
                {
                    numberOfVectorsNotTaken++;
                }
            }

            if (numberOfVectorsNotTaken > 0)
            {
                System.Diagnostics.Debug.WriteLine("Ignored vectors in SVD because too far: " + numberOfVectorsNotTaken.ToString() + " :  out of : " + pointsSource.Count.ToString());
            }



            PointCloud pSourceNew = PointCloud.FromListVector3(sourceList);
            PointCloud pTargetNew = PointCloud.FromListVector3(targetList);

            if (pSourceNew == null || pTargetNew == null)
            {
                return(Matrix4d.Identity);
            }

            return(FindTransformationMatrix(pSourceNew, pTargetNew, icpVersionUsed));
        }
Пример #20
0
 /// <summary>
 /// resets all vectors so that there are no negative values
 /// </summary>
 /// <param name="pc"></param>
 public static void ResetToOriginAxis(PointCloud pc)
 {
     PointCloud.AddVectorToAll(pc, pc.BoundingBox.Min.Abs());
 }
Пример #21
0
        public static Matrix4d FindTransformationMatrix_WithoutCentroids(PointCloud pointsSource, PointCloud pointsTarget, ICP_VersionUsed icpVersionUsed)
        {
            Matrix3d R = FindRotationMatrix(pointsSource, pointsTarget, icpVersionUsed);

            //Vector3d T = new Vector3d();
            Matrix4d myMatrix = new Matrix4d();

            myMatrix = myMatrix.FromMatrix3d(R);

            return(myMatrix);
        }
Пример #22
0
        /// <summary>
        /// creates color info for all DEPTH pixels (to later e.g. write ply file from it) - needed also for image creation
        /// </summary>
        /// <param name="myColorMetaData"></param>
        /// <param name="myDepthMetaData"></param>
        /// <param name="myCoordinateMapper"></param>
        /// <returns></returns>
        public static byte[] ToColorArrayBytes(PointCloud pointCloud, int width, int height)
        {
            byte[] colorPixels = new byte[width * height * 4];
            int    xInt        = 0;
            int    yInt        = 0;
            int    zInt        = 0;
            int    depthIndex  = 0;


            try
            {
                ////out ushort[] depthPixels = PointCloud.ToUshort1Dim(pc, width, height);
                float xMin = pointCloud.BoundingBoxMin.X;
                float yMin = pointCloud.BoundingBoxMin.Y;
                float dx   = pointCloud.BoundingBoxMax.X - pointCloud.BoundingBoxMin.X;
                float dy   = pointCloud.BoundingBoxMax.Y - pointCloud.BoundingBoxMin.Y;


                //init to black background
                for (int x = 0; x < width; x++)
                {
                    for (int y = 0; y < height; y++)
                    {
                        depthIndex = (y * width) + x;
                        //depthIndex = ((height - y - 1) * width) + x;

                        int colorIndex = depthIndex * 4;
                        colorPixels[colorIndex]     = (byte)0;
                        colorPixels[colorIndex + 1] = (byte)0;
                        colorPixels[colorIndex + 2] = (byte)0;
                        colorPixels[colorIndex + 3] = (byte)255;
                    }
                }

                // set color -------------------------------------
                for (int i = 0; i < pointCloud.Count; i++)
                {
                    Vector3 v     = pointCloud.Vectors[i];
                    Vector3 color = pointCloud.Colors[i];


                    xInt = Convert.ToInt32((v.X - xMin) * width / dx);
                    yInt = Convert.ToInt32((v.Y - yMin) * height / dy);
                    zInt = Convert.ToInt32(v.Z);

                    //exclude rounding errors
                    if (xInt < width && yInt < height)
                    {
                        //rotate the cloud to 180 degrees, so that display as image is OK
                        depthIndex = ((height - yInt - 1) * width) + xInt;

                        int colorIndex = depthIndex * 4;
                        colorPixels[colorIndex]     = Convert.ToByte(color.X * 255);
                        colorPixels[colorIndex + 1] = Convert.ToByte(color.Y * 255);
                        colorPixels[colorIndex + 2] = Convert.ToByte(color.Z * 255);

                        colorPixels[colorIndex + 3] = 255;
                    }
                }
            }
            catch
            {
                System.Diagnostics.Debug.WriteLine("Error in ToColorArrayBytes: " + xInt.ToString() + " : " + yInt.ToString() + " : " + zInt.ToString() + " : " + depthIndex.ToString() + " : ");
            }
            return(colorPixels);
        }
Пример #23
0
 public Face(List <Vector3> points)
 {
     this.pointCloud = new OpenTKExtension.PointCloud(points, null, null, null, null, null);
 }
Пример #24
0
 public KDTreeEricRegina(PointCloud pc) : this()
 {
     Build(pc);
 }
Пример #25
0
        /// <summary>
        /// returns the target (tree) points found for the input (source) points
        /// </summary>
        /// <param name="source"></param>
        /// <returns></returns>
        public PointCloud FindClosestPointCloud_NotParallel(PointCloud source)
        {
            this.source = source;
            this.ResetTaken();


            VertexKDTree[] resultArray = new VertexKDTree[source.Count];

            PointCloud sourceShuffled;

            if (this.TakenAlgorithm)
            {
                sourceShuffled = source.Clone();
                sourceShuffled.SetDefaultIndices();
                sourceShuffled = PointCloud.Shuffle(sourceShuffled);
            }
            else
            {
                sourceShuffled = source;
            }
            int   nearest_index    = 0;
            float nearest_distance = 0f;

            //System.Threading.Tasks.Parallel.For(0, source.Count, i =>
            for (int i = 0; i < sourceShuffled.Count; i++)
            {
                VertexKDTree vSource = new VertexKDTree(sourceShuffled.Vectors[i], i);

                VertexKDTree vTargetFound = FindClosestPoint(vSource, ref nearest_distance, ref nearest_index);
                //resultArray[i] = vTargetFound.Clone();
                resultArray[i] = vTargetFound;
            }
            ;

            List <VertexKDTree> resultList = new List <VertexKDTree>(resultArray);

            result = PointCloud.FromListVertexKDTree(resultList);



            //shuffle back
            //float f = PointCloud.MeanDistance(sourceShuffled, pcResult);
            PointCloud pcResultShuffledBack;

            if (this.TakenAlgorithm)
            {
                pcResultShuffledBack = result.Clone();
                for (int i = 0; i < pcResultShuffledBack.Count; i++)
                {
                    //pcResultShuffled.Vectors[i] = pcResult.Vectors[Convert.ToInt32(sourceShuffled.Indices[i])];
                    pcResultShuffledBack.Vectors[Convert.ToInt32(sourceShuffled.Indices[i])] = result.Vectors[i];
                }
            }
            else
            {
                pcResultShuffledBack = result;
            }

            // this.MeanDistance = PointCloud.MeanDistance(source, pcResultShuffledBack);

            return(pcResultShuffledBack);
        }
Пример #26
0
        /// <summary>
        /// at least source points should be non zero
        /// </summary>
        /// <param name="mypointCloudTarget"></param>
        /// <param name="mypointCloudSource"></param>
        /// <param name="mypointCloudResult"></param>
        /// <param name="changeColor"></param>
        public void Show3PointClouds(PointCloud mypointCloudSource, PointCloud mypointCloudTarget, PointCloud mypointCloudResult, bool changeColor)
        {
            this.OpenGLControl.RemoveAllPointClouds();
            mypointCloudTarget.Name = "Target";
            mypointCloudSource.Name = "Source";
            mypointCloudResult.Name = "Result";

            //target in green
            List <System.Drawing.Color> myColors;

            if (mypointCloudTarget != null)
            {
                if (changeColor)
                {
                    myColors = ColorExtensions.ToColorList(mypointCloudTarget.Count, 0, 255, 0, 255);
                    PointCloud.SetColorToList(mypointCloudTarget, myColors);
                }
                this.OpenGLControl.ShowPointCloud(mypointCloudTarget);
            }

            if (mypointCloudSource != null)
            {
                //source in white
                myColors = ColorExtensions.ToColorList(mypointCloudSource.Count, 255, 255, 255, 255);
                if (changeColor)
                {
                    PointCloud.SetColorToList(mypointCloudSource, myColors);
                }
                this.OpenGLControl.ShowPointCloud(mypointCloudSource);
            }

            if (mypointCloudResult != null)
            {
                //transformed in red
                myColors = ColorExtensions.ToColorList(mypointCloudResult.Count, 255, 0, 0, 255);
                if (changeColor)
                {
                    PointCloud.SetColorToList(mypointCloudResult, myColors);
                }
                this.OpenGLControl.ShowPointCloud(mypointCloudResult);
            }
        }
Пример #27
0
        /// <summary>
        /// at least source points should be non zero
        /// </summary>
        /// <param name="mypointCloudTarget"></param>
        /// <param name="mypointCloudSource"></param>
        /// <param name="mypointCloudResult"></param>
        /// <param name="changeColor"></param>
        public void Show3PointCloudOpenGL(PointCloud mypointCloudSource, PointCloud mypointCloudTarget, PointCloud mypointCloudResult, bool changeColor)
        {
            this.OpenGLControl.RemoveAllPointClouds();

            //target in green

            if (mypointCloudTarget != null)
            {
                if (changeColor)
                {
                    mypointCloudTarget.Colors = ColorExtensions.ToVector3Array(mypointCloudTarget.Vectors.Length, 0, 255, 0);
                }
                ShowPointCloudOpenGL(mypointCloudTarget, false);
            }

            if (mypointCloudSource != null)
            {
                //source in white

                if (changeColor)
                {
                    mypointCloudSource.Colors = ColorExtensions.ToVector3Array(mypointCloudSource.Vectors.Length, 255, 255, 255);
                }

                ShowPointCloudOpenGL(mypointCloudSource, false);
            }

            if (mypointCloudResult != null)
            {
                //transformed in red
                if (changeColor)
                {
                    mypointCloudResult.Colors = ColorExtensions.ToVector3Array(mypointCloudResult.Vectors.Length, 255, 0, 0);
                }

                ShowPointCloudOpenGL(mypointCloudResult, false);
            }
        }
Пример #28
0
 public static PointCloud CloneAll(PointCloud pc)
 {
     return(pc.Clone());
 }
Пример #29
0
 public void ShowPointCloud(PointCloud pc)
 {
     this.OpenGLControl.ShowPointCloud(pc);
 }
Пример #30
0
 public static void ToJsonFile(PointCloud pc, string fileName)
 {
     JsonUtils.Serialize(pc.Vectors, fileName);
 }