Get Location and Eulerian Angles in global coordinates of TopoDS_Shape that is a rotated and translated Box

Hi Kirill, thank you very much for your answer.

I am using a Python wrapper of Open Cascade, so this sample is in written in Python:

from OCC.Core.BRepGProp import brepgprop
from OCC.Core.gp import gp_EulerSequence
from OCC.Core.GProp import GProp_GProps
from OCC.Core.TopoDS import TopoDS_Shape

from OCC.Extend.DataExchange import read_step_file


def main():

    path: str = ...
    shape: TopoDS_Shape = read_step_file(path)

    lprops = GProp_GProps()
    brepgprop.VolumeProperties(shape, lprops)

    mass_or_volume = lprops.Mass()

    lprops = GProp_GProps()
    brepgprop.SurfaceProperties(shape, lprops)

    area = lprops.Mass()

    center_of_mass = lprops.CentreOfMass().Coord()

    # For the location
    location = shape.Location()
    transformation = location.Transformation()
    point = transformation.TranslationPart()

    location_coords = point.X(), point.Y(), point.Z()

    # For the orientation
    location = shape.Location()
    transformation = location.Transformation()
    quaternion = transformation.GetRotation()

    rotation_angles = quaternion.GetEulerAngles(gp_EulerSequence.gp_Extrinsic_XYZ)

    print('Volume: ', mass_or_volume)
    print('Area: ', area)
    print('Center of mass: ', center_of_mass)
    print('Location coordinates: ', location_coords)
    print('Rotation angles: ', rotation_angles)


if __name__ == '__main__':
    main()

I suspect that the method read_step_file is part of this python library. This is its definition:

import os
from OCC.Core.STEPControl import STEPControl_Reader

def read_step_file(filename, as_compound=True, verbosity=True):
    """read the STEP file and returns a compound
    filename: the file path
    verbosity: optional, False by default.
    as_compound: True by default. If there are more than one shape at root,
    gather all shapes into one compound. Otherwise returns a list of shapes.
    """
    if not os.path.isfile(filename):
        raise FileNotFoundError(f"{filename} not found.")

    step_reader = STEPControl_Reader()
    status = step_reader.ReadFile(filename)

    if status == IFSelect_RetDone:  # check status
        if verbosity:
            failsonly = False
            step_reader.PrintCheckLoad(failsonly, IFSelect_ItemsByEntity)
            step_reader.PrintCheckTransfer(failsonly, IFSelect_ItemsByEntity)
        transfer_result = step_reader.TransferRoots()
        if not transfer_result:
            raise AssertionError("Transfer failed.")
        _nbs = step_reader.NbShapes()
        if _nbs == 0:
            raise AssertionError("No shape to transfer.")
        if _nbs == 1:  # most cases
            return step_reader.Shape(1)
        if _nbs > 1:
            print("Number of shapes:", _nbs)
            shps = []
            # loop over root shapes
            for k in range(1, _nbs + 1):
                new_shp = step_reader.Shape(k)
                if not new_shp.IsNull():
                    shps.append(new_shp)
            if as_compound:
                compound, result = list_of_shapes_to_compound(shps)
                if not result:
                    print("Warning: all shapes were not added to the compound")
                return compound
            print("Warning, returns a list of shapes.")
            return shps
    else:
        raise AssertionError("Error: can't read file.")
    return None

Similarly, I assume that the method list_of_shapes_to_compound is also from the library. Here it is:

from OCC.Core.TopoDS import TopoDS_Compound, TopoDS_Shape
from OCC.Core.BRep import BRep_Builder

def list_of_shapes_to_compound(
    list_of_shapes: List[TopoDS_Shape],
) -> Tuple[TopoDS_Compound, bool]:
    """takes a list of shape in input, gather all shapes into one compound
    returns the compound and a boolean, True if all shapes were added to the compund,
    False otherwise
    """
    all_shapes_converted = True
    the_compound = TopoDS_Compound()
    the_builder = BRep_Builder()
    the_builder.MakeCompound(the_compound)
    for shp in list_of_shapes:
        # first ensure the shape is not Null
        if shp.IsNull():
            all_shapes_converted = False
            continue
        the_builder.Add(the_compound, shp)
    return the_compound, all_shapes_converted

About the mass and density, why is it that I don't get the mass in the variable mass_or_volume ? About the rotation angles and location, hope you can understand this python code. If not, I could try to transcribe it into C++, but it would be very bad code.

Thank you for the effort!