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

Public Member Functions
def	printt (self)

def	__init__ (self, fp)
	Initialization method for RobRotationProxy. More...

def	onChanged (self, fp, prop)
	Method called after `DocumentObjectGroupPython` RobRotation 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 `RobRotation`'s joint variable sequence. More...

def	is_rotation_property (self, prop)
	Method to check that a property describes a rotation. More...

def	is_ValidRotation (self, timestamps=[], thetas=[], rotation=None)
	Method to check if a rotation 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 RobRotation instance.

A RobRotationProxy instance adds properties to a DocumentObjectGroupPython RobRotation instance and responds to their changes. It provides a RobotPanel to be able to see an object in a rotation range.

To connect this Proxy object to a DocumentObjectGroupPython RobRotation do:

a = FreeCAD.ActiveDocument.addObject("App::DocumentObjectGroupPython",
                                     "RobRotation")
RobRotationProxy(a)

Definition at line 71 of file RobRotation.py.

Constructor & Destructor Documentation

◆ init()

def RobRotation.RobRotationProxy.__init__	(	self,
		fp
	)

Initialization method for RobRotationProxy.

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

Parameters

fp	A `DocumentObjectGroupPython` RobRotation object to be extended.

Definition at line 94 of file RobRotation.py.

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

Member Function Documentation

◆ getstate()

def RobRotation.RobRotationProxy.__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 556 of file RobRotation.py.

     def __getstate__(self):
         return None
 

◆ setstate()

def RobRotation.RobRotationProxy.__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 569 of file RobRotation.py.

     def __setstate__(self, state):
         return None

◆ change_joint_sequence()

def RobRotation.RobRotationProxy.change_joint_sequence	(	self,
		joint_sequence
	)

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

A joint_sequence dictionary containing a rotation is tested for validity and then assigned to a RobRotation DocumentObjectGroupPython.

Parameters

joint_sequence A dictionary describing a rotation.

Definition at line 420 of file RobRotation.py.

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

◆ execute()

def RobRotation.RobRotationProxy.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` RobRotation object.

Definition at line 167 of file RobRotation.py.

     def execute(self, fp):
         # Check that joint is not controlled by a RobotPanel
         if not fp.RobotPanelActive:
             # Check that current rotation has valid format
             if not fp.ValidRotation:
                 FreeCAD.Console.PrintWarning(fp.Name +
                                              ".execute(): Rotation " +
                                              "is not in a valid format.\n")
                 return
 
             # Update theta according to current time and rotation
             indices, weights = self.find_timestamp_indices_and_weights(fp)
 
             fp.theta = fp.thetaOffset \
                 + (weights[0]*fp.thetaSequence[indices[0]]
                    + weights[1]*fp.thetaSequence[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 RobRotation.RobRotationProxy.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` RobRotation 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 513 of file RobRotation.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_rotation_property()

def RobRotation.RobRotationProxy.is_rotation_property	(	self,
		prop
	)

Method to check that a property describes a rotation.

It's checked whether prop is Timestamps or thetaSequence.

Parameters

prop	A str name of a changed property.

Returns: True if prop describes a rotation and False otherwise.

Definition at line 439 of file RobRotation.py.

     def is_rotation_property(self, prop):
         return prop in ["Timestamps", "thetaSequence"]
 

◆ is_ValidRotation()

def RobRotation.RobRotationProxy.is_ValidRotation	(	self,
		timestamps = `[]`,
		thetas = `[]`,
		rotation = `None`
	)

Method to check if a rotation is valid.

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

Parameters

timestamps	A list of floats marking timestamps.
thetas	A list of floats signifying rotation angles about Z axis.
rotation	A dict containing all lists above.

Returns: True if rotation is valid and False otherwise.

Definition at line 459 of file RobRotation.py.

     def is_ValidRotation(self, timestamps=[], thetas=[], rotation=None):
         # Check all keys are included and record lengths of their lists
         if rotation is not None and isinstance(rotation, dict):
             for key in ["Timestamps", "thetaSequence"]:
                 if key not in rotation.keys():
                     FreeCAD.Console.PrintWarning("Rotation misses key " +
                                                  key + ".\n")
                     return False
             timestamps = rotation["Timestamps"]
             thetas = rotation["thetaSequence"]
 
         # Check that all lists have the same length
         if len(timestamps) == 0 or \
                 (len(timestamps) != 0 and len(timestamps) != len(thetas)):
             FreeCAD.Console.PrintWarning("Rotation 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("Rotation 'Timestamps' is not "
                                          + "list of increasing values.\n")
             return False
 
         if not all([self.fp.thetaMinimum <= th <= self.fp.thetaMaximum
                     for th in thetas]):
             FreeCAD.Console.PrintWarning("Rotation 'thetaSequence' elements"
                                          + " are out of theta range.\n")
             return False
 
         return True
 

◆ onChanged()

def RobRotation.RobRotationProxy.onChanged	(	self,
		fp,
		prop
	)

Method called after DocumentObjectGroupPython RobRotation was changed.

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

Parameters

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

Definition at line 111 of file RobRotation.py.

     def onChanged(self, fp, prop):
         # Ignore updates to ranges
         if self.updated:
             self.updated = False
             return
 
         # Control allowed theta range limits
         elif prop == "thetaMinimum" and hasattr(fp, "thetaMaximum"):
             self.updated = True
             fp.thetaMaximum = (fp.thetaMaximum, fp.thetaMinimum,
                                float("inf"), 1)
         elif prop == "thetaMaximum" and hasattr(fp, "thetaMinimum"):
             self.updated = True
             fp.thetaMinimum = (fp.thetaMinimum, -float("inf"),
                                fp.thetaMaximum, 1)
 
         # Check that the rotation has valid format
         elif self.is_rotation_property(prop) and \
                 hasattr(fp, "thetaMaximum") and \
                 hasattr(fp, "thetaMinimum") and \
                 hasattr(self, "fp"):
             traj_valid = self.is_ValidRotation(
                     fp.Timestamps, fp.thetaSequence)
             if traj_valid != fp.ValidRotation:
                 fp.ValidRotation = 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 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 RobRotation.RobRotationProxy.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` RobRotation object.

Definition at line 212 of file RobRotation.py.

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

◆ setProperties()

def RobRotation.RobRotationProxy.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` RobRotation object.

Definition at line 226 of file RobRotation.py.

     def setProperties(self, fp):
         # Add (and preset) properties
         # Animation properties
         if not hasattr(fp, "ValidRotation"):
             fp.addProperty("App::PropertyBool", "ValidRotation", "General",
                            "This property records if rotation was changed."
                            ).ValidRotation = 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 RobRotation 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, "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
         if not hasattr(fp, "thetaMaximum"):
             fp.addProperty("App::PropertyFloatConstraint", "thetaMaximum",
                            "d-hParameters", "Upper limit of rotation angle"
                            + " about Z axis in degrees."
                            ).thetaMaximum = (360, 0, float("inf"), 1)
         elif hasattr(fp, "thetaMinimum"):
             fp.thetaMaximum = (fp.thetaMaximum, fp.thetaMinimum,
                                float("inf"), 1)
         if not hasattr(fp, "thetaMinimum"):
             fp.addProperty("App::PropertyFloatConstraint", "thetaMinimum",
                            "d-hParameters", "Lower limit of rotation angle"
                            + " about Z axis in degrees."
                            ).thetaMinimum = (0, -float("inf"), 360, 1)
         elif hasattr(fp, "thetaMaximum"):
             fp.thetaMinimum = (fp.thetaMinimum, -float("inf"),
                                fp.thetaMaximum, 1)
         if not hasattr(fp, "thetaOffset"):
             fp.addProperty("App::PropertyFloat", "thetaOffset",
                            "d-hParameters", "Offset of rotation angle"
                            + " about Z axis in degrees.").thetaOffset = 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",
                            "Rotation", "Timestamps at which we define\n"
                            + "translation and rotation.")
         if not hasattr(fp, "thetaSequence"):
             fp.addProperty("App::PropertyFloatList", "thetaSequence",
                            "Rotation", "Rotation angles about Z axis in"
                            + " degrees.")
 
         # Add feature python
         self.fp = fp
 
         # Make some properties read-only
         fp.setEditorMode("ObjectPlacement", 1)
         fp.setEditorMode("ParentFramePlacement", 1)
         fp.setEditorMode("theta", 1)
 
         # Hide some properties
         fp.setEditorMode("Placement", 2)
         fp.setEditorMode("ValidRotation", 2)
         fp.setEditorMode("RobotPanelActive", 2)
 
         import AnimateDocumentObserver
         AnimateDocumentObserver.addObserver()
 

Member Data Documentation

◆ fp

RobRotation.RobRotationProxy.fp

A DocumentObjectGroupPython associated with the proxy.

Definition at line 396 of file RobRotation.py.

◆ updated

RobRotation.RobRotationProxy.updated = False

static

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

Definition at line 79 of file RobRotation.py.

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

Doxypypy outputs/RobRotation.py

Public Member Functions

Public Attributes

Static Public Attributes

Detailed Description

Constructor & Destructor Documentation

◆ __init__()

Member Function Documentation

◆ __getstate__()

◆ __setstate__()

◆ change_joint_sequence()

◆ execute()

◆ find_timestamp_indices_and_weights()

◆ is_rotation_property()

◆ is_ValidRotation()

◆ onChanged()

◆ onDocumentRestored()

◆ setProperties()

Member Data Documentation

◆ fp

◆ updated

◆ init()

◆ getstate()

◆ setstate()