RobTranslation.RobTranslationProxy Class Reference

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

Public Member Functions
def	__init__ (self, fp)
	Initialization method for RobTranslationProxy. More...
def	onChanged (self, fp, prop)
	Method called after DocumentObjectGroupPython RobTranslation 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_joint_sequence (self, joint_sequence)
	Method used to change a RobTranslation's joint variable sequence. More...
def	is_translation_property (self, prop)
	Method to check that a property describes a translation. More...
def	is_ValidTranslation (self, timestamps=[], ds=[], translation=None)
	Method to check if a translation is valid. More...
def	find_timestamp_indices_and_weights (self, fp)
	Method to find weighted timestamps indices corresponding to a given time. More...
def	__getstate__ (self)
	Necessary method to avoid errors when trying to save unserializable objects. More...
def	__setstate__ (self, state)
	Necessary method to avoid errors when trying to restore unserializable objects. More...

Public Attributes
	updated
	fp
	A DocumentObjectGroupPython associated with the proxy. More...

Static Public Attributes
bool	updated = False
	A bool - True if a property was changed by a class and not user. More...

Detailed Description

Proxy class for a DocumentObjectGroupPython RobTranslation instance.

A RobTranslationProxy instance adds properties to a DocumentObjectGroupPython RobTranslation instance and responds to their changes. It provides a RobotPanel to be able to see an object in a displacement range.

To connect a Proxy object to a DocumentObjectGroupPython RobTranslation do:

a = FreeCAD.ActiveDocument.addObject("App::DocumentObjectGroupPython",
                                     "RobTranslation")
RobTranslationProxy(a)

Definition at line 71 of file RobTranslation.py.

Constructor & Destructor Documentation

__init__()

def RobTranslation.RobTranslationProxy.__init__	(		self,
			fp
	)

Initialization method for RobTranslationProxy.

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

Parameters

fp	A DocumentObjectGroupPython RobTranslation object to be extended.

Definition at line 91 of file RobTranslation.py.

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

Member Function Documentation

__getstate__()

def RobTranslation.RobTranslationProxy.__getstate__

(

self

)

Necessary method to avoid errors when trying to save unserializable objects.

This method is used by JSON to serialize unserializable objects during autosave. Without this an Error would rise when JSON would try to do that itself.

We need this for unserializable fp attribute, but we don't serialize it, because it's enough to reset it when object is restored.

Returns

None, because we don't serialize anything.

Definition at line 546 of file RobTranslation.py.

    def __getstate__(self):
        return None

__setstate__()

def RobTranslation.RobTranslationProxy.__setstate__	(		self,
			state
	)

Necessary method to avoid errors when trying to restore unserializable objects.

This method is used during a document restoration. We need this for unserializable fp attribute, but we do not restore it, because it's enough to reset them from saved parameters.

Returns

None, because we don't restore anything.

Definition at line 559 of file RobTranslation.py.

    def __setstate__(self, state):
        return None

change_joint_sequence()

def RobTranslation.RobTranslationProxy.change_joint_sequence	(		self,
			joint_sequence
	)

Method used to change a RobTranslation's joint variable sequence.

A joint_sequence dictionary containing a translation is tested for validity and then assigned to a RobTranslation DocumentObjectGroupPython.

Parameters

fp	A DocumentObjectGroupPython RobTranslation object.
joint_sequence	A dictionary describing a RobTranslation.

Definition at line 411 of file RobTranslation.py.

    def change_joint_sequence(self, joint_sequence):
        # Check that RobTranslation has a correct format and load it
        if self.is_ValidTranslation(translation=joint_sequence):
            self.fp.Timestamps = joint_sequence["Timestamps"]
            self.fp.dSequence = joint_sequence["dSequence"]
        else:
            FreeCAD.Console.PrintError("Invalid joint sequence!")

execute()

def RobTranslation.RobTranslationProxy.execute	(		self,
			fp
	)

Method called when recomputing a DocumentObjectGroupPython.

New placement is computed, if a RobotPanel is active or it is not active, but rotation is valid. The current pose in a parent coordinate frame is computed using DH parameters. At last ObjectPlacement and Placement are updated accordingly.

Parameters

fp	A DocumentObjectGroupPython RobTranslation object.

Definition at line 161 of file RobTranslation.py.

    def execute(self, fp):
        # Check that joint is not controlled by a RobotPanel
        if not fp.RobotPanelActive:
            # Check that current translation has valid format
            if not fp.ValidTranslation:
                FreeCAD.Console.PrintWarning(fp.Name +
                                             ".execute(): Translation " +
                                             "is not in a valid format.\n")
                return

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

            fp.d = fp.dOffset + (weights[0]*fp.dSequence[indices[0]]
                                 + weights[1]*fp.dSequence[indices[1]])

        # DH transformation
        T_theta = FreeCAD.Placement(FreeCAD.Vector(0, 0, 0),
                                    FreeCAD.Rotation(FreeCAD.Vector(0, 0, 1),
                                                     fp.theta))
        T_d = FreeCAD.Placement(FreeCAD.Vector(0, 0, fp.d),
                                FreeCAD.Rotation(FreeCAD.Vector(0, 0, 1), 0))
        T_a = FreeCAD.Placement(FreeCAD.Vector(fp.a, 0, 0),
                                FreeCAD.Rotation(FreeCAD.Vector(1, 0, 0), 0))
        T_alpha = FreeCAD.Placement(FreeCAD.Vector(0, 0, 0),
                                    FreeCAD.Rotation(FreeCAD.Vector(1, 0, 0),
                                                     fp.alpha))

        fp.ObjectPlacement = T_theta.multiply(T_d.multiply(
                T_a.multiply(T_alpha)))

        # Placement update
        fp.Placement = fp.ParentFramePlacement.multiply(fp.ObjectPlacement)

find_timestamp_indices_and_weights()

def RobTranslation.RobTranslationProxy.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 RobTranslation 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 503 of file RobTranslation.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_translation_property()

def RobTranslation.RobTranslationProxy.is_translation_property	(		self,
			prop
	)

Method to check that a property describes a translation.

It's checked whether prop is Timestamps or dSequence.

Parameters

prop	A str name of a changed property.

Returns

True if prop describes a translation and False otherwise.

Definition at line 430 of file RobTranslation.py.

    def is_translation_property(self, prop):
        return prop in ["Timestamps", "dSequence"]

is_ValidTranslation()

def RobTranslation.RobTranslationProxy.is_ValidTranslation	(		self,
			timestamps = [],
			ds = [],
			translation = None
	)

Method to check if a translation is valid.

This method needs either a translation dictionary argument or all the other lists of floats. A valid translation 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 displacement cannot exceed joint limits.

Parameters

timestamps	A list of floats marking timestamps.
ds	A list of floats signifying translation diplacements along Z axis.
translation	A dict containing all lists above.

Returns

True if translation is valid and False otherwise.

Definition at line 450 of file RobTranslation.py.

    def is_ValidTranslation(self, timestamps=[], ds=[], translation=None):
        # Check all keys are included and record lengths of their lists
        if translation is not None and isinstance(translation, dict):
            for key in ["Timestamps", "dSequence"]:
                if key not in translation.keys():
                    FreeCAD.Console.PrintWarning("Translation misses key " +
                                                 key + ".\n")
                    return False
            timestamps = translation["Timestamps"]
            ds = translation["dSequence"]

        # Check that all lists have the same length
        if len(timestamps) == 0 or \
                (len(timestamps) != 0 and len(timestamps) != len(ds)):
            FreeCAD.Console.PrintWarning("Translation 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("Translation 'Timestamps' is not "
                                         + "list of increasing values.\n")
            return False

        if not all([self.fp.dMinimum <= d <= self.fp.dMaximum for d in ds]):
            FreeCAD.Console.PrintWarning("Translation 'dSequence' elements"
                                         + " are out of d range.\n")
            return False

        return True

onChanged()

def RobTranslation.RobTranslationProxy.onChanged	(		self,
			fp,
			prop
	)

Method called after DocumentObjectGroupPython RobTranslation was changed.

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

Parameters

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

Definition at line 108 of file RobTranslation.py.

    def onChanged(self, fp, prop):
        # Ignore updates to ranges
        if self.updated:
            self.updated = False
            return

        # Control allowed theta range limits
        elif prop == "dMinimum" and hasattr(fp, "dMaximum"):
            self.updated = True
            fp.dMaximum = (fp.dMaximum, fp.dMinimum, float("inf"), 1)
        elif prop == "dMaximum" and hasattr(fp, "dMinimum"):
            self.updated = True
            fp.dMinimum = (fp.dMinimum, -float("inf"), fp.dMaximum, 1)

        # Check that a translation has valid format
        elif self.is_translation_property(prop) and \
                hasattr(fp, "dMaximum") and \
                hasattr(fp, "dMinimum") and \
                hasattr(self, "fp"):
            trans_valid = self.is_ValidTranslation(fp.Timestamps, fp.dSequence)
            if trans_valid != fp.ValidTranslation:
                fp.ValidTranslation = trans_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 rotation
            # 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 RobTranslation.RobTranslationProxy.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 RobTranslation object.

Definition at line 205 of file RobTranslation.py.

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

setProperties()

def RobTranslation.RobTranslationProxy.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 RobTranslation object.

Definition at line 219 of file RobTranslation.py.

    def setProperties(self, fp):
        # Add (and preset) properties
        # Animation properties
        if not hasattr(fp, "ValidTranslation"):
            fp.addProperty("App::PropertyBool", "ValidTranslation", "General",
                           "This property records if rotation was changed."
                           ).ValidTranslation = False
        if not hasattr(fp, "RobotPanelActive"):
            fp.addProperty("App::PropertyBool", "RobotPanelActive", "General",
                           "This property records if robot panel is active."
                           ).RobotPanelActive = 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 RobTranslation 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.")

        # DH parameters
        if not hasattr(fp, "d"):
            fp.addProperty("App::PropertyFloat", "d", "d-hParameters",
                           "Displacement along Z axis.").d = 0
        if not hasattr(fp, "dMaximum"):
            fp.addProperty("App::PropertyFloatConstraint", "dMaximum",
                           "d-hParameters", "Upper limit of displacement"
                           + " along Z axis."
                           ).dMaximum = (1000, 0, float("inf"), 1)
        elif hasattr(fp, "dMinimum"):
            fp.dMaximum = (fp.dMaximum, fp.dMinimum, float("inf"), 1)
        if not hasattr(fp, "dMinimum"):
            fp.addProperty("App::PropertyFloatConstraint", "dMinimum",
                           "d-hParameters", "Lower limit of displacement"
                           + " alon Z axis."
                           ).dMinimum = (0, -float("inf"), 1000, 1)
        elif hasattr(fp, "dMaximum"):
            fp.dMinimum = (fp.dMinimum, -float("inf"), fp.dMaximum, 1)
        if not hasattr(fp, "dOffset"):
            fp.addProperty("App::PropertyFloat", "dOffset",
                           "d-hParameters", "Offset of displacement"
                           + " along Z axis.").dOffset = 0
        if not hasattr(fp, "a"):
            fp.addProperty("App::PropertyFloat", "a", "d-hParameters",
                           "Displacement along X axis.").a = 0
        if not hasattr(fp, "alpha"):
            fp.addProperty("App::PropertyFloat", "alpha", "d-hParameters",
                           "Rotation angle about X axis in degrees.").alpha = 0
        if not hasattr(fp, "theta"):
            fp.addProperty("App::PropertyFloat", "theta", "d-hParameters",
                           "Rotation angle about X axis in degrees.").theta = 0

        # 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

        # 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.")

        # Rotation properties
        if not hasattr(fp, "Timestamps"):
            fp.addProperty("App::PropertyFloatList", "Timestamps",
                           "Translation", "Timestamps at which we define\n"
                           + "translation.")
        if not hasattr(fp, "dSequence"):
            fp.addProperty("App::PropertyFloatList", "dSequence",
                           "Translation", "Displacements along Z axis.")

        # Add feature python
        self.fp = fp

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

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

        import AnimateDocumentObserver
        AnimateDocumentObserver.addObserver()

Member Data Documentation

fp

RobTranslation.RobTranslationProxy.fp

A DocumentObjectGroupPython associated with the proxy.

Definition at line 386 of file RobTranslation.py.

updated

RobTranslation.RobTranslationProxy.updated = False

static

A bool - True if a property was changed by a class and not user.

Definition at line 79 of file RobTranslation.py.

---

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

• Doxypypy outputs/RobTranslation.py