go-3dtile/quantization.go at master · flywave/go-3dtile · GitHub

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
package tile3d

import (
	"math"

	"github.com/flywave/go3d/vec3"
)

const rangeScale16 = 0xffff
const rangeScale8 = 0xff

func computeScale(extent float32, rangeScale uint16) float32 {
	if extent == 0 {
		return 1
	}
	return extent
}

func isInRange(qpos uint16, rangeScale uint16) bool {
	return qpos <= rangeScale
}

func Quantize(pos float64, origin float32, scale float32, rangeScale uint16) uint16 {
	return uint16(math.Floor(math.Max(0.0, math.Min(float64(rangeScale), (pos-float64(origin))*float64(float32(rangeScale)/scale)))))
}

func IsQuantizable(pos float64, origin float32, scale float32, rangeScale uint16) bool {
	return isInRange(Quantize(pos, origin, scale, rangeScale), rangeScale16)
}

func UnQuantize(qpos uint16, origin float32, scale float32, rangeScale uint16) float64 {
	return float64(origin) + float64(qpos)*float64(scale)/float64(rangeScale)
}

func IsQuantized(qpos uint16) bool {
	return isInRange(qpos, rangeScale16) && qpos == uint16(math.Floor(float64(qpos)))
}

type QParams3d struct {
	Origin [3]float32
	Scale  [3]float32
}

func (p *QParams3d) SetFromRange(range_ *vec3.Box, rangeScale uint16) {
	p.Origin[0] = range_.Min[0]
	p.Origin[1] = range_.Min[1]
	p.Origin[2] = range_.Min[2]

	p.Scale[0] = computeScale(range_.Max[0]-range_.Min[0], rangeScale)
	p.Scale[1] = computeScale(range_.Max[1]-range_.Min[1], rangeScale)
	p.Scale[2] = computeScale(range_.Max[2]-range_.Min[2], rangeScale)
}

func (p *QParams3d) rangeDiagonal() [3]float32 {
	var x float32
	var y float32
	var z float32

	if p.Scale[0] == 0 {
		x = 0
	} else {
		x = rangeScale16 / p.Scale[0]
	}

	if p.Scale[1] == 0 {
		y = 0
	} else {
		y = rangeScale16 / p.Scale[1]
	}

	if p.Scale[2] == 0 {
		z = 0
	} else {
		z = rangeScale16 / p.Scale[2]
	}

	return [3]float32{x, y, z}
}

func QuantizePoint3d(pos [3]float64, params *QParams3d) [3]uint16 {
	var out [3]uint16
	out[0] = Quantize(pos[0], params.Origin[0], params.Scale[0], rangeScale16)
	out[1] = Quantize(pos[1], params.Origin[1], params.Scale[1], rangeScale16)
	out[2] = Quantize(pos[2], params.Origin[2], params.Scale[2], rangeScale16)
	return out
}

func UnQuantizePoint3d(qpos [3]uint16, params *QParams3d) [3]float64 {
	var out [3]float64
	out[0] = UnQuantize(qpos[0], params.Origin[0], params.Scale[0], rangeScale16)
	out[1] = UnQuantize(qpos[1], params.Origin[1], params.Scale[1], rangeScale16)
	out[2] = UnQuantize(qpos[2], params.Origin[2], params.Scale[2], rangeScale16)
	return out
}