On Mon, Jun 2, 2014 at 3:03 PM, Benoit Jacob <jacob.benoi...@gmail.com>
wrote:

>
>
>
> 2014-06-02 17:13 GMT-04:00 Rik Cabanier <caban...@gmail.com>:
>
>
>>
>>
>> On Mon, Jun 2, 2014 at 11:08 AM, Benoit Jacob <jacob.benoi...@gmail.com>
>> wrote:
>>
>>>
>>>
>>>
>>> 2014-06-02 14:06 GMT-04:00 Benoit Jacob <jacob.benoi...@gmail.com>:
>>>
>>>
>>>>
>>>>
>>>> 2014-06-02 13:56 GMT-04:00 Nick Alexander <nalexan...@mozilla.com>:
>>>>
>>>> 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?
>>>>>
>>>>> 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.
>>>>>
>>>>
>>>> The way that propagating an "is identity" flag is better than
>>>> determining that from the matrix coefficients, is that it's predictable.
>>>> People are going to have matrices that are the result of various arithmetic
>>>> operations, that are close to identity but most of the time not exactly
>>>> identity. On these matrices, I would like isIdentity() to consistently
>>>> return false, instead of returning false 99.99% of the time and then
>>>> suddenly accidentally returning true when a little miracle happens and a
>>>> matrix happens to be exactly identity.
>>>>
>>>
>>> ...but, to not lose sight of what I really want:  I am still not
>>> convinced that we should have a isIdentity() method at all, and by default
>>> I would prefer no such method to exist. I was only saying the above _if_ we
>>> must have a isIdentity method.
>>>
>>
>> Scanning through the mozilla codebase, IsIdentity is used to make
>> decisions if objects were transformed. This seems to match how we use
>> Identity() internally.
>>  Since this seems useful for native applications, there's no reason why
>> this wouldn't be the case for the web platform (aka blink's "rational web
>> platform principle"). If for some reason the author *really* wants to know
>> if the matrix is identity, he can calculate it manually.
>>
>> I would be fine with keeping this as an internal flag and defining this
>> behavior normative.
>>
>
> Gecko's existing code really isn't authoritative on matrix design issues!!
> Please don't use it as an argument either way in this discussion --- just
> because it uses isIdentity() doesn't imply even that isIdentity is actually
> useful to it. It could just be shooting itself in the feet.
>
> (not to pick on any code in particular --- I haven't looked. Just
> generically saying I've seen more bad code than good code in this
> department).
>

Sure. My argument was that if this is useful for applications and they can
use it successfully, why not expose it to the web platform?
I looked at the WebKit and Blink codebases and they also use this API a
lot.
_______________________________________________
dev-platform mailing list
dev-platform@lists.mozilla.org
https://lists.mozilla.org/listinfo/dev-platform

Reply via email to