# encoding: utf-8 # module vtkmodules.vtkCommonDataModel # from C:\Users\xukai\Downloads\发票2\venv\Lib\site-packages\vtkmodules\vtkCommonDataModel.cp311-win_amd64.pyd # by generator 1.147 # no doc # imports import vtkmodules.vtkCommonCore as __vtkmodules_vtkCommonCore import vtkmodules.vtkCommonMath as __vtkmodules_vtkCommonMath import vtkmodules.vtkCommonTransforms as __vtkmodules_vtkCommonTransforms from .vtkUndirectedGraph import vtkUndirectedGraph class vtkMolecule(vtkUndirectedGraph): """ vtkMolecule - class describing a molecule Superclass: vtkUndirectedGraph vtkMolecule and the convenience classes vtkAtom and vtkBond describe the geometry and connectivity of a molecule. The molecule can be constructed using the AppendAtom() and AppendBond() methods in one of two ways; either by fully specifying the atom/bond in a single call, or by incrementally setting the various attributes using the convenience vtkAtom and vtkBond classes: Single call:vtkMolecule *mol = vtkMolecule::New(); vtkAtom h1 = mol->AppendAtom(1, 0.0, 0.0, -0.5); vtkAtom h2 = mol->AppendAtom(1, 0.0, 0.0, 0.5); vtkBond b = mol->AppendBond(h1, h2, 1); Incremental:vtkMolecule *mol = vtkMolecule::New(); vtkAtom h1 = mol->AppendAtom(); h1.SetAtomicNumber(1); h1.SetPosition(0.0, 0.0, -0.5); vtkAtom h2 = mol->AppendAtom(); h2.SetAtomicNumber(1); vtkVector3d displacement (0.0, 0.0, 1.0); h2.SetPosition(h1.GetPositionAsVector3d() + displacement); vtkBond b = mol->AppendBond(h1, h2, 1); Both of the above methods will produce the same molecule, two hydrogens connected with a 1.0 Angstrom single bond, aligned to the z-axis. The second example also demonstrates the use of VTK's vtkVector class, which is fully supported by the Chemistry kit. The vtkMolecule object is intended to be used with the vtkMoleculeMapper class for visualizing molecular structure using common rendering techniques. \warning While direct use of the underlying vtkUndirectedGraph structure is possible due to vtkMolecule's public inheritance, this should not be relied upon and may change in the future. @sa vtkAtom vtkBond vtkMoleculeMapper vtkPeriodicTable """ def AllocateAtomGhostArray(self): # real signature unknown; restored from __doc__ """ AllocateAtomGhostArray(self) -> None C++: void AllocateAtomGhostArray() Allocate ghost array for atoms. """ pass def AllocateBondGhostArray(self): # real signature unknown; restored from __doc__ """ AllocateBondGhostArray(self) -> None C++: void AllocateBondGhostArray() Allocate ghost array for bonds. """ pass def AppendAtom(self): # real signature unknown; restored from __doc__ """ AppendAtom(self) -> vtkAtom C++: vtkAtom AppendAtom() AppendAtom(self, atomicNumber:int, x:float, y:float, z:float) -> vtkAtom C++: vtkAtom AppendAtom(unsigned short atomicNumber, double x, double y, double z) AppendAtom(self, atomicNumber:int, pos:vtkVector3f) -> vtkAtom C++: vtkAtom AppendAtom(unsigned short atomicNumber, const vtkVector3f &pos) AppendAtom(self, atomicNumber:int, pos:[float, float, float]) -> vtkAtom C++: vtkAtom AppendAtom(unsigned short atomicNumber, double pos[3]) Add new atom with atomic number 0 (dummy atom) at origin. Return a vtkAtom that refers to the new atom. """ return vtkAtom def AppendBond(self, atom1, atom2, order=1): # real signature unknown; restored from __doc__ """ AppendBond(self, atom1:int, atom2:int, order:int=1) -> vtkBond C++: vtkBond AppendBond(vtkIdType atom1, vtkIdType atom2, unsigned short order=1) AppendBond(self, atom1:vtkAtom, atom2:vtkAtom, order:int=1) -> vtkBond C++: vtkBond AppendBond(const vtkAtom &atom1, const vtkAtom &atom2, unsigned short order=1) Add a bond between the specified atoms, optionally setting the bond order (default: 1). Return a vtkBond object referring to the new bond. """ return vtkBond def CheckedDeepCopy(self, g): # real signature unknown; restored from __doc__ """ CheckedDeepCopy(self, g:vtkGraph) -> bool C++: bool CheckedDeepCopy(vtkGraph *g) override; Performs the same operation as DeepCopy(), but instead of reporting an error for an incompatible graph, returns false. """ return False def CheckedShallowCopy(self, g): # real signature unknown; restored from __doc__ """ CheckedShallowCopy(self, g:vtkGraph) -> bool C++: bool CheckedShallowCopy(vtkGraph *g) override; Performs the same operation as ShallowCopy(), but instead of reporting an error for an incompatible graph, returns false. """ return False def ClearLattice(self): # real signature unknown; restored from __doc__ """ ClearLattice(self) -> None C++: void ClearLattice() Remove any unit cell lattice information from the molecule. """ pass def DeepCopy(self, obj): # real signature unknown; restored from __doc__ """ DeepCopy(self, obj:vtkDataObject) -> None C++: void DeepCopy(vtkDataObject *obj) override; Deep copies the data object into this molecule. """ pass def DeepCopyAttributes(self, m): # real signature unknown; restored from __doc__ """ DeepCopyAttributes(self, m:vtkMolecule) -> None C++: virtual void DeepCopyAttributes(vtkMolecule *m) Deep copies attributes (i.e. everything besides atoms and bonds) fromm into this. """ pass def DeepCopyStructure(self, m): # real signature unknown; restored from __doc__ """ DeepCopyStructure(self, m:vtkMolecule) -> None C++: virtual void DeepCopyStructure(vtkMolecule *m) Deep copies the atoms and bonds from m into this. """ pass def GetActualMemorySize(self): # real signature unknown; restored from __doc__ """ GetActualMemorySize(self) -> int C++: unsigned long GetActualMemorySize() override; Return the actual size of the data in kibibytes (1024 bytes). This number is valid only after the pipeline has updated. The memory size returned is guaranteed to be greater than or equal to the memory required to represent the data (e.g., extra space in arrays, etc. are not included in the return value). """ return 0 def GetAtom(self, atomId): # real signature unknown; restored from __doc__ """ GetAtom(self, atomId:int) -> vtkAtom C++: vtkAtom GetAtom(vtkIdType atomId) Return a vtkAtom that refers to the atom with the specified id. """ return vtkAtom def GetAtomAtomicNumber(self, atomId): # real signature unknown; restored from __doc__ """ GetAtomAtomicNumber(self, atomId:int) -> int C++: unsigned short GetAtomAtomicNumber(vtkIdType atomId) Return the atomic number of the atom with the specified id. """ return 0 def GetAtomData(self): # real signature unknown; restored from __doc__ """ GetAtomData(self) -> vtkDataSetAttributes C++: vtkDataSetAttributes *GetAtomData() Return the VertexData of the underlying graph """ return vtkDataSetAttributes def GetAtomGhostArray(self): # real signature unknown; restored from __doc__ """ GetAtomGhostArray(self) -> vtkUnsignedCharArray C++: vtkUnsignedCharArray *GetAtomGhostArray() Get the array that defines the ghost type of each atom. """ pass def GetAtomicNumberArray(self): # real signature unknown; restored from __doc__ """ GetAtomicNumberArray(self) -> vtkUnsignedShortArray C++: vtkUnsignedShortArray *GetAtomicNumberArray() """ pass def GetAtomicNumberArrayName(self): # real signature unknown; restored from __doc__ """ GetAtomicNumberArrayName(self) -> str C++: virtual char *GetAtomicNumberArrayName() """ return "" def GetAtomicPositionArray(self): # real signature unknown; restored from __doc__ """ GetAtomicPositionArray(self) -> vtkPoints C++: vtkPoints *GetAtomicPositionArray() Access the raw arrays used in this vtkMolecule instance """ pass def GetAtomPosition(self, atomId): # real signature unknown; restored from __doc__ """ GetAtomPosition(self, atomId:int) -> vtkVector3f C++: vtkVector3f GetAtomPosition(vtkIdType atomId) GetAtomPosition(self, atomId:int, pos:[float, float, float]) -> None C++: void GetAtomPosition(vtkIdType atomId, double pos[3]) Get the position of the atom with the specified id. """ return vtkVector3f def GetBond(self, bondId): # real signature unknown; restored from __doc__ """ GetBond(self, bondId:int) -> vtkBond C++: vtkBond GetBond(vtkIdType bondId) Return a vtkAtom that refers to the bond with the specified id. """ return vtkBond def GetBondData(self): # real signature unknown; restored from __doc__ """ GetBondData(self) -> vtkDataSetAttributes C++: vtkDataSetAttributes *GetBondData() Return the EdgeData of the underlying graph """ return vtkDataSetAttributes def GetBondGhostArray(self): # real signature unknown; restored from __doc__ """ GetBondGhostArray(self) -> vtkUnsignedCharArray C++: vtkUnsignedCharArray *GetBondGhostArray() Get the array that defines the ghost type of each bond. """ pass def GetBondId(self, a, b): # real signature unknown; restored from __doc__ """ GetBondId(self, a:int, b:int) -> int C++: vtkIdType GetBondId(vtkIdType a, vtkIdType b) Return the edge id from the underlying graph. """ return 0 def GetBondLength(self, bondId): # real signature unknown; restored from __doc__ """ GetBondLength(self, bondId:int) -> float C++: double GetBondLength(vtkIdType bondId) Get the bond length of the bond with the specified id * ote If the associated vtkBond object is already available, * vtkBond::GetBondLength is potentially much faster than this * function, as a list of all bonds may need to be constructed to * locate the appropriate bond. * \sa UpdateBondList() """ return 0.0 def GetBondOrder(self, bondId): # real signature unknown; restored from __doc__ """ GetBondOrder(self, bondId:int) -> int C++: unsigned short GetBondOrder(vtkIdType bondId) """ return 0 def GetBondOrdersArray(self): # real signature unknown; restored from __doc__ """ GetBondOrdersArray(self) -> vtkUnsignedShortArray C++: vtkUnsignedShortArray *GetBondOrdersArray() """ pass def GetBondOrdersArrayName(self): # real signature unknown; restored from __doc__ """ GetBondOrdersArrayName(self) -> str C++: virtual char *GetBondOrdersArrayName() """ return "" def GetData(self, info): # real signature unknown; restored from __doc__ """ GetData(info:vtkInformation) -> vtkMolecule C++: static vtkMolecule *GetData(vtkInformation *info) GetData(v:vtkInformationVector, i:int=0) -> vtkMolecule C++: static vtkMolecule *GetData(vtkInformationVector *v, int i=0) Retrieve a molecule from an information vector. """ return vtkMolecule def GetDataObjectType(self): # real signature unknown; restored from __doc__ """ GetDataObjectType(self) -> int C++: int GetDataObjectType() override; Return what type of dataset this is. """ return 0 def GetElectronicData(self): # real signature unknown; restored from __doc__ """ GetElectronicData(self) -> vtkAbstractElectronicData C++: virtual vtkAbstractElectronicData *GetElectronicData() Set/Get the AbstractElectronicData-subclassed object for this molecule. """ return vtkAbstractElectronicData def GetLattice(self): # real signature unknown; restored from __doc__ """ GetLattice(self) -> vtkMatrix3x3 C++: vtkMatrix3x3 *GetLattice() GetLattice(self, a:vtkVector3d, b:vtkVector3d, c:vtkVector3d) -> None C++: void GetLattice(vtkVector3d &a, vtkVector3d &b, vtkVector3d &c) GetLattice(self, a:vtkVector3d, b:vtkVector3d, c:vtkVector3d, origin:vtkVector3d) -> None C++: void GetLattice(vtkVector3d &a, vtkVector3d &b, vtkVector3d &c, vtkVector3d &origin) Get the unit cell lattice vectors. The matrix is stored using a row-major layout, with the vectors encoded as columns. Will return nullptr if no unit cell information is available. @sa GetLatticeOrigin """ pass def GetLatticeOrigin(self): # real signature unknown; restored from __doc__ """ GetLatticeOrigin(self) -> vtkVector3d C++: virtual vtkVector3d GetLatticeOrigin() Get the unit cell origin (for rendering purposes). """ return vtkVector3d def GetNumberOfAtoms(self): # real signature unknown; restored from __doc__ """ GetNumberOfAtoms(self) -> int C++: vtkIdType GetNumberOfAtoms() Return the number of atoms in the molecule. """ return 0 def GetNumberOfBonds(self): # real signature unknown; restored from __doc__ """ GetNumberOfBonds(self) -> int C++: vtkIdType GetNumberOfBonds() Return the number of bonds in the molecule. """ return 0 def GetNumberOfGenerationsFromBase(self, type): # real signature unknown; restored from __doc__ """ GetNumberOfGenerationsFromBase(self, type:str) -> int C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type) override; Given the name of a base class of this class type, return the distance of inheritance between this class type and the named class (how many generations of inheritance are there between this class and the named class). If the named class is not in this class's inheritance tree, return a negative value. Valid responses will always be nonnegative. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def GetNumberOfGenerationsFromBaseType(self, type): # real signature unknown; restored from __doc__ """ GetNumberOfGenerationsFromBaseType(type:str) -> int C++: static vtkIdType GetNumberOfGenerationsFromBaseType( const char *type) Given a the name of a base class of this class type, return the distance of inheritance between this class type and the named class (how many generations of inheritance are there between this class and the named class). If the named class is not in this class's inheritance tree, return a negative value. Valid responses will always be nonnegative. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def GetPlaneFromBond(self, bond, normal, plane): # real signature unknown; restored from __doc__ """ GetPlaneFromBond(bond:vtkBond, normal:vtkVector3f, plane:vtkPlane) -> bool C++: static bool GetPlaneFromBond(const vtkBond &bond, const vtkVector3f &normal, vtkPlane *plane) GetPlaneFromBond(atom1:vtkAtom, atom2:vtkAtom, normal:vtkVector3f, plane:vtkPlane) -> bool C++: static bool GetPlaneFromBond(const vtkAtom &atom1, const vtkAtom &atom2, const vtkVector3f &normal, vtkPlane *plane) Obtain the plane that passes through the indicated bond with the given normal. If the plane is set successfully, the function returns true. * If the normal is not orthogonal to the bond, a new normal will be * constructed in such a way that the plane will be orthogonal to * the plane spanned by the bond vector and the input normal vector. * This ensures that the plane passes through the bond, and the * normal is more of a "hint" indicating the orientation of the plane. * The new normal (n) is defined as the input normal vector (n_i) minus * the projection of itself (proj[n_i]_v) onto the bond vector (v): * * v ^ * | n = (n_i - proj[n_j]_v) * proj[n_i]_v ^ |----x * | | / * | | / n_i * | | / * | |/ * * If n_i is parallel to v, a warning will be printed and no plane will be * added. Obviously, n_i must not be parallel to v. """ return False def HasLattice(self): # real signature unknown; restored from __doc__ """ HasLattice(self) -> bool C++: bool HasLattice() Return true if a unit cell lattice is defined. """ return False def Initialize(self): # real signature unknown; restored from __doc__ """ Initialize(self) -> None C++: void Initialize() override; Initialize(self, atomPositions:vtkPoints, atomicNumberArray:vtkDataArray, atomData:vtkDataSetAttributes) -> int C++: int Initialize(vtkPoints *atomPositions, vtkDataArray *atomicNumberArray, vtkDataSetAttributes *atomData) Initialize(self, atomPositions:vtkPoints, atomData:vtkDataSetAttributes) -> int C++: int Initialize(vtkPoints *atomPositions, vtkDataSetAttributes *atomData) Initialize(self, molecule:vtkMolecule) -> int C++: int Initialize(vtkMolecule *molecule) Initialize to an empty graph. """ pass def IsA(self, type): # real signature unknown; restored from __doc__ """ IsA(self, type:str) -> int C++: vtkTypeBool IsA(const char *type) override; Return 1 if this class is the same type of (or a subclass of) the named class. Returns 0 otherwise. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def IsTypeOf(self, type): # real signature unknown; restored from __doc__ """ IsTypeOf(type:str) -> int C++: static vtkTypeBool IsTypeOf(const char *type) Return 1 if this class type is the same type of (or a subclass of) the named class. Returns 0 otherwise. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def NewInstance(self): # real signature unknown; restored from __doc__ """ NewInstance(self) -> vtkMolecule C++: vtkMolecule *NewInstance() """ return vtkMolecule def SafeDownCast(self, o): # real signature unknown; restored from __doc__ """ SafeDownCast(o:vtkObjectBase) -> vtkMolecule C++: static vtkMolecule *SafeDownCast(vtkObjectBase *o) """ return vtkMolecule def SetAtomAtomicNumber(self, atomId, atomicNum): # real signature unknown; restored from __doc__ """ SetAtomAtomicNumber(self, atomId:int, atomicNum:int) -> None C++: void SetAtomAtomicNumber(vtkIdType atomId, unsigned short atomicNum) Set the atomic number of the atom with the specified id. """ pass def SetAtomicNumberArrayName(self, _arg): # real signature unknown; restored from __doc__ """ SetAtomicNumberArrayName(self, _arg:str) -> None C++: virtual void SetAtomicNumberArrayName(const char *_arg) Get/Set the atomic number array name. """ pass def SetAtomPosition(self, atomId, pos): # real signature unknown; restored from __doc__ """ SetAtomPosition(self, atomId:int, pos:vtkVector3f) -> None C++: void SetAtomPosition(vtkIdType atomId, const vtkVector3f &pos) SetAtomPosition(self, atomId:int, x:float, y:float, z:float) -> None C++: void SetAtomPosition(vtkIdType atomId, double x, double y, double z) SetAtomPosition(self, atomId:int, pos:[float, float, float]) -> None C++: void SetAtomPosition(vtkIdType atomId, double pos[3]) Set the position of the atom with the specified id. """ pass def SetBondOrder(self, bondId, order): # real signature unknown; restored from __doc__ """ SetBondOrder(self, bondId:int, order:int) -> None C++: void SetBondOrder(vtkIdType bondId, unsigned short order) Get/Set the bond order of the bond with the specified id """ pass def SetBondOrdersArrayName(self, _arg): # real signature unknown; restored from __doc__ """ SetBondOrdersArrayName(self, _arg:str) -> None C++: virtual void SetBondOrdersArrayName(const char *_arg) Get/Set the bond orders array name. """ pass def SetElectronicData(self, __a): # real signature unknown; restored from __doc__ """ SetElectronicData(self, __a:vtkAbstractElectronicData) -> None C++: virtual void SetElectronicData(vtkAbstractElectronicData *) """ pass def SetLattice(self, matrix): # real signature unknown; restored from __doc__ """ SetLattice(self, matrix:vtkMatrix3x3) -> None C++: void SetLattice(vtkMatrix3x3 *matrix) SetLattice(self, a:vtkVector3d, b:vtkVector3d, c:vtkVector3d) -> None C++: void SetLattice(const vtkVector3d &a, const vtkVector3d &b, const vtkVector3d &c) The unit cell vectors. The matrix is stored using a row-major layout, with the vectors encoded as columns. """ pass def SetLatticeOrigin(self, _arg): # real signature unknown; restored from __doc__ """ SetLatticeOrigin(self, _arg:vtkVector3d) -> None C++: virtual void SetLatticeOrigin(vtkVector3d _arg) """ pass def ShallowCopy(self, obj): # real signature unknown; restored from __doc__ """ ShallowCopy(self, obj:vtkDataObject) -> None C++: void ShallowCopy(vtkDataObject *obj) override; Shallow copies the data object into this molecule. """ pass def ShallowCopyAttributes(self, m): # real signature unknown; restored from __doc__ """ ShallowCopyAttributes(self, m:vtkMolecule) -> None C++: virtual void ShallowCopyAttributes(vtkMolecule *m) Shallow copies attributes (i.e. everything besides atoms and bonds) fromm into this. """ pass def ShallowCopyStructure(self, m): # real signature unknown; restored from __doc__ """ ShallowCopyStructure(self, m:vtkMolecule) -> None C++: virtual void ShallowCopyStructure(vtkMolecule *m) Shallow copies the atoms and bonds from m into this. """ pass def __delattr__(self, *args, **kwargs): # real signature unknown """ Implement delattr(self, name). """ pass def __getattribute__(self, *args, **kwargs): # real signature unknown """ Return getattr(self, name). """ pass def __init__(self, *args, **kwargs): # real signature unknown pass @staticmethod # known case of __new__ def __new__(*args, **kwargs): # real signature unknown """ Create and return a new object. See help(type) for accurate signature. """ pass def __repr__(self, *args, **kwargs): # real signature unknown """ Return repr(self). """ pass def __setattr__(self, *args, **kwargs): # real signature unknown """ Implement setattr(self, name, value). """ pass def __str__(self, *args, **kwargs): # real signature unknown """ Return str(self). """ pass __this__ = property(lambda self: object(), lambda self, v: None, lambda self: None) # default """Pointer to the C++ object.""" __dict__ = None # (!) real value is 'mappingproxy({\'__vtkname__\': \'vtkMolecule\', \'IsTypeOf\': , \'IsA\': , \'SafeDownCast\': , \'NewInstance\': , \'GetNumberOfGenerationsFromBaseType\': , \'GetNumberOfGenerationsFromBase\': , \'Initialize\': , \'GetDataObjectType\': , \'AppendAtom\': , \'GetAtom\': , \'GetNumberOfAtoms\': , \'AppendBond\': , \'GetBond\': , \'GetNumberOfBonds\': , \'GetAtomAtomicNumber\': , \'SetAtomAtomicNumber\': , \'SetAtomPosition\': , \'GetAtomPosition\': , \'SetBondOrder\': , \'GetBondOrder\': , \'GetBondLength\': , \'GetAtomicPositionArray\': , \'GetAtomicNumberArray\': , \'GetBondOrdersArray\': , \'GetElectronicData\': , \'SetElectronicData\': , \'CheckedShallowCopy\': , \'CheckedDeepCopy\': , \'ShallowCopy\': , \'DeepCopy\': , \'ShallowCopyStructure\': , \'DeepCopyStructure\': , \'ShallowCopyAttributes\': , \'DeepCopyAttributes\': , \'GetPlaneFromBond\': , \'HasLattice\': , \'ClearLattice\': , \'SetLattice\': , \'GetLattice\': , \'GetLatticeOrigin\': , \'SetLatticeOrigin\': , \'GetAtomGhostArray\': , \'AllocateAtomGhostArray\': , \'GetBondGhostArray\': , \'AllocateBondGhostArray\': , \'GetData\': , \'GetAtomData\': , \'GetBondData\': , \'GetBondId\': , \'SetAtomicNumberArrayName\': , \'GetAtomicNumberArrayName\': , \'SetBondOrdersArrayName\': , \'GetBondOrdersArrayName\': , \'GetActualMemorySize\': , \'__new__\': , \'__repr__\': , \'__str__\': , \'__getattribute__\': , \'__setattr__\': , \'__delattr__\': , \'__dict__\': , \'__this__\': , \'__doc__\': "vtkMolecule - class describing a molecule\\n\\nSuperclass: vtkUndirectedGraph\\n\\nvtkMolecule and the convenience classes vtkAtom and vtkBond describe\\nthe geometry and connectivity of a molecule. The molecule can be\\nconstructed using the AppendAtom() and AppendBond() methods in one of\\ntwo ways; either by fully specifying the atom/bond in a single call,\\nor by incrementally setting the various attributes using the\\nconvenience vtkAtom and vtkBond classes:\\n\\nSingle call:vtkMolecule *mol = vtkMolecule::New();\\nvtkAtom h1 = mol->AppendAtom(1, 0.0, 0.0, -0.5);\\nvtkAtom h2 = mol->AppendAtom(1, 0.0, 0.0, 0.5);\\nvtkBond b = mol->AppendBond(h1, h2, 1);\\n\\nIncremental:vtkMolecule *mol = vtkMolecule::New();\\n\\nvtkAtom h1 = mol->AppendAtom(); h1.SetAtomicNumber(1);\\nh1.SetPosition(0.0, 0.0, -0.5);\\n\\nvtkAtom h2 = mol->AppendAtom(); h2.SetAtomicNumber(1); vtkVector3d\\ndisplacement (0.0, 0.0, 1.0);\\nh2.SetPosition(h1.GetPositionAsVector3d() + displacement);\\n\\nvtkBond b = mol->AppendBond(h1, h2, 1);\\n\\nBoth of the above methods will produce the same molecule, two\\nhydrogens connected with a 1.0 Angstrom single bond, aligned to the\\nz-axis. The second example also demonstrates the use of VTK\'s\\nvtkVector class, which is fully supported by the Chemistry kit.\\n\\nThe vtkMolecule object is intended to be used with the\\nvtkMoleculeMapper class for visualizing molecular structure using\\ncommon rendering techniques.\\n\\n\\\\warning While direct use of the underlying vtkUndirectedGraph\\nstructure is possible due to vtkMolecule\'s public inheritance, this\\nshould not be relied upon and may change in the future.\\n\\n@sa\\nvtkAtom vtkBond vtkMoleculeMapper vtkPeriodicTable\\n\\n"})' __vtkname__ = 'vtkMolecule'