def validate_player(ctx, param, value):
if not value:
return value
file_info = QFileInfo(value)
if file_info and file_info.isExecutable():
return file_info.filePath()
file_info = QFileInfo(shutil.which(value))
if file_info and file_info.isExecutable():
return file_info.filePath()
if is_windows():
from contextlib import suppress
from pathlib import Path
import winreg
import itertools
filename = Path(value.lower()).stem
with suppress(WindowsError), winreg.OpenKey(
winreg.HKEY_LOCAL_MACHINE,
r"SOFTWARE\Microsoft\Windows\CurrentVersion\App Paths",
) as k:
for i in itertools.count():
subkey = winreg.EnumKey(k, i)
if Path(subkey.lower()).stem == filename:
with winreg.OpenKey(k, subkey) as filekey:
val, _ = winreg.QueryValueEx(filekey, None)
file_info = QFileInfo(val)
if file_info and file_info.isExecutable():
return file_info.filePath()
raise click.BadParameter("Player must an executable")
def replaceImage(self, filepath, title):
self.title = title
self.filepath = filepath
# set custom properties
self.setCustomProperty("title", title)
self.setCustomProperty("filepath", self.filepath)
self.setName(title)
fileInfo = QFileInfo(filepath)
ext = fileInfo.suffix()
if ext == "pdf":
s = QSettings()
oldValidation = s.value("/Projections/defaultBehavior")
s.setValue(
"/Projections/defaultBehavior", "useGlobal"
) # for not asking about crs
path = fileInfo.filePath()
baseName = fileInfo.baseName()
layer = QgsRasterLayer(path, baseName)
self.image = layer.previewAsImage(QSize(layer.width(), layer.height()))
s.setValue("/Projections/defaultBehavior", oldValidation)
else:
reader = QImageReader(filepath)
self.image = reader.read()
self.repaint()
def read_qgsrasterlayer_from_file(spatial_data_file_abs):
"""
Reads the full pathname of spatial data file and returns a QGSRasterLayer object.
Args:
spatial_data_file_abs (str): the full pathname to a spatial data file
Raises:
IOError if the file is invalid.
Returns:
A QGSRasterLayer object containing the data from the input spatial data file.
"""
# Get the filename and basename of the input raster file.
fileInfo = QFileInfo(spatial_data_file_abs)
path = fileInfo.filePath()
baseName = fileInfo.baseName()
# Create the QgsRasterLayer object.
qgs_raster_layer_obj = QgsRasterLayer(path, baseName)
# Return the QgsRasterLayer if it is valid.
if qgs_raster_layer_obj.isValid():
return qgs_raster_layer_obj
# If the created QGSRasterLayer object is invalid, print an error message and return None.
else:
message = 'The QGSRasterLayer for file "{}" is invalid.'.format(
spatial_data_file_abs)
logger = logging.getLogger(__name__)
logger.warning(message)
raise IOError(message)
def dropEvent(self, event):
if (event.mimeData().hasUrls()):
urlList = event.mimeData().urls()
fileInfo = QFileInfo(urlList[0].toLocalFile())
img_full_path = fileInfo.filePath()
with open(img_full_path, 'rb') as fp:
file_bytes = fp.read()
self.run_ocr_async(file_bytes)
event.acceptProposedAction()
def GetFile(self, typeOfFile, suff):
options = QFileDialog.Options()
fileName, _ = QFileDialog.getOpenFileName(
self,
"Open {} File".format(typeOfFile),
"",
"{}".format(suff),
options=options)
if fileName:
if typeOfFile == "any":
myCipher.fileToBeSigned = fileName
f = QFileInfo(fileName)
n = f.fileName()
file_info = "Informations about the file:\n \n"
file_info += "Name: " + n + "\n"
p = f.filePath()
file_info += "Path: " + p + "\n"
suf = f.suffix()
file_info += "Suffix: " + suf + "\n"
size = f.size()
file_info += "Size (in bytes): " + str(size) + "\n"
lastModify = f.lastModified().toPyDateTime()
file_info += "Date of last change: " + str(lastModify)
self.fileInfo.setText(file_info)
elif typeOfFile == "Signed":
myCipher.userFile = fileName
elif typeOfFile == "Private key":
myCipher.privPath = fileName
with open(fileName, "r") as f:
f.seek(4)
base64Text = f.readline()
decodedBase64D = self.decodeFromBase64(base64Text)
myCipher.d = int(decodedBase64D, 10)
base64Text2 = f.readline()
decodedBase64N = self.decodeFromBase64(base64Text2)
myCipher.n = int(decodedBase64N, 10)
elif typeOfFile == "Public key":
myCipher.pubPath = fileName
with open(fileName, "r") as f:
f.seek(4)
base64Text = f.readline()
decodedBase64E = self.decodeFromBase64(base64Text)
myCipher.e = int(decodedBase64E, 10)
base64Text2 = f.readline()
decodedBase64N = self.decodeFromBase64(base64Text2)
myCipher.n = int(decodedBase64N, 10)
elif typeOfFile == "Zip":
myCipher.zipPath = fileName
with zipfile.ZipFile(fileName, "r") as z:
z.extractall("Extracted_files")
elif typeOfFile == "Sign":
myCipher.fileToBeVerified = fileName
with open(fileName, "r") as f:
f.seek(13)
base64Text = f.readline()
decodedBase64 = self.decodeFromBase64(base64Text)
myCipher.toVerifyMessage = list(decodedBase64)
def dropEvent(self, event):
if (event.mimeData().hasUrls()):
self.ui.lineEdit.clear()
urlList = event.mimeData().urls()
fileInfo = QFileInfo(urlList[0].toLocalFile())
img_full_path = fileInfo.filePath()
self.signal_img.emit(QPixmap(img_full_path))
self.run_upload_async(img_full_path)
event.acceptProposedAction()
def insertFromMimeData(self, mime):
if mime.hasImage():
tag = datetime.datetime.now().time().strftime("%H%M%S")
url = QUrl("dropped_image_" + str(tag))
self.dropImage(url, mime.imageData())
mime.imageData().save("/tmp/" + url.toString(), "png")
elif mime.hasUrls():
for url in mime.urls():
info = QFileInfo(url.toLocalFile())
ext = info.suffix().lower().encode('latin-1')
if ext in QImageReader.supportedImageFormats():
print(str(info.filePath()))
self.dropImage(url, info.filePath())
else:
self.dropTextFile(url)
else:
super().insertFromMimeData(mime)
def addAnnotationButtonClicked(self):
self.resetSelectionBand()
labelIndex = self.labelComboBox.currentIndex()
if labelIndex < 0:
messageBox = QMessageBox()
messageBox.setIcon(QMessageBox.Information)
messageBox.setText("Label is not selected.")
messageBox.exec_()
return
currentMapTool = iface.mapCanvas().mapTool()
if not isinstance(currentMapTool, SelectMapTool):
messageBox = QMessageBox()
messageBox.setIcon(QMessageBox.Information)
messageBox.setText("Object is not selected.")
messageBox.exec_()
return
if not currentMapTool.isValid():
messageBox = QMessageBox()
messageBox.setIcon(QMessageBox.Information)
messageBox.setText("Selection is not valid.")
messageBox.exec_()
return
information = currentMapTool.getInformation()
if information is None:
messageBox = QMessageBox()
messageBox.setIcon(QMessageBox.Information)
messageBox.setText("Information cannot be retrieved.")
messageBox.exec_()
return
crs = information.getCRS()
aY, aX, bY, bX = information.getAbsoluteSelection()
c1, c2 = information.getCoordinates()
file = QFileInfo(information.getDataSource())
row = [
self.labelComboBox.currentText(),
file.baseName(),
file.filePath(),
crs.authid(),
str(aY),
str(aX),
str(bY),
str(bX),
str(c1.x()),
str(c1.y()),
str(c2.x()),
str(c2.y())
]
self.model.appendRow([QStandardItem(item) for item in row])
currentMapTool.reset()
def icon(self):
fnisPath = self.__organizer.pluginSetting(self.name(), "fnis-path")
if os.path.exists(fnisPath):
# We can't directly grab the icon from an executable, but this seems like the simplest alternative.
fin = QFileInfo(fnisPath)
model = QFileSystemModel()
model.setRootPath(fin.path())
return model.fileIcon(model.index(fin.filePath()))
else:
# Fall back to where the user might have put an icon manually.
return QIcon("plugins/FNIS.ico")
def _fileinfo_from_user(self, user_path):
""" Convert the name of a file or directory specified by the user to a
QFileInfo instance. A user path may be relative to the name of the
project and may contain environment variables.
"""
fi = QFileInfo(self.expandvars(user_path.strip()))
if fi.isRelative() and self._name is not None:
fi = QFileInfo(self._name.canonicalPath() + '/' + fi.filePath())
return fi
def _fileinfo_from_user(self, user_path):
""" Convert the name of a file or directory specified by the user to a
QFileInfo instance. A user path may be relative to the name of the
project and may contain environment variables.
"""
fi = QFileInfo(self.expandvars(user_path.strip()))
if fi.isRelative() and self._name is not None:
fi = QFileInfo(self._name.canonicalPath() + '/' + fi.filePath())
return fi
def __loadFlashCookiesFromPath(self, path):
"""
Private slot to load the Flash cookies from a path.
@param path Flash cookies path
@type str
"""
if path.endswith("#AppContainer"):
# specific to IE and Windows
return
path = path.replace("\\", "/")
solDir = QDir(path)
entryList = solDir.entryList()
for entry in entryList:
if entry == "." or entry == "..":
continue
entryInfo = QFileInfo(path + "/" + entry)
if entryInfo.isDir():
self.__loadFlashCookiesFromPath(entryInfo.filePath())
else:
self.__insertFlashCookie(entryInfo.filePath())
def __loadFlashCookiesFromPath(self, path):
"""
Private slot to load the Flash cookies from a path.
@param path Flash cookies path
@type str
"""
if path.endswith("#AppContainer"):
# specific to IE and Windows
return
path = path.replace("\\", "/")
solDir = QDir(path)
entryList = solDir.entryList()
for entry in entryList:
if entry == "." or entry == "..":
continue
entryInfo = QFileInfo(path + "/" + entry)
if entryInfo.isDir():
self.__loadFlashCookiesFromPath(entryInfo.filePath())
else:
self.__insertFlashCookie(entryInfo.filePath())
def currentRowChanged(self, selected, deselected):
indexes = self.annotationView.selectedIndexes()
if len(indexes) == 0:
return
rowIndex = indexes[0].row()
targetLayer = None
for node in QgsProject.instance().layerTreeRoot().findLayers():
layer = node.layer()
if isinstance(layer, QgsRasterLayer) and layer.dataProvider(
).dataSourceUri() == self.model.item(rowIndex, 2).text():
targetLayer = layer
break
root = QgsProject.instance().layerTreeRoot()
if targetLayer is None:
file = QFileInfo(self.model.item(rowIndex, 2).text())
path = file.filePath()
base = file.baseName()
targetLayer = QgsRasterLayer(path, base)
QgsProject.instance().addMapLayer(targetLayer, False)
root.insertLayer(0, targetLayer)
else:
clonedLayer = targetLayer.clone()
QgsProject.instance().removeMapLayer(targetLayer.id())
QgsProject.instance().addMapLayer(clonedLayer)
targetLayer = clonedLayer
iface.setActiveLayer(targetLayer)
crs = QgsCoordinateReferenceSystem(self.model.item(rowIndex, 3).text())
QgsProject.instance().setCrs(crs)
iface.mapCanvas().setExtent(targetLayer.extent())
point1 = QgsPointXY(float(self.model.item(rowIndex, 8).text()),
float(self.model.item(rowIndex, 9).text()))
point2 = QgsPointXY(float(self.model.item(rowIndex, 8).text()),
float(self.model.item(rowIndex, 11).text()))
point3 = QgsPointXY(float(self.model.item(rowIndex, 10).text()),
float(self.model.item(rowIndex, 11).text()))
point4 = QgsPointXY(float(self.model.item(rowIndex, 10).text()),
float(self.model.item(rowIndex, 9).text()))
self.resetSelectionBand()
self.selectionBand.addPoint(point1, False)
self.selectionBand.addPoint(point2, False)
self.selectionBand.addPoint(point3, False)
self.selectionBand.addPoint(point4, True)
self.selectionBand.setOpacity(0.5)
self.selectionBand.show()
def export_cfd_parameter(self):
self.data_dict()
print(self.input_d)
# output = output_web(r'C:/Users/BZMBN4/Desktop/123.html', self.input_d)
path = QFileDialog.getSaveFileName(self, filter='html, *.html')
try:
save_path = QFileInfo(path[0])
html_save_path = save_path.filePath()
csv_save_path = save_path.absolutePath() + '\\' + save_path.baseName() + '.csv'
output_html = output_web(html_save_path, self.input_d)
output_csv = OutputCsv(csv_save_path, self.input_d)
except Exception as e:
print(e)
def loadRaster(self, raster):
# Check if string is provided
fileInfo = QFileInfo(raster)
path = fileInfo.filePath()
baseName = fileInfo.baseName()
layer = QgsRasterLayer(path, baseName)
QgsProject.instance().addMapLayer(layer)
if layer.isValid() is True:
self.dataDisplayDlg.appendLogs("Layer was loaded successfully!")
else:
self.dataDisplayDlg.appendLogs(
"Unable to read basename and file path - Your array is probably invalid"
)
def qgis3_add_raster_to_project(iface, raster_path: Path) -> bool:
"""
Adds the Raster(raster_path) at the current open qgis project
:type iface: qgis.gui.QgisInterface
:type raster_path: Path
"""
# TODO: Refactor: NV: Feels like incorrect usage of the APIs
q_file_info = QFileInfo(raster_path.as_posix())
q_base_name = q_file_info.baseName()
q_raster_layer = QgsRasterLayer(q_file_info.filePath(), q_base_name)
if q_raster_layer.isValid():
iface.addRasterLayer(raster_path.as_posix(), raster_path.name)
return True
def dropEvent(self, event):
if (event.mimeData().hasUrls()):
urlList = event.mimeData().urls()
realList = list()
self.ui.textEdit.clear()
for url in urlList:
fileInfo = QFileInfo(url.toLocalFile())
full_path = fileInfo.filePath()
if os.path.isfile(full_path):
realList.append(full_path)
if os.path.isdir(full_path):
realList.extend(self.__getFiles(full_path))
for url in realList:
with open(url, 'rb') as fp:
file_bytes = fp.read()
self.run_ocr_async(file_bytes)
event.acceptProposedAction()
def get_journal(self, case_path, file_type):
"""
if checbox checked, it will use own journal which fill in the LineEdit_journal
if not checked, it will use default_journal func to get default journal
:param case_path:
:return: journal file path
"""
if self.checkbox_journal.isChecked():
jou_path = QFileInfo(self.edit_journal_address.text())
if (jou_path.exists()) and (jou_path.suffix() == "jou"):
return jou_path.filePath()
else:
QMessageBox.warning(self, self.make_trans('warning'),
self.make_trans('no_journal'),
QMessageBox.Yes, QMessageBox.Yes)
else:
jou_file = self.default_journal(case_path, file_type)
return jou_file
def load_dem(self, event):
"""lookup DEM raster reference of scenario, load raster and give styling"""
global_settings_layer = QgsProject.instance().mapLayersByName(
"v2_global_settings"
)[0]
source = Path(
global_settings_layer.dataProvider()
.dataSourceUri()
.split(" ")[0]
.split("=")[1][1:-1]
)
model_directory = source.parents[0]
root = QgsProject.instance().layerTreeRoot()
if not root.findGroup("background"):
grp_background = root.insertGroup(-1, "background")
else:
grp_background = root.findGroup("background")
feature = list(global_settings_layer.getFeatures())[
self.selected_scenario_index
]
dem_file = model_directory / Path(feature["dem_file"])
fileInfo = QFileInfo(str(dem_file))
path = fileInfo.filePath()
baseName = fileInfo.baseName()
dem_layer = QgsRasterLayer(str(dem_file), "Digital Elevation Model")
QgsProject.instance().addMapLayer(dem_layer, False)
grp_background.insertChildNode(0, QgsLayerTreeLayer(dem_layer))
dem_layer.loadNamedStyle(
os.path.join(os.path.dirname(__file__), "styles\DEM.qml")
)
dem_layer.renderer().setOpacity(0.5)
dem_layer.setCustomProperty("embeddedWidgets/count", 1)
dem_layer.setCustomProperty("embeddedWidgets/0/id", "transparency")
self.iface.layerTreeView().refreshLayerSymbology(dem_layer.id())
def replaceImage(self, filepath, title):
self.title = title
self.filepath = filepath
# set custom properties
self.setCustomProperty("title", title)
self.setCustomProperty("filepath", self.filepath)
self.setName(title)
fileInfo = QFileInfo(filepath)
ext = fileInfo.suffix()
if ext == "pdf":
s = QSettings()
oldValidation = s.value("/Projections/defaultBehavior")
s.setValue("/Projections/defaultBehavior", "useGlobal") # for not asking about crs
path = fileInfo.filePath()
baseName = fileInfo.baseName()
layer = QgsRasterLayer(path, baseName)
self.image = layer.previewAsImage(QSize(layer.width(), layer.height()))
s.setValue("/Projections/defaultBehavior", oldValidation)
else:
reader = QImageReader(filepath)
self.image = reader.read()
self.repaint()
def on_btnInfo_filePath_clicked(self):
self.__showBtnInfo(self.sender())
fileInfo = QFileInfo(self.ui.editFile.text())
text = fileInfo.filePath()
self.ui.textEdit.appendPlainText(text + "\n")
def dropEvent(self, event):
if (event.mimeData().hasUrls()):
urlList = event.mimeData().urls()
fileInfo = QFileInfo(urlList[0].toLocalFile())
self.setText(fileInfo.filePath())
event.acceptProposedAction()
def openProjectInQgis(self, projectDirectory, networkName):
metadataFile = os.path.join(
projectDirectory, networkName + "_Metadata.txt")
if os.path.exists(metadataFile):
# Read data as text plain to include the encoding
data = ""
with open(metadataFile, 'r', encoding="latin-1") as content_file:
data = content_file.read()
# Parse data as XML
root = ElementTree.fromstring(data)
# Get data from nodes
for qgs in root.findall('./ThirdParty/QGISRed/QGisProject'):
if ".qgs" in qgs.text or ".qgz" in qgs.text:
finfo = QFileInfo(qgs.text)
QgsProject.instance().read(finfo.filePath())
return
for groups in root.findall('./ThirdParty/QGISRed/Groups'):
for group in groups:
groupName = group.tag
root = QgsProject.instance().layerTreeRoot()
netGroup = root.addGroup(networkName)
treeGroup = netGroup.addGroup(groupName)
for lay in group.iter('Layer'):
layerName = lay.text
layerPath = os.path.join(
projectDirectory, networkName + "_" + layerName + ".shp")
if not os.path.exists(layerPath):
continue
if treeGroup is None:
vlayer = self.iface.addVectorLayer(layerPath, layerName, "ogr")
else:
vlayer = QgsVectorLayer(layerPath, layerName, "ogr")
QgsProject.instance().addMapLayer(vlayer, False)
treeGroup.insertChildNode(0, QgsLayerTreeLayer(vlayer))
if vlayer is not None:
if ".shp" in layerPath:
QGISRedUtils().setStyle(vlayer, layerName.lower())
else: # old file
gqpFilename = os.path.join(projectDirectory, networkName + ".gqp")
if os.path.exists(gqpFilename):
f = open(gqpFilename, "r")
lines = f.readlines()
qgsFile = lines[2]
if ".qgs" in qgsFile or ".qgz" in qgsFile:
finfo = QFileInfo(qgsFile)
QgsProject.instance().read(finfo.filePath())
else:
group = None
for i in range(2, len(lines)):
if "[" in lines[i]:
groupName = str(lines[i].strip("[").strip("\r\n").strip("]")).replace(networkName + " ", "")
root = QgsProject.instance().layerTreeRoot()
netGroup = root.addGroup(networkName)
group = netGroup.addGroup(groupName)
else:
layerPath = lines[i].strip("\r\n")
if not os.path.exists(layerPath):
continue
vlayer = None
layerName = os.path.splitext(os.path.basename(layerPath))[0].replace(networkName + "_", "")
if group is None:
vlayer = self.iface.addVectorLayer(
layerPath, layerName, "ogr")
else:
vlayer = QgsVectorLayer(
layerPath, layerName, "ogr")
QgsProject.instance().addMapLayer(vlayer, False)
group.insertChildNode(
0, QgsLayerTreeLayer(vlayer))
if vlayer is not None:
if ".shp" in layerPath:
names = (os.path.splitext(os.path.basename(layerPath))[0]).split("_")
nameLayer = names[len(names)-1]
QGISRedUtils().setStyle(vlayer, nameLayer.lower())
else:
self.iface.messageBar().pushMessage("Warning", "File not found", level=1, duration=5)
def initializeLayer(self, screenExtent=None):
if self.error or self.initialized or self.initializing:
return
if self.filepath is not None:
# not safe...
self.initializing = True
filepath = self.getAbsoluteFilepath()
if not os.path.exists(filepath):
# TODO integrate with BadLayerHandler ?
loadErrorDialog = LoadErrorDialog(filepath)
result = loadErrorDialog.exec_()
if result == 1:
# absolute
filepath = loadErrorDialog.lineEditImagePath.text()
# to relative if needed
self.filepath = utils.toRelativeToQGS(filepath)
self.setCustomProperty("filepath", self.filepath)
QgsProject.instance().setDirty(True)
else:
self.error = True
del loadErrorDialog
fileInfo = QFileInfo(filepath)
ext = fileInfo.suffix()
if ext == "pdf":
s = QSettings()
oldValidation = s.value("/Projections/defaultBehavior")
s.setValue("/Projections/defaultBehavior",
"useGlobal") # for not asking about crs
path = fileInfo.filePath()
baseName = fileInfo.baseName()
layer = QgsRasterLayer(path, baseName)
self.image = layer.previewAsImage(
QSize(layer.width(), layer.height()))
s.setValue("/Projections/defaultBehavior", oldValidation)
else:
reader = QImageReader(filepath)
self.image = reader.read()
self.initialized = True
self.initializing = False
self.setupCrs()
if screenExtent:
# constructor called from AddLayer action
# if not, layer loaded from QGS project file
# check if image already has georef info
# use GDAL
dataset = gdal.Open(filepath, gdal.GA_ReadOnly)
georef = None
if dataset:
georef = dataset.GetGeoTransform()
if georef and not self.is_default_geotransform(georef):
self.initializeExistingGeoreferencing(dataset, georef)
else:
# init to default params
self.setCenter(screenExtent.center())
self.setRotation(0.0)
sw = screenExtent.width()
sh = screenExtent.height()
self.resetScale(sw, sh)
self.commitTransformParameters()
def makeIcon(name, end="png"):
iconPath = QFileInfo(__file__).dir()
iconPath.cd("data")
iconPath.cd("icons")
iconPath = iconPath.filePath(f"{name}.{end}")
return QIcon(iconPath)
def initializeLayer(self, screenExtent=None):
if self.error or self.initialized or self.initializing:
return
if self.filepath is not None:
# not safe...
self.initializing = True
filepath = self.getAbsoluteFilepath()
if not os.path.exists(filepath):
# TODO integrate with BadLayerHandler ?
loadErrorDialog = LoadErrorDialog(filepath)
result = loadErrorDialog.exec_()
if result == 1:
# absolute
filepath = loadErrorDialog.lineEditImagePath.text()
# to relative if needed
self.filepath = utils.toRelativeToQGS(filepath)
self.setCustomProperty("filepath", self.filepath)
QgsProject.instance().setDirty(True)
else:
self.error = True
del loadErrorDialog
fileInfo = QFileInfo(filepath)
ext = fileInfo.suffix()
if ext == "pdf":
s = QSettings()
oldValidation = s.value("/Projections/defaultBehavior")
s.setValue("/Projections/defaultBehavior", "useGlobal") # for not asking about crs
path = fileInfo.filePath()
baseName = fileInfo.baseName()
layer = QgsRasterLayer(path, baseName)
self.image = layer.previewAsImage(QSize(layer.width(),layer.height()))
s.setValue("/Projections/defaultBehavior", oldValidation)
else:
reader = QImageReader(filepath)
self.image = reader.read()
self.initialized = True
self.initializing = False
self.setupCrs()
if screenExtent:
# constructor called from AddLayer action
# if not, layer loaded from QGS project file
# check if image already has georef info
# use GDAL
dataset = gdal.Open(filepath, gdal.GA_ReadOnly)
georef = None
if dataset:
georef = dataset.GetGeoTransform()
if georef and not self.is_default_geotransform(georef):
self.initializeExistingGeoreferencing(dataset, georef)
else:
# init to default params
self.setCenter(screenExtent.center())
self.setRotation(0.0)
sw = screenExtent.width()
sh = screenExtent.height()
self.resetScale(sw, sh)
self.commitTransformParameters()
