code: def _calculate_node_raw_transforms(self, gltf_node):
      _rot_mat = vray.Matrix.identity
      _offset = vray.Vector(0, 0, 0)
      _scale_mat = vray.Matrix(
          vray.Vector(1, 0, 0),
          vray.Vector(0, 1, 0),
          vray.Vector(0, 0, 1),
      )
  
      updated_Transform = False
      if gltf_node.matrixTransform != None:
          matrix = vray.Matrix(
              vray.Vector(
                  gltf_node.matrixTransform[0],
                  gltf_node.matrixTransform[1],
                  gltf_node.matrixTransform[2],
              ),
              vray.Vector(
                  gltf_node.matrixTransform[4],
                  gltf_node.matrixTransform[5],
                  gltf_node.matrixTransform[6],
              ),
              vray.Vector(
                  gltf_node.matrixTransform[8],
                  gltf_node.matrixTransform[9],
                  gltf_node.matrixTransform[10],
              ),
          )
          offset = vray.Vector(
              gltf_node.matrixTransform[12],
              gltf_node.matrixTransform[13],
              gltf_node.matrixTransform[14],
          )
  
          _rot_mat = matrix
          _offset = offset
          updated_Transform = True
      else:
          if gltf_node.translation != None:
              trans_x = np.clip(
                  gltf_node.translation[0], -1.0e18, 1.0e18
              )
              trans_y = np.clip(
                  gltf_node.translation[1], -1.0e18, 1.0e18
              )
              trans_z = np.clip(
                  gltf_node.translation[2], -1.0e18, 1.0e18
              )
              offset = vray.Vector(trans_x, trans_y, trans_z)
  
              _offset = offset
  
              updated_Transform = True
  
          if gltf_node.scale != None:
              scale_x = np.clip(gltf_node.scale[0], -1.0e18, 1.0e18)
              scale_y = np.clip(gltf_node.scale[1], -1.0e18, 1.0e18)
              scale_z = np.clip(gltf_node.scale[2], -1.0e18, 1.0e18)
              scale = vray.Vector(scale_x, scale_y, scale_z)
  
              _scale_mat = vray.Matrix(
                  vray.Vector(scale[0], 0.0, 0.0),
                  vray.Vector(0.0, scale[1], 0.0),
                  vray.Vector(0.0, 0.0, scale[2]),
              )
  
              updated_Transform = True
  
          if gltf_node.rotation != None:
              qrot_x = np.clip(gltf_node.rotation[0], -1.0e18, 1.0e18)
              qrot_y = np.clip(gltf_node.rotation[1], -1.0e18, 1.0e18)
              qrot_z = np.clip(gltf_node.rotation[2], -1.0e18, 1.0e18)
              qrot_w = np.clip(gltf_node.rotation[3], -1.0e18, 1.0e18)
  
              quatRotation = pyq.Quaternion(
                  qrot_w, qrot_x, qrot_y, qrot_z
              )
              matrixRotation = quatRotation.rotation_matrix
  
              _rot_mat = vray.Matrix(
                  vray.Vector(
                      matrixRotation[0][0],
                      matrixRotation[1][0],
                      matrixRotation[2][0],
                  ),
                  vray.Vector(
                      matrixRotation[0][1],
                      matrixRotation[1][1],
                      matrixRotation[2][1],
                  ),
                  vray.Vector(
                      matrixRotation[0][2],
                      matrixRotation[1][2],
                      matrixRotation[2][2],
                  ),
              )
  
              updated_Transform = True
  
      if updated_Transform == True:
          return vray.Transform(_rot_mat * _scale_mat, _offset)
  
      return None
  
imports: from __future__ import print_function
  import os
  import sys
  import json
  import vray
  from .None import parserUtils
  from .None import cameraUtils
  import numpy
  from tempfile import mkstemp
  import math
  import pyquaternion
  import base64
  from ..None import testUtils
label_desc: Use image node_id 16 for calling the GltfParser obj's underlying member method code with example usage: obj._calculate_node_raw_transforms(gltf_node) and returns: None, vray