Fix edge relative positioning (#208,#71)

Author: palemieux

doc/data_model.md

@@ -86,10 +86,6 @@ Writer module can express temporal offsets in units of ticks, frames, etc. as de
 
 The `dur` timing attribute is not supported.
 
-### Position
-
-The `tts:position` style property is not supported and `tts:origin` is used instead.
-
 ### Lengths
 
-The constraints against length units specified in IMSC are relaxed, and lengths can be expressed in `c`, `%`, `rh`, `rw`, `em` and `px` units.
+Extent, origin and position lengths can be expressed in `c`, `%`, `rh`, `rw` and `px` units.

doc/isd.md

@@ -53,3 +53,7 @@ is:
 ```
 
 An ISD contains no timing information, i.e. no `begin` or `end` properties, or animation steps.
+
+Both the `Origin` and `Position` style properties are always equal.
+
+All lengths are expressed in root-relative units `rh` and `rw`.

scripts/linter.sh

@@ -0,0 +1,3 @@
+#!/bin/sh
+
+pipenv run python -m pylint --exit-zero src/main/python/ttconv/ src/test/python/

scripts/unit_test.sh

@@ -0,0 +1,3 @@
+#!/bin/sh
+
+pipenv run python -m unittest discover -v -s src/test/python/ -t .

setup.py

@@ -10,7 +10,7 @@
 
 setup(
     name='ttconv', 
-    version='1.0.0.dev4',
+    version='1.0.0rc1',
     description='Library for conversion of common timed text formats',
     long_description=long_description,
     long_description_content_type='text/markdown',

src/main/python/ttconv/imsc/style_properties.py

@@ -444,7 +444,7 @@ class Origin(StyleProperty):
     model_prop = styles.StyleProperties.Origin
 
     @classmethod
-    def has_px(cls, attrib_value: styles.PositionType) -> bool:
+    def has_px(cls, attrib_value: styles.CoordinateType) -> bool:
       return attrib_value.x.units == styles.LengthType.Units.px or \
         attrib_value.y.units == styles.LengthType.Units.px
 
@@ -453,7 +453,7 @@ def extract(cls, context: StyleParsingContext, xml_attrib: str):
 
       if xml_attrib == "auto":
 
-        r = styles.PositionType(
+        r = styles.CoordinateType(
           x=styles.LengthType(0, styles.LengthType.Units.pct),
           y=styles.LengthType(0, styles.LengthType.Units.pct)
         )
@@ -464,7 +464,7 @@ def extract(cls, context: StyleParsingContext, xml_attrib: str):
         if len(s) != 2:
           raise ValueError("tts:origin has not two components")
 
-        r = styles.PositionType(
+        r = styles.CoordinateType(
           x=StyleProperties.ttml_length_to_model(context, s[0]),
           y=StyleProperties.ttml_length_to_model(context, s[1])
         )
@@ -475,7 +475,7 @@ def extract(cls, context: StyleParsingContext, xml_attrib: str):
     def from_model(cls, xml_element, model_value):
       xml_element.set(
         f"{{{cls.ns}}}{cls.local_name}", 
-        f"{model_value.x.value}{model_value.x.units.value} {model_value.y.value}{model_value.y.units.value}"
+        f"{model_value.x.value:g}{model_value.x.units.value} {model_value.y.value:g}{model_value.y.units.value}"
       )
 
 
@@ -557,45 +557,30 @@ class Position(StyleProperty):
 
     ns = xml_ns.TTS
     local_name = "position"
-    model_prop = None
+    model_prop = styles.StyleProperties.Position
 
     @classmethod
     def extract(cls, context: StyleParsingContext, xml_attrib: str):
 
       (h_edge, h_offset, v_edge, v_offset) = utils.parse_position(xml_attrib)
 
-      if h_edge == "right":
-        if h_offset.units is styles.LengthType.Units.px:
-          h_offset = styles.LengthType(context.doc.get_px_resolution().width - h_offset.value, h_offset.units)
-        elif h_offset.units is styles.LengthType.Units.pct or h_offset.units is styles.LengthType.Units.rw:
-          h_offset = styles.LengthType(100 - h_offset.value, h_offset.units)
-        else:
-          raise ValueError("Units other than px, pct, rh, rw used in tts:position")
-
-      if v_edge == "bottom":
-        if v_offset.units is styles.LengthType.Units.px:
-          v_offset = styles.LengthType(context.doc.get_px_resolution().height - v_offset.value, v_offset.units)
-        elif v_offset.units is styles.LengthType.Units.pct or v_offset.units is styles.LengthType.Units.rh:
-          v_offset = styles.LengthType(100 - v_offset.value, v_offset.units)
-        else:
-          raise ValueError("Units other than px, pct, rh, rw used in tts:position")
-
       return styles.PositionType(
-        x=h_offset,
-        y=v_offset
+        h_offset=h_offset,
+        v_offset=v_offset,
+        h_edge=styles.PositionType.HEdge(h_edge),
+        v_edge=styles.PositionType.VEdge(v_edge)
       )
 
     @classmethod
-    def to_model(cls, context: StyleParsingContext, xml_element) -> typing.Tuple[typing.Type[model.StyleProperty], typing.Any]:
-      return (
-        styles.StyleProperties.Origin,
-        cls.extract(context, xml_element.get(f"{{{cls.ns}}}{cls.local_name}"))
+    def from_model(cls, xml_element, model_value: styles.PositionType):
+      xml_element.set(
+        f"{{{cls.ns}}}{cls.local_name}", 
+        f"{model_value.h_edge.value} " \
+        f"{model_value.h_offset.value:g}{model_value.h_offset.units.value} " \
+        f"{model_value.v_edge.value} " \
+        f"{model_value.v_offset.value:g}{model_value.v_offset.units.value}"
       )
 
-    @classmethod
-    def from_model(cls, xml_element, model_value):
-      raise NotImplementedError
-
 
   class RubyAlign(StyleProperty):
     '''Corresponds to tts:rubyAlign.'''

src/main/python/ttconv/isd.py

@@ -307,6 +307,7 @@ def generate_isd_sequence(
     styles.StyleProperties.FontSize,
     styles.StyleProperties.Extent,
     styles.StyleProperties.Origin,
+    styles.StyleProperties.Position,
     styles.StyleProperties.LineHeight,
     styles.StyleProperties.LinePadding,
     styles.StyleProperties.RubyReserve,
@@ -467,10 +468,22 @@ def _process_element(
         if isd_element.has_style(initial_style):
           continue
 
-        initial_value = doc.get_initial_value(initial_style) if doc.has_initial_value(initial_style) \
-                          else initial_style.make_initial_value()
+        if doc.has_initial_value(initial_style):
+
+          initial_value = doc.get_initial_value(initial_style)
+
+        elif initial_style is not styles.StyleProperties.Position:
+
+          # the initial value of the Position style property is set to Origin as part of style computation
+
+          initial_value = initial_style.make_initial_value()
+
+        else:
+
+          initial_value = None
 
         styles_to_be_computed.add(initial_style)
+
         isd_element.set_style(initial_style, initial_value)
 
     # compute style properties
@@ -535,9 +548,9 @@ def _process_element(
 
     # remove styles that are not applicable
 
-    for computed_style_prop in list(isd_element.iter_styles()):
-      if not isd_element.is_style_applicable(computed_style_prop):
-        isd_element.set_style(computed_style_prop, None)
+    for style_prop in list(isd_element.iter_styles()):
+      if not isd_element.is_style_applicable(style_prop):
+        isd_element.set_style(style_prop, None)
 
     # prune or keep the element
 
@@ -903,14 +916,14 @@ class Origin(StyleProcessor):
     @classmethod
     def compute(cls, parent: model.ContentElement, element: model.ContentElement):
 
-      style_value: styles.PositionType = element.get_style(cls.style_prop)
+      style_value: styles.CoordinateType = element.get_style(cls.style_prop)
 
       # height
 
       y = _compute_length(
         style_value.y,
         _make_rh_length(100),
-        element.get_style(styles.StyleProperties.FontSize),
+        None,
         _make_rh_length(100 / element.get_doc().get_cell_resolution().rows),
         _make_rh_length(100 / element.get_doc().get_px_resolution().height)
       )
@@ -920,14 +933,14 @@ def compute(cls, parent: model.ContentElement, element: model.ContentElement):
       x = _compute_length(
         style_value.x,
         _make_rw_length(100),
-        element.get_style(styles.StyleProperties.FontSize),
+        None,
         _make_rw_length(100 / element.get_doc().get_cell_resolution().columns),
         _make_rw_length(100 / element.get_doc().get_px_resolution().width)
       )
 
       element.set_style(
         cls.style_prop,
-        styles.PositionType(
+        styles.CoordinateType(
           x=x,
           y=y
         )
@@ -992,6 +1005,81 @@ def compute(cls, parent: model.ContentElement, element: model.ContentElement):
         styles.PaddingType(c_before, c_end, c_after, c_start)
       )    
 
+  class Position(StyleProcessor):
+    style_prop = styles.StyleProperties.Position
+
+    @classmethod
+    def compute(cls, parent: model.ContentElement, element: model.ContentElement):
+
+      position : styles.PositionType = element.get_style(styles.StyleProperties.Position)
+
+      if position is None:
+
+        # if no Position style property was specified, use the value of the Origin style property
+
+        origin : styles.CoordinateType = element.get_style(styles.StyleProperties.Origin)
+
+        element.set_style(
+          styles.StyleProperties.Position,
+          styles.PositionType(
+              h_offset=origin.x,
+              v_offset=origin.y
+            )
+        )
+
+        return
+
+      extent : styles.ExtentType = element.get_style(styles.StyleProperties.Extent)
+
+      assert extent.height.units is styles.LengthType.Units.rh
+      assert extent.width.units is styles.LengthType.Units.rw
+
+      v_offset = _compute_length(
+        position.v_offset,
+        _make_rh_length(100 - extent.height.value),
+        None,
+        _make_rh_length(100 / element.get_doc().get_cell_resolution().rows),
+        _make_rh_length(100 / element.get_doc().get_px_resolution().height)
+      )
+      
+      if position.v_edge is styles.PositionType.VEdge.bottom:
+        v_offset = styles.LengthType(
+          value=100 - v_offset.value,
+          units=v_offset.units
+        )
+
+      h_offset = _compute_length(
+        position.h_offset,
+        _make_rw_length(100 - extent.width.value),
+        None,
+        _make_rw_length(100 / element.get_doc().get_cell_resolution().columns),
+        _make_rw_length(100 / element.get_doc().get_px_resolution().width)
+      )
+
+      if position.h_edge is styles.PositionType.HEdge.right:
+        h_offset = styles.LengthType(
+          value=100 - h_offset.value,
+          units=h_offset.units
+        )
+
+      # if specified, the Position style property overrides the Origin style property
+
+      element.set_style(
+        styles.StyleProperties.Origin,
+        styles.CoordinateType(
+            x=h_offset,
+            y=v_offset
+          )
+      )
+
+      element.set_style(
+        styles.StyleProperties.Position,
+        styles.PositionType(
+            h_offset=h_offset,
+            v_offset=v_offset
+          )
+      )
+
   class RubyAlign(StyleProcessor):
     style_prop = styles.StyleProperties.RubyAlign
 

src/main/python/ttconv/model.py

@@ -769,6 +769,7 @@ class Region(ContentElement):
     StyleProperties.Origin,
     StyleProperties.Overflow,
     StyleProperties.Padding,
+    StyleProperties.Position,
     StyleProperties.ShowBackground,
     StyleProperties.Visibility,
     StyleProperties.WritingMode

src/main/python/ttconv/scc/content.py

@@ -32,7 +32,7 @@
 
 from ttconv.time_code import SmpteTimeCode
 from ttconv.scc.utils import get_position_from_offsets
-from ttconv.style_properties import PositionType
+from ttconv.style_properties import CoordinateType
 
 ROLL_UP_BASE_ROW = 15
 
@@ -99,8 +99,8 @@ def get_y_offset(self) -> int:
     """Returns the y offset"""
     return self._y_offset
 
-  def get_position(self) -> PositionType:
-    """Returns current row and column offsets as a cell-based PositionType"""
+  def get_position(self) -> CoordinateType:
+    """Returns current row and column offsets as a cell-based CoordinateType"""
     return get_position_from_offsets(self._x_offset, self._y_offset)
 
   def get_style_properties(self) -> dict:

src/main/python/ttconv/scc/paragraph.py

@@ -35,7 +35,7 @@
 from ttconv.scc.style import SccCaptionStyle
 from ttconv.time_code import SmpteTimeCode
 from ttconv.scc.utils import get_position_from_offsets, get_extent_from_dimensions, convert_cells_to_percentages
-from ttconv.style_properties import PositionType, ExtentType, StyleProperties, LengthType, DisplayAlignType
+from ttconv.style_properties import CoordinateType, ExtentType, StyleProperties, LengthType, DisplayAlignType
 
 LOGGER = logging.getLogger(__name__)
 
@@ -168,7 +168,7 @@ def apply_roll_up_row_offsets(self):
 
     self.set_row_offset(ROLL_UP_BASE_ROW)
 
-  def get_origin(self) -> PositionType:
+  def get_origin(self) -> CoordinateType:
     """Computes and returns the current paragraph origin, based on its content"""
     if len(self._caption_contents) > 0:
       x_offsets = [text.get_x_offset() for text in self._caption_contents if isinstance(text, SccCaptionText)]
@@ -312,7 +312,7 @@ def get_region(self) -> Region:
 
   def _has_same_origin_as_region(self, region: Region) -> bool:
     """Checks whether the region origin is the same as the paragraph origin"""
-    region_origin: Optional[PositionType] = region.get_style(StyleProperties.Origin)
+    region_origin: Optional[CoordinateType] = region.get_style(StyleProperties.Origin)
 
     # Convert paragraph origin units into percentages
     paragraph_origin = convert_cells_to_percentages(self._paragraph.get_origin(), self._doc.get_cell_resolution())
@@ -352,7 +352,7 @@ def _extend_region_to_paragraph(self, region: Region):
     if paragraph_extent_pct.width.value > region_extent.width.value:
       # Resets the region width on the paragraph line width (up to the right of the safe area)
       # The region height always remains the same (depending on the region origin)
-      region_origin: PositionType = region.get_style(StyleProperties.Origin)
+      region_origin: CoordinateType = region.get_style(StyleProperties.Origin)
 
       # Convert right cells coordinate to percentages
       right_pct = self._right * 100 / self._doc.get_cell_resolution().columns

src/main/python/ttconv/scc/utils.py

@@ -28,15 +28,15 @@
 from typing import Union
 
 from ttconv.model import CellResolutionType
-from ttconv.style_properties import LengthType, PositionType, ExtentType
+from ttconv.style_properties import LengthType, CoordinateType, ExtentType
 
 
-def get_position_from_offsets(x_offset: int, y_offset: int, units=LengthType.Units.c) -> PositionType:
+def get_position_from_offsets(x_offset: int, y_offset: int, units=LengthType.Units.c) -> CoordinateType:
   """Converts offsets into position"""
   x_position = LengthType(value=x_offset, units=units)
   y_position = LengthType(value=y_offset, units=units)
 
-  return PositionType(x_position, y_position)
+  return CoordinateType(x_position, y_position)
 
 
 def get_extent_from_dimensions(width: Union[int, Number], height: Union[int, Number], units=LengthType.Units.c) -> ExtentType:
@@ -47,10 +47,10 @@ def get_extent_from_dimensions(width: Union[int, Number], height: Union[int, Num
   return ExtentType(height, width)
 
 
-def convert_cells_to_percentages(dimensions: Union[PositionType, ExtentType], cell_resolution: CellResolutionType) -> Union[
-  PositionType, ExtentType]:
+def convert_cells_to_percentages(dimensions: Union[CoordinateType, ExtentType], cell_resolution: CellResolutionType) -> Union[
+  CoordinateType, ExtentType]:
   """Converts dimensions from cell units to percentage units"""
-  if isinstance(dimensions, PositionType):
+  if isinstance(dimensions, CoordinateType):
     if dimensions.x.units is not LengthType.Units.c or dimensions.y.units is not LengthType.Units.c:
       raise ValueError("Dimensions to convert must be in cell units")