Mercurial > gemma

comparison pkg/mesh/meshserialize_v1.go @ 5691:9d2e74225104 sr-v2

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Some refactoring to clean up deserialization.
author Sascha L. Teichmann <sascha.teichmann@intevation.de>
date Mon, 12 Feb 2024 12:48:07 +0100
parents da9720b4aa42
children d920f0fa2f04
comparison
equal deleted inserted replaced
5690:da9720b4aa42 5691:9d2e74225104
91 91
92 return nil 92 return nil
93 } 93 }
94 94
95 func (t *Tin) serializeV1(w io.Writer) error { 95 func (t *Tin) serializeV1(w io.Writer) error {
96 if err := binary.Write(w, binary.LittleEndian, t.EPSG); err != nil { 96 if err := t.serializeEPSG(w); err != nil {
97 return err 97 return err
98 } 98 }
99 if err := t.serializeExtent(w); err != nil { 99 if err := t.serializeExtent(w); err != nil {
100 return err 100 return err
101 } 101 }
102 if err := t.serializeVerticesV1(w); err != nil { 102 if err := t.serializeVerticesV1(w); err != nil {
103 return err 103 return err
104 } 104 }
105 return t.serializeTrianglesV1(w)
106 }
107
108 func (t *Tin) serializeTrianglesV1(w io.Writer) error {
105 if err := binary.Write( 109 if err := binary.Write(
106 w, binary.LittleEndian, uint32(len(t.Triangles))); err != nil { 110 w, binary.LittleEndian, uint32(len(t.Triangles))); err != nil {
107 return err 111 return err
108 } 112 }
109 return t.serializeTrianglesV1(w)
110 }
111
112 func (t *Tin) serializeTrianglesV1(w io.Writer) error {
113 var buf [binary.MaxVarintLen32]byte 113 var buf [binary.MaxVarintLen32]byte
114 var written int 114 var written int
115 var last int32 115 var last int32
116 for _, triangle := range t.Triangles { 116 for _, triangle := range t.Triangles {
117 for _, idx := range triangle { 117 for _, idx := range triangle {
135 func (t *Tin) serializeVerticesV1(w io.Writer) error { 135 func (t *Tin) serializeVerticesV1(w io.Writer) error {
136 if err := binary.Write( 136 if err := binary.Write(
137 w, binary.LittleEndian, uint32(len(t.Vertices))); err != nil { 137 w, binary.LittleEndian, uint32(len(t.Vertices))); err != nil {
138 return err 138 return err
139 } 139 }
140
141 var err error 140 var err error
142 vwrite := func(v float64) { 141 vwrite := func(v float64) {
143 if err == nil { 142 if err == nil {
144 err = binary.Write(w, binary.LittleEndian, math.Float64bits(v)) 143 err = binary.Write(w, binary.LittleEndian, math.Float64bits(v))
145 } 144 }
146 } 145 }
147
148 for _, v := range t.Vertices { 146 for _, v := range t.Vertices {
149 vwrite(v.X) 147 vwrite(v.X)
150 vwrite(v.Y) 148 vwrite(v.Y)
151 vwrite(v.Z) 149 vwrite(v.Z)
152 } 150 }
153
154 if err != nil { 151 if err != nil {
155 return err 152 return err
156 } 153 }
157 log.Infof("vertices %d (%d)\n", len(t.Vertices), len(t.Vertices)*3*8) 154 log.Infof("vertices %d (%d)\n", len(t.Vertices), len(t.Vertices)*3*8)
158 return nil 155 return nil
159 } 156 }
160 157
158 func (s *STRTree) deserializeV1(r *bufio.Reader) error {
159 return deserializer(r, s,
160 (*STRTree).deserializeTinV1,
161 (*STRTree).deserializeEntries,
162 (*STRTree).deserializeIndexV1,
163 (*STRTree).deserializeBBoxesV1,
164 )
165 }
166
161 func (s *STRTree) deserializeBBoxesV1(r *bufio.Reader) error { 167 func (s *STRTree) deserializeBBoxesV1(r *bufio.Reader) error {
162
163 var numBBoxes int32 168 var numBBoxes int32
164 if err := binary.Read(r, binary.LittleEndian, &numBBoxes); err != nil { 169 if err := binary.Read(r, binary.LittleEndian, &numBBoxes); err != nil {
165 return err 170 return err
166 } 171 }
167
168 bboxes := make([]Box2D, numBBoxes) 172 bboxes := make([]Box2D, numBBoxes)
169 s.bboxes = bboxes 173 s.bboxes = bboxes
170
171 var err error 174 var err error
172
173 read := func(v *float64) { 175 read := func(v *float64) {
174 if err == nil { 176 if err == nil {
175 err = binary.Read(r, binary.LittleEndian, v) 177 err = binary.Read(r, binary.LittleEndian, v)
176 } 178 }
177 } 179 }
178
179 for i := range bboxes { 180 for i := range bboxes {
180 read(&bboxes[i].X1) 181 read(&bboxes[i].X1)
181 read(&bboxes[i].Y1) 182 read(&bboxes[i].Y1)
182 read(&bboxes[i].X2) 183 read(&bboxes[i].X2)
183 read(&bboxes[i].Y2) 184 read(&bboxes[i].Y2)
184 } 185 }
185
186 return err 186 return err
187 } 187 }
188 188
189 func (s *STRTree) deserializeIndexV1(r *bufio.Reader) error { 189 func (s *STRTree) deserializeIndexV1(r *bufio.Reader) error {
190 var numIndex int32 190 var numIndex int32
191 if err := binary.Read(r, binary.LittleEndian, &numIndex); err != nil { 191 if err := binary.Read(r, binary.LittleEndian, &numIndex); err != nil {
192 return err 192 return err
193 } 193 }
194 index := make([]int32, numIndex) 194 index := make([]int32, numIndex)
195 s.index = index 195 s.index = index
196
197 var last int32 196 var last int32
198 for i := range index { 197 for i := range index {
199 v, err := binary.ReadVarint(r) 198 v, err := binary.ReadVarint(r)
200 if err != nil { 199 if err != nil {
201 return err 200 return err
202 } 201 }
203 value := int32(v) + last 202 value := int32(v) + last
204 index[i] = value 203 index[i] = value
205 last = value 204 last = value
206 } 205 }
207 206 return nil
208 return nil 207 }
209 } 208
210 209 func (s *STRTree) deserializeTinV1(r *bufio.Reader) error {
211 func (s *STRTree) deserializeV1(r *bufio.Reader) error {
212 s.tin = new(Tin) 210 s.tin = new(Tin)
213 if err := s.tin.deserializeV1(r); err != nil { 211 return s.tin.deserializeV1(r)
214 return err
215 }
216 if err := s.deserializeEntries(r); err != nil {
217 return err
218 }
219 if err := s.deserializeIndexV1(r); err != nil {
220 return err
221 }
222 return s.deserializeBBoxesV1(r)
223 } 212 }
224 213
225 // deserializeV1 restores a TIN from a binary representation. 214 // deserializeV1 restores a TIN from a binary representation.
226 func (t *Tin) deserializeV1(r *bufio.Reader) error { 215 func (t *Tin) deserializeV1(r *bufio.Reader) error {
227 216 return deserializer(r, t,
228 if err := binary.Read(r, binary.LittleEndian, &t.EPSG); err != nil { 217 (*Tin).deserializeEPSG,
229 return err 218 (*Tin).deserializeExtent,
230 } 219 (*Tin).deserializeVerticesV1,
231 220 (*Tin).deserializeTrianglesV1,
232 log.Infof("EPSG: %d\n", t.EPSG) 221 )
233 222 }
234 if err := t.Min.Read(r); err != nil { 223
235 return err 224 func (t *Tin) deserializeVerticesV1(r *bufio.Reader) error {
236 }
237
238 if err := t.Max.Read(r); err != nil {
239 return err
240 }
241
242 log.Infof("BBOX: [[%f, %f, %f], [%f, %f, %f]]\n",
243 t.Min.X, t.Min.Y, t.Min.Z,
244 t.Max.X, t.Max.Y, t.Max.Z)
245
246 var numVertices uint32 225 var numVertices uint32
247 if err := binary.Read(r, binary.LittleEndian, &numVertices); err != nil { 226 if err := binary.Read(r, binary.LittleEndian, &numVertices); err != nil {
248 return err 227 return err
249 } 228 }
250
251 log.Infof("vertices: %d\n", numVertices) 229 log.Infof("vertices: %d\n", numVertices)
252
253 vertices := make([]Vertex, numVertices) 230 vertices := make([]Vertex, numVertices)
254 t.Vertices = vertices 231 t.Vertices = vertices
255
256 for i := range vertices { 232 for i := range vertices {
257 if err := vertices[i].Read(r); err != nil { 233 if err := vertices[i].Read(r); err != nil {
258 return err 234 return err
259 } 235 }
260 } 236 }
261 237 return nil
238 }
239
240 func (t *Tin) deserializeTrianglesV1(r *bufio.Reader) error {
262 var numTriangles uint32 241 var numTriangles uint32
263 if err := binary.Read(r, binary.LittleEndian, &numTriangles); err != nil { 242 if err := binary.Read(r, binary.LittleEndian, &numTriangles); err != nil {
264 return err 243 return err
265 } 244 }
266
267 log.Infof("triangles: %d\n", numTriangles) 245 log.Infof("triangles: %d\n", numTriangles)
268
269 indices := make([]int32, 3*numTriangles) 246 indices := make([]int32, 3*numTriangles)
270 triangles := make([][]int32, numTriangles) 247 triangles := make([][]int32, numTriangles)
271 t.Triangles = triangles 248 t.Triangles = triangles
272 249 var last int32
273 var last int32
274
275 for i := range triangles { 250 for i := range triangles {
276 tri := indices[:3] 251 tri := indices[:3]
277 indices = indices[3:] 252 indices = indices[3:]
278 triangles[i] = tri 253 triangles[i] = tri
279 for j := range tri { 254 for j := range tri {
284 value := int32(v) + last 259 value := int32(v) + last
285 tri[j] = value 260 tri[j] = value
286 last = value 261 last = value
287 } 262 }
288 } 263 }
289 264 return nil
290 return nil 265 }
291 }