On Mon, Jun 2, 2014 at 10:56 AM, Nick Alexander <nalexan...@mozilla.com>
wrote:

> On 2014-06-02, 9:59 AM, Rik Cabanier wrote:
>
>>
>>
>>
>> On Mon, Jun 2, 2014 at 9:05 AM, Nick Alexander <nalexan...@mozilla.com
>> <mailto:nalexan...@mozilla.com>> wrote:
>>
>>     On 2014-06-02, 4:59 AM, Robert O'Callahan wrote:
>>
>>         On Mon, Jun 2, 2014 at 3:19 PM, Rik Cabanier <caban...@gmail.com
>>         <mailto:caban...@gmail.com>> wrote:
>>
>>             isIdentity() indeed suffers from rounding errors but since
>>             it's useful, I'm
>>             hesitant to remove it.
>>             In our rendering libraries at Adobe, we check if a matrix is
>>             *almost*
>>             identity. Maybe we can do the same here?
>>
>>
>>         One option would be to make "isIdentity" and "is2D" state bits
>>         in the
>>         object rather than predicates on the matrix coefficients. Then
>>         for each
>>         matrix operation, we would define how it affects the isIdentity
>>         and is2D
>>         bits. For example we could say translate(tx, ty, tz)'s result
>>         isIdentity if
>>         and only if the source matrix isIdentity and tx, ty and tz are
>>         all exactly
>>         0.0, and the result is2D if and only if the source matrix is2D
>>         and tz is
>>         exactly 0.0.
>>
>>         With that approach, isIdentity and is2D would be much less
>>         sensitive to
>>         precision issues. In particular they'd be independent of the
>>         precision used
>>         to compute and store store matrix elements, which would be
>>         helpful I think.
>>
>>
>>     I agree that most mathematical ways of determining a matrix (as a
>>     rotation, or a translation, etc) come with isIdentity for free; but
>>     are most matrices derived from some underlying transformation, or
>>     are they given as a list of coefficients?
>>
>>
>> You can do it either way. Here are the constructors:
>> http://dev.w3.org/fxtf/geometry/#dom-dommatrix-dommatrix
>>
>> So you can do:
>>
>>     var m = new DOMMatrix(); // identity = true, 2d = true
>>     var m = new DOMMatrix("translate(20 20) scale(4 4) skewX"); //
>>     identity = depends, 2d = depends
>>     var m = new DOMMatrix(otherdommatrix;  // identity = inherited, 2d =
>>     inherited
>>     var m = new DOMMatrix([a b c d e f]); // identity = depends, 2d = true
>>     var m = new DOMMatrix([m11 m12... m44]); // identity = depends, 2d =
>>     depends
>>
>>     If the latter, the isIdentity flag needs to be determined by the
>>     constructor, or fed as a parameter.  Exactly how does the
>>     constructor determine the parameter?  Exactly how does the user?
>>
>>
>> The constructor would check the incoming parameters as defined:
>>
>>     http://dev.w3.org/fxtf/geometry/#dom-dommatrixreadonly-is2d
>>     http://dev.w3.org/fxtf/geometry/#dom-dommatrixreadonly-isidentity
>>
>
> Thanks for providing these references.  As an aside -- it worries me that
> these are defined rather differently:  is2d says "are equal to 0", while
> isIdentity says "are '0'".  Is this a syntactic or a semantic difference?
>

It looks like an oversight. I'll ask Dirk to update it.


> But, to the point, the idea of "carrying around the isIdentity flag" is
> looking bad, because we either have that A*A.inverse() will never have
> isIdentity() == true; or we promote the idiom that to check for identity,
> one always creates a new DOMMatrix, so that the constructor determines
> isIdentity, and then we query it.  This is no better than just having
> isIdentity do the (badly-rounded) check.
>
> Nick
>
_______________________________________________
dev-platform mailing list
dev-platform@lists.mozilla.org
https://lists.mozilla.org/listinfo/dev-platform

Reply via email to