| 1 | /** |
| 2 | * Depth encodings matching Paperdoll Renderer camera::DepthFormat. |
| 3 | * Canonical compositor sample is u16 gray + u16 alpha (0..65535). |
| 4 | */ |
| 5 | var DepthDecode = |
| 6 | { |
| 7 | EPSILON_U16: 1, |
| 8 | |
| 9 | parseFormat: function (encoding, bits) |
| 10 | { |
| 11 | var enc = encoding || "gray"; |
| 12 | var b = bits == null ? 16 : Number(bits); |
| 13 | if (b !== 8 && b !== 16) |
| 14 | { throw new Error("depth_bits moet 8 of 16 zijn, kreeg " + bits); } |
| 15 | if (enc !== "gray" && enc !== "rgb_bands" && enc !== "rgb_packed") |
| 16 | { throw new Error("depth_encoding onbekend: " + enc); } |
| 17 | return { encoding: enc, bits: b }; |
| 18 | }, |
| 19 | |
| 20 | max: function (fmt) |
| 21 | { return (1 << fmt.bits) - 1; }, |
| 22 | |
| 23 | levels: function (fmt) |
| 24 | { |
| 25 | var m = this.max(fmt); |
| 26 | if (fmt.encoding === "gray") |
| 27 | { return m; } |
| 28 | if (fmt.encoding === "rgb_bands") |
| 29 | { return 3 * m; } |
| 30 | return Math.pow(2, 3 * fmt.bits) - 1; |
| 31 | }, |
| 32 | |
| 33 | decodeValue: function (fmt, c0, c1, c2) |
| 34 | { |
| 35 | var m = this.max(fmt); |
| 36 | var b = m + 1; |
| 37 | var v; |
| 38 | if (fmt.encoding === "gray") |
| 39 | { v = c0; } |
| 40 | else if (fmt.encoding === "rgb_bands") |
| 41 | { v = c0 + c1 + c2; } |
| 42 | else |
| 43 | { v = c0 * b * b + c1 * b + c2; } |
| 44 | return v / this.levels(fmt); |
| 45 | }, |
| 46 | |
| 47 | encodeValue: function (fmt, t) |
| 48 | { |
| 49 | t = Math.max(0, Math.min(1, Number(t) || 0)); |
| 50 | var m = this.max(fmt); |
| 51 | var v = Math.round(t * this.levels(fmt)); |
| 52 | if (fmt.encoding === "gray") |
| 53 | { return [v, 0, 0]; } |
| 54 | if (fmt.encoding === "rgb_bands") |
| 55 | { |
| 56 | return [ |
| 57 | Math.min(v, m), |
| 58 | Math.min(Math.max(v - m, 0), m), |
| 59 | Math.min(Math.max(v - 2 * m, 0), m) |
| 60 | ]; |
| 61 | } |
| 62 | var b = m + 1; |
| 63 | return [Math.floor(v / (b * b)), Math.floor(v / b) % b, v % b]; |
| 64 | }, |
| 65 | |
| 66 | /** |
| 67 | * Decode one pixel channel tuple to canonical u16 (gray, alpha). |
| 68 | * channels: [c0,c1,c2,a] in native bit depth units. |
| 69 | */ |
| 70 | decodePixelChannels: function (fmt, channels) |
| 71 | { |
| 72 | var c0 = channels[0] || 0; |
| 73 | var c1 = channels[1] || 0; |
| 74 | var c2 = channels[2] || 0; |
| 75 | var a = channels[3] != null ? channels[3] : this.max(fmt); |
| 76 | if (fmt.encoding === "rgb_bands") |
| 77 | { |
| 78 | var m = this.max(fmt); |
| 79 | if ((c1 > 0 && c0 !== m) || (c2 > 0 && c1 !== m)) |
| 80 | { throw new Error("depth rgb_bands: ongeldige bandvolgorde"); } |
| 81 | } |
| 82 | var t = this.decodeValue(fmt, c0, c1, c2); |
| 83 | var scale = 65535 / this.max(fmt); |
| 84 | return { |
| 85 | gray: Math.round(t * 65535), |
| 86 | alpha: Math.round(a * scale) |
| 87 | }; |
| 88 | }, |
| 89 | |
| 90 | /** Meters from camera using near/far and normalized t (0..1 from gray/65535). */ |
| 91 | distanceMeters: function (grayU16, near, far) |
| 92 | { |
| 93 | var t = (grayU16 & 0xffff) / 65535; |
| 94 | return near + t * (far - near); |
| 95 | } |
| 96 | }; |
| 97 | |
| 98 | if (typeof module !== "undefined" && module.exports) |
| 99 | { module.exports = DepthDecode; } |