Set a transform to be applied to all painters contained in this CompoundPainter
@param transform a new AffineTransform
337635
public void setTransform(AffineTransform transform)
    {
        AffineTransform old = getTransform();
        this.transform = transform;
        setDirty(true);
        firePropertyChange("transform", old, transform);
    }
1344424
function through(transform) {
  var th = new Transform({objectMode: true})

  th._transform = transform

  return th
}
23360
@Override
  public void getTransform(Matrix transform) {
    super.getTransform(transform);
    if (mDrawMatrix != null) {
      transform.preConcat(mDrawMatrix);
    }
  }
480533
public BoundingBox transform(ProjectionTransform transform) {
		BoundingBox transformed = this;
		if (transform.isSameProjection()) {
			transformed = new BoundingBox(transformed);
		} else {
			if (transform.getFromProjection().isUnit(Units.DEGREES)) {
				transformed = TileBoundingBoxUtils
						.boundDegreesBoundingBoxWithWebMercatorLimits(transformed);
			}
			GeometryEnvelope envelope = buildEnvelope(transformed);
			GeometryEnvelope transformedEnvelope = transform
					.transform(envelope);
			transformed = new BoundingBox(transformedEnvelope);
		}
		return transformed;
	}
153058
function set() {
      var property = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'transform';

      Components.Html.wrapper.style.transition = this.compose(property);
    }
101964
@Override
	@SuppressWarnings({ "rawtypes" })
	public void accept(final TransformContext transformContext) {
		Object var = eval(transformContext);

		if (var == null) {
			throw new ParameterNotFoundRuntimeException("Parameter is not set. [" + expression + "]");
		} else if (var instanceof List) {
			bindArray(transformContext, ((List) var).toArray());
		} else if (var.getClass().isArray()) {
			bindArray(transformContext, var);
		} else {
			bindArray(transformContext, new Object[] { var });
		}
		pass();
	}
921273
public static void apply(LineAndShapeRenderer renderer) {
        int n=0;
        for (Color c : LINE_GRAPH)
            renderer.setSeriesPaint(n++,c);
    }
584780
public static <I extends ImageGray<I>, T extends ImageGray>
	T transform( I input , T transformed ) {
		if( input instanceof GrayF32) {
			return (T)IntegralImageOps.transform((GrayF32)input,(GrayF32)transformed);
		} else if( input instanceof GrayF64) {
			return (T)IntegralImageOps.transform((GrayF64)input,(GrayF64)transformed);
		} else if( input instanceof GrayU8) {
			return (T)IntegralImageOps.transform((GrayU8)input,(GrayS32)transformed);
		} else if( input instanceof GrayS32) {
			return (T)IntegralImageOps.transform((GrayS32)input,(GrayS32)transformed);
		} else if( input instanceof GrayS64) {
			return (T)IntegralImageOps.transform((GrayS64)input,(GrayS64)transformed);
		} else {
			throw new IllegalArgumentException("Unknown input type: "+input.getClass().getSimpleName());
		}
	}
721419
function setTransform(element, transform) {
  element.style['transform-origin'] = 'top left';

  [ '', '-ms-', '-webkit-' ].forEach(function(prefix) {
    element.style[prefix + 'transform'] = transform;
  });
}
961048
public static void applyTransform(GrayS8 input , int transform[] , int minValue, GrayS8 output ) {
		output.reshape(input.width,input.height);

		if( BoofConcurrency.USE_CONCURRENT ) {
			ImplEnhanceHistogram_MT.applyTransform(input, transform, minValue, output);
		} else {
			ImplEnhanceHistogram.applyTransform(input, transform, minValue, output);
		}
	}
122761
public void paint (Graphics2D gfx, int x, int y)
    {
        AffineTransform otrans = gfx.getTransform();
        gfx.translate(x, y);
        gfx.transform(_transform);
        _base.paint(gfx, 0, 0);
        gfx.setTransform(otrans);
    }
608793
public void setPresetTransformer(Transformer ts){
        //
        // special thanks to https://github.com/ToxicBakery/ViewPagerTransforms
        //
        BaseTransformer t = null;
        switch (ts){
            case Default:
                t = new DefaultTransformer();
                break;
            case Accordion:
                t = new AccordionTransformer();
                break;
            case Background2Foreground:
                t = new BackgroundToForegroundTransformer();
                break;
            case CubeIn:
                t = new CubeInTransformer();
                break;
            case DepthPage:
                t = new DepthPageTransformer();
                break;
            case Fade:
                t = new FadeTransformer();
                break;
            case FlipHorizontal:
                t = new FlipHorizontalTransformer();
                break;
            case FlipPage:
                t = new FlipPageViewTransformer();
                break;
            case Foreground2Background:
                t = new ForegroundToBackgroundTransformer();
                break;
            case RotateDown:
                t = new RotateDownTransformer();
                break;
            case RotateUp:
                t = new RotateUpTransformer();
                break;
            case Stack:
                t = new StackTransformer();
                break;
            case Tablet:
                t = new TabletTransformer();
                break;
            case ZoomIn:
                t = new ZoomInTransformer();
                break;
            case ZoomOutSlide:
                t = new ZoomOutSlideTransformer();
                break;
            case ZoomOut:
                t = new ZoomOutTransformer();
                break;
        }
        setPagerTransformer(true,t);
    }
1038846
public void setCircleTranslate( Float[] value) {
    PropertyValue propertyValue = circleTranslate(value);
    constantPropertyUsageMap.put(PROPERTY_CIRCLE_TRANSLATE, propertyValue);
    layer.setProperties(propertyValue);
  }
378912
ShadowCompatOperation createShadowCompatOperation(final Matrix transform) {
        // If the shadowCompatOperations don't end on the desired endShadowAngle, add an arc to do so.
        addConnectingShadowIfNecessary(endShadowAngle);
        final List<ShadowCompatOperation> operations = new ArrayList<>(shadowCompatOperations);
        return new ShadowCompatOperation() {
            @Override
            public void draw(
                    Matrix matrix, ShadowRenderer shadowRenderer, int shadowElevation, Canvas canvas) {
                for (ShadowCompatOperation op : operations) {
                    op.draw(transform, shadowRenderer, shadowElevation, canvas);
                }
            }
        };
    }
876152
public function addTransform(string $transform, bool $top = true): self
	{
		$this->assertTransform($transform);

		if ($top) {
			array_unshift($this->transforms, $transform);
		} else {
			$this->transforms[] = $transform;
		}

		$this->setOptions['transforms'] = null;

		return $this;
	}
1293330
public static void phase( ImageInterleaved transform , GrayF phase ) {
		if( transform instanceof InterleavedF32 ) {
			DiscreteFourierTransformOps.phase((InterleavedF32) transform, (GrayF32) phase);
		} else if( transform instanceof InterleavedF64 ) {
			DiscreteFourierTransformOps.phase((InterleavedF64) transform, (GrayF64) phase);
		} else {
			throw new IllegalArgumentException("Unknown image type");
		}
	}
428099
protected void processPaint(Graphics gg, Shape a)
    {
        Graphics2D g = (Graphics2D) gg;
        AffineTransform tmpTransform = g.getTransform();
        if (!tmpTransform.equals(transform))
        {
            transform = tmpTransform;
            invalidateTextLayout();
        }

        Component c = container;
        int p0 = getStartOffset();
        int p1 = getEndOffset();
        Color fg = getForeground();

        if (c instanceof JTextComponent)
        {
            JTextComponent tc = (JTextComponent) c;
            if (!tc.isEnabled())
            {
                fg = tc.getDisabledTextColor();
            }

            // javax.swing.plaf.basic.BasicTextUI $ BasicHighlighter
            // >> DefaultHighlighter
            // >> DefaultHighlightPainter

            Highlighter highLighter = tc.getHighlighter();
            if (highLighter instanceof LayeredHighlighter)
            {
                ((LayeredHighlighter) highLighter).paintLayeredHighlights(g, p0, p1, box.getAbsoluteContentBounds(), tc, this);
                // (g, p0, p1, a, tc, this);
            }
        }
        // nothing is selected
        if (!box.isEmpty() && !getText().isEmpty())
            renderContent(g, a, fg, p0, p1);

    }