oxigeo-node 0.2.1

Node.js bindings for OxiGeo - Pure Rust geospatial data abstraction library
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153

/**
 * Algorithm tests
 */

const oxigeo = require('../');

describe('Algorithms', () => {
  test('resample', () => {
    const buffer = new oxigeo.BufferWrapper(100, 100, 'float32');
    buffer.fill(42.0);

    const resampled = oxigeo.resample(
      buffer,
      50,
      50,
      oxigeo.ResamplingMethod.NearestNeighbor
    );

    expect(resampled.width).toBe(50);
    expect(resampled.height).toBe(50);
    expect(resampled.getPixel(0, 0)).toBeCloseTo(42.0, 1);
  });

  test('hillshade', () => {
    const dem = new oxigeo.BufferWrapper(50, 50, 'float32');

    // Create simple slope
    for (let y = 0; y < 50; y++) {
      for (let x = 0; x < 50; x++) {
        dem.setPixel(x, y, x * 2 + y * 2);
      }
    }

    const hillshade = oxigeo.hillshade(dem, 315, 45, 1.0, 1.0);
    expect(hillshade.width).toBe(50);
    expect(hillshade.height).toBe(50);
    expect(hillshade.dataType).toBe('uint8');

    const stats = hillshade.statistics();
    expect(stats.min).toBeGreaterThanOrEqual(0);
    expect(stats.max).toBeLessThanOrEqual(255);
  });

  test('slope', () => {
    const dem = new oxigeo.BufferWrapper(50, 50, 'float32');

    // Create simple slope
    for (let y = 0; y < 50; y++) {
      for (let x = 0; x < 50; x++) {
        dem.setPixel(x, y, y * 10);
      }
    }

    const slope = oxigeo.slope(dem, 1.0, 1.0, false);
    expect(slope.width).toBe(50);
    expect(slope.height).toBe(50);
    expect(slope.dataType).toBe('float32');

    // Slope should be relatively uniform for this simple case
    const stats = slope.statistics();
    expect(stats.mean).toBeGreaterThan(0);
  });

  test('aspect', () => {
    const dem = new oxigeo.BufferWrapper(50, 50, 'float32');

    // Create slope in one direction
    for (let y = 0; y < 50; y++) {
      for (let x = 0; x < 50; x++) {
        dem.setPixel(x, y, x * 10);
      }
    }

    const aspect = oxigeo.aspect(dem, 1.0);
    expect(aspect.width).toBe(50);
    expect(aspect.height).toBe(50);

    // Aspect should indicate east-facing slope
    const stats = aspect.statistics();
    expect(stats.min).toBeGreaterThanOrEqual(-1);
    expect(stats.max).toBeLessThanOrEqual(360);
  });

  test('zonal statistics', () => {
    const raster = new oxigeo.BufferWrapper(10, 10, 'float32');
    const zones = new oxigeo.BufferWrapper(10, 10, 'int32');

    // Create two zones with different values
    for (let y = 0; y < 10; y++) {
      for (let x = 0; x < 10; x++) {
        if (x < 5) {
          zones.setPixel(x, y, 1);
          raster.setPixel(x, y, 10);
        } else {
          zones.setPixel(x, y, 2);
          raster.setPixel(x, y, 20);
        }
      }
    }

    const stats = oxigeo.zonalStats(raster, zones);
    expect(stats).toHaveLength(2);

    const zone1 = stats.find(s => s.zoneId === 1);
    const zone2 = stats.find(s => s.zoneId === 2);

    expect(zone1).toBeDefined();
    expect(zone2).toBeDefined();
    expect(zone1.mean).toBeCloseTo(10, 1);
    expect(zone2.mean).toBeCloseTo(20, 1);
    expect(zone1.count).toBe(50);
    expect(zone2.count).toBe(50);
  });
});

describe('Vector Algorithms', () => {
  test('buffer point', () => {
    const point = oxigeo.GeometryWrapper.point(0, 0);
    const buffered = oxigeo.buffer(point, 1.0, 16);

    expect(buffered.geometryType).toBe('Polygon');
  });

  test('area calculation', () => {
    // Create a simple square polygon
    const coords = [
      [
        [0, 0],
        [1, 0],
        [1, 1],
        [0, 1],
        [0, 0]
      ]
    ];
    const polygon = oxigeo.GeometryWrapper.polygon(coords);
    const area = oxigeo.area(polygon, 'planar');

    expect(area).toBeCloseTo(1.0, 2);
  });

  test('simplify linestring', () => {
    const coords = [
      [0, 0],
      [0.1, 0.05],
      [0.2, 0.1],
      [1, 0]
    ];
    const linestring = oxigeo.GeometryWrapper.linestring(coords);
    const simplified = oxigeo.simplify(linestring, 0.1, 'douglas-peucker');

    expect(simplified.geometryType).toBe('LineString');
  });
});