This commit fixes an error in the geometry scaling, resulting in
an incorrect reconstructed point (used for attribute coding) when
qP > 10, and node-based quantisation is used.

Avoids testing undefined APS parameters by using the HLS signalling
order (and guards) to determine compatibility.

Rather than testing for the attribute encoding in various places in
order to determine the use of LoDs, use the derivation
lodParametersPresent instead.

The aps.search_range variable is required to build the nearest neighbour
predictors in attribute coding, even when scalable_lifting_enabled_flag
is set.  This commit partially reverts the adoption of m50745.

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.

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

This commit moves the non-normative inverse position scaling process
from the codec's reconstruction process into the ply writer.  This
is to support changing the internal point cloud position representation
to integer.

The result and computation types of Vec3<T>::getNorm2 were assumed to
be T.  This works fine for floating point types, but leads to overflow
when the underlying vector is Vec3<int32_t>.  This commit requires the
caller to supply the result of the computation type as a template
parameter to getNorm2.

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)

This commit works around an issue in gcc-5 where template friends
do not grant friendship.

Hyejung Hur authored Nov 13, 2019 and David Flynn committed Nov 21, 2019

This commit enables sharing of LoDs between attributes of the same
slice if certain preconditions are met.

This commit relocates the LoD state into an AttributeLoDs class in
order to enable reusing the LoD data between multiple attributes
within the same slice.

In order to isolate the attribute coder from the rest of the codec,
this adds an interface along with factory methods to the attribute
codec.

Reducing the search range from 8 to 1 significantly reduces the time
spent recolouring.  The value of 1 seems to be a reasonable trade-off
between distortion and runtime.

Sebastien Lasserre authored Aug 24, 2019 and David Flynn committed Nov 21, 2019

This adoption permits IDCM nodes to signal either:
 - two unique points, or
 - a single position with an arbitrary number of duplicates

Sébastien Lasserre authored Jun 10, 2019 and David Flynn committed Nov 21, 2019

This commit introduces planar modes, in the three x,y, and directions,
as new representations of the geometry. Planar modes are activated at
eligible nodes through a planar mode activation flag coded in the
bitstream.  Extra syntax is added to the bitstream to indicate the
position of the plane associated with activated planar modes.

A local eligibility criteria avoids using planar modes in adverse
regions of the point cloud and thus avoiding worse compression
performance, particularly on dense point clouds.

This commit changes the representation of quantised points in the
encoder to be 'MSB' justified, as is the case in the decoder.
Quantised points now take the form "0bppppppqqq00" where p denotes
unquantised bits, q quantised bits, and 0 marks non coded bits.

The geometry quantisation assumed that octree nodes were cubes.  The
addition of qt/bt partitioning modes breaks this premise.  This commit
addresses the following:

 - Only the to-be-coded bits, which may differ for each component, are
   quantised, rather than quantising all bits according to the tree
   depth (which would result in quantising already coded bits).

 - The occupancy mask (determining the non-coded occupancy bits) must
   be recomputed for each node.  Since the effect of quantisation is
   to prune back each sub-tree from the leaves, some nodes that would
   have had qt/bt partitions will not be coded, leaving an unequal
   reconstruction.  The solution is to terminate the shorter leaves
   earlier and to recompute the partition.

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

Geometry quantisation introduced an extra field to the point cloud
to hold scaled positions (to be restored after geometry coding is
complete).  This had a side effect of causing significant memory
increases since it applied to every instance of the point cloud.

Since it is not necessary to store both quantised and scaled positions
separately, this commit removes the extra storage and uses a method
similar to the decoder to represent partially quantised positions.

The geometry tree nodes contain a position element (pos) that identifies
the spatial position of the node.  At internal nodes this node position
is the partial position of a point and may either be represented using
the magnitude of the decoded points, or the magnitude of the current
depth.

The first form equates to:
 nextPos = curPos | (xyz << currentNodeSize)

The second:
 nextPos = (curPos << 1) | xyz

Where xyz represents a position bit from the coded occupancy.

In order to use the first form to determine neighbour relationships,
curPos must be shifted down to represent position within the current
depth.  This repeated shifting, along with the introduction of
simultaneous quantised and unquantised positions becomes increasingly
difficult to follow when adding non-cubic nodes (via OtQtBt).

This commit switches the representation to the second form above,
eliminating various shifted forms and duplicate state.  A decoded
positions is inverse quantised when reaching a leaf node.

Xiang Zhang authored Aug 19, 2019 and David Flynn committed Nov 21, 2019

This extends the geometry based quantisation scheme to:
 - add a per-slice QP offset, and
 - permit uniform quantisation of the whole slice without
   requiring signalling of an additional node QP offset.

Per node QP offset signalling is disabled by setting
positionQuantisationOctreeDepth=-1

Xiang Zhang authored Aug 19, 2019 and David Flynn committed Nov 21, 2019

This introduces a quantization scheme into the octree coding process,
enables adaptive geometry quantization for different regions of the
point cloud.  This in-loop scheme is independent of the any quantisation
performed in non-normative pre-processing at the input to the encoder.

At a particular depth of the octree, the remaining (uncoded) position
bits of each point are quantised according to a per-node (or rather,
per-subtree) QP.  The QP itself is signalled as an offset to a base QP.

The following configuration parameters are added:
  positionQuantisationEnabled
  positionBaseQp
  positionQuantisationOctreeDepth

Noritaka Iguchi authored Sep 27, 2019 and David Flynn committed Nov 21, 2019

A per-slice region may be defined with a qp offset.  Points within
the region have an offset applied to the per-level QP.

Sehoon Yea authored Sep 25, 2019 and David Flynn committed Nov 21, 2019

This commit adds the lossless YCgCoR colour transform.
The CTC configuration is updated to use YCgCoR for lossless
attribute coding instead of inter-component prediction on
GBR (colourMatrix=0) data.

Some imput formats and colour spaces have a different bitdepth
for their chroma (non-primary) component.  This commit adds
support to signal their bitdepth as described by the codec
independent code points.

This commit enables signalling a colour matrix index using
cicp_matrix_coefficients_idx (ISO/IEC 23001-8 codec independent code
points).

It adds the following options that replace the existing colorTransform
option:

 - colourMatrix: The coded representation according to ISO/IEC 23001-8.

 - convertPlyColourspace: Enables conversion to/from RGB using the
   indicated matrix.

Configuration files are updated to use the new option and to
signal the identity matrix in the case of direct GBR coding.

Sehoon Yea authored Sep 25, 2019 and David Flynn committed Nov 21, 2019

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.

None of these methods need to be inlined.

Sehoon Yea authored Sep 25, 2019 and David Flynn committed Nov 21, 2019

This adoption permits prediction of residuals between components of
the same attribute, coding the residual resulting from this second
prediction.

The GBR coding order matches the description in ISO/IEC 23001-8 for
the identity matrix (MatrixCoefficients=0).