⭐ 欢迎来到虫虫下载站! | 📦 资源下载 📁 资源专辑 ℹ️ 关于我们
⭐ 虫虫下载站

📄 dv.java~1046~

📁 一个新的voronoi算法实现
💻 JAVA~1046~
📖 第 1 页 / 共 5 页
字号:
                vop = vpointstore.elementAt(1);
                t = edgestore.elementAt(1);
                exvop = vpointstore.elementAt(1);
                ext = edgestore.elementAt(1);
            } else {
                vop = vpointstore.elementAt(0);
                t = edgestore.elementAt(0);
                exvop = vpointstore.elementAt(0);
                ext = edgestore.elementAt(0);
            }

            if (t.op1 == xop) {
                dop = xop;
                xop = t.op2;
            } else {
                dop = xop;
                xop = t.op1;
            }

        }

        double ldopxop = Math.pow(xop.x - dop.x, 2) +
                         Math.pow(xop.y - dop.y, 2);
        double ldopdtemp = Math.pow(dop.x - dtemp.x, 2) +
                           Math.pow(dop.y - dtemp.y, 2);
        double lxopdtemp = Math.pow(xop.x - dtemp.x, 2) +
                           Math.pow(xop.y - dtemp.y, 2);
        double xk = (xop.x + dtemp.x) / 2;
        double yk = (xop.y + dtemp.y) / 2;
        double sk = -(xop.x - dtemp.x) / (xop.y - dtemp.y);
        vpoint pre0;
        if (yk + sk * ( -unlimit - xk) > max) {

            pre0 = new vpoint(((max - yk) / sk) + xk, max, vpointkey++);
        } else if (yk + sk * ( -unlimit - xk) < -max) {
            pre0 = new vpoint((( -max - yk) / sk) + xk, -max, vpointkey++);
        }

        else {
            pre0 = new vpoint( -unlimit, yk + sk * ( -unlimit - xk), vpointkey++);
        }
        vpoint preunlimit;
        if (yk + sk * (unlimit - xk) > max) {
            preunlimit = new vpoint(((max - yk) / sk) + xk, max, vpointkey++);
        } else if (yk + sk * (unlimit - xk) < -max) {
            preunlimit = new vpoint((( -max - yk) / sk) + xk, -max, vpointkey++);
        } else {
            preunlimit = new vpoint(unlimit, yk + sk * (unlimit - xk),
                                    vpointkey++);
        }

        temp = null;
        temp = new edge();

        if (lxopdtemp >= (ldopxop + ldopdtemp)) {

            if (xk > pre0.x & xk < vop.x || xk > vop.x & xk < pre0.x) {
                temp.a = preunlimit;
                temp.b = vop;
                temp.op1 = dtemp;
                temp.op2 = xop;

            } else {
                temp.a = pre0;
                temp.b = vop;
                temp.op1 = dtemp;
                temp.op2 = xop;
            }

        } else {
            if (xk > pre0.x & xk < vop.x || xk > vop.x & xk < pre0.x) {
                temp.a = pre0;
                temp.b = vop;
                temp.op1 = dtemp;
                temp.op2 = xop;

            } else {
                temp.a = preunlimit;
                temp.b = vop;
                temp.op1 = dtemp;
                temp.op2 = xop;
            }

        }

        vpointstore.removeAllElements();
        edgestore.removeAllElements();
        vpoint a = new vpoint();
        vpoint b = new vpoint();
        for (int i = 0; i < xop.dpointedges.size(); i++) {
            edge tk = xop.dpointedges.elementAt(i);
            a = tk.a;
            b = tk.b;
            double sks = (b.y - a.y) / (b.x - a.x);
            double x = (yk - a.y - sk * xk + sks * a.x) / (sks - sk);
            if (x >= a.x - det & x <= b.x + det ||
                x >= b.x - det & x <= a.x + det) {
                double y = yk + sk * (x - xk);
                vpoint vopk = new vpoint(x, y, vpointkey++);
                vpointstore.add(vopk);
                edgestore.add(tk);
            }

        }

        if (vpointstore.size() == 1) { //注意et

            //此时temp代表的是新生成的边 but 还有一条旧边没有处理 此旧边的对应op1  op2 为dtemp xop
            edge et = edgestore.elementAt(0);

            a = et.a;
            b = et.b;

            if (a.x < b.x) {
                et.a = a;
                et.b = vop;
            } else {
                et.a = vop;
                et.b = b;
            }

            edgelist.add(temp);
            xop.dpointedges.add(temp);
            dtemp.dpointedges.add(temp);

            removeedge(edgelist, xop, temp.a, temp.b);

        } else if (vpointstore.size() == 2) {

            a = ext.a;
            b = ext.b;
            if (a.x < b.x) {
                ext.a = a;
                ext.b = exvop;
            } else {
                ext.b = b;
                ext.a = exvop;
            }

            if (hero == 1) {
                dop = xop;
            }

            kernerl5(edgestore, vpointstore, temp, edgelist, dop, xop, dtemp,
                     vop, t, index);
        }

    }

    public void construct3(Vector<edge> edgelist,
            Vector<dpoint> dpointlist,
            Vector<vpoint> vpointlist, dpoint dtemp, int index) {
        Vector<dpoint> position = new Vector<dpoint>();
        position = findpos(rchc, dtemp);
        if (position.size() == 1) {
            //dop=position  xop,,,    vop ==vpoint ,,,dtemp the insert point

            Vector<vpoint> vpointstore = new Vector<vpoint>();
            Vector<edge> edgestore = new Vector<edge>();
            dpoint dop = position.elementAt(0);
            double xk = (dop.x + dtemp.x) / 2;
            double yk = (dop.y + dtemp.y) / 2;
            double sk = -(dtemp.x - dop.x) / (dtemp.y - dop.y);

            for (int i = 0; i < dop.dpointedges.size(); i++) {
                edge t = dop.dpointedges.elementAt(i);
                vpoint a = t.a;
                vpoint b = t.b;
                double sks = (b.y - a.y) / (b.x - a.x);

                double x = (yk + sks * a.x - a.y - sk * xk) / (sks - sk);

                if (x >= a.x - det & x <= b.x + det ||
                    x >= b.x - det & x <= a.x + det) {
                    double y = a.y + sks * (x - a.x);
                    vpoint vop = new vpoint(x, y, vpointkey++);
                    vpointstore.add(vop);
                    edgestore.add(t);

                }

            }
            if (vpointstore.size() == 1) {

                edge t = edgestore.elementAt(0);
                dpoint xop = new dpoint();
                if (t.op1 == dop) {
                    xop = t.op2;
                } else {
                    xop = t.op1;
                }
                vpoint vop = vpointstore.elementAt(0);

                kernerl3(edgelist, dop, xop, dtemp, vop, t, index); //position ==1 the intersection position ==1

            } else if (vpointstore.size() == 2) {

                vpoint v1 = vpointstore.elementAt(0);
                vpoint v2 = vpointstore.elementAt(1);
                edge t = new edge();
                t.a = v1;
                t.b = v2;
                t.op1 = dop;
                t.op2 = dtemp;
                edgelist.add(t);
                dop.dpointedges.add(t);
                dtemp.dpointedges.add(t);
                removeedge(edgelist, dop, t.a, t.b);
                t = edgestore.elementAt(0);
                vpoint vop = vpointstore.elementAt(0);
                dpoint xop = new dpoint();
                if (t.op1 == dop) {
                    xop = t.op2;
                } else {
                    xop = t.op1;
                }
                kernerl4(edgelist, dop, xop, dtemp, vop, t, index);

                t = edgestore.elementAt(1);
                vop = vpointstore.elementAt(1);
                if (t.op1 == dop) {
                    xop = t.op2;
                } else {
                    xop = t.op1;
                }

                kernerl4(edgelist, dop, xop, dtemp, vop, t, index);

            }

        } else if (position.size() == 2) {

            dpoint up = position.elementAt(0);
            dpoint down = position.elementAt(1);

            if (up.y < down.y) {

            } else {
                dpoint exchange = new dpoint();
                exchange = up;
                up = down;
                down = exchange;
            }

            dpoint dop = up;
            double xk = (dop.x + dtemp.x) / 2;
            double yk = (dop.y + dtemp.y) / 2;
            double sk = -(dop.x - dtemp.x) / (dop.y - dtemp.y);

            Vector<edge> edgestore = new Vector<edge>();
            Vector<vpoint> vpointstore = new Vector<vpoint>();
            for (int i = 0; i < dop.dpointedges.size(); i++) {
                edge t = dop.dpointedges.elementAt(i);
                vpoint a = t.a;
                vpoint b = t.b;
                double sks = (b.y - a.y) / (b.x - a.x);

                double x = (yk + sks * a.x - a.y - sk * xk) / (sks - sk);

                if (x >= a.x - det & x <= b.x + det ||
                    x >= b.x - det & x <= a.x + det) {
                    double y = a.y + sks * (x - a.x);
                    vpoint vop = new vpoint(x, y, vpointkey++);
                    vpointstore.add(vop);
                    edgestore.add(t);

                }

            }
            if (vpointstore.size() == 1) {

                //简单处理上区域、、主要是调用
                //pisition =1 the interpoint =1
                vpoint vop = vpointstore.elementAt(0);

                edge t = edgestore.elementAt(0);
                dpoint xop = new dpoint();
                if (t.op1 == dop) {
                    xop = t.op2;
                } else {
                    xop = t.op1;
                }

                kernerl6(edgelist, dop, xop, dtemp, vop, t, index, down); //处理一条旧边生成一条新边 处理down点

            } else if (vpointstore.size() == 2) {

                //处理上区域
                dpoint xop = down;
                vpoint vop0 = vpointstore.elementAt(0);
                vpoint vop1 = vpointstore.elementAt(1);
                xk = (dop.x + xop.x) / 2;
                yk = (dop.y + xop.y) / 2;
                sk = -(dop.x - xop.x) / (dop.y - xop.y);
                vpoint vop = new vpoint();
                vpoint svop = new vpoint();
                edge t = new edge();
                edge st = new edge();
                vop = null;
                vop = new vpoint();
                double flag = vop0.y - yk - sk * (vop0.x - xk);
                if (Math.abs(flag) < det) {
                    vop = vop0;
                    t = edgestore.elementAt(0);
                    svop = vop1;
                    st = edgestore.elementAt(1);

                } else {
                    vop = vop1;
                    t = edgestore.elementAt(1);
                    svop = vop0;
                    st = edgestore.elementAt(0);
                }

                kernerl7(edgelist, dop, xop, dtemp, vop, t); //mend thd old edge 调用kernerl5

                edge temp = new edge();
                temp.op1 = dtemp;
                temp.op2 = dop;
                kernerl5(edgestore, vpointstore, temp, edgelist, dop, xop,
                         dtemp, vop, t, index);
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                //处理down 点
                //for vpoint exchange


                //处理下部的xop

                vpointstore.removeAllElements();
                edgestore.removeAllElements();
                vpoint a = new vpoint();
                vpoint b = new vpoint();
                xk = (dtemp.x + xop.x) / 2;
                yk = (dtemp.y + xop.y) / 2;
                sk = -(xop.x - dtemp.x) / (xop.y - dtemp.y);
                for (int i = 0; i < xop.dpointedges.size(); i++) {
                    edge tk = xop.dpointedges.elementAt(i);
                    a = tk.a;
                    b = tk.b;
                    double sks = (b.y - a.y) / (b.x - a.x);
                    double x = (yk - a.y - sk * xk + sks * a.x) / (sks - sk);
                    if (x >= a.x - det & x <= b.x + det ||
                        x >= b.x - det & x <= a.x + det) {
                        double y = a.y + sks * (x - a.x);

                        vpoint vopk = new vpoint(x, y, vpointkey++);
                        vpointstore.add(vopk);
                        edgestore.add(tk);
                    }

                }
                temp = null;
                temp = new edge();
                if (vpointstore.size() == 1) {

                    vpoint preunlimit;
                    if (yk + sk * (unlimit - xk) > max) {
                        preunlimit = new vpoint(((max - yk) / sk) + xk, max,
                                                vpointkey++);
                    } else if (yk + sk * (unlimit - xk) < -max) {
                        preunlimit = new vpoint((( -max - yk) / sk) + xk, -max,
                                                vpointkey++);
                    } else {
                        preunlimit = new vpoint(unlimit,
                                                yk + sk * (unlimit - xk),
                                                vpointkey++);
                    }
                    temp.a = vop;
                    temp.b = preunlimit;
                    temp.op1 = dtemp;
                    temp.op2 = xop;

                    edgelist.add(temp);
                    xop.dpointedges.add(temp);

⌨️ 快捷键说明

复制代码 Ctrl + C
搜索代码 Ctrl + F
全屏模式 F11
切换主题 Ctrl + Shift + D
显示快捷键 ?
增大字号 Ctrl + =
减小字号 Ctrl + -