def recompose_image(layer, working_directory):
bands = layer.bands
image_in = layer.get_source()
num_band_pir = bands['pir']
num_band_red = bands['red']
num_band_green = bands['green']
band_pir = gdal_translate_get_one_band(image_in, num_band_pir,
working_directory)
band_red = gdal_translate_get_one_band(image_in, num_band_red,
working_directory)
band_green = gdal_translate_get_one_band(image_in, num_band_green,
working_directory)
logger.debug("pir" + band_pir)
logger.debug("red" + band_red)
logger.debug("green" + band_green)
output_filename = os.path.join(
working_directory,
os.path.splitext(os.path.basename(image_in))[0] + "pir_red_green" +
os.path.splitext(os.path.basename(image_in))[1])
logger.debug("recomposed image" + output_filename)
if not os.path.isfile(output_filename):
OTBApplications.concatenateImages_cli([band_pir, band_red, band_green],
output_filename, "uint16")
return output_filename
def run(self):
logger.debug("run, processing name" + str(self.processing_name))
logger.debug("self.arg" + str(self.arg))
output_filename = ""
if "NDVI" in self.processing_name:
output_filename = terre_image_processing.ndvi(self.layer, self.working_directory, self.iface)
if "NDTI" in self.processing_name:
output_filename = terre_image_processing.ndti(self.layer, self.working_directory, self.iface)
if "Indice de brillance" in self.processing_name:
output_filename = terre_image_processing.brightness(self.layer, self.working_directory, self.iface)
if "Angle Spectral" in self.processing_name:
self.rubberband = QgsRubberBand(self.canvas, QGis.Point)
self.rubberband.setWidth(10)
self.rubberband.setColor(QColor(Qt.yellow))
if not self.arg:
from spectral_angle import SpectralAngle
self.angle_tool = SpectralAngle(self.iface, self.working_directory, self.layer, self.mirrormap_tool, self.rubberband)
logger.debug("self.angle_tool" + str(self.angle_tool))
QObject.connect(self.angle_tool, SIGNAL("anglesComputed(PyQt_PyObject)"), self.display)
self.angle_tool.get_point_for_angles(self.layer)
# spectral_angles(self.layer, self.working_directory, self.iface)
else:
output_filename = self.arg
if "KMEANS" in self.processing_name:
if self.arg:
output_filename = terre_image_processing.kmeans(self.layer, self.working_directory, self.iface, self.arg)
else:
output_filename = terre_image_processing.kmeans(self.layer, self.working_directory, self.iface)
if "Seuillage" in self.processing_name and self.arg:
logger.debug("this is thrshold")
output_filename = terre_image_processing.threshold(self.layer, self.working_directory, self.arg)
if output_filename:
OTBApplications.compute_overviews(output_filename)
logger.debug(output_filename)
self.display(output_filename)
def contrastForRasters(the_raster_layer, min_layer, max_layer, band = None):
"""
Applies a contrast between min and max. If given min and max are 0, then calculates the min and max from gdal.
"""
# type of layer : raster, vector, other
type_of_layer = the_raster_layer.type()
# take the layer renderer to get the min and max
layer_renderer = the_raster_layer.renderer() # for qgis > 1.9
data_provider = the_raster_layer.data_provider()
# the layer has to be a raster layer
if type_of_layer == 1:
if the_raster_layer.rasterType() == 0 and layer_renderer:
# gray band
# layer_renderer <qgis.core.QgsSingleBandGrayRenderer object at 0x514caf0>
layerCE = layer_renderer.contrastEnhancement()
# take the contrast enhancement of the layer threw the renderer
if layerCE:
layerCE.setContrastEnhancementAlgorithm(3) # qgis 1.9
layerCE.setMinimumValue(min_layer)
layerCE.setMaximumValue(max_layer)
elif the_raster_layer.rasterType() == 2 and layer_renderer:
if min_layer == 0 and max_layer == 0:
if band:
min1, max1 = get_min_max_via_qgis(the_raster_layer, band[0])
min2, max2 = get_min_max_via_qgis(the_raster_layer, band[1])
min3, max3 = get_min_max_via_qgis(the_raster_layer, band[2])
# # min1, max1, _, _ = terre_image_utils.computeStatistics(the_raster_layer.source(),0, band[0])
# # min2, max2, _, _ = terre_image_utils.computeStatistics(the_raster_layer.source(),0, band[1])
# # min3, max3, _, _ = terre_image_utils.computeStatistics(the_raster_layer.source(),0, band[2])
# # #print min1, max1, min2, max2, min3, max3
else:
min1, max1, _, _ = OTBApplications.computeStatistics(the_raster_layer.source(), 0, 1)
min2, max2, _, _ = OTBApplications.computeStatistics(the_raster_layer.source(), 0, 2)
min3, max3, _, _ = OTBApplications.computeStatistics(the_raster_layer.source(), 0, 3)
red_enhancement = QgsContrastEnhancement(data_provider.dataType(0))
green_enhancement = QgsContrastEnhancement(data_provider.dataType(1))
blue_enhancement = QgsContrastEnhancement(data_provider.dataType(2))
# set stretch to min max
red_enhancement.setMinimumValue(min1)
red_enhancement.setMaximumValue(max1)
green_enhancement.setMinimumValue(min2)
green_enhancement.setMaximumValue(max2)
blue_enhancement.setMinimumValue(min3)
blue_enhancement.setMaximumValue(max3)
red_enhancement.setContrastEnhancementAlgorithm(3)
green_enhancement.setContrastEnhancementAlgorithm(3)
blue_enhancement.setContrastEnhancementAlgorithm(3)
layer_renderer.setRedContrastEnhancement(red_enhancement) # , QgsRaster.ContrastEnhancementCumulativeCut )
layer_renderer.setGreenContrastEnhancement(green_enhancement) # , QgsRaster.ContrastEnhancementCumulativeCut )
layer_renderer.setBlueContrastEnhancement(blue_enhancement) # , QgsRaster.ContrastEnhancementCumulativeCut )
the_raster_layer.triggerRepaint()
def angles(layer, working_directory, x, y):
ident = layer.get_qgis_layer().dataProvider().identify(
QgsPoint(x, y), QgsRaster.IdentifyFormatValue)
logger.debug(ident)
if ident is not None:
attr = ident.results()
logger.debug(attr)
if len(attr) == layer.get_qgis_layer().bandCount():
image_in = layer.get_qgis_layer().source()
output_filename = os.path.join(
working_directory,
os.path.basename(os.path.splitext(image_in)[0]) + "_angles" +
str(x).replace(".", "dot") + "_" + str(y).replace(".", "dot") +
os.path.splitext(image_in)[1])
if not os.path.isfile(output_filename):
num = []
denom = []
fact = []
# acos((im1b1*1269+im1b2*1060+im1b3*974+im1b4*1576)/
# (sqrt((1269*1269+1060*1060+974*974+1576*1576)*
# (im1b1*im1b1+im1b2*im1b2+im1b3*im1b3+im1b4*im1b4))))
for index in range(1, layer.get_qgis_layer().bandCount() + 1):
current_band = "im1b{}".format(index)
band_value = attr[index]
num.append(current_band + "*" + str(band_value))
denom.append(str(band_value) + "*" + str(band_value))
fact.append(current_band + "*" + current_band)
#compute denom for testing != 0
mult_denom = "({})*({})".format("+".join(denom),
"+".join(fact))
#raw formula
formula = "acos(({})/(sqrt({})))".format(
"+".join(num), mult_denom)
#add threshold
formule_ = '"({}>0.0001?1/{}:0)"'.format(formula, formula)
#add test on denom
formula_with_test_denom_diff_0 = "({}!=0?{}:0)".format(
mult_denom, formule_)
logger.debug("num {}".format(num))
logger.debug("denom {}".format(denom))
logger.debug("fact {}".format(fact))
logger.debug(
"formula {}".format(formula_with_test_denom_diff_0))
OTBApplications.bandmath_cli([image_in],
formula_with_test_denom_diff_0,
output_filename)
# rlayer = manage_QGIS.addRasterLayerToQGIS( output_filename, os.path.basename(os.path.splitext(image_in)[0]) + "_angles" + str(x) + "_" + str(y), iface )
# manage_QGIS.histogram_stretching( rlayer, iface.mapCanvas())
return output_filename
def angles(layer, working_directory, x, y):
ident = layer.get_qgis_layer().dataProvider().identify(
QgsPoint(x, y), QgsRaster.IdentifyFormatValue)
logger.debug(ident)
if ident is not None:
attr = ident.results()
logger.debug(attr)
if len(attr) == layer.get_qgis_layer().bandCount():
image_in = layer.get_qgis_layer().source()
output_filename = os.path.join(
working_directory,
os.path.basename(os.path.splitext(image_in)[0]) + "_angles" +
str(x).replace(".", "dot") + "_" + str(y).replace(".", "dot") +
os.path.splitext(image_in)[1])
if not os.path.isfile(output_filename):
num = []
denom = []
fact = []
# acos((im1b1*1269+im1b2*1060+im1b3*974+im1b4*1576)/
# (sqrt((1269*1269+1060*1060+974*974+1576*1576)*
# (im1b1*im1b1+im1b2*im1b2+im1b3*im1b3+im1b4*im1b4))))
for index in range(1, layer.get_qgis_layer().bandCount() + 1):
current_band = "im1b" + str(index)
band_value = attr[index]
num.append(current_band + "*" + str(band_value))
denom.append(str(band_value) + "*" + str(band_value))
fact.append(current_band + "*" + current_band)
formula = "if(((" + "+".join(fact) + ") != 0),"
formula += "acos("
formula += "(" + "+".join(num) + ")/"
formula += "(sqrt("
formula += "(" + "+".join(denom) + ")*"
formula += "(" + "+".join(fact) + ")"
formula += "))"
formula += "), 0)"
formule_ = "\"if( " + formula + ">0.0001, 1/" + formula + ", 0)\""
logger.debug("num" + str(num))
logger.debug("denom" + str(denom))
logger.debug("fact" + str(fact))
logger.debug("formula" + str(formula))
OTBApplications.bandmath_cli([image_in], formule_,
output_filename)
# rlayer = manage_QGIS.addRasterLayerToQGIS( output_filename, os.path.basename(os.path.splitext(image_in)[0]) + "_angles" + str(x) + "_" + str(y), iface )
# manage_QGIS.histogram_stretching( rlayer, iface.mapCanvas())
return output_filename
def export_kmz(filenames, working_directory):
"""
"""
internal_working_directory = os.path.join(working_directory, "Internal")
if not os.path.exists(internal_working_directory):
os.makedirs(internal_working_directory)
kmzs = []
for image in filenames:
size = get_image_size_with_gdal(image)
warning_size = 0
# by default, tile size of kmz export is 512
# if the image size is smaller than 512, the application does not work properly
if size[0] < 512 or size[1] < 512:
warning_size = size[0] if (size[0] < size[1]) else size[1]
kmz_tmp = OTBApplications.otbcli_export_kmz(
image, internal_working_directory, warning_size)
kmzs.append(kmz_tmp)
# attention rustine
# kmzs = glob.glob( os.path.join(internal_working_directory, "*.kmz"))
kmz_to_return = []
for kmz in kmzs:
new_path = os.path.join(working_directory, os.path.basename(kmz))
shutil.copy(kmz, new_path)
kmz_to_return.append(new_path)
return kmz_to_return
def export_kmz(filenames, working_directory):
"""
"""
internal_working_directory = os.path.join(working_directory, "Internal")
if not os.path.exists(internal_working_directory):
os.makedirs(internal_working_directory)
kmzs = []
for image in filenames:
size = get_image_size_with_gdal(image)
warning_size = 0
# by default, tile size of kmz export is 512
# if the image size is smaller than 512, the application does not work properly
if size[0] < 512 or size[1] < 512:
warning_size = size[0] if (size[0]<size[1]) else size[1]
kmz_tmp = OTBApplications.otbcli_export_kmz(image, internal_working_directory, warning_size)
kmzs.append(kmz_tmp)
# attention rustine
# kmzs = glob.glob( os.path.join(internal_working_directory, "*.kmz"))
kmz_to_return = []
for kmz in kmzs:
new_path = os.path.join(working_directory, os.path.basename(kmz))
shutil.copy(kmz, new_path)
kmz_to_return.append(new_path)
return kmz_to_return
def run(self):
logger.debug("run, processing name" + str(self.processing_name))
logger.debug("self.arg" + str(self.arg))
output_filename = ""
if "NDVI" in self.processing_name:
output_filename = terre_image_processing.ndvi(
self.layer, self.working_directory, self.iface)
if "NDTI" in self.processing_name:
output_filename = terre_image_processing.ndti(
self.layer, self.working_directory, self.iface)
if "Indice de brillance" in self.processing_name:
output_filename = terre_image_processing.brightness(
self.layer, self.working_directory, self.iface)
if "Angle Spectral" in self.processing_name:
self.rubberband = QgsRubberBand(self.canvas, QGis.Point)
self.rubberband.setWidth(10)
self.rubberband.setColor(QColor(Qt.yellow))
if not self.arg:
from spectral_angle import SpectralAngle
self.angle_tool = SpectralAngle(self.iface,
self.working_directory,
self.layer,
self.mirrormap_tool,
self.rubberband)
logger.debug("self.angle_tool" + str(self.angle_tool))
QObject.connect(self.angle_tool,
SIGNAL("anglesComputed(PyQt_PyObject)"),
self.display)
self.angle_tool.get_point_for_angles(self.layer)
# spectral_angles(self.layer, self.working_directory, self.iface)
else:
output_filename = self.arg
if "KMEANS" in self.processing_name:
if self.arg:
output_filename = terre_image_processing.kmeans(
self.layer, self.working_directory, self.iface, self.arg)
else:
output_filename = terre_image_processing.kmeans(
self.layer, self.working_directory, self.iface)
if "Seuillage" in self.processing_name and self.arg:
logger.debug("this is thrshold")
output_filename = terre_image_processing.threshold(
self.layer, self.working_directory, self.arg)
if output_filename:
OTBApplications.compute_overviews(output_filename)
logger.debug(output_filename)
self.display(output_filename)
def angles(layer, working_directory, x, y):
ident = layer.get_qgis_layer().dataProvider().identify(QgsPoint(x, y), QgsRaster.IdentifyFormatValue)
logger.debug(ident)
if ident is not None:
attr = ident.results()
logger.debug(attr)
if len(attr) == layer.get_qgis_layer().bandCount():
image_in = layer.get_qgis_layer().source()
output_filename = os.path.join(working_directory, os.path.basename(os.path.splitext(image_in)[0]) + "_angles" + str(x).replace(".", "dot") + "_" + str(y).replace(".", "dot") + os.path.splitext(image_in)[1])
if not os.path.isfile(output_filename):
num = []
denom = []
fact = []
# acos((im1b1*1269+im1b2*1060+im1b3*974+im1b4*1576)/
# (sqrt((1269*1269+1060*1060+974*974+1576*1576)*
# (im1b1*im1b1+im1b2*im1b2+im1b3*im1b3+im1b4*im1b4))))
for index in range(1, layer.get_qgis_layer().bandCount() + 1):
current_band = "im1b" + str(index)
band_value = attr[index]
num.append(current_band + "*" + str(band_value))
denom.append(str(band_value) + "*" + str(band_value))
fact.append(current_band + "*" + current_band)
formula = "if(((" + "+".join(fact) + ") != 0),"
formula += "acos("
formula += "(" + "+".join(num) + ")/"
formula += "(sqrt("
formula += "(" + "+".join(denom) + ")*"
formula += "(" + "+".join(fact) + ")"
formula += "))"
formula += "), 0)"
formule_ = "\"if( " + formula + ">0.0001, 1/" + formula + ", 0)\""
logger.debug("num" + str(num))
logger.debug("denom" + str(denom))
logger.debug("fact" + str(fact))
logger.debug("formula" + str(formula))
OTBApplications.bandmath_cli([image_in], formule_, output_filename)
# rlayer = manage_QGIS.addRasterLayerToQGIS( output_filename, os.path.basename(os.path.splitext(image_in)[0]) + "_angles" + str(x) + "_" + str(y), iface )
# manage_QGIS.histogram_stretching( rlayer, iface.mapCanvas())
return output_filename
def angles(layer, working_directory, x, y):
ident = layer.get_qgis_layer().dataProvider().identify(QgsPoint(x, y), QgsRaster.IdentifyFormatValue)
logger.debug(ident)
if ident is not None:
attr = ident.results()
logger.debug(attr)
if len(attr) == layer.get_qgis_layer().bandCount():
image_in = layer.get_qgis_layer().source()
output_filename = os.path.join(working_directory, os.path.basename(os.path.splitext(image_in)[0]) + "_angles" + str(x).replace(".", "dot") + "_" + str(y).replace(".", "dot") + os.path.splitext(image_in)[1])
if not os.path.isfile(output_filename):
num = []
denom = []
fact = []
# acos((im1b1*1269+im1b2*1060+im1b3*974+im1b4*1576)/
# (sqrt((1269*1269+1060*1060+974*974+1576*1576)*
# (im1b1*im1b1+im1b2*im1b2+im1b3*im1b3+im1b4*im1b4))))
for index in range(1, layer.get_qgis_layer().bandCount() + 1):
current_band = "im1b{}".format(index)
band_value = attr[index]
num.append(current_band + "*" + str(band_value))
denom.append(str(band_value) + "*" + str(band_value))
fact.append(current_band + "*" + current_band)
#compute denom for testing != 0
mult_denom = "({})*({})".format("+".join(denom),
"+".join(fact))
#raw formula
formula = "acos(({})/(sqrt({})))".format("+".join(num),
mult_denom)
#add threshold
formule_ = '"({}>0.0001?1/{}:0)"'.format(formula, formula)
#add test on denom
formula_with_test_denom_diff_0 = "({}!=0?{}:0)".format(mult_denom, formule_)
logger.debug("num {}".format(num))
logger.debug("denom {}".format(denom))
logger.debug("fact {}".format(fact))
logger.debug("formula {}".format(formula_with_test_denom_diff_0))
OTBApplications.bandmath_cli([image_in], formula_with_test_denom_diff_0, output_filename)
# rlayer = manage_QGIS.addRasterLayerToQGIS( output_filename, os.path.basename(os.path.splitext(image_in)[0]) + "_angles" + str(x) + "_" + str(y), iface )
# manage_QGIS.histogram_stretching( rlayer, iface.mapCanvas())
return output_filename
def recompose_image(layer, working_directory):
bands = layer.bands
image_in = layer.get_source()
num_band_pir = bands['pir']
num_band_red = bands['red']
num_band_green = bands['green']
band_pir = gdal_translate_get_one_band(image_in, num_band_pir, working_directory)
band_red = gdal_translate_get_one_band(image_in, num_band_red, working_directory)
band_green = gdal_translate_get_one_band(image_in, num_band_green, working_directory)
logger.debug("pir" + band_pir)
logger.debug("red" + band_red)
logger.debug("green" + band_green)
output_filename = os.path.join(working_directory, os.path.splitext(os.path.basename(image_in))[0] + "pir_red_green" + os.path.splitext(os.path.basename(image_in))[1])
logger.debug("recomposed image" + output_filename)
if not os.path.isfile(output_filename):
OTBApplications.concatenateImages_cli([band_pir, band_red, band_green], output_filename, "uint16")
return output_filename
def kmeans(layer, working_directory, nb_class=None):
"""
WARNING: nb_valid_pixels à calculer ?
"""
internal_working_directory = os.path.join(working_directory, "Internal")
if not os.path.exists(internal_working_directory):
os.makedirs(internal_working_directory)
logger.debug("enntree dans le kmeans")
bands = []
if nb_class is None:
testqt, ok = QInputDialog.getInt(None, "Kmeans", "Nombre de classes", 5)
if ok:
nb_class = testqt
# mask = OTBApplications.bandmath([layer.get_source()], "if(im1b1>0,1,0)", working_directory, "mask")
output = OTBApplications.kmeans_cli(layer.get_source(), nb_class, internal_working_directory)
image_ref = recompose_image(layer, internal_working_directory)
# if not os.path.isfile(output_colored):
output_colored = OTBApplications.color_mapping_cli_ref_image(output, image_ref, working_directory)
return output_colored
def ndti(layer, working_directory):
# SQRT(R+0.5)
# NDTI= (R-G)/(R+G)
if not layer:
logger.debug("Aucune layer selectionnée")
else:
if layer.red:
image_in = layer.source_file
logger.debug("image_in" + image_in)
output_filename = os.path.join(working_directory, os.path.basename(os.path.splitext(image_in)[0]) + "_ndti" + os.path.splitext(image_in)[1])
logger.debug(output_filename)
if not os.path.isfile(output_filename):
layer_red = "im1b" + str(layer.red)
layer_green = "im1b" + str(layer.green)
# expression = "\"sqrt(" + layer_red + "+0.5)\""
expression = "\"if((" + layer_red + "+" + layer_green + ")!=0,(" + layer_red + "-" + layer_green + ")/(" + layer_red + "+" + layer_green + "),0)\""
logger.debug(expression)
logger.debug("image_in" + image_in)
OTBApplications.bandmath_cli([image_in], expression, output_filename)
return output_filename
def brightness(layer, working_directory):
# IB = sqrt(RxR+PIRxPIR)
if not layer:
logger.debug("Aucune layer selectionnée")
else:
if layer.pir and layer.red:
image_in = layer.source_file
logger.debug("image_in" + image_in)
logger.debug(working_directory)
output_filename = os.path.join(working_directory,
os.path.basename(os.path.splitext(image_in)[0]) + "_brillance" + os.path.splitext(image_in)[1])
logger.debug(output_filename)
if not os.path.isfile(output_filename):
layer_pir = "im1b" + str(layer.pir)
layer_red = "im1b" + str(layer.red)
expression = "\"sqrt(" + layer_red + "*" + layer_red + "*" + layer_pir + "*" + layer_pir + ")\""
logger.debug(expression)
logger.debug("image_in" + image_in)
OTBApplications.bandmath_cli([image_in], expression, output_filename)
return output_filename
def ndvi(layer, working_directory):
# NDVI= (PIR-R)/(PIR+R)
if not layer:
logger.debug("Aucune layer selectionnée")
else:
if layer.pir and layer.red:
image_in = layer.source_file
logger.debug("image_in: " + image_in)
logger.debug(working_directory)
output_filename = os.path.join(working_directory,
os.path.basename(os.path.splitext(image_in)[0]) + "_ndvi" + os.path.splitext(image_in)[1])
logger.debug(output_filename)
if not os.path.isfile(output_filename):
layer_pir = "im1b" + str(layer.pir)
layer_red = "im1b" + str(layer.red)
expression = "\"if((" + layer_pir + "+" + layer_red + ")!=0,(" + layer_pir + "-" + layer_red + ")/(" + layer_pir + "+" + layer_red + "),0)\""
logger.debug(expression)
logger.debug("image_in" + image_in)
OTBApplications.bandmath_cli([image_in], expression, output_filename)
return output_filename
return ""
def threshold(layer, working_directory, forms):
logger.debug("threshold {}".format(forms))
image_in = layer.get_source()
temp = []
i = 1
if len(forms) == 1:
output_filename = os.path.join(
working_directory,
os.path.basename(os.path.splitext(image_in)[0]) + "_threshold" +
os.path.splitext(image_in)[1])
OTBApplications.bandmath_cli([image_in], forms[0], output_filename)
else:
for formula in forms:
output_filename = os.path.join(
working_directory,
os.path.basename(os.path.splitext(image_in)[0]) +
"_threshold" + str(i) + os.path.splitext(image_in)[1])
OTBApplications.bandmath_cli([image_in], formula, output_filename)
i += 1
temp.append(output_filename)
output_filename = os.path.join(
working_directory,
os.path.basename(os.path.splitext(image_in)[0]) + "_threshold" +
os.path.splitext(image_in)[1])
OTBApplications.concatenateImages_cli(temp, output_filename)
return output_filename
def kmeans(layer, working_directory, nb_class=None):
"""
WARNING: nb_valid_pixels à calculer ?
"""
internal_working_directory = os.path.join(working_directory, "Internal")
if not os.path.exists(internal_working_directory):
os.makedirs(internal_working_directory)
logger.debug("enntree dans le kmeans")
bands = []
if nb_class is None:
testqt, ok = QInputDialog.getInt(None, "Kmeans", "Nombre de classes",
5)
if ok:
nb_class = testqt
# mask = OTBApplications.bandmath([layer.get_source()], "if(im1b1>0,1,0)", working_directory, "mask")
output = OTBApplications.kmeans_cli(layer.get_source(), nb_class,
internal_working_directory)
image_ref = recompose_image(layer, internal_working_directory)
# if not os.path.isfile(output_colored):
output_colored = OTBApplications.color_mapping_cli_ref_image(
output, image_ref, working_directory)
return output_colored
def brightness(layer, working_directory):
# IB = sqrt(RxR+PIRxPIR)
if not layer:
logger.debug("Aucune layer selectionnée")
else:
if layer.pir and layer.red:
image_in = layer.source_file
logger.debug("image_in" + image_in)
logger.debug(working_directory)
output_filename = os.path.join(
working_directory,
os.path.basename(os.path.splitext(image_in)[0]) +
"_brillance" + os.path.splitext(image_in)[1])
logger.debug(output_filename)
if not os.path.isfile(output_filename):
layer_pir = "im1b{}".format(layer.pir)
layer_red = "im1b{}".format(layer.red)
expression = "\"sqrt(" + layer_red + "*" + layer_red + "+" + layer_pir + "*" + layer_pir + ")\""
logger.debug(expression)
logger.debug("image_in" + image_in)
OTBApplications.bandmath_cli([image_in], expression,
output_filename)
return output_filename
def ndti(layer, working_directory):
# SQRT(R+0.5)
# NDTI= (R-G)/(R+G)
if not layer:
logger.debug("Aucune layer selectionnée")
else:
if layer.red:
image_in = layer.source_file
logger.debug("image_in" + image_in)
output_filename = os.path.join(
working_directory,
os.path.basename(os.path.splitext(image_in)[0]) + "_ndti" +
os.path.splitext(image_in)[1])
logger.debug(output_filename)
if not os.path.isfile(output_filename):
layer_red = "im1b{}".format(layer.red)
layer_green = "im1b{}".format(layer.green)
# expression = "\"sqrt(" + layer_red + "+0.5)\""
expression = "\"((" + layer_red + "+" + layer_green + ")!=0?(" + layer_red + "-" + layer_green + ")/(" + layer_red + "+" + layer_green + "):0)\""
logger.debug(expression)
logger.debug("image_in" + image_in)
OTBApplications.bandmath_cli([image_in], expression,
output_filename)
return output_filename
def ndvi(layer, working_directory):
# NDVI= (PIR-R)/(PIR+R)
if not layer:
logger.debug("Aucune layer selectionnée")
else:
if layer.pir and layer.red:
image_in = layer.source_file
logger.debug("image_in: " + image_in)
logger.debug(working_directory)
output_filename = os.path.join(
working_directory,
os.path.basename(os.path.splitext(image_in)[0]) + "_ndvi" +
os.path.splitext(image_in)[1])
logger.debug(output_filename)
if not os.path.isfile(output_filename):
layer_pir = "im1b{}".format(layer.pir)
layer_red = "im1b{}".format(layer.red)
expression = "\"((" + layer_pir + "+" + layer_red + ")!=0?(" + layer_pir + "-" + layer_red + ")/(" + layer_pir + "+" + layer_red + "):0)\""
logger.debug(expression)
logger.debug("image_in" + image_in)
OTBApplications.bandmath_cli([image_in], expression,
output_filename)
return output_filename
return ""
def export_kmz(filenames, working_directory):
"""
"""
internal_working_directory = os.path.join(working_directory, "Internal")
if not os.path.exists(internal_working_directory):
os.makedirs(internal_working_directory)
kmzs = []
for image in filenames:
kmz_tmp = OTBApplications.otbcli_export_kmz(image, internal_working_directory)
kmzs.append(kmz_tmp)
# attention rustine
# kmzs = glob.glob( os.path.join(internal_working_directory, "*.kmz"))
kmz_to_return = []
for kmz in kmzs:
new_path = os.path.join(working_directory, os.path.basename(kmz))
shutil.copy(kmz, new_path)
kmz_to_return.append(new_path)
return kmz_to_return
def get_sensor_id(image):
"""
Returns the sensor of the given image if found by ReadImageInfo
Args:
image:
Returns:
"""
result_sensor = OTBApplications.read_image_info_cli(image)
if result_sensor:
# type(result_sensor) = PyQt4.QtCore.QByteArray
for line in str(result_sensor).splitlines():
if "sensor" in line:
# sensor_line = result_sensor[0]
sensor = re.search('sensor: ([a-zA-Z \d]+)$', line)
if sensor:
# group 1 parce qu'on a demande qqchose de particulier a la regexpr a cause des ()
sensor = sensor.group(1)
return sensor
def get_sensor_id(image):
"""
Returns the sensor of the given image if found by ReadImageInfo
Args:
image:
Returns:
"""
result_sensor = OTBApplications.read_image_info_cli(image)
if result_sensor:
# type(result_sensor) = PyQt4.QtCore.QByteArray
for line in str(result_sensor).splitlines():
if "sensor" in line:
# sensor_line = result_sensor[0]
sensor = re.search('sensor: ([a-zA-Z \d]+)$', line)
if sensor:
# group 1 parce qu'on a demande qqchose de particulier a la regexpr a cause des ()
sensor = sensor.group(1)
return sensor
def export_kmz(filenames, working_directory):
"""
"""
internal_working_directory = os.path.join(working_directory, "Internal")
if not os.path.exists(internal_working_directory):
os.makedirs(internal_working_directory)
kmzs = []
for image in filenames:
kmz_tmp = OTBApplications.otbcli_export_kmz(
image, internal_working_directory)
kmzs.append(kmz_tmp)
# attention rustine
# kmzs = glob.glob( os.path.join(internal_working_directory, "*.kmz"))
kmz_to_return = []
for kmz in kmzs:
new_path = os.path.join(working_directory, os.path.basename(kmz))
shutil.copy(kmz, new_path)
kmz_to_return.append(new_path)
return kmz_to_return
def threshold(layer, working_directory, forms):
logger.debug("threshold" + str(forms))
image_in = layer.get_source()
temp = []
i = 1
if len(forms) == 1:
output_filename = os.path.join(working_directory,
os.path.basename(os.path.splitext(image_in)[0]) + "_threshold" + os.path.splitext(image_in)[1])
OTBApplications.bandmath_cli([image_in], forms[0], output_filename)
else:
for formula in forms:
output_filename = os.path.join(working_directory,
os.path.basename(os.path.splitext(image_in)[0]) + "_threshold" + str(i) + os.path.splitext(image_in)[1])
OTBApplications.bandmath_cli([image_in], formula, output_filename)
i += 1
temp.append(output_filename)
output_filename = os.path.join(working_directory, os.path.basename(os.path.splitext(image_in)[0]) + "_threshold" + os.path.splitext(image_in)[1])
OTBApplications.concatenateImages_cli(temp, output_filename)
return output_filename
def get_workinglayer_on_opening(iface):
settings = QSettings()
last_folder = settings.value("terre_image_last_folder")
if last_folder:
path = last_folder
else:
path = QDir.currentPath()
file_opened = QFileDialog.getOpenFileName(None, "Selectionner un fichier raster", path)
settings.setValue("terre_image_last_folder", os.path.dirname(file_opened))
settings.sync()
if file_opened:
# try:
# str(file_opened)
# except UnicodeEncodeError:
# QMessageBox.warning( None , "Erreur", u'L\'image que vous essayez d\'ouvrir contient un ou des caractères spéciaux. \
# La version actuelle du plugin ne gère pas ce type de fichiers. \
# Veuillez renommer le fichier et ou les répertoires le contenant.', QMessageBox.Ok )
# return None, None
# else:
# if file_opened.find(" ") != -1:
# QMessageBox.warning( None , "Attention", u'L\'image que vous essayez d\'ouvrir contient un ou plusieurs espaces. Les traitements sur cette image provoqueront une erreur.'.encode('utf8'), QMessageBox.Ok )
if file_opened.endswith(".qgs"):
# open new qgis project
pass
else:
raster_layer = manage_QGIS.get_raster_layer(file_opened, os.path.splitext(os.path.basename(file_opened))[0])
if not os.name == "posix":
terre_image_run_process.set_OTB_PATH()
type_image = terre_image_processing.get_sensor_id(file_opened)
logger.debug("type_image " + str(type_image))
layer = WorkingLayer(file_opened, raster_layer)
layer.set_type(type_image)
# self.layer = self.canvas.currentLayer()
if layer:
# self.define_bands(self.layer)
# manage_bands()
# self.red, self.green, self.blue, self.pir, self.mir = manage_bands().get_values()
red, green, blue, pir, mir, type_satellite = manage_bands(type_image, layer.get_band_number()).get_values()
if red != -1 or green != -1 or blue != -1 or pir != -1 or mir != -1:
all_set = True
bands = {'red': red, 'green': green, 'blue': blue, 'pir': pir, 'mir': mir}
for i in range(1, layer.get_band_number() + 1):
if i not in bands.values():
all_set = False
if all_set:
layer.set_bands(bands)
if layer.type is None:
layer.set_type(type_satellite)
logger.debug(str(red) + " " + str(green) + " " + str(blue) + " " + str(pir) + " " + str(mir))
cst = TerreImageConstant()
cst.index_group = cst.iface.legendInterface().addGroup("Terre Image", True, None)
manage_QGIS.add_qgis_raser_layer(raster_layer, iface.mapCanvas(), bands)
OTBApplications.compute_overviews(file_opened)
return layer, bands
else:
QMessageBox.warning(None, "Erreur",
u'Il y a un problème dans la définition des bandes spectrales.',
QMessageBox.Ok)
return None, None
else:
return None, None
else:
return None, None
