Method and apparatus for video coding using uniform segment split in pictures

Abstract

A method for decoding a picture from a bitstream. The picture comprising a number of units, and the picture being partitioned into a number of spatial segments by a partition structure. The method includes decoding one or more code words in the bitstream; determining that the partition structure is uniform based on the one or more code words; determining the number of spatial segments based on the one or more code words; determining a segment unit size; and deriving the sizes and/or locations for spatial segments in the picture from the one or more code words. Deriving the sizes and/or locations for spatial segments in the picture comprises a first loop over the number of spatial segments in a first dimension or direction. A number of remaining segment units in the first dimension or direction to be segmented is calculated inside the first loop.

Claims

1. A method for decoding a picture comprising a number of units from a bitstream, the picture being partitioned into a number of spatial segments by a partition structure, the number of spatial segments being greater than or equal to two, the method comprising: decoding one or more code words in the bitstream; determining that the partition structure is uniform based on the one or more code words; determining the number of spatial segments based on the one or more code words; determining a segment unit size; and deriving the sizes and/or locations for spatial segments in the picture from the one or more code words, wherein deriving the sizes and/or locations for spatial segments in the picture comprises a first loop over the number of spatial segments in a first dimension or direction, and a number of remaining segment units in the first dimension or direction to be segmented is calculated inside the first loop.

2. The method of claim 1, wherein the first loop over the number of spatial segments comprises a first loop over the number of spatial segments with size equal to a segment size in the first dimension or direction.

3. The method of claim 1, wherein deriving the sizes and/or locations further comprises a second loop over the number of spatial segments in a second dimension or direction other than the first dimension or direction, and a number of remaining segment units in the second dimension or direction to be segmented is calculated inside the second loop.

4. The method of claim 3, wherein a segment size in the first dimension or direction is a width of a segment in a row and a segment size in the second dimension or direction is a height of a segment in a column, or a segment size in the first dimension or direction is a height of a segment in a column and the segment size in the second dimension or direction is a width of a segment in a row.

5. The method of claim 3, wherein the second loop over the number of spatial segments comprises a second loop over the number of spatial segments with size equal to a segment size in the second dimension or direction.

6. The method of claim 3, wherein the first dimension or direction is a horizontal dimension or direction and the second dimension or direction is a vertical dimension or direction, or the first dimension or direction is a vertical dimension or direction and the second dimension or direction is a horizontal dimension or direction.

7. The method of claim 1, wherein the width of the segments in a row or the height of the segments in a column follows a specified order.

8. The method of claim 1, wherein the width of the segments in a row or the height of the segments in a column of a picture follows a specified default order for the width or height of the segments.

9. The method of claim 1, wherein the segment unit size is equal to the size of a coding tree unit.

10. The method of claim 1, wherein the segment unit size is larger than the size of a coding tree unit.

11. The method of claim 1, where a segment is a tile.

12. The method of claim 1, wherein the segments are independent with respect to other segments such that the derivation of any intra prediction mode for any unit in a current segment depends only on previously derived intra prediction modes in units that belong to the current segment and does not depend on any intra prediction mode in any unit that belongs to a different segment.

13. A method for encoding a picture comprising a number of units into a bitstream, the picture being partitioned into a number of spatial segments by a uniform partition structure, the number of spatial segments being greater than or equal to two, the method comprising: encoding the information that the partition structure is uniform by encoding one or more code words into the bitstream; encoding the number of spatial segments by encoding one or more code words into the bitstream; determining a segment unit size; and deriving and encoding the sizes and/or locations for spatial segments in the picture into the bitstream, wherein deriving the sizes and/or locations for spatial segments in the picture comprises a first loop over the number of spatial segments in a first dimension or direction, and a number of remaining segment units in the first dimension or direction to be segmented is calculated inside the first loop.

14. The method of claim 13, wherein the first loop over the number of spatial segments comprises a first loop over the number of spatial segments with size equal to a segment size in a first dimension or direction.

15. The method of claim 13, wherein deriving the sizes and/or locations comprises a second loop over the number of spatial segments in a second dimension or direction other than the first dimension or direction, and a number of remaining segment units in the second dimension or direction to be segmented is calculated inside the second loop.

16. The method of claim 15, wherein a segment size in the first dimension or direction is a width of a segment in a row and a segment size in the second dimension or direction is a height of a segment in a column, or a segment size in the first dimension or direction is a height of a segment in a column and a segment size in the second dimension or direction is a width of a segment in a row.

17. The method of claim 15, wherein the second loop over the number of spatial segments comprises a second loop over the number of spatial segments with size equal to a segment size in the second dimension or direction.

18. The method of claim 15, wherein the first dimension or direction is a horizontal dimension or direction and the second dimension or direction is a vertical dimension or direction, or the first dimension or direction is a vertical dimension or direction and the second dimension or direction is a horizontal dimension or direction.

19. The method of claim 13, where a segment is a tile.

20. A computer program product comprising a non-transitory computer readable medium storing a computer program comprising instructions which when executed by processing circuitry causes the processing circuitry to perform the method of claim 1.

21. A decoding apparatus for decoding a picture, the decoding apparatus comprising: a computer readable storage medium; and processing circuitry coupled to the computer readable storage medium, wherein the processing circuitry is configured to cause the decoding apparatus to perform the method of claim 1.

22. An encoding apparatus for encoding a picture, the encoding apparatus comprising: a computer readable storage medium; and processing circuitry coupled to the computer readable storage medium, wherein the processing circuitry is configured to cause the encoding apparatus to perform the method of claim 13.

Description

BRIEF DESCRIPTION OF THE DRAWINGS

(1) The accompanying drawings, which are incorporated herein and form part of the specification, illustrate various embodiments.

(2) FIG. 1 shows an example of tile partitioning according to one embodiment.

(3) FIG. 2A shows tile segmentation using HEVC tile partitioning—

(4) FIG. 2B shows tile segmentation using flexible tile splitting.

(5) FIG. 3 shows a picture of a video stream and exemplary partitioning.

(6) FIG. 4 shows a picture according to some embodiments.

(7) FIG. 5 shows a table according to some embodiments.

(8) FIG. 6 shows a table according to some embodiments.

(9) FIG. 7 is a flow chart illustrating a process according to an embodiment.

(10) FIG. 8 is a flow chart illustrating a process according to an embodiment.

(11) FIG. 9 is a diagram showing functional units of a decoder according to one embodiment.

(12) FIG. 10 is a diagram showing functional units of an encoder according to one embodiment.

(13) FIG. 11 is a block diagram of an apparatus according to some embodiments.

(14) FIG. 12 is a flow chart illustrating a process according to an embodiment.

DETAILED DESCRIPTION

(15) The following terminology has been used to describe the embodiments:

(16) The arithmetic operator “/” is used for integer division with truncation of the result toward zero. For example, 7/4 and −7/−4 are truncated to 1 and −7/4 and 7/−4 are truncated to −1.

(17) The arithmetic operator “÷” is used for division in mathematical equations where no truncation or rounding is intended.

(18) Ceil(x) gives the smallest integer greater than or equal to x.

(19) Floor(x) gives the largest integer less than or equal to x.

(20) The terms “tile column width” and “tile width” are used interchangeably which means embodiments can be applied when the tile column widths are being calculated in a tile grid or when the tile widths are being calculated individually (e.g. if there is no tile grid).

(21) The terms “tile row height” and “tile height” are used interchangeably which means the embodiments can be applied when the tile row heights are being calculated in a tile grid or when the tile heights are being calculated individually (e.g. if there is no tile grid).

(22) Embodiments for defining the width (and equivalently the height) of the tiles for uniform_spacing_flag=1 have the following four elements:

(23) (1) In the loop for defining the width of each tile, the width for the tile is defined using the available remaining unit sizes which means the number of unit sizes in the row which are not yet allocated to a tile.

(24) (2) The number of remaining unit sizes is then divided by the number of remaining tiles in the row.

(25) (3) The obtained tile size is rounded towards the larger or smaller integer (Ceil( ) or Floor( ) functions) according to the given rule for ordering the width of the tiles.

(26) (4) An optional element to recalculate the number of remaining unit sizes (e.g. CTUs) in every iteration of the loop for defining the width of each tile.

(27) The same elements apply to defining the height of the tiles.

(28) Embodiments disclosed herein describes a decoder method for decoding a picture 10 from a bitstream, the method comprising deriving the sizes and/or locations for segments in the picture (e.g., all segments in the picture) from the bitstream, wherein the picture 10 consists of a number of units 8 and a partition structure 13 partitions the picture into at least two segments 11 and the decoder determines that the spatial segmentation is uniform by decoding one or more code words in the bitstream, and the decoder determines the number of spatial segments by decoding one or more code words in the bitstream, and the decoder determines a tile unit size, and the partitioning of the segments to uniform widths or heights follows a fixed ripple pattern independent from the number of the spatial segments, and the derivation of the segment sizes is done in a loop over the number of segments, where inside the loop the number of remaining tile units to be segmented is calculated. The number of remaining segments may also be calculated inside the loop.

(29) In one example, an embodiment replaces the following HEVC lines:

(30) TABLE-US-00014 if( uniform_spacing_flag )  for( i = 0; i <= num_tile_columns_minus1; i++ )   colWidth[ i ] = ( ( i + 1 ) * PicWidthInCtbsY ) /   ( num_tile_columns_minus1 + 1 ) −    ( i * PicWidthInCtbsY ) / ( num tile columns minusi + 1 )
with the following lines:

(31) TABLE-US-00015 if( uniform_spacing_flag ){     A = PicWidthInCtbsY     B = num_tile_columns_minus1 + 1  for( i = 0; i <= num_tile_columns_minus1; i++ ){   colWidth[ i ] = Ceil( A ÷ B)      A -= colWidth[ i ]      B -= 1     }    }

(32) The proposed method also reduces complexity compared to HEVC and flexible tile split proposed in JVET-L0359. The proposed method has no multiplication and only 1 division per iteration for determining the widths of the tile columns and the heights of the tile rows, while the HEVC method uses 2 multiplications and 2 divisions per iteration.

Embodiment 1. Monotonic Ripple

(33) In an embodiment, the width of the segments in a row or the height of the segments in a column is never in ascending or never in descending order following a predefined scan direction. The segment may be a tile in a picture and so the tile sizes are monotonic (never ascending or never descending) in a scan direction. For example, for tile widths to be never ascending in the left to right scan direction means that the width of a tile is never larger than the width of another tile on the same row which is spatially located to the left of the first tile.

(34) In the first embodiment, for a never ascending tile column width (left to right scan direction) and tile row height (top to bottom scan direction) on top of HEVC, the following HEVC functions:

(35) TABLE-US-00016  if( uniform_spacing_flag )   for( i = 0; i <= num_tile_columns_minus1; i++ )    colWidth[ i ] = ( ( i + 1 ) * PicWidthInCtbsY ) /    ( num_tile_columns_minus1 + 1 ) −     ( i * PicWidthInCtbsY ) / ( num_tile_columns_minus1 + 1 ) and  if( uniform_spacing_flag )   for( j = 0; j <= num_tile_rows_minus1; j++ )    rowHeight[ j ] = ( ( j + 1 ) * PicHeightInCtbsY ) /    ( num_tile_rows_minus1 + 1 ) −     ( j * PicHeightInCtbsY ) / ( num_tile_rows_minus1 + 1 )
are replaced with the following functions:

(36) TABLE-US-00017  if( uniform_spacing_flag ) {     A = PicWidthInCtbsY     B = num_tile_columns_minus1 + 1   for( i = 0; i <= num_tile_columns_minus1; i++ ) {    colWidth[ i ] = Ceil( A ÷ B)      A -= colWidth[ i ]      B -= 1   }  } and  if( uniform_spacing_flag ) {     C = PicHeightInCtbsY     D = num_tile_rows_minus1 + 1   for( j = 0; j <= num_tile_rows_minus1; j++ ) {    rowHeight[ j ] = Ceil( C ÷ D)      C -= rowHeight [ j ]      D -= 1   }  }

(37) The resulting values in the colWidth and rowHeight lists are in units of luma coding tree block. If for instance the CTU size is equal to 128×128, the values are in units of 128 luma samples such that a value of 2 means 256 luma samples.

(38) The colWidth and rowHeight lists are then used by the decoder to determine the scan order of blocks in the picture. When block data is decoded, the spatial position of a block is based on the values in the colWidth and rowHeight lists. The decoder may construct conversion lists from tile scan addresses to raster scan addresses and the other way around using the values in colWidth and rowHeight. A decoder may then use the conversion lists during decoding to determine the spatial positions of blocks. In HEVC, conversion lists are used and called CtbAddrRsToTs and CtbAddrTsToRs.

(39) FIG. 6 shows table 600 which compares the tile size allocation for HEVC and the above exemplary implementation of the first embodiment. As shown in table 600, in one embodiment, the tile boundaries are kept the same as the original picture when tile columns are removed from the left or right or both sides of the picture. The rounding effect is governed to put the slightly wider tiles on the left side of the picture in all cases using the Ceil( ) function and recalculating the number of the remaining tile units in every iteration of the loop over tiles to determine tile column widths.

(40) Table 600 shows how the internal tile boundaries change after removing some tile columns from the original picture using HEVC uniform tile spacing while the internal tile boundaries are kept intact. The parameters for the original picture are set as follows: uniform_spacing_flag=1, PicWidthInCtbsY=10, num_tile_columns_minus1=3, num_tile_rows_minus1=1.

(41) Below is another example of the first embodiment, built on top of the equations proposed in JVET-L0359 which supports tile size granularities smaller than the CTU size. The following equation changes are proposed on top of JVET-L0359:

(42) TABLE-US-00018 if( uniform_spacing_flag ) {  A = PicWidthInTileUnitsY     B = num_tile_columns_minus1 + 1  for( i = 0; i <= num_tile_columns_minus1; i++ ) {   colWidth[ i ] = Ceil( A ÷ B)      A -= colWidth[ i ]      B -= 1     }    } where:  PicWidthInTileUnitsY = Ceil( pic_width_in_luma_samples ÷  TileUnitSizeY )
and equivalently for the tile row heights the following changes are proposed:

(43) TABLE-US-00019  if( uniform_spacing_flag ) {   C = PicHeightInTileUnitsY      D = num_tile_rows_minus1 + 1   for( j = 0; j <= num_tile_rows_minus1; j++ ) {    rowHeight[ j ] = Ceil( C ÷ D)       C -= rowHeight[ j ]       D -= 1      }     } where:    PicHeightInTileUnitsY = Ceil( pic_height_in_luma_samples ÷    TileUnitSizeY )

(44) The resulting values in the colWidth and rowHeight lists are in units of luma tile units. If for instance the tile unit size is equal to 32×32, the values are in units of 32 luma samples such that a value of 2 means 64 luma samples.

(45) Table 4 compares the results for the width of the tiles between JVET-L0359 and an embodiment for different picture widths values. The results for JVET-L0359 show inconsistency in the width of the tile columns (colWidth[i]) when the tile unit size changes while the embodiment provides consistent width of the tile columns (colWidth[i]) when the tile unit size changes as it consistently prioritizes the slightly larger tiles to be put on the left side of the picture.

(46) TABLE-US-00020 TABLE 4 Picture JVET-L0359 First Embodiment width Tile colWidth[ i ], colWidth[ i ], colWidth[ i ], colWidth[ i ], (in luma size i = 0, 1 i = 0, 1 i = 0, 1 i = 0, 1 samples) unit PicWidthInTileUnitsY (in tile unit size) (in luma samples) (in tile unit size) (in luma samples) 2160  32 Ceil(67.5) = 68 34, 34 1072, 1088 34, 34 1088, 1072 Smaller tile starts Larger tile starts the grid the grid  16 135 67, 68 1088, 1072 68, 67 1088, 1072 Larger tile starts Larger tile starts the grid the grid 1080  16 Ceil(67.5) = 68 34, 34 544, 536 34, 34 544, 536 Larger tile starts Larger tile starts the grid the grid  8 135 67, 68 536, 544 68, 67 544, 536 Smaller tile starts Larger tile starts the grid the grid  480 128 Ceil(3.75) = 4  2, 2 256, 224  2, 2 256, 224 Larger tile starts Larger tile starts the grid the grid  32 15  7, 8 224, 256  8, 7 256, 224 Smaller tile starts Larger tile starts the grid the grid

(47) Table 4 shows tile column width calculated when uniform_spacing_flag=1, num_tile_columns_minus1=1, using the flexible tile splitting as in JVET-L0359 compared with a first embodiment.

(48) In the first embodiment, a decoder may perform all or a subset of the following steps:

(49) 1. Decode information that one or more pictures are partitioned into more than one segment from one or more syntax elements in the bitstream. The syntax is preferably located in a picture parameter set. The syntax may specify a number R indicating the number of segment rows and a number C indicating the number of segment columns.

(50) 2. Decode information that the spatial segmentation is uniform from one or more syntax elements in the bitstream. The syntax is preferably located in a picture parameter set. The syntax may consist of a one-bit flag specifying whether the spatial segmentation is uniform or not.

(51) 3. Determine a segment unit size S either from one or more syntax elements or by using a predefined segment unit size. If a predefined unit size is used, it may be equal to the size of a CTU or the size of a CTU in one dimension. For instance, if the CTU size is equal to 128×128, the segment unit size S may be equal to 128 (or 128×128).

(52) 4. Calculate the size of the picture in number of segment units. The calculation may be done separate for the height and width of the picture such that the horizontal size (HS) is set equal to the picture width in luma samples divided by the segment unit size S. The vertical size (VS) may be set equal to the picture height in luma samples divided by the segment unit size.

(53) 5. Derive the width and heights of segments (e.g. all the segments) from the number of segments in the picture and the segment unit size S. The derivation is done in a loop over the number of segments where the number of segments yet to be segmented and the size of the picture yet to be segmented in number of segment units is updated in each iteration of the loop.

(54) The derivation may be done in two separate loops: a. Derive the segment column widths from the picture width in number of tile units and the number of segment columns C by the following substeps: i. Set the picture width yet to be segmented (A) equal to the value HS ii. Set the number of segment columns yet to be segmented (B) equal to the value C iii. Derive the column widths in a loop where one width value is derived per iteration and where the number of segment columns yet to be segmented (B) and the picture width yet to be segmented (A) are both updated in each iteration. The iteration may be executed C times. 1. The derived column width W may be set equal to Ceil(A÷B) 2. The variable A may then be updated to A−W and the variable B may be updated to B−1 b. Derive the segment row heights from the picture height in number of tile units and the number of segment rows R by the following substeps: i. Set the picture height yet to be segmented (A) equal to the value VS ii. Set the number of segment rows yet to be segmented (B) equal to the value R iii. Derive the row heights in a loop where one height value is derived per iteration and where the number of segment rows yet to be segmented (B) and the picture height yet to be segmented (A) are both updated in each iteration. The iteration may be executed R times. 1. The derived row height H may be set equal to Ceil(A÷B) 2. The variable A may then be updated to A−H and the variable B may be updated to B−1

(55) 6. Derive the spatial location for a current block using derived segment widths and derived segment heights.

(56) 7. Decode the current block using the derived spatial location. Store the decoded sample values for the current block in memory at memory positions corresponding to the derived spatial location.

(57) In a variant of this embodiment, the function Ceil( ) can be replaced by function Floor( ), in only horizontal, or only vertical or both directions.

(58) In a variant of this embodiment, a flag may choose between the two functions Ceil( ) and Floor( ). In some embodiments, there may be two independent flags for the horizontal and vertical directions.

Embodiment 2. Specified Order

(59) In the second embodiment, the width of the segments in a row or the height of the segments in a column follows a specified order. This specified order may be signaled in the bitstream using a template pattern in the form of a sequence of bits. Segments may be tiles in a picture and so in this embodiment, the shape of the preferred ripple on the tile sizes is specified. For example, all slightly wider tiles are in the left side of the picture. This may be done by a template pattern expressed in the form of a sequence of bits that specifies Ceil( ) or Floor( ) function in every iteration of the loop over tiles to specify the tile width (or height). Function Ceil( ) may be represented by 1 and function Floor( ) may be represented by 0 in the template bit sequence. As an example, template 110 would specify Ceil( ) function in the first two tiles and function Floor( ) in the third iteration of the loop for specifying the tile size. The pattern may be periodically repeated if the number of tiles is larger than the length of the template bit sequence.

Embodiment 3. Binary Tile Splits

(60) In the third embodiment, the binary segment split with an explicit ordering of the segment width or height is applied to the width or height of the picture. Segments may be tiles in a picture and so the binary partitioning is used for partitioning the picture into 2.sup.n tiles with uniform tile sizes. A predefined ripple pattern (as in the second embodiment) may be used in combination with this embodiment. The binary partitioning may carry on hierarchically until the algorithm reaches the specified number of segments or only up to a defined number of steps and the rest of the segment divisions being carried out by other methods. As an example, the total size is divided by 2 in a first step where it is specified to assign the smaller or larger segment to the left or right. In each of the subsequent steps, each of the left and right segments are divided into two parts using the next binary partitioning level and the specified rule for the position of possibly smaller or larger segment.

Embodiment 4. Default Ordering of the Ripple

(61) In the fourth embodiment, the width of the segments in a row or the height of the segments in a column of a picture follows a specified default order for the width or height of the segments. Segments may be tiles in a picture and so a default preferred ordering is defined for managing the ripples in the segment sizes. The default ripple pattern may be signaled in the bitstream. In a variant of this embodiment the default pattern may be overwritten. In another variant of this embodiment a flag can specify if the default ordering or another specified ordering is being used.

(62) FIG. 7 is a flow chart illustrating a process 700 according to an embodiment. Process 700 is a method for decoding a picture 10 comprising a number of units 8 from a bitstream, the picture being partitioned into at least two spatial segments 11 by a partition structure 13. Process 700 may begin in steps 710. Step 710 comprises decoding one or more code words in the bitstream. Steps 720 comprises determining that the partition structure is uniform based on the one or more code words. Step 730 comprises determining the number of spatial segments based on the one or more code words. Step 740 comprises determining a segment unit size. Step 750 comprises deriving the sizes and/or locations for spatial segments in the picture from the one or more code words. In one embodiment, deriving the sizes and/or locations for spatial segments in the picture comprises a first loop over the number of spatial segments in a first dimension or direction, and a number of remaining segment units in the first dimension or direction to be segmented is calculated inside the first loop. In some embodiments, a number of remaining segments in the first dimension is calculated inside the first loop.

(63) In some embodiments, the derivation of the segment sizes and/or locations comprises a second loop over the number of spatial segments in a second dimension or direction other than the first dimension or direction, and the number of remaining segment units in the second dimension or direction to be segmented is calculated inside the second loop. In some embodiments, a number of remaining segments in the second dimension or direction is calculated inside the second loop.

(64) In some embodiments, the first dimension or direction is a horizontal dimension or direction and the second dimension or direction is a vertical dimension or direction.

(65) In some embodiments, the width of the segments in a row or the height of the segments in a column follows a specified order.

(66) In some embodiments, the width of the segments in a row or the height of the segments in a column are in a never ascending or a never descending order.

(67) In some embodiments, a binary segment split with an explicit ordering of the segment width or height is applied to the width or height of the picture.

(68) In some embodiments, the width of the segments in a row or the height of the segments in a column of a picture follows a specified default order for the width or height of the segments.

(69) In some embodiments, the segment unit size is equal to the size of the coding tree unit (CTU).

(70) In some embodiments, the segment unit size is smaller than the size of the coding tree unit (CTU). In some embodiments, the segment unit size is larger than the size of the CTU. In some embodiments, a segment is a tile.

(71) In some embodiments, deriving the sizes comprises:

(72) deriving a list Sizes[ ] as:

(73) TABLE-US-00021 A = PicWidthInSegmentUnits B = NumberOfSegmentColumns for( i = 0; i < NumberOfSegmentColumns; i++ ) {  Sizes [ i ] = Round( A ÷ B)  A = A - Sizes[ i ]  B = B - I }

(74) where NumberOfSegmentColumns is the number of segment columns, PicWidthInSegmentUnits is the width of the picture in segment units, Round( ) is either the Floor( ) function or the Ceil( ) function, and ÷ is division without truncation or rounding.

(75) In some embodiments, deriving the sizes comprises:

(76) deriving a list Sizes[ ] as:

(77) TABLE-US-00022 A = PicHeightInSegmentUnits B = NumberOfSegmentRows for( i = 0; i < NumberOfSegmentRows; i++ ) {  Sizes [ i ] = Round( A ÷ B)  A = A - Sizes[ i ]  B = B - 1 }

(78) where NumberOfSegmentRows is the number of segment rows, PicHeightInSegmentUnits is the height of the picture in segment units, Round( ) is either the Floor( ) function or the Ceil( ) function, and ÷ is division without truncation or rounding.

(79) In some embodiments, the segments 11 are independent with respect to other segments 11 such that the derivation of any intra prediction mode for any unit 16 in a current segment 15 depends only on previously derived intra prediction modes in units 17 that belong to the current segment 15 and does not depend on any intra prediction mode in any unit 18 that belongs to a different segment 14.

(80) In some embodiments, the method includes a further step of partitioning the segments to uniform widths or heights follows a fixed ripple pattern independent from the number of the spatial segments.

(81) FIG. 8 is a flow chart illustrating a process 800 according to an embodiment. Process 800 is a method for encoding a picture 10 comprising a number of units 8 into a bitstream, the picture being partitioned into at least two spatial segments 11 by a uniform partition structure 13. The method includes encoding the information that the partition structure 13 is uniform by encoding one or more code words into the bitstream (step 810); encoding the number of spatial segments by encoding one or more code words into the bitstream (step 820); determining a segment unit size (step 830); and deriving and encoding the sizes and/or locations for all spatial segments in the picture into the bitstream (step 840), wherein the derivation of the segment sizes comprises a first loop over the number of spatial segments in a first dimension or direction, and the number of remaining segment units in the first dimension or direction to be segmented is calculated inside the first loop. In some embodiments a number of remaining segments in the first dimension or direction is also calculated inside the first loop.

(82) In some embodiments, the derivation of the segment sizes and/or locations comprises a second loop over the number of spatial segments in a second dimension or direction other than the first dimension or direction, and the number of remaining segment units in the second dimension or direction to be segmented is calculated inside the second loop. In some embodiments a number of remaining segments in the second dimension or direction is also calculated inside the second loop.

(83) In some embodiments, the first dimension or direction is a horizontal dimension or direction and the second dimension or direction is a vertical dimension or direction.

(84) FIG. 9 is a diagram showing functional units of a decoder 902 according to some embodiments. As shown in FIG. 9, decoder 902 includes a decoding unit 904 for decoding one or more code words in the bitstream; a first determining unit 906 for determining that the partition structure is uniform based on the one or more code words; a second determining unit 908 for determining the number of spatial segments based on the one or more code words; a third determining unit 910 for determining a segment unit size; and a deriving unit 912 for deriving the sizes and/or locations for all spatial segments in the picture from the one or more code words, wherein the derivation of the segment sizes and/or locations comprises a first loop over the number of spatial segments in a first dimension and a second loop over the number of spatial segments in a second dimension, the number of remaining segment units in the first dimension to be segmented is calculated inside the first loop, and the number of remaining segment units in the second dimension to be segmented and the number of remaining segments in the second dimension are calculated inside the second loop. In some embodiments, a number of remaining segments in the first dimension is also calculated inside the first loop and a number of remaining segments in the second dimension is also calculated inside the second loop.

(85) FIG. 10 is a diagram showing functional units of an encoder 1002 according to some embodiments. As shown in FIG. 10, encoder 1002 includes a first encoding unit 1004 for encoding the information that the partition structure 13 is uniform by encoding one or more code words into the bitstream; a second encoding unit 1006 for encoding the number of spatial segments by encoding one or more code words into the bitstream; a determining unit 1008 for determining a segment unit size; and a deriving unit 1010 for deriving and encoding the sizes and/or locations for all spatial segments in the picture into the bitstream, wherein the derivation of the segment sizes comprises a first loop over the number of spatial segments in a first dimension and a second loop over the number of spatial segments in a second dimension, the number of remaining segment units in the first dimension to be segmented is calculated inside the first loop, and the number of remaining segment units in the second dimension to be segmented is calculated inside the second loop.

(86) In some embodiments, the encoder is configured to define a partition structure that divides a picture into a number of uniform spatial segments, wherein each spatial segment comprises at least one unit, and wherein derivation of the segment sizes is performed in a first loop over the number of spatial segments in a first dimension and a second loop over the number of spatial segments in a second dimension, wherein the number of remaining segment units in the first dimension to be segmented is calculated inside the first loop, and wherein the number of remaining segment units in the second dimension to be segmented is calculated inside the second loop; encode the plurality of spatial segments in accordance with the partition structure to generate a plurality of coded spatial segments, wherein each coded spatial segment corresponds to one of the spatial segments of the partition structure, and each coded spatial segment is independent such that derivation of any intra prediction mode for a first unit of the first spatial segment depends on a derived intra prediction mode for a second unit of the first spatial segment and is independent of any intra prediction mode for units of other spatial segments of the partition structure; and generate a bit stream comprising the plurality of coded spatial segments and information indicating the uniform partition structure used to divide the picture into the plurality of spatial segments.

(87) FIG. 11 is a block diagram of an apparatus 1100 for implementing decoder 902 and/or encoder 1002, according to some embodiments. When apparatus 1100 implements decoder 902, apparatus 1100 may be referred to as a “decoding apparatus 1100,” and when apparatus 1100 implements encoder 1002, apparatus 1100 may be referred to as an “encoding apparatus 1100.” As shown in FIG. 11, apparatus 1100 (a.k.a., “node”) may comprise: processing circuitry (PC) 1102, which may include one or more processors (P) 1155 (e.g., a general purpose microprocessor and/or one or more other processors, such as an application specific integrated circuit (ASIC), field-programmable gate arrays (FPGAs), and the like); a network interface 1148 comprising a transmitter (Tx) 1145 and a receiver (Rx) 1147 for enabling the apparatus 1100 to transmit data to and receive data from other nodes connected to a network 1110 (e.g., an Internet Protocol (IP) network) to which network interface 1148 is connected; and a local storage unit (a.k.a., “data storage system”) 1108, which may include one or more non-volatile storage devices and/or one or more volatile storage devices. In embodiments where PC 1102 includes a programmable processor, a computer program product (CPP) 1141 may be provided. CPP 1141 includes a computer readable medium (CRM) 1142 storing a computer program (CP) 1143 comprising computer readable instructions (CRI) 1144. CRM 1142 may be a non-transitory computer readable medium, such as, magnetic media (e.g., a hard disk), optical media, memory devices (e.g., random access memory, flash memory), and the like. In some embodiments, the CRI 1144 of computer program 1143 is configured such that when executed by PC 1102, the CRI causes the apparatus 1100 to perform steps described herein (e.g., steps described herein with reference to the flow charts). In other embodiments, the apparatus 1100 may be configured to perform steps described herein without the need for code. That is, for example, PC 1102 may consist merely of one or more ASICs. Hence, the features of the embodiments described herein may be implemented in hardware and/or software.

Summary of Various Embodiments

(88) A1a. A method 700 for decoding a picture 10 comprising a number of units 8 from a bitstream, the picture being partitioned into a number of spatial segments 11 by a partition structure 13, the number of spatial segments being greater than or equal to two, the method comprising: decoding 710 one or more code words in the bitstream; determining 720 that the partition structure is uniform based on the one or more code words; determining 730 the number of spatial segments based on the one or more code words; determining 740 a segment unit size; and deriving 750 the sizes and/or locations for spatial segments in the picture from the one or more code words, wherein deriving the sizes and/or locations for spatial segments in the picture comprises a first loop over the number of spatial segments in a first dimension or direction, and a number of remaining segment units in the first dimension or direction to be segmented is calculated inside the first loop.

(89) A1b. The method of embodiment A1a, wherein the first loop over the number of spatial segments comprises a first loop over the number of spatial segments with size equal to a segment size in a first dimension or direction.

(90) A2a. The method of embodiment A1a or A1b, wherein deriving the sizes and/or locations further comprises a second loop over the number of spatial segments in a second dimension or direction other than the first dimension or direction, and a number of remaining segment units in the second dimension or direction to be segmented is calculated inside the second loop.

(91) A2b. The method of embodiment A2a, wherein a segment size in the first dimension or direction is a width of a segment in a row and a segment size in the second dimension or direction is a height of a segment in a column, or a segment size in the first dimension or direction is a height of a segment in a column and a segment size in the second dimension or direction is a width of a segment in a row.

(92) A2c. The method of embodiment A2a or A2b, wherein the second loop over the number of spatial segments comprises a second loop over the number of spatial segments with size equal to a segment size in a second dimension or direction.

(93) A3. The method of embodiment A2a, A2b or A2c, wherein the first dimension or direction is a horizontal dimension or direction and the second dimension or direction is a vertical dimension or direction, or the first dimension or direction is a vertical dimension or direction and the second dimension or direction is a horizontal dimension or direction.

(94) A4. The method of any one of embodiments A1a-A3, wherein the width of the segments in a row or the height of the segments in a column follows a specified order.

(95) A5. The method of any one of embodiments A1a-A4, wherein the width of the segments in a row or the height of the segments in a column are in a never ascending or a never descending order.

(96) A6. The method of any one of embodiments A1a-A5 wherein a binary segment split with an explicit ordering of the segment width or height is applied to the width or height of the picture.

(97) A7. The method of any one of embodiments A1a-A6 wherein the width of the segments in a row or the height of the segments in a column of a picture follows a specified default order for the width or height of the segments.

(98) A8. The method of any one of embodiments A1a-A7, wherein the segment unit size is equal to the size of the coding tree unit (CTU).

(99) A9. The method of any one of embodiments A1a-A7, wherein the segment unit size is smaller than the size of the coding tree unit (CTU).

(100) A10. The method of any one of embodiments A1a-A7, wherein the segment unit size is larger than the size of the CTU.

(101) A11. The method of any one of embodiments A1a-A10, where a segment is a tile.

(102) A12. The method of any one of embodiments A1a-A11, wherein deriving the sizes comprises deriving a list Sizes[ ] as:

(103) TABLE-US-00023 A = PicWidthInSegmentUnits B = NumberOfSegmentColumns for( i = 0; i < NumberOfSegmentColumns; i++ ) {  Sizes [ i ] = Round( A ÷ B)  A = A - Sizes[ i ]  B = B - I } where NumberOfSegmentColumns is the number of segment columns, PicWidthInSegmentUnits is the width of the picture in segment units, Round( ) is either the Floor( ) function or the Ceil( ) function, and ÷ is division without truncation or rounding.
PicWidthInSegmentUnits is the width of the picture in segment units, Round( ) is either the Floor( ) function or the Ceil( ) function, and ÷ is division without truncation or rounding.

(104) A13. The method of any one of embodiments A1a-A12, where deriving the sizes comprises deriving a list Sizes[ ] as:

(105) TABLE-US-00024 A = PicHeightInSegmentUnits B = NumberOfSegmentRows for( i = 0; i < NumberOfSegmentRows; i++ ) {  Sizes [ i ] = Round( A ÷ B)  A = A - Sizes[ i ]  B = B - 1 } where NumberOfSegmentRows is the number of segment rows, PicHeightInSegmentUnits is the height of the picture in segment units, Round( ) is either the Floor( ) function or the Ceil( ) function, and ÷ is division without truncation or rounding.

(106) A14. The method of any one of embodiments A1a-A13, wherein the segments 11 are independent with respect to other segments 11 such that the derivation of any intra prediction mode for any unit 16 in a current segment 15 depends only on previously derived intra prediction modes in units 17 that belong to the current segment 15 and does not depend on any intra prediction mode in any unit 18 that belongs to a different segment 14.

(107) A15. The method of any one of embodiments A1a-A14, the method further comprising: partitioning the segments to uniform widths or heights follows a fixed ripple pattern independent from the number of the spatial segments.

(108) A16. The method of any one of embodiments A2a-A15, wherein a number of remaining segments in the second dimension or direction is calculated inside the second loop.

(109) A17. The method of any one of embodiments A1a-A16, wherein a number of remaining segments in the first dimension or direction is calculated inside the first loop.

(110) B1a. A method 800 for encoding a picture 10 comprising a number of units 8 into a bitstream, the picture being partitioned into a number of spatial segments 11 by a uniform partition structure 13, the number of spatial segments being greater than or equal to two, the method comprising: encoding 810 the information that the partition structure 13 is uniform by encoding one or more code words into the bitstream; encoding 820 the number of spatial segments by encoding one or more code words into the bitstream; determining 830 a segment unit size; and deriving 840 and encoding the sizes and/or locations for spatial segments in the picture into the bitstream, wherein deriving the sizes and/or locations for spatial segments in the picture comprises a first loop over the number of spatial segments in a first dimension or direction, and a number of remaining segment units in the first dimension or direction to be segmented is calculated inside the first loop.

(111) B1b. The method of embodiment B1a, wherein the first loop over the number of spatial segments comprises a first loop over the number of spatial segments with size equal to a segment size in a first dimension or direction.

(112) B2a. The method of embodiment B1a or B1b, wherein the derivation of the segment sizes and/or locations comprises a second loop over the number of spatial segments in a second dimension or direction other than the first dimension or direction, and a number of remaining segment units in the second dimension or direction to be segmented is calculated inside the second loop.

(113) B2b. The method of embodiment B2a, wherein a segment size in the first dimension or direction is a width of a segment in a row and a segment size in the second dimension or direction is a height of a segment in a column, or a segment size in the first dimension or direction is a height of a segment in a column and a segment size in the second dimension or direction is a width of a segment in a row.

(114) B2c. The method of embodiment B2a or B2b, wherein the second loop over the number of spatial segments comprises a second loop over the number of spatial segments with size equal to a segment size in a second dimension or direction.

(115) B3. The method of embodiment B2a, B2b, or B2c, wherein the first dimension or direction is a horizontal dimension or direction and the second dimension or direction is a vertical dimension or direction, or the first dimension or direction is a vertical dimension or direction and the second dimension or direction is a horizontal dimension or direction.

(116) B4. The method of embodiment B2a, B2b, B2c, or B3, wherein a number of remaining segments in the second dimension or direction is calculated inside the second loop.

(117) B5. The method of any one of embodiments B1a-B4, wherein a number of remaining segments in the first dimension or direction is calculated inside the first loop.

(118) C1. A method 1200 for encoding a picture 10, the method comprising: defining 1210 a partition structure that divides the picture 10 into a number of uniform spatial segments, wherein each spatial segment comprises at least one unit, and wherein derivation of the segment sizes is performed in a first loop over the number of spatial segments in a first dimension or direction and a second loop over the number of spatial segments in a second dimension or direction, wherein the number of remaining segment units in the first dimension or direction to be segmented is calculated inside the first loop, and wherein the number of remaining segment units in the second dimension or direction to be segmented is calculated inside the second loop; encoding 1220 the plurality of spatial segments in accordance with the partition structure to generate a plurality of coded spatial segments, wherein each coded spatial segment corresponds to one of the spatial segments of the partition structure, and each coded spatial segment is independent such that derivation of any intra prediction mode for a first unit of the first spatial segment depends on a derived intra prediction mode for a second unit of the first spatial segment and is independent of any intra prediction mode for units of other spatial segments of the partition structure; and generating 1230 a bit stream comprising the plurality of coded spatial segments and information indicating the uniform partition structure used to divide the picture into the plurality of spatial segments.

(119) D1. A computer program 1143 comprising instructions 1144 which when executed by processing circuitry 1102 causes the processing circuitry 1102 to perform the method of any one of embodiments A1a-C1.

(120) D2. A carrier containing the computer program of embodiment D1, wherein the carrier is one of an electronic signal, an optical signal, a radio signal, and a computer readable storage medium 1142.

(121) E1. A decoding apparatus 1100 for decoding a picture 10 comprising a number of units 8 from a bitstream, the picture being partitioned into a number of spatial segments 11 by a partition structure 13, the number of spatial segments being greater than or equal to two, the decoding apparatus 1100 being configured to: decode one or more code words in the bitstream; determine that the partition structure is uniform based on the one or more code words; determine the number of spatial segments based on the one or more code words; determine a segment unit size; and derive the sizes and/or locations for spatial segments in the picture from the one or more code words, wherein deriving the sizes and/or locations for spatial segments in the picture comprises a first loop over the number of spatial segments in a first dimension or direction, and the decoding apparatus is configured to calculate a number of remaining segment units in the first dimension or direction to be segmented inside the first loop.

(122) E2. The decoding apparatus 1100 of embodiment E1, the decoding apparatus 1100 being further configured to perform the method of any one of embodiments A2-A17.

(123) F1. A decoding apparatus 1100 for decoding a picture 10, the decoding apparatus 1100 comprising: a computer readable storage medium 1142; and processing circuitry 1102 coupled to the computer readable storage medium, wherein the processing circuitry is configured to cause the decoding apparatus 1100 to perform the method of any one of embodiments A1a-A17.

(124) G1. An encoding apparatus 1100 for encoding a picture 10 comprising a number of units 8 into a bitstream, the picture being partitioned into a number of spatial segments 11 by a uniform partition structure 13, the number of spatial segments being greater than or equal to two, the encoding apparatus 1100 being configured to: encode the information that the partition structure 13 is uniform by encoding one or more code words into the bitstream; encode the number of spatial segments by encoding one or more code words into the bitstream; determine a segment unit size; and derive and encoding the sizes and/or locations for spatial segments in the picture into the bitstream, wherein deriving the sizes and/or locations for spatial segments in the picture comprises a first loop over the number of spatial segments in a first dimension or direction, and the encoding apparatus is further configured to calculate a number of remaining segment units in the first dimension or direction to be segmented inside the first loop.

(125) G2. The encoding apparatus 1100 of embodiment G1, the encoding apparatus 1100 being further configured to perform the method of any one of embodiments B2-B5.

(126) H1. An encoding apparatus 1100 for encoding a picture 10, the encoding apparatus 1100 being configured to: define a partition structure that divides a picture into a number of uniform spatial segments, wherein each spatial segment comprises at least one unit, and wherein derivation of the segment sizes is performed in a first loop over the number of spatial segments in a first dimension or direction and a second loop over the number of spatial segments in a second dimension or direction, wherein the number of remaining segment units in the first dimension or direction to be segmented is calculated inside the first loop, and wherein the number of remaining segment units in the second dimension or direction to be segmented is calculated inside the second loop; encode the plurality of spatial segments in accordance with the partition structure to generate a plurality of coded spatial segments, wherein each coded spatial segment corresponds to one of the spatial segments of the partition structure, and each coded spatial segment is independent such that derivation of any intra prediction mode for a first unit of the first spatial segment depends on a derived intra prediction mode for a second unit of the first spatial segment and is independent of any intra prediction mode for units of other spatial segments of the partition structure; and generate a bit stream comprising the plurality of coded spatial segments and information indicating the uniform partition structure used to divide the picture into the plurality of spatial segments.

(127) I1. An encoding apparatus 1100 for encoding a picture 10, the encoding apparatus 1100 comprising: a computer readable storage medium 1142; and processing circuitry 1102 coupled to the computer readable storage medium, wherein the processing circuitry is configured to cause the encoding apparatus 1100 to perform the method of any one of embodiments B1-B5 or C1.

(128) PA1. A method for decoding a picture 10 comprising a number of units 8 from a bitstream, the picture being partitioned into at least two spatial segments 11 by a partition structure 13, the method comprising: decoding one or more code words in the bitstream; determining that the partition structure is uniform based on the one or more code words; determining the number of spatial segments based on the one or more code words; determining a segment unit size; and deriving the sizes and/or locations for all spatial segments in the picture from the one or more code words, wherein the derivation of the segment sizes and/or locations comprises a first loop over the number of spatial segments in a first dimension or direction, and the number of remaining segment units in the first dimension or direction to be segmented and the number of remaining segments in the first dimension or direction are calculated inside the first loop.

(129) PA2. The method of embodiment PA1, wherein the derivation of the segment sizes and/or locations comprises a second loop over the number of spatial segments in a second dimension or direction other than the first dimension or direction, and the number of remaining segment units in the second dimension or direction to be segmented and the number of remaining segments in the second dimension or direction are calculated inside the second loop.

(130) PA3. The method of embodiment PA2, wherein the first dimension or direction is a horizontal dimension or direction and the second dimension or direction is a vertical dimension or direction.

(131) PA4. The method of any one of embodiments PA1-PA3, wherein the width of the segments in a row or the height of the segments in a column follows a specified order.

(132) PA5. The method of any one of embodiments PA1-PA3, wherein the width of the segments in a row or the height of the segments in a column are in a never ascending or a never descending order.

(133) PA6. The method of any one of embodiments PA1-PA3, wherein a binary segment split with an explicit ordering of the segment width or height is applied to the width or height of the picture.

(134) PA7. The method of any one of embodiments PA1-PA3, wherein the width of the segments in a row or the height of the segments in a column of a picture follows a specified default order for the width or height of the segments.

(135) PA8. The method of any one of embodiments PA1-PA7, wherein the segment unit size is equal to the size of the coding tree unit (CTU).

(136) PA9. The method of any one of embodiments PA1-PA8, wherein the segment unit size is smaller than the size of the coding tree unit (CTU).

(137) PA10. The method of any one of embodiments PA1-PA8, wherein the segment unit size is larger than the size of the CTU.

(138) PA11. The method of any one of embodiments PA1-PA10, where any segment is a tile.

(139) PA12. The method of any one of embodiments PA1-PA11, wherein deriving the sizes comprises deriving a list Sizes[ ] as:

(140) TABLE-US-00025 A = PicWidthInTileUnits B = NumberOfSegmentColumns for( i = 0; i < NumberOfSegmentColumns; i++ ) {  Sizes [ i ] = Round( A ÷ B)  A = A - Sizes[ i ]  B = B - 1 } where NumberOfSegmentColumns is the number of segment columns, PicWidthInTileUnits is the width of the picture in tile units, Round( ) is either the Floor( ) function or the Ceil( ) function, and ÷ is division without truncation or rounding.

(141) PA13. The method of any one of embodiments PA1-PA12, where deriving the sizes comprises deriving a list Sizes[ ] as:

(142) TABLE-US-00026 A = PicHeightInTileUnits B = NumberOfSegmentRows for( i = 0; i < NumberOfSegmentRows; i++ ) {  Sizes [ i ] = Round( A ÷ B)  A = A - Sizes[ i ]  B = B - 1 } where NumberOfSegmentRows is the number of segment rows, PicHeightInTileUnits is the height of the picture in tile units, Round( ) is either the Floor( ) function or the Ceil( ) function, and ÷ is division without truncation or rounding.

(143) PA14. The method of any one of embodiments PA1-PA13, wherein the segments 11 are independent with respect to other segments 11 such that the derivation of any intra prediction mode for any unit 16 in a current segment 15 depends only on previously derived intra prediction modes in units 17 that belong to the current segment 15 and does not depend on any intra prediction mode in any unit 18 that belongs to a different segment 14.

(144) PA15. The method of any one of embodiments PA1-PA14, the method further comprising: partitioning the segments to uniform widths or heights follows a fixed ripple pattern independent from the number of the spatial segments.

(145) PB1. A method for encoding a picture 10 comprising a number of units 8 into a bitstream, the picture being partitioned into at least two spatial segments 11 by a uniform partition structure 13, the method comprising: encoding the information that the partition structure 13 is uniform by encoding one or more code words into the bitstream; encoding the number of spatial segments by encoding one or more code words into the bitstream; determining a segment unit size; and deriving and encoding the sizes and/or locations for all spatial segments in the picture into the bitstream, wherein the derivation of the segment sizes comprises a first loop over the number of spatial segments in a first dimension or direction, and the number of remaining segment units in the first dimension or direction to be segmented and the number of remaining segments in the first dimension or direction are calculated inside the first loop.

(146) PB2. The method of embodiment PB1, wherein the derivation of the segment sizes and/or locations comprises a second loop over the number of spatial segments in a second dimension or direction other than the first dimension or direction, and the number of remaining segment units in the second dimension or direction to be segmented and the number of remaining segments in the second dimension or direction are calculated inside the second loop.

(147) PB3. The method of embodiment PB2, wherein the first dimension or direction is a horizontal dimension or direction and the second dimension or direction is a vertical dimension or direction.

(148) PC1. An encoder circuit configured to: define a partition structure that divides a picture into a number of uniform spatial segments, wherein each spatial segment comprises at least one unit, and wherein derivation of the segment sizes is performed in a first loop over the number of spatial segments in a first dimension and a second loop over the number of spatial segments in a second dimension, wherein the number of remaining segment units in the first dimension to be segmented and the number of remaining segments in the first dimension are calculated inside the first loop, and wherein the number of remaining segment units in the second dimension to be segmented and the number of remaining segments in the second dimension are calculated inside the second loop; encode the plurality of spatial segments in accordance with the partition structure to generate a plurality of coded spatial segments, wherein each coded spatial segment corresponds to one of the spatial segments of the partition structure, and each coded spatial segment is independent such that derivation of any intra prediction mode for a first unit of the first spatial segment depends on a derived intra prediction mode for a second unit of the first spatial segment and is independent of any intra prediction mode for units of other spatial segments of the partition structure; and generate a bit stream comprising the plurality of coded spatial segments and information indicating the uniform partition structure used to divide the picture into the plurality of spatial segments.

(149) While various embodiments are described herein (including the Appendix, if any), it should be understood that they have been presented by way of example only, and not limitation. Thus, the breadth and scope of this disclosure should not be limited by any of the above-described exemplary embodiments. Moreover, any combination of the above-described elements in all possible variations thereof is encompassed by the disclosure unless otherwise indicated herein or otherwise clearly contradicted by context.

(150) Additionally, while the processes described above and illustrated in the drawings are shown as a sequence of steps, this was done solely for the sake of illustration. Accordingly, it is contemplated that some steps may be added, some steps may be omitted, the order of the steps may be re-arranged, and some steps may be performed in parallel.