The affine portion of the base transform. This is called by
        LambertAxes._set_lim_and_transforms.
333866
def _get_affine_transform(self):
        """"""
        # How big is the projected globe?
        # In the case of a stereonet, it's actually constant.
        xscale = yscale = self._scale
        # Create an affine transform to stretch the projection from 0-1
        return Affine2D() \
            .rotate(np.radians(self.rotation)) \
            .scale(0.5 / xscale, 0.5 / yscale) \
            .translate(0.5, 0.5)
1372734
def _set_lim_and_transforms(self):
        
        # There are three important coordinate spaces going on here:
        #
        #    1. Data space: The space of the data itself
        #
        #    2. Axes space: The unit rectangle (0, 0) to (1, 1)
        #       covering the entire plot area.
        #
        #    3. Display space: The coordinates of the resulting image,
        #       often in pixels or dpi/inch.

        # This function makes heavy use of the Transform classes in
        # ``lib/matplotlib/transforms.py.`` For more information, see
        # the inline documentation there.

        # The goal of the first two transformations is to get from the
        # data space to axes space.  It is separated into a non-affine
        # and affine part so that the non-affine part does not have to be
        # recomputed when a simple affine change to the figure has been
        # made (such as resizing the window or changing the dpi).

        # 3) This is the transformation from axes space to display
        # space.
        self.transAxes = BboxTransformTo(self.bbox)

        # Now put these 3 transforms together -- from data all the way
        # to display coordinates.  Using the '+' operator, these
        # transforms will be applied "in order".  The transforms are
        # automatically simplified, if possible, by the underlying
        # transformation framework.
        #self.transData = \
        #    self.transProjection + self.transAffine + self.transAxes
        self.transData = self.GingaTransform()
        self.transData.viewer = self.viewer

        # self._xaxis_transform = blended_transform_factory(
        #         self.transData, self.transAxes)
        # self._yaxis_transform = blended_transform_factory(
        #         self.transAxes, self.transData)
        self._xaxis_transform = self.transData
        self._yaxis_transform = self.transData
1033150
public Surface transform (float m00, float m01, float m10, float m11, float tx, float ty) {
    AffineTransform top = tx();
    Transforms.multiply(top, m00, m01, m10, m11, tx, ty, top);
    return this;
  }
302563
public Matrix4 setToTransform (IVector3 translation, IQuaternion rotation, IVector3 scale) {
        double sx = scale.x(), sy = scale.y(), sz = scale.z();
        return setToRotation(rotation).set(
            m00 * sx, m10 * sy, m20 * sz, translation.x(),
            m01 * sx, m11 * sy, m21 * sz, translation.y(),
            m02 * sx, m12 * sy, m22 * sz, translation.z(),
            0f, 0f, 0f, 1f);
    }
1268003
def _transform(self, *transforms):
        
        sequence = None
        for transform in transforms:
            if sequence:
                sequence = Sequence(sequence, transform=transform)
            else:
                sequence = Sequence(self, transform=transform)
        return sequence
1208075
public FDistort affine(double a11, double a12, double a21, double a22,
						   double dx, double dy) {

		PixelTransformAffine_F32 transform;

		if( outputToInput != null && outputToInput instanceof PixelTransformAffine_F32 ) {
			transform = (PixelTransformAffine_F32)outputToInput;
		} else {
			transform = new PixelTransformAffine_F32();
		}

		Affine2D_F32 m = new Affine2D_F32();

		m.a11 = (float)a11;
		m.a12 = (float)a12;
		m.a21 = (float)a21;
		m.a22 = (float)a22;
		m.tx = (float)dx;
		m.ty = (float)dy;

		m.invert(transform.getModel());

		return transform(transform);
	}
277001
private AffineTransform getAlignmentTransform() {
        final int offsetX;
        switch (this.settings.getParams().getAlign()) {
            case LEFT:
                offsetX = 0;
                break;
            case RIGHT:
                offsetX = this.settings.getMaxSize().width - this.settings.getSize().width;
                break;
            case CENTER:
            default:
                offsetX = (int) Math
                        .floor(this.settings.getMaxSize().width / 2.0 - this.settings.getSize().width / 2.0);
                break;
        }

        final int offsetY;
        switch (this.settings.getParams().getVerticalAlign()) {
            case TOP:
                offsetY = 0;
                break;
            case BOTTOM:
                offsetY = this.settings.getMaxSize().height - this.settings.getSize().height;
                break;
            case MIDDLE:
            default:
                offsetY = (int) Math.floor(this.settings.getMaxSize().height / 2.0 -
                                                   this.settings.getSize().height / 2.0);
                break;
        }

        return AffineTransform.getTranslateInstance(Math.round(offsetX), Math.round(offsetY));
    }
1303600
def apply_transform(self, transform):
        
        self.vertices = transformations.transform_points(self.vertices,
                                                         matrix=transform)
880140
public static <T extends Transform> T multiply (AffineTransform a, AffineTransform b, T into) {
        return multiply(a.m00, a.m01, a.m10, a.m11, a.tx, a.ty,
                        b.m00, b.m01, b.m10, b.m11, b.tx, b.ty, into);
    }
1018889
def taax(mt, x, t, m=1):
    
    return mt.Nx[x + t] / mt.Dx[x] - ((float(m - 1) / float(m * 2)) * (1 - nEx(mt, x, t)))
1092
def transform(self, m):
        """"""
        if not len(m) == 6:
            raise ValueError("bad sequ. length")
        self.x0, self.y0, self.x1, self.y1 = TOOLS._transform_rect(self, m)
        return self
567758
function() {
        // If the projections differ we need to reproject
        var bounds;
        if (this.ovmap.getProjection() != this.map.getProjection()) {
            bounds = this.map.getExtent().transform(
                this.map.getProjectionObject(), 
                this.ovmap.getProjectionObject() );
        } else {
            bounds = this.map.getExtent();
        }
        var pxBounds = this.getRectBoundsFromMapBounds(bounds);
        if (pxBounds) {
            this.setRectPxBounds(pxBounds);
        }
    }
662776
function transform(m) {
         var points = this.points;
         var len = points.length;

         for (var i = 0; i < len; i++) {
           m.multiplyVector(points[i]);
         }

         this.recalc();
         this.updateBounds();
         return this;
       }
12879
def _get_core_transform(self, resolution):
        """"""
        return self._base_transform(self._center_longitude,
                                    self._center_latitude,
                                    resolution)
638553
def transformed(self, t):
        
        assert t.shape[0] == t.shape[1]
        extra_dimensions = t.shape[0] - self.dimensions - 1

        def transform(a):
            return t.dot(np.concatenate(
                (a, [0] * extra_dimensions, [1]),
                axis=0
            ))[:self.dimensions]
        return Rect(transform(self.mins), transform(self.maxes))
379966
def get_transform(self):
        
        return self.aux_transform + \
            self.ref_offset_transform + \
            self.dpi_transform + \
            self.offset_transform
479752
def to_affine(self):
        
        X, Y, Z = self.x, self.y, self.inverse(self.z)
        return ((X * Z ** 2) % P, (Y * Z ** 3) % P)