def test_rotMatToAffine(seed): pi = np.pi pi2 = pi / 2 for i in range(100): rots = [ -pi + 2 * pi * np.random.random(), -pi2 + 2 * pi2 * np.random.random(), -pi + 2 * pi * np.random.random() ] if np.random.random() < 0.5: origin = None else: origin = np.random.random(3) rmat = affine.axisAnglesToRotMat(*rots) mataff = affine.rotMatToAffine(rmat, origin) rotaff = affine.rotMatToAffine(rots, origin) exp = np.eye(4) exp[:3, :3] = rmat exp[:3, 3] = origin assert np.all(np.isclose(mataff, rotaff))
def rotate(infile, rx, ry, rz): basename = fslimage.removeExt(op.basename(infile)) outfile = '{}_rotated_{}_{}_{}.nii.gz'.format(basename, rx, ry, rz) img = fslimage.Image(infile) rx = rx * np.pi / 180 ry = ry * np.pi / 180 rz = rz * np.pi / 180 rot = affine.axisAnglesToRotMat(rx, ry, rz) rot = affine.rotMatToAffine(rot) img.voxToWorldMat = affine.concat(rot, img.voxToWorldMat) img.save(outfile) return outfile
def swapdim(infile): basename = fslimage.removeExt(op.basename(infile)) outfile = '{}_swapdim.nii.gz'.format(basename) img = fslimage.Image(infile) data = img.data xform = img.voxToWorldMat data = data.transpose((2, 0, 1)) rot = affine.rotMatToAffine( affine.concat(affine.axisAnglesToRotMat(np.pi / 2, 0, 0), affine.axisAnglesToRotMat(0, 0, 3 * np.pi / 2))) xform = affine.concat(xform, affine.scaleOffsetXform((1, -1, -1), (0, 0, 0)), rot) fslimage.Image(data, xform=xform, header=img.header).save(outfile) return outfile
def __genViewMatrix(self, w, h): """Generate and return a transformation matrix to be used as the model-view matrix. This includes applying the current :attr:`zoom`, :attr:`rotation` and :attr:`offset` settings, and configuring the camera. This method is called by :meth:`__setViewport`. :arg w: Canvas width in pixels :arg h: Canvas height in pixels """ opts = self.opts b = self.__displayCtx.bounds centre = [ b.xlo + 0.5 * b.xlen, b.ylo + 0.5 * b.ylen, b.zlo + 0.5 * b.zlen ] # The MV matrix comprises (in this order): # # - A rotation (the rotation property) # # - Camera configuration. With no rotation, the # camera will be looking towards the positive # Y axis (i.e. +y is forwards), and oriented # towards the positive Z axis (i.e. +z is up) # # - A translation (the offset property) # - A scaling (the zoom property) # Scaling and rotation matrices. Rotation # is always around the centre of the # displaycontext bounds (the bounding # box which contains all loaded overlays). scale = opts.zoom / 100.0 scale = affine.scaleOffsetXform([scale] * 3, 0) rotate = affine.rotMatToAffine(opts.rotation, centre) # The offset property is defined in x/y # pixels, normalised to [-1, 1]. We need # to convert them into viewport space, # where the horizontal axis maps to # (-xhalf, xhalf), and the vertical axis # maps to (-yhalf, yhalf). See # gl.routines.ortho. offset = np.array(opts.offset[:] + [0]) xlen, ylen = glroutines.adjust(b.xlen, b.ylen, w, h) offset[0] = xlen * offset[0] / 2 offset[1] = ylen * offset[1] / 2 offset = affine.scaleOffsetXform(1, offset) # And finally the camera. eye = list(centre) eye[1] += 1 up = [0, 0, 1] camera = glroutines.lookAt(eye, centre, up) # Order is very important! xform = affine.concat(offset, scale, camera, rotate) np.array(xform, dtype=np.float32) self.__viewOffset = offset self.__viewScale = scale self.__viewRotate = rotate self.__viewCamera = camera self.__viewMat = xform