Пример #1
0
        public override void FlipWithPlane(Vector3d p0, Vector3d normal)
        {
            VertexList vl = PointList;

            for (int i = 0; i < vl.Count; i++)
            {
                CadVertex v = vl[i];

                Vector3d cp = CadMath.CrossPlane(v.vector, p0, normal);

                CadVertex d = v - cp;

                v = cp - d;

                vl[i] = v;
            }

            Vector3dList nl = mHeModel.NormalStore;

            for (int i = 0; i < nl.Count; i++)
            {
                Vector3d v = nl[i];

                Vector3d cp = CadMath.CrossPlane(v, Vector3d.Zero, normal);

                Vector3d d = v - cp;

                v = cp - d;

                nl[i] = v;
            }
        }
Пример #2
0
        public override void MoveSelectedPointsFromStored(DrawContext dc, Vector3d delta)
        {
            //base.MoveSelectedPoints(dc, delta);

            if (Locked)
            {
                return;
            }

            Vector3d d;


            if (!IsSelectedAll() && mPointList.Count > 2 && RestrictionByNormal)
            {
                Vector3d vdir = dc.ViewDir;

                Vector3d a = delta;
                Vector3d b = delta + vdir;

                d = CadMath.CrossPlane(a, b, StoreList[0].vector, Normal);

                if (!d.IsValid())
                {
                    Vector3d nvNormal = CadMath.Normal(Normal, vdir);

                    double ip = CadMath.InnerProduct(nvNormal, delta);

                    d = nvNormal * ip;
                }
            }
            else
            {
                d = delta;
            }

            FigUtil.MoveSelectedPointsFromStored(this, dc, d);

            mChildList.ForEach(c =>
            {
                c.MoveSelectedPointsFromStored(dc, delta);
            });
        }
Пример #3
0
        public RulerInfo Capture(DrawContext dc, CadCursor cursor, double range)
        {
            RulerInfo ret = default(RulerInfo);

            Vector3d cwp = dc.DevPointToWorldPoint(cursor.Pos);

            Vector3d xfaceNormal = dc.DevVectorToWorldVector(cursor.DirX);
            Vector3d yfaceNormal = dc.DevVectorToWorldVector(cursor.DirY);

            Vector3d cx = CadMath.CrossPlane(P0, P1, cwp, xfaceNormal);
            Vector3d cy = CadMath.CrossPlane(P0, P1, cwp, yfaceNormal);

            if (!cx.IsValid() && !cy.IsValid())
            {
                return(ret);
            }

            Vector3d p    = VectorExt.InvalidVector3d;
            double   mind = Double.MaxValue;

            StackArray <Vector3d> vtbl = default;

            vtbl[0]     = cx;
            vtbl[1]     = cy;
            vtbl.Length = 2;

            for (int i = 0; i < vtbl.Length; i++)
            {
                Vector3d v = vtbl[i];

                if (!v.IsValid())
                {
                    continue;
                }

                Vector3d devv = dc.WorldPointToDevPoint(v);

                double td = (devv - cursor.Pos).Norm();

                if (td < mind)
                {
                    mind = td;
                    p    = v;
                }
            }

            if (!p.IsValid())
            {
                return(ret);
            }

            if (mind > range)
            {
                return(ret);
            }

            ret.IsValid    = true;
            ret.CrossPoint = p;
            ret.Distance   = mind;

            ret.Ruler = this;

            return(ret);
        }
Пример #4
0
        public override void MoveSelectedPointsFromStored(DrawContext dc, Vector3d delta)
        {
            if (PointList[0].Selected && PointList[1].Selected &&
                PointList[2].Selected && PointList[3].Selected)
            {
                PointList[0] = StoreList[0] + delta;
                PointList[1] = StoreList[1] + delta;
                PointList[2] = StoreList[2] + delta;
                PointList[3] = StoreList[3] + delta;
                return;
            }

            if (PointList[2].Selected || PointList[3].Selected)
            {
                Vector3d v0 = StoreList[3].vector - StoreList[0].vector;

                if (v0.IsZero())
                {
                    // 移動方向が不定の場合
                    MoveSelectedPointWithHeight(dc, delta);
                    return;
                }

                Vector3d v0u = v0.UnitVector();

                double d = CadMath.InnerProduct(v0u, delta);

                Vector3d vd = v0u * d;

                CadVertex nv3 = StoreList[3] + vd;
                CadVertex nv2 = StoreList[2] + vd;

                if (nv3.EqualsThreshold(StoreList[0], 0.001) ||
                    nv2.EqualsThreshold(StoreList[1], 0.001))
                {
                    return;
                }

                PointList[3] = nv3;
                PointList[2] = nv2;

                return;
            }

            if (PointList[0].Selected || PointList[1].Selected)
            {
                Vector3d v0 = StoreList[0].vector;
                Vector3d v1 = StoreList[1].vector;
                Vector3d v2 = StoreList[2].vector;
                Vector3d v3 = StoreList[3].vector;

                Vector3d lv = v3 - v0;
                double   h  = lv.Norm();

                Vector3d planeNormal = CadMath.Normal(v0, v1, v2);

                Vector3d cp0 = v0;
                Vector3d cp1 = v1;

                if (PointList[0].Selected)
                {
                    cp0 = CadMath.CrossPlane(v0 + delta, v0, planeNormal);
                }

                if (PointList[1].Selected)
                {
                    cp1 = CadMath.CrossPlane(v1 + delta, v1, planeNormal);
                }

                if (cp0.EqualsThreshold(cp1, 0.001))
                {
                    return;
                }

                if (PointList[0].Selected)
                {
                    PointList[0] = PointList[0].SetVector(cp0);
                }

                if (PointList[1].Selected)
                {
                    PointList[1] = PointList[1].SetVector(cp1);
                }

                Vector3d normal = CadMath.Normal(cp0, cp0 + planeNormal, cp1);
                Vector3d d      = normal * h;

                PointList[3] = PointList[3].SetVector(PointList[0] + d);
                PointList[2] = PointList[2].SetVector(PointList[1] + d);
            }
        }
Пример #5
0
        private void CheckCircle(DrawContext dc, CadLayer layer, CadFigure fig)
        {
            if (fig.PointCount < 3)
            {
                return;
            }

            VertexList vl = fig.PointList;

            if (fig.StoreList != null)
            {
                vl = fig.StoreList;
            }

            Vector3d c      = vl[0].vector;
            Vector3d a      = vl[1].vector;
            Vector3d b      = vl[2].vector;
            Vector3d normal = CadMath.Normal(a - c, b - c);

            Vector3d tw = Target.Pos;

            tw.Z = 0;
            tw   = dc.DevPointToWorldPoint(tw);

            Vector3d crossP = CadMath.CrossPlane(tw, tw + dc.ViewDir, c, normal);

            if (crossP.IsInvalid())
            {
                // 真横から見ている場合
                // viewed edge-on
                //DOut.tpl("crossP is invalid");
                return;
            }

            double r  = (a - c).Norm();
            double tr = (crossP - c).Norm();

            Vector3d cirP = c + (crossP - c) * (r / tr);

            Vector3d dcirP   = dc.WorldPointToDevPoint(cirP);
            Vector3d dcrossP = dc.WorldPointToDevPoint(crossP);

            dcirP.Z   = 0;
            dcrossP.Z = 0;

            double dist = (dcirP - Target.Pos).Norm();

            if (dist > Range)
            {
                //DOut.tpl($"dist:{dist} Range:{Range}");
                return;
            }

            if (dist < MinDist)
            {
                FigureSegment fseg = new FigureSegment(fig, 0, 0, 0);

                MarkSeg.Layer          = layer;
                MarkSeg.FigSeg         = fseg;
                MarkSeg.CrossPoint     = cirP;
                MarkSeg.CrossPointScrn = dc.WorldPointToDevPoint(cirP);
                MarkSeg.Distance       = dist;

                MinDist = dist;
            }
        }