def cal_the_mean_of_bands(image_path):
img_obj = RSImageclass()
if img_obj.open(image_path):
width = img_obj.GetWidth()
height = img_obj.GetHeight()
mean_of_bands = RSImage.get_image_mean_value(image_path)
if mean_of_bands is False:
return (False,False,False)
return (width,height,mean_of_bands)
else:
basic.outputlogMessage('error, Open image %s failed' %image_path)
return (False,False,False)
def cal_the_mean_of_bands(input_path):
# if multi files in one line, then only consider the first file
image_path = get_first_path_in_line(input_path)
if image_path is False:
return False
img_obj = RSImageclass()
if img_obj.open(image_path):
width = img_obj.GetWidth()
height = img_obj.GetHeight()
mean_of_bands = RSImage.get_image_mean_value(image_path)
if mean_of_bands is False:
return (False,False,False)
return (width,height,mean_of_bands)
else:
basic.outputlogMessage('error, Open image %s failed' %image_path)
return (False,False,False)
def compose_two_image(self, main_image, second_image, nodata):
if io_function.is_file_exist(main_image) is False:
return False
if io_function.is_file_exist(second_image) is False:
return False
main_img = RSImageclass()
if main_img.open(main_image) is False:
return False
width_main = main_img.GetWidth()
height_main = main_img.GetHeight()
bandcount_main = main_img.GetBandCount()
sec_img = RSImageclass()
if sec_img.open(second_image) is False:
return False
width_sec = sec_img.GetWidth()
height_sec = sec_img.GetHeight()
bandcount_sec = sec_img.GetBandCount()
if width_main != width_sec or height_main != height_sec or bandcount_main != bandcount_sec:
basic.outputlogMessage(
'Error: The dimension of two composed images is different')
return False
if main_img.GetGDALDataType() != sec_img.GetGDALDataType(
) or main_img.GetGDALDataType() != 6:
basic.outputlogMessage(
'Error: The Data type of two composed imagaes is different or is not float'
)
return False
outputfile = io_function.get_name_by_adding_tail(main_image, 'comp')
imagenew = RSImageclass()
width = width_main
height = height_main
if not imagenew.New(outputfile, width, height, bandcount_main,
main_img.GetGDALDataType()):
return False
for i in range(0, bandcount_main):
bandindex = i + 1
band_main_str = main_img.ReadbandData(bandindex, 0, 0, width,
height,
main_img.GetGDALDataType())
band_sec_str = sec_img.ReadbandData(bandindex, 0, 0, width, height,
sec_img.GetGDALDataType())
band_main_data = struct.unpack('f' * width * height, band_main_str)
band_main_numpy = numpy.asarray(band_main_data)
band_sec_data = struct.unpack('f' * width * height, band_sec_str)
band_sec_numpy = numpy.asarray(band_sec_data)
compose_loc = numpy.where(
(numpy.fabs(band_main_numpy - nodata) < 0.0001)
& (numpy.fabs(band_sec_numpy - nodata) > 0.0001))
band_main_numpy[compose_loc] = band_sec_numpy[compose_loc]
basic.outputlogMessage('outputfortest2: compose_loc_num = %d' %
numpy.array(compose_loc).size)
templist = band_main_numpy.tolist()
band_composed_str = struct.pack('%sf' % width * height, *templist)
if imagenew.WritebandData(bandindex, 0, 0, width, height,
band_composed_str,
imagenew.GetGDALDataType()) is False:
return False
imagenew.SetBandNoDataValue(bandindex, nodata)
imagenew.SetGeoTransform(main_img.GetGeoTransform())
imagenew.SetProjection(main_img.GetProjection())
main_img = None
sec_img = None
imagenew = None
return outputfile
class RSImgProclass(object):
def __init__(self):
self.imgpath = ''
self.img__obj = None #RSImageclass object
def __del__(self):
# close dataset
# print 'RSImageclass__del__'
self.img__obj = None
def Read_Image_band_data_to_numpy_array_all_pixel(self, bandindex,
image_path):
if io_function.is_file_exist(image_path) is False:
return False
self.img__obj = RSImageclass()
if self.img__obj.open(image_path) is False:
return False
width = self.img__obj.GetWidth()
height = self.img__obj.GetHeight()
return self.__Read_band_data_to_numpy_array(bandindex, 0, 0, width,
height, self.img__obj)
def __Read_Image_band_data_to_numpy_array(self, bandindex, xoff, yoff,
width, height, image_path):
return True
def __Read_band_data_to_numpy_array(self,
bandindex,
xoff,
yoff,
width,
height,
image_obj=None):
if image_obj is None:
image_obj = self.img__obj
offsetvaluestr = image_obj.ReadbandData(
bandindex, xoff, yoff, width, height,
image_obj.GetGDALDataType()) #first band offset, may be xoffset
if offsetvaluestr is False:
return False
# offsetvalue = None
# print image_obj.GetGDALDataType()
if image_obj.GetGDALDataType() == 3: #GDT_Int16
offsetvalue = struct.unpack('h' * width * height, offsetvaluestr)
elif image_obj.GetGDALDataType() == 6:
offsetvalue = struct.unpack('f' * width * height, offsetvaluestr)
else:
basic.outputlogMessage('error: not support datatype currently')
return False
return numpy.asarray(offsetvalue)
def statistic_element_count(self, value, myarray):
loc_nodata = numpy.where(numpy.fabs(myarray - value) < 0.001)
loc_nodatanum = numpy.array(loc_nodata).size
return loc_nodatanum
def statistic_not_element_count(self, not_value, myarray):
loc_not_value = numpy.where(numpy.fabs(myarray - not_value) > 0.0001)
loc_not_value_num = numpy.array(loc_not_value).size
return loc_not_value_num
def statistic_pixel_count(self, pixel_value, RSImageclass_object):
return True
def compose_two_image(self, main_image, second_image, nodata):
if io_function.is_file_exist(main_image) is False:
return False
if io_function.is_file_exist(second_image) is False:
return False
main_img = RSImageclass()
if main_img.open(main_image) is False:
return False
width_main = main_img.GetWidth()
height_main = main_img.GetHeight()
bandcount_main = main_img.GetBandCount()
sec_img = RSImageclass()
if sec_img.open(second_image) is False:
return False
width_sec = sec_img.GetWidth()
height_sec = sec_img.GetHeight()
bandcount_sec = sec_img.GetBandCount()
if width_main != width_sec or height_main != height_sec or bandcount_main != bandcount_sec:
basic.outputlogMessage(
'Error: The dimension of two composed images is different')
return False
if main_img.GetGDALDataType() != sec_img.GetGDALDataType(
) or main_img.GetGDALDataType() != 6:
basic.outputlogMessage(
'Error: The Data type of two composed imagaes is different or is not float'
)
return False
outputfile = io_function.get_name_by_adding_tail(main_image, 'comp')
imagenew = RSImageclass()
width = width_main
height = height_main
if not imagenew.New(outputfile, width, height, bandcount_main,
main_img.GetGDALDataType()):
return False
for i in range(0, bandcount_main):
bandindex = i + 1
band_main_str = main_img.ReadbandData(bandindex, 0, 0, width,
height,
main_img.GetGDALDataType())
band_sec_str = sec_img.ReadbandData(bandindex, 0, 0, width, height,
sec_img.GetGDALDataType())
band_main_data = struct.unpack('f' * width * height, band_main_str)
band_main_numpy = numpy.asarray(band_main_data)
band_sec_data = struct.unpack('f' * width * height, band_sec_str)
band_sec_numpy = numpy.asarray(band_sec_data)
compose_loc = numpy.where(
(numpy.fabs(band_main_numpy - nodata) < 0.0001)
& (numpy.fabs(band_sec_numpy - nodata) > 0.0001))
band_main_numpy[compose_loc] = band_sec_numpy[compose_loc]
basic.outputlogMessage('outputfortest2: compose_loc_num = %d' %
numpy.array(compose_loc).size)
templist = band_main_numpy.tolist()
band_composed_str = struct.pack('%sf' % width * height, *templist)
if imagenew.WritebandData(bandindex, 0, 0, width, height,
band_composed_str,
imagenew.GetGDALDataType()) is False:
return False
imagenew.SetBandNoDataValue(bandindex, nodata)
imagenew.SetGeoTransform(main_img.GetGeoTransform())
imagenew.SetProjection(main_img.GetProjection())
main_img = None
sec_img = None
imagenew = None
return outputfile
def setGCPsfromptsFile(imagefile, projection, GeoTransform, ptsfile):
if not is_file_exist(imagefile):
return False
image = RSImageclass()
if not image.open(imagefile):
return False
ngcpcount = image.ds.GetGCPCount()
if ngcpcount > 0:
basic.outputlogMessage(
'warning: The file already have GCP,GCP count is ' +
str(ngcpcount))
allgcps = []
inputfile_object = open(ptsfile, 'r')
all_points = inputfile_object.readlines()
for linestr in all_points:
if linestr[0:1] == '#' or linestr[0:1] == ';' or len(linestr) < 2:
continue
if len(allgcps) >= 10000:
basic.outputlogMessage(
'warning: the count of gcps already greater than 10000, and ignore the others to make geotiff work correctly'
)
continue
tiepointXY = linestr.split()
base_x = float(tiepointXY[0])
base_y = float(tiepointXY[1])
Xp = GeoTransform[
0] + base_x * GeoTransform[1] + base_y * GeoTransform[2]
Yp = GeoTransform[
3] + base_x * GeoTransform[4] + base_y * GeoTransform[5]
warp_x = float(tiepointXY[2])
warp_y = float(tiepointXY[3])
info = 'GCPbysiftgpu_%d' % len(allgcps)
id = str(len(allgcps))
gcp1 = gdal.GCP(Xp, Yp, 0, warp_x, warp_y, info, id)
allgcps.append(gcp1)
inputfile_object.close()
Outputtiff = imagefile.split('.')[0] + '_new.tif'
format = "GTiff"
driver = gdal.GetDriverByName(format)
metadata = driver.GetMetadata()
if metadata.has_key(
gdal.DCAP_CREATE) and metadata[gdal.DCAP_CREATE] == 'YES':
basic.outputlogMessage('Driver %s supports Create() method.' % format)
else:
basic.outputlogMessage('Driver %s not supports Create() method.' %
format)
return False
# if metadata.has_key(gdal.DCAP_CREATECOPY) and metadata[gdal.DCAP_CREATECOPY] == 'YES':
# syslog.outputlogMessage('Driver %s supports CreateCopy() method.' % format)
# dst_ds = driver.CreateCopy(Outputtiff, dataset, 0)
datatype = image.GetGDALDataType()
dst_ds = driver.Create(Outputtiff, image.GetWidth(), image.GetHeight(),
image.GetBandCount(), datatype)
for bandindex in range(0, image.GetBandCount()):
bandobject = image.Getband(bandindex + 1)
banddata = bandobject.ReadRaster(0, 0, image.GetWidth(),
image.GetHeight(), image.GetWidth(),
image.GetHeight(), datatype)
#byte
# if banddata is 1:
# bandarray = struct.unpack('B'*image.GetWidth()*image.GetHeight(), banddata)
dst_ds.GetRasterBand(bandindex + 1).WriteRaster(
0, 0, image.GetWidth(), image.GetHeight(), banddata,
image.GetWidth(), image.GetHeight(), datatype)
dst_ds.SetGCPs(allgcps, projection)
# if I have set the GCPs, should not do this again, or SetGCPs will be undo
# dst_ds.SetGeoTransform(image.GetGeoTransform())
# dst_ds.SetProjection(image.GetProjection())
if not os.path.isfile(Outputtiff):
basic.outputlogMessage(
'result file not exist, the operation of create set gcp failed')
return False
dst_ds = None
image = None
return Outputtiff
def coregistration_siftGPU(basefile, warpfile, bkeepmidfile, xml_obj):
tiepointfile = '0_1_after.pts'
if os.path.isfile(tiepointfile):
basic.outputlogMessage(
'warning:tie points already exist in dir, skip get_tie_points_by_ZY3ImageMatch'
)
else:
tiepointfile = tiepoints.get_tie_points_by_ZY3ImageMatch(
basefile, warpfile, bkeepmidfile)
if tiepointfile is False:
basic.outputlogMessage('Get tie points by ZY3ImageMatch failed')
return False
xml_obj.add_coregistration_info('tie_points_file', tiepointfile)
# draw tie points rms vector on base image
result_rms_files = '0_1_fs.txt'
tiepoint_vector_ = 'tiepoints_vector.png'
tmpImg_obj = RSImageclass()
tmpImg_obj.open(basefile)
if tmpImg_obj.GetWidth() * tmpImg_obj.GetHeight() < 10000 * 10000:
output_tie_points_vector_on_base_image(basefile, result_rms_files,
tiepoint_vector_)
xml_obj.add_coregistration_info('tie_points_drawed_image',
os.path.abspath(tiepoint_vector_))
else:
basic.outputlogMessage(
'warning: the width*height of the image > 10000*10000, skip drawing tie point vectors'
)
# check the tie points
try:
rms_files_obj = open(result_rms_files, 'r')
rms_lines = rms_files_obj.readlines()
if len(rms_lines) < 2:
basic.outputlogMessage("%s do not contain tie points information" %
os.path.abspath(result_rms_files))
return False
required_point_count = parameters.get_required_minimum_tiepoint_number(
)
acceptable_rms = parameters.get_acceptable_maximum_RMS()
xml_obj.add_coregistration_info('required_tie_point_count',
str(required_point_count))
xml_obj.add_coregistration_info('acceptable_rms', str(acceptable_rms))
try:
digit_str = re.findall('\d+', rms_lines[0])
tiepoints_count = int(digit_str[0])
xml_obj.add_coregistration_info('tie_points_count',
str(tiepoints_count))
if tiepoints_count < required_point_count:
basic.outputlogMessage(
"ERROR: tiepoints count(%d) is less than required one(%d)"
% (tiepoints_count, required_point_count))
return False
digit_str = re.findall('\d+\.?\d*', rms_lines[1])
totalrms_value = float(digit_str[2])
xml_obj.add_coregistration_info('total_rms_value',
str(totalrms_value))
if totalrms_value > acceptable_rms:
basic.outputlogMessage(
"ERROR:Total RMS(%f) exceeds the acceptable one(%f)" %
(totalrms_value, acceptable_rms))
return False
except ValueError:
return basic.outputlogMessage(str(ValueError))
# return False
rms_files_obj.close()
except IOError:
# basic.outputlogMessage(str(IOError))
raise IOError('check the tie points')
# return False
baseimg = RSImageclass()
if not baseimg.open(basefile):
return False
proj = baseimg.GetProjection()
geotransform = baseimg.GetGeoTransform()
# xres = baseimg.GetXresolution()
# yres = baseimg.GetYresolution()
# keep the output resolution the same as orginal image not the base image hlc Jan 31, 2019
warpimg = RSImageclass()
if not warpimg.open(warpfile):
return False
xres = warpimg.GetXresolution()
yres = warpimg.GetYresolution()
try:
Outputtiff = setGCPsfromptsFile(warpfile, proj, geotransform,
tiepointfile)
except RuntimeError as e:
basic.outputlogMessage('setGCPsfromptsFile failed: ')
basic.outputlogMessage(str(e))
return False
if Outputtiff is False:
return False
else:
basic.outputlogMessage('setGCPsfromptsFile completed, Out file: ' +
Outputtiff)
# if not bkeepmidfile:
# os.remove(warpfile)
xml_obj.add_coregistration_info('setted_gcps_file', Outputtiff)
# warp image
warpresultfile = io_function.get_name_by_adding_tail(
Outputtiff, 'warp') # Outputtiff.split('.')[0] + '_warp.tif'
# -order 1 -tps
# -tr xres yres: set output file resolution (in target georeferenced units)
# set resolution as the same as base image is important
order_number = parameters.get_gdalwarp_polynomial_order()
xml_obj.add_coregistration_info('warp_polynomial_order_number',
str(order_number))
if order_number is False:
return False
CommandString = 'gdalwarp ' + ' -order ' + str(
order_number) + ' -r bilinear -tr ' + str(xres) + ' ' + str(
yres) + ' ' + Outputtiff + ' ' + warpresultfile
# basic.outputlogMessage(CommandString)
# (status, result) = commands.getstatusoutput(CommandString)
# basic.outputlogMessage(result)
# if not os.path.isfile(warpresultfile):
# return False
if basic.exec_command_string_one_file(CommandString,
warpresultfile) is False:
return False
if not bkeepmidfile:
os.remove(Outputtiff)
return warpresultfile
def get_geoimage_range_geoid_height(outputfile, ref_image):
#convert srs
ref_img_obj = RSImageclass()
if not ref_img_obj.open(ref_image):
return False
# x_res = ref_img_obj.GetXresolution()
# y_res = ref_img_obj.GetYresolution()
width = ref_img_obj.GetWidth()
height = ref_img_obj.GetHeight()
img_pro = RSImgProclass()
ref_image_data = img_pro.Read_Image_band_data_to_numpy_array_all_pixel(
1, ref_image)
if ref_image_data is False:
return False
nodata = parameters.get_nodata_value()
Image_array = ref_image_data.reshape(height, width)
start_x = ref_img_obj.GetStartX()
start_y = ref_img_obj.GetStartY()
resolution_x = ref_img_obj.GetXresolution()
resolution_y = ref_img_obj.GetYresolution()
ref_img_WKT = ref_img_obj.GetProjection()
# ref_img_WKT = RSImageProcess.get_raster_or_vector_srs_info_wkt(ref_image,syslog)
(i, j) = numpy.where(Image_array != nodata)
input_x = start_x + j * resolution_x
input_y = start_y + i * resolution_y
# srs_longlat_prj4 = '\'+proj=longlat +datum=WGS84 +no_defs\''
# intput_proj4 = RSImage.wkt_to_proj4(ref_img_WKT,syslog)
# intput_proj4 = RSImageProcess.get_raster_or_vector_srs_info_proj4(ref_image,syslog)
# map_projection.convert_points_coordinate_proj4(input_x,input_y,intput_proj4,srs_longlat_prj4,syslog)
srs_longlat_wkt = "GEOGCS[\"WGS 84\",DATUM[\"WGS_1984\",SPHEROID[\"WGS 84\",6378137,298.257223563]],PRIMEM[\"Greenwich\",0],UNIT[\"degree\",0.01745329251994328]]"
map_projection.convert_points_coordinate(input_x, input_y, ref_img_WKT,
srs_longlat_wkt)
tempsave_str = []
save_point_txt_file = 'TXTgeoid_' + os.path.splitext(
os.path.basename(ref_image))[0] + '.txt'
if os.path.isfile(save_point_txt_file):
file_object = open(save_point_txt_file, 'r')
savepoints = file_object.readlines()
for point in savepoints:
tempsave_str.append(point)
file_object.close()
io_function.delete_file_or_dir(save_point_txt_file)
file_object = open(save_point_txt_file, 'a')
nsize = Image_array.size
Image_array = Image_array.astype(numpy.float32)
for index in range(0, nsize):
lon_deg = input_x[index]
lat_deg = input_y[index]
if index < len(tempsave_str):
temp_point = tempsave_str[index].split()
value = float(temp_point[2])
else:
(LongitudeDeg, LongitudeMin, LongitudeSec) = degree_to_dms(lon_deg)
(LatitudeDeg, LatitudeMin, LatitudeSec) = degree_to_dms(lat_deg)
value = get_geoid_height(LatitudeDeg, LatitudeMin, LatitudeSec,
LongitudeDeg, LongitudeMin, LongitudeSec,
nodata)
if value is False:
break
saved_point = ('%f %f %f' % (lon_deg, lat_deg, value))
print saved_point
# tempsave_str.append(saved_point)
file_object.writelines(saved_point + '\n')
file_object.flush()
basic.outputlogMessage('Longitude=%f, Latitude=%f, geoid = %f' %
(lon_deg, lat_deg, value))
# Image_array[index] = value
Image_array[i[index], j[index]] = value
print(i[index], j[index], Image_array[i[index], j[index]])
file_object.close()
if index != (nsize - 1):
return False
#save geoid height
RSImageProcess.save_numpy_2d_array_to_image_tif(outputfile,Image_array,\
6,ref_img_obj.GetGeoTransform(),ref_img_WKT,nodata)
return True