Examples with Point2D javafx.geometry.Point2D used on opensource projects

Example 6 with Point2D

use of javafx.geometry.Point2D in project FXyzLib by Birdasaur.

the class TetrahedraMesh method createTetrahedra.

private TriangleMesh createTetrahedra(float height, int level) {
    TriangleMesh m0 = null;
    if (level > 0) {
        m0 = createTetrahedra(height, level - 1);
    }
    if (level == 0) {
        a = new Affine();
        float hw = height;
        if (center.get() != null) {
            a = a.createConcatenation(new Translate(center.get().x, center.get().y, center.get().z));
        }
        final float[] baseVertices = new float[] { 0f, 0f, 0.612372f * hw, -0.288675f * hw, -0.5f * hw, -0.204124f * hw, -0.288675f * hw, 0.5f * hw, -0.204124f * hw, 0.57735f * hw, 0f, -0.204124f * hw };
        final float[] baseTexCoords = new float[] { 0f, 0f, 0.5f, 0.866025f, 1f, 0f, 1f, 1.73205f, 1.5f, 0.866025f, 2f, 0f };
        final int[] baseTexture = new int[] { 0, 2, 1, 3, 1, 4, 2, 4, 1, 4, 2, 5 };
        final List<Integer> baseFaces = Arrays.asList(1, 2, 3, 2, 1, 0, 3, 0, 1, 0, 3, 2);
        for (int i = 0; i < baseVertices.length / 3; i++) {
            Point3D ta = transform(baseVertices[3 * i], baseVertices[3 * i + 1], baseVertices[3 * i + 2]);
            baseVertices[3 * i] = ta.x;
            baseVertices[3 * i + 1] = ta.y;
            baseVertices[3 * i + 2] = ta.z;
        }
        points0 = baseVertices;
        numVertices = baseVertices.length / 3;
        texCoord0 = baseTexCoords;
        numTexCoords = baseTexCoords.length / 2;
        faces0 = IntStream.range(0, baseFaces.size() / 3).mapToObj(i -> IntStream.of(baseFaces.get(3 * i), baseTexture[3 * i], baseFaces.get(3 * i + 1), baseTexture[3 * i + 1], baseFaces.get(3 * i + 2), baseTexture[3 * i + 2])).flatMapToInt(i -> i).toArray();
        numFaces = baseFaces.size() / 3;
    } else if (m0 != null) {
        points0 = new float[numVertices * m0.getPointElementSize()];
        m0.getPoints().toArray(points0);
    }
    List<Point3D> points1 = IntStream.range(0, numVertices).mapToObj(i -> new Point3D(points0[3 * i], points0[3 * i + 1], points0[3 * i + 2])).collect(Collectors.toList());
    if (level > 0 && m0 != null) {
        texCoord0 = new float[numTexCoords * m0.getTexCoordElementSize()];
        m0.getTexCoords().toArray(texCoord0);
    }
    texCoord1 = IntStream.range(0, numTexCoords).mapToObj(i -> new Point2D(texCoord0[2 * i], texCoord0[2 * i + 1])).collect(Collectors.toList());
    if (level > 0 && m0 != null) {
        faces0 = new int[numFaces * m0.getFaceElementSize()];
        m0.getFaces().toArray(faces0);
    }
    List<Face3> faces1 = IntStream.range(0, numFaces).mapToObj(i -> new Face3(faces0[6 * i], faces0[6 * i + 2], faces0[6 * i + 4])).collect(Collectors.toList());
    index.set(points1.size());
    map.clear();
    listVertices.clear();
    listFaces.clear();
    listVertices.addAll(points1);
    faces1.forEach(face -> {
        int v1 = face.p0;
        int v2 = face.p1;
        int v3 = face.p2;
        if (level > 0) {
            int a = getMiddle(v1, points1.get(v1), v2, points1.get(v2));
            int b = getMiddle(v2, points1.get(v2), v3, points1.get(v3));
            int c = getMiddle(v3, points1.get(v3), v1, points1.get(v1));
            listFaces.add(new Face3(v1, a, c));
            listFaces.add(new Face3(v2, b, a));
            listFaces.add(new Face3(v3, c, b));
            listFaces.add(new Face3(a, b, c));
        } else {
            listFaces.add(new Face3(v1, v2, v3));
        }
    });
    map.clear();
    numVertices = listVertices.size();
    numFaces = listFaces.size();
    List<Face3> textures1;
    if (level == 0) {
        textures1 = IntStream.range(0, faces0.length / 6).mapToObj(i -> new Face3(faces0[6 * i + 1], faces0[6 * i + 3], faces0[6 * i + 5])).collect(Collectors.toList());
    } else {
        textures1 = listTextures.stream().map(t -> t).collect(Collectors.toList());
    }
    index.set(texCoord1.size());
    listTextures.clear();
    textures1.forEach(face -> {
        int v1 = face.p0;
        int v2 = face.p1;
        int v3 = face.p2;
        if (level > 0) {
            int a = getMiddle(v1, texCoord1.get(v1), v2, texCoord1.get(v2));
            int b = getMiddle(v2, texCoord1.get(v2), v3, texCoord1.get(v3));
            int c = getMiddle(v3, texCoord1.get(v3), v1, texCoord1.get(v1));
            listTextures.add(new Face3(v1, a, c));
            listTextures.add(new Face3(v2, b, a));
            listTextures.add(new Face3(v3, c, b));
            listTextures.add(new Face3(a, b, c));
        } else {
            listTextures.add(new Face3(v1, v2, v3));
        }
    });
    map.clear();
    texCoord0 = texCoord1.stream().flatMapToDouble(p -> DoubleStream.of(p.getX(), p.getY())).collect(() -> new FloatCollector(texCoord1.size() * 2), FloatCollector::add, FloatCollector::join).toArray();
    numTexCoords = texCoord0.length / 2;
    textureCoords = texCoord0;
    if (level == getLevel()) {
        areaMesh.setWidth(2f * height);
        areaMesh.setHeight(height * Math.sqrt(3));
        // 1<<j -> bitset, 00100. Otherwise: 000111 will mean they are shared
        smoothingGroups = IntStream.range(0, listFaces.size()).map(i -> 1 << (i / (listFaces.size() / 4))).toArray();
    // smoothing groups based on 3DViewer -> same result
    //            float[] normals=new float[]{1,0,0,-1,0,0,0,1,0,0,-1,0,0,0,1,0,0,-1};
    //            int[] newFaces = IntStream.range(0, listFaces.size())
    //                        .mapToObj(i->IntStream.of((int)listFaces.get(i).x, (int)listFaces.get(i).x, 
    //                                (int)listFaces.get(i).y, (int)listFaces.get(i).y, 
    //                                (int)listFaces.get(i).z, (int)listFaces.get(i).z))
    //                        .flatMapToInt(i->i).toArray();
    //            int[] newFaceNormals = IntStream.range(0,listFaces.size()).mapToObj(i->{
    //                int j=(i/(listFaces.size()/6));
    //                return IntStream.of(j,j,j);
    //            }).flatMapToInt(i->i).toArray();
    //            smoothingGroups=SmoothingGroups.calcSmoothGroups(new TriangleMesh(), newFaces, newFaceNormals, normals);
    }
    return createMesh();
}

Example 7 with Point2D

use of javafx.geometry.Point2D in project FXyzLib by Birdasaur.

the class IcosahedronMesh method createSphere.

private TriangleMesh createSphere(int level, float diameter) {
    TriangleMesh m0 = null;
    if (level > 0) {
        m0 = createSphere(level - 1, diameter);
    }
    // read vertices from level-1
    if (level == 0) {
        points0 = baseVertices;
        numVertices = baseVertices.length / 3;
    } else if (m0 != null) {
        points0 = new float[numVertices * m0.getPointElementSize()];
        m0.getPoints().toArray(points0);
    }
    List<Point3D> points1 = IntStream.range(0, numVertices).mapToObj(i -> new Point3D(points0[3 * i], points0[3 * i + 1], points0[3 * i + 2])).collect(Collectors.toList());
    // read textures from level -1
    if (level == 0) {
        texCoord0 = baseTexCoords;
        numTexCoords = baseTexCoords.length / 2;
    } else if (m0 != null) {
        texCoord0 = new float[numTexCoords * m0.getTexCoordElementSize()];
        m0.getTexCoords().toArray(texCoord0);
    }
    texCoord1 = IntStream.range(0, numTexCoords).mapToObj(i -> new Point2D(texCoord0[2 * i], texCoord0[2 * i + 1])).collect(Collectors.toList());
    // read faces from level -1
    if (level == 0) {
        faces0 = IntStream.range(0, baseFaces.size() / 3).mapToObj(i -> IntStream.of(baseFaces.get(3 * i), baseTexture[3 * i], baseFaces.get(3 * i + 1), baseTexture[3 * i + 1], baseFaces.get(3 * i + 2), baseTexture[3 * i + 2])).flatMapToInt(i -> i).toArray();
        numFaces = baseFaces.size() / 3;
    } else if (m0 != null) {
        faces0 = new int[numFaces * m0.getFaceElementSize()];
        m0.getFaces().toArray(faces0);
    }
    List<Face3> faces1 = IntStream.range(0, numFaces).mapToObj(i -> new Face3(faces0[6 * i], faces0[6 * i + 2], faces0[6 * i + 4])).collect(Collectors.toList());
    index.set(points1.size());
    map.clear();
    listVertices.clear();
    listFaces.clear();
    listVertices.addAll(points1);
    faces1.forEach(face -> {
        int v1 = face.p0;
        int v2 = face.p1;
        int v3 = face.p2;
        if (level > 0) {
            int a = getMiddle(v1, points1.get(v1), v2, points1.get(v2));
            int b = getMiddle(v2, points1.get(v2), v3, points1.get(v3));
            int c = getMiddle(v3, points1.get(v3), v1, points1.get(v1));
            listFaces.add(new Face3(v1, a, c));
            listFaces.add(new Face3(v2, b, a));
            listFaces.add(new Face3(v3, c, b));
            listFaces.add(new Face3(a, b, c));
        } else {
            listFaces.add(new Face3(v1, v2, v3));
        }
    });
    map.clear();
    numVertices = listVertices.size();
    numFaces = listFaces.size();
    List<Face3> textures1;
    if (level == 0) {
        textures1 = IntStream.range(0, faces0.length / 6).mapToObj(i -> new Face3(faces0[6 * i + 1], faces0[6 * i + 3], faces0[6 * i + 5])).collect(Collectors.toList());
    } else {
        textures1 = listTextures.stream().map(t -> t).collect(Collectors.toList());
    }
    index.set(texCoord1.size());
    listTextures.clear();
    textures1.forEach(face -> {
        int v1 = face.p0;
        int v2 = face.p1;
        int v3 = face.p2;
        if (level > 0) {
            int a = getMiddle(v1, texCoord1.get(v1), v2, texCoord1.get(v2));
            int b = getMiddle(v2, texCoord1.get(v2), v3, texCoord1.get(v3));
            int c = getMiddle(v3, texCoord1.get(v3), v1, texCoord1.get(v1));
            listTextures.add(new Face3(v1, a, c));
            listTextures.add(new Face3(v2, b, a));
            listTextures.add(new Face3(v3, c, b));
            listTextures.add(new Face3(a, b, c));
        } else {
            listTextures.add(new Face3(v1, v2, v3));
        }
    });
    map.clear();
    texCoord0 = texCoord1.stream().flatMapToDouble(p -> DoubleStream.of(p.getX(), p.getY())).collect(() -> new FloatCollector(texCoord1.size() * 2), FloatCollector::add, FloatCollector::join).toArray();
    numTexCoords = texCoord0.length / 2;
    textureCoords = texCoord0;
    if (level == getLevel()) {
        areaMesh.setWidth(Math.PI * diameter);
        areaMesh.setHeight(Math.PI * diameter);
        rectMesh.setWidth((int) Math.sqrt(texCoord0.length));
        rectMesh.setHeight(texCoord0.length / ((int) Math.sqrt(texCoord0.length)));
    }
    return createMesh();
}

Example 8 with Point2D

use of javafx.geometry.Point2D in project FXyzLib by Birdasaur.

the class PrismMesh method createCylinder.

private TriangleMesh createCylinder(float radius, float height, int level) {
    TriangleMesh m0 = null;
    if (level > 0) {
        m0 = createCylinder(radius, height, level - 1);
    }
    if (level == 0) {
        int div = DEFAULT_DIVISIONS > 3 ? DEFAULT_DIVISIONS : 3;
        if (getSectionType() != TriangleMeshHelper.SectionType.CIRCLE) {
            div = getSectionType().getSides() * ((int) (div / getSectionType().getSides()) + 1);
        }
        if (getAxisOrigin() != null && getAxisEnd() != null) {
            Point3D dir = getAxisEnd().substract(getAxisOrigin()).crossProduct(new Point3D(0, -1, 0));
            double angle = Math.acos(getAxisEnd().substract(getAxisOrigin()).normalize().dotProduct(new Point3D(0, -1, 0)));
            a = a.createConcatenation(new Translate(getAxisOrigin().x, getAxisOrigin().y - height / 2d, getAxisOrigin().z)).createConcatenation(new Rotate(-Math.toDegrees(angle), 0d, height / 2d, 0d, new javafx.geometry.Point3D(dir.x, -dir.y, dir.z)));
        }
        int nPoints = 2 * div + 2;
        float r = radius;
        float h = height;
        final float[] baseVertices = new float[nPoints * 3];
        // base at y=h/2
        for (int i = 0; i < div; i++) {
            double ang = i * 2d * Math.PI / div;
            double pol = polygonalSection(ang);
            Point3D ta = transform(r * pol * Math.cos(ang), h / 2, r * pol * Math.sin(ang));
            baseVertices[3 * i] = ta.x;
            baseVertices[3 * i + 1] = ta.y;
            baseVertices[3 * i + 2] = ta.z;
        //                baseVertices[3*i]=(float)(r*pol*Math.cos(ang));
        //                baseVertices[3*i+1]=h/2;
        //                baseVertices[3*i+2]=(float)(r*pol*Math.sin(ang));
        }
        // top at y=-h/2
        for (int i = div; i < 2 * div; i++) {
            double ang = i * 2d * Math.PI / div;
            double pol = polygonalSection(ang);
            Point3D ta = transform(r * pol * Math.cos(ang), -h / 2, r * pol * Math.sin(ang));
            baseVertices[3 * i] = ta.x;
            baseVertices[3 * i + 1] = ta.y;
            baseVertices[3 * i + 2] = ta.z;
        //                baseVertices[3*i]=(float)(r*pol*Math.cos(ang));
        //                baseVertices[3*i+1]=-h/2;
        //                baseVertices[3*i+2]=(float)(r*pol*Math.sin(ang));
        }
        Point3D ta = transform(0, h / 2, 0);
        baseVertices[6 * div] = ta.x;
        baseVertices[6 * div + 1] = ta.y;
        baseVertices[6 * div + 2] = ta.z;
        ta = transform(0, -h / 2, 0);
        baseVertices[6 * div + 3] = ta.x;
        baseVertices[6 * div + 4] = ta.y;
        baseVertices[6 * div + 5] = ta.z;
        //            baseVertices[6*div]=0f;
        //            baseVertices[6*div+1]=h/2f;
        //            baseVertices[6*div+2]=0f;
        //            baseVertices[6*div+3]=0f;
        //            baseVertices[6*div+4]=-h/2f;
        //            baseVertices[6*div+5]=0f;
        int nTextCoords = div * 4 + 6;
        float rect = (float) polygonalSize(r);
        float L = (float) (r + 2d * Math.PI * r);
        float H = 4f * r + h;
        final float[] baseTexCoords = new float[nTextCoords * 2];
        // u right ,v up
        for (int i = 0; i <= div; i++) {
            baseTexCoords[2 * i] = (float) (r + i * rect / div) / L;
            baseTexCoords[2 * i + 1] = (float) (2f * r + h) / H;
        }
        for (int i = 0; i <= div; i++) {
            baseTexCoords[2 * div + 2 * i + 2] = (float) (r + i * rect / div) / L;
            baseTexCoords[2 * div + 2 * i + 3] = (float) (2f * r) / H;
        }
        for (int i = 0; i <= div; i++) {
            double ang = i * 2d * Math.PI / div;
            double pol = polygonalSection(ang);
            baseTexCoords[4 * div + 2 * i + 4] = (float) (r + r * pol * Math.sin(ang)) / L;
            baseTexCoords[4 * div + 2 * i + 5] = (float) (3f * r + h - r * pol * Math.cos(ang)) / H;
        }
        for (int i = 0; i <= div; i++) {
            double ang = i * 2d * Math.PI / div;
            double pol = polygonalSection(ang);
            baseTexCoords[6 * div + 2 * i + 6] = (float) (r + r * pol * Math.sin(ang)) / L;
            baseTexCoords[6 * div + 2 * i + 7] = (float) (r + r * pol * Math.cos(ang)) / H;
        }
        baseTexCoords[8 * div + 8] = r / L;
        baseTexCoords[8 * div + 9] = (3f * r + h) / H;
        baseTexCoords[8 * div + 10] = r / L;
        baseTexCoords[8 * div + 11] = r / H;
        int nFaces = div * 4;
        final int[] baseTexture = new int[nFaces * 3];
        final int[] baseFaces = new int[nFaces * 3];
        for (int i = 0; i < div; i++) {
            int p1 = i + 1;
            int p2 = i + div;
            int p3 = i + div + 1;
            baseFaces[6 * i] = i;
            baseFaces[6 * i + 1] = p1 == div ? 0 : p1;
            baseFaces[6 * i + 2] = p2;
            baseFaces[6 * i + 3] = p3 % div == 0 ? p3 - div : p3;
            baseFaces[6 * i + 4] = p2;
            baseFaces[6 * i + 5] = p1 == div ? 0 : p1;
            baseTexture[6 * i] = i;
            baseTexture[6 * i + 1] = p1;
            baseTexture[6 * i + 2] = p2 + 1;
            baseTexture[6 * i + 3] = p3 + 1;
            baseTexture[6 * i + 4] = p2 + 1;
            baseTexture[6 * i + 5] = p1;
        }
        for (int i = 0; i < div; i++) {
            int p1 = div * 2;
            int p2 = i + 1;
            baseFaces[6 * div + 3 * i] = i;
            baseFaces[6 * div + 3 * i + 1] = p1;
            baseFaces[6 * div + 3 * i + 2] = p2 == div ? 0 : p2;
            baseTexture[6 * div + 3 * i] = (div + 1) * 2 + i;
            baseTexture[6 * div + 3 * i + 1] = (div + 1) * 4;
            baseTexture[6 * div + 3 * i + 2] = (div + 1) * 2 + i + 1;
        }
        for (int i = 0; i < div; i++) {
            int p1 = div * 2 + 1;
            int p2 = i + 1 + div;
            baseFaces[9 * div + 3 * i] = i + div;
            baseFaces[9 * div + 3 * i + 1] = p2 % div == 0 ? p2 - div : p2;
            baseFaces[9 * div + 3 * i + 2] = p1;
            baseTexture[9 * div + 3 * i] = (div + 1) * 3 + i;
            baseTexture[9 * div + 3 * i + 1] = (div + 1) * 3 + i + 1;
            baseTexture[9 * div + 3 * i + 2] = (div + 1) * 4 + 1;
        }
        points0 = baseVertices;
        numVertices = baseVertices.length / 3;
        texCoord0 = baseTexCoords;
        numTexCoords = baseTexCoords.length / 2;
        faces0 = IntStream.range(0, baseFaces.length / 3).mapToObj(i -> IntStream.of(baseFaces[3 * i], baseTexture[3 * i], baseFaces[3 * i + 1], baseTexture[3 * i + 1], baseFaces[3 * i + 2], baseTexture[3 * i + 2])).flatMapToInt(i -> i).toArray();
        numFaces = baseFaces.length / 3;
    } else if (m0 != null) {
        points0 = new float[numVertices * m0.getPointElementSize()];
        m0.getPoints().toArray(points0);
    }
    final float h = height;
    List<Point3D> points1 = IntStream.range(0, numVertices).mapToObj(i -> {
        Point3D p = new Point3D(points0[3 * i], points0[3 * i + 1], points0[3 * i + 2]);
        p.f = (h / 2 - unTransform(p).y) / h;
        return p;
    }).collect(Collectors.toList());
    //        points1.forEach(p->System.out.print(" "+p.f));
    if (level > 0 && m0 != null) {
        texCoord0 = new float[numTexCoords * m0.getTexCoordElementSize()];
        m0.getTexCoords().toArray(texCoord0);
    }
    texCoord1 = IntStream.range(0, numTexCoords).mapToObj(i -> new Point2D(texCoord0[2 * i], texCoord0[2 * i + 1])).collect(Collectors.toList());
    if (level > 0 && m0 != null) {
        faces0 = new int[numFaces * m0.getFaceElementSize()];
        m0.getFaces().toArray(faces0);
    }
    List<Face3> faces1 = IntStream.range(0, numFaces).mapToObj(i -> new Face3(faces0[6 * i], faces0[6 * i + 2], faces0[6 * i + 4])).collect(Collectors.toList());
    index.set(points1.size());
    map.clear();
    listVertices.clear();
    listFaces.clear();
    listVertices.addAll(points1);
    faces1.forEach(face -> {
        int v1 = face.p0;
        int v2 = face.p1;
        int v3 = face.p2;
        if (level > 0) {
            int a = getMiddle(v1, points1.get(v1), v2, points1.get(v2));
            int b = getMiddle(v2, points1.get(v2), v3, points1.get(v3));
            int c = getMiddle(v3, points1.get(v3), v1, points1.get(v1));
            listFaces.add(new Face3(v1, a, c));
            listFaces.add(new Face3(v2, b, a));
            listFaces.add(new Face3(v3, c, b));
            listFaces.add(new Face3(a, b, c));
        } else {
            listFaces.add(new Face3(v1, v2, v3));
        }
    });
    map.clear();
    numVertices = listVertices.size();
    numFaces = listFaces.size();
    List<Face3> textures1;
    if (level == 0) {
        textures1 = IntStream.range(0, faces0.length / 6).mapToObj(i -> new Face3(faces0[6 * i + 1], faces0[6 * i + 3], faces0[6 * i + 5])).collect(Collectors.toList());
    } else {
        textures1 = listTextures.stream().map(t -> t).collect(Collectors.toList());
    }
    index.set(texCoord1.size());
    listTextures.clear();
    textures1.forEach(face -> {
        int v1 = face.p0;
        int v2 = face.p1;
        int v3 = face.p2;
        if (level > 0) {
            int a = getMiddle(v1, texCoord1.get(v1), v2, texCoord1.get(v2));
            int b = getMiddle(v2, texCoord1.get(v2), v3, texCoord1.get(v3));
            int c = getMiddle(v3, texCoord1.get(v3), v1, texCoord1.get(v1));
            listTextures.add(new Face3(v1, a, c));
            listTextures.add(new Face3(v2, b, a));
            listTextures.add(new Face3(v3, c, b));
            listTextures.add(new Face3(a, b, c));
        } else {
            listTextures.add(new Face3(v1, v2, v3));
        }
    });
    map.clear();
    texCoord0 = texCoord1.stream().flatMapToDouble(p -> DoubleStream.of(p.getX(), p.getY())).collect(() -> new FloatCollector(texCoord1.size() * 2), FloatCollector::add, FloatCollector::join).toArray();
    numTexCoords = texCoord0.length / 2;
    textureCoords = texCoord0;
    if (level == getLevel()) {
        areaMesh.setWidth(radius + 2f * Math.PI * radius);
        areaMesh.setHeight(height + 4f * radius);
        smoothingGroups = IntStream.range(0, listFaces.size()).map(i -> {
            if (getSectionType() != TriangleMeshHelper.SectionType.CIRCLE) {
                return 0;
            }
            if (i < listFaces.size() / 2) {
                return 1;
            } else if (i < 3 * listFaces.size() / 4) {
                return 2;
            }
            return 4;
        }).toArray();
    //            listVertices.stream()
    //                    .sorted((p1,p2)->Double.compare(p1.y,p2.y))
    //                    .mapToDouble(p->p.f).distinct()
    //                    .forEach(f->System.out.print(" "+f));
    }
    return createMesh();
}

Example 9 with Point2D

use of javafx.geometry.Point2D in project bitsquare by bitsquare.

the class PasswordTextField method getErrorPopupPosition.

private Point2D getErrorPopupPosition() {
    Window window = getScene().getWindow();
    Point2D point;
    point = layoutReference.localToScene(0, 0);
    double x = Math.floor(point.getX() + window.getX() + layoutReference.getWidth() + 20 - getPadding().getLeft() - getPadding().getRight());
    double y = Math.floor(point.getY() + window.getY() + getHeight() / 2 - getPadding().getTop() - getPadding().getBottom());
    return new Point2D(x, y);
}

Example 10 with Point2D

use of javafx.geometry.Point2D in project Gargoyle by callakrsos.

the class DockNode method handle.

@Override
public void handle(MouseEvent event) {
    //		if(event.getSource() instanceof DockTabPane)
    //			return;
    //		System.err.println(event.getPickResult().getIntersectedNode());
    Cursor cursor = Cursor.DEFAULT;
    // TODO: use escape to cancel resize/drag operation like visual studio
    if (!this.isFloating() || !this.isStageResizable()) {
        return;
    }
    if (event.getEventType() == MouseEvent.MOUSE_PRESSED) {
        sizeLast = new Point2D(event.getScreenX(), event.getScreenY());
    } else if (event.getEventType() == MouseEvent.MOUSE_MOVED) {
        Insets insets = borderPane.getPadding();
        sizeWest = event.getX() < insets.getLeft();
        sizeEast = event.getX() > borderPane.getWidth() - insets.getRight();
        sizeNorth = event.getY() < insets.getTop();
        sizeSouth = event.getY() > borderPane.getHeight() - insets.getBottom();
        if (sizeWest) {
            if (sizeNorth) {
                cursor = Cursor.NW_RESIZE;
            } else if (sizeSouth) {
                cursor = Cursor.SW_RESIZE;
            } else {
                cursor = Cursor.W_RESIZE;
            }
        } else if (sizeEast) {
            if (sizeNorth) {
                cursor = Cursor.NE_RESIZE;
            } else if (sizeSouth) {
                cursor = Cursor.SE_RESIZE;
            } else {
                cursor = Cursor.E_RESIZE;
            }
        } else if (sizeNorth) {
            cursor = Cursor.N_RESIZE;
        } else if (sizeSouth) {
            cursor = Cursor.S_RESIZE;
        }
        this.getScene().setCursor(cursor);
    } else if (event.getEventType() == MouseEvent.MOUSE_DRAGGED && this.isMouseResizeZone()) {
        Point2D sizeCurrent = new Point2D(event.getScreenX(), event.getScreenY());
        Point2D sizeDelta = sizeCurrent.subtract(sizeLast);
        double newX = stage.getX(), newY = stage.getY(), newWidth = stage.getWidth(), newHeight = stage.getHeight();
        if (sizeNorth) {
            newHeight -= sizeDelta.getY();
            newY += sizeDelta.getY();
        } else if (sizeSouth) {
            newHeight += sizeDelta.getY();
        }
        if (sizeWest) {
            newWidth -= sizeDelta.getX();
            newX += sizeDelta.getX();
        } else if (sizeEast) {
            newWidth += sizeDelta.getX();
        }
        // TODO: find a way to do this synchronously and eliminate the flickering of moving the stage
        // around, also file a bug report for this feature if a work around can not be found this
        // primarily occurs when dragging north/west but it also appears in native windows and Visual
        // Studio, so not that big of a concern.
        // Bug report filed:
        // https://bugs.openjdk.java.net/browse/JDK-8133332
        double currentX = sizeLast.getX(), currentY = sizeLast.getY();
        if (newWidth >= stage.getMinWidth()) {
            stage.setX(newX);
            stage.setWidth(newWidth);
            currentX = sizeCurrent.getX();
        }
        if (newHeight >= stage.getMinHeight()) {
            stage.setY(newY);
            stage.setHeight(newHeight);
            currentY = sizeCurrent.getY();
        }
        sizeLast = new Point2D(currentX, currentY);
        // while we are actively resizing
        if (sizeNorth || sizeSouth || sizeWest || sizeEast) {
            event.consume();
        }
    }
}