Example #1
0
 def test_intersect_type_4(self):
     #bawah:
     RDD = 6
     self.eg.compute_boundary()
     ll_c, tr_c = self.eg.get_data_boundary_utm(20, 20)
     ll_a = (745266.8882878901, 9278874.129457876)
     tr_a = (746372.3882730848, 9279980.235621063)
     ll_b = (745266.8882878901, 9278874.129457876)
     tr_b = (746372.3882730848, 9279980.235621063)
     ctl = round((9279980.235621063 - 9278874.129457876) *
                 (746372.3882730848 - 745266.8882878901), RDD)
     ret = data_downscaler.intersect(ll_a, tr_a, ll_b, tr_b)
     ret_c = data_downscaler.intersect(ll_c, tr_c, ll_c, tr_c)
     #        dat = (1105.499985194703, 1106.1061631874181, 1222800.3470274603)
     dat = (self.eg.dx, self.eg.dy, self.eg.cell_area)
     self.assertAlmostEqual(ret_c, dat[2])
     #        self.assertAlmostEqual(ret, dat[2])
     #        self.assertAlmostEqual(ret, dat[0] * dat[1])
     self.assertAlmostEqual(tr_c[0] - ll_c[0], dat[0])
     self.assertAlmostEqual(
         round((tr_c[0] - ll_c[0]) * (tr_c[1] - ll_c[1]), RDD),
         round((dat[0] * dat[1]), RDD))
     self.assertAlmostEqual(ret_c, round(dat[0] * dat[1], RDD))
     self.assertAlmostEqual(746372.3882730848 - 745266.8882878901, dat[0])
     self.assertAlmostEqual(9279980.235621063 - 9278874.129457876, dat[1])
     self.assertAlmostEqual(tr_c[0] - ll_c[0], dat[0])
     self.assertAlmostEqual(tr_c[1] - ll_c[1], dat[1])
     self.assertAlmostEqual(ret, ctl)
    def test_intersect_type_4(self):
        #bawah:
        RDD = 6
        self.eg.compute_boundary()
        ll_c, tr_c = self.eg.get_data_boundary_utm(20, 20)
        ll_a = (745266.8882878901, 9278874.129457876)
        tr_a = (746372.3882730848, 9279980.235621063)
        ll_b = (745266.8882878901, 9278874.129457876)
        tr_b = (746372.3882730848, 9279980.235621063)
        ctl = round( (9279980.235621063 - 9278874.129457876) * (746372.3882730848 - 745266.8882878901), RDD)
        ret = data_downscaler.intersect(ll_a, tr_a, ll_b, tr_b)
        ret_c = data_downscaler.intersect(ll_c, tr_c, ll_c, tr_c)
#        dat = (1105.499985194703, 1106.1061631874181, 1222800.3470274603)
        dat = (self.eg.dx, self.eg.dy, self.eg.cell_area)
        self.assertAlmostEqual(ret_c, dat[2])
#        self.assertAlmostEqual(ret, dat[2])
#        self.assertAlmostEqual(ret, dat[0] * dat[1])
        self.assertAlmostEqual(tr_c[0] - ll_c[0], dat[0])
        self.assertAlmostEqual(round( (tr_c[0] - ll_c[0]) * (tr_c[1] - ll_c[1]), RDD) , round( ( dat[0] * dat[1] ), RDD))
        self.assertAlmostEqual(ret_c, round( dat[0] * dat[1], RDD))
        self.assertAlmostEqual(746372.3882730848 - 745266.8882878901, dat[0])
        self.assertAlmostEqual(9279980.235621063 - 9278874.129457876, dat[1])
        self.assertAlmostEqual(tr_c[0] - ll_c[0], dat[0])
        self.assertAlmostEqual(tr_c[1] - ll_c[1], dat[1])
        self.assertAlmostEqual(ret, ctl)
Example #3
0
    def test_intersect_area(self):
        ll_a = (0.0, 0.0)
        tr_a = (10.0, 10.0)
        ll_b = (5.0, 0.0)
        tr_b = (10.0, 10.0)
        ret = data_downscaler.intersect(ll_a, tr_a, ll_b, tr_b)
        self.assertAlmostEqual(ret, float(5 * 10))

        ll_a = (0.0, 0.0)
        tr_a = (10.0, 10.0)
        ll_b = (15.0, 0.0)
        tr_b = (20.0, 10.0)
        ret = data_downscaler.intersect(ll_a, tr_a, ll_b, tr_b)
        self.assertAlmostEqual(ret, 0)

        ll_a = (0.0, 0.0)
        tr_a = (10.0, 10.0)
        ll_b = (3.0, 3.0)
        tr_b = (6.0, 6.0)
        ret = data_downscaler.intersect(ll_a, tr_a, ll_b, tr_b)
        self.assertAlmostEqual(ret, 3 * 3)

        #type 3
        ll_a = (0.0, 0.0)
        tr_a = (10.0, 10.0)
        ll_b = (5.0, 5.0)
        tr_b = (15.0, 15.0)
        ret = data_downscaler.intersect(ll_a, tr_a, ll_b, tr_b)
        self.assertAlmostEqual(ret, 5 * 5)

        #type 4
        #        ll_a = (0.0, 0.0)
        #        tr_a = (10.0, 10.0)
        #        ll_b = (5.0, 3.0)
        #        tr_b = (15.0, 6.0)
        #        ll_a = (0.0, 0.0)
        #        tr_a = (10.0, 10.0)
        #        ll_b = (3.0, 5.0)
        #        tr_b = (6.0, 15.0)

        #        ll_b = (0.0, 0.0)
        #        tr_b = (10.0, 10.0)
        #        ll_a = (5.0, 3.0)
        #        tr_a = (15.0, 6.0)
        ll_b = (0.0, 0.0)
        tr_b = (10.0, 10.0)
        ll_a = (3.0, 5.0)
        tr_a = (6.0, 15.0)
        ret = data_downscaler.intersect(ll_a, tr_a, ll_b, tr_b)
        self.assertAlmostEqual(ret, 5 * 3)

        #type 5
        ll_b = (0.0, 3.0)
        tr_b = (10.0, 6.0)
        ll_a = (3.0, 0.0)
        tr_a = (6.0, 10.0)
        ret = data_downscaler.intersect(ll_a, tr_a, ll_b, tr_b)
        self.assertAlmostEqual(ret, 3 * 3)
    def test_intersect_area(self):
        ll_a = (0.0, 0.0)
        tr_a = (10.0, 10.0)
        ll_b = (5.0, 0.0)
        tr_b = (10.0, 10.0)
        ret = data_downscaler.intersect(ll_a, tr_a, ll_b, tr_b)
        self.assertAlmostEqual(ret, float(5 * 10))
        
        ll_a = (0.0, 0.0)
        tr_a = (10.0, 10.0)
        ll_b = (15.0, 0.0)
        tr_b = (20.0, 10.0)
        ret = data_downscaler.intersect(ll_a, tr_a, ll_b, tr_b)
        self.assertAlmostEqual(ret, 0)
        
        ll_a = (0.0, 0.0)
        tr_a = (10.0, 10.0)
        ll_b = (3.0, 3.0)
        tr_b = (6.0, 6.0)
        ret = data_downscaler.intersect(ll_a, tr_a, ll_b, tr_b)
        self.assertAlmostEqual(ret, 3 * 3)
        
        #type 3
        ll_a = (0.0, 0.0)
        tr_a = (10.0, 10.0)
        ll_b = (5.0, 5.0)
        tr_b = (15.0, 15.0)
        ret = data_downscaler.intersect(ll_a, tr_a, ll_b, tr_b)
        self.assertAlmostEqual(ret, 5 * 5)
        
        #type 4
#        ll_a = (0.0, 0.0)
#        tr_a = (10.0, 10.0)
#        ll_b = (5.0, 3.0)
#        tr_b = (15.0, 6.0)
#        ll_a = (0.0, 0.0)
#        tr_a = (10.0, 10.0)
#        ll_b = (3.0, 5.0)
#        tr_b = (6.0, 15.0)

#        ll_b = (0.0, 0.0)
#        tr_b = (10.0, 10.0)
#        ll_a = (5.0, 3.0)
#        tr_a = (15.0, 6.0)
        ll_b = (0.0, 0.0)
        tr_b = (10.0, 10.0)
        ll_a = (3.0, 5.0)
        tr_a = (6.0, 15.0)
        ret = data_downscaler.intersect(ll_a, tr_a, ll_b, tr_b)
        self.assertAlmostEqual(ret, 5 * 3)
        
        #type 5
        ll_b = (0.0, 3.0)
        tr_b = (10.0, 6.0)
        ll_a = (3.0, 0.0)
        tr_a = (6.0, 10.0)
        ret = data_downscaler.intersect(ll_a, tr_a, ll_b, tr_b)
        self.assertAlmostEqual(ret, 3 * 3)