Since the codec can only code integer positions, using Vec3<double> for
position data requires repeated inefficient format conversions.  This
commit changes the internal representation to Vec3<int32_t>.

For consistency with the upcoming change to the pointcloud position
data type, this commit changes the trisoup coding to internally
use int32_t rather than uint32_t.

This makes Vec3<T> perform more like the usual arithmetic types, in
order to avoid having to explicitly perform element wise conversions
when two Vec3<>s have different numeric types.

For instance:
  _i = int16_t() + int()                // typeof(_i) == int
  vi = Vec3<int16_t>() + Vec3<int>()    // typeof(vi) == Vec3<int>

  _d = 1 + 2.0                          // typeof(_d) == double
  vd = Vec3<int>(1) + Vec3<double>(2.0) // typeof(vd) == Vec3<double>

  vi = Vec3<int>(Vec3<double>())        // typeof(vi) == Vec3<int>
  vd = Vec3<double>(Vec3<int>())        // typeof(vd) == Vec3<double>

Be aware, however, that the usual implicit conversions can result
in a loss of precision:

        int _i = 1 + 1.5                          // _i == 2;
  Vec3<int> vi = Vec3<int>(1) + Vec3<double>(1.5) // vi == Vec3<int>(2)

Xiang Zhang authored Jun 10, 2019 and David Flynn committed Nov 21, 2019

This adoption permits coding geometry with non-cubic bounding boxes.
Since the depth of the tree remains constant for cubic and non-cubic
bounding boxes with identical largest dimensions, quad-tree and
binary-tree partitions are introduced to avoid coding 'fractional'
positions.

The following configuration options control the placement of non-octree
partitions within the coding tree:

 --max_num_implicit_qtbt_before_ot
 --min_implicit_qtbt_size_log2

None of these methods need to be inlined.

Satoru KUMA authored May 31, 2019 and David Flynn committed Nov 21, 2019

This provides a means to achieve spatial scalability for a G-PCC
bitstream.  For bitstreams encoded with aps_scalable_enabled_flag set,
the decoder may partially decode the geometry octree
(minGeomNodeSizeLog2) and the corresponding point attributes.  The
functionality is achieved by constraining the LoD generation process to
align with partial geometry decoding.

This is part of a series attempting to remove unhelpful typedefs.

The old typedefs (PCCVector3D, PCCPoint3D, PCCColor3B) are retained for
compatibility, but marked as deprecated.

This is part of a series attempting to remove unhelpful typedefs.

Ohji Nakagami authored Feb 08, 2019 and David Flynn committed Feb 08, 2019

There should only be 41 entries, not 50 entries in the atan2 lookup
table used by trisoup.

Ohji Nakagami authored Feb 04, 2019 and David Flynn committed Feb 05, 2019

This commit provides an integer approximation of atan2().

Ohji Nakagami authored Nov 26, 2018 and David Flynn committed Feb 05, 2019

This replaces the previous floating point version.  The number of
fractional bits is set to 8, allowing 24bit (unsigned) geometry
to be represented in 32bit calculations with negligible effects
on the reconstruction.

This commit provides trisoup_node_size_log2 as a replacement for
the following HLS syntax variables:
 - geom_codec_type (redundant wrt. triangle node size derivation)
 - trisoup_depth (redundant wrt. bounding box)
 - trisoup_triangle_level (semantics simplified)

The following config options have been removed:
 - geometryCodec (redundant wrt. trisoup_node_size_log2)
 - triSoupLevel  (replaced by trisoup_node_size_log2)
 - triSoupDepth  (unnecessary)
 - triSoupIntToOrigScale (redundant wrt. positionQuantizationScale)

This commit adds an arithmetic codec interface class that allows a
compile time choice of arithmetic codec implementation.  Context types
are renamed to support compile time selection, and existing support
functions that were added to the third-party arithmetic codec are
moved to the wrapper.

Ohji Nakagami authored Aug 07, 2018 and David Flynn committed Nov 01, 2018

This commit uses a direct intersection check between the trisoup
triangles and point cloud unit vectors.  This avoids the need to
upsample the triangles with dense sampling and then performing
voxelisation.

Philip A. Chou authored Jul 19, 2018 and David Flynn committed Nov 01, 2018

This commit integrates a c++ trisoup codec, replacing the previous matlab
implementation.

The provided code has been reworked to avoid duplicating code, dead code,
and operate with the current HLS.