Examples with VisPolygon org.vcell.vis.vismesh.thrift.VisPolygon used on opensource projects

Example 1 with VisPolygon

use of org.vcell.vis.vismesh.thrift.VisPolygon in project vcell by virtualcell.

the class CartesianMeshMapping method fromMesh3DMembrane.

private VisMesh fromMesh3DMembrane(CartesianMesh cartesianMesh, String domainName) {
    ISize size = cartesianMesh.getSize();
    int numX = size.getX();
    int numY = size.getY();
    int dimension = 3;
    Vect3D origin = new Vect3D(cartesianMesh.getOrigin().x, cartesianMesh.getOrigin().y, cartesianMesh.getOrigin().z);
    Vect3D extent = new Vect3D(cartesianMesh.getExtent().x, cartesianMesh.getExtent().y, cartesianMesh.getExtent().z);
    // invoke VisMesh() constructor
    VisMesh visMesh = new VisMesh(dimension, origin, extent);
    int currPointIndex = 0;
    HashMap<String, Integer> pointDict = new HashMap<String, Integer>();
    List<MembraneElement> membraneElements = cartesianMesh.getMembraneElements(domainName);
    for (MembraneElement membraneElement : membraneElements) {
        // inside
        int insideVolumeIndex = membraneElement.getInsideVolumeIndex();
        int insideI = insideVolumeIndex % numX;
        int insideJ = (insideVolumeIndex % (numX * numY)) / numX;
        int insideK = insideVolumeIndex / (numX * numY);
        Box3D insideBox = cartesianMesh.getVolumeElementBox(insideI, insideJ, insideK);
        // outside
        int outsideVolumeIndex = membraneElement.getOutsideVolumeIndex();
        int outsideI = outsideVolumeIndex % numX;
        int outsideJ = (outsideVolumeIndex % (numX * numY)) / numX;
        int outsideK = outsideVolumeIndex / (numX * numY);
        VisPoint p1Coord;
        VisPoint p2Coord;
        VisPoint p3Coord;
        VisPoint p4Coord;
        if (insideI == outsideI + 1) {
            // x-   z cross y
            double x = insideBox.x_lo;
            p1Coord = new VisPoint(x, insideBox.y_lo, insideBox.z_lo);
            p2Coord = new VisPoint(x, insideBox.y_lo, insideBox.z_hi);
            p3Coord = new VisPoint(x, insideBox.y_hi, insideBox.z_hi);
            p4Coord = new VisPoint(x, insideBox.y_hi, insideBox.z_lo);
        } else if (outsideI == insideI + 1) {
            // x+   y cross z
            double x = insideBox.x_hi;
            p1Coord = new VisPoint(x, insideBox.y_lo, insideBox.z_lo);
            p2Coord = new VisPoint(x, insideBox.y_hi, insideBox.z_lo);
            p3Coord = new VisPoint(x, insideBox.y_hi, insideBox.z_hi);
            p4Coord = new VisPoint(x, insideBox.y_lo, insideBox.z_hi);
        } else if (insideJ == outsideJ + 1) {
            // y-   x cross z
            double y = insideBox.y_lo;
            p1Coord = new VisPoint(insideBox.x_lo, y, insideBox.z_lo);
            p2Coord = new VisPoint(insideBox.x_hi, y, insideBox.z_lo);
            p3Coord = new VisPoint(insideBox.x_hi, y, insideBox.z_hi);
            p4Coord = new VisPoint(insideBox.x_lo, y, insideBox.z_hi);
        } else if (outsideJ == insideJ + 1) {
            // y+   z cross x
            double y = insideBox.y_hi;
            p1Coord = new VisPoint(insideBox.x_lo, y, insideBox.z_lo);
            p2Coord = new VisPoint(insideBox.x_lo, y, insideBox.z_hi);
            p3Coord = new VisPoint(insideBox.x_hi, y, insideBox.z_hi);
            p4Coord = new VisPoint(insideBox.x_hi, y, insideBox.z_lo);
        } else if (insideK == outsideK + 1) {
            // z-   y cross x
            double z = insideBox.z_lo;
            p1Coord = new VisPoint(insideBox.x_lo, insideBox.y_lo, z);
            p2Coord = new VisPoint(insideBox.x_lo, insideBox.y_hi, z);
            p3Coord = new VisPoint(insideBox.x_hi, insideBox.y_hi, z);
            p4Coord = new VisPoint(insideBox.x_hi, insideBox.y_lo, z);
        } else if (outsideK == insideK + 1) {
            // z+   x cross y
            double z = insideBox.z_hi;
            p1Coord = new VisPoint(insideBox.x_lo, insideBox.y_lo, z);
            p2Coord = new VisPoint(insideBox.x_hi, insideBox.y_lo, z);
            p3Coord = new VisPoint(insideBox.x_hi, insideBox.y_hi, z);
            p4Coord = new VisPoint(insideBox.x_lo, insideBox.y_hi, z);
        } else {
            throw new RuntimeException("inside/outside volume indices not reconciled in membraneElement " + membraneElement.getMembraneIndex() + " in domain " + domainName);
        }
        // 
        // make sure vertices are added to model without duplicates and get the assigned identifier.
        // 
        String p1Key = toStringKey(p1Coord);
        Integer i1 = pointDict.get(p1Key);
        if (i1 == null) {
            pointDict.put(p1Key, currPointIndex);
            i1 = currPointIndex;
            visMesh.addToPoints(p1Coord);
            currPointIndex++;
        }
        String p2Key = toStringKey(p2Coord);
        Integer i2 = pointDict.get(p2Key);
        if (i2 == null) {
            pointDict.put(p2Key, currPointIndex);
            i2 = currPointIndex;
            visMesh.addToPoints(p2Coord);
            currPointIndex++;
        }
        String p3Key = toStringKey(p3Coord);
        Integer i3 = pointDict.get(p3Key);
        if (i3 == null) {
            pointDict.put(p3Key, currPointIndex);
            i3 = currPointIndex;
            visMesh.addToPoints(p3Coord);
            currPointIndex++;
        }
        String p4Key = toStringKey(p4Coord);
        Integer i4 = pointDict.get(p4Key);
        if (i4 == null) {
            pointDict.put(p4Key, currPointIndex);
            i4 = currPointIndex;
            visMesh.addToPoints(p4Coord);
            currPointIndex++;
        }
        VisPolygon quad = new VisPolygon(Arrays.asList(new Integer[] { i1, i2, i3, i4 }));
        quad.setFiniteVolumeIndex(new FiniteVolumeIndex(membraneElement.getMembraneIndex(), cartesianMesh.getMembraneRegionIndex(membraneElement.getMembraneIndex())));
        // print('adding a cell at level '+str(currLevel.getLevel())+" from "+str(p1Coord)+" to "+str(p3Coord))
        visMesh.addToPolygons(quad);
    }
    return visMesh;
}

Example 2 with VisPolygon

use of org.vcell.vis.vismesh.thrift.VisPolygon in project vcell by virtualcell.

the class ComsolMeshReader method readElements.

private static void readElements(BufferedReader br, VisMesh visMesh, int numElements) throws IOException {
    String line = br.readLine();
    String tetrahedraTag = "% Elements (tetrahedra)";
    String trianglesTag = "% Elements (triangles)";
    if (line.trim().equals(trianglesTag)) {
        for (int i = 0; i < numElements; i++) {
            line = br.readLine();
            String[] tokens = line.split("\\ +");
            ArrayList<Integer> points = new ArrayList<Integer>();
            points.add(Integer.parseInt(tokens[0]) - 1);
            points.add(Integer.parseInt(tokens[1]) - 1);
            points.add(Integer.parseInt(tokens[2]) - 1);
            visMesh.addToPolygons(new VisPolygon(points));
        }
    } else if (line.trim().equals(tetrahedraTag)) {
        for (int i = 0; i < numElements; i++) {
            line = br.readLine();
            String[] tokens = line.split("\\ +");
            ArrayList<Integer> points = new ArrayList<Integer>();
            points.add(Integer.parseInt(tokens[0]) - 1);
            points.add(Integer.parseInt(tokens[1]) - 1);
            points.add(Integer.parseInt(tokens[2]) - 1);
            points.add(Integer.parseInt(tokens[3]) - 1);
            visMesh.addToTetrahedra(new VisTetrahedron(points));
        }
    } else {
        throw new RuntimeException("read " + line + "\nexpected " + tetrahedraTag + " or " + trianglesTag);
    }
}

Example 3 with VisPolygon

use of org.vcell.vis.vismesh.thrift.VisPolygon in project vcell by virtualcell.

the class ChomboMeshMapping method cropQuads.

private void cropQuads(VisMesh visMesh) {
    if (visMesh.getDimension() != 2) {
        throw new RuntimeException("expecting 2D mesh");
    }
    List<VisPolygon> polygons = visMesh.getPolygons();
    List<VisPoint> points = visMesh.getPoints();
    List<VisLine> lines = visMesh.getVisLines();
    for (VisPolygon polygon : polygons) {
        List<Integer> polygonPointIndices = polygon.getPointIndices();
        double fraction = polygon.getChomboVolumeIndex().getFraction();
        if (fraction < 1.0 && polygonPointIndices.size() == 4) {
            int p0 = polygonPointIndices.get(0);
            int p1 = polygonPointIndices.get(1);
            int p2 = polygonPointIndices.get(2);
            int p3 = polygonPointIndices.get(3);
            VisPoint point0 = points.get(p0);
            VisPoint point1 = points.get(p1);
            VisPoint point2 = points.get(p2);
            VisPoint point3 = points.get(p3);
            double p0x = point0.x;
            double p0y = point0.y;
            double p1x = point1.x;
            double p1y = point1.y;
            double p2x = point2.x;
            double p2y = point2.y;
            double p3x = point3.x;
            double p3y = point3.y;
            double pLowX = p0x;
            double pLowY = p0y;
            double pHiX = p2x;
            double pHiY = p2y;
            for (VisLine segment : lines) {
                VisPoint segpoint1 = points.get(segment.getP1());
                double s1x = segpoint1.x;
                double s1y = segpoint1.y;
                if (s1x <= pHiX && s1x >= pLowX && s1y <= pHiY && s1y >= pLowY) {
                    VisPoint segpoint2 = points.get(segment.getP2());
                    double s2x = segpoint2.x;
                    double s2y = segpoint2.y;
                    if (s2x <= pHiX && s2x >= pLowX && s2y <= pHiY && s2y >= pLowY) {
                        // 
                        if (p0x == s1x && p0y == s2y) {
                            if (fraction > 0.5) {
                                polygon.setPointIndices(Arrays.asList(new Integer[] { segment.getP2(), segment.getP1(), p1, p2, p3 }));
                            } else {
                                polygon.setPointIndices(Arrays.asList(new Integer[] { segment.getP2(), p0, segment.getP1() }));
                            }
                        } else if (p0x == s2x && p0y == s1y) {
                            if (fraction > 0.5) {
                                polygon.setPointIndices(Arrays.asList(new Integer[] { segment.getP1(), segment.getP2(), p1, p2, p3 }));
                            } else {
                                polygon.setPointIndices(Arrays.asList(new Integer[] { segment.getP1(), p0, segment.getP2() }));
                            }
                        // case 2) { (remove point one && replace with segment
                        // 
                        // 0      3                         0      3
                        // s1          =>  s1        or     s1
                        // 1  s2  2        1  s2               s2  2
                        // 
                        } else if (p1x == s1x && p1y == s2y) {
                            if (fraction > 0.5) {
                                polygon.setPointIndices(Arrays.asList(new Integer[] { p0, segment.getP1(), segment.getP2(), p2, p3 }));
                            } else {
                                polygon.setPointIndices(Arrays.asList(new Integer[] { segment.getP1(), p1, segment.getP2() }));
                            }
                        } else if (p1x == s2x && p1y == s1y) {
                            if (fraction > 0.5) {
                                polygon.setPointIndices(Arrays.asList(new Integer[] { p0, segment.getP2(), segment.getP1(), p2, p3 }));
                            } else {
                                polygon.setPointIndices(Arrays.asList(new Integer[] { segment.getP2(), p1, segment.getP1() }));
                            }
                        // case 3) { (remove point two && replace with segment
                        // 
                        // 0      3                           0      3
                        // s2   =>         s2   or            s2
                        // 1  s1  2           s1  2           1  s1
                        // 
                        } else if (p2x == s1x && p2y == s2y) {
                            if (fraction > 0.5) {
                                polygon.setPointIndices(Arrays.asList(new Integer[] { p0, p1, segment.getP2(), segment.getP1(), p3 }));
                            } else {
                                polygon.setPointIndices(Arrays.asList(new Integer[] { segment.getP2(), p2, segment.getP1() }));
                            }
                        } else if (p2x == s2x && p2y == s1y) {
                            if (fraction > 0.5) {
                                polygon.setPointIndices(Arrays.asList(new Integer[] { p0, p1, segment.getP1(), segment.getP2(), p3 }));
                            } else {
                                polygon.setPointIndices(Arrays.asList(new Integer[] { segment.getP1(), p2, segment.getP2() }));
                            }
                        // case 4) { (remove point three && replace with segment
                        // 
                        // 0  s2  3           s2  3           0  s2
                        // s1   =>         s1   or            s1
                        // 1      2                           1      2
                        // 
                        } else if (p3x == s1x && p3y == s2y) {
                            if (fraction > 0.5) {
                                polygon.setPointIndices(Arrays.asList(new Integer[] { p0, p1, p2, segment.getP1(), segment.getP2() }));
                            } else {
                                polygon.setPointIndices(Arrays.asList(new Integer[] { segment.getP1(), p3, segment.getP2() }));
                            }
                        } else if (p3x == s2x && p3y == s1y) {
                            if (fraction > 0.5) {
                                polygon.setPointIndices(Arrays.asList(new Integer[] { p0, p1, p2, segment.getP2(), segment.getP1() }));
                            } else {
                                polygon.setPointIndices(Arrays.asList(new Integer[] { segment.getP2(), p3, segment.getP1() }));
                            }
                        // case 5) { (remove points 0 && 1 verticle cut)
                        // 
                        // 0  s1  3        0  s1                 s1  3
                        // =>               or
                        // 1  s2  2        1  s2                 s2  2
                        // 
                        } else if (p0y == s1y && p1y == s2y) {
                            boolean bigleft = ((s1x - p0x) + (s2x - p0x) > p3x - p0x);
                            if ((fraction > 0.5 && bigleft) || (fraction <= 0.5 && !bigleft)) {
                                polygon.setPointIndices(Arrays.asList(new Integer[] { p0, p1, segment.getP2(), segment.getP1() }));
                            } else {
                                polygon.setPointIndices(Arrays.asList(new Integer[] { segment.getP1(), segment.getP2(), p2, p3 }));
                            }
                        } else if (p0y == s2y && p1y == s1y) {
                            boolean bigleft = ((s1x - p0x) + (s2x - p0x) > p3x - p0x);
                            if ((fraction > 0.5 && bigleft) || (fraction <= 0.5 && !bigleft)) {
                                polygon.setPointIndices(Arrays.asList(new Integer[] { p0, p1, segment.getP1(), segment.getP2() }));
                            } else {
                                polygon.setPointIndices(Arrays.asList(new Integer[] { segment.getP2(), segment.getP1(), p2, p3 }));
                            }
                        // case 6) { (remove points 0 && 1 horizontal cut)
                        // 
                        // 0      3        0      3
                        // s1     s2  =>   s1     s2   or     s1     s2
                        // 1      2                           1      2
                        // 
                        } else if (p0x == s1x && p3x == s2x) {
                            boolean bigtop = ((s1y - p0y) + (s2y - p0y) > p1y - p0y);
                            if ((fraction > 0.5 && bigtop) || (fraction <= 0.5 && !bigtop)) {
                                polygon.setPointIndices(Arrays.asList(new Integer[] { p0, segment.getP1(), segment.getP2(), p3 }));
                            } else {
                                polygon.setPointIndices(Arrays.asList(new Integer[] { segment.getP2(), segment.getP1(), p1, p2 }));
                            }
                        } else if (p0x == s2x && p3x == s1x) {
                            boolean bigtop = ((s1y - p0y) + (s2y - p0y) > p1y - p0y);
                            if ((fraction > 0.5 && bigtop) || (fraction <= 0.5 && !bigtop)) {
                                polygon.setPointIndices(Arrays.asList(new Integer[] { p0, segment.getP2(), segment.getP1(), p3 }));
                            } else {
                                polygon.setPointIndices(Arrays.asList(new Integer[] { segment.getP1(), segment.getP2(), p1, p2 }));
                            }
                        } else {
                            LG.warn("found the segment for this polygon, don't know how to crop this one yet");
                        }
                    }
                }
            }
        }
    }
}

Example 4 with VisPolygon

use of org.vcell.vis.vismesh.thrift.VisPolygon in project vcell by virtualcell.

the class ChomboMeshMapping method fromMeshData2D.

private VisMesh fromMeshData2D(ChomboMeshData chomboMeshData) {
    ChomboMesh chomboMesh = chomboMeshData.getMesh();
    ChomboLevel finestLevel = chomboMesh.getLevel(chomboMesh.getNumLevels() - 1);
    int finestAbsRefinement = finestLevel.getAbsoluteRefinement();
    ISize size = finestLevel.getSize();
    int numX = size.getX();
    int numY = size.getY();
    int numZ = size.getZ();
    int dimension = chomboMeshData.getMesh().getDimension();
    int z = 0;
    // invoke VisMesh() constructor
    VisMesh visMesh = new VisMesh(chomboMesh.getDimension(), toThrift(chomboMesh.getOrigin()), toThrift(chomboMesh.getExtent()));
    int currPointIndex = 0;
    HashMap<String, Integer> pointDict = new HashMap<String, Integer>();
    double originX = chomboMesh.getOrigin().x;
    double originY = chomboMesh.getOrigin().y;
    double originZ = chomboMesh.getOrigin().z;
    double extentX = chomboMesh.getExtent().x;
    double extentY = chomboMesh.getExtent().y;
    double extentZ = chomboMesh.getExtent().z;
    ChomboBoundaries chomboBoundaries = chomboMesh.getBoundaries();
    for (ChomboBoundaries.Point chomboPoint : chomboBoundaries.getPoints()) {
        double px = chomboPoint.x;
        double py = chomboPoint.y;
        double pz = z;
        px = (px - originX) * (numX) / extentX * 2 - 1;
        py = (py - originY) * (numY) / extentY * 2 - 1;
        pz = (pz - originZ) * (numZ) / extentZ * 2 - 1;
        if (dimension == 2) {
            pz = z;
        }
        VisPoint newVisPoint = new VisPoint(px, py, pz);
        String coordKey = toStringKey(newVisPoint);
        pointDict.put(coordKey, currPointIndex);
        visMesh.addToPoints(newVisPoint);
        visMesh.addToSurfacePoints(newVisPoint);
        currPointIndex += 1;
    }
    for (ChomboBoundaries.Segment segment : chomboBoundaries.getSegments()) {
        VisLine newVisLine = new VisLine(segment.getP1(), segment.getP2());
        newVisLine.setChomboSurfaceIndex(new ChomboSurfaceIndex(segment.getChomboIndex()));
        visMesh.addToVisLines(newVisLine);
    }
    for (int levelIndex = 0; levelIndex < chomboMesh.getNumLevels(); levelIndex++) {
        ChomboLevelData chomboLevelData = chomboMeshData.getLevelData(levelIndex);
        ChomboLevel currLevel = chomboMesh.getLevel(levelIndex);
        int currAbsRefinement = currLevel.getAbsoluteRefinement();
        Covering covering = currLevel.getCovering();
        int[] levelMap = covering.getLevelMap();
        int[] boxNumberMap = covering.getBoxNumberMap();
        int[] boxIndexMap = covering.getBoxIndexMap();
        int levelNumX = currLevel.getSize().getX();
        int levelNumY = currLevel.getSize().getY();
        for (int x = 0; x < levelNumX; x++) {
            for (int y = 0; y < levelNumY; y++) {
                int mapIndex = x + y * levelNumX;
                if (levelMap[mapIndex] == levelIndex) {
                    // 
                    // if fraction (volume fraction of element in box) is 0 ... then skip this element
                    // 
                    int boxNumber = boxNumberMap[mapIndex];
                    int boxIndex = boxIndexMap[mapIndex];
                    double fraction = chomboLevelData.getCellFraction(currLevel, boxNumber, boxIndex);
                    if (fraction > 0) {
                        // 
                        // add cell
                        // 
                        ChomboBox chomboBox = new ChomboBox(currLevel, x, x, y, y, z, z, dimension).getProjectedBox(currAbsRefinement, finestAbsRefinement);
                        double minX = 2 * chomboBox.getMinX() - 1;
                        double maxX = 2 * chomboBox.getMaxX() + 1;
                        double minY = 2 * chomboBox.getMinY() - 1;
                        double maxY = 2 * chomboBox.getMaxY() + 1;
                        // 
                        // counter clockwise points for a VisPolygon ... initially a quad ... then may be
                        // 
                        // minX,minY
                        // minX,maxY
                        // maxX,maxY
                        // maxX,minY
                        // 
                        VisPoint p1Coord = new VisPoint(minX, minY, z);
                        String p1Key = toStringKey(p1Coord);
                        Integer i1 = pointDict.get(p1Key);
                        if (i1 == null) {
                            pointDict.put(p1Key, currPointIndex);
                            i1 = currPointIndex;
                            visMesh.addToPoints(p1Coord);
                            currPointIndex++;
                        }
                        VisPoint p2Coord = new VisPoint(minX, maxY, z);
                        String p2Key = toStringKey(p2Coord);
                        Integer i2 = pointDict.get(p2Key);
                        if (i2 == null) {
                            pointDict.put(p2Key, currPointIndex);
                            i2 = currPointIndex;
                            visMesh.addToPoints(p2Coord);
                            currPointIndex++;
                        }
                        VisPoint p3Coord = new VisPoint(maxX, maxY, z);
                        String p3Key = toStringKey(p3Coord);
                        Integer i3 = pointDict.get(p3Key);
                        if (i3 == null) {
                            pointDict.put(p3Key, currPointIndex);
                            i3 = currPointIndex;
                            visMesh.addToPoints(p3Coord);
                            currPointIndex++;
                        }
                        VisPoint p4Coord = new VisPoint(maxX, minY, z);
                        String p4Key = toStringKey(p4Coord);
                        Integer i4 = pointDict.get(p4Key);
                        if (i4 == null) {
                            pointDict.put(p4Key, currPointIndex);
                            i4 = currPointIndex;
                            visMesh.addToPoints(p4Coord);
                            currPointIndex++;
                        }
                        VisPolygon quad = new VisPolygon(Arrays.asList(new Integer[] { i1, i2, i3, i4 }));
                        quad.setChomboVolumeIndex(new ChomboVolumeIndex(levelIndex, boxNumber, boxIndex, fraction));
                        // print('adding a cell at level '+str(currLevel.getLevel())+" from "+str(p1Coord)+" to "+str(p3Coord))
                        visMesh.addToPolygons(quad);
                    }
                }
            }
        }
    }
    cropQuads(visMesh);
    return visMesh;
}

Example 5 with VisPolygon

use of org.vcell.vis.vismesh.thrift.VisPolygon in project vcell by virtualcell.

the class CartesianMeshMapping method fromMesh2DVolume.

private VisMesh fromMesh2DVolume(CartesianMesh cartesianMesh, String domainName) {
    ISize size = cartesianMesh.getSize();
    int numX = size.getX();
    int numY = size.getY();
    int numZ = size.getZ();
    int dimension = 2;
    int z = 0;
    Vect3D origin = new Vect3D(cartesianMesh.getOrigin().x, cartesianMesh.getOrigin().y, cartesianMesh.getOrigin().z);
    Vect3D extent = new Vect3D(cartesianMesh.getExtent().x, cartesianMesh.getExtent().y, cartesianMesh.getExtent().z);
    // invoke VisMesh() constructor
    VisMesh visMesh = new VisMesh(dimension, origin, extent);
    int currPointIndex = 0;
    HashMap<String, Integer> pointDict = new HashMap<String, Integer>();
    List<Integer> volumeRegionIDs = cartesianMesh.getVolumeRegionIDs(domainName);
    int volumeIndex = 0;
    for (int k = 0; k < numZ; k++) {
        for (int j = 0; j < numY; j++) {
            for (int i = 0; i < numX; i++) {
                int regionIndex = cartesianMesh.getVolumeRegionIndex(volumeIndex);
                if (volumeRegionIDs.contains(regionIndex)) {
                    Box3D element = cartesianMesh.getVolumeElementBox(i, j, k);
                    double minX = element.x_lo;
                    double maxX = element.x_hi;
                    double minY = element.y_lo;
                    double maxY = element.y_hi;
                    // 
                    // counter clockwise points for a VisPolygon ... initially a quad ... then may be
                    // 
                    // minX,minY
                    // minX,maxY
                    // maxX,maxY
                    // maxX,minY
                    // 
                    VisPoint p1Coord = new VisPoint(minX, minY, z);
                    String p1Key = toStringKey(p1Coord);
                    Integer i1 = pointDict.get(p1Key);
                    if (i1 == null) {
                        pointDict.put(p1Key, currPointIndex);
                        i1 = currPointIndex;
                        visMesh.addToPoints(p1Coord);
                        currPointIndex++;
                    }
                    VisPoint p2Coord = new VisPoint(minX, maxY, z);
                    String p2Key = toStringKey(p2Coord);
                    Integer i2 = pointDict.get(p2Key);
                    if (i2 == null) {
                        pointDict.put(p2Key, currPointIndex);
                        i2 = currPointIndex;
                        visMesh.addToPoints(p2Coord);
                        currPointIndex++;
                    }
                    VisPoint p3Coord = new VisPoint(maxX, maxY, z);
                    String p3Key = toStringKey(p3Coord);
                    Integer i3 = pointDict.get(p3Key);
                    if (i3 == null) {
                        pointDict.put(p3Key, currPointIndex);
                        i3 = currPointIndex;
                        visMesh.addToPoints(p3Coord);
                        currPointIndex++;
                    }
                    VisPoint p4Coord = new VisPoint(maxX, minY, z);
                    String p4Key = toStringKey(p4Coord);
                    Integer i4 = pointDict.get(p4Key);
                    if (i4 == null) {
                        pointDict.put(p4Key, currPointIndex);
                        i4 = currPointIndex;
                        visMesh.addToPoints(p4Coord);
                        currPointIndex++;
                    }
                    VisPolygon quad = new VisPolygon(Arrays.asList(new Integer[] { i1, i2, i3, i4 }));
                    quad.setFiniteVolumeIndex(new FiniteVolumeIndex(volumeIndex, cartesianMesh.getVolumeRegionIndex(volumeIndex)));
                    // print('adding a cell at level '+str(currLevel.getLevel())+" from "+str(p1Coord)+" to "+str(p3Coord))
                    visMesh.addToPolygons(quad);
                }
                // end if
                volumeIndex++;
            }
        // end i
        }
    // end j
    }
    return visMesh;
}