Trajectory.TrajectoryProxy Class Reference

Proxy class for a DocumentObjectGroupPython Trajectory instance. More...

Public Member Functions
def	__init__ (self, fp)
	Initialization method for TrajectoryProxy. More...
def	onChanged (self, fp, prop)
	Method called after DocumentObjectGroupPython Trajectory was changed. More...
def	execute (self, fp)
	Method called when recomputing a DocumentObjectGroupPython. More...
def	onDocumentRestored (self, fp)
	Method called when document is restored to make sure everything is as it was. More...
def	setProperties (self, fp)
	Method to set properties during initialization or document restoration. More...
def	change_trajectory (self, fp, traj)
	Method used to change a Trajectory's trajectory. More...
def	is_trajectory_property (self, prop)
	Method to check that a property describes a trajectory. More...
def	is_ValidTrajectory (self, timestamps=[], translation_x=[], translation_y=[], translation_z=[], rotation_point_x=[], rotation_point_y=[], rotation_point_z=[], rotation_axis_x=[], rotation_axis_y=[], rotation_axis_z=[], rotation_angle=[], trajectory=None)
	Method to check if a trajectory is valid. More...
def	find_timestamp_indices_and_weights (self, fp)
	Method to find weighted timestamps indices corresponding to a given time. More...

Public Attributes
	pose
	A dict describing a pose - position, rotation axis, point and angle. More...

Detailed Description

Proxy class for a DocumentObjectGroupPython Trajectory instance.

A TrajectoryProxy instance adds properties to a DocumentObjectGroupPython Trajectory instance and responds to their changes. It provides a TrajectoryPanel to be able to see an object progress through a trajectory.

To connect this Proxy object to a DocumentObjectGroupPython Trajectory do:

a = FreeCAD.ActiveDocument.addObject("App::DocumentObjectGroupPython",
                                     "Trajectory")
TrajectoryProxy(a)

Definition at line 244 of file Trajectory.py.

Constructor & Destructor Documentation

__init__()

def Trajectory.TrajectoryProxy.__init__	(		self,
			fp
	)

Initialization method for TrajectoryProxy.

A class instance is created and made a Proxy for a generic DocumentObjectGroupPython Trajectory object. During initialization number of properties are specified and preset.

Parameters

fp	A DocumentObjectGroupPython Trajectory object to be extended.

Definition at line 259 of file Trajectory.py.

    def __init__(self, fp):
        # Add (and preset) properties
        self.setProperties(fp)
        fp.Proxy = self

Member Function Documentation

change_trajectory()

def Trajectory.TrajectoryProxy.change_trajectory	(		self,
			fp,
			traj
	)

Method used to change a Trajectory's trajectory.

A traj dictionary containing a trajectory is tested for validity and then assigned to a Trajectory DocumentObjectGroupPython.

Parameters

fp	A DocumentObjectGroupPython Trajectory object.
traj	A dictionary describing a trajectory.

Definition at line 631 of file Trajectory.py.

    def change_trajectory(self, fp, traj):
        # Check that trajectory has a correct format and load it
        if self.is_ValidTrajectory(trajectory=traj):
            fp.RotationAngle = traj["RotationAngle"]
            fp.RotationAxisX = traj["RotationAxisX"]
            fp.RotationAxisY = traj["RotationAxisY"]
            fp.RotationAxisZ = traj["RotationAxisZ"]
            fp.RotationPointX = traj["RotationPointX"]
            fp.RotationPointY = traj["RotationPointY"]
            fp.RotationPointZ = traj["RotationPointZ"]
            fp.TranslationX = traj["TranslationX"]
            fp.TranslationY = traj["TranslationY"]
            fp.TranslationZ = traj["TranslationZ"]
            fp.Timestamps = traj["Timestamps"]
        else:
            FreeCAD.Console.PrintError("Invalid trajectory!")

execute()

def Trajectory.TrajectoryProxy.execute	(		self,
			fp
	)

Method called when recomputing a DocumentObjectGroupPython.

If a trajectory is valid, then current pose in a parent coordinate frame is computed, ObjectPlacement and Placement are updated accordingly.

Parameters

fp	A DocumentObjectGroupPython Trajectory object.

Definition at line 316 of file Trajectory.py.

    def execute(self, fp):
        # Check that current trajectory has valid format
        if not fp.ValidTrajectory:
            FreeCAD.Console.PrintWarning(fp.Name + ".execute(): Trajectory " +
                                         "is not in a valid format.\n")
            return

        # Update placement according to current time and trajectory
        indices, weights = self.find_timestamp_indices_and_weights(fp)

        self.pose["position"] = (weights[0]*fp.TranslationX[indices[0]] +
                                 weights[1]*fp.TranslationX[indices[1]],
                                 weights[0]*fp.TranslationY[indices[0]] +
                                 weights[1]*fp.TranslationY[indices[1]],
                                 weights[0]*fp.TranslationZ[indices[0]] +
                                 weights[1]*fp.TranslationZ[indices[1]])
        self.pose["rot_axis"] = (weights[0]*fp.RotationAxisX[indices[0]]
                                 + weights[1]*fp.RotationAxisX[indices[1]],
                                 weights[0]*fp.RotationAxisY[indices[0]]
                                 + weights[1]*fp.RotationAxisY[indices[1]],
                                 weights[0]*fp.RotationAxisZ[indices[0]]
                                 + weights[1]*fp.RotationAxisZ[indices[1]])
        self.pose["rot_point"] = (weights[0]*fp.RotationPointX[indices[0]]
                                  + weights[1]*fp.RotationPointX[indices[1]],
                                  weights[0]*fp.RotationPointY[indices[0]]
                                  + weights[1]*fp.RotationPointY[indices[1]],
                                  weights[0]*fp.RotationPointZ[indices[0]]
                                  + weights[1]*fp.RotationPointZ[indices[1]])
        self.pose["rot_angle"] = (weights[0]*fp.RotationAngle[indices[0]]
                                  + weights[1]*fp.RotationAngle[indices[1]])

        fp.ObjectPlacement = FreeCAD.Placement(
            FreeCAD.Vector(self.pose["position"][0],
                           self.pose["position"][1],
                           self.pose["position"][2]),
            FreeCAD.Rotation(FreeCAD.Vector(self.pose["rot_axis"][0],
                                            self.pose["rot_axis"][1],
                                            self.pose["rot_axis"][2]),
                             self.pose["rot_angle"]),
            FreeCAD.Vector(self.pose["rot_point"][0],
                           self.pose["rot_point"][1],
                           self.pose["rot_point"][2],))
        fp.Placement = fp.ParentFramePlacement.multiply(
                       fp.ObjectPlacement)

find_timestamp_indices_and_weights()

def Trajectory.TrajectoryProxy.find_timestamp_indices_and_weights	(		self,
			fp
	)

Method to find weighted timestamps indices corresponding to a given time.

If a time is smaller than the first timestamp, the returned indices are [0,0] with weights [1,0] as that's the closest value. Similarly, if the time is greater than the last timestamp, the returned indices are [-1,-1] pointing to the last element of a timestamps list with weights [1,0]. If the time value is between the first and last timestamp, the indices belong to the closest higher and lower time. At the same time, if interpolation is off, the weights are 0 and 1, where one is given to the index closest to the time. Otherwise, the weights, whose sum equals to 1, are computed to show inverse relative distance i.e. an index with a greater weight is the closer.

Parameters

fp	A DocumentObjectGroupPython Trajectory object.

Returns

indices A list of two integers between -1 and and length of Timestamps.

weights A list of two floats between 0 and 1 showing relative closeness.

Definition at line 777 of file Trajectory.py.

    def find_timestamp_indices_and_weights(self, fp):
        # Retrieve indices corresponding to current time
        # If the time is before the first Timestamp use the first Timestamp
        if fp.Time <= fp.Timestamps[0]:
            indices = [0, 0]
            weights = [1, 0]

        # If the time is after the last Timpestamp use the last Timestamp
        elif fp.Time >= fp.Timestamps[-1]:
            indices = [-1, -1]
            weights = [1, 0]

        # If time is in the range of Timesteps
        else:
            # Find the index of the closest higher value
            indices = [bisect(fp.Timestamps, fp.Time)]
            # Add the previous index
            indices.insert(0, indices[0]-1)
            weights = [fp.Timestamps[indices[1]] - fp.Time,
                       fp.Time - fp.Timestamps[indices[0]]]
            if not fp.Interpolate:
                if weights[0] > weights[1]:
                    weights = [1, 0]
                else:
                    weights = [0, 1]
            else:
                weights = [weights[0]/sum(weights), weights[1]/sum(weights)]

        return indices, weights

is_trajectory_property()

def Trajectory.TrajectoryProxy.is_trajectory_property	(		self,
			prop
	)

Method to check that a property describes a trajectory.

It's checked whether prop is Timestamps, TranslationX, TranslationY, TranslationZ, RotationPointX, RotationPointY, RotationPointZ, RotationAxisX, RotationAxisY, RotationAxisZ or RotationAngle.

Parameters

prop	A str name of a changed property.

Returns

True if prop describes a trajectory and False otherwise.

Definition at line 661 of file Trajectory.py.

    def is_trajectory_property(self, prop):
        return prop in ["Timestamps", "TranslationX", "TranslationY",
                        "TranslationZ", "RotationPointX", "RotationPointY",
                        "RotationPointZ", "RotationAxisX", "RotationAxisY",
                        "RotationAxisZ", "RotationAngle"]

is_ValidTrajectory()

def Trajectory.TrajectoryProxy.is_ValidTrajectory	(		self,
			timestamps = [],
			translation_x = [],
			translation_y = [],
			translation_z = [],
			rotation_point_x = [],
			rotation_point_y = [],
			rotation_point_z = [],
			rotation_axis_x = [],
			rotation_axis_y = [],
			rotation_axis_z = [],
			rotation_angle = [],
			trajectory = None
	)

Method to check if a trajectory is valid.

This method needs either a trajectory dictionary argument or all the other lists of floats. A valid trajectory needs to have all the necessary lists. All the lists must have same length. A timestamps list must consist of a sequence of strictly increasing floats. A rotation axis must have always length equal to 1.

Parameters

timestamps	A list of floats marking timestamps.
translation_x	A list of floats signifying translations in X direction.
translation_y	A list of floats signifying translations in Y direction.
translation_z	A list of floats signifying translations in Z direction.
rotation_point_x	A list of floats signifying rotation point X coordinates.
rotation_point_y	A list of floats signifying rotation point Y coordinates.
rotation_point_z	A list of floats signifying rotation point Z coordinates.
rotation_axis_x	A list of floats signifying rotation axis X elements.
rotation_axis_y	A list of floats signifying rotation axis Y elements.
rotation_axis_z	A list of floats signifying rotation axis Z elements.
rotation_angle	A list of floats signifying rotation angles.
trajectory	A dict containing all lists above.

Returns

True if trajectory is valid and False otherwise.

Definition at line 693 of file Trajectory.py.

    def is_ValidTrajectory(self, timestamps=[], translation_x=[],
                           translation_y=[], translation_z=[],
                           rotation_point_x=[], rotation_point_y=[],
                           rotation_point_z=[], rotation_axis_x=[],
                           rotation_axis_y=[], rotation_axis_z=[],
                           rotation_angle=[], trajectory=None):
        # Check all keys are included and record lengths of their lists
        if trajectory is not None and isinstance(trajectory, dict):
            for key in ["Timestamps", "TranslationX", "TranslationY",
                        "TranslationZ", "RotationPointX", "RotationPointY",
                        "RotationPointZ", "RotationAxisX", "RotationAxisY",
                        "RotationAxisZ", "RotationAngle"]:
                if key not in trajectory.keys():
                    FreeCAD.Console.PrintWarning("Trajectory misses key " +
                                                 key + ".\n")
                    return False
            timestamps = trajectory["Timestamps"]
            translation_x = trajectory["TranslationX"]
            translation_y = trajectory["TranslationY"]
            translation_z = trajectory["TranslationZ"]
            rotation_point_x = trajectory["RotationPointX"]
            rotation_point_y = trajectory["RotationPointY"]
            rotation_point_z = trajectory["RotationPointZ"]
            rotation_axis_x = trajectory["RotationAxisX"]
            rotation_axis_y = trajectory["RotationAxisY"]
            rotation_axis_z = trajectory["RotationAxisZ"]
            rotation_angle = trajectory["RotationAngle"]

        # Check that all lists have the same length
        if len(timestamps) == 0 or \
                (len(timestamps) != 0 and
                 (len(timestamps) != len(timestamps) or
                  len(timestamps) != len(translation_x) or
                  len(timestamps) != len(translation_y) or
                  len(timestamps) != len(translation_z) or
                  len(timestamps) != len(rotation_point_x) or
                  len(timestamps) != len(rotation_point_y) or
                  len(timestamps) != len(rotation_point_z) or
                  len(timestamps) != len(rotation_axis_x) or
                  len(timestamps) != len(rotation_axis_y) or
                  len(timestamps) != len(rotation_axis_z) or
                  len(timestamps) != len(rotation_angle))):
            FreeCAD.Console.PrintWarning("Trajectory has lists with "
                                         + "inconsistent or zero "
                                         + "lengths.\n")
            return False

        # Check timestamps correspond to list of increasing values
        if any([timestamps[i] >= timestamps[i+1]
                for i in range(len(timestamps)-1)]):
            FreeCAD.Console.PrintWarning("Trajectory 'Timestamps' is not "
                                         + "list of increasing values.\n")
            return False

        if any([sum([rotation_axis_x[i]**2,
                     rotation_axis_y[i]**2,
                     rotation_axis_z[i]**2]) != 1
                for i in range(len(rotation_axis_x))]):
            FreeCAD.Console.PrintWarning("Trajectory 'Rotation Axis' "
                                         + "elements don't have norm 1.\n")
            return False

        return True

onChanged()

def Trajectory.TrajectoryProxy.onChanged	(		self,
			fp,
			prop
	)

Method called after DocumentObjectGroupPython Trajectory was changed.

A trajectory is checked for its validity. If the Placement property is changed, then ParentFramePlacement property of a Trajectory children is set to equal the new Placement. If the ParentFramePlacement is changed, then the Placement property is changed.

Parameters

fp	A DocumentObjectGroupPython Trajectory object.
prop	A str name of a changed property.

Definition at line 276 of file Trajectory.py.

    def onChanged(self, fp, prop):
        # Check that a trajectory has valid format
        if self.is_trajectory_property(prop):
            traj_valid = self.is_ValidTrajectory(
                    fp.Timestamps, fp.TranslationX, fp.TranslationY,
                    fp.TranslationZ, fp.RotationPointX, fp.RotationPointY,
                    fp.RotationPointZ, fp.RotationAxisX, fp.RotationAxisY,
                    fp.RotationAxisZ, fp.RotationAngle)
#            traj_valid = self.is_ValidTrajectory(trajectory=traj)
            if traj_valid != fp.ValidTrajectory:
                fp.ValidTrajectory = traj_valid

        elif prop == "Placement":
            # Propagate the Placement updates down the chain
            if hasattr(fp, "Group") and len(fp.Group) != 0:
                for child in fp.Group:
                    child.ParentFramePlacement = fp.Placement
                    child.purgeTouched()

            # Display animated objects in a pose specified by the trajectory
            # and current time
            if hasattr(fp, "AnimatedObjects") and len(fp.AnimatedObjects) != 0:
                for o in fp.AnimatedObjects:
                    o.Placement = fp.Placement
                    o.purgeTouched()

        elif prop == "ParentFramePlacement":
            # If parent frame changed, recompute placement
            fp.Placement = fp.ParentFramePlacement.multiply(
                       fp.ObjectPlacement)

onDocumentRestored()

def Trajectory.TrajectoryProxy.onDocumentRestored	(		self,
			fp
	)

Method called when document is restored to make sure everything is as it was.

Reinitialization it creates properties and sets them to default, if they were not restored automatically. Properties of connected ViewObject are also recreated and reset if necessary.

Parameters

fp	A restored DocumentObjectGroupPython Trajectory object.

Definition at line 371 of file Trajectory.py.

    def onDocumentRestored(self, fp):
        fp.ViewObject.Proxy.setProperties(fp.ViewObject)
        self.setProperties(fp)

setProperties()

def Trajectory.TrajectoryProxy.setProperties	(		self,
			fp
	)

Method to set properties during initialization or document restoration.

The properties are set if they are not already present and an AnimateDocumentObserver is recreated.

Parameters

fp	A restored or barebone DocumentObjectGroupPython Trajectory object.

Definition at line 385 of file Trajectory.py.

    def setProperties(self, fp):
        self.pose = {"position":  (0, 0, 0),
                     "rot_axis":  (0, 0, 0),
                     "rot_point": (0, 0, 0),
                     "rot_angle": None}

        # Add (and preset) properties
        # Animation properties
        if not hasattr(fp, "ValidTrajectory"):
            fp.addProperty("App::PropertyBool", "ValidTrajectory", "General",
                           "This property records if trajectory was changed."
                           ).ValidTrajectory = False
        if not hasattr(fp, "AnimatedObjects"):
            fp.addProperty("App::PropertyLinkListGlobal", "AnimatedObjects",
                           "General", "Objects that will be animated.")
        if not hasattr(fp, "Interpolate"):
            fp.addProperty("App::PropertyBool", "Interpolate", "General",
                           "Interpolate trajectory between timestamps."
                           ).Interpolate = True
        if not hasattr(fp, "AllowServer"):
            fp.addProperty("App::PropertyBool", "AllowServer", "General",
                           "Should this object allow a Server object to "
                           + "change it.").AllowServer = True
        if not hasattr(fp, "AllowControl"):
            fp.addProperty("App::PropertyBool", "AllowControl", "General",
                           "Should this object allow a Control object "
                           + " to change it."
                           ).AllowControl = True
        if not hasattr(fp, "Time"):
            fp.addProperty("App::PropertyFloat", "Time", "General",
                           "Animation time in seconds.").Time = 0
        if not hasattr(fp, "ParentFramePlacement"):
            fp.addProperty("App::PropertyPlacement", "ParentFramePlacement",
                           "General", "Current placement of a Parent Frame.")
        if not hasattr(fp, "ObjectPlacement"):
            fp.addProperty("App::PropertyPlacement", "ObjectPlacement",
                           "General",
                           "Current Object placement in a Parent Frame.")

        # Trajectory properties
        if not hasattr(fp, "Timestamps"):
            fp.addProperty("App::PropertyFloatList", "Timestamps",
                           "Trajectory", "Timestamps at which we define\n" +
                           "translation and rotation.")
        if not hasattr(fp, "TranslationX"):
            fp.addProperty("App::PropertyFloatList", "TranslationX",
                           "Trajectory",
                           "Object translation along global X direction.")
        if not hasattr(fp, "TranslationY"):
            fp.addProperty("App::PropertyFloatList", "TranslationY",
                           "Trajectory",
                           "Object translation along global Y direction.")
        if not hasattr(fp, "TranslationZ"):
            fp.addProperty("App::PropertyFloatList", "TranslationZ",
                           "Trajectory",
                           "Object translation along global Z direction.")

        if not hasattr(fp, "RotationPointX"):
            fp.addProperty("App::PropertyFloatList", "RotationPointX",
                           "Trajectory",
                           "Object rotation point X coordinate.")
        if not hasattr(fp, "RotationPointY"):
            fp.addProperty("App::PropertyFloatList", "RotationPointY",
                           "Trajectory",
                           "Object rotation point Y coordinate.")
        if not hasattr(fp, "RotationPointZ"):
            fp.addProperty("App::PropertyFloatList", "RotationPointZ",
                           "Trajectory",
                           "Object rotation point Z coordinate.")

        if not hasattr(fp, "RotationAxisX"):
            fp.addProperty("App::PropertyFloatList", "RotationAxisX",
                           "Trajectory", "Object rotation axis component X.")
        if not hasattr(fp, "RotationAxisY"):
            fp.addProperty("App::PropertyFloatList", "RotationAxisY",
                           "Trajectory", "Object rotation axis component Y.")
        if not hasattr(fp, "RotationAxisZ"):
            fp.addProperty("App::PropertyFloatList", "RotationAxisZ",
                           "Trajectory", "Object rotation axis component Z.")
        if not hasattr(fp, "RotationAngle"):
            fp.addProperty("App::PropertyFloatList", "RotationAngle",
                           "Trajectory",
                           "Rotation angle in degrees.")

        # Frame properties
        if not hasattr(fp, "ShowFrame"):
            fp.addProperty("App::PropertyBool", "ShowFrame", "Frame",
                           "Show a frame for current pose."
                           ).ShowFrame = True
        if not hasattr(fp, "FrameTransparency"):
            fp.addProperty("App::PropertyPercent", "FrameTransparency",
                           "Frame", "Transparency of the frame in percents."
                           ).FrameTransparency = 0
        if not hasattr(fp, "ShowFrameArrowheads"):
            fp.addProperty("App::PropertyBool", "ShowFrameArrowheads", "Frame",
                           "Show arrowheads for frame axis arrow's."
                           ).ShowFrameArrowheads = True
        if not hasattr(fp, "FrameArrowheadLength"):
            fp.addProperty("App::PropertyFloatConstraint",
                           "FrameArrowheadLength", "Frame",
                           "Frame axis arrow's arrowhead length.\n"
                           + "Range is < 1.0 | 1e6 >."
                           ).FrameArrowheadLength = (10, 1.0, 1e6, 1)
        else:
            fp.FrameArrowheadLength = (fp.FrameArrowheadLength, 1.0, 1e6, 1)
        if not hasattr(fp, "FrameArrowheadRadius"):
            fp.addProperty("App::PropertyFloatConstraint",
                           "FrameArrowheadRadius", "Frame",
                           "Frame axis arrow's arrowhead bottom radius.\n"
                           + "Range is < 0.5 | 1e6 >."
                           ).FrameArrowheadRadius = (5, 0.5, 1e6, 0.5)
        else:
            fp.FrameArrowheadRadius = (fp.FrameArrowheadRadius, 0.5, 1e6, 0.5)
        if not hasattr(fp, "ShaftLength"):
            fp.addProperty("App::PropertyFloatConstraint", "ShaftLength",
                           "Frame", "Frame axis arrow's shaft length.\n"
                           + "Range is < 1.0 | 1e6 >."
                           ).ShaftLength = (20, 1.0, 1e6, 1)
        else:
            fp.ShaftLength = (fp.ShaftLength, 1.0, 1e6, 1)
        if not hasattr(fp, "ShaftWidth"):
            fp.addProperty("App::PropertyFloatConstraint", "ShaftWidth",
                           "Frame", "Frame axis arrow's shaft width.\n"
                           + "Range is < 1.0 | 64 >."
                           ).ShaftWidth = (4, 1.0, 64, 1)
        else:
            fp.ShaftWidth = (fp.ShaftWidth, 1.0, 64, 1)
        if not hasattr(fp, "ShowFrameLabels"):
            fp.addProperty("App::PropertyBool", "ShowFrameLabels",
                           "Frame", "Show label for frame axes."
                           ).ShowFrameLabels = True

        # Rotation axis properties
        if not hasattr(fp, "ShowRotationAxis"):
            fp.addProperty("App::PropertyBool", "ShowRotationAxis",
                           "RotationAxis",
                           "Show currently used rotation axis."
                           ).ShowRotationAxis = True
        if not hasattr(fp, "AxisLength"):
            fp.addProperty("App::PropertyFloatConstraint", "AxisLength",
                           "RotationAxis", "The rotation axis length.\n"
                           + "Range is < 1.0 | 1e6 >."
                           ).AxisLength = (20, 1.0, 1e6, 1)
        else:
            fp.AxisLength = (fp.AxisLength, 1.0, 1e6, 1)
        if not hasattr(fp, "AxisWidth"):
            fp.addProperty("App::PropertyFloatConstraint", "AxisWidth",
                           "RotationAxis", "The rotation axis width.\n"
                           + "Range is < 1.0 | 64 >."
                           ).AxisWidth = (4, 1.0, 64, 1)
        else:
            fp.AxisWidth = (fp.AxisWidth, 1.0, 64, 1)
        if not hasattr(fp, "AxisColor"):
            fp.addProperty("App::PropertyColor", "AxisColor",
                           "RotationAxis", "The rotation axis width."
                           ).AxisColor = (1.000, 0.667, 0.000)
        if not hasattr(fp, "AxisTransparency"):
            fp.addProperty("App::PropertyPercent", "AxisTransparency",
                           "RotationAxis",
                           "Transparency of the rotation axis in percents."
                           ).AxisTransparency = 0
        if not hasattr(fp, "ShowAxisArrowhead"):
            fp.addProperty("App::PropertyBool", "ShowAxisArrowhead",
                           "RotationAxis", "Show arrowhead for axis arrow."
                           ).ShowAxisArrowhead = True
        if not hasattr(fp, "AxisArrowheadLength"):
            fp.addProperty("App::PropertyFloatConstraint",
                           "AxisArrowheadLength", "RotationAxis",
                           "Frame axis arrow's arrowhead length.\n"
                           + "Range is < 1.0 | 1e6 >."
                           ).AxisArrowheadLength = (10, 1.0, 1e6, 1)
        else:
            fp.AxisArrowheadLength = (fp.AxisArrowheadLength, 1.0, 1e6, 1)
        if not hasattr(fp, "AxisArrowheadRadius"):
            fp.addProperty("App::PropertyFloatConstraint",
                           "AxisArrowheadRadius", "RotationAxis",
                           "Frame axis arrow's arrowhead bottom radius.\n"
                           + "Range is < 0.5 | 1e6 >."
                           ).AxisArrowheadRadius = (5, 0.5, 1e6, 0.5)
        else:
            fp.AxisArrowheadRadius = (fp.AxisArrowheadRadius, 0.5, 1e6, 0.5)
        if not hasattr(fp, "ShowAxisLabel"):
            fp.addProperty("App::PropertyBool", "ShowAxisLabel",
                           "RotationAxis", "Show label for rotation axis."
                           ).ShowAxisLabel = True

        # Label properties
        if not hasattr(fp, "FontSize"):
            fp.addProperty("App::PropertyIntegerConstraint", "FontSize",
                           "Labels", "Label font size.\n"
                           + "Range is < 1 | 100 >."
                           ).FontSize = (10, 1, 100, 1)
        else:
            fp.FontSize = (fp.FontSize, 1, 100, 1)
        if not hasattr(fp, "DistanceToAxis"):
            fp.addProperty("App::PropertyFloatConstraint", "DistanceToAxis",
                           "Labels", "Distance from label to its axis.\n"
                           + "Range is < 0.5 | 1e6 >."
                           ).DistanceToAxis = (5, 0.5, 1e6, 0.5)
        else:
            fp.DistanceToAxis = (fp.DistanceToAxis, 0.5, 1e6, 0.5)
        if not hasattr(fp, "Subscription"):
            fp.addProperty("App::PropertyString", "Subscription", "Labels",
                           "Subscription added to an axis name."
                           ).Subscription = ""
        if not hasattr(fp, "Superscription"):
            fp.addProperty("App::PropertyString", "Superscription", "Labels",
                           "Superscription added to an axis name."
                           ).Superscription = ""
        if not hasattr(fp, "FontFamily"):
            fp.addProperty("App::PropertyEnumeration", "FontFamily",
                           "Labels", "Label font family."
                           ).FontFamily = ["SERIF", "SANS", "TYPEWRITER"]
        if not hasattr(fp, "FontStyle"):
            fp.addProperty("App::PropertyEnumeration", "FontStyle",
                           "Labels", "Label font style."
                           ).FontStyle = ["NONE", "BOLD", "ITALIC",
                                          "BOLD ITALIC"]

        # Placement properties
        if not hasattr(fp, "Placement"):
            fp.addProperty("App::PropertyPlacement", "Placement", "Base",
                           "Current placement for animated objects in "
                           + "world frame.")

        # Make some properties read-only
        fp.setEditorMode("ObjectPlacement", 1)
        fp.setEditorMode("ParentFramePlacement", 1)

        # Hide some properties
        fp.setEditorMode("Placement", 2)
        fp.setEditorMode("ValidTrajectory", 2)

        import AnimateDocumentObserver
        AnimateDocumentObserver.addObserver()

Member Data Documentation

pose

Trajectory.TrajectoryProxy.pose

A dict describing a pose - position, rotation axis, point and angle.

Definition at line 386 of file Trajectory.py.

---

The documentation for this class was generated from the following file:

• Doxypypy outputs/Trajectory.py