1. 21 Nov, 2019 39 commits
• ply: perform inverse scaling during ply writing · 9f898950
David Flynn authored
```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.```
• maths: be explicit in the computation type of Vec3::getNorm2 + friends · ee064ec9
David Flynn authored
```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.```
• maths: allow the usual numeric conversions between Vec3<T> and Vec3<U> · 52848dbf
David Flynn authored
```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)```
• maths: use operator[] in Vec3<> arithmetic operators · 6dcd6f29
David Flynn authored
```This commit works around an issue in gcc-5 where template friends
do not grant friendship.```
• attr/m51092: reuse lods between attributes of same slice · 0eab32df
Hyejung Hur authored and David Flynn committed
```This commit enables sharing of LoDs between attributes of the same
slice if certain preconditions are met.```
• attr: refactor lod representation to be member of attribute codec · 4a73572f
David Flynn authored
```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.```
• attr: use interface to hide attribute codec internals · f0eedcdb
David Flynn authored
```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.```
• remove inappropriate copy constructors · b12db69c
David Flynn authored
• recolour/m51510: reduce default search range to 1 · 574ceff8
David Flynn authored
```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.```
• cfg/m51008: update dist2 parameter for cat1 sequences · 11dd54b1
Zhenzhen Gao authored and David Flynn committed
• geom/m48905: permit more than one duplicate point in IDCM nodes · 4f17624e
Sebastien Lasserre authored and David Flynn committed
```This adoption permits IDCM nodes to signal either:
- two unique points, or
- a single position with an arbitrary number of duplicates```
• geom/m48906: planar mode coding of octree occupancy · 2c74c097
Sebastien Lasserre authored and David Flynn committed
```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.```
• geom: unify encoder and decoder internal point representation · 8bed893b
David Flynn authored
```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.```
• geom: fix interaction of qtbt and octree geometry quantisation · 8f3fd506
David Flynn authored
```The geometry quantisation assumed that octree nodes were cubes.  The
addition of qt/bt partitioning modes breaks this premise.  This commit

- 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.```
• geom/m49231: add support for non-cubic nodes with implicit qtbt · 667f9209
Xiang Zhang authored and David Flynn committed
```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```
• geom: remove reconstructed position data from PCCPointSet3 · e156f8aa
David Flynn authored
```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.```
• geom: use single level based tree position representation · a8e8d3e6
David Flynn authored
```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

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.```
• geom/m50927: slice-based geometry quantization · 220acf28
Xiang Zhang authored and David Flynn committed
```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```
• geom/m49232: octree node geometry quantisation · 4d0d1e66
Xiang Zhang authored and David Flynn committed
```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```
• attr/m49626: add region-wise quantization support for LoD coding · 6b18730b
Noritaka Iguchi authored and David Flynn committed
```A per-slice region may be defined with a qp offset.  Points within
the region have an offset applied to the per-level QP.```
• attr/m49601: add YCgCoR colour transform support · 1654a45d
Sehoon Yea authored and David Flynn committed
```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.```
• attr/m49601: add support to signal chroma (secondary) bitdepth · 20d66c65
David Flynn authored
```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.```
• attr: refactor colourspace conversion to support other formats · a8f27566
David Flynn authored
```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.```
• attr/m49601: use attr_t (uint16_t) for all attributes · f5e788ec
Sehoon Yea authored and David Flynn committed
```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.```
• refactor: move pointset processing functions to compilation unit · d0e2ec04
David Flynn authored
`None of these methods need to be inlined.`
• attr/m49605: add inter component prediction for predicting coder · 0a90edeb
Sehoon Yea authored and David Flynn committed
```This adoption permits prediction of residuals between components of
the same attribute, coding the residual resulting from this second
prediction.```
• attr: change RGB coding order to GBR · c963fede
David Flynn authored
```The GBR coding order matches the description in ISO/IEC 23001-8 for
the identity matrix (MatrixCoefficients=0).```
• attr/m48894: introduce neighbour bias LoD predictor construction · 9d34012b
Yiting Shao authored and David Flynn committed
```This adoption allows determining the weights of each point's
predicting neighbours with a reduced influence of the, for
instance, z component.```
• attr/m50669: adjust context derivation for zerorun · a96dda0c
ChenJiafeng authored and David Flynn committed
```This adoption implements a different context selection method for the
isOne syntax element in attribute coding.```
• hls/m51027: signal geometry axis order · d96e5851
David Flynn authored
```This adoption permits encoding the geometry positions in an order other
than {x,y,z}.  The --geometry_axis_order option causes the encoder to
load data from the ply file in a different order.  The order is
signalled in the SPS and the decoder will label the output axis as
appropriate.```
• ply: move ply io methods to separate compilation unit · 31d57093
David Flynn authored
`This commit migrates PCCPointSet3::read and write to ply::read and write.`
• cli: add support for encoding pointcloud sequences · ef9b47b9
David Flynn authored and David Flynn committed
```This commit enables the codec to encapsulate more than one frame in the
coded bitstream.  The number of frames to encode is controlled by the
frameCount option.

Support is added to encode multiple source frames from separate ply
files based on a template input file name.  A printf-like "%d" directive
acts as a placeholder for the current frame number.

Decoding functions in a similar way with a each frame decoded from the
bitstream being written to a separate ply file named according to a
template pattern.

The first frame number used for file I/O may be set using the
• hls/m51025: support multi-frame sequences · 105120bd
David Flynn authored
```This adds:
- a frame_idx syntax element to every geometry slice header.
- (decoder) handling of a frame boundary data unit.

Frame boundaries are represented by changes in the value of frame_idx
or by the presence of a frame boundary data unit.```
• attr: don't specialise k=0 case in (de/en)codeColorsPred · 8c37a777
David Flynn authored
```This converts an unrolled loop (with special case for the initial
iteration) to the rolled up form in order to improve readability.```
• hls/m50745: avoid signalling variables in meaningless cases · f38332a3
David Flynn authored
```For the lifting scheme, some APS parameters are always signalled.
However, some syntax elements are not needed depending upon the values
of attr_coding_type and lifting_scalability_enabled_flag.  This adoption
avoids signalling unnecessary syntax elements in these cases.```
• release: update version to 7.1 · 047cc958
David Flynn authored
• attr: pass aps reference rather than use many arguments in calls · 41bc63dc
David Flynn authored
```This commit refactors calling the LoD generation routines to pass
the aps rather than a long list of syntax variables.```
• attr/m47352: permit partial geometry and attribute reconstruction · 10a4eb36
Satoru KUMA authored and David Flynn committed
```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.```
2. 12 Nov, 2019 1 commit