def getSpectralAngleByBand(self, nbins=500, updater=None): """Calculate the spectral angle between every pixel in two cubes using bands Fast for BSQ cubes, slow for BIL, and extremely slow for BIP. """ sam = HSI.createCube('bsq', self.lines, self.samples, 1, numpy.float32) data = sam.getBandRaw(0) top = numpy.zeros((self.lines, self.samples), dtype=numpy.float32) bot1 = numpy.zeros((self.lines, self.samples), dtype=numpy.float32) bot2 = numpy.zeros((self.lines, self.samples), dtype=numpy.float32) for i in range(self.bands): if updater: updater.updateStatus(i, self.bands, "Calculating Spectral Angle") if self.bbl[i]: band1 = self.cube1.getBand(i) band2 = self.cube2.getBand(i) top += band1 * band2 bot1 += numpy.square(band1) bot2 += numpy.square(band2) bot = numpy.sqrt(bot1 + bot2) tot = top/bot data[:,:] = numpy.nan_to_num(numpy.arccos(tot) * (180.0 / math.pi)) self.dprint(data) return sam
def getSpectralAngleByFocalPlane(self, iter, updater=None): """Calculate the spectral angle between every pixel in two cubes using focal planes Fast for BIP and BIL, slow for BSQ. """ sam = HSI.createCube('bsq', self.lines, self.samples, 1, numpy.float32) data = sam.getBandRaw(0) bblmask = self.getFocalPlaneBadBandMask() for i, plane1, plane2 in iter: if updater: updater.updateStatus(i, self.lines, "Calculating Spectral Angle") p1 = numpy.cast[numpy.float32](plane1 * bblmask) p2 = numpy.cast[numpy.float32](plane2 * bblmask) zerotest = numpy.add.reduce(plane1 - plane2) top = numpy.add.reduce(p1 * p2) bot = numpy.sqrt(numpy.add.reduce(p1 * p1)) * numpy.sqrt( numpy.add.reduce(p2 * p2)) # the arccos may not be zero if the spectra are exactly the same due # to round-off error in the squaring/sqrt. So, we add this check # here to force the total to 1.0 if any pixel in plane1 is exactly # equal to the pixel in plane 2 tot = numpy.where(zerotest == 0.0, 1.0, top / bot) line = numpy.nan_to_num(numpy.arccos(tot) * (180.0 / math.pi)) self.dprint("%s %s" % (line.shape, line)) data[i, :] = line self.dprint(data) return sam
def getSpectralAngleByFocalPlane(self, iter, updater=None): """Calculate the spectral angle between every pixel in two cubes using focal planes Fast for BIP and BIL, slow for BSQ. """ sam = HSI.createCube('bsq', self.lines, self.samples, 1, numpy.float32) data = sam.getBandRaw(0) bblmask = self.getFocalPlaneBadBandMask() for i, plane1, plane2 in iter: if updater: updater.updateStatus(i, self.lines, "Calculating Spectral Angle") p1 = numpy.cast[numpy.float32](plane1 * bblmask) p2 = numpy.cast[numpy.float32](plane2 * bblmask) zerotest = numpy.add.reduce(plane1 - plane2) top = numpy.add.reduce(p1 * p2) bot = numpy.sqrt(numpy.add.reduce(p1 * p1)) * numpy.sqrt(numpy.add.reduce(p2 * p2)) # the arccos may not be zero if the spectra are exactly the same due # to round-off error in the squaring/sqrt. So, we add this check # here to force the total to 1.0 if any pixel in plane1 is exactly # equal to the pixel in plane 2 tot = numpy.where(zerotest == 0.0, 1.0, top/bot) line = numpy.nan_to_num(numpy.arccos(tot) * (180.0 / math.pi)) self.dprint("%s %s" % (line.shape, line)) data[i,:] = line self.dprint(data) return sam
def getSpectralAngleByBand(self, nbins=500, updater=None): """Calculate the spectral angle between every pixel in two cubes using bands Fast for BSQ cubes, slow for BIL, and extremely slow for BIP. """ sam = HSI.createCube('bsq', self.lines, self.samples, 1, numpy.float32) data = sam.getBandRaw(0) top = numpy.zeros((self.lines, self.samples), dtype=numpy.float32) bot1 = numpy.zeros((self.lines, self.samples), dtype=numpy.float32) bot2 = numpy.zeros((self.lines, self.samples), dtype=numpy.float32) for i in range(self.bands): if updater: updater.updateStatus(i, self.bands, "Calculating Spectral Angle") if self.bbl[i]: band1 = self.cube1.getBand(i) band2 = self.cube2.getBand(i) top += band1 * band2 bot1 += numpy.square(band1) bot2 += numpy.square(band2) bot = numpy.sqrt(bot1 + bot2) tot = top / bot data[:, :] = numpy.nan_to_num(numpy.arccos(tot) * (180.0 / math.pi)) self.dprint(data) return sam
def getHeatMapByFocalPlane(self, iter): """Generate a heat map using focal planes Fast for BIP and BIL, slow for BSQ. This is a slightly more complicated algorithm that uses focal planes to create the histogram. Because there's an extra python loop inside this method, the theoretical speed of this method is slower than L{getHistogramByBand}. However, because BIL and BIP cubes are structured to read focal plane images very quickly, this method is many times faster than L{getHistogramByBand} when both cubes are BIL or BIP. If one cube is BSQ, it's probably faster to use L{getHistogramByBand} because more work is done by numpy. """ self.heatmap = HSI.createCube('bsq', self.lines, self.samples, 1, self.dtype) data = self.heatmap.getBandRaw(0) bblmask = self.getFocalPlaneBadBandMask() for i, plane1, plane2 in iter: p1 = plane1 * bblmask p2 = plane2 * bblmask line = numpy.add.reduce(abs(p1 - p2), axis=0) self.dprint("%s %s" % (line.shape, line)) data[i,:] = line self.dprint(data) return self.heatmap
def getHeatMapByFocalPlane(self, iter): """Generate a heat map using focal planes Fast for BIP and BIL, slow for BSQ. This is a slightly more complicated algorithm that uses focal planes to create the histogram. Because there's an extra python loop inside this method, the theoretical speed of this method is slower than L{getHistogramByBand}. However, because BIL and BIP cubes are structured to read focal plane images very quickly, this method is many times faster than L{getHistogramByBand} when both cubes are BIL or BIP. If one cube is BSQ, it's probably faster to use L{getHistogramByBand} because more work is done by numpy. """ self.heatmap = HSI.createCube('bsq', self.lines, self.samples, 1, self.dtype) data = self.heatmap.getBandRaw(0) bblmask = self.getFocalPlaneBadBandMask() for i, plane1, plane2 in iter: p1 = plane1 * bblmask p2 = plane2 * bblmask line = numpy.add.reduce(abs(p1 - p2), axis=0) self.dprint("%s %s" % (line.shape, line)) data[i, :] = line self.dprint(data) return self.heatmap
def getDifferenceByFocalPlane(self, iter): """Difference the cubes using focal planes Fast for BIP and BIL, slow for BSQ. """ self.difference = HSI.createCube('bil', self.lines, self.samples, self.bands, self.dtype) bblmask = self.getFocalPlaneBadBandMask() for i, plane1, plane2 in iter: p1 = plane1 * bblmask p2 = plane2 * bblmask diff = p1 - p2 plane = self.difference.getFocalPlaneRaw(i) plane[:,:] = diff self.dprint("%s %s" % (plane.shape, plane)) return self.difference
def getDifferenceByFocalPlane(self, iter): """Difference the cubes using focal planes Fast for BIP and BIL, slow for BSQ. """ self.difference = HSI.createCube('bil', self.lines, self.samples, self.bands, self.dtype) bblmask = self.getFocalPlaneBadBandMask() for i, plane1, plane2 in iter: p1 = plane1 * bblmask p2 = plane2 * bblmask diff = p1 - p2 plane = self.difference.getFocalPlaneRaw(i) plane[:, :] = diff self.dprint("%s %s" % (plane.shape, plane)) return self.difference
def getDifferenceByBand(self,nbins=500): """Difference two cubes using bands Fast for BSQ cubes, slow for BIL, and extremely slow for BIP. The most straight-forward algorithm, but is slow unless the cubes are in BSQ format. Differences two cubes on a band-by-band basis and puts the results in a new cube. """ self.difference = HSI.createCube('bsq', self.lines, self.samples, self.bands, self.dtype) for i in range(self.cube1.bands): if self.bbl[i]: band = self.difference.getBandRaw(i) band1 = self.cube1.getBand(i) band2 = self.cube2.getBand(i) band[:,:] = band1 - band2 self.dprint(band) return self.difference
def getHeatMapByBand(self,nbins=500): """Generate a heat map using bands Fast for BSQ cubes, slow for BIL, and extremely slow for BIP. The most straight-forward algorithm, but is slow unless the cubes are in BSQ format. Differences the corresponding bands, runs a histogram on them, and puts the results into the instance histogram. """ self.heatmap = HSI.createCube('bsq', self.lines, self.samples, 1, self.dtype) data = self.heatmap.getBandRaw(0) for i in range(self.bands): if self.bbl[i]: band1 = self.cube1.getBand(i) band2 = self.cube2.getBand(i) band = abs(band1-band2) data += band self.dprint(data) return self.heatmap
def getDifferenceByBand(self, nbins=500): """Difference two cubes using bands Fast for BSQ cubes, slow for BIL, and extremely slow for BIP. The most straight-forward algorithm, but is slow unless the cubes are in BSQ format. Differences two cubes on a band-by-band basis and puts the results in a new cube. """ self.difference = HSI.createCube('bsq', self.lines, self.samples, self.bands, self.dtype) for i in range(self.cube1.bands): if self.bbl[i]: band = self.difference.getBandRaw(i) band1 = self.cube1.getBand(i) band2 = self.cube2.getBand(i) band[:, :] = band1 - band2 self.dprint(band) return self.difference
def getHeatMapByBand(self, nbins=500): """Generate a heat map using bands Fast for BSQ cubes, slow for BIL, and extremely slow for BIP. The most straight-forward algorithm, but is slow unless the cubes are in BSQ format. Differences the corresponding bands, runs a histogram on them, and puts the results into the instance histogram. """ self.heatmap = HSI.createCube('bsq', self.lines, self.samples, 1, self.dtype) data = self.heatmap.getBandRaw(0) for i in range(self.bands): if self.bbl[i]: band1 = self.cube1.getBand(i) band2 = self.cube2.getBand(i) band = abs(band1 - band2) data += band self.dprint(data) return self.heatmap
def getEuclideanDistanceByFocalPlane(self, iter, updater=None): """Calculate the euclidean distance for every pixel in two cubes using focal planes Fast for BIP and BIL, slow for BSQ. """ euclidean = HSI.createCube('bsq', self.lines, self.samples, 1, numpy.float32) data = euclidean.getBandRaw(0) bblmask = self.getFocalPlaneBadBandMask() for i, plane1, plane2 in iter: if updater: updater.updateStatus(i, self.lines, "Calculating Euclidean Distance") p1 = plane1 * bblmask p2 = plane2 * bblmask plane = p1 - p2 line = numpy.sqrt(numpy.add.reduce(plane * plane, axis=0)) self.dprint("%s %s" % (line.shape, line)) data[i,:] = line self.dprint(data) return euclidean
def getEuclideanDistanceByBand(self, nbins=500, updater=None): """Calculate the euclidean distance for every pixel in two cubes using bands Fast for BSQ cubes, slow for BIL, and extremely slow for BIP. """ euclidean = HSI.createCube('bsq', self.lines, self.samples, 1, numpy.float32) data = euclidean.getBandRaw(0) working = numpy.zeros((self.lines, self.samples), dtype=numpy.float32) for i in range(self.bands): if updater: updater.updateStatus(i, self.bands, "Calculating Euclidean Distance") if self.bbl[i]: band1 = self.cube1.getBand(i) band2 = self.cube2.getBand(i) band = band1 - band2 working += numpy.square(band) data = numpy.sqrt(working) self.dprint(data) return euclidean
def getEuclideanDistanceByFocalPlane(self, iter, updater=None): """Calculate the euclidean distance for every pixel in two cubes using focal planes Fast for BIP and BIL, slow for BSQ. """ euclidean = HSI.createCube('bsq', self.lines, self.samples, 1, numpy.float32) data = euclidean.getBandRaw(0) bblmask = self.getFocalPlaneBadBandMask() for i, plane1, plane2 in iter: if updater: updater.updateStatus(i, self.lines, "Calculating Euclidean Distance") p1 = plane1 * bblmask p2 = plane2 * bblmask plane = p1 - p2 line = numpy.sqrt(numpy.add.reduce(plane * plane, axis=0)) self.dprint("%s %s" % (line.shape, line)) data[i, :] = line self.dprint(data) return euclidean
self.fovy = 30 self.n = 1 self.f = 10000 def onResize(self, w=None, h=None): super(PerspectiveView, self).onResize(w, h) self.aspect = float(self.w) / float(self.h) def onMotion(self, x, y): self.head += (x - self.x) self.pitch += (y - self.y) self.x = x self.y = y return True def updateProjection(self): gluPerspective(self.fovy, self.aspect, self.n, self.f) def updateView(self): glTranslate(0, 0, -self.distance) glRotate(self.head, 0, 1, 0) glRotate(self.pitch, 1, 0, 0) if __name__ == '__main__': import cube glut_ui.run( glbase.BaseController( PerspectiveView(80), cube.createCube(10)))
def onMotion(self, x, y): self.head += (x - self.x) self.pitch += (y - self.y) self.x = x self.y = y # return True for redrawing return True def updateProjection(self): l = -self.w / 2 r = -l b = -self.h / 2 t = -b n = 0 f = 1000 glOrtho(l, r, b, t, n, f) def updateView(self): glTranslate(0, 0, -self.distance) glRotate(self.head, 0, 1, 0) glRotate(self.pitch, 1, 0, 0) if __name__ == '__main__': import cube glut_ui.run( glbase.BaseController( OrthogonalView(200), cube.createCube(100)))