Calculate Local Transform from Global Transform
Use this advanced 2D transform calculator to derive a child object’s local position, rotation, and scale from its global transform and its parent’s global transform. This is ideal for game development, robotics, animation pipelines, AR interfaces, CAD workflows, and scene graph debugging.
Interactive Local Transform Calculator
Enter the child global transform and the parent global transform. The calculator solves for the child local transform using matrix inversion and affine composition.
Child Global Transform
Assumed order: Translate → Rotate → Scale in 2D affine space.
Parent Global Transform
If the parent has zero scale on an axis, the inverse cannot be computed for that axis.
Expert Guide: How to Calculate Local Transform from Global Transform
Calculating a local transform from a global transform is one of the most practical skills in 2D and 3D mathematics. It appears in game engines, robotics, animation rigs, CAD tools, simulation software, digital twins, GIS overlays, and mixed reality systems. Anytime an object lives inside a parent-child hierarchy, there are usually two ways to describe it: in world space, also called global space, and in local space, also called parent-relative space. The difference matters because movement, attachment, and orientation often depend on the parent frame rather than the world frame.
In simple terms, the global transform tells you where an object is in the overall scene. The local transform tells you where that object is relative to its parent. If you know the child’s global transform and the parent’s global transform, you can recover the child’s local transform by multiplying the child global matrix by the inverse of the parent global matrix in the correct order. In common notation for column-vector math, the relationship is:
Therefore:
Child Local = Inverse(Parent Global) × Child Global
Why this calculation matters
Many systems store transforms hierarchically because it is efficient and intuitive. A camera mounted on a vehicle, a wheel attached to a robot arm, or a hand bone attached to a forearm bone all inherit motion from their parents. If the parent moves, the child follows automatically. However, there are many situations where you receive a world-space value and need to convert it back into local space:
- Reparenting an object while preserving its world-space position.
- Saving animation keyframes relative to a rig or socket.
- Aligning UI elements to moving anchors in augmented reality.
- Converting sensor or tool coordinates into a robot base frame.
- Debugging scene graph issues in game engines or editors.
- Importing transforms from one software package into another.
Core concepts behind local and global transforms
A transform usually combines translation, rotation, and scale. In 2D workflows, these are often represented in a 3×3 affine matrix. In 3D workflows, 4×4 homogeneous matrices are standard. The calculator above focuses on 2D affine transforms, which is enough for many UI, sprite, CAD, simulation, and top-down game scenarios.
Suppose a parent object has a global transform that positions it at some point in the world, rotates it by a certain angle, and scales it along each axis. A child attached to that parent also has its own local offset, local rotation, and local scaling. When you compose those transforms, you get the child’s final global transform. To reverse that process, you apply the inverse of the parent transform to the child global transform.
Step-by-step calculation workflow
- Convert the parent transform values into a matrix.
- Convert the child global transform values into a matrix.
- Compute the inverse of the parent matrix.
- Multiply the inverse parent matrix by the child global matrix.
- Decompose the resulting local matrix into translation, rotation, and scale.
If there is no shear and your transform order is known, decomposition is straightforward. For a 2D affine matrix, the translation is stored directly in the last column. Scale can be extracted from the magnitude of the basis vectors, and rotation can be derived from the normalized rotation terms using the arctangent function.
The most common formula
For a 2D transform using translate, rotate, and scale, the matrix can be represented as:
M = T × R × S
Given parent matrix P and child global matrix G, the local matrix L is:
L = P-1 × G
This order is critical. Matrix multiplication is not commutative, which means A × B is usually not the same as B × A. A large share of transform bugs happen because developers invert or multiply in the wrong order.
Practical interpretation of the result
Once you compute the local transform, the numbers have direct meaning:
- Local position tells you where the child is relative to the parent origin.
- Local rotation tells you how much the child is rotated relative to the parent’s orientation.
- Local scale tells you how much the child is stretched relative to the parent’s basis vectors.
For example, if a child’s global X value changes but the parent moves too, the local X might remain constant. That is often the expected result in a rigged hierarchy because the child did not move relative to its parent, only relative to the world.
Industry context and real-world usage data
Coordinate transformations are not just academic. They are foundational in aerospace, robotics, navigation, and engineering metrology. According to the U.S. Bureau of Labor Statistics, software developers number well over 1.8 million in the United States, with substantial demand in simulation, visualization, and engineering software where transform math is routine. Robotics and autonomous systems research at leading universities also relies heavily on frame conversions, homogeneous transforms, and kinematic chains.
| Sector | Typical Transform Use | Common Frame Types | Error Sensitivity |
|---|---|---|---|
| Game Development | Scene graphs, animation, cameras, sockets | World, local, bone, screen | Medium to High |
| Robotics | Manipulator kinematics, tool frames, sensors | Base, joint, end-effector, map | Very High |
| CAD and Manufacturing | Assembly constraints, part positioning | Model, part, machine, workpiece | Very High |
| AR and VR | Anchors, head pose, controller tracking | Device, room, anchor, world | High |
Even small transform mistakes can have outsized effects. In interactive graphics, a sign error may cause mirrored animation or broken attachments. In robotics, a frame mismatch can produce positional offsets large enough to invalidate calibration. In surveying and geospatial visualization, frame and datum misunderstandings can lead to misalignment across data sources.
Typical causes of incorrect local transform calculations
- Using the wrong multiplication order.
- Mixing row-vector and column-vector conventions.
- Forgetting whether angles are in degrees or radians.
- Assuming uniform scale when non-uniform scale is present.
- Ignoring shear or skew introduced earlier in a pipeline.
- Attempting inversion when one scale axis is zero.
- Combining transforms from systems that use different handedness conventions.
Comparison of common transform representations
| Representation | Strengths | Weaknesses | Common Use |
|---|---|---|---|
| Separate TRS Values | Human-readable, easy editing | Order-dependent, can hide shear issues | Editors, inspectors, UI tools |
| Affine Matrix | Fast composition, complete transform storage | Harder to read directly | Render pipelines, scene graphs |
| Quaternion plus Position | Stable 3D rotation, avoids gimbal lock | Less intuitive for beginners | 3D animation, robotics, engines |
How this calculator handles the math
This calculator uses a 2D affine approach. You enter translation X and Y, rotation, and scale X and Y for the child global transform and the parent global transform. The script converts each transform into a matrix, computes the inverse of the parent matrix, and multiplies it by the child global matrix. The result is then decomposed back into local translation, local rotation, and local scale.
The decomposition assumes there is no shear. In many practical design tools and game engines, that assumption is acceptable because standard inspector transforms are created from clean translate, rotate, and scale channels. If your data pipeline introduces skew or arbitrary affine distortion, a more advanced decomposition method may be required.
Worked intuition example
Imagine a parent object at position (10, 5), rotated 30 degrees, scaled by (2, 1). A child object appears in world space at (12, 8), rotated 50 degrees, scaled by (1.5, 0.75). The local transform is not simply the difference between positions and rotations because the parent’s rotation and scale change the basis. The local X and Y must be solved in the parent’s rotated and scaled coordinate frame. This is why matrix inversion is the proper method.
When you run those values through the calculator, you recover a local transform that, when recomposed with the parent transform, reproduces the original child global transform. That consistency check is the best way to validate your math: compute local, then recompute global from parent and local, and verify the values match within a small tolerance.
Where to learn more from authoritative sources
If you want deeper grounding in coordinate frames, transformations, and engineering conventions, these sources are useful:
- NASA for spacecraft guidance, navigation, and reference-frame context.
- National Institute of Standards and Technology (NIST) for measurement science and engineering references.
- MIT OpenCourseWare for robotics, linear algebra, and motion planning coursework.
Best practices for developers and engineers
- Document your transform convention clearly, especially multiplication order.
- Keep a single source of truth for world-to-local and local-to-world conversions.
- Store matrices for fast runtime composition, but expose TRS in tooling if users need readability.
- Use unit tests with known transform pairs and round-trip checks.
- Treat zero scales and near-singular matrices as special cases.
- Normalize rotations and use tolerances when comparing floating-point results.
Interpreting numerical precision
Because transform calculations involve trigonometric functions and floating-point arithmetic, tiny numeric differences are normal. If your recovered local rotation displays as 19.999999 instead of 20, that is usually just precision noise. In production systems, values are often rounded for display while full precision is retained internally. This calculator lets you choose the number of decimals so that the result can match your workflow, whether you are debugging a scene graph or preparing human-readable documentation.
Final takeaway
To calculate local transform from global transform, always think in terms of reference frames. The child global transform tells you where the object is in world space. The parent global transform tells you how the local frame itself sits in the world. Applying the inverse parent transform effectively pulls the child out of world space and expresses it in parent space. Once that idea clicks, transform hierarchies become much easier to reason about.