Beispiel #1
0
void fastbitIndex(const char* datasetName, void* data, uint64_t blockSize, FastBitDataType ft, 
		  double**keys, uint64_t*nk, int64_t**offsets, uint64_t*no,		  
		  uint32_t**bms, uint64_t*nb)
{
  long int fastbitErr;

  fastbitErr = fastbit_iapi_register_array(datasetName, ft, data, blockSize);
  assertErr(fastbitErr, "failed to register array with", datasetName);
  
  fastbitErr = fastbit_iapi_build_index(datasetName, (const char*)gBinningOption);
  assertErr(fastbitErr, "failed to build idx with ", datasetName);
  
  
  fastbitErr = fastbit_iapi_deconstruct_index(datasetName, keys, nk, offsets, no, bms, nb);
  assertErr(fastbitErr, "failed with fastbit_iapi_deconstruct on ", datasetName);
  
  //printf("nk/no/nb %" PRId64 " %" PRId64 " %" PRId64 "\n", *nk, *no, *nb);
  
  fastbit_iapi_free_all();

  /*free(offsets);

  free(keys);

  free(bms);
  */
}
TEST_F(CheapRulerTest, along) {
    for (unsigned i = 0; i < lines.size(); ++i) {
        auto expected = turf_along[i];
        auto actual = ruler.along(lines[i], turf_along_dist[i]);

        assertErr(expected.x, actual.x, 1e-6); // along longitude
        assertErr(expected.y, actual.y, 1e-6); // along latitude
    }
}
TEST_F(CheapRulerTest, destination) {
    for (unsigned i = 0; i < points.size(); ++i) {
        auto bearing = (i % 360) - 180.;
        auto expected = turf_destination[i];
        auto actual = ruler.destination(points[i], 1.0, bearing);

        assertErr(expected.x, actual.x, 1e-6); // longitude
        assertErr(expected.y, actual.y, 1e-6); // latitude
    }
}
TEST_F(CheapRulerTest, bufferPoint) {
    for (unsigned i = 0; i < points.size(); ++i) {
        auto expected = turf_bufferPoint[i];
        auto actual = milesRuler.bufferPoint(points[i], 0.1);

        assertErr(expected.min.x, actual.min.x, 2e-7);
        assertErr(expected.min.x, actual.min.x, 2e-7);
        assertErr(expected.max.y, actual.max.y, 2e-7);
        assertErr(expected.max.y, actual.max.y, 2e-7);
    }
}
TEST_F(CheapRulerTest, lineDistance) {
    for (unsigned i = 0; i < lines.size(); ++i) {
        auto expected = turf_lineDistance[i];
        auto actual = ruler.lineDistance(lines[i]);

        assertErr(expected, actual, 0.003);
    }
}
TEST_F(CheapRulerTest, bearing) {
    for (unsigned i = 0; i < points.size() - 1; ++i) {
        auto expected = turf_bearing[i];
        auto actual = ruler.bearing(points[i], points[i + 1]);

        assertErr(expected, actual, .005);
    }
}
TEST_F(CheapRulerTest, distance) {
    for (unsigned i = 0; i < points.size() - 1; ++i) {
        auto expected = turf_distance[i];
        auto actual = ruler.distance(points[i], points[i + 1]);

        assertErr(expected, actual, .003);
    }
}
TEST_F(CheapRulerTest, fromTile) {
    auto ruler1 = cr::CheapRuler(50.5);
    auto ruler2 = cr::CheapRuler::fromTile(11041, 15);

    cr::point p1(30.5, 50.5);
    cr::point p2(30.51, 50.51);

    assertErr(ruler1.distance(p1, p2), ruler2.distance(p1, p2), 2e-5);
}
TEST_F(CheapRulerTest, lineSlice) {
    for (unsigned i = 0; i < lines.size(); ++i) {
        auto line = lines[i];
        auto dist = ruler.lineDistance(line);
        auto start = ruler.along(line, dist * 0.3);
        auto stop = ruler.along(line, dist * 0.7);
        auto expected = turf_lineSlice[i];
        auto actual = ruler.lineDistance(ruler.lineSlice(start, stop, line));

        assertErr(expected, actual, 1e-5);
    }
}
TEST_F(CheapRulerTest, lineSliceAlong) {
    for (unsigned i = 0; i < lines.size(); ++i) {
        if (i == 46) {
            // skip due to Turf bug https://github.com/Turfjs/turf/issues/351
            continue;
        };

        auto line = lines[i];
        auto dist = ruler.lineDistance(line);
        auto expected = turf_lineSlice[i];
        auto actual = ruler.lineDistance(ruler.lineSliceAlong(dist * 0.3, dist * 0.7, line));

        assertErr(expected, actual, 1e-5);
    }
}
TEST_F(CheapRulerTest, area) {
    for (unsigned i = 0, j = 0; i < lines.size(); ++i) {
        if (lines[i].size() < 3) {
            continue;
        }

        cr::linear_ring ring;
        for (auto point : lines[i]) {
            ring.push_back(point);
        }
        ring.push_back(lines[i][0]);

        auto expected = turf_area[j++];
        auto actual = ruler.area(cr::polygon{ ring });

        assertErr(expected, actual, 0.003);
    }
}
TEST_F(CheapRulerTest, distanceInMiles) {
    auto d = ruler.distance({ 30.5, 32.8351 }, { 30.51, 32.8451 });
    auto d2 = milesRuler.distance({ 30.5, 32.8351 }, { 30.51, 32.8451 });

    assertErr(d / d2, 1.609344, 1e-12);
}