def correctPixelCoordinates(registrationResult): '''Rescales the pixel coordinates based on the resolution they were collected at compared to the full image resolution.''' # TODO: Account for the image labels adjusting the image size! sourceHeight = registrationResult['manualImageHeight'] sourceWidth = registrationResult['manualImageWidth'] (outputWidth, outputHeight) = IrgGeoFunctions.getImageSize( registrationResult['sourceImagePath']) if (sourceHeight != outputHeight) or (sourceWidth != outputWidth): # Compute rescale heightScale = float(outputHeight) / float(sourceHeight) widthScale = float(outputWidth) / float(sourceWidth) # Apply to each of the pixel coordinates out = [] for pixel in registrationResult['imageInliers']: newPixel = (pixel[0] * widthScale, pixel[1] * heightScale) out.append(newPixel) registrationResult['imageInliers'] = out return registrationResult
def cropImageLabel(jpegPath, outputPath): '''Create a copy of a jpeg file with any label cropped off''' # Check if there is a label using a simple command line tool cmdPath = settings.PROJ_ROOT + '/apps/georef_imageregistration/build/detectImageTag' cmd = [cmdPath, jpegPath] print cmd p = subprocess.Popen(cmd, stdout=subprocess.PIPE) textOutput, err = p.communicate() if 'NO_LABEL' in textOutput: # The file is fine, just copy it. print 'Copy ' + jpegPath + ' --> ' + outputPath try: shutil.copy(jpegPath, outputPath) except: print 'Copy failed, try again!' # shutil.copy(jpegPath, outputPath) os.system('cp ' + jpegPath + ' ' + outputPath) if not os.path.exists(outputPath): raise Exception('Still failed!') print 'Retry successful!' else: lines = textOutput.strip().split( '\n') # Get the parts of the last line parts = lines[-1].split() if len(parts) != 3: raise Exception('Error running detectImageTag, got response: ' + textOutput) side = parts[1] labelPos = int(parts[2]) print 'Detected image label: ' + side + ' at index ' + str(labelPos) # Trim the label off of the bottom of the image imageSize = IrgGeoFunctions.getImageSize(jpegPath) x = 0 y = 0 width = imageSize[0] height = imageSize[1] if side == 'LEFT': x = labelPos width = width - labelPos if side == 'RIGHT': width = labelPos if side == 'TOP': y = labelPos height = height - labelPos if side == 'BOTTOM': height = labelPos cmd = ('gdal_translate -of jpeg -srcwin %d %d %d %d %s %s' % (x, y, width, height, jpegPath, outputPath)) print cmd os.system(cmd)
def recordOutputImages(sourceImagePath, exifSourcePath, outputPrefix, imageInliers, gdcInliers, minUncertaintyMeters, centerPointSource, isManualRegistration=False, overwrite=True): '''Generates all the output image files that we create for each successfully processed image.''' # We generate two pairs of images, one containing the image data # and another with the same format but containing the uncertainty distances. outputPrefix = outputPrefix + '-' + centerPointSource uncertaintyOutputPrefix = outputPrefix + '-uncertainty' rawUncertaintyPath = outputPrefix + '-uncertainty_raw.tif' # Create the raw uncertainty image (width, height) = IrgGeoFunctions.getImageSize(sourceImagePath) posError = generateUncertaintyImage(width, height, imageInliers, minUncertaintyMeters, rawUncertaintyPath) # Get a measure of the fit error fitError = getFitError(imageInliers, gdcInliers) # Generate the two pairs of images in the same manner try: (noWarpOutputPath, warpOutputPath) = \ generateGeotiff(sourceImagePath, outputPrefix, imageInliers, gdcInliers, posError, fitError, isManualRegistration, exifSourcePath, writeHeaders=True, overwrite=True) except Exception as e: print str(e) try: (noWarpOutputPath, warpOutputPath) = \ generateGeotiff(rawUncertaintyPath, uncertaintyOutputPrefix, imageInliers, gdcInliers, posError, fitError, isManualRegistration, exifSourcePath, writeHeaders=False, overwrite=True) except Exception as e: print str(e) # Clean up the raw uncertainty image and any extraneous files rawXmlPath = rawUncertaintyPath + '.aux.xml' os.remove(rawUncertaintyPath) if os.path.exists(rawXmlPath): os.remove(rawXmlPath)
def splitImageGdal(imagePath, outputPrefix, tileSize, force=False, pool=None, maskList=[]): '''gdal_translate based replacement for the ImageMagick convert based image split. This function assumes that all relevant folders have been created.''' # Compute the bounding box for each tile inputImageSize = IrgGeoFunctions.getImageSize(imagePath) #print imagePath + ' is size ' + str(inputImageSize) numTilesX = int(math.ceil(float(inputImageSize[0]) / float(tileSize))) numTilesY = int(math.ceil(float(inputImageSize[1]) / float(tileSize))) print 'Using gdal_translate to generate ' + str(int(numTilesX*numTilesY)) + ' tiles!' # Generate each of the tiles using GDAL cmdList = [] for r in range(0,numTilesY): for c in range(0,numTilesX): if maskList: # Make sure this tile is not completely masked out # Find the info for the corresponding mask tile # If the image is larger than the mask, there is a chance there will be no # mask tile for this image tile. If so we can still skip the image tile,, tilePrefix = getTilePrefix(r, c) maskTileInfo = [x for x in maskList if x['prefix'] == tilePrefix] if not maskTileInfo or (maskTileInfo[0]['percentValid'] < MIN_TILE_PERCENT_PIXELS_VALID): continue # Get the pixel ROI for this tile # - TODO: Use the Tiling class! minCol = c*tileSize minRow = r*tileSize width = tileSize height = tileSize if (minCol + width ) > inputImageSize[0]: width = inputImageSize[0] - minCol if (minRow + height) > inputImageSize[1]: height = inputImageSize[1] - minRow totalNumPixels = height*width # Generate the tile (console output suppressed) thisPixelRoi = ('%d %d %d %d' % (minCol, minRow, width, height)) thisTilePath = outputPrefix + str(r) +'_'+ str(c) + '.tif' cmd = MosaicUtilities.GDAL_TRANSLATE_PATH+' -q -srcwin ' + thisPixelRoi +' '+ imagePath +' '+ thisTilePath if pool: #print cmd cmdList.append((cmd, thisTilePath, force)) else: MosaicUtilities.cmdRunner(cmd, thisTilePath, force) if pool: # Pass all of these commands to a multiprocessing worker pool print 'splitImageGdal is launching '+str(len(cmdList))+' gdalwarp threads...' pool.map(MosaicUtilities.cmdRunnerWrapper, cmdList)
def getPixelToGdcTransform(imagePath, pixelToProjectedTransform=None): '''Returns a pixel to GDC transform. The input image must either be a nicely georegistered image from Earth Engine or a pixel to projected coordinates transform must be provided.''' if pixelToProjectedTransform: # Have image to projected transform, convert it to an image to GDC transform. # Use the simple file info call (the input file may not have geo information) (width, height) = IrgGeoFunctions.getImageSize(imagePath) imagePoints = [] gdcPoints = [] # Loop through a spaced out grid of pixels in the image pointPixelSpacing = (width + height) / 20 # Results in about 100 points for r in range(0, width, pointPixelSpacing): for c in range(0, height, pointPixelSpacing): # This pixel --> projected coords --> lonlat coord thisPixel = numpy.array([float(c), float(r)]) projectedCoordinate = pixelToProjectedTransform.forward( thisPixel) gdcCoordinate = transform.metersToLatLon(projectedCoordinate) imagePoints.append(thisPixel) gdcPoints.append(gdcCoordinate) # Solve for a transform with all of these point pairs pixelToGdcTransform = transform.getTransform( numpy.asarray(gdcPoints), numpy.asarray(imagePoints)) else: # Using a reference image from EE which will have nice bounds. # Use the more thorough file info call stats = IrgGeoFunctions.getImageGeoInfo(imagePath, False) (width, height) = stats['image_size'] (minLon, maxLon, minLat, maxLat) = stats['lonlat_bounds'] # Make a transform from ref pixel to GDC using metadata on disk xScale = (maxLon - minLon) / width yScale = (maxLat - minLat) / height transformMatrix = numpy.array([[xScale, 0, minLon], [0, -yScale, maxLat], [0, 0, 1]]) pixelToGdcTransform = transform.LinearTransform(transformMatrix) return pixelToGdcTransform
def generateTileInfo(fullPath, fileName, tileSize, metadataPath, force=False): '''Generates a metadata json file for an image tile''' # If the metadata is saved, just reload it. if (os.path.exists(metadataPath) and not force): with open(metadataPath, 'r') as f: thisTileInfo = json.load(f) return thisTileInfo # Figure out the position of the tile numbers = re.findall(r"[\d']+", fileName) # Extract all numbers from the file name tileRow = int(numbers[-2]) # In the tile grid tileCol = int(numbers[-1]) pixelRow = tileRow * tileSize # In pixel coordinates relative to the original image pixelCol = tileCol * tileSize # TODO: Counting the black pixels is a little slow, run this in parallel! # Get other tile information width, height = IrgGeoFunctions.getImageSize(fullPath) totalNumPixels = height * width blackPixelCount = MosaicUtilities.countBlackPixels(fullPath) validPercentage = 1.0 - (float(blackPixelCount) / float(totalNumPixels)) thisTileInfo = { 'path': fullPath, 'tileRow': tileRow, 'tileCol': tileCol, 'pixelRow': pixelRow, 'pixelCol': pixelCol, 'heightPixels': height, 'widthPixels': width, 'percentValid': validPercentage, 'prefix': getTilePrefix(tileRow, tileCol) } # Cache the metadata to disk so we don't have to recompute with open(metadataPath, 'w') as f: json.dump(thisTileInfo, f) return thisTileInfo
def generateTileInfo(fullPath, fileName, tileSize, metadataPath, force=False): '''Generates a metadata json file for an image tile''' # If the metadata is saved, just reload it. if (os.path.exists(metadataPath) and not force): with open(metadataPath, 'r') as f: thisTileInfo = json.load(f) return thisTileInfo # Figure out the position of the tile numbers = re.findall(r"[\d']+", fileName) # Extract all numbers from the file name tileRow = int(numbers[-2]) # In the tile grid tileCol = int(numbers[-1]) pixelRow = tileRow * tileSize # In pixel coordinates relative to the original image pixelCol = tileCol * tileSize # TODO: Counting the black pixels is a little slow, run this in parallel! # Get other tile information width, height = IrgGeoFunctions.getImageSize(fullPath) totalNumPixels = height*width blackPixelCount = MosaicUtilities.countBlackPixels(fullPath) validPercentage = 1.0 - (float(blackPixelCount) / float(totalNumPixels)) thisTileInfo = {'path' : fullPath, 'tileRow' : tileRow, 'tileCol' : tileCol, 'pixelRow' : pixelRow, 'pixelCol' : pixelCol, 'heightPixels': height, 'widthPixels' : width, 'percentValid': validPercentage, 'prefix' : getTilePrefix(tileRow, tileCol) } # Cache the metadata to disk so we don't have to recompute with open(metadataPath, 'w') as f: json.dump(thisTileInfo, f) return thisTileInfo
def writeLabelFile(imagePath, outputPath, dataSetName, versionId, description, extraData=None): """Write out a .LBL file formatted for the PDS""" # Call functions to automatically obtain some data from the referenced image imageSize = IrgGeoFunctions.getImageSize(imagePath) boundingBox = IrgGeoFunctions.getImageBoundingBox(imagePath) # Obtain the ASP version string aspVersionString = IrgAspFunctions.getAspVersionStrings() imageGeoInfo = IrgGeoFunctions.getImageGeoInfo(imagePath) projCenterLatitude = imageGeoInfo['standard_parallel_1'] projCenterLongitude = imageGeoInfo['central_meridian'] # Currently assuming pixels are the same size metersPerPixel = abs(imageGeoInfo['pixel size'][0]) # Compute pixels per degree lonSpanDegrees = boundingBox[1] - boundingBox[0] latSpanDegrees = boundingBox[3] - boundingBox[2] pixelsPerDegreeLon = imageSize[0] / lonSpanDegrees pixelsPerDegreeLat = imageSize[1] / latSpanDegrees pixelsPerDegree = (pixelsPerDegreeLat + pixelsPerDegreeLon) / 2.0 # Computed by dividing 'Origin' by 'Pixel Size' lineProjOffset = imageGeoInfo['origin'][0] / imageGeoInfo['pixel size'][1] sampleProjOffset = imageGeoInfo['origin'][1] / imageGeoInfo['pixel size'][0] labelFile = open(outputPath, 'w') labelFile.write('PDS_VERSION_ID = PDS3\n') labelFile.write('/* The source image data definition. */\n') labelFile.write('^IMAGE = ' + os.path.basename(outputPath) +'\n') labelFile.write('/* Identification Information */\n') labelFile.write('DATA_SET_ID = ""\n') # Someone will tell us what to put here labelFile.write('DATA_SET_NAME = ""\n') # Someone will tell us what to put here labelFile.write("VOLUME_ID = ''\n") # Someone will tell us what to put here labelFile.write('PRODUCER_INSTITUTION_NAME = "NASA AMES RESEARCH CENTER"\n') labelFile.write('PRODUCER_ID = NASA IRG\n') labelFile.write('PRODUCER_FULL_NAME = "ZACHARY MORATTO"\n') labelFile.write("PRODUCT_ID = " + dataSetName + "\n") labelFile.write("PRODUCT_VERSION_ID = " + versionId + "\n") labelFile.write('PRODUCT_TYPE = "RDR"\n') labelFile.write('INSTRUMENT_HOST_NAME = "LUNAR RECONNAISSANCE ORBITER"\n') labelFile.write('INSTRUMENT_HOST_ID = "LRO"\n') labelFile.write('INSTRUMENT_NAME = "LUNAR RECONNAISSANCE ORBITER CAMERA"\n') labelFile.write('INSTRUMENT_ID = "LROC"\n') labelFile.write('TARGET_NAME = MOON\n') labelFile.write('MISSION_PHASE_NAME = "NOMINAL MISSION"\n') labelFile.write("""RATIONALE_DESC = "Created at the request of NASA's Exploration\n""") labelFile.write(' Systems Mission Directorate to support future\n') labelFile.write(' human exploration"\n') labelFile.write('SOFTWARE_NAME = "'+ aspVersionString[0] +' | '+ aspVersionString[2] +'"\n') labelFile.write('DESCRIPTION = "' + description + '"\n') labelFile.write('\n') labelFile.write('/* Time Parameters */\n') labelFile.write('PRODUCT_CREATION_TIME = ' + time.strftime("%Y-%m-%dT%H:%M:%S") + '\n') labelFile.write('\n') labelFile.write('/* NOTE: */\n') labelFile.write('/* This raster image is composed of a set of pixels that represent finite */\n') labelFile.write('/* areas, and not discrete points. The center of the upper left pixel is */\n') labelFile.write('/* defined as line and sample (1.0,1.0). The */\n') labelFile.write('/* [LINE,SAMPLE]_PROJECTION_OFFSET elements are the pixel offset from line */\n') labelFile.write('/* and sample (1.0,1.0) to the map projection origin (defined by the */\n') labelFile.write('/* CENTER_LATITUDE and CENTER_LONGITUDE elements). These offset values */\n') labelFile.write('/* are positive when the map projection origin is to the right or below */\n') labelFile.write('/* the center of the upper left pixel. */\n') if extraData: # Location for additional notes labelFile.write(extraData) labelFile.write('\n') labelFile.write('OBJECT = IMAGE_MAP_PROJECTION\n') labelFile.write(' MAP_PROJECTION_TYPE = EQUIRECTANGULAR\n') # Specified by +proj=eqc labelFile.write(' PROJECTION_LATITUDE_TYPE = PLANETOCENTRIC\n') #From gdalinfo? labelFile.write(' A_AXIS_RADIUS = 1737.4 <KM>\n') # Fixed lunar radius labelFile.write(' B_AXIS_RADIUS = 1737.4 <KM>\n') labelFile.write(' C_AXIS_RADIUS = 1737.4 <KM>\n') labelFile.write(' COORDINATE_SYSTEM_NAME = PLANETOCENTRIC\n') #From gdalinfo? labelFile.write(' POSITIVE_LONGITUDE_DIRECTION = EAST\n') #From gdalinfo? labelFile.write(' KEYWORD_LATITUDE_TYPE = PLANETOCENTRIC\n') #From gdalinfo? labelFile.write(' /* NOTE: CENTER_LATITUDE and CENTER_LONGITUDE describe the location */\n') labelFile.write(' /* of the center of projection, which is not necessarily equal to the */\n') labelFile.write(' /* location of the center point of the image. */\n') labelFile.write(' CENTER_LATITUDE = ' + str(projCenterLatitude) + ' <DEG>\n') labelFile.write(' CENTER_LONGITUDE = ' + str(projCenterLongitude) + ' <DEG>\n') labelFile.write(' LINE_FIRST_PIXEL = 1\n') labelFile.write(' LINE_LAST_PIXEL = ' + str(imageSize[1] + 1) + '\n') labelFile.write(' SAMPLE_FIRST_PIXEL = 1\n') labelFile.write(' SAMPLE_LAST_PIXEL = ' + str(imageSize[0] + 1) + '\n') labelFile.write(' MAP_PROJECTION_ROTATION = 0.0 <DEG>\n') #From gdalinfo (probably always zero) labelFile.write(' MAP_RESOLUTION = ' + str(round(pixelsPerDegree,2)) +' <PIX/DEG>\n') labelFile.write(' MAP_SCALE = ' + str(round(metersPerPixel,4)) + ' <METERS/PIXEL>\n') labelFile.write(' MAXIMUM_LATITUDE = ' + str(boundingBox[3]) + ' <DEG>\n') labelFile.write(' MINIMUM_LATITUDE = ' + str(boundingBox[2]) + ' <DEG>\n') labelFile.write(' EASTERNMOST_LONGITUDE = ' + str(boundingBox[0]) + ' <DEG>\n') labelFile.write(' WESTERNMOST_LONGITUDE = ' + str(boundingBox[1]) + ' <DEG>\n') labelFile.write(' LINE_PROJECTION_OFFSET = ' + str(round(lineProjOffset,2)) +' <PIXEL>\n') labelFile.write(' SAMPLE_PROJECTION_OFFSET = ' + str(round(sampleProjOffset,2)) +' <PIXEL>\n') labelFile.write('END_OBJECT = IMAGE_MAP_PROJECTION\n') labelFile.write('\n') labelFile.write('END\n') labelFile.close() return True
def convertTransformToGeo(imageToRefImageTransform, newImagePath, refImagePath, refImageGeoTransform=None): '''Converts an image-to-image homography to the ProjectiveTransform class used elsewhere in geocam. Either the reference image must be geo-registered, or the geo transform for it must be provided.''' # Convert the image-to-image transform parameters to a class temp = numpy.array([imageToRefImageTransform[0:3], imageToRefImageTransform[3:6], imageToRefImageTransform[6:9]] ) imageToRefTransform = transform.ProjectiveTransform(temp) newImageSize = IrgGeoFunctions.getImageSize(newImagePath) refImageSize = IrgGeoFunctions.getImageSize(refImagePath) # Get a pixel to GDC transform for the reference image refPixelToGdcTransform = registration_common.getPixelToGdcTransform( refImagePath, refImageGeoTransform) # Generate a list of point pairs imagePoints = [] projPoints = [] gdcPoints = [] print 'transform = \n' + str(imageToRefTransform.matrix) # Loop through an evenly spaced grid of pixels in the new image # - For each pixel, compute the desired output coordinate pointPixelSpacing = (newImageSize[0] + newImageSize[1]) / 20 # Results in about 100 points for r in range(0, newImageSize[0], pointPixelSpacing): for c in range(0, newImageSize[1], pointPixelSpacing): # Get pixel in new image and matching pixel in the reference image thisPixel = numpy.array([float(c), float(r)]) pixelInRefImage = imageToRefTransform.forward(thisPixel) # If any pixel transforms outside the reference image our transform # is probably invalid but continue on skipping this pixel. if ((not registration_common.isPixelValid(thisPixel, newImageSize)) or (not registration_common.isPixelValid(pixelInRefImage, refImageSize))): continue # Compute the location of this pixel in the projected coordinate system # used by the transform.py file. if (not refImageGeoTransform): # Use the geo information of the reference image gdcCoordinate = refPixelToGdcTransform.forward(pixelInRefImage) projectedCoordinate = transform.lonLatToMeters(gdcCoordinate) else: # Use the user-provided transform projectedCoordinate = refImageGeoTransform.forward(pixelInRefImage) gdcCoordinate = transform.metersToLatLon(projectedCoordinate) imagePoints.append(thisPixel) projPoints.append(projectedCoordinate) gdcPoints.append(gdcCoordinate) #print str(thisPixel) + ' --> ' + str(gdcCoordinate) + ' <--> ' + str(projectedCoordinate) # Compute a transform object that converts from the new image to projected coordinates #print 'Converting transform to world coordinates...' #testImageToProjectedTransform = transform.getTransform(numpy.asarray(worldPoints), # numpy.asarray(imagePoints)) testImageToProjectedTransform = transform.ProjectiveTransform.fit(numpy.asarray(projPoints), numpy.asarray(imagePoints)) testImageToGdcTransform = transform.ProjectiveTransform.fit(numpy.asarray(gdcPoints), numpy.asarray(imagePoints)) #print refPixelToGdcTransform #print testImageToProjectedTransform #for i, w in zip(imagePoints, worldPoints): # print str(i) + ' --> ' + str(w) + ' <--> ' + str(testImageToProjectedTransform.forward(i)) return (testImageToProjectedTransform, testImageToGdcTransform, refPixelToGdcTransform)
def qualityGdalwarp(imagePath, outputPath, imagePoints, gdcPoints): '''Use some workarounds to get a higher quality gdalwarp output than is normally possible.''' # Generate a high resolution grid of fake GCPs based on a transform we compute, # then call gdalwarp using a high order polynomial to accurately match our transform. #trans = transform.ProjectiveTransform.fit(numpy.asarray(gdcPoints),numpy.asarray(imagePoints))ls trans = transform.getTransform(numpy.asarray(gdcPoints),numpy.asarray(imagePoints)) transformName = trans.getJsonDict()['type'] tempPath = outputPath + '-temp.tif' # Generate a temporary image containing the grid of fake GCPs cmd = ('gdal_translate -co "COMPRESS=LZW" -co "tiled=yes" -co "predictor=2" -a_srs "' + OUTPUT_PROJECTION +'" '+ imagePath +' '+ tempPath) # Generate the GCPs in a grid, keeping the total under about 500 points so # that GDAL does not complain. (width, height) = IrgGeoFunctions.getImageSize(imagePath) xStep = width /22 yStep = height/22 MAX_DEG_SIZE = 20 minLon = 999 # Keep track of the lonlat size and don't write if it is too big. minLat = 999 # - This would work better if it was in pixels, but how to get that size? maxLon = -999 maxLat = -999 for r in range(0,height,yStep): for c in range(0,width,xStep): pixel = (c,r) lonlat = trans.forward(pixel) cmd += ' -gcp '+ str(c) +' '+str(r) +' '+str(lonlat[0]) +' '+str(lonlat[1]) if lonlat[0] < minLon: minLon = lonlat[0] if lonlat[1] < minLat: minLat = lonlat[1] if lonlat[0] > maxLon: maxLon = lonlat[0] if lonlat[1] > maxLat: maxLat = lonlat[1] #print cmd os.system(cmd) if max((maxLon - minLon), (maxLat - minLat)) > MAX_DEG_SIZE: raise Exception('Warped image is too large to generate!\n' '-> LonLat bounds: ' + str((minLon, minLat, maxLon, maxLat))) # Now generate a warped geotiff. # - "order 2" looks terrible with fewer GCPs, but "order 1" does not accurately # capture the footprint of higher tilt images. # - tps seems to work well with the evenly spaced grid of virtual GCPs. cmd = ('gdalwarp -co "COMPRESS=LZW" -co "tiled=yes" -co "predictor=2"' + ' -dstalpha -overwrite -tps -multi -r cubic -t_srs "' + OUTPUT_PROJECTION +'" ' + tempPath +' '+ outputPath) print cmd os.system(cmd) # Check output and cleanup os.remove(tempPath) if not os.path.exists(outputPath): raise Exception('Failed to create warped geotiff file: ' + outputPath) return transformName
def loadFrame(self, mission, roll, frame): '''Populate from an entry in the database''' self._dbCursor.execute('select * from Frames where trim(MISSION)=? and trim(ROLL)=? and trim(FRAME)=?', (mission, roll, frame)) rows = self._dbCursor.fetchall() if len(rows) != 1: # Make sure we found the next lines raise Exception('Could not find any data for frame: ' + source_image_utils.getFrameString(mission, roll, frame)) output = source_image_utils.FrameInfo() rows = rows[0] #print rows output.mission = mission output.roll = roll output.frame = frame output.exposure = str(rows[0]).strip() output.tilt = str(rows[3]).strip() output.time = str(rows[8]).strip() output.date = str(rows[9]).strip() output.cloudPercentage = float(rows[13]) / 100 output.altitude = float(rows[15]) output.focalLength = float(rows[18]) output.centerLat = float(rows[19]) output.centerLon = float(rows[20]) output.nadirLat = float(rows[21]) output.nadirLon = float(rows[22]) output.camera = str(rows[23]).strip() output.film = str(rows[24]).strip() if (output.centerLat) and (output.centerLon): output.centerPointSource = georefDbWrapper.AUTOWCENTER output.metersPerPixel = None # This information is not stored in the database # Clean up the time format output.time = output.time[0:2] +':'+ output.time[2:4] +':'+ output.time[4:6] # The input tilt can be in letters or degrees so convert # it so that it is always in degrees. if (output.tilt == 'NV') or not output.tilt: output.tilt = '0' if output.tilt == 'LO': # We want to try these output.tilt = '30' if output.tilt == 'HO': # Do not want to try these! output.tilt = '80' output.tilt = float(output.tilt) # Convert the date to 'YYYY.MM.DD' format that the image fetcher wants # - TODO: Use a standardized format! output.date = output.date[0:4] + '.' + output.date[4:6] + '.' + output.date[6:8] # Get the sensor size (output.sensorWidth, output.sensorHeight) = \ source_image_utils.getSensorSize(output.camera) #if not output.isGoodAlignmentCandidate(): # return # In this case don't bother finding the images # Fetch the associated non-raw image files dbCursor.execute('select * from Images where trim(MISSION)=? and trim(ROLL)=? and trim(FRAME)=?', (mission, roll, frame)) rows = dbCursor.fetchall() if len(rows) < 1: # No images provided return # Record the image paths bestNumPixels = 0 for row in rows: # Get the file path and verify it exists folder = str(row[4]).strip() name = str(row[5]).strip() path = os.path.join(folder, name) if not os.path.exists(path): continue output.imageList.append(path) # Record if this is the highest resolution image width = int(row[6]) height = int(row[7]) numPixels = width*height if numPixels > bestNumPixels: output.width = width output.height = height # Try to find an associated RAW file thisRaw = source_image_utils.getRawPath(output.mission, output.roll, output.frame) if os.path.exists(thisRaw): output.rawPath = thisRaw else: print 'Did not find: ' + thisRaw # TODO: Handle images with no RAW data # Get the image size if output.rawPath: (output.width, output.height) = \ source_image_utils.getRawImageSize(output.rawPath) if output.width == 0: [outputPath, exifSourcePath] = source_image_utils.getSourceImage(output) output.width, output.height = IrgGeoFunctions.getImageSize(outputPath) print "width is %d" % output.width print "height is %d" % output.height
def __init__(self, sourceFileInfoDict, outputFolder, basemapInstance, basemapInstance180, force=False, threadPool=None): '''Set up all the low resolution HRSC products.''' setName = sourceFileInfoDict['setName'] self._logger = logging.getLogger('hrscImageManager') # Echo logging to stdout echo = logging.StreamHandler(sys.stdout) echo.setLevel(logging.DEBUG) echo.setFormatter(logging.Formatter(MosaicUtilities.LOG_FORMAT_STR)) self._logger.addHandler(echo) self._logger.info('Initializing hrscImageManager for set ' + setName) # Initialize some values to empty in case they are accessed prematurely self._tileDict = None # # Set up some paths self._setName = setName self._threadPool = threadPool self._outputFolder = outputFolder self._hrscBasePathOut = os.path.join(outputFolder, setName) self._tileFolder = self._hrscBasePathOut + '_tiles' self._lowResMaskPath = self._hrscBasePathOut + '_low_res_mask.tif' self._highResBinaryMaskPath = self._hrscBasePathOut + '_high_res_binary_mask.tif' self._highResMaskPath = self._hrscBasePathOut + '_high_res_mask.tif' self._brightnessGainsPath = self._hrscBasePathOut + '_brightness_gains.csv' self._basemapCropPath = self._hrscBasePathOut + '_local_cropped_basemap.tif' # A crop of the basemap used in several places self._basemapGrayCropPath = self._hrscBasePathOut + '_local_gray_cropped_basemap.tif' #self._colorPairPath = self._hrscBasePathOut + '_low_res_color_pairs.csv' self._basemapSpatialRegistrationPath = self._hrscBasePathOut + '_low_res_spatial_transform_basemap.csv' # Transform to the low res basemap self._croppedRegionSpatialRegistrationPath = self._hrscBasePathOut + '_cropped_region_spatial_transform.csv' # Transform to cropped region of low res basemap self._highResSpatialRegistrationPath = self._hrscBasePathOut + '_high_res_spatial_transform_basemap.csv' self._lowResSpatialCroppedRegistrationPath = self._hrscBasePathOut + '_low_res_cropped_spatial_transform.csv' # Get full list of input paths from the input dictionary # - Sort them into a fixed order defined at the top of the file self._inputHrscPaths = [] rawList = sourceFileInfoDict['allChannelPaths'] self._inputHrscPaths.append( [s for s in rawList if 're3' in s][0] ) self._inputHrscPaths.append( [s for s in rawList if 'gr3' in s][0] ) self._inputHrscPaths.append( [s for s in rawList if 'bl3' in s][0] ) self._inputHrscPaths.append( [s for s in rawList if 'ir3' in s][0] ) self._inputHrscPaths.append( [s for s in rawList if 'nd3' in s][0] ) # TODO: Always store path to regular basemap? # Determine if a 180-centered basemap should be used for image preprocessing. self._isCentered180 = (self.chooseLonCenter() == 180) if self._isCentered180: self._logger.info('HRSC image is centered around 180') self._basemapInstance = basemapInstance180 else: # Normal case, use the 0 centered basemap self._basemapInstance = basemapInstance # Record input parameters self._basemapColorPath = self._basemapInstance.getColorBasemapPath() # Path to the color low res entire base map print 'Generating low res image copies...' # TODO: Warp to the correct basemap! # Generate a copy of each input HRSC channel at the low basemap resolution self._lowResWarpedPaths = [self._warpToProjection(path, outputFolder, '_basemap_res', self._basemapInstance.getLowResMpp(), force) for path in self._inputHrscPaths] # Build up a string containing all the low res paths for convenience self._lowResPathString = '' for path in self._lowResWarpedPaths: self._lowResPathString += path + ' ' print 'Generating low resolution mask...' # Make a mask at the low resolution cmd = './makeSimpleImageMask ' + self._lowResMaskPath +' '+ self._lowResPathString MosaicUtilities.cmdRunner(cmd, self._lowResMaskPath, force) self._lowResPathStringAndMask = self._lowResPathString +' '+ self._lowResMaskPath self._lowResMaskImageSize = IrgGeoFunctions.getImageSize(self._lowResMaskPath) # Compute the HRSC bounding box # - This is a pretty good estimate based on the metadata lowResNadirPath = self._lowResWarpedPaths[HRSC_NADIR] geoInfo = IrgGeoFunctions.getImageGeoInfo(lowResNadirPath) #print geoInfo['projection_bounds'] # print geoInfo['lonlat_bounds'] if 'lonlat_bounds' in geoInfo: (minLon, maxLon, minLat, maxLat) = geoInfo['lonlat_bounds'] else: # This function is not as reliable! (minLon, maxLon, minLat, maxLat) = IrgGeoFunctions.getImageBoundingBox(lowResNadirPath) hrscBoundingBoxDegrees = MosaicUtilities.Rectangle(minLon, maxLon, minLat, maxLat) if hrscBoundingBoxDegrees.maxX < hrscBoundingBoxDegrees.minX: hrscBoundingBoxDegrees.maxX += 360 # If needed, get both lon values into 0-360 degree range if (hrscBoundingBoxDegrees.minX < 0) and self._isCentered180: # If working in the 0-360 degree space, make sure the longitude values are positive hrscBoundingBoxDegrees.minX += 360 hrscBoundingBoxDegrees.maxX += 360 print 'Estimated HRSC bounds: ' + str(hrscBoundingBoxDegrees) # Cut out a region from the basemap around the location of the HRSC image # - We record the ROI in degrees and low res pixels print 'Generating low res base basemap region around HRSC data' CROP_BUFFER_LAT = 1.0 CROP_BUFFER_LON = 1.0 self._croppedRegionBoundingBoxDegrees = copy.copy(hrscBoundingBoxDegrees) self._croppedRegionBoundingBoxDegrees.expand(CROP_BUFFER_LON, CROP_BUFFER_LAT) self._croppedRegionBoundingBoxPixels = self._basemapInstance.degreeRoiToPixelRoi( self._croppedRegionBoundingBoxDegrees, False) self._basemapInstance.makeCroppedRegionDegrees(self._croppedRegionBoundingBoxDegrees, self._basemapCropPath, force) self._makeGrayscaleImage(self._basemapCropPath, self._basemapGrayCropPath) # Compute the spatial registration from the HRSC image to the base map self._computeBaseSpatialRegistration(self._basemapInstance, lowResNadirPath, force) # Compute the brightness scaling gains relative to the cropped base map # - This is done at low resolution # - The low resolution output is smoothed out later to avoid jagged edges. cmd = ('./computeBrightnessCorrection ' + self._basemapCropPath +' '+ self._lowResPathStringAndMask +' ' + self._lowResSpatialCroppedRegistrationPath +' '+ self._brightnessGainsPath) MosaicUtilities.cmdRunner(cmd, self._brightnessGainsPath, force) print 'Finished with low resolution processing for HRSC set ' + setName
def matchLocally(mission, roll, frame, cursor, georefDb, sourceImagePath): '''Performs image alignment to an already aligned ISS image''' # Load new frame info targetFrameData = source_database.FrameInfo() targetFrameData.loadFromDb(cursor, mission, roll, frame) targetFrameData = computeFrameInfoMetersPerPixel(targetFrameData) # Find candidate names to match to possibleNearbyMatches = findNearbyResults(targetFrameData, cursor, georefDb) if not possibleNearbyMatches: print 'Did not find any potential local matches!' for (otherFrame, ourResult) in possibleNearbyMatches: print 'Trying local match with frame: ' + str(otherFrame.frame) # Get path to other frame image otherImagePath, exifSourcePath = source_database.getSourceImage(otherFrame) source_database.clearExif(exifSourcePath) otherTransform = ourResult[0] # This is still in the google projected format #print 'otherTransform = ' + str(otherTransform.matrix) print 'New image mpp = ' + str(targetFrameData.metersPerPixel) print 'Local match image mpp = ' + str(otherFrame.metersPerPixel) # If we could not estimate the MPP value of the new image, guess that it is the same as # the local reference image we are about to try. thisMpp = targetFrameData.metersPerPixel if not thisMpp: thisMpp = otherFrame.metersPerPixel print 'Attempting to register image...' (imageToProjectedTransform, imageToGdcTransform, confidence, imageInliers, gdcInliers, refMetersPerPixel) = \ register_image.register_image(sourceImagePath, otherFrame.centerLon, otherFrame.centerLat, thisMpp, targetFrameData.date, refImagePath =otherImagePath, referenceGeoTransform=otherTransform, refMetersPerPixelIn =otherFrame.metersPerPixel, debug=options.debug, force=True, slowMethod=False) if not options.debug: os.remove(otherImagePath) # Clean up the image we matched against # Quit once we get a good match if confidence == registration_common.CONFIDENCE_HIGH: print 'High confidence match!' # Convert from the image-to-image GCPs to the reference image GCPs # located in the new image. refFrameGdcInliers = ourResult[3] # TODO: Clean this up! (width, height) = IrgGeoFunctions.getImageSize(sourceImagePath) print '\n\n' print refFrameGdcInliers print '\n\n' (imageInliers, gdcInliers) = registration_common.convertGcps(refFrameGdcInliers, imageToProjectedTransform, width, height) print imageInliers print '\n\n' # If none of the original GCPs fall in the new image, don't use this alignment result. # - We could use this result, but we don't in order to maintain accuracy standards. if imageInliers: print 'Have inliers' print otherFrame return (imageToProjectedTransform, imageToGdcTransform, confidence, imageInliers, gdcInliers, refMetersPerPixel, otherFrame) else: print 'Inliers out of bounds!' # Match failure, return junk values return (registration_common.getIdentityTransform(), registration_common.getIdentityTransform(), registration_common.CONFIDENCE_NONE, [], [], 9999, None)
def splitImageGdal(imagePath, outputPrefix, tileSize, force=False, pool=None, maskList=[]): '''gdal_translate based replacement for the ImageMagick convert based image split. This function assumes that all relevant folders have been created.''' # Compute the bounding box for each tile inputImageSize = IrgGeoFunctions.getImageSize(imagePath) #print imagePath + ' is size ' + str(inputImageSize) numTilesX = int(math.ceil(float(inputImageSize[0]) / float(tileSize))) numTilesY = int(math.ceil(float(inputImageSize[1]) / float(tileSize))) print 'Using gdal_translate to generate ' + str(int( numTilesX * numTilesY)) + ' tiles!' # Generate each of the tiles using GDAL cmdList = [] for r in range(0, numTilesY): for c in range(0, numTilesX): if maskList: # Make sure this tile is not completely masked out # Find the info for the corresponding mask tile # If the image is larger than the mask, there is a chance there will be no # mask tile for this image tile. If so we can still skip the image tile,, tilePrefix = getTilePrefix(r, c) maskTileInfo = [ x for x in maskList if x['prefix'] == tilePrefix ] if not maskTileInfo or (maskTileInfo[0]['percentValid'] < MIN_TILE_PERCENT_PIXELS_VALID): continue # Get the pixel ROI for this tile # - TODO: Use the Tiling class! minCol = c * tileSize minRow = r * tileSize width = tileSize height = tileSize if (minCol + width) > inputImageSize[0]: width = inputImageSize[0] - minCol if (minRow + height) > inputImageSize[1]: height = inputImageSize[1] - minRow totalNumPixels = height * width # Generate the tile (console output suppressed) thisPixelRoi = ('%d %d %d %d' % (minCol, minRow, width, height)) thisTilePath = outputPrefix + str(r) + '_' + str(c) + '.tif' cmd = MosaicUtilities.GDAL_TRANSLATE_PATH + ' -q -srcwin ' + thisPixelRoi + ' ' + imagePath + ' ' + thisTilePath if pool: #print cmd cmdList.append((cmd, thisTilePath, force)) else: MosaicUtilities.cmdRunner(cmd, thisTilePath, force) if pool: # Pass all of these commands to a multiprocessing worker pool print 'splitImageGdal is launching ' + str( len(cmdList)) + ' gdalwarp threads...' pool.map(MosaicUtilities.cmdRunnerWrapper, cmdList)
def __init__(self, sourceFileInfoDict, outputFolder, basemapInstance, basemapInstance180, force=False, threadPool=None): '''Set up all the low resolution HRSC products.''' setName = sourceFileInfoDict['setName'] self._logger = logging.getLogger('hrscImageManager') # Echo logging to stdout echo = logging.StreamHandler(sys.stdout) echo.setLevel(logging.DEBUG) echo.setFormatter(logging.Formatter(MosaicUtilities.LOG_FORMAT_STR)) self._logger.addHandler(echo) self._logger.info('Initializing hrscImageManager for set ' + setName) # Initialize some values to empty in case they are accessed prematurely self._tileDict = None # # Set up some paths self._setName = setName self._threadPool = threadPool self._outputFolder = outputFolder self._hrscBasePathOut = os.path.join(outputFolder, setName) self._tileFolder = self._hrscBasePathOut + '_tiles' self._lowResMaskPath = self._hrscBasePathOut + '_low_res_mask.tif' self._highResBinaryMaskPath = self._hrscBasePathOut + '_high_res_binary_mask.tif' self._highResMaskPath = self._hrscBasePathOut + '_high_res_mask.tif' self._brightnessGainsPath = self._hrscBasePathOut + '_brightness_gains.csv' self._basemapCropPath = self._hrscBasePathOut + '_local_cropped_basemap.tif' # A crop of the basemap used in several places self._basemapGrayCropPath = self._hrscBasePathOut + '_local_gray_cropped_basemap.tif' #self._colorPairPath = self._hrscBasePathOut + '_low_res_color_pairs.csv' self._basemapSpatialRegistrationPath = self._hrscBasePathOut + '_low_res_spatial_transform_basemap.csv' # Transform to the low res basemap self._croppedRegionSpatialRegistrationPath = self._hrscBasePathOut + '_cropped_region_spatial_transform.csv' # Transform to cropped region of low res basemap self._highResSpatialRegistrationPath = self._hrscBasePathOut + '_high_res_spatial_transform_basemap.csv' self._lowResSpatialCroppedRegistrationPath = self._hrscBasePathOut + '_low_res_cropped_spatial_transform.csv' # Get full list of input paths from the input dictionary # - Sort them into a fixed order defined at the top of the file self._inputHrscPaths = [] rawList = sourceFileInfoDict['allChannelPaths'] self._inputHrscPaths.append([s for s in rawList if 're3' in s][0]) self._inputHrscPaths.append([s for s in rawList if 'gr3' in s][0]) self._inputHrscPaths.append([s for s in rawList if 'bl3' in s][0]) self._inputHrscPaths.append([s for s in rawList if 'ir3' in s][0]) self._inputHrscPaths.append([s for s in rawList if 'nd3' in s][0]) # TODO: Always store path to regular basemap? # Determine if a 180-centered basemap should be used for image preprocessing. self._isCentered180 = (self.chooseLonCenter() == 180) if self._isCentered180: self._logger.info('HRSC image is centered around 180') self._basemapInstance = basemapInstance180 else: # Normal case, use the 0 centered basemap self._basemapInstance = basemapInstance # Record input parameters self._basemapColorPath = self._basemapInstance.getColorBasemapPath( ) # Path to the color low res entire base map print 'Generating low res image copies...' # TODO: Warp to the correct basemap! # Generate a copy of each input HRSC channel at the low basemap resolution self._lowResWarpedPaths = [ self._warpToProjection(path, outputFolder, '_basemap_res', self._basemapInstance.getLowResMpp(), force) for path in self._inputHrscPaths ] # Build up a string containing all the low res paths for convenience self._lowResPathString = '' for path in self._lowResWarpedPaths: self._lowResPathString += path + ' ' print 'Generating low resolution mask...' # Make a mask at the low resolution cmd = './makeSimpleImageMask ' + self._lowResMaskPath + ' ' + self._lowResPathString MosaicUtilities.cmdRunner(cmd, self._lowResMaskPath, force) self._lowResPathStringAndMask = self._lowResPathString + ' ' + self._lowResMaskPath self._lowResMaskImageSize = IrgGeoFunctions.getImageSize( self._lowResMaskPath) # Compute the HRSC bounding box # - This is a pretty good estimate based on the metadata lowResNadirPath = self._lowResWarpedPaths[HRSC_NADIR] geoInfo = IrgGeoFunctions.getImageGeoInfo(lowResNadirPath) #print geoInfo['projection_bounds'] # print geoInfo['lonlat_bounds'] if 'lonlat_bounds' in geoInfo: (minLon, maxLon, minLat, maxLat) = geoInfo['lonlat_bounds'] else: # This function is not as reliable! (minLon, maxLon, minLat, maxLat) = IrgGeoFunctions.getImageBoundingBox(lowResNadirPath) hrscBoundingBoxDegrees = MosaicUtilities.Rectangle( minLon, maxLon, minLat, maxLat) if hrscBoundingBoxDegrees.maxX < hrscBoundingBoxDegrees.minX: hrscBoundingBoxDegrees.maxX += 360 # If needed, get both lon values into 0-360 degree range if (hrscBoundingBoxDegrees.minX < 0) and self._isCentered180: # If working in the 0-360 degree space, make sure the longitude values are positive hrscBoundingBoxDegrees.minX += 360 hrscBoundingBoxDegrees.maxX += 360 print 'Estimated HRSC bounds: ' + str(hrscBoundingBoxDegrees) # Cut out a region from the basemap around the location of the HRSC image # - We record the ROI in degrees and low res pixels print 'Generating low res base basemap region around HRSC data' CROP_BUFFER_LAT = 1.0 CROP_BUFFER_LON = 1.0 self._croppedRegionBoundingBoxDegrees = copy.copy( hrscBoundingBoxDegrees) self._croppedRegionBoundingBoxDegrees.expand(CROP_BUFFER_LON, CROP_BUFFER_LAT) self._croppedRegionBoundingBoxPixels = self._basemapInstance.degreeRoiToPixelRoi( self._croppedRegionBoundingBoxDegrees, False) self._basemapInstance.makeCroppedRegionDegrees( self._croppedRegionBoundingBoxDegrees, self._basemapCropPath, force) self._makeGrayscaleImage(self._basemapCropPath, self._basemapGrayCropPath) # Compute the spatial registration from the HRSC image to the base map self._computeBaseSpatialRegistration(self._basemapInstance, lowResNadirPath, force) # Compute the brightness scaling gains relative to the cropped base map # - This is done at low resolution # - The low resolution output is smoothed out later to avoid jagged edges. cmd = ('./computeBrightnessCorrection ' + self._basemapCropPath + ' ' + self._lowResPathStringAndMask + ' ' + self._lowResSpatialCroppedRegistrationPath + ' ' + self._brightnessGainsPath) MosaicUtilities.cmdRunner(cmd, self._brightnessGainsPath, force) print 'Finished with low resolution processing for HRSC set ' + setName