Project

General

Profile

« Previous | Next » 

Revision 7b925f23

Added by Leszek Koltunski 1 day ago

transition the 'mesh' package.

View differences:

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