Region.java

Go to the documentation of this file.

/*******************************************************************************
 * Copyright (c) 2014 Andrei Stoica. All rights reserved. This program and the accompanying
 * materials are made available under the terms of the GNU Public License v3.0 which accompanies
 * this distribution, and is available at http://www.gnu.org/licenses/gpl.html
 * 
 * Contributors: Andrei Stoica - initial API and implementation during Google Summer of Code 2014
 ******************************************************************************/

package edu.tum.cs.vis.model.util;

import java.awt.Color;
import java.util.ArrayList;
import java.util.List;

public class Region {

        private final int                               id;

        private float                                   area;

        private final float[]                   curvatureMinMax         = new float[3];

        private final List<Triangle>    triangles                       = new ArrayList<Triangle>();

        private final List<Triangle>    boundaryTriangles       = new ArrayList<Triangle>();

        private final List<Region>              regionNeighbors         = new ArrayList<Region>();

        private final List<Edge>                edgeBoundary            = new ArrayList<Edge>();

        private float                                   perimeter;

        private Appearance                              appearance                      = new Appearance();

        public Region(final int newId) {
                this.id = newId;
                this.initializeApperance();
                this.area = 0.0f;
                this.perimeter = 0.0f;
                this.curvatureMinMax[0] = this.curvatureMinMax[1] = this.curvatureMinMax[2] = 0.0f;
        }

        public Region(final int newId, final Triangle initSeedTr) {
                this.id = newId;
                this.initializeApperance();
                this.area = 0.0f;
                this.perimeter = 0.0f;
                this.addTriangleToRegion(initSeedTr);
                this.curvatureMinMax[0] = initSeedTr.getCurvatureValues()[0];
                this.curvatureMinMax[1] = initSeedTr.getCurvatureValues()[1];
                this.curvatureMinMax[2] = initSeedTr.getCurvatureValues()[2];
        }

        public int getRegionId() {
                return this.id;
        }

        public float getAreaOfRegion() {
                return this.area;
        }

        public Appearance getAppearance() {
                return this.appearance;
        }

        public float getPerimeterOfRegion() {
                return this.perimeter;
        }

        public List<Triangle> getTriangles() {
                return this.triangles;
        }

        public List<Triangle> getBoundaryTriangles() {
                return this.boundaryTriangles;
        }

        public List<Region> getNeighbors() {
                return this.regionNeighbors;
        }

        public List<Edge> getBoundaryEdges() {
                return this.edgeBoundary;
        }

        public float[] getCurvatureMinMaxOfRegion() {
                return this.curvatureMinMax;
        }

        public List<Triangle> getOutsideBoundaryUnlabelled() {
                List<Triangle> unlabelledOutside = new ArrayList<Triangle>();
                for (int i = 0; i < boundaryTriangles.size(); ++i) {
                        Triangle t = boundaryTriangles.get(i);
                        for (Triangle n : t.getNeighbors()) {
                                if (n.getRegionLabel() == -1) {
                                        unlabelledOutside.add(n);
                                }
                        }
                }
                return unlabelledOutside;
        }

        public List<Edge> getCommonEdges(Region neighbor) {
                List<Edge> commonEdges = new ArrayList<Edge>();
                for (Edge e : this.edgeBoundary) {
                        for (Edge en : neighbor.edgeBoundary) {
                                if (e.isDirectNeighbor(en)) {
                                        commonEdges.add(e);
                                        break;
                                }
                        }
                }
                return commonEdges;
        }

        public Edge getCommonEdge(Triangle triangle) {
                if (!boundaryTriangles.contains(triangle)) {
                        for (Triangle n : boundaryTriangles) {
                                // Edge edge = triangle.getCommonEdge(n);
                                Edge edge = n.getCommonEdge(triangle);
                                if (edge != null) {
                                        return edge;
                                }
                        }
                }
                return null;
        }

        public void setApperance(final Appearance newAppearance) {
                this.appearance = newAppearance;
        }

        public void setCurvatureMin(final float kMin) {
                this.curvatureMinMax[0] = kMin;
        }

        public void setCurvatureMax(final float kMax) {
                this.curvatureMinMax[1] = kMax;
        }

        public void setCurvatureMinMax(final float kMinkMax) {
                this.curvatureMinMax[2] = kMinkMax;
        }

        public boolean isNeighbor(Region region) {
                if (regionNeighbors.contains(region)) {
                        return true;
                }
                return false;
        }

        public void initializeApperance() {
                int R, G, B, min = 0, max = 255;
                R = min + (int) (Math.random() * ((max - min) + 1));
                G = min + (int) (Math.random() * ((max - min) + 1));
                B = min + (int) (Math.random() * ((max - min) + 1));
                Color regionColor = new Color(R, G, B);
                this.appearance.setColorFill(regionColor);
        }

        public void updateAreaOfRegion() {
                area = 0.0f;
                for (Triangle tr : triangles) {
                        area += tr.getArea();
                }
        }

        private void updateAreaOfRegion(final Triangle tr, final boolean toRemove) {
                if (tr != null) {
                        if (toRemove == false) {
                                area += tr.getArea();
                        } else {
                                area -= tr.getArea();
                        }
                }
        }

        public void updatePerimeterOfRegion() {
                perimeter = 0.0f;
                for (Edge e : edgeBoundary) {
                        perimeter += e.getEdgeValue().length();
                }
        }

        public void addTrianglesToRegion(final List<Triangle> newTr) {
                if (newTr != null) {
                        for (int i = 0; i < newTr.size(); ++i) {
                                if (newTr.get(i) != null) {
                                        Triangle triangle = newTr.get(i);
                                        if (!triangles.contains(triangle)) {
                                                triangles.add(triangle);
                                                triangle.setRegionLabel(id);
                                                triangle.appearance = this.appearance;
                                                this.updateAreaOfRegion(triangle, false);
                                        }
                                }
                        }
                }
        }

        public void addTriangleToRegion(final Triangle newTr) {
                if (newTr != null && !triangles.contains(newTr) && newTr.getRegionLabel() == -1) {
                        triangles.add(newTr);
                        newTr.setRegionLabel(id);
                        newTr.appearance = this.appearance;
                        this.updateAreaOfRegion(newTr, false);
                        this.addTriangleToRegionBoundary(newTr);
                }
        }

        public void addTriangleToRegionBoundary(final Triangle newTr) {
                if (!triangles.containsAll(newTr.getNeighbors())) {
                        // add current Triangle object located on boundary
                        boundaryTriangles.add(newTr);
                } else {
                        // check if newTr is a "margin" triangle
                        for (Edge e : newTr.getEdges()) {
                                List<Triangle> neighborsOfEdge = newTr.getNeighborsOfEdge(e);
                                if (neighborsOfEdge.size() == 0) {
                                        boundaryTriangles.add(newTr);
                                }
                        }
                }
                List<Triangle> toRemove = new ArrayList<Triangle>();
                // make sure neighboring triangles are not on the region boundary given the new added
                // triangle
                for (Triangle tr : newTr.getNeighbors()) {
                        // a margin triangle is one that does not have neighbors for an edge
                        boolean marginTriangle = false;
                        for (Edge tre : tr.getEdges()) {
                                List<Triangle> neighborsOfEdge = tr.getNeighborsOfEdge(tre);
                                if (neighborsOfEdge.size() == 0) {
                                        marginTriangle = true;
                                }
                        }
                        // if the neighboring triangle has all its neighbors in the region and is not a
                        // margin triangle then it is not on the boundary
                        if (triangles.containsAll(tr.getNeighbors()) && !marginTriangle) {
                                toRemove.add(tr);
                        }
                }
                // remove triangles that are not on the boundary anymore
                boundaryTriangles.removeAll(toRemove);
                return;
        }

        public void removeTriangleFromRegion(final Triangle toRemove) {
                if (triangles.remove(toRemove)) {
                        updateAreaOfRegion(toRemove, true);
                        if (boundaryTriangles.remove(toRemove)) {
                                System.out.println("Triangle " + toRemove.toString()
                                                + " also removed from the boundary region");
                                this.updateRegionBoundary();
                        }
                }
                // unset region label
                toRemove.setRegionLabel(-1);
        }

        public void updateRegionBoundary() {
                boundaryTriangles.clear();
                for (Triangle tr : triangles) {
                        for (Edge e : tr.getEdges()) {
                                List<Triangle> neighborsOfEdge = tr.getNeighborsOfEdge(e);
                                if (neighborsOfEdge.size() == 0) {
                                        boundaryTriangles.add(tr);
                                } else {
                                        for (int i = 0; i < neighborsOfEdge.size(); ++i) {
                                                if (triangles.contains(neighborsOfEdge.get(i))) {
                                                        boundaryTriangles.add(tr);
                                                        break;
                                                }
                                        }
                                }
                        }
                }
        }

        public void updateRegionNeighbors(List<Region> allRegions) {
                regionNeighbors.clear();
                edgeBoundary.clear();
                for (Triangle t : boundaryTriangles) {
                        // if no neighboring triangles, just add the edge to boundary
                        for (Edge e : t.getEdges()) {
                                List<Triangle> neighborsOfEdge = t.getNeighborsOfEdge(e);
                                if (neighborsOfEdge.size() != 0) {
                                        for (Triangle n : neighborsOfEdge) {
                                                if (n.getRegionLabel() != t.getRegionLabel()) {
                                                        for (int i = 0; i < allRegions.size(); ++i) {
                                                                if (allRegions.get(i).getRegionId() == n.getRegionLabel()
                                                                                && !regionNeighbors.contains(allRegions.get(i))) {
                                                                        regionNeighbors.add(allRegions.get(i));
                                                                }
                                                                if (!edgeBoundary.contains(e)) {
                                                                        edgeBoundary.add(e);
                                                                }
                                                        }
                                                }
                                        }
                                } else {
                                        if (!edgeBoundary.contains(e)) {
                                                edgeBoundary.add(e);
                                        }
                                }
                        }
                }
                updatePerimeterOfRegion();
        }

        public void buildUpRegion() {
                for (int i = 0; i < triangles.size(); ++i) {
                        Triangle tr = triangles.get(i);
                        // Edge[] nonSharpEdges = tr.getNonSharpEdges();
                        Edge[] edges = tr.getEdges();
                        for (int j = 0; j < edges.length; ++j) {
                                if (!edges[j].isSharpEdge()) {
                                        List<Triangle> neighborList = tr.getNeighborsOfEdge(edges[j]);
                                        if (neighborList.size() == 0) {
                                                // System.out.println(tr.getNeighbors().size());
                                                // System.out.println("null @: " + i + " " + j);
                                                continue;
                                        }
                                        for (Triangle neighbor : neighborList) {
                                                if (neighbor.getRegionLabel() != -1) {
                                                        // if already classified, then skip it
                                                        continue;
                                                }
                                                Vertex oppositeVertex = neighbor.getOppositeVertexFromEdge(edges[j]);
                                                if (oppositeVertex != null
                                                                && ((oppositeVertex.isSharpVertex()) || ((oppositeVertex
                                                                                .getClusterCurvatureVal()[0] == curvatureMinMax[0])
                                                                                && (oppositeVertex.getClusterCurvatureVal()[1] == curvatureMinMax[1]) && (oppositeVertex
                                                                                .getClusterCurvatureVal()[2] == curvatureMinMax[2])))) {
                                                        this.addTriangleToRegion(neighbor);
                                                }
                                        }
                                }
                        }
                }
        }

        /*
         * (non-Javadoc)
         * @see java.lang.Object#toString()
         */
        @Override
        public String toString() {
                String print = "Region ID " + id + "\n";
                print = print + "Curvatures: KMin = " + curvatureMinMax[0] + ", KMax = "
                                + curvatureMinMax[1] + ", KMinMax= " + curvatureMinMax[2] + "\n";
                print = print + "Triangles: " + triangles.size() + "\n";
                print = print + "Boundary Triangles: " + boundaryTriangles.size() + "\n";
                print = print + "Boundary Edges: " + edgeBoundary.size() + "\n";
                print = print + "Area: " + area + ", Perimeter: " + perimeter + "\n";
                return print;
        }
}