TMC3.cpp 22.4 KB
Newer Older
Khaled Mammou's avatar
TMC3v0  
Khaled Mammou committed
1
/* The copyright in this software is being made available under the BSD
David Flynn's avatar
David Flynn committed
2
3
4
 * Licence, included below.  This software may be subject to other third
 * party and contributor rights, including patent rights, and no such
 * rights are granted under this licence.
Khaled Mammou's avatar
TMC3v0  
Khaled Mammou committed
5
 *
David Flynn's avatar
David Flynn committed
6
 * Copyright (c) 2017-2018, ISO/IEC
Khaled Mammou's avatar
TMC3v0  
Khaled Mammou committed
7
8
9
10
11
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
David Flynn's avatar
David Flynn committed
12
13
14
15
16
17
18
19
20
21
 * * Redistributions of source code must retain the above copyright
 *   notice, this list of conditions and the following disclaimer.
 *
 * * Redistributions in binary form must reproduce the above copyright
 *   notice, this list of conditions and the following disclaimer in the
 *   documentation and/or other materials provided with the distribution.
 *
 * * Neither the name of the ISO/IEC nor the names of its contributors
 *   may be used to endorse or promote products derived from this
 *   software without specific prior written permission.
Khaled Mammou's avatar
TMC3v0  
Khaled Mammou committed
22
23
24
25
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
David Flynn's avatar
David Flynn committed
26
27
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
Khaled Mammou's avatar
TMC3v0  
Khaled Mammou committed
28
29
30
31
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
David Flynn's avatar
David Flynn committed
32
33
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
Khaled Mammou's avatar
TMC3v0  
Khaled Mammou committed
34
35
36
 */

#include "TMC3.h"
David Flynn's avatar
David Flynn committed
37
38
39
40
41

#include <memory>

#include "PCCTMC3Encoder.h"
#include "PCCTMC3Decoder.h"
42
#include "constants.h"
43
#include "program_options_lite.h"
44
#include "io_tlv.h"
45
#include "version.h"
Khaled Mammou's avatar
TMC3v0  
Khaled Mammou committed
46
47
48
49

using namespace std;
using namespace pcc;

50
51
52
53
54
//============================================================================

struct Parameters {
  bool isDecoder;

55
56
57
  // command line parsing should adjust dist2 values according to PQS
  bool positionQuantizationScaleAdjustsDist2;

58
59
60
  // output mode for ply writing (binary or ascii)
  bool outputBinaryPly;

61
62
63
  // when true, configure the encoder as if no attributes are specified
  bool disableAttributeCoding;

64
65
66
67
  std::string uncompressedDataPath;
  std::string compressedStreamPath;
  std::string reconstructedDataPath;

68
69
70
  // Filename for saving pre inverse scaled point cloud.
  std::string preInvScalePath;

71
72
73
74
75
  pcc::EncoderParams encoder;
  pcc::DecoderParams decoder;

  // todo(df): this should be per-attribute
  ColorTransform colorTransform;
76
77
78

  // todo(df): this should be per-attribute
  int reflectanceScale;
79
80
81
82
};

//============================================================================

83
84
85
int
main(int argc, char* argv[])
{
86
  cout << "MPEG PCC tmc3 version " << ::pcc::version << endl;
87

Khaled Mammou's avatar
TMC3v0  
Khaled Mammou committed
88
89
90
91
  Parameters params;
  if (!ParseParameters(argc, argv, params)) {
    return -1;
  }
92
93
94
95
96
97
98

  // Timers to count elapsed wall/user time
  pcc::chrono::Stopwatch<std::chrono::steady_clock> clock_wall;
  pcc::chrono::Stopwatch<pcc::chrono::utime_inc_children_clock> clock_user;

  clock_wall.start();

Khaled Mammou's avatar
TMC3v0  
Khaled Mammou committed
99
  int ret = 0;
100
  if (params.isDecoder) {
101
    ret = Decompress(params, clock_user);
102
103
  } else {
    ret = Compress(params, clock_user);
Khaled Mammou's avatar
TMC3v0  
Khaled Mammou committed
104
105
  }

106
107
108
109
110
111
112
113
  clock_wall.stop();

  using namespace std::chrono;
  auto total_wall = duration_cast<milliseconds>(clock_wall.count()).count();
  auto total_user = duration_cast<milliseconds>(clock_user.count()).count();
  std::cout << "Processing time (wall): " << total_wall / 1000.0 << " s\n";
  std::cout << "Processing time (user): " << total_user / 1000.0 << " s\n";

Khaled Mammou's avatar
TMC3v0  
Khaled Mammou committed
114
115
116
  return ret;
}

117
118
119
//---------------------------------------------------------------------------
// :: Command line / config parsing helpers

120
121
122
123
template<typename T>
static std::istream&
readUInt(std::istream& in, T& val)
{
124
125
126
127
128
129
  unsigned int tmp;
  in >> tmp;
  val = T(tmp);
  return in;
}

130
131
132
static std::istream&
operator>>(std::istream& in, ColorTransform& val)
{
133
134
135
  return readUInt(in, val);
}

136
namespace pcc {
137
static std::istream&
138
operator>>(std::istream& in, AttributeEncoding& val)
139
{
140
  return readUInt(in, val);
141
142
}
}  // namespace pcc
143
144

namespace pcc {
145
static std::ostream&
146
operator<<(std::ostream& out, const AttributeEncoding& val)
147
{
148
  switch (val) {
149
150
151
  case AttributeEncoding::kPredictingTransform: out << "0 (Pred)"; break;
  case AttributeEncoding::kRAHTransform: out << "1 (RAHT)"; break;
  case AttributeEncoding::kLiftingTransform: out << "2 (Lift)"; break;
152
153
  }
  return out;
154
155
}
}  // namespace pcc
156

157
158
159
//---------------------------------------------------------------------------
// :: Command line / config parsing

160
161
162
bool
ParseParameters(int argc, char* argv[], Parameters& params)
{
163
164
  namespace po = df::program_options_lite;

165
166
167
168
169
  struct {
    AttributeDescription desc;
    AttributeParameterSet aps;
  } params_attr;

170
171
172
173
174
175
176
177
178
179
180
181
182
  bool print_help = false;

  // a helper to set the attribute
  std::function<po::OptionFunc::Func> attribute_setter =
    [&](po::Options&, const std::string& name, po::ErrorReporter) {
      // copy the current state of parsed attribute parameters
      //
      // NB: this does not cause the default values of attr to be restored
      // for the next attribute block.  A side-effect of this is that the
      // following is allowed leading to attribute foo having both X=1 and
      // Y=2:
      //   "--attr.X=1 --attribute foo --attr.Y=2 --attribute foo"
      //
183
184
185
186
187
188
189
190
191
192
193
194
195
196

      // NB: insert returns any existing element
      const auto& it = params.encoder.attributeIdxMap.insert(
        {name, int(params.encoder.attributeIdxMap.size())});

      if (it.second) {
        params.encoder.sps.attributeSets.push_back(params_attr.desc);
        params.encoder.aps.push_back(params_attr.aps);
        return;
      }

      // update existing entry
      params.encoder.sps.attributeSets[it.first->second] = params_attr.desc;
      params.encoder.aps[it.first->second] = params_attr.aps;
197
198
    };

199
  /* clang-format off */
200
201
202
203
204
205
206
207
208
209
210
  // The definition of the program/config options, along with default values.
  //
  // NB: when updating the following tables:
  //      (a) please keep to 80-columns for easier reading at a glance,
  //      (b) do not vertically align values -- it breaks quickly
  //
  po::Options opts;
  opts.addOptions()
  ("help", print_help, false, "this help text")
  ("config,c", po::parseConfigFile, "configuration file name")

211
212
  (po::Section("General"))

213
  ("mode", params.isDecoder, false,
214
215
    "The encoding/decoding mode:\n"
    "  0: encode\n"
216
    "  1: decode")
217
218
219

  // i/o parameters
  ("reconstructedDataPath",
220
221
    params.reconstructedDataPath, {},
    "The ouput reconstructed pointcloud file path (decoder only)")
222
223

  ("uncompressedDataPath",
224
225
    params.uncompressedDataPath, {},
    "The input pointcloud file path")
226
227

  ("compressedStreamPath",
228
229
    params.compressedStreamPath, {},
    "The compressed bitstream path (encoder=output, decoder=input)")
230

231
  ("postRecolorPath",
232
    params.encoder.postRecolorPath, {},
233
    "Recolored pointcloud file path (encoder only)")
234
235

  ("preInvScalePath",
236
    params.preInvScalePath, {},
237
    "Pre inverse scaled pointcloud file path (decoder only)")
238

239
240
241
242
  ("outputBinaryPly",
    params.outputBinaryPly, false,
    "Output ply files using binary (or otherwise ascii) format")

243
  // general
244
  // todo(df): this should be per-attribute
245
  ("colorTransform",
246
247
248
249
    params.colorTransform, COLOR_TRANSFORM_RGB_TO_YCBCR,
    "The colour transform to be applied:\n"
    "  0: none\n"
    "  1: RGB to YCbCr (Rec.709)")
250

251
252
253
254
255
256
  // todo(df): this should be per-attribute
  ("hack.reflectanceScale",
    params.reflectanceScale, 1,
    "scale factor to be applied to reflectance "
    "pre encoding / post reconstruction")

257
258
  // NB: if adding decoder options, uncomment the Decoder section marker
  // (po::Section("Decoder"))
259
260
261

  (po::Section("Encoder"))

262
  ("positionQuantizationScale",
263
    params.encoder.sps.seq_source_geom_scale_factor, 1.f,
264
    "Scale factor to be applied to point positions during quantization process")
265

266
267
268
269
  ("positionQuantizationScaleAdjustsDist2",
    params.positionQuantizationScaleAdjustsDist2, false,
    "Scale dist2 values by squared positionQuantizationScale")

270
  ("mergeDuplicatedPoints",
271
    params.encoder.gps.geom_unique_points_flag, true,
272
    "Enables removal of duplicated points")
273

274
275
276
277
  ("disableAttributeCoding",
    params.disableAttributeCoding, false,
    "Ignore attribute coding configuration")

278
  (po::Section("Geometry"))
279

280
  // tools
281
282
283
284
285
286
  ("bitwiseOccupancyCoding",
    params.encoder.gps.bitwise_occupancy_coding_flag, true,
    "Selects between bitwise and bytewise occupancy coding:\n"
    "  0: bytewise\n"
    "  1: bitwise")

287
  ("neighbourContextRestriction",
288
    params.encoder.gps.neighbour_context_restriction_flag, false,
289
    "Limit geometry octree occupancy contextualisation to sibling nodes")
290

291
  ("neighbourAvailBoundaryLog2",
292
    params.encoder.gps.neighbour_avail_boundary_log2, 0,
293
294
295
    "Defines the avaliability volume for neighbour occupancy lookups."
    " 0: unconstrained")

296
  ("inferredDirectCodingMode",
297
    params.encoder.gps.inferred_direct_coding_mode_enabled_flag, true,
298
    "Permits early termination of the geometry octree for isolated points")
299

300
301
302
303
  ("intra_pred_max_node_size_log2",
    params.encoder.gps.intra_pred_max_node_size_log2, 0,
    "octree nodesizes eligible for occupancy intra prediction")

304
305
306
307
  ("ctxOccupancyReductionFactor",
     params.encoder.gps.geom_occupancy_ctx_reduction_factor, 3,
     "Adjusts the number of contexts used in occupancy coding")

308
309
310
311
  ("trisoup_node_size_log2",
    params.encoder.gps.trisoup_node_size_log2, 0,
    "Size of nodes for surface triangulation.\n"
    "  0: disabled\n")
312

313
314
  (po::Section("Attributes"))

315
316
317
  // attribute processing
  //   NB: Attribute options are special in the way they are applied (see above)
  ("attribute",
318
319
320
    attribute_setter,
    "Encode the given attribute (NB, must appear after the"
    "following attribute parameters)")
321

322
323
324
325
  ("bitdepth",
    params_attr.desc.attr_bitdepth, 8,
    "Attribute bitdepth")

326
  ("transformType",
327
    params_attr.aps.attr_encoding, AttributeEncoding::kPredictingTransform,
328
    "Coding method to use for attribute:\n"
329
    "  0: Hierarchical neighbourhood prediction\n"
330
    "  1: Region Adaptive Hierarchical Transform (RAHT)\n"
331
    "  2: Hierarichical neighbourhood prediction as lifting transform")
332

333
  ("rahtLeafDecimationDepth",
334
    params_attr.aps.raht_binary_level_threshold, 3,
335
336
    "Sets coefficients to zero in the bottom n levels of RAHT tree. "
    "Used for chroma-subsampling in attribute=color only.")
337

338
  ("rahtQuantizationStep",
339
    params_attr.aps.quant_step_size_luma, 0,
340
    "deprecated -- use quantizationStepsLuma")
341
342

  ("rahtDepth",
343
    params_attr.aps.raht_depth, 21,
344
345
    "Number of bits for morton representation of an RAHT co-ordinate"
    "component")
346

347
  ("numberOfNearestNeighborsInPrediction",
348
    params_attr.aps.num_pred_nearest_neighbours, 3,
349
    "Attribute's maximum number of nearest neighbors to be used for prediction")
350

351
352
353
354
355
356
  ("adaptivePredictionThreshold",
    params_attr.aps.adaptive_prediction_threshold, -1,
    "Neighbouring attribute value difference that enables choice of "
    "single|multi predictors. Applies to transformType=2 only.\n"
    "  -1: auto = 2**(bitdepth-2)")

357
358
359
360
  ("attributeSearchRange",
    params_attr.aps.search_range, 128,
    "Range for nearest neighbor search")

361
362
363
364
365
  ("max_num_direct_predictors",
    params_attr.aps.max_num_direct_predictors, 3,
    "Maximum number of nearest neighbour candidates used in direct"
    "attribute prediction")

366
  ("levelOfDetailCount",
367
    params_attr.aps.num_detail_levels, 1,
368
    "Attribute's number of levels of detail")
369

370
371
372
  ("quantizationStepLuma",
    params_attr.aps.quant_step_size_luma, 0,
    "Attribute's luma quantization step size")
373

374
375
376
  ("quantizationStepChroma",
    params_attr.aps.quant_step_size_chroma, 0,
    "Attribute's chroma quantization step size")
377

378
379
  ("dist2",
    params_attr.aps.dist2, {},
380
381
    "Attribute's list of squared distances, or initial value for automatic"
    "derivation")
382
  ;
383
  /* clang-format on */
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398

  po::setDefaults(opts);
  po::ErrorReporter err;
  const list<const char*>& argv_unhandled =
    po::scanArgv(opts, argc, (const char**)argv, err);

  for (const auto arg : argv_unhandled) {
    err.warn() << "Unhandled argument ignored: " << arg << "\n";
  }

  if (argc == 1 || print_help) {
    po::doHelp(std::cout, opts, 78);
    return false;
  }

399
400
  // Certain coding modes are not available when trisoup is enabled.
  // Disable them, and warn if set (they may be set as defaults).
401
  if (params.encoder.gps.trisoup_node_size_log2 > 0) {
402
403
404
405
406
407
408
409
410
411
    if (!params.encoder.gps.geom_unique_points_flag)
      err.warn() << "TriSoup geometry does not preserve duplicated points\n";

    if (params.encoder.gps.inferred_direct_coding_mode_enabled_flag)
      err.warn() << "TriSoup geometry is incompatable with IDCM\n";

    params.encoder.gps.geom_unique_points_flag = true;
    params.encoder.gps.inferred_direct_coding_mode_enabled_flag = false;
  }

412
413
414
415
416
417
418
  // support disabling attribute coding (simplifies configuration)
  if (params.disableAttributeCoding) {
    params.encoder.attributeIdxMap.clear();
    params.encoder.sps.attributeSets.clear();
    params.encoder.aps.clear();
  }

419
  // fixup any per-attribute settings
420
  for (const auto& it : params.encoder.attributeIdxMap) {
421
    auto& attr_sps = params.encoder.sps.attributeSets[it.second];
422
423
    auto& attr_aps = params.encoder.aps[it.second];

424
425
426
427
428
    // Avoid wasting bits signalling chroma quant step size for reflectance
    if (it.first == "reflectance") {
      attr_aps.quant_step_size_chroma = 0;
    }

429
430
431
432
433
434
    bool isLifting =
      attr_aps.attr_encoding == AttributeEncoding::kPredictingTransform
      || attr_aps.attr_encoding == AttributeEncoding::kLiftingTransform;

    // derive the dist2 values based on an initial value
    if (isLifting && !attr_aps.dist2.empty()) {
435
436
      if (attr_aps.dist2.size() < attr_aps.num_detail_levels) {
        attr_aps.dist2.resize(attr_aps.num_detail_levels);
437
438
        const double distRatio = 4.0;
        uint64_t d2 = attr_aps.dist2[0];
439
440
        for (int i = 0; i < attr_aps.num_detail_levels; ++i) {
          attr_aps.dist2[i] = d2;
441
442
443
444
445
          d2 = uint64_t(std::round(distRatio * d2));
        }
      }
    }

446
447
448
449
450
451
452
453
454
455
456
    // In order to simplify specification of dist2 values, which are
    // depending on the scale of the coded point cloud, the following
    // adjust the dist2 values according to PQS.  The user need only
    // specify the unquantised PQS value.
    if (params.positionQuantizationScaleAdjustsDist2) {
      double pqs = params.encoder.sps.seq_source_geom_scale_factor;
      double pqs2 = pqs * pqs;
      for (auto& dist2 : attr_aps.dist2)
        dist2 = int64_t(std::round(pqs2 * dist2));
    }

457
458
459
460
461
462
463
464
465
466
467
    // Set default threshold based on bitdepth
    if (attr_aps.adaptive_prediction_threshold == -1) {
      attr_aps.adaptive_prediction_threshold = 1
        << (attr_sps.attr_bitdepth - 2);
    }

    if (attr_aps.attr_encoding == AttributeEncoding::kLiftingTransform) {
      attr_aps.adaptive_prediction_threshold = 0;
    }

    // For RAHT, ensure that the unused lod count = 0 (prevents mishaps)
468
    if (attr_aps.attr_encoding == AttributeEncoding::kRAHTransform) {
469
      attr_aps.num_detail_levels = 0;
470
      attr_aps.adaptive_prediction_threshold = 0;
471
472
473

      // todo(df): suggest chroma quant_step_size for raht
      attr_aps.quant_step_size_chroma = 0;
474
475
476
    }
  }

477
  // sanity checks
478
479
480
481
482
483

  if (params.encoder.gps.intra_pred_max_node_size_log2)
    if (!params.encoder.gps.neighbour_avail_boundary_log2)
      err.error() << "Geometry intra prediction requires finite"
                     "neighbour_avail_boundary_log2\n";

484
485
486
487
488
489
490
491
  for (const auto& it : params.encoder.attributeIdxMap) {
    const auto& attr_sps = params.encoder.sps.attributeSets[it.second];
    const auto& attr_aps = params.encoder.aps[it.second];

    bool isLifting =
      attr_aps.attr_encoding == AttributeEncoding::kPredictingTransform
      || attr_aps.attr_encoding == AttributeEncoding::kLiftingTransform;

492
493
494
495
496
497
498
499
500
501
502
    if (it.first == "color") {
      // todo(??): permit relaxing of the following constraint
      if (attr_sps.attr_bitdepth > 8)
        err.error() << it.first << ".bitdepth must be less than 9\n";
    }

    if (it.first == "reflectance") {
      if (attr_sps.attr_bitdepth > 16)
        err.error() << it.first << ".bitdepth must be less than 17\n";
    }

503
    if (isLifting) {
504
      int lod = attr_aps.num_detail_levels;
505

506
      if (lod > 255 || lod < 1) {
507
        err.error() << it.first
508
                    << ".levelOfDetailCount must be in the range [1,255]\n";
509
      }
510
511
      if (attr_aps.dist2.size() != lod) {
        err.error() << it.first << ".dist2 does not have " << lod
512
                    << " entries\n";
513
      }
514

515
516
517
518
519
      if (attr_aps.adaptive_prediction_threshold < 0) {
        err.error() << it.first
                    << ".adaptivePredictionThreshold must be positive\n";
      }

520
      if (
521
        attr_aps.num_pred_nearest_neighbours
522
        > kAttributePredictionMaxNeighbourCount) {
523
524
        err.error() << it.first
                    << ".numberOfNearestNeighborsInPrediction must be <= "
525
                    << kAttributePredictionMaxNeighbourCount << "\n";
526
      }
527
    }
Khaled Mammou's avatar
TMC3v0  
Khaled Mammou committed
528
529
  }

530
531
  // check required arguments are specified

532
  if (!params.isDecoder && params.uncompressedDataPath.empty())
533
534
    err.error() << "uncompressedDataPath not set\n";

535
  if (params.isDecoder && params.reconstructedDataPath.empty())
536
537
538
539
540
541
542
543
544
545
    err.error() << "reconstructedDataPath not set\n";

  if (params.compressedStreamPath.empty())
    err.error() << "compressedStreamPath not set\n";

  // report the current configuration (only in the absence of errors so
  // that errors/warnings are more obvious and in the same place).
  if (err.is_errored)
    return false;

546
547
  // Dump the complete derived configuration
  cout << "+ Effective configuration parameters\n";
548

549
  po::dumpCfg(cout, opts, "General", 4);
550
  if (params.isDecoder) {
551
    po::dumpCfg(cout, opts, "Decoder", 4);
552
  } else {
553
554
555
    po::dumpCfg(cout, opts, "Encoder", 4);
    po::dumpCfg(cout, opts, "Geometry", 4);

556
    for (const auto& it : params.encoder.attributeIdxMap) {
557
      // NB: when dumping the config, opts references params_attr
558
559
      params_attr.desc = params.encoder.sps.attributeSets[it.second];
      params_attr.aps = params.encoder.aps[it.second];
560
561
562
      cout << "    " << it.first << "\n";
      po::dumpCfg(cout, opts, "Attributes", 8);
    }
Khaled Mammou's avatar
TMC3v0  
Khaled Mammou committed
563
564
  }

565
566
  cout << endl;

Khaled Mammou's avatar
TMC3v0  
Khaled Mammou committed
567
568
  return true;
}
569

570
int
571
Compress(Parameters& params, Stopwatch& clock)
572
{
Khaled Mammou's avatar
TMC3v0  
Khaled Mammou committed
573
  PCCPointSet3 pointCloud;
574
575
576
  if (
    !pointCloud.read(params.uncompressedDataPath)
    || pointCloud.getPointCount() == 0) {
Khaled Mammou's avatar
TMC3v0  
Khaled Mammou committed
577
578
579
580
    cout << "Error: can't open input file!" << endl;
    return -1;
  }

581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
  // Sanitise the input point cloud
  // todo(df): remove the following with generic handling of properties
  bool codeColour = params.encoder.attributeIdxMap.count("color");
  if (!codeColour)
    pointCloud.removeColors();
  assert(codeColour == pointCloud.hasColors());

  bool codeReflectance = params.encoder.attributeIdxMap.count("reflectance");
  if (!codeReflectance)
    pointCloud.removeReflectances();
  assert(codeReflectance == pointCloud.hasReflectances());

  ofstream fout(params.compressedStreamPath, ios::binary);
  if (!fout.is_open()) {
    return -1;
  }

598
599
  clock.start();

Khaled Mammou's avatar
TMC3v0  
Khaled Mammou committed
600
601
602
  if (params.colorTransform == COLOR_TRANSFORM_RGB_TO_YCBCR) {
    pointCloud.convertRGBToYUV();
  }
603
604
605
606
607
608
609
610
611

  if (params.reflectanceScale > 1 && pointCloud.hasReflectances()) {
    const auto pointCount = pointCloud.getPointCount();
    for (size_t i = 0; i < pointCount; ++i) {
      int val = pointCloud.getReflectance(i) / params.reflectanceScale;
      pointCloud.setReflectance(i, val);
    }
  }

Khaled Mammou's avatar
TMC3v0  
Khaled Mammou committed
612
613
  PCCTMC3Encoder3 encoder;

614
615
  // The reconstructed point cloud
  std::unique_ptr<PCCPointSet3> reconPointCloud;
Khaled Mammou's avatar
TMC3v0  
Khaled Mammou committed
616
  if (!params.reconstructedDataPath.empty()) {
617
    reconPointCloud.reset(new PCCPointSet3);
Khaled Mammou's avatar
TMC3v0  
Khaled Mammou committed
618
619
  }

620
  int ret = encoder.compress(
621
622
    pointCloud, &params.encoder,
    [&](const PayloadBuffer& buf) { writeTlv(buf, fout); },
623
    reconPointCloud.get());
624
  if (ret) {
Khaled Mammou's avatar
TMC3v0  
Khaled Mammou committed
625
626
627
    cout << "Error: can't compress point cloud!" << endl;
    return -1;
  }
628

629
  std::cout << "Total bitstream size " << fout.tellp() << " B" << std::endl;
Khaled Mammou's avatar
TMC3v0  
Khaled Mammou committed
630
631
  fout.close();

632
633
  clock.stop();

Khaled Mammou's avatar
TMC3v0  
Khaled Mammou committed
634
635
  if (!params.reconstructedDataPath.empty()) {
    if (params.colorTransform == COLOR_TRANSFORM_RGB_TO_YCBCR) {
636
637
638
639
640
641
642
643
644
      reconPointCloud->convertYUVToRGB();
    }

    if (params.reflectanceScale > 1 && reconPointCloud->hasReflectances()) {
      const auto pointCount = reconPointCloud->getPointCount();
      for (size_t i = 0; i < pointCount; ++i) {
        int val = reconPointCloud->getReflectance(i) * params.reflectanceScale;
        reconPointCloud->setReflectance(i, val);
      }
Khaled Mammou's avatar
TMC3v0  
Khaled Mammou committed
645
    }
646

647
648
    reconPointCloud->write(
      params.reconstructedDataPath, !params.outputBinaryPly);
Khaled Mammou's avatar
TMC3v0  
Khaled Mammou committed
649
650
651
652
  }

  return 0;
}
653
int
654
Decompress(Parameters& params, Stopwatch& clock)
655
{
Khaled Mammou's avatar
TMC3v0  
Khaled Mammou committed
656
657
658
659
660
  ifstream fin(params.compressedStreamPath, ios::binary);
  if (!fin.is_open()) {
    return -1;
  }

661
662
  clock.start();

663
  PayloadBuffer buf;
Khaled Mammou's avatar
TMC3v0  
Khaled Mammou committed
664
  PCCTMC3Decoder3 decoder;
665

666
667
668
  while (true) {
    PayloadBuffer* buf_ptr = &buf;
    readTlv(fin, &buf);
Khaled Mammou's avatar
TMC3v0  
Khaled Mammou committed
669

670
671
672
    // at end of file (or other error), flush decoder
    if (!fin)
      buf_ptr = nullptr;
Khaled Mammou's avatar
TMC3v0  
Khaled Mammou committed
673

674
675
676
    int ret = decoder.decompress(
      params.decoder, buf_ptr, [&](const PCCPointSet3& decodedPointCloud) {
        PCCPointSet3 pointCloud(decodedPointCloud);
677

678
679
680
681
        if (params.colorTransform == COLOR_TRANSFORM_RGB_TO_YCBCR) {
          pointCloud.convertYUVToRGB();
        }

682
683
684
685
686
687
688
689
        if (params.reflectanceScale > 1 && pointCloud.hasReflectances()) {
          const auto pointCount = pointCloud.getPointCount();
          for (size_t i = 0; i < pointCount; ++i) {
            int val = pointCloud.getReflectance(i) * params.reflectanceScale;
            pointCloud.setReflectance(i, val);
          }
        }

690
691
        // Dump the decoded colour using the pre inverse scaled geometry
        if (!params.preInvScalePath.empty()) {
692
          pointCloud.write(params.preInvScalePath, !params.outputBinaryPly);
693
694
        }

695
        decoder.inverseQuantization(pointCloud);
696
697
698

        clock.stop();

699
700
        if (!pointCloud.write(
              params.reconstructedDataPath, !params.outputBinaryPly)) {
701
702
703
704
705
706
707
708
709
710
711
712
713
          cout << "Error: can't open output file!" << endl;
        }

        clock.start();
      });

    if (ret) {
      cout << "Error: can't decompress point cloud!" << endl;
      return -1;
    }

    if (!buf_ptr)
      break;
Khaled Mammou's avatar
TMC3v0  
Khaled Mammou committed
714
  }
715

716
717
718
719
720
721
  fin.clear();
  fin.seekg(0, ios_base::end);
  std::cout << "Total bitstream size " << fin.tellg() << " B" << std::endl;

  clock.stop();

Khaled Mammou's avatar
TMC3v0  
Khaled Mammou committed
722
723
  return 0;
}