Revision 7b925f23
Added by Leszek Koltunski 29 days ago
| src/main/java/org/distorted/library/mesh/MeshMultigon.kt | ||
|---|---|---|
| 86 | 86 |
} |
| 87 | 87 |
|
| 88 | 88 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 89 |
private fun computeEdgeVectors(vertices: Array<Array<FloatArray>>, edgesUp: Array<IntArray?>)
|
|
| 89 |
private fun computeEdgeVectors(vertices: Array<Array<FloatArray>>, edgesUp: Array<IntArray>) |
|
| 90 | 90 |
{
|
| 91 | 91 |
val numPoly = vertices.size |
| 92 | 92 |
mEdgeVectors = arrayOfNulls(numPoly) |
| ... | ... | |
| 99 | 99 |
|
| 100 | 100 |
for (v in 0 until numV) |
| 101 | 101 |
{
|
| 102 |
val edgeUp = edgesUp[c]!![v]
|
|
| 102 |
val edgeUp = edgesUp[c][v] |
|
| 103 | 103 |
val xs = polygon[v][0] |
| 104 | 104 |
val ys = polygon[v][1] |
| 105 | 105 |
val n = if (v==numV-1) 0 else v+1 |
| ... | ... | |
| 201 | 201 |
|
| 202 | 202 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 203 | 203 |
private fun computeMode(vL: FloatArray, vR: FloatArray, vT: FloatArray, normL: FloatArray, normR: FloatArray, |
| 204 |
edgesUp: Array<IntArray?>, vertsUp: Array<BooleanArray?>, vertices: Array<Array<FloatArray>>, centers: Array<FloatArray?>, component: Int, curr: Int): Int |
|
| 204 |
edgesUp: Array<IntArray>, vertsUp: Array<BooleanArray?>, vertices: Array<Array<FloatArray>>, |
|
| 205 |
centers: Array<FloatArray?>, component: Int, curr: Int): Int |
|
| 205 | 206 |
{
|
| 206 | 207 |
val v = vertices[component] |
| 207 | 208 |
val edges = edgesUp[component] |
| 208 | 209 |
val numPoly = v.size |
| 209 | 210 |
val next = if (curr==numPoly-1) 0 else curr+1 |
| 210 | 211 |
val prev = if (curr==0) numPoly-1 else curr-1 |
| 211 |
val eupc = edges!![curr]
|
|
| 212 |
val eupc = edges[curr] |
|
| 212 | 213 |
|
| 213 | 214 |
if (eupc<0) |
| 214 | 215 |
{
|
| ... | ... | |
| 496 | 497 |
} |
| 497 | 498 |
|
| 498 | 499 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 499 |
private fun detectNextOuterVertex(vertices: Array<Array<FloatArray>>, curr: FloatArray, vect: FloatArray, edgesUp: Array<IntArray?>): FloatArray
|
|
| 500 |
private fun detectNextOuterVertex(vertices: Array<Array<FloatArray>>, curr: FloatArray, vect: FloatArray, edgesUp: Array<IntArray>): FloatArray |
|
| 500 | 501 |
{
|
| 501 | 502 |
var maxAngle = 0.0 |
| 502 | 503 |
var x = 0f |
| ... | ... | |
| 513 | 514 |
val xc = vert[v][0] |
| 514 | 515 |
val yc = vert[v][1] |
| 515 | 516 |
|
| 516 |
if (edgesUp[c]!![v]<0&&isSame(xc-curr[0], yc-curr[1]))
|
|
| 517 |
if (edgesUp[c][v]<0&&isSame(xc-curr[0], yc-curr[1])) |
|
| 517 | 518 |
{
|
| 518 | 519 |
val n = (if (v==numV-1) 0 else v+1) |
| 519 | 520 |
val xn = vert[n][0] |
| ... | ... | |
| 573 | 574 |
} |
| 574 | 575 |
|
| 575 | 576 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 576 |
private fun generateHole(vertices: Array<Array<FloatArray>>, unclaimedEdges: Array<IntArray?>, output: Array<FloatArray>, edgesUp: Array<IntArray?>, holeNumber: Int, numHoleVerts: Int): Int
|
|
| 577 |
private fun generateHole(vertices: Array<Array<FloatArray>>, unclaimedEdges: Array<IntArray?>, output: Array<FloatArray>, edgesUp: Array<IntArray>, holeNumber: Int, numHoleVerts: Int): Int |
|
| 577 | 578 |
{
|
| 578 | 579 |
var firstIndex = -1 |
| 579 | 580 |
|
| ... | ... | |
| 593 | 594 |
|
| 594 | 595 |
val p = unclaimedEdges[nextIndex]!![0] |
| 595 | 596 |
val v = unclaimedEdges[nextIndex]!![1] |
| 596 |
edgesUp[p]!![v] = -holeNumber-2
|
|
| 597 |
edgesUp[p][v] = -holeNumber-2 |
|
| 597 | 598 |
currIndex = nextIndex |
| 598 | 599 |
val e = unclaimedEdges[nextIndex] |
| 599 | 600 |
val ve = vertices[e!![0]][e[1]] |
| ... | ... | |
| 614 | 615 |
} |
| 615 | 616 |
|
| 616 | 617 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 617 |
private fun computeHoles(vertices: Array<Array<FloatArray>>, edgesUp: Array<IntArray?>, outer: Array<FloatArray>, numHoleVerts: Int): Array<Array<FloatArray?>>
|
|
| 618 |
private fun computeHoles(vertices: Array<Array<FloatArray>>, edgesUp: Array<IntArray>, outer: Array<FloatArray>, numHoleVerts: Int): Array<Array<FloatArray?>> |
|
| 618 | 619 |
{
|
| 619 | 620 |
val unclaimedEdges = arrayOfNulls<IntArray>(numHoleVerts) |
| 620 | 621 |
var index = 0 |
| ... | ... | |
| 625 | 626 |
val ve = vertices[p] |
| 626 | 627 |
val numEdges = ve.size |
| 627 | 628 |
|
| 628 |
for (e in 0 until numEdges) if (edgesUp[p]!![e]<0)
|
|
| 629 |
for (e in 0 until numEdges) if (edgesUp[p][e]<0) |
|
| 629 | 630 |
{
|
| 630 | 631 |
val x1 = ve[e][0] |
| 631 | 632 |
val y1 = ve[e][1] |
| ... | ... | |
| 639 | 640 |
// x x x |
| 640 | 641 |
// x o x |
| 641 | 642 |
// o x x |
| 642 |
if (doesNotBelongToOuter(x1, y1, outer)||doesNotBelongToOuter(x2, y2, outer))
|
|
| 643 |
if ( doesNotBelongToOuter(x1,y1,outer) || doesNotBelongToOuter(x2,y2,outer) )
|
|
| 643 | 644 |
{
|
| 644 | 645 |
unclaimedEdges[index] = intArrayOf(p, e, 1) |
| 645 | 646 |
index++ |
| ... | ... | |
| 668 | 669 |
holes.add(hole) |
| 669 | 670 |
} |
| 670 | 671 |
|
| 671 |
val ret: Array<Array<FloatArray?>> = arrayOfNulls(numHoles) |
|
| 672 |
for (h in 0 until numHoles) ret[h] = holes.removeAt(0) |
|
| 672 |
|
|
| 673 |
val ret = holes.toTypedArray() |
|
| 674 |
holes.clear() |
|
| 673 | 675 |
|
| 674 | 676 |
return ret |
| 675 | 677 |
} |
| ... | ... | |
| 687 | 689 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 688 | 690 |
// PUBLIC API |
| 689 | 691 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 690 |
fun computeEdgesUp(vertices: Array<Array<FloatArray>>): Array<IntArray?>
|
|
| 692 |
fun computeEdgesUp(vertices: Array<Array<FloatArray>>): Array<IntArray> |
|
| 691 | 693 |
{
|
| 692 | 694 |
val numPoly = vertices.size |
| 693 | 695 |
val up = arrayOfNulls<IntArray>(numPoly) |
| ... | ... | |
| 699 | 701 |
for (e in 0 until numEdges) up[p]!![e] = isUp(vertices, p, e) |
| 700 | 702 |
} |
| 701 | 703 |
|
| 702 |
return up |
|
| 704 |
return up.requireNoNulls()
|
|
| 703 | 705 |
} |
| 704 | 706 |
|
| 705 | 707 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 706 |
fun computeOuterAndHoleVertices(vertices: Array<Array<FloatArray>>, edgesUp: Array<IntArray?>): Array<Array<FloatArray>>
|
|
| 708 |
fun computeOuterAndHoleVertices(vertices: Array<Array<FloatArray>>, edgesUp: Array<IntArray>): Array<Array<FloatArray>> |
|
| 707 | 709 |
{
|
| 708 | 710 |
val tmp = ArrayList<FloatArray>() |
| 709 | 711 |
|
| ... | ... | |
| 722 | 724 |
while (!isSame(next[0]-first[0], next[1]-first[1])) |
| 723 | 725 |
|
| 724 | 726 |
val numOuterVerts = tmp.size |
| 725 |
val outerVertices = arrayOfNulls<FloatArray>(numOuterVerts)
|
|
| 726 |
for (i in 0 until numOuterVerts) outerVertices[i] = tmp.removeAt(0)
|
|
| 727 |
val outerVertices = tmp.toTypedArray()
|
|
| 728 |
tmp.clear()
|
|
| 727 | 729 |
|
| 728 | 730 |
val numEdgesDown = countEdgesDown(edgesUp) |
| 729 | 731 |
val numHoleVerts = numEdgesDown-numOuterVerts |
| 730 | 732 |
var holeVertices: Array<Array<FloatArray?>>? = null |
| 731 | 733 |
if (numHoleVerts>0) holeVertices = computeHoles(vertices, edgesUp, outerVertices, numHoleVerts) |
| 732 | 734 |
val numHoles = holeVertices?.size ?: 0 |
| 733 |
val ret: Array<Array<FloatArray?>> = arrayOfNulls(1+numHoles)
|
|
| 735 |
val ret: Array<Array<FloatArray>> = arrayOfNulls(1+numHoles) |
|
| 734 | 736 |
ret[0] = outerVertices |
| 735 | 737 |
for (i in 0 until numHoles) ret[i+1] = holeVertices!![i] |
| 736 | 738 |
|
Also available in: Unified diff
transition the 'mesh' package.