public bool EqualsPoint(MyVector2 v)
 {
     if ((this - v).Length() < 1e-6)
     {
         return(true);
     }
     else
     {
         return(false);
     }
 }
        public void Project3dToBelongPlane()
        {
            // prepare 2d coordinate
            MyVector3 circle_norm = this.belongPlane.Normal();
            MyVector3 X           = new MyVector3(1, 0, 0);
            MyVector3 Y           = new MyVector3(0, 1, 0);
            MyVector3 Z           = new MyVector3(0, 0, 1);
            MyVector3 rotAxis     = Z.Cross(circle_norm).Normalize();
            double    angle_cos   = Z.Dot(circle_norm);

            if (angle_cos > 1)
            {
                angle_cos = 1;
            }
            if (angle_cos < -1)
            {
                angle_cos = -1;
            }
            double rotAngle = Math.Acos(angle_cos);

            MyMatrix4d      Mat   = MyMatrix4d.RotationMatrix(rotAxis, rotAngle);
            MyVector3       X_new = (Mat * new MyVector4(X)).XYZ().Normalize();
            MyVector3       Y_new = (Mat * new MyVector4(Y)).XYZ().Normalize();
            CoordinateFrame frame = new CoordinateFrame(this.belongPlane.planeCenter, X_new, Y_new, circle_norm);

            // projection and denoise(leave out far away points)
            MyVector3 tmpc = frame.GetPointLocalCoord(this.center);

            this.center2d = new MyVector2(tmpc.x, tmpc.y);
            for (int i = 0; i < this.circleSlice3d.Count; i++)
            {
                MyVector3 vert = this.circleSlice3d[i];
                MyVector3 tmp  = frame.GetPointLocalCoord(vert);
                MyVector2 tmp2 = new MyVector2(tmp.x, tmp.y);
                double    dist = Math.Abs((tmp2 - this.center2d).Length() - this.radius);
                if (dist > 0.5 * this.radius && dist < 0.75 * this.radius)
                {
                    this.circleSlice3d.RemoveAt(i);
                    i--;
                }
                else
                {
                    this.circleSlice2d.Add(tmp2);
                }
            }
        }
        public bool PointInPlane2d(MyVector2 p)
        {
            this.ProjectVerticesTo2d();
            bool             c      = false;
            List <MyVector2> points = this.planeVertices2d;
            int n = points.Count;

            for (int i = 0, j = n - 1; i < n; j = i++)
            {
                if (((points[i].y > p.y) != (points[j].y > p.y)) &&
                    (p.x < (points[j].x - points[i].x) * (p.y - points[i].y) / (points[j].y - points[i].y) + points[i].x))
                {
                    c = !c;
                }
            }
            return(c);
        }
Exemple #4
0
        private MyVector3 MapToSphere(MyVector2 pt)
        {
            #region old map
            //MyVector2 v = new MyVector2();
            ////v.x = (w - pt.x) * adjustWidth;
            //v.x = (pt.x - this.w) * adjustWidth;
            //v.y = (this.h - pt.y) * adjustHeight;

            //double lenSq = v.Dot(v);
            //MyVector3 v3 = new MyVector3(v.x, 0, v.y);
            //if (lenSq > 1.0)
            //{
            //    double norm = 1.0 / Math.Sqrt(lenSq);
            //    return new MyVector3(v.x * norm, -v.y * norm, 0);
            //}
            //else
            //{
            //    return new MyVector3(v.x, Math.Sqrt(1.0 - lenSq), v.y);
            //}
            #endregion

            //just. 1116
            MyVector2 v = new MyVector2();
            v.x = (this.w - pt.x) * adjustWidth / radius;
            v.y = (this.h - pt.y) * adjustHeight / radius;

            double lenSq = v.Dot(v);
            //MyVector3 v3 = new MyVector3(v.x, 0, v.y);
            if (lenSq > 1.0)
            {
                double norm = 1.0 / Math.Sqrt(lenSq);
                return(new MyVector3(v.x * norm, v.y * norm, 0));
            }
            else
            {
                return(new MyVector3(v.x, v.y, Math.Sqrt(1.0 - lenSq)));
            }
        }
Exemple #5
0
        public void Drag(MyVector2 pt)
        {
            edPt  = pt;
            edVec = MapToSphere(pt);
            //angle = Math.Acos(stVec.Dot(edVec));

            double epsilon = 1.0e-5;

            MyVector3 prep = stVec.Cross(edVec);

            if (prep.Length() > epsilon)
            {
                quat = new MyVector4();

                quat.x = prep.x;
                quat.y = prep.y;
                quat.z = prep.z;
                quat.w = stVec.x + edVec.x + stVec.y + edVec.y + stVec.z + edVec.z;
            }
            else
            {
                quat = new MyVector4();
            }
            //if (prep.Length() > epsilon)
            //{
            //    quat = new MyVector3();

            //    quat.x = prep.x;
            //    quat.y = prep.y;
            //    quat.z = prep.z;
            //}
            //else
            //    quat = new MyVector3();

            //angle = Math.PI / 2.0 * prep.Length();
        }
Exemple #6
0
        public void ProjCenterTo2d()
        {
            MyVector3 tmp = frame.GetPointLocalCoord(center);

            center2d = tmp.XY();
        }
 public double Dot(MyVector2 v)
 {
     return(x * v.x + y * v.y);
 }
 public MyVector3(MyVector2 v, double z)
 {
     this.x = v.x;
     this.y = v.y;
     this.z = z;
 }
 public MyVector3(MyVector2 v)
 {
     this.x = v.x;
     this.y = v.y;
     this.z = 0;
 }
 public MyVector2(MyVector2 v)
 {
     this.x = v.x;
     this.y = v.y;
 }
 static public double Distance(MyVector2 a, MyVector2 b)
 {
     return((a - b).Length());
 }
 public double Cross(MyVector2 v)
 {
     return(x * v.y - y * v.x);
 }
 public bool Equals(MyVector2 v)
 {
     return((this.x == v.x) && (this.y == v.y) ? true : false);
 }
Exemple #14
0
        public void Optimizing()
        {
            // do optimize in 2d space
            // each gcuboid has a list of polygon(defined in MyPolygon.cs)
            // input data : polygon's 2d information, including center2d, cornerPoints2d and slicePoints2d
            // output data : new position of cornerPoints2d

            #region a theoretically fast method, but there are mystery bugs in it for now =.=
            K = this.polyList.Count;
            N = this.polyList[0].CornerPoints2d.Count;

            //// compute every triangle's initial height
            //h = new double[K * N]; // using Heron's formula to compute height
            //CLineSegment[] bottomEdges = new CLineSegment[K * N]; // bottom edges (used to calculate dis)
            //int triangleIdx = 0;
            int idx = 0;
            center2d = new MyVector2[K];
            foreach (MyPolygon mp in this.polyList)
            {
                center2d[idx] = new MyVector2();
                foreach (MyVector2 vert in mp.CornerPoints2d)
                {
                    center2d[idx] += vert;
                }
                center2d[idx] /= mp.CornerPoints2d.Count;

                //double edgeLengthA = (mp.CornerPoints2d[0] - center2d[idx]).Length();
                //for (int i = 0; i < mp.CornerPoints2d.Count; i++)
                //{
                //    bottomEdges[triangleIdx] = new CLineSegment(mp.CornerPoints2d[i], mp.CornerPoints2d[(i + 1) % N]);

                //    double edgeLengthB = (mp.CornerPoints2d[(i + 1) % N] - center2d).Length();
                //    double edgeLengthBottom = bottomEdges[triangleIdx].GetLineSegmentLength();

                //    double p = (edgeLengthA + edgeLengthB + edgeLengthBottom) / 2;
                //    double S = Math.Sqrt(p * (p - edgeLengthA) * (p - edgeLengthB) * (p - edgeLengthBottom));
                //    h[triangleIdx] = 2 * S / edgeLengthBottom;

                //    triangleIdx++;
                //    edgeLengthA = edgeLengthB;
                //}
                idx++;
            }

            //// compute initial distance between slice points and its nearest bottom edge
            //dis = new double[M_sum]; // initial distances
            //segmentIdx = new int[M_sum]; // belong to which bottom edge
            //int disIdx = 0, mpIdx = 0;
            //foreach (MyPolygon mp in this.polyList)
            //{
            //    foreach (MyVector2 mv2 in mp.SlicePoints2d)
            //    {
            //        double minDis = double.MaxValue;
            //        for (int i = mpIdx; i < mpIdx + N; i++)
            //        {
            //            // must be countercwise, and when point is on the left of the segment, dis > 0
            //            double tmpDis = bottomEdges[i].GetDistance(mv2) * -bottomEdges[i].GetPointLocation(mv2);
            //            if (Math.Abs(minDis) > Math.Abs(tmpDis))
            //            {
            //                minDis = tmpDis;
            //                segmentIdx[disIdx] = i;
            //            }
            //        }
            //        dis[disIdx++] = minDis;
            //    }
            //    mpIdx += N;
            //}

            //// saved rho (to compute deltaRho in each iteration)
            //rho = new double[K];
            //for (int i = 0; i < K; i++)
            //    rho[i] = 1.0;
            #endregion

            // begin to optimize
            double[] x = new double[K];
            for (int i = 0; i < K; i++)
            {
                x[i] = 1.0;
            }
            double             epsg   = 1e-4;
            double             epsf   = 0;
            double             epsx   = 0;
            int                maxits = 100; //300
            alglib.minlmstate  state;
            alglib.minlmreport rep;

            alglib.minlmcreatev(2, x, 0.01, out state);
            alglib.minlmsetcond(state, epsg, epsf, epsx, maxits);
            alglib.minlmoptimize(state, funcFitPolygon1, null, null);
            alglib.minlmresults(state, out x, out rep);

            idx = 0;
            foreach (MyPolygon mp in this.polyList)
            {
                MyVector3 center = mp.Center;
                for (int i = 0; i < mp.CornerPoints3d.Count; i++)
                {
                    mp.CornerPoints3d[i] = x[idx] * (mp.CornerPoints3d[i] - center) + center;
                }
                idx++;
            }
        }
Exemple #15
0
        private void funcFitPolygon1(double[] x, double[] f, object obj)
        {
            f[0] = 0.0;
            f[1] = 0.0;

            int idx = 0;

            foreach (MyPolygon mp in this.polyList)
            {
                MyVector2[] vertices = new MyVector2[N];
                for (int i = 0; i < mp.CornerPoints2d.Count; i++)
                {
                    vertices[i] = center2d[idx] + (mp.CornerPoints2d[i] - center2d[idx]) * x[idx];
                }

                CLine[] segments = new CLine[N];
                for (int i = 0; i < mp.CornerPoints2d.Count; i++)
                {
                    segments[i] = new CLine(vertices[i], vertices[(i + 1) % N]);
                }

                foreach (MyVector2 mv2 in mp.SlicePoints2d)
                {
                    double minDis = double.MaxValue;
                    for (int i = 0; i < N; i++)
                    {
                        double disTmp = segments[i].GetDistance(mv2);
                        if (minDis > disTmp)
                        {
                            minDis = disTmp;
                        }
                    }
                    f[0] += minDis;
                }
                idx++;
            }

            // compute f[1]
            for (int i = 0; i < K; i++)
            {
                if (i == 0)
                {
                    f[1] += Math.Pow(x[i] - x[i + 1], 2);
                }
                else if (i == K - 1)
                {
                    f[1] += Math.Pow(x[i] - x[i - 1], 2);
                }
                else
                {
                    f[1] += Math.Pow(2 * x[i] - x[i - 1] - x[i + 1], 2);
                }
            }
            f[1] *= 1e-1;

            if (outputIdx == 0)
            {
                Console.WriteLine(f[0].ToString("0.000") + "\t" + f[1].ToString("0.000"));
            }
            outputIdx = (outputIdx + 1) % 1000;
        }