skif::LayerSpace< SkMatrix > Class Reference

#include <SkImageFilterTypes.h>

Public Member Functions
	LayerSpace ()=default
	LayerSpace (const SkMatrix &m)
	LayerSpace (SkMatrix &&m)
	operator const SkMatrix & () const
LayerSpace< SkRect >	mapRect (const LayerSpace< SkRect > &r) const
LayerSpace< SkIRect >	mapRect (const LayerSpace< SkIRect > &r) const
LayerSpace< SkPoint >	mapPoint (const LayerSpace< SkPoint > &p) const
LayerSpace< Vector >	mapVector (const LayerSpace< Vector > &v) const
LayerSpace< SkSize >	mapSize (const LayerSpace< SkSize > &s) const
LayerSpace< SkMatrix > &	preConcat (const LayerSpace< SkMatrix > &m)
LayerSpace< SkMatrix > &	postConcat (const LayerSpace< SkMatrix > &m)
bool	invert (LayerSpace< SkMatrix > *inverse) const
bool	inverseMapRect (const LayerSpace< SkRect > &r, LayerSpace< SkRect > *out) const
bool	inverseMapRect (const LayerSpace< SkIRect > &r, LayerSpace< SkIRect > *out) const
float	rc (int row, int col) const
float	get (int i) const

Static Public Member Functions
static LayerSpace< SkMatrix >	RectToRect (const LayerSpace< SkRect > &from, const LayerSpace< SkRect > &to)

Detailed Description

Definition at line 490 of file SkImageFilterTypes.h.

Constructor & Destructor Documentation

LayerSpace() [1/3]

skif::LayerSpace< SkMatrix >::LayerSpace ( )

default

LayerSpace() [2/3]

skif::LayerSpace< SkMatrix >::LayerSpace ( const SkMatrix &  m )

inlineexplicit

Definition at line 493 of file SkImageFilterTypes.h.

: fData(m) {}

LayerSpace() [3/3]

skif::LayerSpace< SkMatrix >::LayerSpace ( SkMatrix &&  m )

inlineexplicit

Definition at line 494 of file SkImageFilterTypes.h.

: fData(std::move(m)) {}

Member Function Documentation

get()

float skif::LayerSpace< SkMatrix >::get ( int  i ) const

inline

Definition at line 535 of file SkImageFilterTypes.h.

{ return fData.get(i); }

inverseMapRect() [1/2]

bool skif::LayerSpace< SkMatrix >::inverseMapRect	(	const LayerSpace< SkIRect > &	r,
		LayerSpace< SkIRect > *	out
	)		const

Definition at line 478 of file SkImageFilterTypes.cpp.

                                                                          {
    if (rect.isEmpty()) {
        // An empty input always inverse maps to an empty rect "successfully"
        *out = LayerSpace<SkIRect>::Empty();
        return true;
    } else if (fData.isScaleTranslate()) { // Specialized inverse of 1px-preserving map<SkIRect>
        // A scale-translate matrix with a 0 scale factor is not invertible.
        if (fData.getScaleX() == 0.f || fData.getScaleY() == 0.f) {
            return false;
        }
        double l = (rect.left()   - (double)fData.getTranslateX()) / (double)fData.getScaleX();
        double r = (rect.right()  - (double)fData.getTranslateX()) / (double)fData.getScaleX();
        double t = (rect.top()    - (double)fData.getTranslateY()) / (double)fData.getScaleY();
        double b = (rect.bottom() - (double)fData.getTranslateY()) / (double)fData.getScaleY();
 
        SkIRect mapped{sk_double_saturate2int(std::floor(std::min(l, r) + kRoundEpsilon)),
                       sk_double_saturate2int(std::floor(std::min(t, b) + kRoundEpsilon)),
                       sk_double_saturate2int(std::ceil(std::max(l, r)  - kRoundEpsilon)),
                       sk_double_saturate2int(std::ceil(std::max(t, b)  - kRoundEpsilon))};
        *out = LayerSpace<SkIRect>(mapped);
        return true;
    } else {
        SkRect mapped;
        if (SkMatrixPriv::InverseMapRect(fData, &mapped, SkRect::Make(SkIRect(rect)))) {
            *out = LayerSpace<SkRect>(mapped).roundOut();
            return true;
        }
    }
 
    return false;
}

inverseMapRect() [2/2]

bool skif::LayerSpace< SkMatrix >::inverseMapRect	(	const LayerSpace< SkRect > &	r,
		LayerSpace< SkRect > *	out
	)		const

Definition at line 463 of file SkImageFilterTypes.cpp.

                                                                         {
    SkRect mapped;
    if (r.isEmpty()) {
        // An empty input always inverse maps to an empty rect "successfully"
        *out = LayerSpace<SkRect>::Empty();
        return true;
    } else if (SkMatrixPriv::InverseMapRect(fData, &mapped, SkRect(r))) {
        *out = LayerSpace<SkRect>(mapped);
        return true;
    } else {
        return false;
    }
}

invert()

bool skif::LayerSpace< SkMatrix >::invert ( LayerSpace< SkMatrix > *  inverse ) const

inline

Definition at line 525 of file SkImageFilterTypes.h.

                                                     {
        return fData.invert(&inverse->fData);
    }

mapPoint()

LayerSpace< SkPoint > skif::LayerSpace< SkMatrix >::mapPoint

(

const LayerSpace< SkPoint > &

p

)

const

Definition at line 451 of file SkImageFilterTypes.cpp.

                                                                                     {
    return LayerSpace<SkPoint>(Mapping::map(SkPoint(p), fData));
}

mapRect() [1/2]

LayerSpace< SkIRect > skif::LayerSpace< SkMatrix >::mapRect

(

const LayerSpace< SkIRect > &

r

)

const

Definition at line 447 of file SkImageFilterTypes.cpp.

                                                                                    {
    return LayerSpace<SkIRect>(Mapping::map(SkIRect(r), fData));
}

mapRect() [2/2]

LayerSpace< SkRect > skif::LayerSpace< SkMatrix >::mapRect

(

const LayerSpace< SkRect > &

r

)

const

Definition at line 441 of file SkImageFilterTypes.cpp.

                                                                                  {
    return LayerSpace<SkRect>(Mapping::map(SkRect(r), fData));
}

mapSize()

LayerSpace< SkSize > skif::LayerSpace< SkMatrix >::mapSize

(

const LayerSpace< SkSize > &

s

)

const

Definition at line 459 of file SkImageFilterTypes.cpp.

                                                                                  {
    return LayerSpace<SkSize>(Mapping::map(SkSize(s), fData));
}

mapVector()

LayerSpace< Vector > skif::LayerSpace< SkMatrix >::mapVector

(

const LayerSpace< Vector > &

v

)

const

Definition at line 455 of file SkImageFilterTypes.cpp.

                                                                                    {
    return LayerSpace<Vector>(Mapping::map(Vector(v), fData));
}

operator const SkMatrix &()

skif::LayerSpace< SkMatrix >::operator const SkMatrix & ( ) const

inlineexplicit

Definition at line 495 of file SkImageFilterTypes.h.

{ return fData; }

postConcat()

LayerSpace< SkMatrix > & skif::LayerSpace< SkMatrix >::postConcat ( const LayerSpace< SkMatrix > &  m )

inline

Definition at line 520 of file SkImageFilterTypes.h.

                                                                    {
        fData = SkMatrix::Concat(m.fData, fData);
        return *this;
    }

preConcat()

LayerSpace< SkMatrix > & skif::LayerSpace< SkMatrix >::preConcat ( const LayerSpace< SkMatrix > &  m )

inline

Definition at line 515 of file SkImageFilterTypes.h.

                                                                   {
        fData = SkMatrix::Concat(fData, m.fData);
        return *this;
    }

rc()

float skif::LayerSpace< SkMatrix >::rc ( int  row, int  col  ) const

inline

Definition at line 534 of file SkImageFilterTypes.h.

{ return fData.rc(row, col); }

RectToRect()

static LayerSpace< SkMatrix > skif::LayerSpace< SkMatrix >::RectToRect ( const LayerSpace< SkRect > &  from, const LayerSpace< SkRect > &  to  )

inlinestatic

Definition at line 497 of file SkImageFilterTypes.h.

                                                                         {
        return LayerSpace<SkMatrix>(SkMatrix::RectToRect(SkRect(from), SkRect(to)));
    }

---

The documentation for this class was generated from the following files:

• third_party/skia/src/core/SkImageFilterTypes.h
• third_party/skia/src/core/SkImageFilterTypes.cpp