Replies the coordinates of this path in an array of
double precision floating-point numbers.

@param transform is the transformation to apply to all the coordinates.
@return the coordinates.
975607
@Pure
	public double[] toDoubleArray(Transform3D transform) {
		double[] clone = new double[this.numCoordsProperty.get()];
		if (transform==null) {
			for(int i=0; i<this.numCoordsProperty.get(); ++i) {
				clone[i] = this.coordsProperty[i].get();
			}
		}
		else {
			Point3f p = new Point3f();
			for(int i=0; i<clone.length;) {
				p.x = this.coordsProperty[i].get();
				p.y = this.coordsProperty[i+1].get();
				p.y = this.coordsProperty[i+2].get();
				transform.transform(p);
				clone[i++] = p.x;
				clone[i++] = p.y;
				clone[i++] = p.z;
			}
		}
		return clone;
	}
821153
function _getWorldPositionFromLocalPosition(transform) {
  if (transform.parent === undefined)
    return transform.localPosition;
  else
    return transform.parent.position.add(transform.parent.rotation.mulVector3(transform.localPosition));
}
1320389
@Override
    public double[] transform(double[] x) {
        if (x.length != scale.length) {
            throw new IllegalArgumentException(String.format("Invalid vector size %d, expected %d", x.length, scale.length));
        }

        double[] y = copy ? new double[x.length] : x;
        for (int i = 0; i < x.length; i++) {
            y[i] = x[i] / scale[i];
        }

        return y;
    }
657167
@Override
    public double doubleValueExact() {
        double d = this.number.doubleValue();
        if (d == Double.NEGATIVE_INFINITY || d == Double.POSITIVE_INFINITY) {
            throw new ArithmeticException("Unable to convert to double: "
                    + this.number);
        }
        return d;
    }
1090251
function transformPoints(points, transform) {
    var newPoints, i, pt, newPt;
    newPoints = [];
    for (i = 0; i < points.length; i += 1) {
        pt = points[i];
        newPt = {
            x: transform.xScale * pt.x + transform.scale01 * pt.y + transform.dx,
            y: transform.scale10 * pt.x + transform.yScale * pt.y + transform.dy,
            onCurve: pt.onCurve,
            lastPointOfContour: pt.lastPointOfContour
        };
        newPoints.push(newPt);
    }
    return newPoints;
}
311608
protected void getParentTransform(Matrix transform) {
    if (mTransformCallback != null) {
      mTransformCallback.getTransform(transform);
    } else {
      transform.reset();
    }
  }
916666
public int getLocation(Object value) {
    int		result;
    double	distance;
    double	currDistance;
    int		i;

    result = 0;

    // determine x
    distance = m_Step;
    for (i = 0; i < width(); i++) {
      currDistance = StrictMath.abs(((Double) value) - ((Double) getValue(i)));
      if (Utils.sm(currDistance, distance)) {
	distance = currDistance;
	result   = i;
      }
    }

    return result;
  }
205977
public AffineTransform getTransform() {
        if (FloatingPointUtil.equals(this.rotation, 0.0)) {
            return null;
        }

        final Dimension rotatedMapSize = getRotatedMapSize();

        final AffineTransform transform = AffineTransform.getTranslateInstance(0.0, 0.0);
        // move to the center of the original map rectangle (this is the actual
        // size of the graphic)
        transform.translate(this.mapSize.width / 2, this.mapSize.height / 2);

        // then rotate around this center
        transform.rotate(this.rotation);

        // then move to an artificial origin (0,0) which might be outside of the actual
        // painting area. this origin still keeps the center of the original map area
        // at the center of the rotated map area.
        transform.translate(-rotatedMapSize.width / 2, -rotatedMapSize.height / 2);

        return transform;
    }
1304888
public final int getIndex( int coordinate[] ) {
		int index = coordinate[0]*strides[0];
		for (int i = 1; i < coordinate.length; i++) {
			index += strides[i]*coordinate[i];
		}

		return index;
	}
557333
private Path2D getPath(double simplifyTolerance, BoundingBox boundingBox,
			ProjectionTransform transform, LineString lineString) {

		Path2D path = null;

		// Try to simplify the number of points in the LineString
		List<Point> lineStringPoints = simplifyPoints(simplifyTolerance,
				lineString.getPoints());

		for (Point point : lineStringPoints) {

			Point projectedPoint = transform.transform(point);

			float x = TileBoundingBoxUtils.getXPixel(tileWidth, boundingBox,
					projectedPoint.getX());
			float y = TileBoundingBoxUtils.getYPixel(tileHeight, boundingBox,
					projectedPoint.getY());

			if (path == null) {
				path = new Path2D.Double();
				path.moveTo(x, y);
			} else {
				path.lineTo(x, y);
			}

		}

		return path;
	}
91601
public float getAxisValue(int axis) {
        switch (axis) {
            case AXIS_X:
                return x;
            case AXIS_Y:
                return y;
            case AXIS_PRESSURE:
                return pressure;
            case AXIS_SIZE:
                return size;
            case AXIS_TOUCH_MAJOR:
                return touchMajor;
            case AXIS_TOUCH_MINOR:
                return touchMinor;
            case AXIS_TOOL_MAJOR:
                return toolMajor;
            case AXIS_TOOL_MINOR:
                return toolMinor;
            case AXIS_ORIENTATION:
                return orientation;
            default: {
                if (axis < 0 || axis > 63) {
                    throw new IllegalArgumentException("Axis out of range.");
                }
                final long bits = mPackedAxisBits;
                final long axisBit = 1L << axis;
                if ((bits & axisBit) == 0) {
                    return 0;
                }
                final int index = Long.bitCount(bits & (axisBit - 1L));
                return mPackedAxisValues[index];
            }
        }
    }
1238585
public Se3_F64 getWorldToCurr3D() {

		// compute transform in 2D space
		Se2_F64 currToWorld = getCurrToWorld2D();

		// 2D to 3D coordinates
		currPlaneToWorld3D.getT().set(-currToWorld.T.y, 0, currToWorld.T.x);
		DMatrixRMaj R = currPlaneToWorld3D.getR();

		// set rotation around Y axis.
		// Transpose the 2D transform since the rotation are pointing in opposite directions
		R.unsafe_set(0, 0, currToWorld.c);
		R.unsafe_set(0, 2, -currToWorld.s);
		R.unsafe_set(1, 1, 1);
		R.unsafe_set(2, 0, currToWorld.s);
		R.unsafe_set(2, 2, currToWorld.c);

		currPlaneToWorld3D.invert(worldToCurrPlane3D);

		worldToCurrPlane3D.concat(planeToCamera, worldToCurrCam3D);

		return worldToCurrCam3D;
	}
600729
public void extractScaleTransform(Transformation2D scale,
			Transformation2D rotateNshearNshift) {

		scale.setScale(Math.sqrt(xx * xx + xy * xy),
				Math.sqrt(yx * yx + yy * yy));
		rotateNshearNshift.setScale(1.0 / scale.xx, 1.0 / scale.yy);
		rotateNshearNshift.multiply(this);
	}
337635
public void setTransform(AffineTransform transform)
    {
        AffineTransform old = getTransform();
        this.transform = transform;
        setDirty(true);
        firePropertyChange("transform", old, transform);
    }
831255
@Override
	public void translate(float x, float y, float z)
	{
		transformMatrix.translate(new Vector3f(x, y, z));
	}
543360
@SuppressWarnings({ "unchecked", "rawtypes" })
	@Override
	protected void doTransform(ITransformable transformable, float comp)
	{
		if (listTransformations.size() == 0)
			return;

		for (Transformation transformation : listTransformations)
			transformation.transform(transformable, elapsedTimeCurrentLoop);
	}
1021803
void applyTransformation(Transformation2D transform) {
		m_vertices_mp.applyTransformation(transform);
		if (m_segments != null) {
			for (int i = 0, n = m_segments.size(); i < n; i++) {
				if (m_segments.get(i) != null) {
					m_segments.get(i).applyTransformation(transform);
				}
			}
		}
	}