Commit f5e788ec authored by Sehoon Yea's avatar Sehoon Yea Committed by David Flynn
Browse files

attr/m49601: use attr_t (uint16_t) for all attributes

In order to support bit depths higher than 8bit, this commit adds
an attr_t type to represent attribute data.  Existing uses of
uint8_t and uint16_t are converted to attr_t.
parent d2718fae
...@@ -254,7 +254,7 @@ AttributeDecoder::computeReflectancePredictionWeights( ...@@ -254,7 +254,7 @@ AttributeDecoder::computeReflectancePredictionWeights(
int64_t minValue = 0; int64_t minValue = 0;
int64_t maxValue = 0; int64_t maxValue = 0;
for (int i = 0; i < predictor.neighborCount; ++i) { for (int i = 0; i < predictor.neighborCount; ++i) {
const uint16_t reflectanceNeighbor = pointCloud.getReflectance( const attr_t reflectanceNeighbor = pointCloud.getReflectance(
indexes[predictor.neighbors[i].predictorIndex]); indexes[predictor.neighbors[i].predictorIndex]);
if (i == 0 || reflectanceNeighbor < minValue) { if (i == 0 || reflectanceNeighbor < minValue) {
minValue = reflectanceNeighbor; minValue = reflectanceNeighbor;
...@@ -303,7 +303,7 @@ AttributeDecoder::decodeReflectancesPred( ...@@ -303,7 +303,7 @@ AttributeDecoder::decodeReflectancesPred(
computeReflectancePredictionWeights( computeReflectancePredictionWeights(
aps, pointCloud, indexesLOD, predictor, decoder); aps, pointCloud, indexesLOD, predictor, decoder);
const uint32_t pointIndex = indexesLOD[predictorIndex]; const uint32_t pointIndex = indexesLOD[predictorIndex];
uint16_t& reflectance = pointCloud.getReflectance(pointIndex); attr_t& reflectance = pointCloud.getReflectance(pointIndex);
uint32_t attValue0 = 0; uint32_t attValue0 = 0;
if (zero_cnt > 0) { if (zero_cnt > 0) {
zero_cnt--; zero_cnt--;
...@@ -316,8 +316,8 @@ AttributeDecoder::decodeReflectancesPred( ...@@ -316,8 +316,8 @@ AttributeDecoder::decodeReflectancesPred(
const int64_t delta = divExp2RoundHalfUp( const int64_t delta = divExp2RoundHalfUp(
quant[0].scale(UIntToInt(attValue0)), kFixedPointAttributeShift); quant[0].scale(UIntToInt(attValue0)), kFixedPointAttributeShift);
const int64_t reconstructedQuantAttValue = quantPredAttValue + delta; const int64_t reconstructedQuantAttValue = quantPredAttValue + delta;
reflectance = uint16_t( reflectance =
PCCClip(reconstructedQuantAttValue, int64_t(0), maxReflectance)); attr_t(PCCClip(reconstructedQuantAttValue, int64_t(0), maxReflectance));
} }
} }
...@@ -338,7 +338,7 @@ AttributeDecoder::computeColorPredictionWeights( ...@@ -338,7 +338,7 @@ AttributeDecoder::computeColorPredictionWeights(
int64_t minValue[3] = {0, 0, 0}; int64_t minValue[3] = {0, 0, 0};
int64_t maxValue[3] = {0, 0, 0}; int64_t maxValue[3] = {0, 0, 0};
for (int i = 0; i < predictor.neighborCount; ++i) { for (int i = 0; i < predictor.neighborCount; ++i) {
const Vec3<uint8_t> colorNeighbor = const Vec3<attr_t> colorNeighbor =
pointCloud.getColor(indexes[predictor.neighbors[i].predictorIndex]); pointCloud.getColor(indexes[predictor.neighbors[i].predictorIndex]);
for (size_t k = 0; k < 3; ++k) { for (size_t k = 0; k < 3; ++k) {
if (i == 0 || colorNeighbor[k] < minValue[k]) { if (i == 0 || colorNeighbor[k] < minValue[k]) {
...@@ -398,8 +398,8 @@ AttributeDecoder::decodeColorsPred( ...@@ -398,8 +398,8 @@ AttributeDecoder::decodeColorsPred(
zero_cnt = decoder.decodeZeroCnt(pointCount); zero_cnt = decoder.decodeZeroCnt(pointCount);
} }
const uint32_t pointIndex = indexesLOD[predictorIndex]; const uint32_t pointIndex = indexesLOD[predictorIndex];
Vec3<uint8_t>& color = pointCloud.getColor(pointIndex); Vec3<attr_t>& color = pointCloud.getColor(pointIndex);
const Vec3<uint8_t> predictedColor = const Vec3<attr_t> predictedColor =
predictor.predictColor(pointCloud, indexesLOD); predictor.predictColor(pointCloud, indexesLOD);
int64_t clipMax = (1 << desc.attr_bitdepth) - 1; int64_t clipMax = (1 << desc.attr_bitdepth) - 1;
...@@ -409,7 +409,7 @@ AttributeDecoder::decodeColorsPred( ...@@ -409,7 +409,7 @@ AttributeDecoder::decodeColorsPred(
const int64_t residual = divExp2RoundHalfUp( const int64_t residual = divExp2RoundHalfUp(
q.scale(UIntToInt(values[k])), kFixedPointAttributeShift); q.scale(UIntToInt(values[k])), kFixedPointAttributeShift);
const int64_t recon = predictedColor[k] + residual + residual0; const int64_t recon = predictedColor[k] + residual + residual0;
color[k] = uint8_t(PCCClip(recon, int64_t(0), clipMax)); color[k] = attr_t(PCCClip(recon, int64_t(0), clipMax));
if (!k && aps.inter_component_prediction_enabled_flag) if (!k && aps.inter_component_prediction_enabled_flag)
residual0 = residual; residual0 = residual;
...@@ -466,8 +466,8 @@ AttributeDecoder::decodeReflectancesRaht( ...@@ -466,8 +466,8 @@ AttributeDecoder::decodeReflectancesRaht(
const int64_t minReflectance = 0; const int64_t minReflectance = 0;
for (int n = 0; n < voxelCount; n++) { for (int n = 0; n < voxelCount; n++) {
int64_t val = attributes[attribCount * n]; int64_t val = attributes[attribCount * n];
const uint16_t reflectance = const attr_t reflectance =
(uint16_t)PCCClip(val, minReflectance, maxReflectance); attr_t(PCCClip(val, minReflectance, maxReflectance));
pointCloud.setReflectance(packedVoxel[n].index, reflectance); pointCloud.setReflectance(packedVoxel[n].index, reflectance);
} }
...@@ -531,10 +531,10 @@ AttributeDecoder::decodeColorsRaht( ...@@ -531,10 +531,10 @@ AttributeDecoder::decodeColorsRaht(
const int r = attributes[attribCount * n]; const int r = attributes[attribCount * n];
const int g = attributes[attribCount * n + 1]; const int g = attributes[attribCount * n + 1];
const int b = attributes[attribCount * n + 2]; const int b = attributes[attribCount * n + 2];
Vec3<uint8_t> color; Vec3<attr_t> color;
color[0] = uint8_t(PCCClip(r, 0, clipMax)); color[0] = attr_t(PCCClip(r, 0, clipMax));
color[1] = uint8_t(PCCClip(g, 0, clipMax)); color[1] = attr_t(PCCClip(g, 0, clipMax));
color[2] = uint8_t(PCCClip(b, 0, clipMax)); color[2] = attr_t(PCCClip(b, 0, clipMax));
pointCloud.setColor(packedVoxel[n].index, color); pointCloud.setColor(packedVoxel[n].index, color);
} }
...@@ -635,9 +635,9 @@ AttributeDecoder::decodeColorsLift( ...@@ -635,9 +635,9 @@ AttributeDecoder::decodeColorsLift(
for (size_t f = 0; f < pointCount; ++f) { for (size_t f = 0; f < pointCount; ++f) {
const auto color0 = const auto color0 =
divExp2RoundHalfInf(colors[f], kFixedPointAttributeShift); divExp2RoundHalfInf(colors[f], kFixedPointAttributeShift);
Vec3<uint8_t> color; Vec3<attr_t> color;
for (size_t d = 0; d < 3; ++d) { for (size_t d = 0; d < 3; ++d) {
color[d] = uint8_t(PCCClip(color0[d], int64_t(0), clipMax)); color[d] = attr_t(PCCClip(color0[d], int64_t(0), clipMax));
} }
pointCloud.setColor(indexesLOD[f], color); pointCloud.setColor(indexesLOD[f], color);
} }
...@@ -727,7 +727,7 @@ AttributeDecoder::decodeReflectancesLift( ...@@ -727,7 +727,7 @@ AttributeDecoder::decodeReflectancesLift(
const auto refl = const auto refl =
divExp2RoundHalfInf(reflectances[f], kFixedPointAttributeShift); divExp2RoundHalfInf(reflectances[f], kFixedPointAttributeShift);
pointCloud.setReflectance( pointCloud.setReflectance(
indexesLOD[f], uint16_t(PCCClip(refl, int64_t(0), maxReflectance))); indexesLOD[f], attr_t(PCCClip(refl, int64_t(0), maxReflectance)));
} }
} }
......
...@@ -507,7 +507,7 @@ AttributeEncoder::encodeReflectancesPred( ...@@ -507,7 +507,7 @@ AttributeEncoder::encodeReflectancesPred(
const uint32_t pointIndex = indexesLOD[predictorIndex]; const uint32_t pointIndex = indexesLOD[predictorIndex];
const uint64_t reflectance = pointCloud.getReflectance(pointIndex); const uint64_t reflectance = pointCloud.getReflectance(pointIndex);
const uint16_t predictedReflectance = const attr_t predictedReflectance =
predictor.predictReflectance(pointCloud, indexesLOD); predictor.predictReflectance(pointCloud, indexesLOD);
const int64_t quantAttValue = reflectance; const int64_t quantAttValue = reflectance;
const int64_t quantPredAttValue = predictedReflectance; const int64_t quantPredAttValue = predictedReflectance;
...@@ -518,8 +518,8 @@ AttributeEncoder::encodeReflectancesPred( ...@@ -518,8 +518,8 @@ AttributeEncoder::encodeReflectancesPred(
divExp2RoundHalfUp(quant[0].scale(delta), kFixedPointAttributeShift); divExp2RoundHalfUp(quant[0].scale(delta), kFixedPointAttributeShift);
const int64_t reconstructedQuantAttValue = const int64_t reconstructedQuantAttValue =
quantPredAttValue + reconstructedDelta; quantPredAttValue + reconstructedDelta;
const uint16_t reconstructedReflectance = const attr_t reconstructedReflectance =
uint16_t(PCCClip(reconstructedQuantAttValue, int64_t(0), clipMax)); attr_t(PCCClip(reconstructedQuantAttValue, int64_t(0), clipMax));
if (!attValue0) if (!attValue0)
++zero_cnt; ++zero_cnt;
...@@ -558,8 +558,8 @@ AttributeEncoder::encodeReflectancesPred( ...@@ -558,8 +558,8 @@ AttributeEncoder::encodeReflectancesPred(
Vec3<int64_t> Vec3<int64_t>
AttributeEncoder::computeColorResiduals( AttributeEncoder::computeColorResiduals(
const Vec3<uint8_t> color, const Vec3<attr_t> color,
const Vec3<uint8_t> predictedColor, const Vec3<attr_t> predictedColor,
const Quantizers& quant) const Quantizers& quant)
{ {
Vec3<int64_t> residuals; Vec3<int64_t> residuals;
...@@ -597,7 +597,7 @@ AttributeEncoder::computeColorPredictionWeights( ...@@ -597,7 +597,7 @@ AttributeEncoder::computeColorPredictionWeights(
int64_t minValue[3] = {0, 0, 0}; int64_t minValue[3] = {0, 0, 0};
int64_t maxValue[3] = {0, 0, 0}; int64_t maxValue[3] = {0, 0, 0};
for (int i = 0; i < predictor.neighborCount; ++i) { for (int i = 0; i < predictor.neighborCount; ++i) {
const Vec3<uint8_t> colorNeighbor = const Vec3<attr_t> colorNeighbor =
pointCloud.getColor(indexesLOD[predictor.neighbors[i].predictorIndex]); pointCloud.getColor(indexesLOD[predictor.neighbors[i].predictorIndex]);
for (size_t k = 0; k < 3; ++k) { for (size_t k = 0; k < 3; ++k) {
if (i == 0 || colorNeighbor[k] < minValue[k]) { if (i == 0 || colorNeighbor[k] < minValue[k]) {
...@@ -614,12 +614,11 @@ AttributeEncoder::computeColorPredictionWeights( ...@@ -614,12 +614,11 @@ AttributeEncoder::computeColorPredictionWeights(
predictor.maxDiff = maxDiff; predictor.maxDiff = maxDiff;
if (maxDiff >= aps.adaptive_prediction_threshold) { if (maxDiff >= aps.adaptive_prediction_threshold) {
Vec3<uint8_t> attrValue = Vec3<attr_t> attrValue = pointCloud.getColor(indexesLOD[predictorIndex]);
pointCloud.getColor(indexesLOD[predictorIndex]);
// base case: weighted average of n neighbours // base case: weighted average of n neighbours
predictor.predMode = 0; predictor.predMode = 0;
Vec3<uint8_t> attrPred = predictor.predictColor(pointCloud, indexesLOD); Vec3<attr_t> attrPred = predictor.predictColor(pointCloud, indexesLOD);
Vec3<int64_t> attrResidualQuant = Vec3<int64_t> attrResidualQuant =
computeColorResiduals(attrValue, attrPred, quant); computeColorResiduals(attrValue, attrPred, quant);
...@@ -694,11 +693,11 @@ AttributeEncoder::encodeColorsPred( ...@@ -694,11 +693,11 @@ AttributeEncoder::encodeColorsPred(
aps, pointCloud, indexesLOD, predictorIndex, predictor, encoder, context, aps, pointCloud, indexesLOD, predictorIndex, predictor, encoder, context,
quant); quant);
const auto pointIndex = indexesLOD[predictorIndex]; const auto pointIndex = indexesLOD[predictorIndex];
const Vec3<uint8_t> color = pointCloud.getColor(pointIndex); const Vec3<attr_t> color = pointCloud.getColor(pointIndex);
const Vec3<uint8_t> predictedColor = const Vec3<attr_t> predictedColor =
predictor.predictColor(pointCloud, indexesLOD); predictor.predictColor(pointCloud, indexesLOD);
Vec3<uint8_t> reconstructedColor; Vec3<attr_t> reconstructedColor;
int64_t residual0 = 0; int64_t residual0 = 0;
for (int k = 0; k < 3; ++k) { for (int k = 0; k < 3; ++k) {
const auto& q = quant[std::min(k, 1)]; const auto& q = quant[std::min(k, 1)];
...@@ -721,7 +720,7 @@ AttributeEncoder::encodeColorsPred( ...@@ -721,7 +720,7 @@ AttributeEncoder::encodeColorsPred(
values[k] = uint32_t(IntToUInt(long(residualQ))); values[k] = uint32_t(IntToUInt(long(residualQ)));
int64_t recon = predictedColor[k] + residualR; int64_t recon = predictedColor[k] + residualR;
reconstructedColor[k] = uint8_t(PCCClip(recon, int64_t(0), clipMax)); reconstructedColor[k] = attr_t(PCCClip(recon, int64_t(0), clipMax));
} }
pointCloud.setColor(pointIndex, reconstructedColor); pointCloud.setColor(pointIndex, reconstructedColor);
...@@ -819,8 +818,8 @@ AttributeEncoder::encodeReflectancesTransformRaht( ...@@ -819,8 +818,8 @@ AttributeEncoder::encodeReflectancesTransformRaht(
const int64_t minReflectance = 0; const int64_t minReflectance = 0;
for (int n = 0; n < voxelCount; n++) { for (int n = 0; n < voxelCount; n++) {
int64_t val = attributes[attribCount * n]; int64_t val = attributes[attribCount * n];
const uint16_t reflectance = const attr_t reflectance =
(uint16_t)PCCClip(val, minReflectance, maxReflectance); attr_t(PCCClip(val, minReflectance, maxReflectance));
pointCloud.setReflectance(packedVoxel[n].index, reflectance); pointCloud.setReflectance(packedVoxel[n].index, reflectance);
} }
...@@ -892,10 +891,10 @@ AttributeEncoder::encodeColorsTransformRaht( ...@@ -892,10 +891,10 @@ AttributeEncoder::encodeColorsTransformRaht(
const int r = attributes[attribCount * n]; const int r = attributes[attribCount * n];
const int g = attributes[attribCount * n + 1]; const int g = attributes[attribCount * n + 1];
const int b = attributes[attribCount * n + 2]; const int b = attributes[attribCount * n + 2];
Vec3<uint8_t> color; Vec3<attr_t> color;
color[0] = uint8_t(PCCClip(r, 0, clipMax)); color[0] = attr_t(PCCClip(r, 0, clipMax));
color[1] = uint8_t(PCCClip(g, 0, clipMax)); color[1] = attr_t(PCCClip(g, 0, clipMax));
color[2] = uint8_t(PCCClip(b, 0, clipMax)); color[2] = attr_t(PCCClip(b, 0, clipMax));
pointCloud.setColor(packedVoxel[n].index, color); pointCloud.setColor(packedVoxel[n].index, color);
} }
...@@ -1001,9 +1000,9 @@ AttributeEncoder::encodeColorsLift( ...@@ -1001,9 +1000,9 @@ AttributeEncoder::encodeColorsLift(
for (size_t f = 0; f < pointCount; ++f) { for (size_t f = 0; f < pointCount; ++f) {
const auto color0 = const auto color0 =
divExp2RoundHalfInf(colors[f], kFixedPointAttributeShift); divExp2RoundHalfInf(colors[f], kFixedPointAttributeShift);
Vec3<uint8_t> color; Vec3<attr_t> color;
for (size_t d = 0; d < 3; ++d) { for (size_t d = 0; d < 3; ++d) {
color[d] = uint8_t(PCCClip(color0[d], 0.0, clipMax)); color[d] = attr_t(PCCClip(color0[d], 0, clipMax));
} }
pointCloud.setColor(indexesLOD[f], color); pointCloud.setColor(indexesLOD[f], color);
} }
...@@ -1097,7 +1096,7 @@ AttributeEncoder::encodeReflectancesLift( ...@@ -1097,7 +1096,7 @@ AttributeEncoder::encodeReflectancesLift(
const int64_t refl = const int64_t refl =
divExp2RoundHalfInf(reflectances[f], kFixedPointAttributeShift); divExp2RoundHalfInf(reflectances[f], kFixedPointAttributeShift);
pointCloud.setReflectance( pointCloud.setReflectance(
indexesLOD[f], uint16_t(PCCClip(refl, int64_t(0), maxReflectance))); indexesLOD[f], attr_t(PCCClip(refl, int64_t(0), maxReflectance)));
} }
} }
......
...@@ -108,8 +108,8 @@ protected: ...@@ -108,8 +108,8 @@ protected:
PCCResidualsEncoder& encoder); PCCResidualsEncoder& encoder);
static Vec3<int64_t> computeColorResiduals( static Vec3<int64_t> computeColorResiduals(
const Vec3<uint8_t> color, const Vec3<attr_t> color,
const Vec3<uint8_t> predictedColor, const Vec3<attr_t> predictedColor,
const Quantizers& quant); const Quantizers& quant);
static void computeColorPredictionWeights( static void computeColorPredictionWeights(
......
...@@ -51,6 +51,13 @@ ...@@ -51,6 +51,13 @@
#include "PCCMisc.h" #include "PCCMisc.h"
namespace pcc { namespace pcc {
//============================================================================
// The type used for internally representing attribute data
typedef uint16_t attr_t;
//============================================================================
class PCCPointSet3 { class PCCPointSet3 {
public: public:
typedef Vec3<double> PointType; typedef Vec3<double> PointType;
...@@ -259,32 +266,32 @@ public: ...@@ -259,32 +266,32 @@ public:
assert(index < positions.size()); assert(index < positions.size());
return positions[index]; return positions[index];
} }
Vec3<uint8_t> getColor(const size_t index) const Vec3<attr_t> getColor(const size_t index) const
{ {
assert(index < colors.size() && withColors); assert(index < colors.size() && withColors);
return colors[index]; return colors[index];
} }
Vec3<uint8_t>& getColor(const size_t index) Vec3<attr_t>& getColor(const size_t index)
{ {
assert(index < colors.size() && withColors); assert(index < colors.size() && withColors);
return colors[index]; return colors[index];
} }
void setColor(const size_t index, const Vec3<uint8_t> color) void setColor(const size_t index, const Vec3<attr_t> color)
{ {
assert(index < colors.size() && withColors); assert(index < colors.size() && withColors);
colors[index] = color; colors[index] = color;
} }
uint16_t getReflectance(const size_t index) const attr_t getReflectance(const size_t index) const
{ {
assert(index < reflectances.size() && withReflectances); assert(index < reflectances.size() && withReflectances);
return reflectances[index]; return reflectances[index];
} }
uint16_t& getReflectance(const size_t index) attr_t& getReflectance(const size_t index)
{ {
assert(index < reflectances.size() && withReflectances); assert(index < reflectances.size() && withReflectances);
return reflectances[index]; return reflectances[index];
} }
void setReflectance(const size_t index, const uint16_t reflectance) void setReflectance(const size_t index, const attr_t reflectance)
{ {
assert(index < reflectances.size() && withReflectances); assert(index < reflectances.size() && withReflectances);
reflectances[index] = reflectance; reflectances[index] = reflectance;
...@@ -495,8 +502,8 @@ public: ...@@ -495,8 +502,8 @@ public:
private: private:
std::vector<Vec3<double>> positions; std::vector<Vec3<double>> positions;
std::vector<Vec3<uint8_t>> colors; std::vector<Vec3<attr_t>> colors;
std::vector<uint16_t> reflectances; std::vector<attr_t> reflectances;
std::vector<uint8_t> frameidx; std::vector<uint8_t> frameidx;
bool withColors; bool withColors;
bool withReflectances; bool withReflectances;
......
...@@ -105,21 +105,21 @@ struct PCCPredictor { ...@@ -105,21 +105,21 @@ struct PCCPredictor {
int8_t predMode; int8_t predMode;
int64_t maxDiff; int64_t maxDiff;
Vec3<uint8_t> predictColor( Vec3<attr_t> predictColor(
const PCCPointSet3& pointCloud, const std::vector<uint32_t>& indexes) const const PCCPointSet3& pointCloud, const std::vector<uint32_t>& indexes) const
{ {
Vec3<int64_t> predicted(0); Vec3<int64_t> predicted(0);
if (predMode > neighborCount) { if (predMode > neighborCount) {
/* nop */ /* nop */
} else if (predMode > 0) { } else if (predMode > 0) {
const Vec3<uint8_t> color = const Vec3<attr_t> color =
pointCloud.getColor(indexes[neighbors[predMode - 1].predictorIndex]); pointCloud.getColor(indexes[neighbors[predMode - 1].predictorIndex]);
for (size_t k = 0; k < 3; ++k) { for (size_t k = 0; k < 3; ++k) {
predicted[k] += color[k]; predicted[k] += color[k];
} }
} else { } else {
for (size_t i = 0; i < neighborCount; ++i) { for (size_t i = 0; i < neighborCount; ++i) {
const Vec3<uint8_t> color = const Vec3<attr_t> color =
pointCloud.getColor(indexes[neighbors[i].predictorIndex]); pointCloud.getColor(indexes[neighbors[i].predictorIndex]);
const uint32_t w = neighbors[i].weight; const uint32_t w = neighbors[i].weight;
for (size_t k = 0; k < 3; ++k) { for (size_t k = 0; k < 3; ++k) {
...@@ -131,7 +131,7 @@ struct PCCPredictor { ...@@ -131,7 +131,7 @@ struct PCCPredictor {
divExp2RoundHalfInf(predicted[k], kFixedPointWeightShift); divExp2RoundHalfInf(predicted[k], kFixedPointWeightShift);
} }
} }
return Vec3<uint8_t>(predicted[0], predicted[1], predicted[2]); return Vec3<attr_t>(predicted[0], predicted[1], predicted[2]);
} }
int64_t predictReflectance( int64_t predictReflectance(
......
...@@ -801,11 +801,8 @@ ParseParameters(int argc, char* argv[], Parameters& params) ...@@ -801,11 +801,8 @@ ParseParameters(int argc, char* argv[], Parameters& params)
attr_aps.attr_encoding == AttributeEncoding::kPredictingTransform attr_aps.attr_encoding == AttributeEncoding::kPredictingTransform
|| attr_aps.attr_encoding == AttributeEncoding::kLiftingTransform; || attr_aps.attr_encoding == AttributeEncoding::kLiftingTransform;
if (it.first == "color") { if (attr_sps.attr_bitdepth > 16)
// todo(??): permit relaxing of the following constraint err.error() << it.first << ".bitdepth must be less than 17\n";
if (attr_sps.attr_bitdepth > 8)
err.error() << it.first << ".bitdepth must be less than 9\n";
}
if (it.first == "reflectance") { if (it.first == "reflectance") {
if (attr_sps.attr_bitdepth > 16) if (attr_sps.attr_bitdepth > 16)
......
...@@ -387,9 +387,12 @@ PCCTMC3Encoder3::compressPartition( ...@@ -387,9 +387,12 @@ PCCTMC3Encoder3::compressPartition(
// NB: recolouring is required if points are added / removed // NB: recolouring is required if points are added / removed
if (_gps->geom_unique_points_flag || _gps->trisoup_node_size_log2 > 0) { if (_gps->geom_unique_points_flag || _gps->trisoup_node_size_log2 > 0) {
for (const auto& attr_sps : _sps->attributeSets) {
recolour( recolour(
params->recolour, originPartCloud, _sps->seq_source_geom_scale_factor, attr_sps, params->recolour, originPartCloud,
_sps->seq_bounding_box_xyz0, _sliceOrigin, &pointCloud); _sps->seq_source_geom_scale_factor, _sps->seq_bounding_box_xyz0,
_sliceOrigin, &pointCloud);
}
} }
// dump recoloured point cloud // dump recoloured point cloud
......
...@@ -142,7 +142,7 @@ ply::write( ...@@ -142,7 +142,7 @@ ply::write(
const Vec3<double>& position = cloud[i]; const Vec3<double>& position = cloud[i];
fout << position.x() << " " << position.y() << " " << position.z(); fout << position.x() << " " << position.y() << " " << position.z();
if (cloud.hasColors()) { if (cloud.hasColors()) {
const Vec3<uint8_t>& color = cloud.getColor(i); const Vec3<attr_t>& color = cloud.getColor(i);
fout << " " << static_cast<int>(color[0]) << " " fout << " " << static_cast<int>(color[0]) << " "
<< static_cast<int>(color[1]) << " " << static_cast<int>(color[1]) << " "
<< static_cast<int>(color[2]); << static_cast<int>(color[2]);
...@@ -164,11 +164,12 @@ ply::write( ...@@ -164,11 +164,12 @@ ply::write(
fout.write( fout.write(
reinterpret_cast<const char* const>(&position), sizeof(double) * 3); reinterpret_cast<const char* const>(&position), sizeof(double) * 3);
if (cloud.hasColors()) { if (cloud.hasColors()) {
const Vec3<uint8_t>& color = cloud.getColor(i); const Vec3<attr_t>& c = cloud.getColor(i);
fout.write(reinterpret_cast<const char*>(&color), sizeof(uint8_t) * 3); Vec3<uint8_t> val8b{uint8_t(c[0]), uint8_t(c[1]), uint8_t(c[2])};
fout.write(reinterpret_cast<const char*>(&val8b), sizeof(uint8_t) * 3);
} }
if (cloud.hasReflectances()) { if (cloud.hasReflectances()) {
const uint16_t& reflectance = cloud.getReflectance(i); const attr_t& reflectance = cloud.getReflectance(i);
fout.write( fout.write(
reinterpret_cast<const char*>(&reflectance), sizeof(uint16_t)); reinterpret_cast<const char*>(&reflectance), sizeof(uint16_t));
} }
...@@ -447,14 +448,17 @@ ply::read( ...@@ -447,14 +448,17 @@ ply::read(
position[2] = z; position[2] = z;
} }
} else if (a == indexR && attributeInfo.byteCount == 1) { } else if (a == indexR && attributeInfo.byteCount == 1) {
auto& color = cloud.getColor(pointCounter); uint8_t val8b;
ifs.read(reinterpret_cast<char*>(&color[2]), sizeof(uint8_t)); ifs.read(reinterpret_cast<char*>(&val8b), sizeof(uint8_t));
cloud.getColor(pointCounter)[2] = val8b;
} else if (a == indexG && attributeInfo.byteCount == 1) { } else if (a == indexG && attributeInfo.byteCount == 1) {
auto& color = cloud.getColor(pointCounter); uint8_t val8b;
ifs.read(reinterpret_cast<char*>(&color[0]), sizeof(uint8_t)); ifs.read(reinterpret_cast<char*>(&val8b), sizeof(uint8_t));
cloud.getColor(pointCounter)[0] = val8b;
} else if (a == indexB && attributeInfo.byteCount == 1) { } else if (a == indexB && attributeInfo.byteCount == 1) {
auto& color = cloud.getColor(pointCounter);