blob: 9f668f7fa1587e915fb2f117b970acf9e233b6cf (
plain)
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
|
// Copyright 2017 The Draco Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
#ifndef DRACO_METADATA_GEOMETRY_METADATA_H_
#define DRACO_METADATA_GEOMETRY_METADATA_H_
#include "draco/metadata/metadata.h"
namespace draco {
// Class for representing specifically metadata of attributes. It must have an
// attribute id which should be identical to it's counterpart attribute in
// the point cloud it belongs to.
class AttributeMetadata : public Metadata {
public:
AttributeMetadata() : att_unique_id_(0) {}
explicit AttributeMetadata(const Metadata &metadata)
: Metadata(metadata), att_unique_id_(0) {}
void set_att_unique_id(uint32_t att_unique_id) {
att_unique_id_ = att_unique_id;
}
// The unique id of the attribute that this metadata belongs to.
uint32_t att_unique_id() const { return att_unique_id_; }
private:
uint32_t att_unique_id_;
friend struct AttributeMetadataHasher;
friend class PointCloud;
};
// Functor for computing a hash from data stored in a AttributeMetadata class.
struct AttributeMetadataHasher {
size_t operator()(const AttributeMetadata &metadata) const {
size_t hash = metadata.att_unique_id_;
MetadataHasher metadata_hasher;
hash = HashCombine(metadata_hasher(static_cast<const Metadata &>(metadata)),
hash);
return hash;
}
};
// Class for representing the metadata for a point cloud. It could have a list
// of attribute metadata.
class GeometryMetadata : public Metadata {
public:
GeometryMetadata(){};
explicit GeometryMetadata(const Metadata &metadata) : Metadata(metadata) {}
const AttributeMetadata *GetAttributeMetadataByStringEntry(
const std::string &entry_name, const std::string &entry_value) const;
bool AddAttributeMetadata(std::unique_ptr<AttributeMetadata> att_metadata);
void DeleteAttributeMetadataByUniqueId(int32_t att_unique_id) {
for (auto itr = att_metadatas_.begin(); itr != att_metadatas_.end();
++itr) {
if (itr->get()->att_unique_id() == att_unique_id) {
att_metadatas_.erase(itr);
return;
}
}
}
const AttributeMetadata *GetAttributeMetadataByUniqueId(
int32_t att_unique_id) const {
// TODO(draco-eng): Consider using unordered_map instead of vector to store
// attribute metadata.
for (auto &&att_metadata : att_metadatas_) {
if (att_metadata->att_unique_id() == att_unique_id) {
return att_metadata.get();
}
}
return nullptr;
}
AttributeMetadata *attribute_metadata(int32_t att_unique_id) {
// TODO(draco-eng): Consider use unordered_map instead of vector to store
// attribute metadata.
for (auto &&att_metadata : att_metadatas_) {
if (att_metadata->att_unique_id() == att_unique_id) {
return att_metadata.get();
}
}
return nullptr;
}
const std::vector<std::unique_ptr<AttributeMetadata>> &attribute_metadatas()
const {
return att_metadatas_;
}
private:
std::vector<std::unique_ptr<AttributeMetadata>> att_metadatas_;
friend struct GeometryMetadataHasher;
};
// Functor for computing a hash from data stored in a GeometryMetadata class.
struct GeometryMetadataHasher {
size_t operator()(const GeometryMetadata &metadata) const {
size_t hash = metadata.att_metadatas_.size();
AttributeMetadataHasher att_metadata_hasher;
for (auto &&att_metadata : metadata.att_metadatas_) {
hash = HashCombine(att_metadata_hasher(*att_metadata), hash);
}
MetadataHasher metadata_hasher;
hash = HashCombine(metadata_hasher(static_cast<const Metadata &>(metadata)),
hash);
return hash;
}
};
} // namespace draco
#endif // THIRD_PARTY_DRACO_METADATA_GEOMETRY_METADATA_H_
|
