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
|
// 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_SRC_DRACO_COMPRESSION_EXPERT_ENCODE_H_
#define DRACO_SRC_DRACO_COMPRESSION_EXPERT_ENCODE_H_
#include "draco/compression/config/compression_shared.h"
#include "draco/compression/config/encoder_options.h"
#include "draco/compression/encode_base.h"
#include "draco/core/encoder_buffer.h"
#include "draco/core/status.h"
#include "draco/mesh/mesh.h"
namespace draco {
// Advanced helper class for encoding geometry using the Draco compression
// library. Unlike the basic Encoder (encode.h), this class allows users to
// specify options for each attribute individually using provided attribute ids.
// The drawback of this encoder is that it can be used to encode only one model
// at a time, and for each new model the options need to be set again,
class ExpertEncoder : public EncoderBase<EncoderOptions> {
public:
typedef EncoderBase<EncoderOptions> Base;
typedef EncoderOptions OptionsType;
explicit ExpertEncoder(const PointCloud &point_cloud);
explicit ExpertEncoder(const Mesh &mesh);
// Encodes the geometry provided in the constructor to the target buffer.
Status EncodeToBuffer(EncoderBuffer *out_buffer);
// Set encoder options used during the geometry encoding. Note that this call
// overwrites any modifications to the options done with the functions below.
void Reset(const EncoderOptions &options);
void Reset();
// Sets the desired encoding and decoding speed for the given options.
//
// 0 = slowest speed, but the best compression.
// 10 = fastest, but the worst compression.
// -1 = undefined.
//
// Note that both speed options affect the encoder choice of used methods and
// algorithms. For example, a requirement for fast decoding may prevent the
// encoder from using the best compression methods even if the encoding speed
// is set to 0. In general, the faster of the two options limits the choice of
// features that can be used by the encoder. Additionally, setting
// |decoding_speed| to be faster than the |encoding_speed| may allow the
// encoder to choose the optimal method out of the available features for the
// given |decoding_speed|.
void SetSpeedOptions(int encoding_speed, int decoding_speed);
// Sets the quantization compression options for a specific attribute. The
// attribute values will be quantized in a box defined by the maximum extent
// of the attribute values. I.e., the actual precision of this option depends
// on the scale of the attribute values.
void SetAttributeQuantization(int32_t attribute_id, int quantization_bits);
// Sets the explicit quantization compression for a named attribute. The
// attribute values will be quantized in a coordinate system defined by the
// provided origin and range (the input values should be within interval:
// <origin, origin + range>).
void SetAttributeExplicitQuantization(int32_t attribute_id,
int quantization_bits, int num_dims,
const float *origin, float range);
// Enables/disables built in entropy coding of attribute values. Disabling
// this option may be useful to improve the performance when third party
// compression is used on top of the Draco compression. Default: [true].
void SetUseBuiltInAttributeCompression(bool enabled);
// Sets the desired encoding method for a given geometry. By default, encoding
// method is selected based on the properties of the input geometry and based
// on the other options selected in the used EncoderOptions (such as desired
// encoding and decoding speed). This function should be called only when a
// specific method is required.
//
// |encoding_method| can be one of the values defined in
// compression/config/compression_shared.h based on the type of the input
// geometry that is going to be encoded. For point clouds, allowed entries are
// POINT_CLOUD_SEQUENTIAL_ENCODING
// POINT_CLOUD_KD_TREE_ENCODING
//
// For meshes the input can be
// MESH_SEQUENTIAL_ENCODING
// MESH_EDGEBREAKER_ENCODING
//
// If the selected method cannot be used for the given input, the subsequent
// call of EncodePointCloudToBuffer or EncodeMeshToBuffer is going to fail.
void SetEncodingMethod(int encoding_method);
// Sets the desired encoding submethod, only for MESH_EDGEBREAKER_ENCODING.
// Valid values for |encoding_submethod| are:
// MESH_EDGEBREAKER_STANDARD_ENCODING
// MESH_EDGEBREAKER_VALENCE_ENCODING
// see also compression/config/compression_shared.h.
void SetEncodingSubmethod(int encoding_submethod);
// Sets the desired prediction method for a given attribute. By default,
// prediction scheme is selected automatically by the encoder using other
// provided options (such as speed) and input geometry type (mesh, point
// cloud). This function should be called only when a specific prediction is
// preferred (e.g., when it is known that the encoder would select a less
// optimal prediction for the given input data).
//
// |prediction_scheme_method| should be one of the entries defined in
// compression/config/compression_shared.h :
//
// PREDICTION_NONE - use no prediction.
// PREDICTION_DIFFERENCE - delta coding
// MESH_PREDICTION_PARALLELOGRAM - parallelogram prediction for meshes.
// MESH_PREDICTION_CONSTRAINED_PARALLELOGRAM
// - better and more costly version of the parallelogram prediction.
// MESH_PREDICTION_TEX_COORDS_PORTABLE
// - specialized predictor for tex coordinates.
// MESH_PREDICTION_GEOMETRIC_NORMAL
// - specialized predictor for normal coordinates.
//
// Note that in case the desired prediction cannot be used, the default
// prediction will be automatically used instead.
Status SetAttributePredictionScheme(int32_t attribute_id,
int prediction_scheme_method);
private:
Status EncodePointCloudToBuffer(const PointCloud &pc,
EncoderBuffer *out_buffer);
Status EncodeMeshToBuffer(const Mesh &m, EncoderBuffer *out_buffer);
const PointCloud *point_cloud_;
const Mesh *mesh_;
};
} // namespace draco
#endif // DRACO_SRC_DRACO_COMPRESSION_EXPERT_ENCODE_H_
|
